Fix background compiler issue with new-space allocation in the parser.

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 2339 matching lines @@
     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(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));
+    const String& getter_name =
+        String::ZoneHandle(Z, Field::GetterSymbol(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(Z, super_class,
                                                  Symbols::NoSuchMethod());
     ASSERT(!super_func.IsNull());
     *is_no_such_method = true;
   } else {
@@ skipping 3258 matching lines @@
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupLocalObject(var_name) != Object::null()) {
       ReportError(name_pos, "'%s' is already defined", var_name.ToCString());
     }
 
     // Check whether a getter or setter for this name exists. A const
     // or final field implies a setter which throws a NoSuchMethodError,
     // thus we need to check for conflicts with existing setters and
     // getters.
-    String& accessor_name = String::Handle(Z, Field::GetterName(var_name));
+    String& accessor_name = String::Handle(Z, Field::GetterSymbol(var_name));
     if (library_.LookupLocalObject(accessor_name) != Object::null()) {
       ReportError(name_pos, "getter for '%s' is already defined",
                   var_name.ToCString());
     }
     accessor_name = Field::SetterName(var_name);
     if (library_.LookupLocalObject(accessor_name) != Object::null()) {
       ReportError(name_pos, "setter for '%s' is already defined",
                   var_name.ToCString());
     }
 
@@ skipping 100 matching lines @@
   const TokenPosition name_pos = TokenPos();
   const String& func_name = *ExpectIdentifier("function name expected");
 
   bool found = library_.LookupLocalObject(func_name) != Object::null();
   if (found && !is_patch) {
     ReportError(name_pos, "'%s' is already defined", func_name.ToCString());
   } else if (!found && is_patch) {
     ReportError(name_pos, "missing '%s' cannot be patched",
                 func_name.ToCString());
   }
-  String& accessor_name = String::Handle(Z, Field::GetterName(func_name));
+  String& accessor_name = String::Handle(Z, Field::GetterSymbol(func_name));
   if (library_.LookupLocalObject(accessor_name) != Object::null()) {
     ReportError(name_pos, "'%s' is already defined as getter",
                 func_name.ToCString());
   }
   // A setter named x= may co-exist with a function named x, thus we do
   // not need to check setters.
 
   Function& func = Function::Handle(
       Z, Function::New(func_name, RawFunction::kRegularFunction,
                        /* is_static = */ true,
@@ skipping 5695 matching lines @@
                                  arguments->names()));
   if (func.IsNull()) {
     // 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(Z, cls.LookupStaticField(func_name));
     Function& func = Function::ZoneHandle(Z);
     if (field.IsNull()) {
       // No field, check if we have an explicit getter function.
       const String& getter_name =
-          String::ZoneHandle(Z, Field::GetterName(func_name));
+          String::ZoneHandle(Z, Field::GetterSymbol(func_name));

[hausner, 2017/01/30 23:01:03]

I don't think we want to create a symbol for the getter name unless we know for
sure that the getter exists. Otherwise, we end up creating unnecessary symbols.

[Florian Schneider, 2017/01/30 23:30:23]

Ok, instead I could for example create the temporary string in old-space only if
we're compiling on the background thread. That would be better anyway, since we
would not create old-space garbage for unoptimized compilations.

       const int kNumArguments = 0;  // no arguments.
       func = Resolver::ResolveStatic(cls, getter_name, kNumArguments,
                                      Object::empty_array());
       if (!func.IsNull()) {
         ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
         closure = new (Z) StaticGetterNode(
             call_pos, NULL, Class::ZoneHandle(Z, cls.raw()), func_name);
         return BuildClosureCall(call_pos, closure, arguments);
       }
     } else {
@@ skipping 590 matching lines @@
       }
     } else {
       Function& func = Function::Handle(Z);
       if (is_setter_name) {
         extractor_name = Field::SetterName(extractor_name);
         func = cls.LookupStaticFunction(extractor_name);
       } else {
         func = cls.LookupStaticFunction(extractor_name);
         if (func.IsNull()) {
           const String& getter_name =
-              String::Handle(Z, Field::GetterName(extractor_name));
+              String::Handle(Z, Field::GetterSymbol(extractor_name));
           func = cls.LookupStaticFunction(getter_name);
         }
       }
       if (!func.IsNull()) {
         return CreateImplicitClosureNode(func, property_pos, NULL);
       }
     }
     return ThrowNoSuchMethodError(
         property_pos, cls, extractor_name,
         NULL,  // No arguments.
@@ skipping 2920 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