Convert all symbols accessor to return read only handles so that it is not necessary to create a ne…

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 97 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::ExprTemp()),
+                           Symbols::ExprTemp(),
                            Type::ZoneHandle(Type::DynamicType()));
 }
 
 
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
 }
 
 
 LocalVariable* ParsedFunction::GetSavedArgumentsDescriptorVar() const {
   const int num_parameters = function().NumParameters();
   LocalScope* scope = node_sequence()->scope();
   if (scope->num_variables() > num_parameters) {
     LocalVariable* saved_args_desc_var = scope->VariableAt(num_parameters);
     ASSERT(saved_args_desc_var != NULL);
     // The scope of the formal parameters may also contain at this position
     // an alias for the saved arguments descriptor variable of the enclosing
     // function (check its scope owner) or an internal variable such as the
     // expression temp variable or the saved entry context variable (check its
     // name).
     if ((saved_args_desc_var->owner() == scope) &&
         saved_args_desc_var->name().StartsWith(
-            String::Handle(Symbols::SavedArgDescVarPrefix()))) {
+            Symbols::SavedArgDescVarPrefix())) {
       return saved_args_desc_var;
     }
   }
   return NULL;
 }
 
 
 void ParsedFunction::AllocateVariables() {
   LocalScope* scope = node_sequence()->scope();
   const intptr_t num_fixed_params = function().num_fixed_parameters();
@@ skipping 29 matching lines @@
       scope->AllocateVariables(first_parameter_index_,
                                num_params,
                                first_stack_local_index_,
                                scope,
                                &context_owner);
 
   // If this function is not a closure function and if it contains captured
   // variables, the context needs to be saved on entry and restored on exit.
   // Add and allocate a local variable to this purpose.
   if ((context_owner != NULL) && !function().IsClosureFunction()) {
-    const String& context_var_name =
-        String::ZoneHandle(Symbols::SavedEntryContextVar());
     LocalVariable* context_var =
         new LocalVariable(function().token_pos(),
-                          context_var_name,
+                          Symbols::SavedEntryContextVar(),
                           Type::ZoneHandle(Type::DynamicType()));
     context_var->set_index(next_free_frame_index--);
     scope->AddVariable(context_var);
     set_saved_context_var(context_var);
   }
 
   // Frame indices are relative to the frame pointer and are decreasing.
   ASSERT(next_free_frame_index <= first_stack_local_index_);
   num_stack_locals_ = first_stack_local_index_ - next_free_frame_index;
 }
@@ skipping 234 matching lines @@
     param.name_pos = name_pos;
     param.name = name;
     param.is_final = true;
     param.type = type;
     this->parameters->Add(param);
   }
 
   void AddReceiver(const Type* receiver_type) {
     ASSERT(this->parameters->is_empty());
     AddFinalParameter(receiver_type->token_pos(),
-                      &Symbols::ThisHandle(),
+                      &Symbols::This(),
                       receiver_type);
   }
 
   void SetImplicitlyFinal() {
     implicitly_final = true;
   }
 
   int num_fixed_parameters;
   int num_optional_parameters;
   bool has_optional_positional_parameters;
@@ skipping 487 matching lines @@
   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;
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(ident_pos));
   params.AddFinalParameter(ident_pos,
-                           &String::ZoneHandle(Symbols::Value()),
+                           &Symbols::Value(),
                            &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(!func.HasOptionalParameters());
   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 =
@@ skipping 144 matching lines @@
       // The parsed parameter type is actually the function result type.
       const AbstractType& result_type =
           AbstractType::Handle(parameter.type->raw());
 
       // Finish parsing the function type parameter.
       ParamList func_params;
 
       // Add implicit closure object parameter.
       func_params.AddFinalParameter(
           TokenPos(),
-          &String::ZoneHandle(Symbols::ClosureParameter()),
+          &Symbols::ClosureParameter(),
           &Type::ZoneHandle(Type::DynamicType()));
 
       const bool no_explicit_default_values = false;
       ParseFormalParameterList(no_explicit_default_values, &func_params);
 
       // The field 'is_static' has no meaning for signature functions.
       const Function& signature_function = Function::Handle(
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         /* is_static = */ false,
@@ skipping 162 matching lines @@
                                     arguments->names(),
                                     NULL)) {
     super_func = Function::null();
   } else if (super_func.IsNull() && resolve_getter) {
     const String& getter_name = String::ZoneHandle(Field::GetterName(name));
     super_func = Resolver::ResolveDynamicAnyArgs(super_class, getter_name);
     ASSERT(super_func.IsNull() ||
            (super_func.kind() != RawFunction::kConstImplicitGetter));
   }
   if (super_func.IsNull()) {
-    const String& no_such_method_name = String::Handle(Symbols::NoSuchMethod());
     super_func =
-        Resolver::ResolveDynamicAnyArgs(super_class, no_such_method_name);
+        Resolver::ResolveDynamicAnyArgs(super_class, Symbols::NoSuchMethod());
     ASSERT(!super_func.IsNull());
     *is_no_such_method = true;
   } else {
     *is_no_such_method = false;
   }
   return super_func.raw();
 }
 
 
 // Lookup class in the core lib which also contains various VM
@@ skipping 27 matching lines @@
   arguments->Add(new LiteralNode(args_pos, args_descriptor));
   // The third argument is an array containing the original function arguments,
   // including the receiver.
   ArrayNode* args_array = new ArrayNode(
       args_pos, Type::ZoneHandle(Type::ArrayType()));
   for (intptr_t i = 0; i < function_args.length(); i++) {
     args_array->AddElement(function_args.NodeAt(i));
   }
   arguments->Add(args_array);
   // Lookup the static InvocationMirror._allocateInvocationMirror method.
-  const Class& mirror_class = Class::Handle(
-      LookupCoreClass(String::Handle(Symbols::InvocationMirror())));
+  const Class& mirror_class =
+      Class::Handle(LookupCoreClass(Symbols::InvocationMirror()));
   ASSERT(!mirror_class.IsNull());
-  const String& allocation_function_name =
-      String::Handle(Symbols::AllocateInvocationMirror());
   const Function& allocation_function = Function::ZoneHandle(
-      mirror_class.LookupStaticFunction(allocation_function_name));
+      mirror_class.LookupStaticFunction(Symbols::AllocateInvocationMirror()));
   ASSERT(!allocation_function.IsNull());
   return new StaticCallNode(call_pos, allocation_function, arguments);
 }
 
 
 ArgumentListNode* Parser::BuildNoSuchMethodArguments(
     intptr_t call_pos,
     const String& function_name,
     const ArgumentListNode& function_args) {
   ASSERT(function_args.length() >= 1);  // The receiver is the first argument.
@@ skipping 224 matching lines @@
   const Class& super_class = Class::Handle(cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
   // we're not compiling class Object), or if the super class is an
   // artificially generated "wrapper class" that has no constructor.
   if (super_class.IsNull() ||
       (super_class.num_native_fields() > 0 &&
        Class::Handle(super_class.SuperClass()).IsObjectClass())) {
     return;
   }
   String& ctor_name = String::Handle(super_class.Name());
-  ctor_name = String::Concat(ctor_name, Symbols::DotHandle());
+  ctor_name = String::Concat(ctor_name, Symbols::Dot());
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // Implicit 'this' parameter is the first argument.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
   // Implicit construction phase parameter is second argument.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
                       Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
   const Function& super_ctor = Function::ZoneHandle(
@@ skipping 19 matching lines @@
 
 AstNode* Parser::ParseSuperInitializer(const Class& cls,
                                        LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
   ASSERT(CurrentToken() == Token::kSUPER);
   const intptr_t supercall_pos = TokenPos();
   ConsumeToken();
   const Class& super_class = Class::Handle(cls.SuperClass());
   ASSERT(!super_class.IsNull());
   String& ctor_name = String::Handle(super_class.Name());
-  ctor_name = String::Concat(ctor_name, Symbols::DotHandle());
+  ctor_name = String::Concat(ctor_name, Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_name = String::Concat(ctor_name,
                                *ExpectIdentifier("constructor name expected"));
   }
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("parameter list expected");
   }
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
@@ skipping 198 matching lines @@
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   TRACE_PARSER("ParseConstructorRedirection");
   ASSERT(CurrentToken() == Token::kTHIS);
   const intptr_t call_pos = TokenPos();
   ConsumeToken();
   String& ctor_name = String::Handle(cls.Name());
 
-  ctor_name = String::Concat(ctor_name, Symbols::DotHandle());
+  ctor_name = String::Concat(ctor_name, Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_name = String::Concat(ctor_name,
                                *ExpectIdentifier("constructor name expected"));
   }
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("parameter list expected");
   }
 
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
@@ skipping 28 matching lines @@
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
   const intptr_t ctor_pos = TokenPos();
   OpenFunctionBlock(func);
   const Class& cls = Class::Handle(func.Owner());
   LocalVariable* receiver = new LocalVariable(
       ctor_pos,
-      Symbols::ThisHandle(),
+      Symbols::This(),
       Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(receiver);
 
   LocalVariable* phase_parameter = new LocalVariable(
        ctor_pos,
-       String::ZoneHandle(Symbols::PhaseParameter()),
+       Symbols::PhaseParameter(),
        Type::ZoneHandle(Type::SmiType()));
   current_block_->scope->AddVariable(phase_parameter);
 
   // Parse expressions of instance fields that have an explicit
   // initializer expression.
   // The receiver must not be visible to field initializer expressions.
   receiver->set_invisible(true);
   GrowableArray<Field*> initialized_fields;
   ParseInitializedInstanceFields(cls, receiver, &initialized_fields);
   receiver->set_invisible(false);
@@ skipping 47 matching lines @@
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   // Add implicit receiver parameter which is passed the allocated
   // but uninitialized instance to construct.
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(TokenPos()));
 
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(
       TokenPos(),
-      &String::ZoneHandle(Symbols::PhaseParameter()),
+      &Symbols::PhaseParameter(),
       &Type::ZoneHandle(Type::SmiType()));
 
   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.NumParameters() == params.parameters->length());
@@ skipping 227 matching lines @@
   OpenFunctionBlock(func);  // Build local scope for function.
 
   ParamList params;
   // An instance closure function may capture and access the receiver, but via
   // the context and not via the first formal parameter.
   if (func.IsClosureFunction()) {
     // The first parameter of a closure function is the closure object.
     ASSERT(!func.is_const());  // Closure functions cannot be const.
     params.AddFinalParameter(
         TokenPos(),
-        &String::ZoneHandle(Symbols::ClosureParameter()),
+        &Symbols::ClosureParameter(),
         &Type::ZoneHandle(Type::DynamicType()));
   } else if (!func.is_static()) {
     // Static functions do not have a receiver.
     ASSERT(current_class().raw() == func.Owner());
     params.AddReceiver(ReceiverType(TokenPos()));
   } else if (func.IsFactory()) {
     // The first parameter of a factory is the AbstractTypeArguments vector of
     // the type of the instance to be allocated.
     params.AddFinalParameter(
         TokenPos(),
-        &String::ZoneHandle(Symbols::TypeArgumentsParameter()),
+        &Symbols::TypeArgumentsParameter(),
         &Type::ZoneHandle(Type::DynamicType()));
   }
   ASSERT((CurrentToken() == Token::kLPAREN) || func.IsGetterFunction());
   const bool allow_explicit_default_values = true;
   if (!func.IsGetterFunction()) {
     ParseFormalParameterList(allow_explicit_default_values, &params);
   } else {
     // TODO(hausner): Remove this once we no longer support the old
     // getter syntax with explicit empty parameter list.
     if (CurrentToken() == Token::kLPAREN) {
@@ skipping 188 matching lines @@
   const intptr_t formal_param_pos = TokenPos();
   method->params.Clear();
   // Static functions do not have a receiver.
   // The first parameter of a factory is the AbstractTypeArguments vector of
   // the type of the instance to be allocated.
   if (!method->has_static || method->IsConstructor()) {
     method->params.AddReceiver(ReceiverType(formal_param_pos));
   } else if (method->IsFactory()) {
     method->params.AddFinalParameter(
         formal_param_pos,
-        &String::ZoneHandle(Symbols::TypeArgumentsParameter()),
+        &Symbols::TypeArgumentsParameter(),
         &Type::ZoneHandle(Type::DynamicType()));
   }
   // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
     method->params.AddFinalParameter(
         TokenPos(),
-        &String::ZoneHandle(Symbols::PhaseParameter()),
+        &Symbols::PhaseParameter(),
         &Type::ZoneHandle(Type::SmiType()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   if (!method->IsGetter()) {
     ParseFormalParameterList(allow_explicit_default_values, &method->params);
   }
 
   // Now that we know the parameter list, we can distinguish between the
@@ skipping 73 matching lines @@
       // Redirected constructor: either this(...) or this.xxx(...).
       if (method->params.has_field_initializer) {
         // Constructors that redirect to another constructor must not
         // initialize any fields using field initializer parameters.
         ErrorMsg(formal_param_pos, "Redirecting constructor "
                  "may not use field initializer parameters");
       }
       ConsumeToken();  // Colon.
       ExpectToken(Token::kTHIS);
       String& redir_name = String::ZoneHandle(
-          String::Concat(members->class_name(), Symbols::DotHandle()));
+          String::Concat(members->class_name(), Symbols::Dot()));
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         redir_name = String::Concat(redir_name,
             *ExpectIdentifier("constructor name expected"));
       }
       method->redirect_name = &redir_name;
       if (CurrentToken() != Token::kLPAREN) {
         ErrorMsg("'(' expected");
       }
       SkipToMatchingParenthesis();
@@ skipping 237 matching lines @@
                                field->has_static,
                                field->has_final,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                current_class(),
                                field->name_pos);
         ParamList params;
         ASSERT(current_class().raw() == setter.Owner());
         params.AddReceiver(ReceiverType(TokenPos()));
         params.AddFinalParameter(TokenPos(),
-                                 &String::ZoneHandle(Symbols::Value()),
+                                 &Symbols::Value(),
                                  field->type);
         setter.set_result_type(Type::Handle(Type::VoidType()));
         AddFormalParamsToFunction(&params, setter);
         members->AddFunction(setter);
       }
     }
 
     if (CurrentToken() != Token::kCOMMA) {
       break;
     }
