Move more symbols to the vm isolate.

vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 19 matching lines @@
 
 static void CheckedModeHandler(bool value) {
   FLAG_enable_asserts = value;
   FLAG_enable_type_checks = value;
 }
 
 DEFINE_FLAG_HANDLER(CheckedModeHandler,
                     enable_checked_mode,
                     "Enabled checked mode.");
 
-// All references to Dart names are listed here.
-static const char* kAssertionErrorName = "AssertionError";
-static const char* kTypeErrorName = "TypeError";
-static const char* kFallThroughErrorName = "FallThroughError";
-static const char* kStaticResolutionExceptionName = "StaticResolutionException";
-static const char* kThrowNewName = "_throwNew";
-static const char* kListLiteralFactoryClassName = "_ListLiteralFactory";
-static const char* kListLiteralFactoryName = "List.fromLiteral";
-static const char* kMapLiteralFactoryClassName = "_MapLiteralFactory";
-static const char* kMapLiteralFactoryName = "Map.fromLiteral";
-static const char* kImmutableMapName = "ImmutableMap";
-static const char* kImmutableMapConstructorName = "ImmutableMap._create";
-static const char* kStringClassName = "StringBase";
-static const char* kInterpolateName = "_interpolate";
-static const char* kThisName = "this";
-static const char* kPhaseParameterName = ":phase";
-static const char* kGetIteratorName = "iterator";
-static const char* kNoSuchMethodName = "noSuchMethod";
-
 #if defined(DEBUG)
 
 class TraceParser : public ValueObject {
  public:
   TraceParser(intptr_t token_pos, const Script& script, const char* msg) {
     if (FLAG_trace_parser) {
       // Skips tracing of bootstrap libraries.
       if (script.HasSource()) {
         intptr_t line, column;
         script.GetTokenLocation(token_pos, &line, &column);
@@ skipping 47 matching lines @@
     stack_trace ^= Object::Clone(stack_trace, Heap::kOld);
   }
   return new ThrowNode(token_pos,
                        new LiteralNode(token_pos, exception),
                        new LiteralNode(token_pos, stack_trace));
 }
 
 
 LocalVariable* ParsedFunction::CreateExpressionTempVar(intptr_t token_pos) {
   return new LocalVariable(token_pos,
-                           String::ZoneHandle(Symbols::New(":expr_temp")),
+                           String::ZoneHandle(Symbols::ExprTemp()),
                            Type::ZoneHandle(Type::DynamicType()));
 }
 
 
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
   const int num_fixed_params = function().num_fixed_parameters();
   const int num_opt_params = function().num_optional_parameters();
@@ skipping 289 matching lines @@
   void Clear() {
     num_fixed_parameters = 0;
     num_optional_parameters = 0;
     has_named_optional_parameters = false;
     has_field_initializer = false;
     implicitly_final = false;
     this->parameters = new ZoneGrowableArray<ParamDesc>();
   }
 
   void AddFinalParameter(intptr_t name_pos,
-                         const char* name,
+                         String* name,
                          const AbstractType* type) {
     this->num_fixed_parameters++;
     ParamDesc param;
     param.name_pos = name_pos;
-    param.name = &String::ZoneHandle(Symbols::New(name));
+    param.name = name;
     param.is_final = true;
     param.type = type;
     this->parameters->Add(param);
   }
 
   void AddReceiver(intptr_t name_pos) {
     ASSERT(this->parameters->is_empty());
     // The receiver does not need to be type checked.
     AddFinalParameter(name_pos,
-                      kThisName,
+                      &String::ZoneHandle(Symbols::This()),
                       &Type::ZoneHandle(Type::DynamicType()));
   }
 
   void SetImplicitlyFinal() {
     implicitly_final = true;
   }
 
   int num_fixed_parameters;
   int num_optional_parameters;
   bool has_named_optional_parameters;  // Indicates use of the new syntax.
@@ skipping 442 matching lines @@
   // TokenPos() returns the function's token position which points to
   // the name of the field; we can use it to form the field_name.
   const String& field_name = *CurrentLiteral();
   const Class& field_class = Class::ZoneHandle(func.owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
   const AbstractType& field_type = AbstractType::ZoneHandle(field.type());
 
   ParamList params;
   params.AddReceiver(TokenPos());
-  params.AddFinalParameter(TokenPos(), "value", &field_type);
+  params.AddFinalParameter(TokenPos(),
+                           &String::ZoneHandle(Symbols::Value()),
+                           &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(func.num_optional_parameters() == 0);
   ASSERT(AbstractType::Handle(func.result_type()).IsVoidType());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   LoadLocalNode* receiver =
       new LoadLocalNode(TokenPos(), *current_block_->scope->VariableAt(0));
@@ skipping 310 matching lines @@
                                       bool* is_no_such_method) {
   const Class& super_class = Class::Handle(current_class().SuperClass());
   if (super_class.IsNull()) {
     ErrorMsg(token_pos, "class '%s' does not have a superclass",
              String::Handle(current_class().Name()).ToCString());
   }
 
   Function& super_func =
       Function::Handle(ResolveDynamicFunction(super_class, name));
   if (super_func.IsNull()) {
-    const String& no_such_method_name =
-        String::ZoneHandle(Symbols::New(kNoSuchMethodName));
+    const String& no_such_method_name = String::Handle(Symbols::NoSuchMethod());
     super_func = ResolveDynamicFunction(super_class, no_such_method_name);
     ASSERT(!super_func.IsNull());
     *is_no_such_method = true;
   } else {
     *is_no_such_method = false;
   }
   CheckFunctionIsCallable(token_pos, super_func);
   return super_func.raw();
 }
 
@@ skipping 92 matching lines @@
             CreateTempConstVariable(operator_pos, index_expr->id(), "lix");
         AstNode* save =
             new StoreLocalNode(operator_pos, *temp, index_expr);
         current_block_->statements->Add(save);
         index_expr = new LoadLocalNode(operator_pos, *temp);
       }
     }
 
     // Resolve the [] operator function in the superclass.
     const String& index_operator_name =
-        String::ZoneHandle(Symbols::New(Token::Str(Token::kINDEX)));
+        String::ZoneHandle(Symbols::IndexToken());
     bool is_no_such_method = false;
     const Function& index_operator = Function::ZoneHandle(
         GetSuperFunction(operator_pos,
                          index_operator_name,
                          &is_no_such_method));
 
     ArgumentListNode* index_op_arguments = new ArgumentListNode(operator_pos);
     AstNode* receiver = LoadReceiver(operator_pos);
     index_op_arguments->Add(receiver);
     index_op_arguments->Add(index_expr);
 
     if (is_no_such_method) {
       index_op_arguments = BuildNoSuchMethodArguments(index_operator_name,
                                                       *index_op_arguments);
     }
     super_op = new StaticCallNode(
         operator_pos, index_operator, index_op_arguments);
 
     if (Token::IsAssignmentOperator(CurrentToken())) {
       Token::Kind assignment_op = CurrentToken();
       ConsumeToken();
       AstNode* value = ParseExpr(kAllowConst, kConsumeCascades);
 
       value = ExpandAssignableOp(operator_pos, assignment_op, super_op, value);
 
       // Resolve the []= operator function in the superclass.
-      const String& assign_index_operator_name = String::ZoneHandle(
-          Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
+      const String& assign_index_operator_name =
+          String::ZoneHandle(Symbols::AssignIndexToken());
       bool is_no_such_method = false;
       const Function& assign_index_operator = Function::ZoneHandle(
           GetSuperFunction(operator_pos,
                            assign_index_operator_name,
                            &is_no_such_method));
 
       ArgumentListNode* operator_args = new ArgumentListNode(operator_pos);
       operator_args->Add(LoadReceiver(operator_pos));
       operator_args->Add(index_expr);
       operator_args->Add(value);
@@ skipping 411 matching lines @@
   OpenFunctionBlock(func);
 
   // Parse expressions of instance fields that have an explicit
   // initializers.
   GrowableArray<FieldInitExpression> initializers;
   Class& cls = Class::Handle(func.owner());
   ParseInitializedInstanceFields(cls, &initializers);
 
   LocalVariable* receiver = new LocalVariable(
       ctor_pos,
-      String::ZoneHandle(Symbols::New(kThisName)),
+      String::ZoneHandle(Symbols::This()),
       Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(receiver);
 
   LocalVariable* phase_parameter = new LocalVariable(
        ctor_pos,
-       String::ZoneHandle(Symbols::New(kPhaseParameterName)),
+       String::ZoneHandle(Symbols::PhaseParameter()),
        Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(phase_parameter);
 
   // Now that the "this" parameter is in scope, we can generate the code
   // to strore the initializer expressions in the respective instance fields.
   for (int i = 0; i < initializers.length(); i++) {
     const Field* field = initializers[i].inst_field;
     AstNode* instance = new LoadLocalNode(field->token_pos(), *receiver);
     AstNode* field_init =
         new StoreInstanceFieldNode(field->token_pos(),
@@ skipping 41 matching lines @@
   const bool allow_explicit_default_values = true;
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   // Add implicit receiver parameter which is passed the allocated
   // but uninitialized instance to construct.
   params.AddReceiver(TokenPos());
 
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(
       TokenPos(),
-      kPhaseParameterName,
+      &String::ZoneHandle(Symbols::PhaseParameter()),
       &Type::ZoneHandle(Type::DynamicType()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
   ASSERT(func.NumberOfParameters() == params.parameters->length());
@@ skipping 428 matching lines @@
   const bool allow_explicit_default_values = true;
   const intptr_t formal_param_pos = TokenPos();
   method->params.Clear();
   if (has_this_param) {
     method->params.AddReceiver(formal_param_pos);
   }
   // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
     method->params.AddFinalParameter(
         TokenPos(),
-        kPhaseParameterName,
+        &String::ZoneHandle(Symbols::PhaseParameter()),
         &Type::ZoneHandle(Type::DynamicType()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &method->params);
   if (method->IsGetter() || method->IsSetter()) {
     int expected_num_parameters = 0;
     if (method->IsGetter()) {
       expected_num_parameters = (method->has_static) ? 0 : 1;
@@ skipping 219 matching lines @@
       AddFormalParamsToFunction(&params, getter);
       members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
         String& setter_name = String::Handle(Field::SetterSymbol(*field->name));
         setter = Function::New(setter_name, RawFunction::kImplicitSetter,
                                field->has_static, field->has_final,
                                field->name_pos);
         ParamList params;
         params.AddReceiver(TokenPos());
-        params.AddFinalParameter(TokenPos(), "value", field->type);
+        params.AddFinalParameter(TokenPos(),
+                                 &String::ZoneHandle(Symbols::Value()),
+                                 field->type);
         setter.set_result_type(Type::Handle(Type::VoidType()));
         AddFormalParamsToFunction(&params, setter);
         members->AddFunction(setter);
       }
     }
 
     if (CurrentToken() != Token::kCOMMA) {
       break;
     }
     ConsumeToken();
@@ skipping 350 matching lines @@
                       RawFunction::kConstructor,
                       /* is_static = */ false,
                       /* is_const = */ false,
                       class_desc->token_pos()));
     ParamList params;
     // Add implicit 'this' parameter.
     params.AddReceiver(TokenPos());
     // Add implicit parameter for construction phase.
     params.AddFinalParameter(
         TokenPos(),
-        kPhaseParameterName,
+        &String::ZoneHandle(Symbols::PhaseParameter()),
         &Type::ZoneHandle(Type::DynamicType()));
 
     AddFormalParamsToFunction(&params, ctor);
     // The body of the constructor cannot modify the type arguments of the
     // constructed instance, which is passed in as a hidden parameter.
     // Therefore, there is no need to set the result type to be checked.
     const AbstractType& result_type = Type::ZoneHandle(Type::DynamicType());
     ctor.set_result_type(result_type);
     class_desc->AddFunction(ctor);
   }
@@ skipping 855 matching lines @@
   // They need to be registered with class finalization after parsing
   // has been completed.
   Isolate* isolate = Isolate::Current();
   ObjectStore* object_store = isolate->object_store();
   const GrowableObjectArray& pending_classes =
       GrowableObjectArray::Handle(isolate, object_store->pending_classes());
   SetPosition(0);
   is_top_level_ = true;
   TopLevel top_level;
   Class& toplevel_class = Class::Handle(
-      Class::New(String::ZoneHandle(Symbols::New("::")),
-                 script_,
-                 TokenPos()));
+      Class::New(String::Handle(Symbols::TopLevel()), script_, TokenPos()));
   toplevel_class.set_library(library_);
 
   if (is_library_source()) {
     ParseLibraryDefinition();
   }
 
   while (true) {
     set_current_class(Class::Handle());  // No current class.
     if (CurrentToken() == Token::kCLASS) {
       ParseClassDefinition(pending_classes);
@@ skipping 195 matching lines @@
       new ReturnNode(TokenPos(), new NativeBodyNode(TokenPos(),
                                                     native_name,
                                                     native_function,
                                                     num_parameters,
                                                     has_opt_params,
                                                     is_instance_closure)));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
-  const String& this_name = String::Handle(Symbols::New(kThisName));
+  const String& this_name = String::Handle(Symbols::This());
   return from_scope->LookupVariable(this_name, test_only);
 }
 
 
 LocalVariable* Parser::LookupPhaseParameter() {
   const String& phase_name =
-      String::Handle(Symbols::New(kPhaseParameterName));
+      String::Handle(Symbols::PhaseParameter());
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(phase_name, kTestOnly);
 }
 
 
 void Parser::CaptureReceiver() {
   ASSERT(current_block_->scope->function_level() > 0);
   const bool kTestOnly = false;
   // Side effect of lookup captures the receiver variable.
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
@@ skipping 147 matching lines @@
   }
   const intptr_t ident_pos = TokenPos();
   if (IsIdentifier()) {
     variable_name = CurrentLiteral();
     function_name = variable_name;
     ConsumeToken();
   } else {
     if (!is_literal) {
       ErrorMsg("function name expected");
     }
-    const String& anonymous_function_name =
-        String::ZoneHandle(Symbols::New("function"));
-    function_name = &anonymous_function_name;
+    function_name = &String::ZoneHandle(Symbols::Function());
   }
   ASSERT(ident_pos >= 0);
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
   intptr_t function_pos = TokenPos();
 
   // Check whether we have parsed this closure function before, in a previous
   // compilation. If so, reuse the function object, else create a new one
@@ skipping 512 matching lines @@
       // End of switch statement.
       break;
     }
     if ((next_token == Token::kCASE) || (next_token == Token::kDEFAULT)) {
       // End of this case clause. If there is a possible fall-through to
       // the next case clause, throw an implicit FallThroughError.
       if (!abrupt_completing_seen) {
         ArgumentListNode* arguments = new ArgumentListNode(TokenPos());
         arguments->Add(new LiteralNode(
             TokenPos(), Integer::ZoneHandle(Integer::New(TokenPos()))));
+        const String& cls_name = String::Handle(Symbols::FallThroughError());
+        const String& func_name = String::Handle(Symbols::ThrowNew());
         current_block_->statements->Add(
-            MakeStaticCall(kFallThroughErrorName, kThrowNewName, arguments));
+            MakeStaticCall(cls_name, func_name, arguments));
       }
       break;
     }
     // The next statement still belongs to this case.
     AstNode* statement = ParseStatement();
     if (statement != NULL) {
       current_block_->statements->Add(statement);
       abrupt_completing_seen |= IsAbruptCompleting(statement);
     }
   }
@@ skipping 150 matching lines @@
     }
   }
   ExpectToken(Token::kIN);
   const intptr_t collection_pos = TokenPos();
   AstNode* collection_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
 
   OpenBlock();  // Implicit block around while loop.
 
   // Generate implicit iterator variable and add to scope.
-  const String& iterator_name =
-      String::ZoneHandle(Symbols::New(":for-in-iter"));
+  const String& iterator_name = String::ZoneHandle(Symbols::ForInIter());
   // We could set the type of the implicit iterator variable to Iterator<T>
   // where T is the type of the for loop variable. However, the type error
   // would refer to the compiler generated iterator and could confuse the user.
   // It is better to leave the iterator untyped and postpone the type error
   // until the loop variable is assigned to.
   const AbstractType& iterator_type = Type::ZoneHandle(Type::DynamicType());
   LocalVariable* iterator_var =
       new LocalVariable(collection_pos, iterator_name, iterator_type);
   current_block_->scope->AddVariable(iterator_var);
 
   // Generate initialization of iterator variable.
   const String& iterator_method_name =
-      String::ZoneHandle(Symbols::New(kGetIteratorName));
+      String::ZoneHandle(Symbols::GetIterator());
   ArgumentListNode* no_args = new ArgumentListNode(collection_pos);
   AstNode* get_iterator = new InstanceCallNode(
       collection_pos, collection_expr, iterator_method_name, no_args);
   AstNode* iterator_init =
       new StoreLocalNode(collection_pos, *iterator_var, get_iterator);
   current_block_->statements->Add(iterator_init);
 
   // Generate while loop condition.
   AstNode* iterator_has_next = new InstanceCallNode(
       collection_pos,
       new LoadLocalNode(collection_pos, *iterator_var),
-      String::ZoneHandle(Symbols::New("hasNext")),
+      String::ZoneHandle(Symbols::HasNext()),
       no_args);
 
   // Parse the for loop body. Ideally, we would use ParseNestedStatement()
   // here, but that does not work well because we have to insert an implicit
   // variable assignment and potentially a variable declaration in the
   // loop body.
   OpenLoopBlock();
   current_block_->scope->AddLabel(label);
 
   AstNode* iterator_next = new InstanceCallNode(
       collection_pos,
       new LoadLocalNode(collection_pos, *iterator_var),
-      String::ZoneHandle(Symbols::New("next")),
+      String::ZoneHandle(Symbols::Next()),
       no_args);
 
   // Generate assignment of next iterator value to loop variable.
   AstNode* loop_var_assignment = NULL;
   if (loop_var != NULL) {
     // The for loop declares a new variable. Add it to the loop body scope.
     current_block_->scope->AddVariable(loop_var);
     loop_var_assignment =
         new StoreLocalNode(loop_var_pos, *loop_var, iterator_next);
   } else {
@@ skipping 90 matching lines @@
   return new ForNode(for_pos,
                      label,
                      NodeAsSequenceNode(init_pos, initializer, init_scope),
                      condition,
                      NodeAsSequenceNode(incr_pos, increment, incr_scope),
                      body);
 }
 
 
 // Calling VM-internal helpers, uses implementation core library.
-AstNode* Parser::MakeStaticCall(const char* class_name,
-                                const char* function_name,
+AstNode* Parser::MakeStaticCall(const String& cls_name,
+                                const String& func_name,
                                 ArgumentListNode* arguments) {
-  const String& cls_name =
-      String::Handle(Symbols::New(class_name));
   const Class& cls = Class::Handle(LookupImplClass(cls_name));
   ASSERT(!cls.IsNull());
-  const String& func_name =
-      String::ZoneHandle(Symbols::New(function_name));
   const Function& func = Function::ZoneHandle(
       Resolver::ResolveStatic(cls,
                               func_name,
                               arguments->length(),
                               arguments->names(),
                               Resolver::kIsQualified));
   ASSERT(!func.IsNull());
   CheckFunctionIsCallable(arguments->token_pos(), func);
   return new StaticCallNode(arguments->token_pos(), func, arguments);
 }
 
 
 AstNode* Parser::MakeAssertCall(intptr_t begin, intptr_t end) {
   ArgumentListNode* arguments = new ArgumentListNode(begin);
   arguments->Add(new LiteralNode(begin,
       Integer::ZoneHandle(Integer::New(begin))));
   arguments->Add(new LiteralNode(end,
       Integer::ZoneHandle(Integer::New(end))));
-  return MakeStaticCall(kAssertionErrorName, kThrowNewName, arguments);
+  const String& cls_name = String::Handle(Symbols::AssertionError());
+  const String& func_name = String::Handle(Symbols::ThrowNew());
+  return MakeStaticCall(cls_name, func_name, arguments);
 }
 
 
 AstNode* Parser::InsertClosureCallNodes(AstNode* condition) {
   if (condition->IsClosureNode() ||
       (condition->IsStoreLocalNode() &&
        condition->AsStoreLocalNode()->value()->IsClosureNode())) {
     EnsureExpressionTemp();
     // Function literal in assert implies a call.
     const intptr_t pos = condition->token_pos();
@@ skipping 156 matching lines @@
   //                        slot before processing the catch block handler.
   // ':exception_var' - Used to save the current exception object that was
   //                    thrown.
   // ':stacktrace_var' - Used to save the current stack trace object into which
   //                     the stack trace was copied into when an exception was
   //                     thrown.
   // :exception_var and :stacktrace_var get set with the exception object
   // and the stacktrace object when an exception is thrown.
   // These three implicit variables can never be captured variables.
   const String& context_var_name =
-      String::ZoneHandle(Symbols::New(":saved_context_var"));
+      String::ZoneHandle(Symbols::SavedContextVar());
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(context_var_name);
   if (context_var == NULL) {
     context_var = new LocalVariable(TokenPos(),
                                     context_var_name,
                                     Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   const String& catch_excp_var_name =
-      String::ZoneHandle(Symbols::New(":exception_var"));
+      String::ZoneHandle(Symbols::ExceptionVar());
   LocalVariable* catch_excp_var =
       current_block_->scope->LocalLookupVariable(catch_excp_var_name);
   if (catch_excp_var == NULL) {
     catch_excp_var = new LocalVariable(TokenPos(),
                                        catch_excp_var_name,
                                        Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_excp_var);
   }
   const String& catch_trace_var_name =
-      String::ZoneHandle(Symbols::New(":stacktrace_var"));
+      String::ZoneHandle(Symbols::StacktraceVar());
   LocalVariable* catch_trace_var =
       current_block_->scope->LocalLookupVariable(catch_trace_var_name);
   if (catch_trace_var == NULL) {
     catch_trace_var = new LocalVariable(TokenPos(),
                                         catch_trace_var_name,
                                         Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_trace_var);
   }
 
   const intptr_t try_pos = TokenPos();
@@ skipping 348 matching lines @@
       // Check if it is ok to do a rethrow.
       SourceLabel* label = current_block_->scope->LookupInnermostCatchLabel();
       if (label == NULL ||
           label->FunctionLevel() != current_block_->scope->function_level()) {
         ErrorMsg("rethrow of an exception is not valid here");
       }
       ASSERT(label->owner() != NULL);
       LocalScope* scope = label->owner()->parent();
       ASSERT(scope != NULL);
       LocalVariable* excp_var = scope->LocalLookupVariable(
-          String::ZoneHandle(Symbols::New(":exception_var")));
+          String::ZoneHandle(Symbols::ExceptionVar()));
       ASSERT(excp_var != NULL);
       LocalVariable* trace_var = scope->LocalLookupVariable(
-          String::ZoneHandle(Symbols::New(":stacktrace_var")));
+          String::ZoneHandle(Symbols::StacktraceVar()));
       ASSERT(trace_var != NULL);
       statement = new ThrowNode(statement_pos,
                                 new LoadLocalNode(statement_pos, *excp_var),
                                 new LoadLocalNode(statement_pos, *trace_var));
     }
   } else {
     statement = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectSemicolon();
   }
   return statement;
@@ skipping 270 matching lines @@
   ArgumentListNode* arguments = new ArgumentListNode(type_pos);
   // Location argument.
   arguments->Add(new LiteralNode(
       type_pos, Integer::ZoneHandle(Integer::New(type_pos))));
   // Src value argument.
   arguments->Add(new LiteralNode(type_pos, Instance::ZoneHandle()));
   // Dst type name argument.
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
       Symbols::New("malformed"))));
   // Dst name argument.
-  arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
-    Symbols::New(""))));
+  arguments->Add(new LiteralNode(type_pos,
+                                 String::ZoneHandle(Symbols::Empty())));
   // Malformed type error.
   const Error& error = Error::Handle(type.malformed_error());
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
       Symbols::New(error.ToErrorCString()))));
-  return MakeStaticCall(kTypeErrorName, kThrowNewName, arguments);
+  const String& cls_name = String::Handle(Symbols::TypeError());
+  const String& func_name = String::Handle(Symbols::ThrowNew());
+  return MakeStaticCall(cls_name, func_name, arguments);
 }
 
 
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= 4);
   AstNode* left_operand = ParseUnaryExpr();
   if (IsLiteral("as")) {  // Not a reserved word.
     token_kind_ = Token::kAS;
   }
@@ skipping 502 matching lines @@
     // do not match or compile time error otherwise.
     const Function& test_func = Function::Handle(
         Resolver::ResolveStaticByName(cls, func_name, Resolver::kIsQualified));
     if (test_func.IsNull()) {
       ErrorMsg(ident_pos, "unresolved static method '%s'",
           func_name.ToCString());
     } else {
       ArgumentListNode* arguments = new ArgumentListNode(ident_pos);
       arguments->Add(new LiteralNode(
           TokenPos(), Integer::ZoneHandle(Integer::New(ident_pos))));
-      return MakeStaticCall(kStaticResolutionExceptionName,
-                            kThrowNewName,
-                            arguments);
+      const String& cls_name =
+          String::Handle(Symbols::StaticResolutionException());
+      const String& func_name = String::Handle(Symbols::ThrowNew());
+      return MakeStaticCall(cls_name, func_name, arguments);
     }
   }
   CheckFunctionIsCallable(call_pos, func);
   return new StaticCallNode(call_pos, func, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceCall(AstNode* receiver, const String& func_name) {
   TRACE_PARSER("ParseInstanceCall");
   const intptr_t call_pos = TokenPos();
@@ skipping 1049 matching lines @@
                "a type variable");
     }
   }
   ASSERT(type_arguments.IsNull() || (type_arguments.Length() == 1));
 
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   ArrayNode* list = new ArrayNode(TokenPos(), type_arguments);
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
-    const String& dst_name = String::ZoneHandle(
-        Symbols::New("list literal element"));
+    const String& dst_name = String::ZoneHandle(Symbols::ListLiteralElement());
     while (CurrentToken() != Token::kRBRACK) {
       const intptr_t element_pos = TokenPos();
       AstNode* element = ParseExpr(is_const, kConsumeCascades);
       if (FLAG_enable_type_checks &&
           !is_const &&
           !element_type.IsDynamicType()) {
         element = new AssignableNode(element_pos,
                                      element,
                                      element_type,
                                      dst_name);
@@ skipping 37 matching lines @@
         }
       }
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
     const_list ^= const_list.Canonicalize();
     const_list.MakeImmutable();
     return new LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
     String& list_literal_factory_class_name = String::Handle(
-        Symbols::New(kListLiteralFactoryClassName));
+        Symbols::ListLiteralFactoryClass());
     const Class& list_literal_factory_class =
         Class::Handle(LookupCoreClass(list_literal_factory_class_name));
     ASSERT(!list_literal_factory_class.IsNull());
     const String& list_literal_factory_name =
-        String::Handle(Symbols::New(kListLiteralFactoryName));
+        String::Handle(Symbols::ListLiteralFactory());
     const Function& list_literal_factory = Function::ZoneHandle(
         list_literal_factory_class.LookupFactory(list_literal_factory_name));
     ASSERT(!list_literal_factory.IsNull());
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
@@ skipping 99 matching lines @@
   }
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   // The kv_pair array is temporary and of element type Dynamic. It is passed
   // to the factory to initialize a properly typed map.
   ArrayNode* kv_pairs =
       new ArrayNode(TokenPos(), TypeArguments::ZoneHandle());
-  const String& dst_name = String::ZoneHandle(
-      Symbols::New("list literal element"));
+  const String& dst_name = String::ZoneHandle(Symbols::ListLiteralElement());
   while (CurrentToken() != Token::kRBRACE) {
     AstNode* key = NULL;
     if (CurrentToken() == Token::kSTRING) {
       key = ParseStringLiteral();
     }
     if (key == NULL) {
       ErrorMsg("map entry key must be string literal");
     } else if (is_const && !key->IsLiteralNode()) {
       ErrorMsg("map entry key must be compile time constant string");
     }
@@ skipping 51 matching lines @@
                    String::Handle(value_type.UserVisibleName()).ToCString());
         }
       }
       key_value_array.SetAt(i, arg->AsLiteralNode()->literal());
     }
     key_value_array ^= key_value_array.Canonicalize();
     key_value_array.MakeImmutable();
 
     // Construct the map object.
     const String& immutable_map_class_name =
-        String::Handle(Symbols::New(kImmutableMapName));
+        String::Handle(Symbols::ImmutableMap());
     const Class& immutable_map_class =
         Class::Handle(LookupImplClass(immutable_map_class_name));
     ASSERT(!immutable_map_class.IsNull());
     ArgumentListNode* constr_args = new ArgumentListNode(TokenPos());
     constr_args->Add(new LiteralNode(literal_pos, key_value_array));
     const String& constr_name =
-        String::Handle(Symbols::New(kImmutableMapConstructorName));
+        String::Handle(Symbols::ImmutableMapConstructor());
     const Function& map_constr = Function::ZoneHandle(
         immutable_map_class.LookupConstructor(constr_name));
     ASSERT(!map_constr.IsNull());
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,
                                      map_constr,
                                      constr_args));
     if (constructor_result.IsUnhandledException()) {
       return GenerateRethrow(literal_pos, constructor_result);
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
       return new LiteralNode(literal_pos,
                              Instance::ZoneHandle(const_instance.raw()));
     }
   } else {
     // Factory call at runtime.
     String& map_literal_factory_class_name = String::Handle(
-        Symbols::New(kMapLiteralFactoryClassName));
+        Symbols::MapLiteralFactoryClass());
     const Class& map_literal_factory_class =
         Class::Handle(LookupCoreClass(map_literal_factory_class_name));
     ASSERT(!map_literal_factory_class.IsNull());
     const String& map_literal_factory_name =
-        String::Handle(Symbols::New(kMapLiteralFactoryName));
+        String::Handle(Symbols::MapLiteralFactory());
     const Function& map_literal_factory = Function::ZoneHandle(
         map_literal_factory_class.LookupFactory(map_literal_factory_name));
     ASSERT(!map_literal_factory.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
@@ skipping 279 matching lines @@
     // If the type argument vector is not instantiated, we verify in checked
     // mode at runtime that it is within its declared bounds.
     new_object = CreateConstructorCallNode(
         new_pos, type_arguments, constructor, arguments);
   }
   return new_object;
 }
 
 
 String& Parser::Interpolate(ArrayNode* values) {
-  const String& class_name =
-      String::Handle(Symbols::New(kStringClassName));
+  const String& class_name = String::Handle(Symbols::StringBase());
   const Class& cls = Class::Handle(LookupImplClass(class_name));
   ASSERT(!cls.IsNull());
-  const String& func_name = String::Handle(Symbols::New(kInterpolateName));
+  const String& func_name = String::Handle(Symbols::Interpolate());
   const Function& func =
       Function::Handle(cls.LookupStaticFunction(func_name));
   ASSERT(!func.IsNull());
 
   // Build the array of literal values to interpolate.
   const Array& value_arr = Array::Handle(Array::New(values->length()));
   for (int i = 0; i < values->length(); i++) {
     ASSERT(values->ElementAt(i)->IsLiteralNode());
     value_arr.SetAt(i, values->ElementAt(i)->AsLiteralNode()->literal());
   }
@@ skipping 69 matching lines @@
       }
       values->AddElement(expr);
     }
   }
   if (is_compiletime_const) {
     primary = new LiteralNode(literal_start, Interpolate(values));
   } else {
     ArgumentListNode* interpolate_arg =
         new ArgumentListNode(values->token_pos());
     interpolate_arg->Add(values);
-    primary = MakeStaticCall(kStringClassName,
-                             kInterpolateName,
-                             interpolate_arg);
+    const String& cls_name = String::Handle(Symbols::StringBase());
+    const String& func_name = String::Handle(Symbols::Interpolate());
+    primary = MakeStaticCall(cls_name, func_name, interpolate_arg);
   }
   return primary;
 }
 
 
 // An import string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol }+ kSTRING }
 // interpol = kINTERPOL_VAR
 // In other words, the scanner breaks down interpolated strings so that
 // a string literal always begins and ends with a kSTRING token, and
 // there are never two kSTRING tokens next to each other.
 String* Parser::ParseImportStringLiteral() {
   TRACE_PARSER("ParseImportStringLiteral");
   if ((CurrentToken() == Token::kSTRING) &&
       (LookaheadToken(1) != Token::kINTERPOL_VAR) &&
       (LookaheadToken(1) != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
     String* result = CurrentLiteral();
     ConsumeToken();
     return result;
   }
   // String interpolation needed.
-  String& result = String::ZoneHandle(String::New(""));
+  String& result = String::ZoneHandle(Symbols::Empty());
   String& resolved_name = String::Handle();
   while (CurrentToken() == Token::kSTRING) {
     result = String::Concat(result, *CurrentLiteral());
     ConsumeToken();
     if ((CurrentToken() != Token::kINTERPOL_VAR) &&
         (CurrentToken() != Token::kINTERPOL_START)) {
       break;
     }
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
            (CurrentToken() == Token::kINTERPOL_START)) {
@@ skipping 64 matching lines @@
       }
     } else {
       // This is a qualified identifier with a library prefix so resolve
       // the identifier locally in that library (we do not include the
       // libraries imported by that library).
       primary = ResolveIdentInLibraryPrefixScope(*(qual_ident.lib_prefix),
                                                  qual_ident);
     }
     ASSERT(primary != NULL);
   } else if (CurrentToken() == Token::kTHIS) {
-    const String& this_name = String::Handle(Symbols::New(kThisName));
+    const String& this_name = String::Handle(Symbols::This());
     LocalVariable* local = LookupLocalScope(this_name);
     if (local == NULL) {
       ErrorMsg("receiver 'this' is not in scope");
     }
     primary = new LoadLocalNode(TokenPos(), *local);
     ConsumeToken();
   } else if (CurrentToken() == Token::kINTEGER) {
     const Integer& literal = Integer::ZoneHandle(CurrentIntegerLiteral());
     primary = new LiteralNode(TokenPos(), literal);
     ConsumeToken();
@@ skipping 340 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart