Use isolate parameter while creating handles during class finalizers.

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 1254 matching lines @@
   //   conflict with an accessible static setter 'v=' of a super class).
   // The compile-time errors we report are:
   // - a static member 'v' conflicting with an inherited instance member 'v'.
   // - a static setter 'v=' conflicting with an inherited instance setter 'v='.
   // - an instance method conflicting with an inherited instance field or
   //   instance getter.
   // - an instance field or instance getter conflicting with an inherited
   //   instance method.
 
   // Resolve type of fields and check for conflicts in super classes.
-  Array& array = Array::Handle(cls.fields());
-  Field& field = Field::Handle();
-  AbstractType& type = AbstractType::Handle();
-  String& name = String::Handle();
-  String& getter_name = String::Handle();
-  String& setter_name = String::Handle();
-  Class& super_class = Class::Handle();
+  Isolate* I = Isolate::Current();
+  Array& array = Array::Handle(I, cls.fields());
+  Field& field = Field::Handle(I);
+  AbstractType& type = AbstractType::Handle(I);
+  String& name = String::Handle(I);
+  String& getter_name = String::Handle(I);
+  String& setter_name = String::Handle(I);
+  Class& super_class = Class::Handle(I);
   const intptr_t num_fields = array.Length();
   for (intptr_t i = 0; i < num_fields; i++) {
     field ^= array.At(i);
     type = field.type();
     type = FinalizeType(cls, type, kCanonicalize);
     field.set_type(type);
     name = field.name();
     if (field.is_static()) {
       getter_name = Field::GetterSymbol(name);
       super_class = FindSuperOwnerOfInstanceMember(cls, name, getter_name);
       if (!super_class.IsNull()) {
-        const String& class_name = String::Handle(cls.Name());
-        const String& super_class_name = String::Handle(super_class.Name());
+        const String& class_name = String::Handle(I, cls.Name());
+        const String& super_class_name = String::Handle(I, super_class.Name());
         ReportError(cls, field.token_pos(),
                     "static field '%s' of class '%s' conflicts with "
                     "instance member '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
       // An implicit setter is not generated for a static field, therefore, we
       // cannot rely on the code below handling the static setter case to report
       // a conflict with an instance setter. So we check explicitly here.
       setter_name = Field::SetterSymbol(name);
       super_class = FindSuperOwnerOfFunction(cls, setter_name);
       if (!super_class.IsNull()) {
-        const String& class_name = String::Handle(cls.Name());
-        const String& super_class_name = String::Handle(super_class.Name());
+        const String& class_name = String::Handle(I, cls.Name());
+        const String& super_class_name = String::Handle(I, super_class.Name());
         ReportError(cls, field.token_pos(),
                     "static field '%s' of class '%s' conflicts with "
                     "instance setter '%s=' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
 
     } else {
       // Instance field. Check whether the field overrides a method
       // (but not getter).
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
-        const String& class_name = String::Handle(cls.Name());
-        const String& super_class_name = String::Handle(super_class.Name());
+        const String& class_name = String::Handle(I, cls.Name());
+        const String& super_class_name = String::Handle(I, super_class.Name());
         ReportError(cls, field.token_pos(),
                     "field '%s' of class '%s' conflicts with method '%s' "
                     "of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     }
     if (field.is_static() &&
         (field.value() != Object::null()) &&
         (field.value() != Object::sentinel().raw())) {
       // The parser does not preset the value if the type is a type parameter or
       // is parameterized unless the value is null.
-      Error& error = Error::Handle();
+      Error& error = Error::Handle(I);
       if (type.IsMalformedOrMalbounded()) {
         error = type.error();
       } else {
         ASSERT(type.IsInstantiated());
       }
-      const Instance& const_value = Instance::Handle(field.value());
+      const Instance& const_value = Instance::Handle(I, field.value());
       if (!error.IsNull() ||
           (!type.IsDynamicType() &&
            !const_value.IsInstanceOf(type,
                                      Object::null_type_arguments(),
                                      &error))) {
         if (FLAG_error_on_bad_type) {
           const AbstractType& const_value_type = AbstractType::Handle(
-              const_value.GetType());
+              I, const_value.GetType());
           const String& const_value_type_name = String::Handle(
-              const_value_type.UserVisibleName());
-          const String& type_name = String::Handle(type.UserVisibleName());
+              I, const_value_type.UserVisibleName());
+          const String& type_name = String::Handle(I, type.UserVisibleName());
           ReportErrors(error, cls, field.token_pos(),
                        "error initializing static %s field '%s': "
                        "type '%s' is not a subtype of type '%s'",
                        field.is_const() ? "const" : "final",
                        name.ToCString(),
                        const_value_type_name.ToCString(),
                        type_name.ToCString());
         } else {
           // Do not report an error yet, even in checked mode, since the field
           // may not actually be used.
           // Also, we may be generating a snapshot in production mode that will
           // later be executed in checked mode, in which case an error needs to
           // be reported, should the field be accessed.
           // Therefore, we undo the optimization performed by the parser, i.e.
           // we create an implicit static final getter and reset the field value
           // to the sentinel value.
           const Function& getter = Function::Handle(
+              I,
               Function::New(getter_name,
                             RawFunction::kImplicitStaticFinalGetter,
                             /* is_static = */ true,
                             /* is_const = */ field.is_const(),
                             /* is_abstract = */ false,
                             /* is_external = */ false,
                             /* is_native = */ false,
                             cls,
                             field.token_pos()));
           getter.set_result_type(type);
           cls.AddFunction(getter);
-          field.set_value(Instance::Handle(Object::sentinel().raw()));
+          field.set_value(Instance::Handle(I, Object::sentinel().raw()));
         }
       }
     }
   }
   // Collect interfaces, super interfaces, and super classes of this class.
   const GrowableObjectArray& interfaces =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
+      GrowableObjectArray::Handle(I, GrowableObjectArray::New());
   CollectInterfaces(cls, interfaces);
   // Include superclasses in list of interfaces and super interfaces.
   super_class = cls.SuperClass();
   while (!super_class.IsNull()) {
     interfaces.Add(super_class);
     CollectInterfaces(super_class, interfaces);
     super_class = super_class.SuperClass();
   }
   // Resolve function signatures and check for conflicts in super classes and
   // interfaces.
   array = cls.functions();
-  Function& function = Function::Handle();
-  Function& overridden_function = Function::Handle();
+  Function& function = Function::Handle(I);
+  Function& overridden_function = Function::Handle(I);
   const intptr_t num_functions = array.Length();
-  Error& error = Error::Handle();
+  Error& error = Error::Handle(I);
   for (intptr_t i = 0; i < num_functions; i++) {
     function ^= array.At(i);
     ResolveAndFinalizeSignature(cls, function);
     name = function.name();
     if (FLAG_error_on_bad_override &&  // Report signature conflicts only.
         !function.is_static() && !function.IsConstructor()) {
       // A constructor cannot override anything.
       for (intptr_t i = 0; i < interfaces.Length(); i++) {
         super_class ^= interfaces.At(i);
         // Finalize superclass since overrides check relies on all members
         // of the superclass to be finalized.
         FinalizeClass(super_class);
         overridden_function = super_class.LookupDynamicFunction(name);
         if (!overridden_function.IsNull() &&
             !function.HasCompatibleParametersWith(overridden_function,
                                                   &error)) {
-          const String& class_name = String::Handle(cls.Name());
-          const String& super_class_name = String::Handle(super_class.Name());
+          const String& class_name = String::Handle(I, cls.Name());
+          const String& super_class_name =
+              String::Handle(I, super_class.Name());
           ReportErrors(error, cls, function.token_pos(),
                        "class '%s' overrides method '%s' of super "
                        "class '%s' with incompatible parameters",
                        class_name.ToCString(),
                        name.ToCString(),
                        super_class_name.ToCString());
         }
       }
     }
     if (function.IsSetterFunction() || function.IsImplicitSetterFunction()) {
       if (function.is_static()) {
         super_class = FindSuperOwnerOfFunction(cls, name);
         if (!super_class.IsNull()) {
-          const String& class_name = String::Handle(cls.Name());
-          const String& super_class_name = String::Handle(super_class.Name());
+          const String& class_name = String::Handle(I, cls.Name());
+          const String& super_class_name =
+              String::Handle(I, super_class.Name());
           ReportError(cls, function.token_pos(),
                       "static setter '%s=' of class '%s' conflicts with "
                       "instance setter '%s=' of super class '%s'",
                       name.ToCString(),
                       class_name.ToCString(),
                       name.ToCString(),
                       super_class_name.ToCString());
         }
       }
       continue;
     }
     if (function.IsGetterFunction() || function.IsImplicitGetterFunction()) {
       getter_name = name.raw();
       name = Field::NameFromGetter(getter_name);
     } else {
       getter_name = Field::GetterSymbol(name);
     }
     if (function.is_static()) {
       super_class = FindSuperOwnerOfInstanceMember(cls, name, getter_name);
       if (!super_class.IsNull()) {
-        const String& class_name = String::Handle(cls.Name());
-        const String& super_class_name = String::Handle(super_class.Name());
+        const String& class_name = String::Handle(I, cls.Name());
+        const String& super_class_name = String::Handle(I, super_class.Name());
         ReportError(cls, function.token_pos(),
                     "static %s '%s' of class '%s' conflicts with "
                     "instance member '%s' of super class '%s'",
                     (function.IsGetterFunction() ||
                      function.IsImplicitGetterFunction()) ? "getter" : "method",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
       if (function.IsRedirectingFactory()) {
         // The function may be a still unresolved redirecting factory. Do not
         // yet try to resolve it in order to avoid cycles in class finalization.
         // However, the redirection type should be finalized.
-        Type& type = Type::Handle(function.RedirectionType());
+        Type& type = Type::Handle(I, function.RedirectionType());
         type ^= FinalizeType(cls, type, kCanonicalize);
         function.SetRedirectionType(type);
       }
     } else if (function.IsGetterFunction() ||
                function.IsImplicitGetterFunction()) {
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
-        const String& class_name = String::Handle(cls.Name());
-        const String& super_class_name = String::Handle(super_class.Name());
+        const String& class_name = String::Handle(I, cls.Name());
+        const String& super_class_name = String::Handle(I, super_class.Name());
         ReportError(cls, function.token_pos(),
                     "getter '%s' of class '%s' conflicts with "
                     "method '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     } else if (!function.IsSetterFunction() &&
                !function.IsImplicitSetterFunction()) {
       // A function cannot conflict with a setter, since they cannot
       // have the same name. Thus, we do not need to check setters.
       super_class = FindSuperOwnerOfFunction(cls, getter_name);
       if (!super_class.IsNull()) {
-        const String& class_name = String::Handle(cls.Name());
-        const String& super_class_name = String::Handle(super_class.Name());
+        const String& class_name = String::Handle(I, cls.Name());
+        const String& super_class_name = String::Handle(I, super_class.Name());
         ReportError(cls, function.token_pos(),
                     "method '%s' of class '%s' conflicts with "
                     "getter '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     }
   }
@@ skipping 1556 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