Delay resolution of redirecting factory targets in order to avoid class

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 264 matching lines @@
   if (resolved_class.IsNull() && !ambiguity_error_msg.IsNull()) {
     const Script& script = Script::Handle(cls.script());
     *ambiguity_error = Parser::FormatErrorMsg(
         script, unresolved_class.token_pos(), "Error",
         "%s", ambiguity_error_msg.ToCString());
   }
   return resolved_class.raw();
 }
 
 
+
+void ClassFinalizer::ResolveRedirectingFactory(const Class& cls,
+                                               const Function& factory) {
+  const Function& target = Function::Handle(factory.RedirectionTarget());
+  if (target.IsNull()) {
+    const Type& type = Type::Handle(factory.RedirectionType());
+    if (!type.IsMalformed()) {
+      const GrowableObjectArray& visited_factories =
+          GrowableObjectArray::Handle(GrowableObjectArray::New());
+      ResolveRedirectingFactoryTarget(cls, factory, visited_factories);
+    }
+  }
+}
+
+
 void ClassFinalizer::ResolveRedirectingFactoryTarget(
     const Class& cls,
     const Function& factory,
     const GrowableObjectArray& visited_factories) {
   ASSERT(factory.IsRedirectingFactory());
 
   // Check for redirection cycle.
   for (int i = 0; i < visited_factories.Length(); i++) {
     if (visited_factories.At(i) == factory.raw()) {
       // A redirection cycle is reported as a compile-time error.
@@ skipping 83 matching lines @@
         kResolveTypeParameters,  // No compile-time error.
         "constructor '%s' has incompatible parameters with "
         "redirecting factory '%s'",
         String::Handle(target.name()).ToCString(),
         String::Handle(factory.name()).ToCString());
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
 
-  // Verify that the target is const if the the redirecting factory is const.
+  // Verify that the target is const if the redirecting factory is const.
   if (factory.is_const() && !target.is_const()) {
     const Script& script = Script::Handle(cls.script());
     ReportError(script, factory.token_pos(),
                 "constructor '%s' must be const as required by redirecting"
                 "const factory '%s'",
                 String::Handle(target.name()).ToCString(),
                 String::Handle(factory.name()).ToCString());
   }
 
   // Update redirection data with resolved target.
@@ skipping 753 matching lines @@
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
         ReportError(script, function.token_pos(),
                     "static function '%s' of class '%s' conflicts with "
                     "instance member '%s' of super class '%s'",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
-      if (function.IsRedirectingFactory()) {
-        const GrowableObjectArray& redirecting_factories =
-            GrowableObjectArray::Handle(GrowableObjectArray::New());
-        ResolveRedirectingFactoryTarget(cls, function, redirecting_factories);
-      }
+      // The function may be a still unresolved redirecting factory. Do not yet
+      // try to resolve it in order to avoid cycles in class finalization.
     } else {
       for (int i = 0; i < interfaces.Length(); i++) {
         super_class ^= interfaces.At(i);
         overridden_function = super_class.LookupDynamicFunction(function_name);
         if (!overridden_function.IsNull() &&
             !function.HasCompatibleParametersWith(overridden_function)) {
           // Function types are purposely not checked for subtyping.
           const String& class_name = String::Handle(cls.Name());
           const String& super_class_name = String::Handle(super_class.Name());
           const Script& script = Script::Handle(cls.script());
@@ skipping 321 matching lines @@
   }
 }
 
 
 void ClassFinalizer::FinalizeTypesInClass(const Class& cls) {
   HANDLESCOPE(Isolate::Current());
   if (cls.is_type_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
-    OS::Print("Finalize %s\n", cls.ToCString());
+    OS::Print("Finalize types in %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());
@@ skipping 88 matching lines @@
   // contains them.
   FinalizeUpperBounds(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);
   }
   // Top level classes are parsed eagerly so just finalize it.
   if (cls.IsTopLevel()) {
-    ClassFinalizer::FinalizeClass(cls);
+    FinalizeClass(cls);
   }
 }
 
 
 void ClassFinalizer::FinalizeClass(const Class& cls) {
   HANDLESCOPE(Isolate::Current());
   if (cls.is_finalized()) {
     return;
   }
+  if (FLAG_trace_class_finalization) {
+    OS::Print("Finalize %s\n", cls.ToCString());
+  }
   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);
   }
+  // Ensure super class is finalized.
+  const Class& super = Class::Handle(cls.SuperClass());
+  if (!super.IsNull()) {
+    FinalizeClass(super);
+  }
   // 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);
   }
 }
 
@@ skipping 544 matching lines @@
   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