- Refactor Symbol allocation to expect a thread parameter.

runtime/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/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 168 matching lines @@
   }
   ASSERT(has_expression_temp_var());
   return expression_temp_var();
 }
 
 
 void ParsedFunction::EnsureFinallyReturnTemp(bool is_async) {
   if (!has_finally_return_temp_var()) {
     LocalVariable* temp = new(Z) LocalVariable(
         function_.token_pos(),
-        String::ZoneHandle(Z, Symbols::New(":finally_ret_val")),
+        Symbols::FinallyRetVal(),
         Object::dynamic_type());
     ASSERT(temp != NULL);
     temp->set_is_final();
     if (is_async) {
       temp->set_is_captured();
     }
     set_finally_return_temp_var(temp);
   }
   ASSERT(has_finally_return_temp_var());
 }
@@ skipping 1026 matching lines @@
 
 
 ParsedFunction* Parser::ParseStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   Thread* thread = Thread::Current();
   // TODO(koda): Should there be a StackZone here?
   Zone* zone = thread->zone();
 
   const String& field_name = String::Handle(zone, field.name());
   String& init_name = String::Handle(zone,
-      Symbols::FromConcat(Symbols::InitPrefix(), field_name));
+      Symbols::FromConcat(thread, Symbols::InitPrefix(), field_name));
 
   const Script& script = Script::Handle(zone, field.Script());
   Object& initializer_owner = Object::Handle(field.Owner());
   initializer_owner =
       PatchClass::New(Class::Handle(field.Owner()), script);
 
   const Function& initializer = Function::ZoneHandle(zone,
       Function::New(init_name,
                     RawFunction::kImplicitStaticFinalGetter,
                     true,   // static
@@ skipping 320 matching lines @@
   ParamList params;
   // Receiver first.
   TokenPosition token_pos = func.token_pos();
   params.AddReceiver(ReceiverType(current_class()), token_pos);
   // Remaining positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); ++i) {
     ParamDesc p;
     char name[64];
     OS::SNPrint(name, 64, ":p%" Pd, i);
-    p.name = &String::ZoneHandle(Z, Symbols::New(name));
+    p.name = &String::ZoneHandle(Z, Symbols::New(T, name));
     p.type = &Object::dynamic_type();
     params.parameters->Add(p);
     params.num_fixed_parameters++;
   }
   ASSERT(desc.PositionalCount() == params.num_fixed_parameters);
 
   // Named parameters.
   for (; i < desc.Count(); ++i) {
     ParamDesc p;
     intptr_t index = i - desc.PositionalCount();
@@ skipping 93 matching lines @@
       Isolate::Current()->object_store()->closure_class());
 
   const Class& owner = Class::Handle(Z, func.Owner());
   ASSERT(!owner.IsNull());
   const String& name = String::Handle(Z, func.name());
   AstNode* function_object = NULL;
   if (owner.raw() == closure_cls.raw() && name.Equals(Symbols::Call())) {
     function_object = receiver;
   } else {
     const String& getter_name = String::ZoneHandle(Z,
-        Symbols::New(String::Handle(Z, Field::GetterSymbol(name))));
+        Field::GetterSymbol(name));
     function_object = new(Z) InstanceCallNode(
         token_pos, receiver, getter_name, no_args);
   }
 
   // Pass arguments 1..n to the closure call.
   ArgumentListNode* args = new(Z) ArgumentListNode(token_pos);
   const Array& names = Array::Handle(
       Z, Array::New(desc.NamedCount(), Heap::kOld));
   // Positional parameters.
   intptr_t i = 1;
@@ skipping 382 matching lines @@
                                       const String& name,
                                       ArgumentListNode* arguments,
                                       bool resolve_getter,
                                       bool* is_no_such_method) {
   const Class& super_class = Class::Handle(Z, current_class().SuperClass());
   if (super_class.IsNull()) {
     ReportError(token_pos, "class '%s' does not have a superclass",
                 String::Handle(Z, current_class().Name()).ToCString());
   }
   Function& super_func = Function::Handle(Z,
-      Resolver::ResolveDynamicAnyArgs(super_class, name));
+      Resolver::ResolveDynamicAnyArgs(Z, super_class, name));
   if (!super_func.IsNull() &&
       !super_func.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     NULL)) {
     super_func = Function::null();
   } else if (super_func.IsNull() && resolve_getter) {
     const String& getter_name = String::ZoneHandle(Z, Field::GetterName(name));
-    super_func = Resolver::ResolveDynamicAnyArgs(super_class, getter_name);
+    super_func = Resolver::ResolveDynamicAnyArgs(Z, super_class, getter_name);
     ASSERT(super_func.IsNull() ||
            (super_func.kind() != RawFunction::kImplicitStaticFinalGetter));
   }
   if (super_func.IsNull()) {
-    super_func =
-        Resolver::ResolveDynamicAnyArgs(super_class, Symbols::NoSuchMethod());
+    super_func = Resolver::ResolveDynamicAnyArgs(Z,
+        super_class, Symbols::NoSuchMethod());
     ASSERT(!super_func.IsNull());
     *is_no_such_method = true;
   } else {
     *is_no_such_method = false;
   }
   return super_func.raw();
 }
 
 
 StaticCallNode* Parser::BuildInvocationMirrorAllocation(
@@ skipping 113 matching lines @@
 }
 
 
 AstNode* Parser::BuildUnarySuperOperator(Token::Kind op, PrimaryNode* super) {
   ASSERT(super->IsSuper());
   AstNode* super_op = NULL;
   const TokenPosition super_pos = super->token_pos();
   if ((op == Token::kNEGATE) ||
       (op == Token::kBIT_NOT)) {
     // Resolve the operator function in the superclass.
-    const String& operator_function_name =
-        String::ZoneHandle(Z, Symbols::New(Token::Str(op)));
+    const String& operator_function_name = Symbols::Token(op);
     ArgumentListNode* op_arguments = new ArgumentListNode(super_pos);
     AstNode* receiver = LoadReceiver(super_pos);
     op_arguments->Add(receiver);
     const bool kResolveGetter = false;
     bool is_no_such_method = false;
     const Function& super_operator = Function::ZoneHandle(Z,
         GetSuperFunction(super_pos,
                          operator_function_name,
                          op_arguments,
                          kResolveGetter,
@@ skipping 39 matching lines @@
 
     ASSERT(Token::Precedence(op) >= Token::Precedence(Token::kEQ));
     AstNode* other_operand = ParseBinaryExpr(Token::Precedence(op) + 1);
 
     ArgumentListNode* op_arguments = new ArgumentListNode(operator_pos);
     AstNode* receiver = LoadReceiver(operator_pos);
     op_arguments->Add(receiver);
     op_arguments->Add(other_operand);
 
     // Resolve the operator function in the superclass.
-    const String& operator_function_name =
-        String::ZoneHandle(Z, Symbols::New(Token::Str(op)));
+    const String& operator_function_name = Symbols::Token(op);
     const bool kResolveGetter = false;
     bool is_no_such_method = false;
     const Function& super_operator = Function::ZoneHandle(Z,
         GetSuperFunction(operator_pos,
                          operator_function_name,
                          op_arguments,
                          kResolveGetter,
                          &is_no_such_method));
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(
@@ skipping 37 matching lines @@
   if (super_class.IsNull()) {
     ReportError("class '%s' does not have a superclass",
                 String::Handle(Z, current_class().Name()).ToCString());
   }
   AstNode* implicit_argument = LoadReceiver(field_pos);
 
   const String& getter_name =
       String::ZoneHandle(Z, Field::LookupGetterSymbol(field_name));
   Function& super_getter = Function::ZoneHandle(Z);
   if (!getter_name.IsNull()) {
-    super_getter = Resolver::ResolveDynamicAnyArgs(super_class, getter_name);
+    super_getter = Resolver::ResolveDynamicAnyArgs(Z, super_class, getter_name);
   }
   if (super_getter.IsNull()) {
     const String& setter_name =
         String::ZoneHandle(Z, Field::LookupSetterSymbol(field_name));
     Function& super_setter = Function::ZoneHandle(Z);
     if (!setter_name.IsNull()) {
-      super_setter = Resolver::ResolveDynamicAnyArgs(super_class, setter_name);
+      super_setter = Resolver::ResolveDynamicAnyArgs(Z,
+          super_class, setter_name);
     }
     if (super_setter.IsNull()) {
       // Check if this is an access to an implicit closure using 'super'.
       // If a function exists of the specified field_name then try
       // accessing it as a getter, at runtime we will handle this by
       // creating an implicit closure of the function and returning it.
       const Function& super_function = Function::ZoneHandle(Z,
-          Resolver::ResolveDynamicAnyArgs(super_class, field_name));
+          Resolver::ResolveDynamicAnyArgs(Z, super_class, field_name));
       if (!super_function.IsNull()) {
         // In case CreateAssignmentNode is called later on this
         // CreateImplicitClosureNode, it will be replaced by a StaticSetterNode.
         return CreateImplicitClosureNode(super_function,
                                          field_pos,
                                          implicit_argument);
       }
       // No function or field exists of the specified field_name.
       // Emit a StaticGetterNode anyway, so that noSuchMethod gets called.
     }
@@ skipping 11 matching lines @@
   const Class& super_class = Class::Handle(Z, 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(Z, super_class.SuperClass()).IsObjectClass())) {
     return NULL;
   }
   String& super_ctor_name = String::Handle(Z, super_class.Name());
-  super_ctor_name = Symbols::FromConcat(super_ctor_name, Symbols::Dot());
+  super_ctor_name = Symbols::FromDot(T, super_ctor_name);
 
   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);
 
   // If this is a super call in a forwarding constructor, add the user-
   // defined arguments to the super call and adjust the the super
   // constructor name to the respective named constructor if necessary.
   if (forwarding_args != NULL) {
     for (int i = 0; i < forwarding_args->length(); i++) {
       arguments->Add(forwarding_args->NodeAt(i));
     }
     String& ctor_name = String::Handle(Z, current_function().name());
     String& class_name = String::Handle(Z, cls.Name());
     if (ctor_name.Length() > class_name.Length() + 1) {
       // Generating a forwarding call to a named constructor 'C.n'.
       // Add the constructor name 'n' to the super constructor.
       const intptr_t kLen =  class_name.Length() + 1;
-      ctor_name = Symbols::New(ctor_name, kLen, ctor_name.Length() - kLen);
-      super_ctor_name = Symbols::FromConcat(super_ctor_name, ctor_name);
+      ctor_name = Symbols::New(T, ctor_name, kLen, ctor_name.Length() - kLen);
+      super_ctor_name = Symbols::FromConcat(T, super_ctor_name, ctor_name);
     }
   }
 
   // Resolve super constructor function and check arguments.
   const Function& super_ctor = Function::ZoneHandle(Z,
       super_class.LookupConstructor(super_ctor_name));
   if (super_ctor.IsNull()) {
       ReportError(supercall_pos,
                   "unresolved implicit call to super constructor '%s()'",
                   String::Handle(Z, super_class.Name()).ToCString());
@@ skipping 17 matching lines @@
 
 StaticCallNode* Parser::ParseSuperInitializer(const Class& cls,
                                               LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
   ASSERT(CurrentToken() == Token::kSUPER);
   const TokenPosition supercall_pos = TokenPos();
   ConsumeToken();
   const Class& super_class = Class::Handle(Z, cls.SuperClass());
   ASSERT(!super_class.IsNull());
   String& ctor_name = String::Handle(Z, super_class.Name());
-  ctor_name = Symbols::FromConcat(ctor_name, Symbols::Dot());
+  ctor_name = String::Concat(ctor_name, Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
-    ctor_name = Symbols::FromConcat(
+    ctor_name = Symbols::FromConcat(T,
         ctor_name, *ExpectIdentifier("constructor name expected"));
   }
   CheckToken(Token::kLPAREN, "parameter list expected");
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super class constructor.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
 
   // 'this' parameter must not be accessible to the other super call arguments.
@@ skipping 373 matching lines @@
   const TokenPosition call_pos = TokenPos();
   ConsumeToken();
   String& ctor_name = String::Handle(Z, cls.Name());
   GrowableHandlePtrArray<const String> pieces(Z, 3);
   pieces.Add(ctor_name);
   pieces.Add(Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     pieces.Add(*ExpectIdentifier("constructor name expected"));
   }
-  ctor_name = Symbols::FromConcatAll(pieces);
+  ctor_name = Symbols::FromConcatAll(T, pieces);
   CheckToken(Token::kLPAREN, "parameter list expected");
 
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
   // 'this' parameter is the first argument to constructor.
   AstNode* implicit_argument = new LoadLocalNode(call_pos, receiver);
   arguments->Add(implicit_argument);
 
   receiver->set_invisible(true);
   ParseActualParameters(arguments, kAllowConst);
   receiver->set_invisible(false);
@@ skipping 739 matching lines @@
   }
 
   // Now that we know the parameter list, we can distinguish between the
   // unary and binary operator -.
   if (method->has_operator) {
     if ((method->operator_token == Token::kSUB) &&
        (method->params.num_fixed_parameters == 1)) {
       // Patch up name for unary operator - so it does not clash with the
       // name for binary operator -.
       method->operator_token = Token::kNEGATE;
-      *method->name = Symbols::New(Token::Str(Token::kNEGATE));
+      *method->name = Symbols::Token(Token::kNEGATE).raw();
     }
     CheckOperatorArity(*method);
   }
 
   // Mangle the name for getter and setter functions and check function
   // arity.
   if (method->IsGetter() || method->IsSetter()) {
     int expected_num_parameters = 0;
     if (method->IsGetter()) {
       expected_num_parameters = (method->has_static) ? 0 : 1;
       method->dict_name = method->name;
       method->name = &String::ZoneHandle(Z, Field::GetterSymbol(*method->name));
     } else {
       ASSERT(method->IsSetter());
       expected_num_parameters = (method->has_static) ? 1 : 2;
       method->dict_name = &String::ZoneHandle(Z,
-          Symbols::FromConcat(*method->name, Symbols::Equals()));
+          Symbols::FromConcat(T, *method->name, Symbols::Equals()));
       method->name = &String::ZoneHandle(Z, Field::SetterSymbol(*method->name));
     }
     if ((method->params.num_fixed_parameters != expected_num_parameters) ||
         (method->params.num_optional_parameters != 0)) {
       ReportError(method->name_pos, "illegal %s parameters",
                   method->IsGetter() ? "getter" : "setter");
     }
   }
 
   // Parse redirecting factory constructor.
@@ skipping 64 matching lines @@
       ConsumeToken();  // Colon.
       ExpectToken(Token::kTHIS);
       GrowableHandlePtrArray<const String> pieces(Z, 3);
       pieces.Add(members->class_name());
       pieces.Add(Symbols::Dot());
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         pieces.Add(*ExpectIdentifier("constructor name expected"));
       }
       String& redir_name =
-          String::ZoneHandle(Z, Symbols::FromConcatAll(pieces));
+          String::ZoneHandle(Z, Symbols::FromConcatAll(T, pieces));
 
       method->redirect_name = &redir_name;
       CheckToken(Token::kLPAREN);
       SkipToMatchingParenthesis();
     } else {
       SkipInitializers();
     }
   }
 
   // Only constructors can redirect to another method.
@@ skipping 510 matching lines @@
     member.kind = RawFunction::kConstructor;
     GrowableHandlePtrArray<const String> to_concat(Z, 3);
     to_concat.Add(*member.name);
     to_concat.Add(Symbols::Dot());
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       member.dict_name = ExpectIdentifier("identifier expected");
       to_concat.Add(*member.dict_name);
     }
-    *member.name = Symbols::FromConcatAll(to_concat);
+    *member.name = Symbols::FromConcatAll(T, to_concat);
     CheckToken(Token::kLPAREN);
   } else if ((CurrentToken() == Token::kGET) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON)) {
     ConsumeToken();
     member.kind = RawFunction::kGetterFunction;
     member.name_pos = this->TokenPos();
     member.name = ExpectIdentifier("identifier expected");
@@ skipping 22 matching lines @@
     if (!Token::CanBeOverloaded(CurrentToken())) {
       ReportError("invalid operator overloading");
     }
     if (member.has_static) {
       ReportError("operator overloading functions cannot be static");
     }
     member.operator_token = CurrentToken();
     member.has_operator = true;
     member.kind = RawFunction::kRegularFunction;
     member.name_pos = this->TokenPos();
-    member.name =
-        &String::ZoneHandle(Z, Symbols::New(Token::Str(member.operator_token)));
+    member.name = &String::ZoneHandle(Z, Symbols::Token(member.operator_token));
     ConsumeToken();
   } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
     member.name_pos = TokenPos();
     ConsumeToken();
   } else {
     ReportError("identifier expected");
   }
 
   ASSERT(member.name != NULL);
@@ skipping 439 matching lines @@
     const Smi& ordinal_value = Smi::Handle(Z, Smi::New(i));
     enum_value.SetStaticValue(ordinal_value, true);
     enum_value.RecordStore(ordinal_value);
     i++;
 
     // For the user-visible name of the enumeration value, we need to
     // unmangle private names.
     if (enum_ident->CharAt(0) == '_') {
       *enum_ident = String::ScrubName(*enum_ident);
     }
-    enum_value_name = Symbols::FromConcat(name_prefix, *enum_ident);
+    enum_value_name = Symbols::FromConcat(T, name_prefix, *enum_ident);
     enum_names.Add(enum_value_name, Heap::kOld);
 
     ConsumeToken();  // Enum value name.
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     }
   }
   ExpectToken(Token::kRBRACE);
 
   const Class& helper_class =
@@ skipping 46 matching lines @@
   cls.AddFields(enum_members.fields());
   const Array& functions = Array::Handle(Z, enum_members.MakeFunctionsArray());
   cls.SetFunctions(functions);
 }
 
 
 // Add an implicit constructor to the given class.
 void Parser::AddImplicitConstructor(const Class& cls) {
   // The implicit constructor is unnamed, has no explicit parameter.
   String& ctor_name = String::ZoneHandle(Z, cls.Name());
-  ctor_name = Symbols::FromConcat(ctor_name, Symbols::Dot());
+  ctor_name = Symbols::FromDot(T, ctor_name);
   // To indicate that this is an implicit constructor, we set the
   // token position and end token position of the function
   // to the token position of the class.
   Function& ctor = Function::Handle(Z,
       Function::New(ctor_name,
                     RawFunction::kConstructor,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
@@ skipping 931 matching lines @@
   ConsumeToken();
   String& lib_name = *ExpectIdentifier("library name expected");
   if (CurrentToken() == Token::kPERIOD) {
     GrowableHandlePtrArray<const String> pieces(Z, 3);
     pieces.Add(lib_name);
     while (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       pieces.Add(Symbols::Dot());
       pieces.Add(*ExpectIdentifier("malformed library name"));
     }
-    lib_name = Symbols::FromConcatAll(pieces);
+    lib_name = Symbols::FromConcatAll(T, pieces);
   }
   library_.SetName(lib_name);
   ExpectSemicolon();
 }
 
 
 void Parser::ParseIdentList(GrowableObjectArray* names) {
   if (!IsIdentifier()) {
     ReportError("identifier expected");
   }
@@ skipping 789 matching lines @@
   const Function& found_func = Function::Handle(
       Z, I->LookupClosureFunction(innermost_function(), func_pos));
   if (!found_func.IsNull()) {
     ASSERT(found_func.IsSyncGenClosure());
     body = found_func.raw();
     body_closure_name = body.name();
   } else {
     // Create the closure containing the body of this generator function.
     String& generator_name = String::Handle(Z, innermost_function().name());
     body_closure_name =
-        Symbols::NewFormatted("<%s_sync_body>", generator_name.ToCString());
-    body_closure_name = Symbols::New(body_closure_name);
+        Symbols::NewFormatted(T, "<%s_sync_body>", generator_name.ToCString());
     body = Function::NewClosureFunction(body_closure_name,
                                         innermost_function(),
                                         func_pos);
     body.set_is_generated_body(true);
     body.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
 
   ParamList closure_params;
   AddSyncGenClosureParameters(&closure_params);
@@ skipping 110 matching lines @@
   // compilation of this function.
   const Function& found_func = Function::Handle(
       Z, I->LookupClosureFunction(innermost_function(), async_func_pos));
   if (!found_func.IsNull()) {
     ASSERT(found_func.IsAsyncClosure());
     closure = found_func.raw();
   } else {
     // Create the closure containing the body of this async function.
     const String& async_func_name =
         String::Handle(Z, innermost_function().name());
-    String& closure_name = String::Handle(Z,
-        Symbols::NewFormatted("<%s_async_body>", async_func_name.ToCString()));
+    String& closure_name = String::Handle(Z, Symbols::NewFormatted(T,
+        "<%s_async_body>", async_func_name.ToCString()));
     closure = Function::NewClosureFunction(
         closure_name,
         innermost_function(),
         async_func_pos);
     closure.set_is_generated_body(true);
     closure.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
   // Create the parameter list for the async body closure.
   ParamList closure_params;
@@ skipping 111 matching lines @@
   // compilation of this function.
   const Function& found_func = Function::Handle(
       Z, I->LookupClosureFunction(innermost_function(), async_func_pos));
   if (!found_func.IsNull()) {
     ASSERT(found_func.IsAsyncGenClosure());
     closure = found_func.raw();
   } else {
     // Create the closure containing the body of this async generator function.
     const String& async_generator_name =
         String::Handle(Z, innermost_function().name());
-    String& closure_name = String::Handle(Z,
-        Symbols::NewFormatted("<%s_async_gen_body>",
-                              async_generator_name.ToCString()));
-    closure = Function::NewClosureFunction(
-        String::Handle(Z, Symbols::New(closure_name)),
-        innermost_function(),
-        async_func_pos);
+    const String& closure_name = String::Handle(Z, Symbols::NewFormatted(T,
+          "<%s_async_gen_body>", async_generator_name.ToCString()));
+    closure = Function::NewClosureFunction(closure_name,
+                                           innermost_function(),
+                                           async_func_pos);
     closure.set_is_generated_body(true);
     closure.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
 
   ParamList closure_params;
   AddAsyncGenClosureParameters(&closure_params);
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
@@ skipping 1281 matching lines @@
     SequenceNode* sequence = CloseBlock();
     sequence->set_label(label);
     if_node = sequence;
   }
   return if_node;
 }
 
 
 // Return true if the type class of the given value implements the
 // == operator.
-static bool ImplementsEqualOperator(const Instance& value) {
+static bool ImplementsEqualOperator(Zone* zone, const Instance& value) {
   Class& cls = Class::Handle(value.clazz());
-  const Function& equal_op = Function::Handle(
-      Resolver::ResolveDynamicAnyArgs(cls, Symbols::EqualOperator()));
+  const Function& equal_op = Function::Handle(zone,
+      Resolver::ResolveDynamicAnyArgs(zone, cls, Symbols::EqualOperator()));
   ASSERT(!equal_op.IsNull());
   cls = equal_op.Owner();
   return !cls.IsObjectClass();
 }
 
 
 // Check that all case expressions are of the same type, either int, String,
 // or any other class that does not override the == operator.
 // The expressions are compile-time constants and are thus in the form
 // of a LiteralNode.
@@ skipping 26 matching lines @@
       ReportError(val_pos, "all case expressions must be of same type");
     }
     if (val.clazz() == I->object_store()->symbol_class()) {
       continue;
     }
     if (i == 0) {
       // The value is of some type other than int, String or double.
       // Check that the type class does not override the == operator.
       // Check this only in the first loop iteration since all values
       // are of the same type, which we check above.
-      if (ImplementsEqualOperator(val)) {
+      if (ImplementsEqualOperator(Z, val)) {
         ReportError(val_pos,
                     "type class of case expression must not "
                     "implement operator ==");
       }
     }
   }
   if (first_value.IsInteger()) {
     return Type::Handle(Z, Type::IntType()).type_class();
   } else if (first_value.IsString()) {
     return Type::Handle(Z, Type::StringType()).type_class();
@@ skipping 231 matching lines @@
 
 
 static LocalVariable* LookupSavedTryContextVar(LocalScope* scope) {
   LocalVariable* var =
       scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   ASSERT((var != NULL) && !var->is_captured());
   return var;
 }
 
 
-static LocalVariable* LookupAsyncSavedTryContextVar(LocalScope* scope,
+static LocalVariable* LookupAsyncSavedTryContextVar(Thread* thread,
+                                                    LocalScope* scope,
                                                     uint16_t try_index) {
-  const String& async_saved_try_ctx_name =
-      String::ZoneHandle(Symbols::NewFormatted(
-          "%s%d",
-          Symbols::AsyncSavedTryCtxVarPrefix().ToCString(),
-          try_index));
+  Zone* zone = thread->zone();
+  const String& async_saved_try_ctx_name = String::ZoneHandle(zone,
+      Symbols::NewFormatted(thread,
+                            "%s%d",
+                            Symbols::AsyncSavedTryCtxVarPrefix().ToCString(),
+                            try_index));
   LocalVariable* var = scope->LocalLookupVariable(async_saved_try_ctx_name);
   ASSERT(var != NULL);
   return var;
 }
 
 
 // If the await or yield being parsed is in a try block, the continuation code
 // needs to restore the corresponding stack-based variable :saved_try_ctx_var,
 // and the stack-based variable :saved_try_ctx_var of the outer try block.
 // The inner :saved_try_ctx_var is used by a finally clause handling an
@@ skipping 17 matching lines @@
   *outer_saved_try_ctx = NULL;
   *outer_async_saved_try_ctx = NULL;
   if (try_stack_ != NULL) {
     LocalScope* scope = try_stack_->try_block()->scope;
     uint16_t try_index = try_stack_->try_index();
     const int current_function_level = current_block_->scope->function_level();
     if (scope->function_level() == current_function_level) {
       // The block declaring :saved_try_ctx_var variable is the parent of the
       // pushed try block.
       *saved_try_ctx = LookupSavedTryContextVar(scope->parent());
-      *async_saved_try_ctx = LookupAsyncSavedTryContextVar(async_temp_scope_,
-                                                           try_index);
+      *async_saved_try_ctx = LookupAsyncSavedTryContextVar(T,
+          async_temp_scope_, try_index);
       if ((try_stack_->outer_try() != NULL) && !try_stack_->inside_finally()) {
         // Collecting the outer try scope is not necessary if we
         // are in a finally block.
         scope = try_stack_->outer_try()->try_block()->scope;
         try_index = try_stack_->outer_try()->try_index();
         if (scope->function_level() == current_function_level) {
           *outer_saved_try_ctx = LookupSavedTryContextVar(scope->parent());
-          *outer_async_saved_try_ctx =
-              LookupAsyncSavedTryContextVar(async_temp_scope_, try_index);
+          *outer_async_saved_try_ctx = LookupAsyncSavedTryContextVar(T,
+              async_temp_scope_, try_index);
         }
       }
     }
   }
   // An async or async* has an implicitly created try-catch around the
   // function body, so the await or yield inside the async closure should always
   // be created with a try scope.
   ASSERT((*saved_try_ctx != NULL) ||
          innermost_function().IsAsyncFunction() ||
          innermost_function().IsAsyncGenerator() ||
          innermost_function().IsSyncGenClosure() ||
          innermost_function().IsSyncGenerator());
 }
 
 
 // Build an AST node for static call to Dart function print(str).
 // Used during debugging to insert print in generated dart code.
 AstNode* Parser::DartPrint(const char* str) {
   const Library& lib = Library::Handle(Library::CoreLibrary());
   const Function& print_fn = Function::ZoneHandle(
       Z, lib.LookupFunctionAllowPrivate(Symbols::print()));
   ASSERT(!print_fn.IsNull());
   ArgumentListNode* one_arg =
       new(Z) ArgumentListNode(TokenPosition::kNoSource);
-  String& msg = String::ZoneHandle(Symbols::NewFormatted("%s", str));
+  String& msg = String::ZoneHandle(Symbols::NewFormatted(T, "%s", str));
   one_arg->Add(new(Z) LiteralNode(TokenPosition::kNoSource, msg));
   AstNode* print_call =
       new(Z) StaticCallNode(TokenPosition::kNoSource, print_fn, one_arg);
   return print_call;
 }
 
 
 AstNode* Parser::ParseAwaitForStatement(String* label_name) {
   TRACE_PARSER("ParseAwaitForStatement");
   ASSERT(IsAwaitKeyword());
@@ skipping 639 matching lines @@
   }
   // In case of async closures we need to restore the saved try context of an
   // outer try block (if it exists).  The current try block has already been
   // removed from the stack of try blocks.
   if (is_async) {
     if (try_stack_ != NULL) {
       LocalScope* scope = try_stack_->try_block()->scope;
       if (scope->function_level() == current_block_->scope->function_level()) {
         LocalVariable* saved_try_ctx =
             LookupSavedTryContextVar(scope->parent());
-        LocalVariable* async_saved_try_ctx =
-            LookupAsyncSavedTryContextVar(async_temp_scope_,
-                                          try_stack_->try_index());
+        LocalVariable* async_saved_try_ctx = LookupAsyncSavedTryContextVar(T,
+            async_temp_scope_, try_stack_->try_index());
         current_block_->statements->Add(
             new (Z) StoreLocalNode(
                 TokenPosition::kNoSource,
                 saved_try_ctx,
                 new (Z) LoadLocalNode(TokenPosition::kNoSource,
                                       async_saved_try_ctx)));
       }
     }
     // We need to save the exception variables as in catch clauses, whether
     // there is an outer try or not. Note that this is only necessary if the
@@ skipping 250 matching lines @@
   // the catch clauses.
   if (is_async && (current != NULL)) {
     ASSERT(try_stack_ != NULL);
     SequenceNode* async_code = new(Z) SequenceNode(handler_pos, NULL);
     const TryStack* try_block = try_stack_->outer_try();
     if (try_block != NULL) {
       LocalScope* scope = try_block->try_block()->scope;
       if (scope->function_level() == current_block_->scope->function_level()) {
         LocalVariable* saved_try_ctx =
             LookupSavedTryContextVar(scope->parent());
-        LocalVariable* async_saved_try_ctx =
-            LookupAsyncSavedTryContextVar(async_temp_scope_,
-                                          try_block->try_index());
+        LocalVariable* async_saved_try_ctx = LookupAsyncSavedTryContextVar(T,
+            async_temp_scope_, try_block->try_index());
         async_code->Add(
             new (Z) StoreLocalNode(
                 TokenPosition::kNoSource,
                 saved_try_ctx,
                 new (Z) LoadLocalNode(TokenPosition::kNoSource,
                                       async_saved_try_ctx)));
       }
     }
     SaveExceptionAndStacktrace(async_code,
                                exception_var,
                                stack_trace_var,
                                rethrow_exception_var,
                                rethrow_stack_trace_var);
     // The async_code node sequence contains code to restore the context (if
     // an outer try block is present) and code to save the exception and
     // stack trace variables.
     // This async code is inserted before the current node sequence containing
     // the chain of if/then/else handling all catch clauses.
     async_code->Add(current);
     current = async_code;
   }
   return current;
 }
 
 
 void Parser::SetupSavedTryContext(LocalVariable* saved_try_context) {
   const String& async_saved_try_ctx_name = String::ZoneHandle(Z,
-      Symbols::NewFormatted("%s%d",
-                           Symbols::AsyncSavedTryCtxVarPrefix().ToCString(),
-                           last_used_try_index_ - 1));
+      Symbols::NewFormatted(T,
+                            "%s%d",
+                            Symbols::AsyncSavedTryCtxVarPrefix().ToCString(),
+                            last_used_try_index_ - 1));
   LocalVariable* async_saved_try_ctx = new (Z) LocalVariable(
       TokenPosition::kNoSource,
       async_saved_try_ctx_name,
       Object::dynamic_type());
   ASSERT(async_temp_scope_ != NULL);
   async_temp_scope_->AddVariable(async_saved_try_ctx);
   ASSERT(saved_try_context != NULL);
   current_block_->statements->Add(new(Z) StoreLocalNode(
       TokenPosition::kNoSource,
       async_saved_try_ctx,
@@ skipping 817 matching lines @@
     arguments->Add(LoadReceiver(func->token_pos()));
   } else {
     AbstractType& type = AbstractType::ZoneHandle(Z);
     type ^= Type::New(cls, TypeArguments::Handle(Z), call_pos, Heap::kOld);
     type ^= ClassFinalizer::FinalizeType(
         current_class(), type, ClassFinalizer::kCanonicalize);
     arguments->Add(new(Z) LiteralNode(call_pos, type));
   }
   // String memberName.
   arguments->Add(new(Z) LiteralNode(
-      call_pos, String::ZoneHandle(Z, Symbols::New(function_name))));
+      call_pos, String::ZoneHandle(Z, Symbols::New(T, function_name))));
   // Smi invocation_type.
   if (cls.IsTopLevel()) {
     ASSERT(im_call == InvocationMirror::kStatic ||
            im_call == InvocationMirror::kTopLevel);
     im_call = InvocationMirror::kTopLevel;
   }
   arguments->Add(new(Z) LiteralNode(call_pos, Smi::ZoneHandle(Z,
       Smi::New(InvocationMirror::EncodeType(im_call, im_type)))));
   // List arguments.
   if (function_arguments == NULL) {
@@ skipping 147 matching lines @@
   parsed_function()->EnsureExpressionTemp();
 }
 
 
 LocalVariable* Parser::CreateTempConstVariable(TokenPosition token_pos,
                                                const char* s) {
   char name[64];
   OS::SNPrint(name, 64, ":%s%" Pd "", s, token_pos.value());
   LocalVariable* temp = new(Z) LocalVariable(
       token_pos,
-      String::ZoneHandle(Z, Symbols::New(name)),
+      String::ZoneHandle(Z, Symbols::New(T, name)),
       Object::dynamic_type());
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
 }
 
 
 // TODO(srdjan): Implement other optimizations.
 AstNode* Parser::OptimizeBinaryOpNode(TokenPosition op_pos,
                                       Token::Kind binary_op,
@@ skipping 191 matching lines @@
 AstNode* Parser::CreateAssignmentNode(AstNode* original,
                                       AstNode* rhs,
                                       const String* left_ident,
                                       TokenPosition left_pos,
                                       bool is_compound /* = false */) {
   AstNode* result = original->MakeAssignmentNode(rhs);
   if (result == NULL) {
     String& name = String::ZoneHandle(Z);
     const Class* target_cls = &current_class();
     if (original->IsTypeNode()) {
-      name = Symbols::New(original->AsTypeNode()->TypeName());
+      name = Symbols::New(T, original->AsTypeNode()->TypeName());
     } else if (original->IsLoadStaticFieldNode()) {
       name = original->AsLoadStaticFieldNode()->field().name();
       target_cls = &Class::Handle(Z,
           original->AsLoadStaticFieldNode()->field().Owner());
     } else if ((left_ident != NULL) &&
                (original->IsLiteralNode() ||
                 original->IsLoadLocalNode())) {
       name = left_ident->raw();
     }
     if (name.IsNull()) {
@@ skipping 880 matching lines @@
 
   String& extractor_name = String::ZoneHandle(Z);
   if (IsIdentifier()) {
     extractor_name = CurrentLiteral()->raw();
     ConsumeToken();
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       is_setter_name = true;
     }
   } else if (Token::CanBeOverloaded(CurrentToken())) {
-    extractor_name = Symbols::New(Token::Str(CurrentToken()));
+    extractor_name = Symbols::Token(CurrentToken()).raw();
     ConsumeToken();
   } else {
     ReportError("identifier or operator expected");
   }
 
   if (primary->IsPrimaryNode() && primary->AsPrimaryNode()->IsSuper()) {
     // TODO(hausner): implement super#m
     ReportError("closurization of super method not yet supported");
   }
 
@@ skipping 106 matching lines @@
                                   NULL);  // No existing function.
   }
 
   // Closurization of instance getter, setter, method or operator.
   GrowableHandlePtrArray<const String> pieces(Z, 3);
   pieces.Add(Symbols::HashMark());
   if (is_setter_name) {
     pieces.Add(Symbols::SetterPrefix());
   }
   pieces.Add(extractor_name);
-  extractor_name = Symbols::FromConcatAll(pieces);
+  extractor_name = Symbols::FromConcatAll(T, pieces);
   return new(Z) InstanceGetterNode(property_pos, primary, extractor_name);
 }
 
 
 AstNode* Parser::ParsePostfixExpr() {
   TRACE_PARSER("ParsePostfixExpr");
   String* expr_ident =
       Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
   const TokenPosition expr_pos = TokenPos();
   AstNode* expr = ParsePrimary();
@@ skipping 1169 matching lines @@
     }
     if (is_const) {
       ASSERT(key->IsLiteralNode());
       const Instance& key_value = key->AsLiteralNode()->literal();
       if (key_value.IsDouble()) {
         ReportError(key_pos, "key value must not be of type double");
       }
       if (!key_value.IsInteger() &&
           !key_value.IsString() &&
           (key_value.clazz() != I->object_store()->symbol_class()) &&
-          ImplementsEqualOperator(key_value)) {
+          ImplementsEqualOperator(Z, key_value)) {
         ReportError(key_pos, "key value must not implement operator ==");
       }
     }
     ExpectToken(Token::kCOLON);
     const TokenPosition value_pos = TokenPos();
     AstNode* value = ParseExpr(is_const, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     if (I->type_checks() &&
         !is_const &&
         !value_type.IsDynamicType()) {
@@ skipping 177 matching lines @@
   if (IsIdentifier()) {
     symbol = CurrentLiteral()->raw();
     ConsumeToken();
     GrowableHandlePtrArray<const String> pieces(Z, 3);
     pieces.Add(symbol);
     while (CurrentToken() == Token::kPERIOD) {
       pieces.Add(Symbols::Dot());
       ConsumeToken();
       pieces.Add(*ExpectIdentifier("identifier expected"));
     }
-    symbol = Symbols::FromConcatAll(pieces);
+    symbol = Symbols::FromConcatAll(T, pieces);
   } else if (Token::CanBeOverloaded(CurrentToken())) {
-    symbol = Symbols::New(Token::Str(CurrentToken()));
+    symbol = Symbols::Token(CurrentToken()).raw();
     ConsumeToken();
   } else {
     ReportError("illegal symbol literal");
   }
   ASSERT(symbol.IsSymbol());
 
   Instance& symbol_instance = Instance::ZoneHandle(Z);
   if (GetCachedConstant(symbol_pos, &symbol_instance)) {
     return new(Z) LiteralNode(symbol_pos, symbol_instance);
   }
@@ skipping 26 matching lines @@
     const Function& ctr, TokenPosition token_pos) {
   ASSERT(ctr.kind() == RawFunction::kConstructor);
   Function& closure = Function::Handle(Z);
   closure = I->LookupClosureFunction(innermost_function(), token_pos);
   if (!closure.IsNull()) {
     ASSERT(closure.IsConstructorClosureFunction());
     return closure.raw();
   }
 
   String& closure_name = String::Handle(Z, ctr.name());
-  closure_name = Symbols::FromConcat(Symbols::ConstructorClosurePrefix(),
-                                     closure_name);
+  closure_name = Symbols::FromConcat(T,
+      Symbols::ConstructorClosurePrefix(), closure_name);
 
   ParamList params;
   params.AddFinalParameter(token_pos,
                            &Symbols::ClosureParameter(),
                            &Object::dynamic_type());
 
   ParseFormalParameters(ctr, &params);
   // Per language spec, the type of the closure parameters is dynamic.
   // Replace the types parsed from the constructor.
   params.EraseParameterTypes();
@@ skipping 11 matching lines @@
   Type& signature_type = Type::Handle(Z, closure.SignatureType());
   signature_type ^= ClassFinalizer::FinalizeType(
       current_class(), signature_type, ClassFinalizer::kCanonicalize);
   closure.SetSignatureType(signature_type);
   // Finalization would be premature when top-level parsing.
   ASSERT(!is_top_level_);
   return closure.raw();
 }
 
 
-static String& BuildConstructorName(const String& type_class_name,
+static String& BuildConstructorName(Thread* thread,
+                                    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(Symbols::FromConcat(type_class_name, Symbols::Dot()));
+  Zone* zone = thread->zone();
+  String& constructor_name = String::Handle(zone,
+      Symbols::FromDot(thread, type_class_name));
   if (named_constructor != NULL) {
     constructor_name =
-        Symbols::FromConcat(constructor_name, *named_constructor);
+        Symbols::FromConcat(thread, constructor_name, *named_constructor);
   }
   return constructor_name;
 }
 
 
 // Parse a primary expression of the form new T# or new T#m.
 // Current token position is after the keyword new. Extracts the
 // anonymous or named constructor and type arguments.
 // Note that type type T has already been parsed before
 // (by ParseNewOperator()) and is guaranteed to be well-formed,
@@ skipping 18 matching lines @@
   ExpectToken(Token::kHASH);
   String* named_constructor = NULL;
   if (IsIdentifier()) {
     named_constructor = CurrentLiteral();
     ConsumeToken();
   }
   // Resolve the type and optional identifier to a constructor or factory.
   Class& type_class = Class::Handle(Z, type.type_class());
   String& type_class_name = String::Handle(Z, type_class.Name());
   *type_arguments = type.arguments();
-  String& constructor_name =
-      BuildConstructorName(type_class_name, named_constructor);
+  String& constructor_name = BuildConstructorName(T,
+      type_class_name, named_constructor);
   *constructor = type_class.LookupConstructor(constructor_name);
   if (constructor->IsNull()) {
     *constructor = type_class.LookupFactory(constructor_name);
     ASSERT(!constructor->IsNull());
     if (constructor->IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(type_class, *constructor);
       type = constructor->RedirectionType();
       ASSERT(!type.IsMalformedOrMalbounded());
       if (!type.IsInstantiated()) {
         Error& error = Error::Handle(Z);
@@ skipping 119 matching lines @@
 
   // A constructor has an implicit 'this' parameter (instance to construct)
   // and a factory has an implicit 'this' parameter (type_arguments).
   intptr_t arguments_length = arguments->length() + 1;
 
   // An additional type check of the result of a redirecting factory may be
   // required.
   AbstractType& type_bound = AbstractType::ZoneHandle(Z);
 
   // Make sure that an appropriate constructor exists.
-  String& constructor_name =
-      BuildConstructorName(type_class_name, named_constructor);
+  String& constructor_name = BuildConstructorName(T,
+              type_class_name, named_constructor);
   Function& constructor = Function::ZoneHandle(Z,
       type_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
     constructor = type_class.LookupFactory(constructor_name);
     if (constructor.IsNull()) {
       const String& external_constructor_name =
           (named_constructor ? constructor_name : type_class_name);
       // Replace the type with a malformed type and compile a throw or report a
       // compile-time error if the constructor is const.
       if (is_const) {
@@ skipping 247 matching lines @@
   interpolate_arg.SetAt(0, value_arr);
 
   // Call interpolation function.
   Object& result = Object::Handle(Z);
   result = DartEntry::InvokeFunction(func, interpolate_arg);
   if (result.IsUnhandledException()) {
     ReportError("%s", Error::Cast(result).ToErrorCString());
   }
   String& concatenated = String::ZoneHandle(Z);
   concatenated ^= result.raw();
-  concatenated = Symbols::New(concatenated);
+  concatenated = Symbols::New(T, concatenated);
   return concatenated;
 }
 
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol } kSTRING }
 // interpol = kINTERPOL_VAR | (kINTERPOL_START expression kINTERPOL_END)
 // In other words, the scanner breaks down interpolated strings so that
 // a string literal always begins and ends with a kSTRING token.
@@ skipping 77 matching lines @@
       const String& interpolated_string = Interpolate(values_list);
       primary = new(Z) LiteralNode(literal_start, interpolated_string);
       CacheConstantValue(literal_start, interpolated_string);
     } else {
       GrowableHandlePtrArray<const String> pieces(Z, values_list.length());
       for (int i = 0; i < values_list.length(); i++) {
         const Instance& part = values_list[i]->AsLiteralNode()->literal();
         ASSERT(part.IsString());
         pieces.Add(String::Cast(part));
       }
-      const String& lit = String::ZoneHandle(Z, Symbols::FromConcatAll(pieces));
+      const String& lit = String::ZoneHandle(Z,
+          Symbols::FromConcatAll(T, pieces));
       primary = new(Z) LiteralNode(literal_start, lit);
       // Caching of constant not necessary because the symbol lookup will
       // find the value next time.
     }
   } else {
     ArrayNode* values = new(Z) ArrayNode(
         TokenPos(),
         Type::ZoneHandle(Z, Type::ArrayType()),
         values_list);
     primary = new(Z) StringInterpolateNode(TokenPos(), values);
@@ skipping 69 matching lines @@
           // in the parser. The four cases are: prefixed vs non-prefixed
           // name, static vs dynamic context in which the unresolved name
           // is used. We cheat a little here by looking at the next token
           // to determine whether we have an unresolved method call or
           // field access.
           GrowableHandlePtrArray<const String> pieces(Z, 3);
           pieces.Add(String::Handle(Z, prefix.name()));
           pieces.Add(Symbols::Dot());
           pieces.Add(ident);
           const String& qualified_name = String::ZoneHandle(Z,
-              Symbols::FromConcatAll(pieces));
+              Symbols::FromConcatAll(T, pieces));
           InvocationMirror::Type call_type =
               CurrentToken() == Token::kLPAREN ?
                   InvocationMirror::kMethod : InvocationMirror::kGetter;
           primary = ThrowNoSuchMethodError(qual_ident_pos,
                                            current_class(),
                                            qualified_name,
                                            NULL,  // No arguments.
                                            InvocationMirror::kTopLevel,
                                            call_type,
                                            NULL);  // No existing function.
         }
       } else if (FLAG_load_deferred_eagerly && prefix.is_deferred_load()) {
         // primary != NULL.
-        String& qualified_name = String::ZoneHandle(Z, prefix.name());
-        qualified_name = String::Concat(qualified_name, Symbols::Dot());
-        qualified_name = Symbols::FromConcat(qualified_name, ident);
+        GrowableHandlePtrArray<const String> pieces(Z, 3);
+        pieces.Add(String::Handle(Z, prefix.name()));
+        pieces.Add(Symbols::Dot());
+        pieces.Add(ident);
+        const String& qualified_name = String::ZoneHandle(Z,
+            Symbols::FromConcatAll(T, pieces));
         InvocationMirror::Type call_type =
             CurrentToken() == Token::kLPAREN ?
                 InvocationMirror::kMethod : InvocationMirror::kGetter;
         // Note: Adding a statement to current block is a hack, parsing an
         // espression should have no side-effect.
         current_block_->statements->Add(ThrowNoSuchMethodError(
                                             qual_ident_pos,
                                             current_class(),
                                             qualified_name,
                                             NULL,  // No arguments.
@@ skipping 573 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME