Fix new space allocation in parser which can be triggered on background compiler

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 439 matching lines @@
   }
 }
 
 
 // For parsing a compilation unit.
 Parser::Parser(const Script& script,
                const Library& library,
                TokenPosition token_pos)
     : thread_(Thread::Current()),
       isolate_(thread()->isolate()),
+      allocation_space_(thread_->IsMutatorThread() ? Heap::kNew : Heap::kOld),
       script_(Script::Handle(zone(), script.raw())),
       tokens_iterator_(zone(),
                        TokenStream::Handle(zone(), script.tokens()),
                        token_pos),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       await_is_keyword_(false),
       current_member_(NULL),
       allow_function_literals_(true),
@@ skipping 12 matching lines @@
   ASSERT(!library.IsNull());
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                ParsedFunction* parsed_function,
                TokenPosition token_pos)
     : thread_(Thread::Current()),
       isolate_(thread()->isolate()),
+      allocation_space_(thread_->IsMutatorThread() ? Heap::kNew : Heap::kOld),
       script_(Script::Handle(zone(), script.raw())),
       tokens_iterator_(zone(),
                        TokenStream::Handle(zone(), script.tokens()),
                        token_pos),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       await_is_keyword_(false),
       current_member_(NULL),
       allow_function_literals_(true),
@@ skipping 1442 matching lines @@
         unexpected_token_found = true;
         break;
       default:
         // nothing.
         break;
     }
   } while (!token_stack.is_empty() && is_match && !unexpected_token_found);
   if (!is_match) {
     const Error& error = Error::Handle(LanguageError::NewFormatted(
         Error::Handle(), script_, opening_pos, Report::AtLocation,
-        Report::kWarning, Heap::kNew, "unbalanced '%s' opens here",
+        Report::kWarning, allocation_space_, "unbalanced '%s' opens here",
         Token::Str(opening_token)));
     ReportErrors(error, script_, token_pos, "unbalanced '%s'",
                  Token::Str(token));
   } else if (unexpected_token_found) {
     ReportError(start_pos, "unterminated '%s'", Token::Str(opening_token));
   }
 }
 
 
 void Parser::SkipBlock() {
@@ skipping 3696 matching lines @@
 void Parser::ParseInterfaceList(const Class& cls) {
   TRACE_PARSER("ParseInterfaceList");
   ASSERT(CurrentToken() == Token::kIMPLEMENTS);
   const GrowableObjectArray& all_interfaces =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   AbstractType& interface = AbstractType::Handle(Z);
   // First get all the interfaces already implemented by class.
   Array& cls_interfaces = Array::Handle(Z, cls.interfaces());
   for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
     interface ^= cls_interfaces.At(i);
-    all_interfaces.Add(interface);
+    all_interfaces.Add(interface, Heap::kOld);
   }
   // Now parse and add the new interfaces.
   do {
     ConsumeToken();
     TokenPosition interface_pos = TokenPos();
     interface = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (interface.IsTypeParameter()) {
       ReportError(interface_pos,
                   "type parameter '%s' may not be used in interface list",
                   String::Handle(Z, interface.UserVisibleName()).ToCString());
     }
-    all_interfaces.Add(interface);
+    all_interfaces.Add(interface, Heap::kOld);
   } while (CurrentToken() == Token::kCOMMA);
   cls_interfaces = Array::MakeArray(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 RawAbstractType* Parser::ParseMixins(const AbstractType& super_type) {
   TRACE_PARSER("ParseMixins");
   ASSERT(CurrentToken() == Token::kWITH);
   const GrowableObjectArray& mixin_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   AbstractType& mixin_type = AbstractType::Handle(Z);
   do {
     ConsumeToken();
     mixin_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (mixin_type.IsDynamicType()) {
       // The string 'dynamic' is not resolved yet at this point, but a malformed
       // type mapped to dynamic can be encountered here.
       ReportError(mixin_type.token_pos(), "illegal mixin of a malformed type");
     }
     if (mixin_type.IsTypeParameter()) {
       ReportError(mixin_type.token_pos(),
                   "mixin type '%s' may not be a type parameter",
                   String::Handle(Z, mixin_type.UserVisibleName()).ToCString());
     }
-    mixin_types.Add(mixin_type);
+    mixin_types.Add(mixin_type, Heap::kOld);
   } while (CurrentToken() == Token::kCOMMA);
   return MixinAppType::New(super_type,
                            Array::Handle(Z, Array::MakeArray(mixin_types)));
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level,
                                    const Object& owner,
                                    TokenPosition metadata_pos) {
   TRACE_PARSER("ParseTopLevelVariable");
@@ skipping 457 matching lines @@
   library_.SetName(lib_name);
   ExpectSemicolon();
 }
 
 
 void Parser::ParseIdentList(GrowableObjectArray* names) {
   if (!IsIdentifier()) {
     ReportError("identifier expected");
   }
   while (IsIdentifier()) {
-    names->Add(*CurrentLiteral());
+    names->Add(*CurrentLiteral(), allocation_space_);
     ConsumeToken();  // Identifier.
     if (CurrentToken() != Token::kCOMMA) {
       return;
     }
     ConsumeToken();  // Comma.
   }
 }
 
 
 void Parser::ParseLibraryImportExport(const Object& tl_owner,
                                       TokenPosition metadata_pos) {
   ASSERT(Thread::Current()->IsMutatorThread());
   bool is_import = (CurrentToken() == Token::kIMPORT);
   bool is_export = (CurrentToken() == Token::kEXPORT);
   ASSERT(is_import || is_export);
   const TokenPosition import_pos = TokenPos();
   ConsumeToken();
   CheckToken(Token::kSTRING, "library url expected");
   AstNode* url_literal = ParseStringLiteral(false);
   if (FLAG_conditional_directives) {
     bool condition_triggered = false;
     while (CurrentToken() == Token::kIF) {
       // Conditional import: if (env == val) uri.
       ConsumeToken();
       ExpectToken(Token::kLPAREN);
       // Parse dotted name.
-      const GrowableObjectArray& pieces =
-          GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
-      pieces.Add(*ExpectIdentifier("identifier expected"));
+      const GrowableObjectArray& pieces = GrowableObjectArray::Handle(
+          Z, GrowableObjectArray::New(allocation_space_));
+      pieces.Add(*ExpectIdentifier("identifier expected"), allocation_space_);
       while (CurrentToken() == Token::kPERIOD) {
-        pieces.Add(Symbols::Dot());
+        pieces.Add(Symbols::Dot(), allocation_space_);
         ConsumeToken();
-        pieces.Add(*ExpectIdentifier("identifier expected"));
+        pieces.Add(*ExpectIdentifier("identifier expected"), allocation_space_);
       }
       AstNode* valueNode = NULL;
       if (CurrentToken() == Token::kEQ) {
         ConsumeToken();
         CheckToken(Token::kSTRING, "string literal expected");
         valueNode = ParseStringLiteral(false);
         ASSERT(valueNode->IsLiteralNode());
         ASSERT(valueNode->AsLiteralNode()->literal().IsString());
       }
       ExpectToken(Token::kRPAREN);
       CheckToken(Token::kSTRING, "library url expected");
       AstNode* conditional_url_literal = ParseStringLiteral(false);
 
       // If there was already a condition that triggered, don't try to match
       // again.
       if (condition_triggered) {
         continue;
       }
       // Check if this conditional line overrides the default import.
-      const String& key = String::Handle(
-          String::ConcatAll(Array::Handle(Array::MakeArray(pieces))));
+      const String& key = String::Handle(String::ConcatAll(
+          Array::Handle(Array::MakeArray(pieces)), allocation_space_));
       const String& value =
           (valueNode == NULL)
               ? Symbols::True()
               : String::Cast(valueNode->AsLiteralNode()->literal());
       // Call the embedder to supply us with the environment.
       const String& env_value =
           String::Handle(Api::GetEnvironmentValue(T, key));
       if (!env_value.IsNull() && env_value.Equals(value)) {
         condition_triggered = true;
         url_literal = conditional_url_literal;
@@ skipping 17 matching lines @@
   if (is_import && (CurrentToken() == Token::kAS)) {
     ConsumeToken();
     prefix_pos = TokenPos();
     prefix = ExpectIdentifier("prefix identifier expected")->raw();
   }
 
   Array& show_names = Array::Handle(Z);
   Array& hide_names = Array::Handle(Z);
   if (is_deferred_import || IsSymbol(Symbols::Show()) ||
       IsSymbol(Symbols::Hide())) {
-    GrowableObjectArray& show_list =
-        GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
-    GrowableObjectArray& hide_list =
-        GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
+    GrowableObjectArray& show_list = GrowableObjectArray::Handle(
+        Z, GrowableObjectArray::New(allocation_space_));
+    GrowableObjectArray& hide_list = GrowableObjectArray::Handle(
+        Z, GrowableObjectArray::New(allocation_space_));
     // Libraries imported through deferred import automatically hide
     // the name 'loadLibrary'.
     if (is_deferred_import) {
       hide_list.Add(Symbols::LoadLibrary());
     }
     for (;;) {
       if (IsSymbol(Symbols::Show())) {
         ConsumeToken();
         ParseIdentList(&show_list);
       } else if (IsSymbol(Symbols::Hide())) {
@@ skipping 448 matching lines @@
       finally_clause = NULL;
       AddFinallyClauseToNode(true, node_to_inline, node);
       node_index++;
     }
   } while (finally_clause == NULL);
 
   if (try_stack_ != NULL) {
     try_stack_->exit_finally();
   }
 
-  const GrowableObjectArray& handler_types =
-      GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   // Catch block handles all exceptions.
-  handler_types.Add(Object::dynamic_type());
+  const Array& handler_types = Array::ZoneHandle(Z, Array::New(1, Heap::kOld));
+  handler_types.SetAt(0, Object::dynamic_type());
 
   CatchClauseNode* catch_clause = new (Z) CatchClauseNode(
-      TokenPosition::kNoSource, catch_handler_list,
-      Array::ZoneHandle(Z, Array::MakeArray(handler_types)), context_var,
+      TokenPosition::kNoSource, catch_handler_list, handler_types, context_var,
       exception_var, stack_trace_var, saved_exception_var,
       saved_stack_trace_var, AllocateTryIndex(), true);
 
   const intptr_t try_index = try_statement->try_index();
 
   AstNode* try_catch_node = new (Z)
       TryCatchNode(TokenPosition::kNoSource, body, context_var, catch_clause,
                    finally_clause, try_index, finally_clause);
   current_block_->statements->Add(try_catch_node);
   return CloseBlock();
@@ skipping 74 matching lines @@
       new (Z) LoadLocalNode(TokenPosition::kNoSource, async_completer),
       Symbols::CompleterCompleteError(), completer_args));
   ReturnNode* return_node = new (Z) ReturnNode(func_end_pos);
   // Behavior like a continuation return, i.e,. don't call a completer.
   return_node->set_return_type(ReturnNode::kContinuation);
   current_block_->statements->Add(return_node);
   AstNode* catch_block = CloseBlock();
   current_block_->statements->Add(catch_block);
   SequenceNode* catch_handler_list = CloseBlock();
 
-  const GrowableObjectArray& handler_types =
-      GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
-  handler_types.SetLength(0);
-  handler_types.Add(*exception_param.type);
+  const Array& handler_types = Array::ZoneHandle(Z, Array::New(1, Heap::kOld));
+  handler_types.SetAt(0, *exception_param.type);
 
   TryStack* try_statement = PopTry();
   const intptr_t try_index = try_statement->try_index();
 
   CatchClauseNode* catch_clause = new (Z) CatchClauseNode(
-      TokenPosition::kNoSource, catch_handler_list,
-      Array::ZoneHandle(Z, Array::MakeArray(handler_types)), context_var,
+      TokenPosition::kNoSource, catch_handler_list, handler_types, context_var,
       exception_var, stack_trace_var, saved_exception_var,
       saved_stack_trace_var, CatchClauseNode::kInvalidTryIndex, true);
   AstNode* try_catch_node = new (Z) TryCatchNode(
       TokenPosition::kNoSource, try_block, context_var, catch_clause,
       NULL,  // No finally clause.
       try_index,
       NULL);  // No rethrow-finally clause.
   current_block_->statements->Add(try_catch_node);
   return CloseBlock();
 }
@@ skipping 3159 matching lines @@
       type_tests.Add(new (Z) LiteralNode(catch_pos, Bool::True()));
       if (is_bad_type) {
         // Replace the body with one that throws.
         SequenceNode* block = new (Z) SequenceNode(catch_pos, NULL);
         block->Add(ThrowTypeError(catch_pos, *exception_param.type));
         catch_blocks.Last() = block;
       }
       // This catch clause will handle all exceptions. We can safely forget
       // all previous catch clause types.
       handler_types.SetLength(0);
-      handler_types.Add(*exception_param.type);
+      handler_types.Add(*exception_param.type, Heap::kOld);
     } else {
       // Has a type specification that is not malformed or malbounded.  Now
       // form an 'if type check' to guard the catch handler code.
       if (!exception_param.type->IsInstantiated() && (FunctionLevel() > 0)) {
         // Make sure that the instantiators are captured.
         CaptureAllInstantiators();
       }
       TypeNode* exception_type =
           new (Z) TypeNode(catch_pos, *exception_param.type);
       AstNode* exception_value =
           new (Z) LoadLocalNode(catch_pos, exception_var);
       if (!exception_type->type().IsInstantiated()) {
         EnsureExpressionTemp();
       }
       type_tests.Add(new (Z) ComparisonNode(catch_pos, Token::kIS,
                                             exception_value, exception_type));
 
       // Do not add uninstantiated types (e.g. type parameter T or generic
       // type List<T>), since the debugger won't be able to instantiate it
       // when walking the stack.
       //
       // This means that the debugger is not able to determine whether an
       // exception is caught if the catch clause uses generic types.  It
       // will report the exception as uncaught when in fact it might be
       // caught and handled when we unwind the stack.
       if (!generic_catch_seen && exception_param.type->IsInstantiated()) {
-        handler_types.Add(*exception_param.type);
+        handler_types.Add(*exception_param.type, Heap::kOld);
       }
     }
 
     ASSERT(type_tests.length() == catch_blocks.length());
   }
 
   // Build the if/then/else nest from the inside out.  Keep the AST simple
   // for the case of a single generic catch clause.  The initial value of
   // current is the last (innermost) else block if there were any catch
   // clauses.
@@ skipping 2550 matching lines @@
 
 
 void Parser::InsertCachedConstantValue(const Script& script,
                                        TokenPosition token_pos,
                                        const Instance& value) {
   ASSERT(Thread::Current()->IsMutatorThread());
   const intptr_t kInitialConstMapSize = 16;
   ASSERT(!script.InVMHeap());
   if (script.compile_time_constants() == Array::null()) {
     const Array& array = Array::Handle(
-        HashTables::New<ConstantsMap>(kInitialConstMapSize, Heap::kNew));
+        HashTables::New<ConstantsMap>(kInitialConstMapSize, Heap::kOld));
     script.set_compile_time_constants(array);
   }
   ConstantsMap constants(script.compile_time_constants());
   constants.InsertNewOrGetValue(token_pos, value);
   script.set_compile_time_constants(constants.Release());
 }
 
 
 void Parser::CacheConstantValue(TokenPosition token_pos,
                                 const Instance& value) {
@@ skipping 127 matching lines @@
     ArgumentListNode* arguments) {
   NoReloadScope no_reload_scope(isolate(), thread());
   NoOOBMessageScope no_msg_scope(thread());
   // Factories and constructors are not generic functions.
   const int kTypeArgsLen = 0;
   // Factories have one extra argument: the type arguments.
   // Constructors have one extra arguments: receiver.
   const int kNumExtraArgs = 1;
   const int num_arguments = arguments->length() + kNumExtraArgs;
   const Array& arg_values =
-      Array::Handle(Z, Array::New(num_arguments, Heap::kOld));
+      Array::Handle(Z, Array::New(num_arguments, allocation_space_));
   Instance& instance = Instance::Handle(Z);
   if (!constructor.IsFactory()) {
-    instance = Instance::New(type_class, Heap::kOld);
+    instance = Instance::New(type_class, allocation_space_);
     if (!type_arguments.IsNull()) {
       if (!type_arguments.IsInstantiated()) {
         ReportError("type must be constant in const constructor");
       }
       instance.SetTypeArguments(
           TypeArguments::Handle(Z, type_arguments.Canonicalize()));
     }
     arg_values.SetAt(0, instance);
   } else {
     // Prepend type_arguments to list of arguments to factory.
@@ skipping 515 matching lines @@
         (CurrentToken() == Token::kPERIOD) &&
         (Token::IsIdentifier(LookaheadToken(1)))) {
       if (!is_top_level_ && (current_block_ != NULL)) {
         // Add the unresolved prefix name to the list of referenced
         // names of this scope.
         current_block_->scope->AddReferencedName(TokenPos(), type_name);
       }
       ConsumeToken();  // Period token.
       ASSERT(IsIdentifier());
       String& qualified_name = String::Handle(Z, type_name.raw());
-      qualified_name = String::Concat(qualified_name, Symbols::Dot());
-      qualified_name = String::Concat(qualified_name, *CurrentLiteral());
+      qualified_name =
+          String::Concat(qualified_name, Symbols::Dot(), allocation_space_);
+      qualified_name =
+          String::Concat(qualified_name, *CurrentLiteral(), allocation_space_);
       ConsumeToken();
       // The type is malformed. Skip over its type arguments.
       ParseTypeArguments(ClassFinalizer::kIgnore);
       return ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(Z),  // No previous error.
           script_, ident_pos, "qualified name '%s' does not refer to a type",
           qualified_name.ToCString());
     }
 
     // If parsing inside a local scope, check whether the type name
@@ skipping 1915 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