More cleanups for background compilation.

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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 1033 matching lines @@
     return error.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 RawArray* Parser::EvaluateMetadata() {
   CheckToken(Token::kAT, "Metadata character '@' expected");
   GrowableObjectArray& meta_values =
-      GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
+      GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   while (CurrentToken() == Token::kAT) {
     ConsumeToken();
     intptr_t expr_pos = TokenPos();
     if (!IsIdentifier()) {
       ExpectIdentifier("identifier expected");
     }
     // Reject expressions with deferred library prefix eagerly.
     Object& obj =
         Object::Handle(Z, library_.LookupLocalObject(*CurrentLiteral()));
     if (!obj.IsNull() && obj.IsLibraryPrefix()) {
@@ skipping 48 matching lines @@
                       ident->ToCString(),
                       cls.ToCString());
         }
         expr = GenerateStaticFieldLookup(field, ident_pos);
       }
     }
     if (expr->EvalConstExpr() == NULL) {
       ReportError(expr_pos, "expression must be a compile-time constant");
     }
     const Instance& val = EvaluateConstExpr(expr_pos, expr);
-    meta_values.Add(val);
+    meta_values.Add(val, Heap::kOld);
   }
   return Array::MakeArray(meta_values);
 }
 
 
 SequenceNode* Parser::ParseStaticInitializer() {
   ExpectIdentifier("field name expected");
   CheckToken(Token::kASSIGN, "field initialier expected");
   ConsumeToken();
   OpenFunctionBlock(parsed_function()->function());
@@ skipping 442 matching lines @@
 
   // Receiver is local 0.
   LocalScope* scope = current_block_->scope;
   ArgumentListNode* func_args = new ArgumentListNode(token_pos);
   for (intptr_t i = 0; i < desc.Count(); ++i) {
     func_args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
   }
 
   if (desc.NamedCount() > 0) {
     const Array& arg_names =
-        Array::ZoneHandle(Z, Array::New(desc.NamedCount()));
+        Array::ZoneHandle(Z, Array::New(desc.NamedCount(), Heap::kOld));
     for (intptr_t i = 0; i < arg_names.Length(); ++i) {
       arg_names.SetAt(i, String::Handle(Z, desc.NameAt(i)));
     }
     func_args->set_names(arg_names);
   }
 
   const String& func_name = String::ZoneHandle(Z, func.name());
   ArgumentListNode* arguments = BuildNoSuchMethodArguments(
       token_pos, func_name, *func_args, NULL, false);
   const intptr_t kNumArguments = 2;  // Receiver, InvocationMirror.
@@ skipping 4235 matching lines @@
   }
   return Api::UnwrapHandle(result);
 }
 
 
 void Parser::ParseLibraryName() {
   ASSERT(CurrentToken() == Token::kLIBRARY);
   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();
-      lib_name = String::Concat(lib_name, Symbols::Dot());
-      lib_name = String::Concat(lib_name,
-          *ExpectIdentifier("malformed library name"));
+      pieces.Add(Symbols::Dot());
+      pieces.Add(*ExpectIdentifier("malformed library name"));
     }
-    lib_name = Symbols::New(lib_name);
+    lib_name = Symbols::FromConcatAll(pieces);
   }
   library_.SetName(lib_name);
   ExpectSemicolon();
 }
 
 
 void Parser::ParseIdentList(GrowableObjectArray* names) {
   if (!IsIdentifier()) {
     ReportError("identifier expected");
   }
@@ skipping 5824 matching lines @@
                                   extractor_name,
                                   NULL,  // No arguments.
                                   InvocationMirror::kStatic,
                                   is_setter_name
                                       ? InvocationMirror::kSetter
                                       : InvocationMirror::kMethod,
                                   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) {
-    extractor_name = String::Concat(Symbols::SetterPrefix(), extractor_name);
+    pieces.Add(Symbols::SetterPrefix());
   }
-  extractor_name = Symbols::FromConcat(Symbols::HashMark(), extractor_name);
+  pieces.Add(extractor_name);
+  extractor_name = Symbols::FromConcatAll(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 intptr_t expr_pos = TokenPos();
   AstNode* expr = ParsePrimary();
@@ skipping 1869 matching lines @@
 
 String& Parser::Interpolate(const GrowableArray<AstNode*>& values) {
   const Class& cls = Class::Handle(
       Z, Library::LookupCoreClass(Symbols::StringBase()));
   ASSERT(!cls.IsNull());
   const Function& func = Function::Handle(Z, cls.LookupStaticFunction(
       Library::PrivateCoreLibName(Symbols::Interpolate())));
   ASSERT(!func.IsNull());
 
   // Build the array of literal values to interpolate.
-  const Array& value_arr = Array::Handle(Z, Array::New(values.length()));
+  const Array& value_arr = Array::Handle(Z,
+      Array::New(values.length(), Heap::kOld));
   for (int i = 0; i < values.length(); i++) {
     ASSERT(values[i]->IsLiteralNode());
     value_arr.SetAt(i, values[i]->AsLiteralNode()->literal());
   }
 
   // Build argument array to pass to the interpolation function.
-  const Array& interpolate_arg = Array::Handle(Z, Array::New(1));
+  const Array& interpolate_arg = Array::Handle(Z, Array::New(1, Heap::kOld));
   interpolate_arg.SetAt(0, value_arr);
 
   // Call interpolation function.
   Object& result = Object::Handle(Z);
   {
     PAUSETIMERSCOPE(T, time_compilation);
     result = DartEntry::InvokeFunction(func, interpolate_arg);
   }
   if (result.IsUnhandledException()) {
     ReportError("%s", Error::Cast(result).ToErrorCString());
@@ skipping 162 matching lines @@
           // TODO(hausner): Ideally we should generate the NoSuchMethodError
           // later, when we know more about how the unresolved name is used.
           // For example, we don't know yet whether the unresolved name
           // refers to a getter or a setter. However, it is more awkward
           // to distinuish four NoSuchMethodError cases all over the place
           // 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.
-          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(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.
@@ skipping 512 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart