Delay Class parsing until the class is actually used.

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/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 129 matching lines @@
       cls ^= class_array.At(i);
       if (FLAG_trace_class_finalization) {
         OS::Print("Resolving super and interfaces: %s\n", cls.ToCString());
       }
       GrowableArray<intptr_t> visited_interfaces;
       ResolveSuperTypeAndInterfaces(cls, &visited_interfaces);
     }
     // Finalize all classes.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
-      FinalizeClass(cls);
+      FinalizeTypesInClass(cls);
     }
     if (FLAG_print_classes) {
       for (intptr_t i = 0; i < class_array.Length(); i++) {
         cls ^= class_array.At(i);
         PrintClassInformation(cls);
       }
     }
     // Clear pending classes array.
     class_array = GrowableObjectArray::New();
     object_store->set_pending_classes(class_array);
@@ skipping 336 matching lines @@
 //   Input:    C<String, double> expressed as
 //             cls = C, arguments = [null, null, String, double],
 //             i.e. cls_args = [String, double], offset = 2, length = 2.
 //   Output:   arguments = [int, double, String, double]
 void ClassFinalizer::FinalizeTypeArguments(
     const Class& cls,
     const AbstractTypeArguments& arguments,
     FinalizationKind finalization,
     Error* bound_error) {
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
-  if (!cls.is_finalized()) {
+  if (!cls.is_type_finalized()) {
     FinalizeTypeParameters(cls);
     ResolveUpperBounds(cls);
   }
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     AbstractTypeArguments& super_type_args = AbstractTypeArguments::Handle();
     if (super_type.IsBeingFinalized()) {
       // This type references itself via its type arguments. This is legal, but
       // we must avoid endless recursion. We therefore map the innermost
@@ skipping 48 matching lines @@
 
 // Check the type argument vector 'arguments' against the corresponding bounds
 // of the type parameters of class 'cls' and, recursively, of its superclasses.
 // Replace a type argument that cannot be checked at compile time by a
 // BoundedType, thereby postponing the bound check to run time.
 // Return a bound error if a type argument is not within bound at compile time.
 void ClassFinalizer::CheckTypeArgumentBounds(
     const Class& cls,
     const AbstractTypeArguments& arguments,
     Error* bound_error) {
-  if (!cls.is_finalized()) {
+  if (!cls.is_type_finalized()) {
     FinalizeUpperBounds(cls);
   }
   // Note that when finalizing a type, we need to verify the bounds in both
   // production mode and checked mode, because the finalized type may be written
   // to a snapshot. It would be wrong to ignore bounds when generating the
   // snapshot in production mode and then use the unchecked type in checked mode
   // after reading it from the snapshot.
   // However, we do not immediately report a bound error, which would be wrong
   // in production mode, but simply postpone the bound checking to runtime.
   const intptr_t num_type_params = cls.NumTypeParameters();
@@ skipping 89 matching lines @@
       } else {
         return type.Canonicalize();
       }
     }
     return type.raw();
   }
   ASSERT(type.IsResolved());
   ASSERT(finalization >= kFinalize);
 
   if (FLAG_trace_type_finalization) {
-    OS::Print("Finalize type '%s'\n", String::Handle(type.Name()).ToCString());
+    OS::Print("Finalize type '%s' for class %s\n",
+              String::Handle(type.Name()).ToCString(),
+              cls.ToCString());
   }
 
   if (type.IsTypeParameter()) {
     const TypeParameter& type_parameter = TypeParameter::Cast(type);
     const Class& parameterized_class =
         Class::Handle(type_parameter.parameterized_class());
     ASSERT(!parameterized_class.IsNull());
     // The index must reflect the position of this type parameter in the type
     // arguments vector of its parameterized class. The offset to add is the
     // number of type arguments in the super type, which is equal to the
@@ skipping 22 matching lines @@
 
   // Mark type as being finalized in order to detect illegal self reference.
   parameterized_type.set_is_being_finalized();
 
   // The type class does not need to be finalized in order to finalize the type,
   // however, it must at least be resolved (this was done as part of resolving
   // the type itself, a precondition to calling FinalizeType).
   // Also, the interfaces of the type class must be resolved and the type
   // parameters of the type class must be finalized.
   Class& type_class = Class::Handle(parameterized_type.type_class());
-  if (!type_class.is_finalized()) {
+  if (!type_class.is_type_finalized()) {
     FinalizeTypeParameters(type_class);
     ResolveUpperBounds(type_class);
   }
 
   // Finalize the current type arguments of the type, which are still the
   // parsed type arguments.
   AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(parameterized_type.arguments());
   if (!arguments.IsNull()) {
     intptr_t num_arguments = arguments.Length();
@@ skipping 112 matching lines @@
   }
 
   // If the type class is a signature class, we are currently finalizing a
   // signature type, i.e. finalizing the result type and parameter types of the
   // signature function of this signature type.
   // We do this after marking this type as finalized in order to allow a
   // function type to refer to itself via its parameter types and result type.
   if (type_class.IsSignatureClass()) {
     // The class may be created while parsing a function body, after all
     // pending classes have already been finalized.
-    FinalizeClass(type_class);
+    FinalizeTypesInClass(type_class);
   }
 
   // If a bound error occurred, return a BoundedType with a malformed bound.
   // The malformed bound will be ignored in production mode.
   if (!bound_error.IsNull()) {
     FinalizationKind bound_finalization = kTryResolve;  // No compile error.
     if (FLAG_enable_type_checks || FLAG_error_on_malformed_type) {
       bound_finalization = finalization;
     }
     const String& parameterized_type_name = String::Handle(
@@ skipping 373 matching lines @@
                                         param_bound,
                                         param.token_pos());
       cloned_type_params.SetTypeAt(cloned_index, cloned_param);
       cloned_index++;
     }
   }
   mixapp_class.set_type_parameters(cloned_type_params);
 }
 
 
-void ClassFinalizer::ApplyMixin(const Class& cls) {
+void ClassFinalizer::ApplyMixinTypes(const Class& cls) {
   const Type& mixin_type = Type::Handle(cls.mixin());
   ASSERT(!mixin_type.IsNull());
   ASSERT(mixin_type.HasResolvedTypeClass());
   const Class& mixin_cls = Class::Handle(mixin_type.type_class());
 
   if (FLAG_trace_class_finalization) {
-    OS::Print("Applying mixin '%s' to '%s' at pos %"Pd"\n",
+    OS::Print("Applying mixin type '%s' to '%s' at pos %"Pd"\n",
               String::Handle(mixin_cls.Name()).ToCString(),
               cls.ToCString(),
               cls.token_pos());
   }
 
   // Check that the super class of the mixin class is extending
   // class Object.
   const AbstractType& mixin_super_type =
       AbstractType::Handle(mixin_cls.super_type());
   if (!mixin_super_type.IsObjectType()) {
     const Script& script = Script::Handle(cls.script());
     const String& class_name = String::Handle(mixin_cls.Name());
     ReportError(script, cls.token_pos(),
                 "mixin class %s must extend class Object",
                 class_name.ToCString());
   }
 
   // Copy type parameters to mixin application class.
   CloneTypeParameters(cls);
 
+  if (FLAG_trace_class_finalization) {
+    OS::Print("done mixin type appl %s %s extending %s\n",
+              String::Handle(cls.Name()).ToCString(),
+              TypeArguments::Handle(cls.type_parameters()).ToCString(),
+              AbstractType::Handle(cls.super_type()).ToCString());
+  }
+}
+
+
+void ClassFinalizer::ApplyMixin(const Class& cls) {
+  Isolate* isolate = Isolate::Current();
+  const Type& mixin_type = Type::Handle(isolate, cls.mixin());
+  ASSERT(!mixin_type.IsNull());
+  ASSERT(mixin_type.HasResolvedTypeClass());
+  const Class& mixin_cls = Class::Handle(isolate, mixin_type.type_class());
+  mixin_cls.EnsureIsParsed(isolate);
+
+  if (FLAG_trace_class_finalization) {
+    OS::Print("Applying mixin '%s' to '%s' at pos %"Pd"\n",
+              String::Handle(mixin_cls.Name()).ToCString(),
+              cls.ToCString(),
+              cls.token_pos());
+  }
+
   const GrowableObjectArray& cloned_funcs =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
-  Array& functions = Array::Handle();
-  Function& func = Function::Handle();
+      GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
+  Array& functions = Array::Handle(isolate);
+  Function& func = Function::Handle(isolate);
   // The parser creates the mixin application class and adds just
   // one function, the implicit constructor.
   functions = cls.functions();
   ASSERT(functions.Length() == 1);
   func ^= functions.At(0);
   ASSERT(func.IsImplicitConstructor());
   cloned_funcs.Add(func);
   // Now clone the functions from the mixin class.
   functions = mixin_cls.functions();
   const intptr_t num_functions = functions.Length();
   for (int i = 0; i < num_functions; i++) {
     func ^= functions.At(i);
     if (func.IsConstructor()) {
       // A mixin class must not have explicit constructors.
       if (!func.IsImplicitConstructor()) {
-        const Script& script = Script::Handle(cls.script());
+        const Script& script = Script::Handle(isolate, cls.script());
         ReportError(script, cls.token_pos(),
                     "mixin class %s must not have constructors\n",
-                    String::Handle(mixin_cls.Name()).ToCString());
+                    String::Handle(isolate, mixin_cls.Name()).ToCString());
       }
       continue;  // Skip the implicit constructor.
     }
     if (!func.is_static()) {
       func = func.Clone(cls);
       cloned_funcs.Add(func);
     }
   }
   functions = Array::MakeArray(cloned_funcs);
   cls.SetFunctions(functions);
 
   // Now clone the fields from the mixin class. There should be no
   // existing fields in the mixin application class.
   ASSERT(Array::Handle(cls.fields()).Length() == 0);
-  Array& fields = Array::Handle(mixin_cls.fields());
-  Field& field = Field::Handle();
+  Array& fields = Array::Handle(isolate, mixin_cls.fields());
+  Field& field = Field::Handle(isolate);
   const GrowableObjectArray& cloned_fields =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
+      GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
   const intptr_t num_fields = fields.Length();
   for (int i = 0; i < num_fields; i++) {
     field ^= fields.At(i);
     if (!field.is_static()) {
       field = field.Clone(cls);
       cloned_fields.Add(field);
     }
   }
   fields = Array::MakeArray(cloned_fields);
   cls.SetFields(fields);
 
   if (FLAG_trace_class_finalization) {
     OS::Print("done mixin appl %s %s extending %s\n",
               String::Handle(cls.Name()).ToCString(),
               TypeArguments::Handle(cls.type_parameters()).ToCString(),
               AbstractType::Handle(cls.super_type()).ToCString());
   }
 }
 
 
-void ClassFinalizer::FinalizeClass(const Class& cls) {
+void ClassFinalizer::FinalizeTypesInClass(const Class& cls) {
   HANDLESCOPE(Isolate::Current());
-  if (cls.is_finalized()) {
+  if (cls.is_type_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
   }
   if (!IsSuperCycleFree(cls)) {
     const String& name = String::Handle(cls.Name());
     const Script& script = Script::Handle(cls.script());
     ReportError(script, cls.token_pos(),
                 "class '%s' has a cycle in its superclass relationship",
                 name.ToCString());
   }
   // Finalize super class.
   const Class& super_class = Class::Handle(cls.SuperClass());
   if (!super_class.IsNull()) {
-    FinalizeClass(super_class);
+    FinalizeTypesInClass(super_class);
   }
   if (cls.mixin() != Type::null()) {
-    // Copy instance methods and fields from the mixin class.
-    // This has to happen before the check whether the methods of
-    // the class conflict with inherited methods.
-    ApplyMixin(cls);
+    // Copy the type parameters to the mixin application.
+    ApplyMixinTypes(cls);
   }
   // Finalize type parameters before finalizing the super type.
   FinalizeTypeParameters(cls);
   ResolveUpperBounds(cls);
   // Finalize super type.
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     // In case of a bound error in the super type in production mode, the
     // finalized super type will be a BoundedType with a malformed bound.
     // It should not be a problem if the class is written to a snapshot and
     // later executed in checked mode. Note that the finalized type argument
     // vector of any type of the base class will contain a BoundedType for the
     // out of bound type argument.
     super_type = FinalizeType(cls, super_type, kCanonicalizeWellFormed);
     cls.set_super_type(super_type);
   }
   if (cls.IsSignatureClass()) {
     // Check for illegal self references.
     GrowableArray<intptr_t> visited_aliases;
     if (!IsAliasCycleFree(cls, &visited_aliases)) {
       const String& name = String::Handle(cls.Name());
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
                   "typedef '%s' illegally refers to itself",
                   name.ToCString());
     }
-    cls.Finalize();
+    cls.set_is_type_finalized();
     // Signature classes extend Object. No need to add this class to the direct
     // subclasses of Object.
     ASSERT(super_type.IsNull() || super_type.IsObjectType());
 
     // The type parameters of signature classes may have bounds.
     FinalizeUpperBounds(cls);
 
     // Resolve and finalize the result and parameter types of the signature
     // function of this signature class.
     const Function& sig_function = Function::Handle(cls.signature_function());
@@ skipping 31 matching lines @@
       if (interface_type.Equals(seen_interf)) {
         const Script& script = Script::Handle(cls.script());
         ReportError(script, cls.token_pos(),
                     "interface '%s' appears twice in "
                     "implements clause of class '%s'",
                     String::Handle(interface_type.Name()).ToCString(),
                     String::Handle(cls.Name()).ToCString());
       }
     }
   }
-  // Mark as finalized before resolving type parameter upper bounds and member
-  // types in order to break cycles.
-  cls.Finalize();
+  // Mark as type finalized before resolving type parameter upper bounds and
+  // member types in order to break cycles.
+  cls.set_is_type_finalized();
   // Finalize bounds even if running in production mode, so that a snapshot
   // contains them.
   FinalizeUpperBounds(cls);
-  ResolveAndFinalizeMemberTypes(cls);
-  // Run additional checks after all types are finalized.
-  if (cls.is_const()) {
-    CheckForLegalConstClass(cls);
-  }
   // Add this class to the direct subclasses of the superclass, unless the
   // superclass is Object.
   if (!super_type.IsNull() && !super_type.IsObjectType()) {
     ASSERT(!super_class.IsNull());
     super_class.AddDirectSubclass(cls);
   }
+  if (cls.is_parsed()) {
+    ClassFinalizer::FinalizeClass(cls);
+  }
+}
+
+
+void ClassFinalizer::FinalizeClass(const Class& cls) {
+  HANDLESCOPE(Isolate::Current());
+  if (cls.is_finalized()) {
+    return;
+  }
+  if (cls.mixin() != Type::null()) {
+    // Copy instance methods and fields from the mixin class.
+    // This has to happen before the check whether the methods of
+    // the class conflict with inherited methods.
+    ApplyMixin(cls);
+  }
+  // Mark as parsed and finalized.
+  cls.Finalize();
+  // Resolve and finalize all member types.
+  ResolveAndFinalizeMemberTypes(cls);
+  // Run additional checks after all types are finalized.
+  if (cls.is_const()) {
+    CheckForLegalConstClass(cls);
+  }
 }
 
 
 bool ClassFinalizer::IsSuperCycleFree(const Class& cls) {
   Class& test1 = Class::Handle(cls.raw());
   Class& test2 = Class::Handle(cls.SuperClass());
   // A finalized class has been checked for cycles.
   // Using the hare and tortoise algorithm for locating cycles.
-  while (!test1.is_finalized() &&
-         !test2.IsNull() && !test2.is_finalized()) {
+  while (!test1.is_type_finalized() &&
+         !test2.IsNull() && !test2.is_type_finalized()) {
     if (test1.raw() == test2.raw()) {
       // Found a cycle.
       return false;
     }
     test1 = test1.SuperClass();
     test2 = test2.SuperClass();
     if (!test2.IsNull()) {
       test2 = test2.SuperClass();
     }
   }
   // No cycles.
   return true;
 }
 
 
 // Returns false if the function type alias illegally refers to itself.
 bool ClassFinalizer::IsAliasCycleFree(const Class& cls,
                                       GrowableArray<intptr_t>* visited) {
   ASSERT(cls.IsSignatureClass());
-  ASSERT(!cls.is_finalized());
+  ASSERT(!cls.is_type_finalized());
   ASSERT(visited != NULL);
   const intptr_t cls_index = cls.id();
   for (int i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // We have already visited alias 'cls'. We found a cycle.
       return false;
     }
   }
 
   // Visit the result type and parameter types of this signature type.
   visited->Add(cls.id());
   const Function& function = Function::Handle(cls.signature_function());
   // Check class of result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
   ResolveType(cls, type, kCanonicalize);
   if (type.IsType() && !type.IsMalformed()) {
     const Class& type_class = Class::Handle(type.type_class());
-    if (!type_class.is_finalized() &&
+    if (!type_class.is_type_finalized() &&
         type_class.IsSignatureClass() &&
         !IsAliasCycleFree(type_class, visited)) {
       return false;
     }
   }
   // Check classes of formal parameter types.
   const intptr_t num_parameters = function.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
     ResolveType(cls, type, kCanonicalize);
     if (type.IsType() && !type.IsMalformed()) {
       const Class& type_class = Class::Handle(type.type_class());
-      if (!type_class.is_finalized() &&
+      if (!type_class.is_type_finalized() &&
           type_class.IsSignatureClass() &&
           !IsAliasCycleFree(type_class, visited)) {
         return false;
       }
     }
   }
   visited->RemoveLast();
   return true;
 }
 
@@ skipping 403 matching lines @@
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 
 void ClassFinalizer::VerifyImplicitFieldOffsets() {
 #ifdef DEBUG
-  const ClassTable& class_table = *(Isolate::Current()->class_table());
-  Class& cls = Class::Handle();
-  Array& fields_array = Array::Handle();
-  Field& field = Field::Handle();
-  String& name = String::Handle();
-  String& expected_name = String::Handle();
+  Isolate* isolate = Isolate::Current();
+  const ClassTable& class_table = *(isolate->class_table());
+  Class& cls = Class::Handle(isolate);
+  Array& fields_array = Array::Handle(isolate);
+  Field& field = Field::Handle(isolate);
+  String& name = String::Handle(isolate);
+  String& expected_name = String::Handle(isolate);
+  Error& error = Error::Handle(isolate);
 
   // First verify field offsets of all the TypedDataView classes.
   for (intptr_t cid = kTypedDataInt8ArrayViewCid;
        cid <= kTypedDataFloat32x4ArrayViewCid;
        cid++) {
     cls = class_table.At(cid);  // Get the TypedDataView class.
+    error = cls.EnsureIsParsed(isolate);
+    ASSERT(error.IsNull());
     cls = cls.SuperClass();  // Get it's super class '_TypedListView'.
     fields_array ^= cls.fields();
     ASSERT(fields_array.Length() == TypedDataView::NumberOfFields());
     field ^= fields_array.At(0);
     ASSERT(field.Offset() == TypedDataView::data_offset());
     name ^= field.name();
     expected_name ^= String::New("_typedData");
     ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
     field ^= fields_array.At(1);
     ASSERT(field.Offset() == TypedDataView::offset_in_bytes_offset());
     name ^= field.name();
     ASSERT(name.Equals("offsetInBytes"));
     field ^= fields_array.At(2);
     ASSERT(field.Offset() == TypedDataView::length_offset());
     name ^= field.name();
     ASSERT(name.Equals("length"));
   }
 
   // Now verify field offsets of '_ByteDataView' class.
   cls = class_table.At(kByteDataViewCid);
+  error = cls.EnsureIsParsed(isolate);
+  ASSERT(error.IsNull());
   fields_array ^= cls.fields();
   ASSERT(fields_array.Length() == TypedDataView::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == TypedDataView::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_typedData");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(1);
   ASSERT(field.Offset() == TypedDataView::offset_in_bytes_offset());
   name ^= field.name();
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart