Constrain type annotations with deferred types.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

Index: sdk/lib/_internal/compiler/implementation/resolution/members.dart
diff --git a/sdk/lib/_internal/compiler/implementation/resolution/members.dart b/sdk/lib/_internal/compiler/implementation/resolution/members.dart
index 69e3b45b9d02d08514b558f3b894906b061ee331..999689c4f5f2aef6a970ae0d70f290be3dd24260 100644
--- a/sdk/lib/_internal/compiler/implementation/resolution/members.dart
+++ b/sdk/lib/_internal/compiler/implementation/resolution/members.dart
@@ -1666,34 +1666,46 @@ class TypeResolver {
 
   TypeResolver(this.compiler);
 
-  Element resolveTypeName(Scope scope,
-                          Identifier prefixName,
-                          Identifier typeName) {
+  /// Tries to resolve the type name as an element.
+  ///
+  /// Returns that element paired with true if the [prefixName] was referring
+  /// to a deferred library prefix.
+  Pair<Element, bool> resolveTypeName(Identifier prefixName,

[floitsch, 2014/02/28 12:58:15]

I really don't like that we return a pair now.

maybe Johnni has a better suggestion?

[sigurdm, 2014/03/03 13:18:49]

With Johnni's help I found a better way.

+                                      Identifier typeName,
+                                      Scope scope) {
+    Element element;
+    bool deferredTypeAnnotation = false;
     if (prefixName != null) {
-      Element element =
+      Element prefixElement =
           lookupInScope(compiler, prefixName, scope, prefixName.source);
-      if (element != null && element.isPrefix()) {
+      if (prefixElement != null && prefixElement.isPrefix()) {
         // The receiver is a prefix. Lookup in the imported members.
-        PrefixElement prefix = element;
-        return prefix.lookupLocalMember(typeName.source);
+        PrefixElement prefix = prefixElement;
+        element = prefix.lookupLocalMember(typeName.source);
+        if (element != null && prefix.isDeferred) {
+          deferredTypeAnnotation = true;
+        }
+      } else {
+        // The caller of this method will create the ErroneousElement for
+        // the MalformedType.
+        element = null;
       }
-      // The caller of this method will create the ErroneousElement for
-      // the MalformedType.
-      return null;
     } else {
       String stringValue = typeName.source;
       if (identical(stringValue, 'void')) {
-        return compiler.types.voidType.element;
+        element = compiler.types.voidType.element;
       } else if (identical(stringValue, 'dynamic')) {
-        return compiler.dynamicClass;
+        element = compiler.dynamicClass;
       } else {
-        return lookupInScope(compiler, typeName, scope, typeName.source);
+        element = lookupInScope(compiler, typeName, scope, typeName.source);
       }
     }
+    return new Pair<Element, bool>(element, deferredTypeAnnotation);
   }
 
   DartType resolveTypeAnnotation(MappingVisitor visitor, TypeAnnotation node,
-                                 {bool malformedIsError: false}) {
+                                 {bool malformedIsError: false,
+                                  bool deferredIsMalformed: true}) {
     Identifier typeName;
     Identifier prefixName;
     Send send = node.typeName.asSend();
@@ -1705,7 +1717,11 @@ class TypeResolver {
       typeName = node.typeName.asIdentifier();
     }
 
-    Element element = resolveTypeName(visitor.scope, prefixName, typeName);
+    Pair<Element, bool> p = resolveTypeName(prefixName,
+                                            typeName,
+                                            visitor.scope);
+    Element element = p.first;
+    bool deferredTypeAnnotation = p.second;
 
     DartType reportFailureAndCreateType(MessageKind messageKind,
                                         Map messageArguments,
@@ -1738,6 +1754,7 @@ class TypeResolver {
       return type;
     }
 
+    // Now try to construct the type from the element.
     DartType type;
     if (element == null) {
       type = reportFailureAndCreateType(
@@ -1750,6 +1767,11 @@ class TypeResolver {
     } else if (!element.impliesType()) {
       type = reportFailureAndCreateType(
           MessageKind.NOT_A_TYPE, {'node': node.typeName});
+    } else if (deferredTypeAnnotation &&
+               deferredIsMalformed &&
+               compiler.deferredLoadTask.splitProgram) {
+      type = reportFailureAndCreateType(
+          MessageKind.DEFERRED_TYPE_ANNOTATION, {'node': node.typeName});
     } else {
       bool addTypeVariableBoundsCheck = false;
       if (identical(element, compiler.types.voidType.element) ||
@@ -3160,9 +3182,11 @@ class ResolverVisitor extends MappingVisitor<Element> {
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node,
-                                 {bool malformedIsError: false}) {
+                                 {bool malformedIsError: false,
+                                  bool deferredIsMalformed: true}) {
     DartType type = typeResolver.resolveTypeAnnotation(
-        this, node, malformedIsError: malformedIsError);
+        this, node, malformedIsError: malformedIsError,
+        deferredIsMalformed: deferredIsMalformed);
     if (type == null) return null;
     if (inCheckContext) {
       compiler.enqueuer.resolution.registerIsCheck(type, mapping);
@@ -4458,7 +4482,8 @@ class ConstructorResolver extends CommonResolverVisitor<Element> {
   Element visitTypeAnnotation(TypeAnnotation node) {
     assert(invariant(node, type == null));
     type = resolver.resolveTypeAnnotation(node,
-                                          malformedIsError: inConstContext);
+                                          malformedIsError: inConstContext,
+                                          deferredIsMalformed: false);

[floitsch, 2014/02/28 12:58:15]

Why is it not an error here?

[sigurdm, 2014/03/03 13:18:49]

I added an explanatory comment.

The problem is that the resolution of the constructor-name in "new A<x>()" is
treating the constructor as a type-annotation and using that mechanism for
resolving it.
But because we want to allow new-expressions with a deferred constructor we
allow deferred types her.

     compiler.backend.registerRequiredType(type, resolver.enclosingElement);
     return type.element;
   }