Redirection type of a redirecting factory can be deferred

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 230 matching lines @@
     OS::Exit(255);
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("VerifyBootstrapClasses END.\n");
   }
   Isolate::Current()->heap()->Verify();
 }
 #endif  // defined(DART_NO_SNAPSHOT).
 
 
+static bool IsLoaded(const Type& type) {
+  if (type.HasResolvedTypeClass()) {
+    return true;
+  }
+  const UnresolvedClass& unresolved_class =
+      UnresolvedClass::Handle(type.unresolved_class());
+  const LibraryPrefix& prefix =
+      LibraryPrefix::Handle(unresolved_class.library_prefix());
+  return prefix.IsNull() || prefix.is_loaded();
+}
+
+
 // Resolve unresolved_class in the library of cls, or return null.
 RawClass* ClassFinalizer::ResolveClass(
       const Class& cls,
       const UnresolvedClass& unresolved_class) {
   const String& class_name = String::Handle(unresolved_class.ident());
   Library& lib = Library::Handle();
   Class& resolved_class = Class::Handle();
   if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
     lib = cls.library();
     ASSERT(!lib.IsNull());
     resolved_class = lib.LookupClass(class_name);
   } else {
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     lib_prefix = unresolved_class.library_prefix();
     ASSERT(!lib_prefix.IsNull());
     resolved_class = lib_prefix.LookupClass(class_name);
   }
   return resolved_class.raw();
 }
 
 
 
 void ClassFinalizer::ResolveRedirectingFactory(const Class& cls,
                                                const Function& factory) {
   const Function& target = Function::Handle(factory.RedirectionTarget());
   if (target.IsNull()) {
     Type& type = Type::Handle(factory.RedirectionType());
-    if (!type.IsMalformed()) {
+    if (!type.IsMalformed() && IsLoaded(type)) {
       const GrowableObjectArray& visited_factories =
           GrowableObjectArray::Handle(GrowableObjectArray::New());
       ResolveRedirectingFactoryTarget(cls, factory, visited_factories);
     }
     if (factory.is_const()) {
       type = factory.RedirectionType();
       if (type.IsMalformedOrMalbounded()) {
         ReportError(Error::Handle(type.error()));
       }
     }
@@ skipping 1202 matching lines @@
                      function.IsImplicitGetterFunction()) ? "getter" : "method",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
       if (function.IsRedirectingFactory()) {
         // The function may be a still unresolved redirecting factory. Do not
         // yet try to resolve it in order to avoid cycles in class finalization.
         // However, the redirection type should be finalized.
+        // If the redirection type is from a deferred library and is not
+        // yet loaded, do not attempt to resolve.
         Type& type = Type::Handle(I, function.RedirectionType());
-        type ^= FinalizeType(cls, type, kCanonicalize);
-        function.SetRedirectionType(type);
+        if (IsLoaded(type)) {
+          type ^= FinalizeType(cls, type, kCanonicalize);
+          function.SetRedirectionType(type);
+        }
       }
     } else if (function.IsGetterFunction() ||
                function.IsImplicitGetterFunction()) {
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(I, cls.Name());
         const String& super_class_name = String::Handle(I, super_class.Name());
         ReportError(cls, function.token_pos(),
                     "getter '%s' of class '%s' conflicts with "
                     "method '%s' of super class '%s'",
@@ skipping 1670 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart