- Refactor Symbol allocation to expect a thread parameter.

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/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 1691 matching lines @@
       // level. As a consequence, if this mixin application is used itself as a
       // mixin in another mixin application, the bounds will be ignored, which
       // is correct, because the other mixin application does not inherit from
       // the super class of its mixin. Note also that the other mixin
       // application will only mixin the last mixin type listed in the first
       // mixin application it is mixing in.
       param_bound = thread->isolate()->object_store()->object_type();
       for (intptr_t i = 0; i < num_super_type_params; i++) {
         param ^= super_type_params.TypeAt(i);
         param_name = param.name();
-        param_name = Symbols::FromConcat(param_name, Symbols::Backtick());
+        param_name = Symbols::FromConcat(thread,
+                                         param_name, Symbols::Backtick());
         cloned_param = TypeParameter::New(mixin_app_class,
                                           cloned_index,
                                           param_name,
                                           param_bound,
                                           param.token_pos());
         cloned_type_params.SetTypeAt(cloned_index, cloned_param);
         // Change the type arguments of the super type to refer to the
         // cloned type parameters of the mixin application class.
         super_type_args.SetTypeAt(cloned_index, cloned_param);
         cloned_index++;
@@ skipping 160 matching lines @@
 The instantiator vector consists of the cloned type parameters of M shifted by
 an offset corresponding to the finalized index of the first type parameter of M.
 This is done in the recursive call to CloneMixinAppTypeParameters and does not
 require specific code in ApplyMixinAppAlias.
 */
 void ClassFinalizer::ApplyMixinAppAlias(const Class& mixin_app_class,
                                         const TypeArguments& instantiator) {
   // If this mixin alias is aliasing another mixin alias, another class
   // will be inserted via recursion. No need to check here.
   // The mixin type may or may not be finalized yet.
-  Zone* zone = Thread::Current()->zone();
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
   AbstractType& super_type = AbstractType::Handle(zone,
                                                   mixin_app_class.super_type());
   const Type& mixin_type = Type::Handle(zone, mixin_app_class.mixin());
   const Class& mixin_class = Class::Handle(zone, mixin_type.type_class());
   ASSERT(mixin_class.is_mixin_app_alias());
   const Class& aliased_mixin_app_class = Class::Handle(zone,
       mixin_class.SuperClass());
   // Note that the super class of aliased_mixin_app_class can itself be a
   // mixin application class (this happens if the alias is mixing more than one
   // type). Instead of trying to recursively insert yet another class as the
   // super class of this inserted class, we apply the composition rules of the
   // spec and only mixin the members of aliased_mixin_app_class, not those of
   // its super class. In other words, we only mixin the last mixin of the alias.
   const Type& aliased_mixin_type = Type::Handle(zone,
       aliased_mixin_app_class.mixin());
   // The name of the inserted mixin application class is the name of mixin
   // class name with a backtick added.
   String& inserted_class_name = String::Handle(zone, mixin_app_class.Name());
   inserted_class_name = String::Concat(inserted_class_name,
                                        Symbols::Backtick());
   const Library& library = Library::Handle(zone, mixin_app_class.library());
   Class& inserted_class = Class::Handle(zone,
       library.LookupLocalClass(inserted_class_name));
   if (inserted_class.IsNull()) {
-    inserted_class_name = Symbols::New(inserted_class_name);
+    inserted_class_name = Symbols::New(thread, inserted_class_name);
     const Script& script = Script::Handle(zone, mixin_app_class.script());
     inserted_class = Class::New(
         inserted_class_name, script, mixin_app_class.token_pos());
     inserted_class.set_is_synthesized_class();
     library.AddClass(inserted_class);
 
     if (FLAG_trace_class_finalization) {
       THR_Print("Creating mixin application alias %s\n",
                 inserted_class.ToCString());
     }
@@ skipping 208 matching lines @@
   // class, but it does not instantiate them.
   ASSERT(!mixin_type.IsMalbounded());
   mixin_app_class.set_mixin(mixin_type);
 }
 
 
 void ClassFinalizer::CreateForwardingConstructors(
     const Class& mixin_app,
     const Class& mixin_cls,
     const GrowableObjectArray& cloned_funcs) {
-  const String& mixin_name = String::Handle(mixin_app.Name());
-  const Class& super_class = Class::Handle(mixin_app.SuperClass());
-  const String& super_name = String::Handle(super_class.Name());
-  const Array& functions = Array::Handle(super_class.functions());
+  Thread* T = Thread::Current();
+  Zone* Z = T->zone();
+  const String& mixin_name = String::Handle(Z, mixin_app.Name());
+  const Class& super_class = Class::Handle(Z, mixin_app.SuperClass());
+  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();
+  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(func.name());
-      String& clone_name = String::Handle(
+      const String& ctor_name = String::Handle(Z, func.name());
+      String& clone_name = String::Handle(Z,
           String::SubString(ctor_name, super_name.Length()));
-      clone_name = Symbols::FromConcat(mixin_name, clone_name);
+      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.
       const PatchClass& owner =
-          PatchClass::Handle(PatchClass::New(mixin_app, mixin_cls));
+          PatchClass::Handle(Z, PatchClass::New(mixin_app, mixin_cls));
 
-      const Function& clone = Function::Handle(
+      const Function& clone = Function::Handle(Z,
           Function::New(clone_name,
                         func.kind(),
                         func.is_static(),
                         false,  // Not const.
                         false,  // Not abstract.
                         false,  // Not external.
                         false,  // Not native.
                         owner,
                         mixin_cls.token_pos()));
       clone.set_num_fixed_parameters(func.num_fixed_parameters());
       clone.SetNumOptionalParameters(func.NumOptionalParameters(),
                                      func.HasOptionalPositionalParameters());
       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(func.parameter_names());
+      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(Array::New(num_parameters)));
+      clone.set_parameter_types(Array::Handle(Z, Array::New(num_parameters)));
       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 510 matching lines @@
     collected_args.Add(arg);
   }
 }
 
 
 RawType* ClassFinalizer::ResolveMixinAppType(
     const Class& cls,
     const MixinAppType& mixin_app_type) {
   // Lookup or create mixin application classes in the library of cls
   // and resolve super type and mixin types.
-  Zone* zone = Thread::Current()->zone();
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
   const Library& library = Library::Handle(zone, cls.library());
   ASSERT(!library.IsNull());
   const Script& script = Script::Handle(zone, cls.script());
   ASSERT(!script.IsNull());
   const GrowableObjectArray& type_args =
       GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
   AbstractType& mixin_super_type =
       AbstractType::Handle(zone, mixin_app_type.super_type());
   ResolveType(cls, mixin_super_type);
   ASSERT(mixin_super_type.HasResolvedTypeClass());  // Even if malformed.
@@ skipping 56 matching lines @@
     // and is not reused in a context where this optimization is not possible.
     if (share_type_params) {
       mixin_app_class_name = String::Concat(mixin_app_class_name,
                                             Symbols::Ampersand());
     }
     mixin_type_class_name = mixin_type.ClassName();
     mixin_app_class_name = String::Concat(mixin_app_class_name,
                                           mixin_type_class_name);
     mixin_app_class = library.LookupLocalClass(mixin_app_class_name);
     if (mixin_app_class.IsNull()) {
-      mixin_app_class_name = Symbols::New(mixin_app_class_name);
+      mixin_app_class_name = Symbols::New(thread, mixin_app_class_name);
       mixin_app_class = Class::New(mixin_app_class_name,
                                    script,
                                    mixin_type.token_pos());
       mixin_app_class.set_super_type(mixin_super_type);
       mixin_type_class = mixin_type.type_class();
       const Type& generic_mixin_type = Type::Handle(zone,
           Type::New(mixin_type_class,
                     Object::null_type_arguments(),
                     mixin_type.token_pos()));
       mixin_app_class.set_mixin(generic_mixin_type);
@@ skipping 493 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart