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

runtime/vm/class_finalizer.cc

Index: runtime/vm/class_finalizer.cc
diff --git a/runtime/vm/class_finalizer.cc b/runtime/vm/class_finalizer.cc
index 288e05698389fed9323d941b3c02cae9f5e03dc9..28004997392313cec53675270167c8772d010142 100644
--- a/runtime/vm/class_finalizer.cc
+++ b/runtime/vm/class_finalizer.cc
@@ -321,7 +321,7 @@ void ClassFinalizer::ResolveRedirectingFactory(const Class& cls,
     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()) {
@@ -349,7 +349,7 @@ void ClassFinalizer::ResolveRedirectingFactoryTarget(
                   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());
@@ -388,11 +388,11 @@ void ClassFinalizer::ResolveRedirectingFactoryTarget(
   }
   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.
@@ -2305,8 +2305,8 @@ void ClassFinalizer::CreateForwardingConstructors(
       // 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) {
@@ -2340,7 +2340,8 @@ void ClassFinalizer::CreateForwardingConstructors(
       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());
       }
@@ -2373,7 +2374,7 @@ void ClassFinalizer::ApplyMixinMembers(const Class& cls) {
   }
 
   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);
@@ -2405,7 +2406,7 @@ void ClassFinalizer::ApplyMixinMembers(const Class& cls) {
         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()));
@@ -2419,7 +2420,7 @@ void ClassFinalizer::ApplyMixinMembers(const Class& cls) {
     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);
@@ -2650,7 +2651,7 @@ void ClassFinalizer::FinalizeClass(const Class& cls) {
   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());
@@ -2706,7 +2707,7 @@ void ClassFinalizer::AllocateEnumValues(const Class& enum_cls) {
       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);