Add a first class GrowableObjectArray type in the VM and use it internally in the VM at all spots w…

vm/class_finalizer.cc

 // Copyright (c) 2012, 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/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_classes, false, "Prints details about loaded classes.");
 DEFINE_FLAG(bool, trace_class_finalization, false, "Trace class finalization.");
 DEFINE_FLAG(bool, trace_type_finalization, false, "Trace type finalization.");
 DEFINE_FLAG(bool, verify_implements, false,
     "Verify that all classes implement their interface.");
 DECLARE_FLAG(bool, enable_type_checks);
 
-void ClassFinalizer::AddPendingClasses(
-    const GrowableArray<const Class*>& classes) {
-  if (!classes.is_empty()) {
-    ObjectStore* object_store = Isolate::Current()->object_store();
-    const Array& old_array = Array::Handle(object_store->pending_classes());
-    const intptr_t old_length = old_array.Length();
-    const int new_length = old_length + classes.length();
-    const Array& new_array = Array::Handle(Array::Grow(old_array, new_length));
-    // Add new classes.
-    for (int i = 0; i < classes.length(); i++) {
-      new_array.SetAt(i + old_length, *classes[i]);
-    }
-    object_store->set_pending_classes(new_array);
-  }
-}
-
 
 bool ClassFinalizer::AllClassesFinalized() {
   ObjectStore* object_store = Isolate::Current()->object_store();
-  const Array& classes = Array::Handle(object_store->pending_classes());
+  const GrowableObjectArray& classes =
+      GrowableObjectArray::Handle(object_store->pending_classes());
   return classes.Length() == 0;
 }
 
 
 // Class finalization occurs:
 // a) when bootstrap process completes (VerifyBootstrapClasses).
 // b) after the user classes are loaded (dart_api).
 bool ClassFinalizer::FinalizePendingClasses(bool generating_snapshot) {
   bool retval = true;
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ObjectStore* object_store = isolate->object_store();
   const Error& error = Error::Handle(object_store->sticky_error());
   if (!error.IsNull()) {
     return false;
   }
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
-    const Array& class_array = Array::Handle(object_store->pending_classes());
+    GrowableObjectArray& class_array = GrowableObjectArray::Handle();
+    class_array = object_store->pending_classes();
     ASSERT(!class_array.IsNull());
     Class& cls = Class::Handle();
     // First resolve all superclasses.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       if (FLAG_trace_class_finalization) {
         OS::Print("Resolving super and default: %s\n", cls.ToCString());
       }
       ResolveSuperType(cls);
       if (cls.is_interface()) {
@@ skipping 13 matching lines @@
     }
     if (FLAG_verify_implements) {
       for (intptr_t i = 0; i < class_array.Length(); i++) {
         cls ^= class_array.At(i);
         if (!cls.is_interface()) {
           VerifyClassImplements(cls);
         }
       }
     }
     // Clear pending classes array.
-    object_store->set_pending_classes(Array::Handle(Array::Empty()));
+    class_array = GrowableObjectArray::New();
+    object_store->set_pending_classes(class_array);
 
     // Check to ensure there are no duplicate definitions in the library
     // hierarchy.
     const String& str = String::Handle(Library::CheckForDuplicateDefinition());
     if (!str.IsNull()) {
       ReportError("Duplicate definition : %s\n", str.ToCString());
     }
   } else {
     retval = false;
   }
   isolate->set_long_jump_base(base);
   return retval;
 }
 
 
 #if defined (DEBUG)
 // Adds all interfaces of cls into 'collected'. Duplicate entries may occur.
 // No cycles are allowed.
 void ClassFinalizer::CollectInterfaces(const Class& cls,
-                                       GrowableArray<const Class*>* collected) {
+                                       const GrowableObjectArray& collected) {
   const Array& interface_array = Array::ZoneHandle(cls.interfaces());
+  AbstractType& interface = AbstractType::Handle();
+  Class& interface_class = Class::Handle();
   for (intptr_t i = 0; i < interface_array.Length(); i++) {
-    AbstractType& interface = AbstractType::Handle();
     interface ^= interface_array.At(i);
-    const Class& interface_class = Class::ZoneHandle(interface.type_class());
-    collected->Add(&interface_class);
+    interface_class = interface.type_class();
+    collected.Add(interface_class);
     CollectInterfaces(interface_class, collected);
   }
 }
 
 
 // Collect all interfaces of the class 'cls' and check that every function
 // defined in each interface can be found in the class.
 // No need to check instance fields since they have been turned into
 // getters/setters.
 void ClassFinalizer::VerifyClassImplements(const Class& cls) {
   ASSERT(!cls.is_interface());
-  GrowableArray<const Class*> interfaces;
-  CollectInterfaces(cls, &interfaces);
+  const GrowableObjectArray& interfaces =
+      GrowableObjectArray::Handle(GrowableObjectArray::New());
+  CollectInterfaces(cls, interfaces);
   const String& class_name = String::Handle(cls.Name());
-  for (int i = 0; i < interfaces.length(); i++) {
-    const String& interface_name = String::Handle(interfaces[i]->Name());
-    const Array& interface_functions =
-        Array::Handle(interfaces[i]->functions());
+  Class& interface_class = Class::Handle();
+  String& interface_name = String::Handle();
+  Array& interface_functions = Array::Handle();
+  for (int i = 0; i < interfaces.Length(); i++) {
+    interface_class ^= interfaces.At(i);
+    interface_name = interface_class.Name();
+    interface_functions = interface_class.functions();
     for (intptr_t f = 0; f < interface_functions.Length(); f++) {
       Function& interface_function = Function::Handle();
       interface_function ^= interface_functions.At(f);
       const String& function_name = String::Handle(interface_function.name());
       // Check for constructor/factory.
       if (function_name.StartsWith(interface_name)) {
         // TODO(srdjan): convert 'InterfaceName.' to 'ClassName.' and check.
         continue;
       }
       if (interface_function.kind() == RawFunction::kConstImplicitGetter) {
@@ skipping 71 matching lines @@
   ASSERT(Array::InstanceSize() == cls.instance_size());
   cls = object_store->immutable_array_class();
   ASSERT(ImmutableArray::InstanceSize() == cls.instance_size());
   cls = object_store->internal_byte_array_class();
   ASSERT(InternalByteArray::InstanceSize() == cls.instance_size());
   cls = object_store->external_byte_array_class();
   ASSERT(ExternalByteArray::InstanceSize() == cls.instance_size());
 #endif  // defined(DEBUG)
 
   // Remember the currently pending classes.
-  const Array& class_array = Array::Handle(object_store->pending_classes());
+  const GrowableObjectArray& class_array =
+      GrowableObjectArray::Handle(object_store->pending_classes());
   for (intptr_t i = 0; i < class_array.Length(); i++) {
     // TODO(iposva): Add real checks.
     cls ^= class_array.At(i);
     if (cls.is_finalized() || cls.is_prefinalized()) {
       // Pre-finalized bootstrap classes must not define any fields.
       ASSERT(Array::Handle(cls.fields()).Length() == 0);
     }
   }
 
   // Finalize classes that aren't pre-finalized by Object::Init().
@@ skipping 659 matching lines @@
   }
   // Signature classes are finalized upon creation.
   ASSERT(!cls.IsSignatureClass());
   if (!IsSuperCycleFree(cls)) {
     const String& name = String::Handle(cls.Name());
     const Script& script = Script::Handle(cls.script());
     ReportError(script, cls.token_index(),
                 "class '%s' has a cycle in its superclass relationship",
                 name.ToCString());
   }
-  GrowableArray<const Class*> visited;
-  ResolveInterfaces(cls, &visited);
+  const GrowableObjectArray& visited =
+      GrowableObjectArray::Handle(GrowableObjectArray::New());
+  ResolveInterfaces(cls, visited);
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     // Finalize super class and super type.
     FinalizeClass(super_class, generating_snapshot);
     super_type ^= FinalizeType(cls, super_type, kFinalizeWellFormed);
     cls.set_super_type(super_type);
   }
   if (cls.is_interface()) {
     if (cls.HasFactoryClass()) {
@@ skipping 58 matching lines @@
     if (!test2.IsNull()) {
       test2 = test2.SuperClass();
     }
   }
   // No cycles.
   return true;
 }
 
 
 bool ClassFinalizer::AddInterfaceIfUnique(
-    GrowableArray<AbstractType*>* interface_list,
-    AbstractType* interface,
+    const GrowableObjectArray& interface_list,
+    const AbstractType& interface,
     AbstractType* conflicting) {
-  String& interface_class_name = String::Handle(interface->ClassName());
+  String& interface_class_name = String::Handle(interface.ClassName());
   String& existing_interface_class_name = String::Handle();
-  for (intptr_t i = 0; i < interface_list->length(); i++) {
-    existing_interface_class_name = (*interface_list)[i]->ClassName();
+  String& interface_name = String::Handle();
+  String& existing_interface_name = String::Handle();
+  AbstractType& other_interface = AbstractType::Handle();
+  for (intptr_t i = 0; i < interface_list.Length(); i++) {
+    other_interface ^= interface_list.At(i);
+    existing_interface_class_name = other_interface.ClassName();
     if (interface_class_name.Equals(existing_interface_class_name)) {
       // Same interface class name, now check names of type arguments.
-      const String& interface_name = String::Handle(interface->Name());
-      const String& existing_interface_name =
-          String::Handle((*interface_list)[i]->Name());
+      interface_name = interface.Name();
+      existing_interface_name = other_interface.Name();
       // TODO(regis): Revisit depending on the outcome of issue 4905685.
       if (!interface_name.Equals(existing_interface_name)) {
-        *conflicting = (*interface_list)[i]->raw();
+        *conflicting = other_interface.raw();
         return false;
       } else {
         return true;
       }
     }
   }
-  interface_list->Add(interface);
+  interface_list.Add(interface);
   return true;
 }
 
 
-template<typename T>
-static RawArray* NewArray(const GrowableArray<T*>& objs) {
-  Array& a = Array::Handle(Array::New(objs.length()));
-  for (int i = 0; i < objs.length(); i++) {
-    a.SetAt(i, *objs[i]);
-  }
-  return a.raw();
-}
-
-
 // Walks the graph of explicitly declared interfaces of classes and
 // interfaces recursively. Resolves unresolved interfaces.
 // Returns false if there is an interface reference that cannot be
 // resolved, or if there is a cycle in the graph. We detect cycles by
 // remembering interfaces we've visited in each path through the
 // graph. If we visit an interface a second time on a given path,
 // we found a loop.
 void ClassFinalizer::ResolveInterfaces(const Class& cls,
-                                       GrowableArray<const Class*>* visited) {
-  ASSERT(visited != NULL);
-  for (int i = 0; i < visited->length(); i++) {
-    if ((*visited)[i]->raw() == cls.raw()) {
+                                       const GrowableObjectArray& visited) {
+  ASSERT(!visited.IsNull());
+  Class& visited_cls = Class::Handle();
+  for (int i = 0; i < visited.Length(); i++) {
+    visited_cls ^= visited.At(i);
+    if (visited_cls.raw() == cls.raw()) {
       // We have already visited interface class 'cls'. We found a cycle.
       const String& interface_name = String::Handle(cls.Name());
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_index(),
                   "cyclic reference found for interface '%s'",
                   interface_name.ToCString());
     }
   }
 
   // If the class/interface has no explicit interfaces, we are done.
   Array& super_interfaces = Array::Handle(cls.interfaces());
   if (super_interfaces.Length() == 0) {
     return;
   }
 
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   const bool cls_belongs_to_core_lib =
       (cls.library() == Library::CoreLibrary()) ||
       (cls.library() == Library::CoreImplLibrary());
 
   // Resolve and check the interfaces of cls.
-  visited->Add(&cls);
+  visited.Add(cls);
   AbstractType& interface = AbstractType::Handle();
+  Class& interface_class = Class::Handle();
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
     ResolveType(cls, interface, kFinalizeWellFormed);
     if (interface.IsTypeParameter()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_index(),
                   "type parameter '%s' cannot be used as interface",
                   String::Handle(interface.Name()).ToCString());
     }
-    const Class& interface_class = Class::Handle(interface.type_class());
+    interface_class = interface.type_class();
     if (!interface_class.is_interface()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_index(),
                   "class '%s' is used where an interface is expected",
                   String::Handle(interface_class.Name()).ToCString());
     }
     // Verify that unless cls belongs to core lib, it cannot extend or implement
     // any of bool, num, int, double, String, Function, Dynamic.
     // The exception is signature classes, which are compiler generated and
     // represent a function type, therefore implementing the Function interface.
     if (!cls_belongs_to_core_lib) {
       if (interface.IsBoolInterface() ||
           interface.IsNumberInterface() ||
           interface.IsIntInterface() ||
           interface.IsDoubleInterface() ||
           interface.IsStringInterface() ||
           (interface.IsFunctionInterface() && !cls.IsSignatureClass()) ||
           interface.IsDynamicType()) {
         const Script& script = Script::Handle(cls.script());
         ReportError(script, cls.token_index(),
                     "'%s' is not allowed to extend or implement '%s'",
                     String::Handle(cls.Name()).ToCString(),
                     String::Handle(interface_class.Name()).ToCString());
       }
     }
     // Now resolve the super interfaces.
     ResolveInterfaces(interface_class, visited);
   }
-  visited->RemoveLast();
+  visited.RemoveLast();
 }
 
 
 // A class is marked as constant if it has one constant constructor.
 // A constant class:
 // - may extend only const classes.
 // - has only const instance fields.
 // Note: we must check for cycles before checking for const properties.
 void ClassFinalizer::CheckForLegalConstClass(const Class& cls) {
   ASSERT(cls.is_const());
@@ skipping 106 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart