Redirection type of a redirecting factory can be deferred

runtime/vm/parser.cc

 // Copyright (c) 2012, 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/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 3555 matching lines @@
                   method->name->ToCString());
     }
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
     is_redirecting = true;
     const bool consume_unresolved_prefix =
         (LookaheadToken(3) == Token::kLT) ||
         (LookaheadToken(3) == Token::kPERIOD);
     const AbstractType& type = AbstractType::Handle(Z,
         ParseType(ClassFinalizer::kResolveTypeParameters,
-                  false,  // Deferred types not allowed.
+                  true,
                   consume_unresolved_prefix));
     if (!type.IsMalformed() && type.IsTypeParameter()) {
       // Replace the type with a malformed type and compile a throw when called.
       redirection_type = ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(Z),  // No previous error.
           script_,
           type_pos,
           "factory '%s' may not redirect to type parameter '%s'",
           method->name->ToCString(),
           String::Handle(Z, type.UserVisibleName()).ToCString());
@@ skipping 8425 matching lines @@
           Error::Handle(Z),  // No previous error.
           script_,
           ident_pos,
           "using '%s' in this context is invalid",
           type_name.ToCString());
     }
     if (!prefix.IsNull() && prefix.is_deferred_load()) {
       // If deferred prefixes are allowed but it is not yet loaded,
       // remember that this function depends on the prefix.
       if (allow_deferred_type && !prefix.is_loaded()) {
-        ASSERT(parsed_function() != NULL);
-        parsed_function()->AddDeferredPrefix(prefix);
+        if (parsed_function() != NULL) {
+          parsed_function()->AddDeferredPrefix(prefix);
+        }
       }
-      // If the deferred prefixes are not allowed, or if the prefix
-      // is not yet loaded, return a malformed type. Otherwise, handle
-      // resolution below, as needed.
-      if (!prefix.is_loaded() || !allow_deferred_type) {
+      // If the deferred prefixes are not allowed, or if the prefix is not yet
+      // loaded when finalization is requested, return a malformed type.
+      // Otherwise, handle resolution below, as needed.
+      if (!allow_deferred_type ||
+          (!prefix.is_loaded()
+              && (finalization > ClassFinalizer::kResolveTypeParameters))) {
         ParseTypeArguments(ClassFinalizer::kIgnore);
         return ClassFinalizer::NewFinalizedMalformedType(
             Error::Handle(Z),  // No previous error.
             script_,
             ident_pos,
             !prefix.is_loaded()
                 ? "deferred type '%s.%s' is not yet loaded"
                 : "using deferred type '%s.%s' is invalid",
             String::Handle(Z, prefix.name()).ToCString(),
             type_name.ToCString());
@@ skipping 656 matching lines @@
         redirect_type ^= redirect_type.InstantiateFrom(type_arguments, &error);
         if (!error.IsNull()) {
           redirect_type = ClassFinalizer::NewFinalizedMalformedType(
               error,
               script_,
               call_pos,
               "redirecting factory type '%s' cannot be instantiated",
               String::Handle(Z, redirect_type.UserVisibleName()).ToCString());
         }
       }
+      if (!redirect_type.HasResolvedTypeClass()) {
+        // If the redirection type is unresolved, we convert the allocation
+        // into throwing a type error.
+        const UnresolvedClass& cls =
+            UnresolvedClass::Handle(Z, redirect_type.unresolved_class());
+        const LibraryPrefix& prefix =
+            LibraryPrefix::Handle(Z, cls.library_prefix());
+        if (!prefix.IsNull() && !prefix.is_loaded()) {
+          // If the redirection type is unresolved because it refers to
+          // an unloaded deferred prefix, mark this function as depending
+          // on the library prefix. It will then get invalidated when the
+          // prefix is loaded.
+          parsed_function()->AddDeferredPrefix(prefix);
+        }
+        redirect_type = ClassFinalizer::NewFinalizedMalformedType(
+            Error::Handle(Z),
+            script_,
+            call_pos,
+            "redirection type '%s' is not loaded",
+            String::Handle(Z, redirect_type.UserVisibleName()).ToCString());
+      }
+
       if (redirect_type.IsMalformedOrMalbounded()) {
         if (is_const) {
           ReportError(Error::Handle(Z, redirect_type.error()));
         }
         return ThrowTypeError(redirect_type.token_pos(), redirect_type);
       }
       if (I->flags().type_checks() && !redirect_type.IsSubtypeOf(type, NULL)) {
         // Additional type checking of the result is necessary.
         type_bound = type.raw();
       }
@@ skipping 811 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart