Heap::kNew-space allocations discovered by experimental code called transitively from parser

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/hash_table.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 303 matching lines @@
 }
 
 
 void ClassFinalizer::ResolveRedirectingFactory(const Class& cls,
                                                const Function& factory) {
   const Function& target = Function::Handle(factory.RedirectionTarget());
   if (target.IsNull()) {
     Type& type = Type::Handle(factory.RedirectionType());
     if (!type.IsMalformed() && IsLoaded(type)) {
       const GrowableObjectArray& visited_factories =
-          GrowableObjectArray::Handle(GrowableObjectArray::New());
+          GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
       ResolveRedirectingFactoryTarget(cls, factory, visited_factories);
     }
     if (factory.is_const()) {
       type = factory.RedirectionType();
       if (type.IsMalformedOrMalbounded()) {
         ReportError(Error::Handle(type.error()));
       }
     }
   }
 }
 
 
 void ClassFinalizer::ResolveRedirectingFactoryTarget(
     const Class& cls,
     const Function& factory,
     const GrowableObjectArray& visited_factories) {
   ASSERT(factory.IsRedirectingFactory());
 
   // Check for redirection cycle.
   for (intptr_t i = 0; i < visited_factories.Length(); i++) {
     if (visited_factories.At(i) == factory.raw()) {
       // A redirection cycle is reported as a compile-time error.
       ReportError(cls, factory.token_pos(),
                   "factory '%s' illegally redirects to itself",
                   String::Handle(factory.name()).ToCString());
     }
   }
-  visited_factories.Add(factory);
+  visited_factories.Add(factory, Heap::kOld);
 
   // Check if target is already resolved.
   Type& type = Type::Handle(factory.RedirectionType());
   Function& target = Function::Handle(factory.RedirectionTarget());
   if (type.IsMalformedOrMalbounded()) {
     // Already resolved to a malformed or malbounded type. Will throw on usage.
     ASSERT(target.IsNull());
     return;
   }
   if (!target.IsNull()) {
@@ skipping 18 matching lines @@
     type = NewFinalizedMalformedType(Error::Handle(),  // No previous error.
                                      Script::Handle(cls.script()),
                                      factory.token_pos(),
                                      "factory may not redirect to 'dynamic'");
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
   const Class& target_class = Class::Handle(type.type_class());
   String& target_class_name = String::Handle(target_class.Name());
-  String& target_name =
-      String::Handle(String::Concat(target_class_name, Symbols::Dot()));
+  String& target_name = String::Handle(
+      String::Concat(target_class_name, Symbols::Dot(), Heap::kOld));
   const String& identifier = String::Handle(factory.RedirectionIdentifier());
   if (!identifier.IsNull()) {
-    target_name = String::Concat(target_name, identifier);
+    target_name = String::Concat(target_name, identifier, Heap::kOld);
   }
 
   // Verify that the target constructor of the redirection exists.
   target = target_class.LookupConstructor(target_name);
   if (target.IsNull()) {
     target = target_class.LookupFactory(target_name);
   }
   if (target.IsNull()) {
     const String& user_visible_target_name =
         identifier.IsNull() ? target_class_name : target_name;
@@ skipping 1892 matching lines @@
   const String& super_name = String::Handle(Z, super_class.Name());
   const Array& functions = Array::Handle(Z, super_class.functions());
   const intptr_t num_functions = functions.Length();
   Function& func = Function::Handle(Z);
   for (intptr_t i = 0; i < num_functions; i++) {
     func ^= functions.At(i);
     if (func.IsGenerativeConstructor()) {
       // Build constructor name from mixin application class name
       // and name of cloned super class constructor.
       const String& ctor_name = String::Handle(Z, func.name());
-      String& clone_name =
-          String::Handle(Z, String::SubString(ctor_name, super_name.Length()));
+      String& clone_name = String::Handle(
+          Z, String::SubString(ctor_name, super_name.Length(), Heap::kOld));
       clone_name = Symbols::FromConcat(T, mixin_name, clone_name);
 
       if (FLAG_trace_class_finalization) {
         THR_Print("Cloning constructor '%s' as '%s'\n", ctor_name.ToCString(),
                   clone_name.ToCString());
       }
 
       // The owner of the forwarding constructor is the mixin application
       // class. The source is the mixin class. The source may be needed
       // to parse field initializer expressions in the mixin class.
@@ skipping 13 matching lines @@
       clone.set_result_type(Object::dynamic_type());
       clone.set_is_debuggable(false);
 
       const intptr_t num_parameters = func.NumParameters();
       // The cloned ctor shares the parameter names array with the
       // original.
       const Array& parameter_names = Array::Handle(Z, func.parameter_names());
       ASSERT(parameter_names.Length() == num_parameters);
       clone.set_parameter_names(parameter_names);
       // The parameter types of the cloned constructor are 'dynamic'.
-      clone.set_parameter_types(Array::Handle(Z, Array::New(num_parameters)));
+      clone.set_parameter_types(
+          Array::Handle(Z, Array::New(num_parameters, Heap::kOld)));
       for (intptr_t n = 0; n < num_parameters; n++) {
         clone.SetParameterTypeAt(n, Object::dynamic_type());
       }
       cloned_funcs.Add(clone);
     }
   }
 }
 
 
 void ClassFinalizer::ApplyMixinMembers(const Class& cls) {
@@ skipping 12 matching lines @@
          Class::Handle(zone, cls.SuperClass()).IsMixinApplication());
   // A default constructor will be created for the mixin app alias class.
 
   if (FLAG_trace_class_finalization) {
     THR_Print("Applying mixin members of %s to %s at pos %s\n",
               mixin_cls.ToCString(), cls.ToCString(),
               cls.token_pos().ToCString());
   }
 
   const GrowableObjectArray& cloned_funcs =
-      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
+      GrowableObjectArray::Handle(zone, GrowableObjectArray::New(Heap::kOld));
 
   Array& functions = Array::Handle(zone);
   Function& func = Function::Handle(zone);
 
   // The parser creates the mixin application class with no functions.
   // But the Kernel frontend will generate mixin classes with only
   // constructors inside them, which forward to the base class constructors.
   //
   // => We generate the constructors if they are not already there.
   functions = cls.functions();
@@ skipping 11 matching lines @@
   functions = mixin_cls.functions();
   const intptr_t num_functions = functions.Length();
   for (intptr_t i = 0; i < num_functions; i++) {
     func ^= functions.At(i);
     if (func.IsGenerativeConstructor()) {
       // A mixin class must not have explicit constructors.
       if (!func.IsImplicitConstructor()) {
         const Script& script = Script::Handle(cls.script());
         const Error& error = Error::Handle(LanguageError::NewFormatted(
             Error::Handle(), script, func.token_pos(), Report::AtLocation,
-            Report::kError, Heap::kNew,
+            Report::kError, Heap::kOld,
             "constructor '%s' is illegal in mixin class %s",
             String::Handle(func.UserVisibleName()).ToCString(),
             String::Handle(zone, mixin_cls.Name()).ToCString()));
 
         ReportErrors(error, cls, cls.token_pos(),
                      "mixin class '%s' must not have constructors",
                      String::Handle(zone, mixin_cls.Name()).ToCString());
       }
       continue;  // Skip the implicit constructor.
     }
     if (!func.is_static() && !func.IsMethodExtractor() &&
         !func.IsNoSuchMethodDispatcher() && !func.IsInvokeFieldDispatcher()) {
       func = func.Clone(cls);
-      cloned_funcs.Add(func);
+      cloned_funcs.Add(func, Heap::kOld);
     }
   }
   functions = Array::MakeArray(cloned_funcs);
   cls.SetFunctions(functions);
 
   // Now clone the fields from the mixin class. There should be no
   // existing fields in the mixin application class.
   ASSERT(Array::Handle(cls.fields()).Length() == 0);
   const Array& fields = Array::Handle(zone, mixin_cls.fields());
   const intptr_t num_fields = fields.Length();
@@ skipping 210 matching lines @@
     // This has to happen before the check whether the methods of
     // the class conflict with inherited methods.
     ApplyMixinMembers(cls);
   }
   // Mark as parsed and finalized.
   cls.Finalize();
   // Mixin app alias classes may still lack their forwarding constructor.
   if (cls.is_mixin_app_alias() &&
       (cls.functions() == Object::empty_array().raw())) {
     const GrowableObjectArray& cloned_funcs =
-        GrowableObjectArray::Handle(GrowableObjectArray::New());
+        GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
 
     const Class& mixin_app_class = Class::Handle(cls.SuperClass());
     const Type& mixin_type = Type::Handle(mixin_app_class.mixin());
     const Class& mixin_cls = Class::Handle(mixin_type.type_class());
 
     CreateForwardingConstructors(cls, mixin_cls, cloned_funcs);
     const Array& functions = Array::Handle(Array::MakeArray(cloned_funcs));
     cls.SetFunctions(functions);
   }
   // Every class should have at least a constructor, unless it is a top level
@@ skipping 35 matching lines @@
       zone, enum_cls.LookupInstanceFieldAllowPrivate(Symbols::_name()));
   ASSERT(!name_field.IsNull());
   const Field& values_field =
       Field::Handle(zone, enum_cls.LookupStaticField(Symbols::Values()));
   ASSERT(!values_field.IsNull());
   ASSERT(Instance::Handle(zone, values_field.StaticValue()).IsArray());
   Array& values_list =
       Array::Handle(zone, Array::RawCast(values_field.StaticValue()));
   const String& enum_name = String::Handle(enum_cls.ScrubbedName());
   const String& name_prefix =
-      String::Handle(String::Concat(enum_name, Symbols::Dot()));
+      String::Handle(String::Concat(enum_name, Symbols::Dot(), Heap::kOld));
 
   Field& field = Field::Handle(zone);
   Instance& ordinal_value = Instance::Handle(zone);
   Instance& enum_value = Instance::Handle(zone);
 
   String& enum_ident = String::Handle();
 
   enum_ident =
       Symbols::FromConcat(thread, Symbols::_DeletedEnumPrefix(), enum_name);
   enum_value = Instance::New(enum_cls, Heap::kOld);
@@ skipping 1080 matching lines @@
   ProgramVisitor::VisitFunctions(&function_visitor);
 
   class ClearCodeClassVisitor : public ClassVisitor {
     void Visit(const Class& cls) { cls.DisableAllocationStub(); }
   };
   ClearCodeClassVisitor class_visitor;
   ProgramVisitor::VisitClasses(&class_visitor);
 }
 
 }  // namespace dart