@@ skipping 127 matching lines @@
                                member.name_pos));
       // The type arguments of the result type are set during finalization.
       member.type = &Type::ZoneHandle(Type::New(result_type_class,
                                                 TypeArguments::Handle(),
                                                 member.name_pos));
     } else if (member.has_static) {
       ErrorMsg(member.name_pos, "constructor cannot be static");
     }
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
-    *member.name = String::Concat(*member.name, Symbols::DotHandle());
+    *member.name = String::Concat(*member.name, Symbols::Dot());
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       member.constructor_name = ExpectIdentifier("identifier expected");
       *member.name = String::Concat(*member.name, *member.constructor_name);
     }
     // Ensure that names are symbols.
     *member.name = Symbols::New(*member.name);
     if (member.type == NULL) {
       ASSERT(!member.has_factory);
@@ skipping 126 matching lines @@
     }
     cls = Class::New(class_name, script_, classname_pos);
     library_.AddClass(cls);
   } else {
     if (!obj.IsClass()) {
       ErrorMsg(classname_pos, "'%s' is already defined",
                class_name.ToCString());
     }
     cls ^= obj.raw();
     if (is_patch) {
-      String& patch = String::Handle(Symbols::New("patch "));
-      patch = String::Concat(patch, class_name);
+      String& patch = String::Handle(
+          String::Concat(Symbols::PatchSpace(), class_name));
       patch = Symbols::New(patch);
       cls = Class::New(patch, script_, classname_pos);
       cls.set_library(library_);
     } else {
       // Not patching a class, but it has been found. This must be one of the
       // pre-registered classes from object.cc or a duplicate definition.
       if (cls.functions() != Object::empty_array().raw()) {
         ErrorMsg(classname_pos, "class '%s' is already defined",
                  class_name.ToCString());
       }
@@ skipping 70 matching lines @@
     }
   }
 }
 
 
 // Add an implicit constructor if no explicit constructor is present.
 void Parser::AddImplicitConstructor(ClassDesc* class_desc) {
   // The implicit constructor is unnamed, has no explicit parameter,
   // and contains a supercall in the initializer list.
   String& ctor_name = String::ZoneHandle(
-    String::Concat(class_desc->class_name(), Symbols::DotHandle()));
+    String::Concat(class_desc->class_name(), Symbols::Dot()));
   ctor_name = Symbols::New(ctor_name);
   // The token position for the implicit constructor is the 'class'
   // keyword of the constructor's class.
   Function& ctor = Function::Handle(
       Function::New(ctor_name,
                     RawFunction::kConstructor,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     current_class(),
                     class_desc->token_pos()));
   ParamList params;
   // Add implicit 'this' parameter.
   ASSERT(current_class().raw() == ctor.Owner());
   params.AddReceiver(ReceiverType(TokenPos()));
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(TokenPos(),
-                           &String::ZoneHandle(Symbols::PhaseParameter()),
+                           &Symbols::PhaseParameter(),
                            &Type::ZoneHandle(Type::SmiType()));
 
   AddFormalParamsToFunction(&params, ctor);
   // The body of the constructor cannot modify the type of the constructed
   // instance, which is passed in as the receiver.
   ctor.set_result_type(*((*params.parameters)[0].type));
   class_desc->AddFunction(ctor);
 }
 
 
