Clean up finalization of recursive types in the VM.

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/hash_table.h"
 #include "vm/heap.h"
@@ skipping 909 matching lines @@
         if (!super_type_arg.IsInstantiated()) {
           if (FLAG_trace_type_finalization && super_type_arg.IsTypeRef()) {
             AbstractType& ref_type =
                 AbstractType::Handle(TypeRef::Cast(super_type_arg).type());
             THR_Print(
                 "Instantiating TypeRef '%s': '%s'\n"
                 "  instantiator: '%s'\n",
                 String::Handle(super_type_arg.Name()).ToCString(),
                 ref_type.ToCString(), arguments.ToCString());
           }
+          // In the typical case of an F-bounded type, the instantiation of the
+          // super_type_arg from arguments is a fixpoint. Take the shortcut.
+          // Example: class B<T>; class D<T> extends B<D<T>>;
+          // While finalizing D<T>, the super type arg D<T> (a typeref) gets
+          // instantiated from vector [T], yielding itself.
+          //
+          if (super_type_arg.IsTypeRef() && super_type_arg.IsBeingFinalized() &&
+              (super_type_arg.arguments() == arguments.raw())) {
+            arguments.SetTypeAt(i, super_type_arg);
+            continue;
+          }
           Error& error = Error::Handle();
           super_type_arg = super_type_arg.InstantiateFrom(
               arguments, &error, instantiation_trail, NULL, Heap::kOld);
           if (!error.IsNull()) {
             // InstantiateFrom does not report an error if the type is still
             // uninstantiated. Instead, it will return a new BoundedType so
             // that the check is postponed to run time.
             ASSERT(super_type_arg.IsInstantiated());
             // Keep only the first bound error.
             if (bound_error->IsNull()) {
               *bound_error = error.raw();
             }
           }
-          if (!super_type_arg.IsFinalized() &&
-              !super_type_arg.IsBeingFinalized()) {
+          if (super_type_arg.IsBeingFinalized()) {
             // The super_type_arg was instantiated from a type being finalized.
             // We need to finish finalizing its type arguments.
-            if (super_type_arg.IsTypeRef()) {
-              super_type_arg = TypeRef::Cast(super_type_arg).type();
-            }
-            Type::Cast(super_type_arg).SetIsBeingFinalized();
-            pending_types->Add(super_type_arg);
-            const Class& cls = Class::Handle(super_type_arg.type_class());
+            ASSERT(super_type_arg.IsTypeRef());
+            AbstractType& ref_super_type_arg =
+                AbstractType::Handle(TypeRef::Cast(super_type_arg).type());
+            ref_super_type_arg.SetIsFinalized();
+            const Class& cls = Class::Handle(ref_super_type_arg.type_class());
             FinalizeTypeArguments(
-                cls, TypeArguments::Handle(super_type_arg.arguments()),
+                cls, TypeArguments::Handle(ref_super_type_arg.arguments()),
                 cls.NumTypeArguments() - cls.NumTypeParameters(), bound_error,
                 pending_types, instantiation_trail);
-            Type::Cast(super_type_arg).SetIsFinalized();
           }
         }
       }
       arguments.SetTypeAt(i, super_type_arg);
     }
     FinalizeTypeArguments(super_class, arguments, super_offset, bound_error,
                           pending_types, instantiation_trail);
   }
 }
 
@@ skipping 2749 matching lines @@
   ProgramVisitor::VisitFunctions(&function_visitor);
 
   class ClearCodeClassVisitor : public ClassVisitor {
     void Visit(const Class& cls) { cls.DisableAllocationStub(); }
   };
   ClearCodeClassVisitor class_visitor;
   ProgramVisitor::VisitClasses(&class_visitor);
 }
 
 }  // namespace dart