Avoid repeated resolution of types by marking them as resolved.

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 287 matching lines @@
   if (!target.IsNull()) {
     // Already resolved.
     return;
   }
 
   // Target is not resolved yet.
   if (FLAG_trace_class_finalization) {
     OS::Print("Resolving redirecting factory: %s\n",
               String::Handle(factory.name()).ToCString());
   }
-  ResolveType(cls, type);
   type ^= FinalizeType(cls, type, kCanonicalize);
   factory.SetRedirectionType(type);
   if (type.IsMalformedOrMalbounded()) {
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
   ASSERT(!type.IsTypeParameter());  // Resolved in parser.
   if (type.IsDynamicType()) {
     // Replace the type with a malformed type and compile a throw when called.
     type = NewFinalizedMalformedType(
@@ skipping 135 matching lines @@
         "cannot resolve class '%s' from '%s'",
         String::Handle(unresolved_class.Name()).ToCString(),
         String::Handle(cls.Name()).ToCString());
     return;
   }
   parameterized_type.set_type_class(type_class);
 }
 
 
 void ClassFinalizer::ResolveType(const Class& cls, const AbstractType& type) {
-  // TODO(regis): Add a kResolved bit in type_state_ for efficiency.
-  if (type.IsFinalized() || type.IsResolved()) {
+  if (type.IsResolved()) {
     return;
   }
+  ASSERT(type.IsType());
   if (FLAG_trace_type_finalization) {
     OS::Print("Resolve type '%s'\n", String::Handle(type.Name()).ToCString());
   }
-
   ResolveTypeClass(cls, type);
-
+  if (type.IsMalformed()) {
+    ASSERT(type.IsResolved());
+    return;
+  }
+  // Mark type as resolved before resolving its type arguments in order to avoid
+  // repeating resolution of recursive types.
+  Type::Cast(type).set_is_resolved();
   // Resolve type arguments, if any.
   const TypeArguments& arguments = TypeArguments::Handle(type.arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
       ResolveType(cls, type_argument);
     }
   }
@@ skipping 277 matching lines @@
 
   if (type.IsBeingFinalized()) {
     if (FLAG_trace_type_finalization) {
       OS::Print("Creating TypeRef '%s' for class '%s'\n",
                 String::Handle(type.Name()).ToCString(),
                 cls.ToCString());
     }
     return TypeRef::New(type);
   }
 
-  ASSERT(type.IsResolved());
+  ResolveType(cls, type);
   if (FLAG_trace_type_finalization) {
     OS::Print("Finalizing 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());
@@ skipping 201 matching lines @@
   }
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
   // It is not a compile time error if this name does not resolve to a class or
   // interface.
-  ResolveType(cls, type);
   type = FinalizeType(cls, type, kCanonicalize);
   // The result type may be malformed or malbounded.
   function.set_result_type(type);
   // Resolve 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);
     type = FinalizeType(cls, type, kCanonicalize);
     // The parameter type may be malformed or malbounded.
     function.SetParameterTypeAt(i, type);
   }
 }
 
 
 // Check if an instance field, getter, or method of same name exists
 // in any super class.
 static RawClass* FindSuperOwnerOfInstanceMember(const Class& cls,
@@ skipping 108 matching lines @@
   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();
   const intptr_t num_fields = array.Length();
   for (intptr_t i = 0; i < num_fields; i++) {
     field ^= array.At(i);
     type = field.type();
-    ResolveType(cls, 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 Script& script = Script::Handle(cls.script());
@@ skipping 1786 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