@@ skipping 60 matching lines @@
 
 
 void Parser::ParseFunctionTypeAlias(
     const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
   // Allocate an abstract class to hold the type parameters and their bounds.
   // Make it the owner of the function type descriptor.
   const Class& alias_owner = Class::Handle(
-      Class::New(String::Handle(Symbols::New(":alias_owner")),
-                 Script::Handle(),
-                 TokenPos()));
+      Class::New(Symbols::AliasOwner(), Script::Handle(), TokenPos()));
 
   alias_owner.set_is_abstract();
   alias_owner.set_library(library_);
   set_current_class(alias_owner);
 
   // Parse the result type of the function type.
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
@@ skipping 18 matching lines @@
   }
   // Parse the formal parameters of the function type.
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("formal parameter list expected");
   }
   ParamList func_params;
 
   // Add implicit closure object parameter.
   func_params.AddFinalParameter(
       TokenPos(),
-      &String::ZoneHandle(Symbols::ClosureParameter()),
+      &Symbols::ClosureParameter(),
       &Type::ZoneHandle(Type::DynamicType()));
 
   const bool no_explicit_default_values = false;
   ParseFormalParameterList(no_explicit_default_values, &func_params);
   // The field 'is_static' has no meaning for signature functions.
   Function& signature_function = Function::Handle(
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
                     /* is_const = */ false,
@@ skipping 720 matching lines @@
 }
 
 
 void Parser::ParseLibraryName() {
   ASSERT(CurrentToken() == Token::kLIBRARY);
   ConsumeToken();
   String& lib_name = *ExpectIdentifier("library name expected");
   if (CurrentToken() == Token::kPERIOD) {
     while (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
-      lib_name = String::Concat(lib_name, Symbols::DotHandle());
+      lib_name = String::Concat(lib_name, Symbols::Dot());
       lib_name = String::Concat(lib_name,
           *ExpectIdentifier("malformed library name"));
     }
     lib_name = Symbols::New(lib_name);
   }
   library_.SetName(lib_name);
   ExpectSemicolon();
 }
 
 
@@ skipping 218 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::Handle(Symbols::TopLevel()), script_, TokenPos()));
+      Class::New(Symbols::TopLevel(), script_, TokenPos()));
   toplevel_class.set_library(library_);
 
   if (is_library_source()) {
     ParseLibraryDefinition();
   } else if (is_part_source()) {
     ParsePartHeader();
   }
 
   while (true) {
     set_current_class(Class::Handle());  // No current class.
@@ skipping 200 matching lines @@
       new ReturnNode(TokenPos(),
                      new NativeBodyNode(TokenPos(),
                                         Function::ZoneHandle(func.raw()),
                                         native_name,
                                         native_function)));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
   ASSERT(!current_function().is_static());
-  return from_scope->LookupVariable(Symbols::ThisHandle(), test_only);
+  return from_scope->LookupVariable(Symbols::This(), test_only);
 }
 
 
 LocalVariable* Parser::LookupTypeArgumentsParameter(LocalScope* from_scope,
                                                     bool test_only) {
   ASSERT(current_function().IsInFactoryScope());
-  const String& param_name = String::Handle(Symbols::TypeArgumentsParameter());
-  return from_scope->LookupVariable(param_name, test_only);
+  return from_scope->LookupVariable(Symbols::TypeArgumentsParameter(),
+                                    test_only);
 }
 LocalVariable* Parser::LookupPhaseParameter() {
-  const String& phase_name =
-      String::Handle(Symbols::PhaseParameter());
   const bool kTestOnly = false;
-  return current_block_->scope->LookupVariable(phase_name, kTestOnly);
+  return current_block_->scope->LookupVariable(Symbols::PhaseParameter(),
+                                               kTestOnly);
 }
 
 
 void Parser::CaptureInstantiator() {
   ASSERT(current_block_->scope->function_level() > 0);
   const bool kTestOnly = false;
   // Side effect of lookup captures the instantiator variable.
   LocalVariable* instantiator = NULL;
   if (current_function().IsInFactoryScope()) {
     instantiator = LookupTypeArgumentsParameter(current_block_->scope,
@@ skipping 157 matching lines @@
   AbstractType& result_type = AbstractType::Handle();
   const String* variable_name = NULL;
   const String* function_name = NULL;
 
   result_type = Type::DynamicType();
 
   intptr_t ident_pos = TokenPos();
   if (FLAG_strict_function_literals) {
     if (is_literal) {
       ASSERT(CurrentToken() == Token::kLPAREN);
-      function_name = &String::ZoneHandle(Symbols::AnonymousClosure());
+      function_name = &Symbols::AnonymousClosure();
     } else {
       if (CurrentToken() == Token::kVOID) {
         ConsumeToken();
         result_type = Type::VoidType();
       } else if ((CurrentToken() == Token::kIDENT) &&
                  (LookaheadToken(1) != Token::kLPAREN)) {
         result_type = ParseType(ClassFinalizer::kCanonicalize);
       }
       ident_pos = TokenPos();
       variable_name = ExpectIdentifier("function name expected");
@@ skipping 11 matching lines @@
     }
     ident_pos = TokenPos();
     if (IsIdentifier()) {
       variable_name = CurrentLiteral();
       function_name = variable_name;
       ConsumeToken();
     } else {
       if (!is_literal) {
         ErrorMsg("function name expected");
       }
-      function_name = &String::ZoneHandle(Symbols::AnonymousClosure());
+      function_name = &Symbols::AnonymousClosure();
     }
   }
 
   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 620 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(cls_name, func_name, arguments));
+            MakeStaticCall(Symbols::FallThroughError(),
+                           Symbols::ThrowNew(),
+                           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 23 matching lines @@
   if (paren_found) {
     ExpectToken(Token::kRPAREN);
   }
   ExpectToken(Token::kLBRACE);
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
   // Store switch expression in temporary local variable.
   LocalVariable* temp_variable =
       new LocalVariable(expr_pos,
-                        String::ZoneHandle(Symbols::New(":switch_expr")),
+                        Symbols::SwitchExpr(),
                         Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(temp_variable);
   AstNode* save_switch_expr =
       new StoreLocalNode(expr_pos, temp_variable, switch_expr);
   current_block_->statements->Add(save_switch_expr);
 
   // Parse case clauses
   bool default_seen = false;
   while (true) {
     // Check for statement label
@@ skipping 110 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::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);
+      new LocalVariable(collection_pos, Symbols::ForInIter(), iterator_type);
   current_block_->scope->AddVariable(iterator_var);
 
   // Generate initialization of iterator variable.
-  const String& iterator_method_name =
-      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);
+      collection_pos, collection_expr, Symbols::GetIterator(), 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 InstanceGetterNode(
       collection_pos,
       new LoadLocalNode(collection_pos, iterator_var),
-      String::ZoneHandle(Symbols::HasNext()));
+      Symbols::HasNext());
 
   // 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::Next()),
+      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 112 matching lines @@
   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))));
-  const String& cls_name = String::Handle(Symbols::AssertionError());
-  const String& func_name = String::Handle(Symbols::ThrowNew());
-  return MakeStaticCall(cls_name, func_name, arguments);
+  return MakeStaticCall(Symbols::AssertionError(),
+                        Symbols::ThrowNew(),
+                        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 137 matching lines @@
   //                        block. The context register is restored from this
   //                        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::SavedContextVar());
   LocalVariable* context_var =
-      current_block_->scope->LocalLookupVariable(context_var_name);
+      current_block_->scope->LocalLookupVariable(Symbols::SavedContextVar());
   if (context_var == NULL) {
     context_var = new LocalVariable(TokenPos(),
-                                    context_var_name,
+                                    Symbols::SavedContextVar(),
                                     Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
-  const String& catch_excp_var_name =
-      String::ZoneHandle(Symbols::ExceptionVar());
   LocalVariable* catch_excp_var =
-      current_block_->scope->LocalLookupVariable(catch_excp_var_name);
+      current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (catch_excp_var == NULL) {
     catch_excp_var = new LocalVariable(TokenPos(),
-                                       catch_excp_var_name,
+                                       Symbols::ExceptionVar(),
                                        Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_excp_var);
   }
-  const String& catch_trace_var_name =
-      String::ZoneHandle(Symbols::StacktraceVar());
   LocalVariable* catch_trace_var =
-      current_block_->scope->LocalLookupVariable(catch_trace_var_name);
+      current_block_->scope->LocalLookupVariable(Symbols::StacktraceVar());
   if (catch_trace_var == NULL) {
     catch_trace_var = new LocalVariable(TokenPos(),
-                                        catch_trace_var_name,
+                                        Symbols::StacktraceVar(),
                                         Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_trace_var);
   }
 
   const intptr_t try_pos = TokenPos();
   ConsumeToken();  // Consume the 'try'.
 
   SourceLabel* try_label = NULL;
   if (label_name != NULL) {
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
@@ skipping 344 matching lines @@
     ExpectSemicolon();
     // 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(statement_pos, "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::ExceptionVar()));
+    LocalVariable* excp_var =
+        scope->LocalLookupVariable(Symbols::ExceptionVar());
     ASSERT(excp_var != NULL);
-    LocalVariable* trace_var = scope->LocalLookupVariable(
-        String::ZoneHandle(Symbols::StacktraceVar()));
+    LocalVariable* trace_var =
+        scope->LocalLookupVariable(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 252 matching lines @@
 
 AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type) {
   ASSERT(type.IsMalformed());
   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"))));
+  arguments->Add(new LiteralNode(type_pos, Symbols::Malformed()));
   // Dst name argument.
-  arguments->Add(new LiteralNode(type_pos,
-                                 String::ZoneHandle(Symbols::Empty())));
+  arguments->Add(new LiteralNode(type_pos, 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()))));
-  const String& cls_name = String::Handle(Symbols::TypeError());
-  const String& func_name = String::Handle(Symbols::ThrowNew());
-  return MakeStaticCall(cls_name, func_name, arguments);
+  return MakeStaticCall(Symbols::TypeError(), Symbols::ThrowNew(), arguments);
 }
 
 
 // TODO(regis): Providing the argument values is not always feasible, since
 // evaluating them could throw an error.
 // Should NoSuchMethodError reflect the argument count and names instead of
 // argument values? Or should the spec specify a different evaluation order?
 AstNode* Parser::ThrowNoSuchMethodError(intptr_t call_pos,
                                         const Class& cls,
                                         const String& function_name) {
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
   // Object receiver.
   // TODO(regis): For now, we pass a class literal of the unresolved
   // method's owner, but this is not specified and will probably change.
   Type& type = Type::ZoneHandle(
       Type::New(cls, TypeArguments::Handle(), call_pos, Heap::kOld));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
   arguments->Add(new LiteralNode(call_pos, type));
   // String memberName.
   arguments->Add(new LiteralNode(
       call_pos, String::ZoneHandle(Symbols::New(function_name))));
   // List arguments.
   arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
   // List argumentNames.
   arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
   // List existingArgumentNames.
   arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
-  const String& cls_name = String::Handle(Symbols::NoSuchMethodError());
-  const String& func_name = String::Handle(Symbols::ThrowNew());
-  return MakeStaticCall(cls_name, func_name, arguments);
+  return MakeStaticCall(Symbols::NoSuchMethodError(),
+                        Symbols::ThrowNew(),
+                        arguments);
 }
 
 
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= 4);
   AstNode* left_operand = ParseUnaryExpr();
   if (left_operand->IsPrimaryNode() &&
       (left_operand->AsPrimaryNode()->IsSuper())) {
     ErrorMsg(left_operand->token_pos(), "illegal use of 'super'");
@@ skipping 529 matching lines @@
     // Check if there is a static field of the same name, it could be a closure
     // and so we try and invoke the closure.
     AstNode* closure = NULL;
     const Field& field = Field::ZoneHandle(cls.LookupStaticField(func_name));
     Function& func = Function::ZoneHandle();
     if (field.IsNull()) {
       // No field, check if we have an explicit getter function.
       const String& getter_name =
           String::ZoneHandle(Field::GetterName(func_name));
       const int kNumArguments = 0;  // no arguments.
-      const Array& kNoArgumentNames = Array::Handle();
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
                                      kNumArguments,
-                                     kNoArgumentNames,
+                                     Object::empty_array(),
                                      Resolver::kIsQualified);
       if (!func.IsNull()) {
         ASSERT(func.kind() != RawFunction::kConstImplicitGetter);
         EnsureExpressionTemp();
         closure = new StaticGetterNode(call_pos,
                                        NULL,
                                        false,
                                        Class::ZoneHandle(cls.raw()),
                                        func_name);
         return new ClosureCallNode(call_pos, closure, arguments);
@@ skipping 61 matching lines @@
   const intptr_t call_pos = TokenPos();
   const Field& field = Field::ZoneHandle(cls.LookupStaticField(field_name));
   Function& func = Function::ZoneHandle();
   if (Token::IsAssignmentOperator(CurrentToken())) {
     // Make sure an assignment is legal.
     if (field.IsNull()) {
       // No field, check if we have an explicit setter function.
       const String& setter_name =
           String::ZoneHandle(Field::SetterName(field_name));
       const int kNumArguments = 1;  // value.
-      const Array& kNoArgumentNames = Array::Handle();
       func = Resolver::ResolveStatic(cls,
                                      setter_name,
                                      kNumArguments,
-                                     kNoArgumentNames,
+                                     Object::empty_array(),
                                      Resolver::kIsQualified);
       if (func.IsNull()) {
         // No field or explicit setter function, throw a NoSuchMethodError.
         return ThrowNoSuchMethodError(ident_pos, cls, field_name);
       }
 
       // Explicit setter function for the field found, field does not exist.
       // Create a getter node first in case it is needed. If getter node
       // is used as part of, e.g., "+=", and the explicit getter does not
       // exist, and error will be reported by the code generator.
@@ skipping 12 matching lines @@
                  field_name.ToCString());
       }
       access = GenerateStaticFieldLookup(field, TokenPos());
     }
   } else {  // Not Token::IsAssignmentOperator(CurrentToken()).
     if (field.IsNull()) {
       // No field, check if we have an explicit getter function.
       const String& getter_name =
           String::ZoneHandle(Field::GetterName(field_name));
       const int kNumArguments = 0;  // no arguments.
-      const Array& kNoArgumentNames = Array::Handle();
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
                                      kNumArguments,
-                                     kNoArgumentNames,
+                                     Object::empty_array(),
                                      Resolver::kIsQualified);
       if (func.IsNull()) {
         // We might be referring to an implicit closure, check to see if
         // there is a function of the same name.
         func = cls.LookupStaticFunction(field_name);
         if (func.IsNull()) {
           // No field or explicit getter function, throw a NoSuchMethodError.
           return ThrowNoSuchMethodError(ident_pos, cls, field_name);
         }
         access = CreateImplicitClosureNode(func, call_pos, NULL);
@@ skipping 399 matching lines @@
 // Returns true if ident resolves to a formal parameter of the current function
 // or of one of its enclosing functions.
 // Make sure not to capture the formal parameter, since it is not accessed.
 bool Parser::IsFormalParameter(const String& ident,
                                Function* owner_function,
                                LocalScope** owner_scope,
                                intptr_t* local_index) {
   if (current_block_ == NULL) {
     return false;
   }
-  if (ident.Equals(Symbols::ThisHandle())) {
+  if (ident.Equals(Symbols::This())) {
     // 'this' is not a formal parameter.
     return false;
   }
   // Since an argument definition test does not use the value of the formal
   // parameter, there is no reason to capture it.
   const bool kTestOnly = true;  // No capturing.
   LocalVariable* local =
       current_block_->scope->LookupVariable(ident, kTestOnly);
   if (local == NULL) {
     if (!current_function().IsLocalFunction()) {
@@ skipping 135 matching lines @@
     // This field has not been referenced yet and thus the value has
     // not been evaluated. If the field is const, call the static getter method
     // to evaluate the expression and canonicalize the value.
     if (field.is_const()) {
       field.set_value(Object::transition_sentinel());
       const String& field_name = String::Handle(field.name());
       const String& getter_name =
           String::Handle(Field::GetterName(field_name));
       const Class& cls = Class::Handle(field.owner());
       const int kNumArguments = 0;  // no arguments.
-      const Array& kNoArgumentNames = Array::Handle();
       const Function& func =
           Function::Handle(Resolver::ResolveStatic(cls,
                                                    getter_name,
                                                    kNumArguments,
-                                                   kNoArgumentNames,
+                                                   Object::empty_array(),
                                                    Resolver::kIsQualified));
       ASSERT(!func.IsNull());
       ASSERT(func.kind() == RawFunction::kConstImplicitGetter);
       Object& const_value = Object::Handle(
           DartEntry::InvokeStatic(func, Object::empty_array()));
       if (const_value.IsError()) {
         const Error& error = Error::Cast(const_value);
         if (error.IsUnhandledException()) {
           field.set_value(Instance::Handle());
           // It is a compile-time error if evaluation of a compile-time constant
@@ skipping 630 matching lines @@
   Type& type = Type::ZoneHandle(
       Type::New(array_class, type_arguments, type_pos));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
   ArrayNode* list = new ArrayNode(TokenPos(), type);
 
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
-    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);
+                                     Symbols::ListLiteralElement());
       }
       list->AddElement(element);
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
       } else if (CurrentToken() != Token::kRBRACK) {
         ErrorMsg("comma or ']' expected");
       }
     }
     ExpectToken(Token::kRBRACK);
     SetAllowFunctionLiterals(saved_mode);
@@ skipping 26 matching lines @@
                    String::Handle(element_type.UserVisibleName()).ToCString());
         }
       }
       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& factory_class_name = String::Handle(Symbols::List());
     const Class& factory_class =
-        Class::Handle(LookupCoreClass(factory_class_name));
+        Class::Handle(LookupCoreClass(Symbols::List()));
     ASSERT(!factory_class.IsNull());
-    const String& factory_method_name =
-        String::Handle(Symbols::ListLiteralFactory());
     const Function& factory_method = Function::ZoneHandle(
-        factory_class.LookupFactory(factory_method_name));
+        factory_class.LookupFactory(Symbols::ListLiteralFactory()));
     ASSERT(!factory_method.IsNull());
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
     AbstractTypeArguments& factory_type_args =
         AbstractTypeArguments::ZoneHandle(type_arguments.raw());
     // If the factory class extends other parameterized classes, adjust the
@@ skipping 111 matching lines @@
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
   // 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(), Type::ZoneHandle(Type::ArrayType()));
 
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
-  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");
     }
     ExpectToken(Token::kCOLON);
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const intptr_t value_pos = TokenPos();
     AstNode* value = ParseExpr(is_const, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     if (FLAG_enable_type_checks &&
         !is_const &&
         !value_type.IsDynamicType()) {
       value = new AssignableNode(value_pos,
                                  value,
                                  value_type,
-                                 dst_name);
+                                 Symbols::ListLiteralElement());
     }
     AddKeyValuePair(kv_pairs, is_const, key, value);
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() != Token::kRBRACE) {
       ErrorMsg("comma or '}' expected");
     }
   }
   ASSERT(kv_pairs->length() % 2 == 0);
@@ skipping 28 matching lines @@
                    i >> 1,
                    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::ImmutableMap());
     const Class& immutable_map_class =
-        Class::Handle(LookupCoreClass(immutable_map_class_name));
+        Class::Handle(LookupCoreClass(Symbols::ImmutableMap()));
     ASSERT(!immutable_map_class.IsNull());
     // If the immutable map class extends other parameterized classes, we need
     // to adjust the type argument vector. This is currently not the case.
     ASSERT(immutable_map_class.NumTypeArguments() == 2);
     ArgumentListNode* constr_args = new ArgumentListNode(TokenPos());
     constr_args->Add(new LiteralNode(literal_pos, key_value_array));
-    const String& constr_name =
-        String::Handle(Symbols::ImmutableMapConstructor());
-    const Function& map_constr = Function::ZoneHandle(
-        immutable_map_class.LookupConstructor(constr_name));
+    const Function& map_constr =
+        Function::ZoneHandle(immutable_map_class.LookupConstructor(
+            Symbols::ImmutableMapConstructor()));
     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& factory_class_name = String::Handle(Symbols::Map());
     const Class& factory_class =
-        Class::Handle(LookupCoreClass(factory_class_name));
+        Class::Handle(LookupCoreClass(Symbols::Map()));
     ASSERT(!factory_class.IsNull());
-    const String& factory_method_name =
-        String::Handle(Symbols::MapLiteralFactory());
     const Function& factory_method = Function::ZoneHandle(
-        factory_class.LookupFactory(factory_method_name));
+        factory_class.LookupFactory(Symbols::MapLiteralFactory()));
     ASSERT(!factory_method.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
     AbstractTypeArguments& factory_type_args =
         AbstractTypeArguments::ZoneHandle(map_type_arguments.raw());
     // If the factory class extends other parameterized classes, adjust the
@@ skipping 48 matching lines @@
 }
 
 
 static const String& BuildConstructorName(const String& type_class_name,
                                           const String* named_constructor) {
   // By convention, the static function implementing a named constructor 'C'
   // for class 'A' is labeled 'A.C', and the static function implementing the
   // unnamed constructor for class 'A' is labeled 'A.'.
   // This convention prevents users from explicitly calling constructors.
   String& constructor_name =
-      String::Handle(String::Concat(type_class_name, Symbols::DotHandle()));
+      String::Handle(String::Concat(type_class_name, Symbols::Dot()));
   if (named_constructor != NULL) {
     constructor_name = String::Concat(constructor_name, *named_constructor);
   }
   return constructor_name;
 }
 
 
 AstNode* Parser::ParseNewOperator() {
   TRACE_PARSER("ParseNewOperator");
   const intptr_t new_pos = TokenPos();
@@ skipping 122 matching lines @@
 
   // It is ok to call a factory method of an abstract class, but it is
   // a dynamic error to instantiate an abstract class.
   ASSERT(!constructor.IsNull());
   if (type_class.is_abstract() && !constructor.IsFactory()) {
     ArgumentListNode* arguments = new ArgumentListNode(type_pos);
     arguments->Add(new LiteralNode(
         TokenPos(), Integer::ZoneHandle(Integer::New(type_pos))));
     arguments->Add(new LiteralNode(
         TokenPos(), String::ZoneHandle(type_class_name.raw())));
-    const String& cls_name =
-        String::Handle(Symbols::AbstractClassInstantiationError());
-    const String& func_name = String::Handle(Symbols::ThrowNew());
-    return MakeStaticCall(cls_name, func_name, arguments);
+    return MakeStaticCall(Symbols::AbstractClassInstantiationError(),
+                          Symbols::ThrowNew(),
+                          arguments);
   }
   String& error_message = String::Handle();
   if (!constructor.AreValidArguments(arguments_length,
                                      arguments->names(),
                                      &error_message)) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : type_class_name);
     if (is_const) {
       ErrorMsg(call_pos,
                "invalid arguments passed to constructor '%s' "
@@ skipping 60 matching lines @@
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
     // 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);
   }
   if (!type_bound.IsNull()) {
-    const String& dst_name = String::ZoneHandle(Symbols::FactoryResult());
-    new_object = new AssignableNode(new_pos, new_object, type_bound, dst_name);
+    new_object = new AssignableNode(new_pos,
+                                    new_object,
+                                    type_bound,
+                                    Symbols::FactoryResult());
   }
   return new_object;
 }
 
 
 String& Parser::Interpolate(ArrayNode* values) {
-  const String& class_name = String::Handle(Symbols::StringBase());
-  const Class& cls = Class::Handle(LookupCoreClass(class_name));
+  const Class& cls = Class::Handle(LookupCoreClass(Symbols::StringBase()));
   ASSERT(!cls.IsNull());
-  const String& func_name = String::Handle(Symbols::Interpolate());
   const Function& func =
-      Function::Handle(cls.LookupStaticFunction(func_name));
+      Function::Handle(cls.LookupStaticFunction(Symbols::Interpolate()));
   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());
   }
 
   // Build argument array to pass to the interpolation function.
