Remove isolate argument from handle allocation: Part I

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 102 matching lines @@
 
 // Processing ObjectStore::pending_classes_ occurs:
 // a) when bootstrap process completes (VerifyBootstrapClasses).
 // b) after the user classes are loaded (dart_api).
 bool ClassFinalizer::ProcessPendingClasses() {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   HANDLESCOPE(thread);
   ObjectStore* object_store = isolate->object_store();
-  const Error& error = Error::Handle(isolate, object_store->sticky_error());
+  const Error& error =
+      Error::Handle(thread->zone(), object_store->sticky_error());
   if (!error.IsNull()) {
     return false;
   }
   if (AllClassesFinalized()) {
     return true;
   }
 
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     GrowableObjectArray& class_array = GrowableObjectArray::Handle();
@@ skipping 421 matching lines @@
 // The induced type set S consists of the super types of any type in S as well
 // as the type arguments of any parameterized type in S.
 // The Dart Language Specification does not disallow the declaration and use of
 // non-contractive types (this may change). They are nevertheless disallowed
 // as an implementation restriction in the VM since they cause divergence.
 // A non-contractive type can be detected by looking at the queue of types
 // pending finalization that are mutually recursive with the checked type.
 void ClassFinalizer::CheckRecursiveType(const Class& cls,
                                         const Type& type,
                                         PendingTypes* pending_types) {
-  Isolate* isolate = Isolate::Current();
+  Zone* zone = Thread::Current()->zone();
   if (FLAG_trace_type_finalization) {
     THR_Print("Checking recursive type '%s': %s\n",
               String::Handle(type.Name()).ToCString(),
               type.ToCString());
   }
-  const Class& type_cls = Class::Handle(isolate, type.type_class());
+  const Class& type_cls = Class::Handle(zone, type.type_class());
   const TypeArguments& arguments =
-      TypeArguments::Handle(isolate, type.arguments());
+      TypeArguments::Handle(zone, type.arguments());
   // A type can only be recursive via its type arguments.
   ASSERT(!arguments.IsNull());
   const intptr_t num_type_args = arguments.Length();
   ASSERT(num_type_args > 0);
   ASSERT(num_type_args == type_cls.NumTypeArguments());
   const intptr_t num_type_params = type_cls.NumTypeParameters();
   const intptr_t first_type_param = num_type_args - num_type_params;
   // If the type is not generic (num_type_params == 0) or if its type parameters
   // are instantiated, no divergence can occur. Note that if the type parameters
   // are null, i.e. if the generic type is raw, they are considered
   // instantiated and no divergence can occur.
   if ((num_type_params == 0) ||
       arguments.IsSubvectorInstantiated(first_type_param, num_type_params)) {
     return;
   }
   // The type parameters are not instantiated. Verify that there is no other
   // type pending finalization with the same type class, but different
   // uninstantiated type parameters.
-  TypeArguments& pending_arguments = TypeArguments::Handle(isolate);
+  TypeArguments& pending_arguments = TypeArguments::Handle(zone);
   const intptr_t num_pending_types = pending_types->length();
   for (intptr_t i = num_pending_types - 1; i >= 0; i--) {
     const Type& pending_type = Type::Cast(pending_types->At(i));
     if (FLAG_trace_type_finalization) {
       THR_Print("  Comparing with pending type '%s': %s\n",
                 String::Handle(pending_type.Name()).ToCString(),
                 pending_type.ToCString());
     }
     if ((pending_type.raw() != type.raw()) &&
         (pending_type.type_class() == type_cls.raw())) {
       pending_arguments = pending_type.arguments();
       if (!pending_arguments.IsSubvectorEquivalent(arguments,
                                                    first_type_param,
                                                    num_type_params) &&
           !pending_arguments.IsSubvectorInstantiated(first_type_param,
                                                      num_type_params)) {
         // Reject the non-contractive recursive type.
-        const String& type_name = String::Handle(isolate, type.Name());
+        const String& type_name = String::Handle(zone, type.Name());
         ReportError(cls, type.token_pos(),
                     "illegal recursive type '%s'", type_name.ToCString());
       }
     }
   }
 }
 
 
 // Finalize the type argument vector 'arguments' of the type defined by the
 // class 'cls' parameterized with the type arguments 'cls_args'.
@@ skipping 945 matching lines @@
 //   class C<E extends BE> extends S<E> with M<List<E>> { }
 // results in
 //   class S&M<T`, T extends BT> extends S<T`> implements M<T> { }
 //   class C<E extends BE> extends S&M<E, List<E>> { }
 // CloneMixinAppTypeParameters decorates class S&M with type parameters T` and
 // T, and use them as type arguments in S<T`> and M<T>.
 // Note that the bound BT on T of S is not applied to T` of S&M. However, the
 // bound BT on T of M is applied to T of S&M. See comments below.
 void ClassFinalizer::CloneMixinAppTypeParameters(const Class& mixin_app_class) {
   ASSERT(mixin_app_class.type_parameters() == TypeArguments::null());
-  Isolate* isolate = Isolate::Current();
-  const AbstractType& super_type = AbstractType::Handle(isolate,
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  const AbstractType& super_type = AbstractType::Handle(zone,
       mixin_app_class.super_type());
   ASSERT(super_type.IsResolved());
-  const Class& super_class = Class::Handle(isolate, super_type.type_class());
+  const Class& super_class = Class::Handle(zone, super_type.type_class());
   const intptr_t num_super_type_params = super_class.NumTypeParameters();
-  const Type& mixin_type = Type::Handle(isolate, mixin_app_class.mixin());
-  const Class& mixin_class = Class::Handle(isolate, mixin_type.type_class());
+  const Type& mixin_type = Type::Handle(zone, mixin_app_class.mixin());
+  const Class& mixin_class = Class::Handle(zone, mixin_type.type_class());
   const intptr_t num_mixin_type_params = mixin_class.NumTypeParameters();
 
   // The mixin type (in raw form) should have been added to the interfaces
   // implemented by the mixin application class. This is necessary so that cycle
   // check works at compile time (type arguments are ignored) and so that
   // type tests work at runtime (by then, type arguments will have been set, see
   // below).
   ASSERT(mixin_app_class.interfaces() != Object::empty_array().raw());
 
   // If both the super type and the mixin type are non generic, the mixin
   // application class is non generic as well and we can skip type parameter
   // cloning.
-  TypeArguments& instantiator = TypeArguments::Handle(isolate);
+  TypeArguments& instantiator = TypeArguments::Handle(zone);
   if ((num_super_type_params + num_mixin_type_params) > 0) {
     // If the last ampersand in the name of the mixin application class is
     // doubled, the same type parameters can propagate the type arguments to
     // the super type and to the mixin type.
     bool share_type_params = false;
     if (num_super_type_params == num_mixin_type_params) {
-      const String& name = String::Handle(isolate, mixin_app_class.Name());
+      const String& name = String::Handle(zone, mixin_app_class.Name());
       for (intptr_t i = name.Length() - 1; i > 0; --i) {
         if (name.CharAt(i) == '&') {
           if (name.CharAt(i - 1) == '&') {
             share_type_params = true;
           }
           break;
         }
       }
     }
 
-    const TypeArguments& cloned_type_params = TypeArguments::Handle(isolate,
+    const TypeArguments& cloned_type_params = TypeArguments::Handle(zone,
         TypeArguments::New((share_type_params ? 0 : num_super_type_params) +
                            num_mixin_type_params));
-    TypeParameter& param = TypeParameter::Handle(isolate);
-    TypeParameter& cloned_param = TypeParameter::Handle(isolate);
-    String& param_name = String::Handle(isolate);
-    AbstractType& param_bound = AbstractType::Handle(isolate);
+    TypeParameter& param = TypeParameter::Handle(zone);
+    TypeParameter& cloned_param = TypeParameter::Handle(zone);
+    String& param_name = String::Handle(zone);
+    AbstractType& param_bound = AbstractType::Handle(zone);
     intptr_t cloned_index = 0;
 
     // First, clone the super class type parameters. Rename them so that
     // there can be no name conflict between the parameters of the super
     // class and the mixin class.
     if (!share_type_params && (num_super_type_params > 0)) {
       const TypeArguments& super_type_params =
-          TypeArguments::Handle(isolate, super_class.type_parameters());
-      const TypeArguments& super_type_args = TypeArguments::Handle(isolate,
+          TypeArguments::Handle(zone, super_class.type_parameters());
+      const TypeArguments& super_type_args = TypeArguments::Handle(zone,
           TypeArguments::New(num_super_type_params));
       // The cloned super class type parameters do not need to repeat their
       // bounds, since the bound checks will be performed at the super class
       // 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 = isolate->object_store()->object_type();
+      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());
         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++;
       }
       // The super type may have a BoundedType as type argument, but cannot be
       // a BoundedType itself.
       Type::Cast(super_type).set_arguments(super_type_args);
       ASSERT(!super_type.IsFinalized());
     }
 
     // Second, clone the type parameters of the mixin class.
     // We need to retain the parameter names of the mixin class
     // since the code that will be compiled in the context of the
     // mixin application class may refer to the type parameters
     // with that name. We also retain the type parameter bounds.
     if (num_mixin_type_params > 0) {
       const TypeArguments& mixin_params =
-          TypeArguments::Handle(isolate, mixin_class.type_parameters());
+          TypeArguments::Handle(zone, mixin_class.type_parameters());
       const intptr_t offset =
           mixin_class.NumTypeArguments() - mixin_class.NumTypeParameters();
-      const TypeArguments& mixin_type_args = TypeArguments::Handle(isolate,
+      const TypeArguments& mixin_type_args = TypeArguments::Handle(zone,
           TypeArguments::New(num_mixin_type_params));
       instantiator ^= TypeArguments::New(offset + num_mixin_type_params);
       bool has_uninstantiated_bounds = false;
       for (intptr_t i = 0; i < num_mixin_type_params; i++) {
         param ^= mixin_params.TypeAt(i);
         param_name = param.name();
         param_bound = param.bound();  // The bound will be adjusted below.
         if (!param_bound.IsInstantiated()) {
           has_uninstantiated_bounds = true;
         }
@@ skipping 11 matching lines @@
       // Third, replace the type parameters appearing in the bounds of the mixin
       // type parameters, if any, by the cloned type parameters. This can be
       // done by instantiating each bound using the instantiator built above.
       // If the mixin class extends a generic super class, its first finalized
       // type parameter has a non-zero index, therefore, the instantiator
       // requires shifting by the offset calculated above.
       // Unfinalized type parameters replace finalized type parameters, which
       // is not a problem since they will get finalized shortly as the mixin
       // application class gets finalized.
       if (has_uninstantiated_bounds) {
-        Error& bound_error = Error::Handle(isolate);
+        Error& bound_error = Error::Handle(zone);
         for (intptr_t i = 0; i < num_mixin_type_params; i++) {
           param ^= mixin_type_args.TypeAt(i);
           param_bound = param.bound();
           if (!param_bound.IsInstantiated()) {
             // Make sure the bound is finalized before instantiating it.
             if (!param_bound.IsFinalized() &&
                 !param_bound.IsBeingFinalized()) {
               param_bound =
                   FinalizeType(mixin_app_class, param_bound, kCanonicalize);
               param.set_bound(param_bound);  // In case part of recursive type.
@@ skipping 100 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.
-  Isolate* isolate = Isolate::Current();
-  AbstractType& super_type = AbstractType::Handle(isolate,
+  Zone* zone = Thread::Current()->zone();
+  AbstractType& super_type = AbstractType::Handle(zone,
                                                   mixin_app_class.super_type());
-  const Type& mixin_type = Type::Handle(isolate, mixin_app_class.mixin());
-  const Class& mixin_class = Class::Handle(isolate, mixin_type.type_class());
+  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(isolate,
+  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(isolate,
+  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(isolate, mixin_app_class.Name());
+  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(isolate, mixin_app_class.library());
-  Class& inserted_class = Class::Handle(isolate,
+  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);
-    const Script& script = Script::Handle(isolate, mixin_app_class.script());
+    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());
     }
 
     // The super type of the inserted class is identical to the super type of
     // this mixin application class, except that it must refer to the type
     // parameters of the inserted class rather than to those of the mixin
     // application class.
     // The type arguments of the super type will be set properly when calling
     // CloneMixinAppTypeParameters on the inserted class, as long as the super
     // type class is set properly.
     inserted_class.set_super_type(super_type);  // Super class only is used.
 
     // The mixin type and interface type must also be set before calling
     // CloneMixinAppTypeParameters.
     // After FinalizeTypesInClass, if the mixin type and interface type are
     // generic, their type arguments will refer to the type parameters of
     // inserted_class.
-    const Type& inserted_class_mixin_type = Type::Handle(isolate,
-        Type::New(Class::Handle(isolate, aliased_mixin_type.type_class()),
+    const Type& inserted_class_mixin_type = Type::Handle(zone,
+        Type::New(Class::Handle(zone, aliased_mixin_type.type_class()),
                   Object::null_type_arguments(),
                   aliased_mixin_type.token_pos()));
     inserted_class.set_mixin(inserted_class_mixin_type);
     // Add the mixin type to the list of interfaces that the mixin application
     // class implements. This is necessary so that cycle check work at
     // compile time (type arguments are ignored by that check).
     const Array& interfaces = Array::Handle(Array::New(1));
     interfaces.SetAt(0, inserted_class_mixin_type);
     ASSERT(inserted_class.interfaces() == Object::empty_array().raw());
     inserted_class.set_interfaces(interfaces);
@@ skipping 10 matching lines @@
   // old super type arguments (propagating type arguments to the super class)
   // with new type arguments providing type arguments to the mixin.
   // The appended type arguments are those of the super type of the mixin
   // application alias that are forwarding to the aliased mixin type, except
   // that they must refer to the type parameters of the mixin application
   // class rather than to those of the mixin application alias class.
   // This type parameter substitution is performed by an instantiation step.
   // It is important that the type parameters of the mixin application class
   // are not finalized yet, because new type parameters may have been added
   // to the super class.
-  const Class& super_class = Class::Handle(isolate, super_type.type_class());
+  const Class& super_class = Class::Handle(zone, super_type.type_class());
   ASSERT(mixin_app_class.SuperClass() == super_class.raw());  // Will change.
   const intptr_t num_super_type_params = super_class.NumTypeParameters();
-  AbstractType& type = AbstractType::Handle(isolate);
+  AbstractType& type = AbstractType::Handle(zone);
   // The instantiator is mapping finalized type parameters of mixin_class to
   // unfinalized type parameters of mixin_app_class.
   ASSERT(aliased_mixin_type.IsFinalized());
-  const Class& aliased_mixin_type_class = Class::Handle(isolate,
+  const Class& aliased_mixin_type_class = Class::Handle(zone,
       aliased_mixin_type.type_class());
   const intptr_t num_aliased_mixin_type_params =
       aliased_mixin_type_class.NumTypeParameters();
   ASSERT(inserted_class.NumTypeParameters() ==
          (num_super_type_params + num_aliased_mixin_type_params));
   const AbstractType& mixin_class_super_type =
-      AbstractType::Handle(isolate, mixin_class.super_type());
+      AbstractType::Handle(zone, mixin_class.super_type());
   ASSERT(mixin_class_super_type.IsFinalized());
   // The aliased_mixin_type may be raw.
   const TypeArguments& mixin_class_super_type_args =
-      TypeArguments::Handle(isolate, mixin_class_super_type.arguments());
-  TypeArguments& new_mixin_type_args = TypeArguments::Handle(isolate);
+      TypeArguments::Handle(zone, mixin_class_super_type.arguments());
+  TypeArguments& new_mixin_type_args = TypeArguments::Handle(zone);
   if ((num_aliased_mixin_type_params > 0) &&
       !mixin_class_super_type_args.IsNull()) {
     new_mixin_type_args = TypeArguments::New(num_aliased_mixin_type_params);
-    AbstractType& bounded_type = AbstractType::Handle(isolate);
-    AbstractType& upper_bound = AbstractType::Handle(isolate);
-    TypeParameter& type_parameter = TypeParameter::Handle(isolate);
-    Error& bound_error = Error::Handle(isolate);
+    AbstractType& bounded_type = AbstractType::Handle(zone);
+    AbstractType& upper_bound = AbstractType::Handle(zone);
+    TypeParameter& type_parameter = TypeParameter::Handle(zone);
+    Error& bound_error = Error::Handle(zone);
     const intptr_t offset =
         mixin_class_super_type_args.Length() - num_aliased_mixin_type_params;
     for (intptr_t i = 0; i < num_aliased_mixin_type_params; i++) {
       type = mixin_class_super_type_args.TypeAt(offset + i);
       if (!type.IsInstantiated()) {
         // In the presence of bounds, the bounded type and the upper bound must
         // be instantiated separately. Instantiating a BoundedType would wrap
         // the BoundedType in another BoundedType.
         if (type.IsBoundedType()) {
           bounded_type = BoundedType::Cast(type).type();
           bounded_type = bounded_type.InstantiateFrom(instantiator,
                                                       &bound_error);
           // The instantiator contains only TypeParameter objects and no
           // BoundedType objects, so no bound error may occur.
           ASSERT(bound_error.IsNull());
           upper_bound = BoundedType::Cast(type).bound();
           upper_bound = upper_bound.InstantiateFrom(instantiator, &bound_error);
           ASSERT(bound_error.IsNull());
           type_parameter = BoundedType::Cast(type).type_parameter();
           // The type parameter that declared the bound does not change.
           type = BoundedType::New(bounded_type, upper_bound, type_parameter);
         } else {
           type = type.InstantiateFrom(instantiator, &bound_error);
           ASSERT(bound_error.IsNull());
         }
       }
       new_mixin_type_args.SetTypeAt(i, type);
     }
   }
-  TypeArguments& new_super_type_args = TypeArguments::Handle(isolate);
+  TypeArguments& new_super_type_args = TypeArguments::Handle(zone);
   if ((num_super_type_params + num_aliased_mixin_type_params) > 0) {
     new_super_type_args = TypeArguments::New(num_super_type_params +
                                              num_aliased_mixin_type_params);
     const TypeArguments& type_params =
-        TypeArguments::Handle(isolate, mixin_app_class.type_parameters());
+        TypeArguments::Handle(zone, mixin_app_class.type_parameters());
     for (intptr_t i = 0; i < num_super_type_params; i++) {
       type = type_params.TypeAt(i);
       new_super_type_args.SetTypeAt(i, type);
     }
     for (intptr_t i = 0; i < num_aliased_mixin_type_params; i++) {
       if (new_mixin_type_args.IsNull()) {
         type = Type::DynamicType();
       } else {
         type = new_mixin_type_args.TypeAt(i);
       }
       new_super_type_args.SetTypeAt(num_super_type_params + i, type);
     }
   }
   super_type = Type::New(inserted_class,
                          new_super_type_args,
                          mixin_app_class.token_pos());
   mixin_app_class.set_super_type(super_type);
 
   // Mark this mixin application class as being an alias.
   mixin_app_class.set_is_mixin_app_alias();
   ASSERT(!mixin_app_class.is_type_finalized());
   ASSERT(!mixin_app_class.is_mixin_type_applied());
   if (FLAG_trace_class_finalization) {
     THR_Print("Inserting class '%s' %s\n"
               "  as super type '%s' with %" Pd " type args: %s\n"
               "  of mixin application alias '%s' %s\n",
               String::Handle(inserted_class.Name()).ToCString(),
               TypeArguments::Handle(
                   inserted_class.type_parameters()).ToCString(),
-              String::Handle(isolate, super_type.Name()).ToCString(),
+              String::Handle(zone, super_type.Name()).ToCString(),
               num_super_type_params + num_aliased_mixin_type_params,
               super_type.ToCString(),
               String::Handle(mixin_app_class.Name()).ToCString(),
               TypeArguments::Handle(
                   mixin_app_class.type_parameters()).ToCString());
   }
 }
 
 
 void ClassFinalizer::ApplyMixinType(const Class& mixin_app_class,
@@ skipping 611 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.
-  Isolate* isolate = Isolate::Current();
-  const Library& library = Library::Handle(isolate, cls.library());
+  Zone* zone = Thread::Current()->zone();
+  const Library& library = Library::Handle(zone, cls.library());
   ASSERT(!library.IsNull());
-  const Script& script = Script::Handle(isolate, cls.script());
+  const Script& script = Script::Handle(zone, cls.script());
   ASSERT(!script.IsNull());
   const GrowableObjectArray& type_args =
-      GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
+      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
   AbstractType& mixin_super_type =
-      AbstractType::Handle(isolate, mixin_app_type.super_type());
+      AbstractType::Handle(zone, mixin_app_type.super_type());
   ResolveType(cls, mixin_super_type);
   ASSERT(mixin_super_type.HasResolvedTypeClass());  // Even if malformed.
   // The super type may have a BoundedType as type argument, but cannot be
   // a BoundedType itself.
   CollectTypeArguments(cls, Type::Cast(mixin_super_type), type_args);
-  AbstractType& mixin_type = AbstractType::Handle(isolate);
-  Class& mixin_type_class = Class::Handle(isolate);
-  Class& mixin_app_class = Class::Handle(isolate);
-  String& mixin_app_class_name = String::Handle(isolate);
-  String& mixin_type_class_name = String::Handle(isolate);
-  AbstractType& super_type_arg = AbstractType::Handle(isolate);
-  AbstractType& mixin_type_arg = AbstractType::Handle(isolate);
+  AbstractType& mixin_type = AbstractType::Handle(zone);
+  Class& mixin_type_class = Class::Handle(zone);
+  Class& mixin_app_class = Class::Handle(zone);
+  String& mixin_app_class_name = String::Handle(zone);
+  String& mixin_type_class_name = String::Handle(zone);
+  AbstractType& super_type_arg = AbstractType::Handle(zone);
+  AbstractType& mixin_type_arg = AbstractType::Handle(zone);
   const intptr_t depth = mixin_app_type.Depth();
   for (intptr_t i = 0; i < depth; i++) {
     mixin_type = mixin_app_type.MixinTypeAt(i);
     ASSERT(!mixin_type.IsNull());
     ResolveType(cls, mixin_type);
     ASSERT(mixin_type.HasResolvedTypeClass());  // Even if malformed.
     ASSERT(mixin_type.IsType());
     const intptr_t num_super_type_args = type_args.Length();
     CollectTypeArguments(cls, Type::Cast(mixin_type), type_args);
 
@@ skipping 34 matching lines @@
     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 = 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(isolate,
+      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);
       // Add the mixin type to the list of interfaces that the mixin application
       // class implements. This is necessary so that cycle check work at
       // compile time (type arguments are ignored by that check).
-      const Array& interfaces = Array::Handle(isolate, Array::New(1));
+      const Array& interfaces = Array::Handle(zone, Array::New(1));
       interfaces.SetAt(0, generic_mixin_type);
       ASSERT(mixin_app_class.interfaces() == Object::empty_array().raw());
       mixin_app_class.set_interfaces(interfaces);
       mixin_app_class.set_is_synthesized_class();
       library.AddClass(mixin_app_class);
 
       // No need to add the new class to pending_classes, since it will be
       // processed via the super_type chain of a pending class.
 
       if (FLAG_trace_class_finalization) {
         THR_Print("Creating mixin application %s\n",
                   mixin_app_class.ToCString());
       }
     }
     // This mixin application class becomes the type class of the super type of
     // the next mixin application class. It is however too early to provide the
     // correct super type arguments. We use the raw type for now.
     mixin_super_type = Type::New(mixin_app_class,
                                  Object::null_type_arguments(),
                                  mixin_type.token_pos());
   }
-  TypeArguments& mixin_app_args = TypeArguments::Handle(isolate);
+  TypeArguments& mixin_app_args = TypeArguments::Handle(zone);
   if (type_args.Length() > 0) {
     mixin_app_args = TypeArguments::New(type_args.Length());
-    AbstractType& type_arg = AbstractType::Handle(isolate);
+    AbstractType& type_arg = AbstractType::Handle(zone);
     for (intptr_t i = 0; i < type_args.Length(); i++) {
       type_arg ^= type_args.At(i);
       mixin_app_args.SetTypeAt(i, type_arg);
     }
   }
   if (FLAG_trace_class_finalization) {
     THR_Print("ResolveMixinAppType: mixin appl type args: %s\n",
               mixin_app_args.ToCString());
   }
   // The mixin application class at depth k is a subclass of mixin application
@@ skipping 15 matching lines @@
 // we found a loop.
 void ClassFinalizer::ResolveSuperTypeAndInterfaces(
     const Class& cls, GrowableArray<intptr_t>* visited) {
   if (cls.is_cycle_free()) {
     return;
   }
   ASSERT(visited != NULL);
   if (FLAG_trace_class_finalization) {
     THR_Print("Resolving super and interfaces: %s\n", cls.ToCString());
   }
-  Isolate* isolate = Isolate::Current();
+  Zone* zone = Thread::Current()->zone();
   const intptr_t cls_index = cls.id();
   for (intptr_t i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // We have already visited class 'cls'. We found a cycle.
-      const String& class_name = String::Handle(isolate, cls.Name());
+      const String& class_name = String::Handle(zone, cls.Name());
       ReportError(cls, cls.token_pos(),
                   "cyclic reference found for class '%s'",
                   class_name.ToCString());
     }
   }
 
   // If the class/interface has no explicit super class/interfaces
   // and is not a mixin application, we are done.
-  AbstractType& super_type = AbstractType::Handle(isolate, cls.super_type());
-  Array& super_interfaces = Array::Handle(isolate, cls.interfaces());
+  AbstractType& super_type = AbstractType::Handle(zone, cls.super_type());
+  Array& super_interfaces = Array::Handle(zone, cls.interfaces());
   if ((super_type.IsNull() || super_type.IsObjectType()) &&
       (super_interfaces.Length() == 0)) {
     cls.set_is_cycle_free();
     return;
   }
 
   if (super_type.IsMixinAppType()) {
     // For the cycle check below to work, ResolveMixinAppType needs to set
     // the mixin interfaces in the super classes, even if only in raw form.
     // It is indeed too early to set the correct type arguments, which is not
     // a problem since they are ignored in the cycle check.
     const MixinAppType& mixin_app_type = MixinAppType::Cast(super_type);
     super_type = ResolveMixinAppType(cls, mixin_app_type);
     cls.set_super_type(super_type);
   }
 
   // If cls belongs to core lib, restrictions about allowed interfaces
   // are lifted.
   const bool cls_belongs_to_core_lib = cls.library() == Library::CoreLibrary();
 
   // Resolve and check the super type and interfaces of cls.
   visited->Add(cls_index);
-  AbstractType& interface = AbstractType::Handle(isolate);
-  Class& interface_class = Class::Handle(isolate);
+  AbstractType& interface = AbstractType::Handle(zone);
+  Class& interface_class = Class::Handle(zone);
 
   // Resolve super type. Failures lead to a longjmp.
   ResolveType(cls, super_type);
   if (super_type.IsMalformedOrMalbounded()) {
-    ReportError(Error::Handle(isolate, super_type.error()));
+    ReportError(Error::Handle(zone, super_type.error()));
   }
   if (super_type.IsDynamicType()) {
     ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend 'dynamic'",
-                String::Handle(isolate, cls.Name()).ToCString());
+                String::Handle(zone, cls.Name()).ToCString());
   }
   interface_class = super_type.type_class();
   if (interface_class.IsSignatureClass()) {
     ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend function type alias '%s'",
-                String::Handle(isolate, cls.Name()).ToCString(),
-                String::Handle(isolate,
+                String::Handle(zone, cls.Name()).ToCString(),
+                String::Handle(zone,
                                super_type.UserVisibleName()).ToCString());
   }
   if (interface_class.is_enum_class()) {
     ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend enum '%s'",
-                String::Handle(isolate, cls.Name()).ToCString(),
-                String::Handle(isolate, interface_class.Name()).ToCString());
+                String::Handle(zone, cls.Name()).ToCString(),
+                String::Handle(zone, interface_class.Name()).ToCString());
   }
 
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   if (!cls_belongs_to_core_lib) {
     // Prevent extending core implementation classes.
     bool is_error = false;
     switch (interface_class.id()) {
       case kNumberCid:
       case kIntegerCid:  // Class Integer, not int.
@@ skipping 24 matching lines @@
         // Special case: classes for which we don't have a known class id.
         if (super_type.IsDoubleType() ||
             super_type.IsIntType() ||
             super_type.IsStringType()) {
           is_error = true;
         }
         break;
       }
     }
     if (is_error) {
-      const String& interface_name = String::Handle(isolate,
+      const String& interface_name = String::Handle(zone,
                                                     interface_class.Name());
       ReportError(cls, cls.token_pos(),
                   "'%s' is not allowed to extend '%s'",
-                  String::Handle(isolate, cls.Name()).ToCString(),
+                  String::Handle(zone, cls.Name()).ToCString(),
                   interface_name.ToCString());
     }
   }
   // Now resolve the super interfaces of the super type.
   ResolveSuperTypeAndInterfaces(interface_class, visited);
 
   // Resolve interfaces. Failures lead to a longjmp.
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
     ResolveType(cls, interface);
     ASSERT(!interface.IsTypeParameter());  // Should be detected by parser.
     // A malbounded interface is only reported when involved in a type test.
     if (interface.IsMalformed()) {
-      ReportError(Error::Handle(isolate, interface.error()));
+      ReportError(Error::Handle(zone, interface.error()));
     }
     if (interface.IsDynamicType()) {
       ReportError(cls, cls.token_pos(),
                   "'dynamic' may not be used as interface");
     }
     interface_class = interface.type_class();
     if (interface_class.IsSignatureClass()) {
-      const String& interface_name = String::Handle(isolate,
+      const String& interface_name = String::Handle(zone,
                                                     interface_class.Name());
       ReportError(cls, cls.token_pos(),
                   "function type alias '%s' may not be used as interface",
                   interface_name.ToCString());
     }
     if (interface_class.is_enum_class()) {
-      const String& interface_name = String::Handle(isolate,
+      const String& interface_name = String::Handle(zone,
                                                     interface_class.Name());
       ReportError(cls, cls.token_pos(),
                   "enum '%s' may not be used as interface",
                   interface_name.ToCString());
     }
     // Verify that unless cls belongs to core lib, it cannot extend, implement,
     // or mixin any of Null, bool, num, int, double, String, dynamic.
     if (!cls_belongs_to_core_lib) {
       if (interface.IsBoolType() ||
           interface.IsNullType() ||
           interface.IsNumberType() ||
           interface.IsIntType() ||
           interface.IsDoubleType() ||
           interface.IsStringType() ||
           interface.IsDynamicType()) {
-        const String& interface_name = String::Handle(isolate,
+        const String& interface_name = String::Handle(zone,
                                                       interface_class.Name());
         if (cls.IsMixinApplication()) {
           ReportError(cls, cls.token_pos(),
                       "illegal mixin of '%s'",
                       interface_name.ToCString());
         } else {
           ReportError(cls, cls.token_pos(),
                       "'%s' is not allowed to extend or implement '%s'",
-                      String::Handle(isolate, cls.Name()).ToCString(),
+                      String::Handle(zone, cls.Name()).ToCString(),
                       interface_name.ToCString());
         }
       }
     }
     interface_class.set_is_implemented();
     // Now resolve the super interfaces.
     ResolveSuperTypeAndInterfaces(interface_class, visited);
   }
   visited->RemoveLast();
   cls.set_is_cycle_free();
@@ skipping 251 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