@@ skipping 70 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);
-    const String& cls_name = String::Handle(Symbols::StringBase());
-    const String& func_name = String::Handle(Symbols::Interpolate());
-    primary = MakeStaticCall(cls_name, func_name, interpolate_arg);
+    primary = MakeStaticCall(Symbols::StringBase(),
+                             Symbols::Interpolate(),
+                             interpolate_arg);
   }
   return primary;
 }
 
 
 AstNode* Parser::ParseArgumentDefinitionTest() {
   const intptr_t test_pos = TokenPos();
   ConsumeToken();
   const intptr_t ident_pos = TokenPos();
   String* ident = ExpectIdentifier("parameter name expected");
   Function& owner_function = Function::Handle();
   LocalScope* owner_scope;
   intptr_t param_index;
   if (!IsFormalParameter(*ident, &owner_function, &owner_scope, &param_index)) {
     ErrorMsg(ident_pos, "formal parameter name expected");
   }
   if (param_index < owner_function.num_fixed_parameters()) {
     // The formal parameter is not optional, therefore the corresponding
     // argument is always passed and defined.
     return new LiteralNode(test_pos, Bool::ZoneHandle(Bool::True()));
   }
   char name[64];
   OS::SNPrint(name, 64, "%s_%"Pd"",
-              Symbols::Name(Symbols::kSavedArgDescVarPrefix),
+              Symbols::Name(Symbols::kSavedArgDescVarPrefixId),
               owner_function.token_pos());
   const String& saved_args_desc_name = String::ZoneHandle(Symbols::New(name));
   LocalVariable* saved_args_desc_var = LookupLocalScope(saved_args_desc_name);
   if (saved_args_desc_var == NULL) {
     ASSERT(owner_scope != NULL);
     saved_args_desc_var =
         new LocalVariable(owner_function.token_pos(),
                           saved_args_desc_name,
                           Type::ZoneHandle(Type::ArrayType()));
     saved_args_desc_var->set_is_final();
@@ skipping 58 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 = ResolveIdentInPrefixScope(qual_ident.ident_pos,
                                           *qual_ident.lib_prefix,
                                           *qual_ident.ident);
     }
     ASSERT(primary != NULL);
   } else if (CurrentToken() == Token::kTHIS) {
-    LocalVariable* local = LookupLocalScope(Symbols::ThisHandle());
+    LocalVariable* local = LookupLocalScope(Symbols::This());
     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();
   } else if (CurrentToken() == Token::kTRUE) {
@@ skipping 51 matching lines @@
       if (CurrentToken() == Token::kLPAREN) {
         primary = ParseSuperCall(ident);
       } else {
         primary = ParseSuperFieldAccess(ident);
       }
     } else if ((CurrentToken() == Token::kLBRACK) ||
         Token::CanBeOverloaded(CurrentToken()) ||
         (CurrentToken() == Token::kNE)) {
       primary = ParseSuperOperator();
     } else {
-      primary = new PrimaryNode(TokenPos(),
-                                String::ZoneHandle(Symbols::Super()));
+      primary = new PrimaryNode(TokenPos(), Symbols::Super());
     }
   } else if (CurrentToken() == Token::kCONDITIONAL) {
     primary = ParseArgumentDefinitionTest();
   } else {
     UnexpectedToken();
   }
   return primary;
 }
 
 
@@ skipping 305 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart