Constrain type annotations with deferred types.

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

 // 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 1648 matching lines @@
     breakTargetStack = breakTargetStack.tail;
     labels = labels.outer;
   }
 }
 
 class TypeResolver {
   final Compiler compiler;
 
   TypeResolver(this.compiler);
 
-  Element resolveTypeName(Scope scope,
-                          Identifier prefixName,
-                          Identifier typeName) {
+  /// Tries to resolve the type name as an element.
+  Element resolveTypeName(Identifier prefixName,
+                          Identifier typeName,
+                          Scope scope,
+                          {bool deferredIsMalformed: true}) {
+    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 &&
+            deferredIsMalformed &&
+            compiler.deferredLoadTask.splitProgram) {

[floitsch, 2014/03/03 14:18:06]

why the check for compiler.deferredLoadTast.splitProgram ?

Even if we don't split, it should still be an error/warning.

[sigurdm, 2014/03/04 12:36:19]

Added a comment explaining why.

+          element = new ErroneousElementX(MessageKind.DEFERRED_TYPE_ANNOTATION,
+                                          {'node': typeName},
+                                          element.name,
+                                          element);
+        }
+      } 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 element;

[floitsch, 2014/03/03 14:18:06]

nit: I preferred the individual returns. But keep as is now.

[sigurdm, 2014/03/04 12:36:19]

Done.

   }
 
   DartType resolveTypeAnnotation(MappingVisitor visitor, TypeAnnotation node,
-                                 {bool malformedIsError: false}) {
+                                 {bool malformedIsError: false,
+                                  bool deferredIsMalformed: true}) {
     Identifier typeName;
     Identifier prefixName;
     Send send = node.typeName.asSend();
     if (send != null) {
       // The type name is of the form [: prefix . identifier :].
       prefixName = send.receiver.asIdentifier();
       typeName = send.selector.asIdentifier();
     } else {
       typeName = node.typeName.asIdentifier();
     }
 
-    Element element = resolveTypeName(visitor.scope, prefixName, typeName);
+    Element element = resolveTypeName(prefixName, typeName, visitor.scope,
+                                      deferredIsMalformed: deferredIsMalformed);
 
     DartType reportFailureAndCreateType(MessageKind messageKind,
                                         Map messageArguments,
-                                        {DartType userProvidedBadType}) {
+                                        {DartType userProvidedBadType,
+                                         Element erroneousElement}) {
       if (malformedIsError) {
         visitor.error(node, messageKind, messageArguments);
       } else {
         compiler.backend.registerThrowRuntimeError(visitor.mapping);
         visitor.warning(node, messageKind, messageArguments);
       }
-      Element erroneousElement = new ErroneousElementX(
-          messageKind, messageArguments, typeName.source,
-          visitor.enclosingElement);
+      if (erroneousElement == null) {
+         erroneousElement = new ErroneousElementX(
+            messageKind, messageArguments, typeName.source,
+            visitor.enclosingElement);
+      }
       LinkBuilder<DartType> arguments = new LinkBuilder<DartType>();
       resolveTypeArguments(visitor, node, null, arguments);
       return new MalformedType(erroneousElement,
               userProvidedBadType, arguments.toLink());
     }
 
     DartType checkNoTypeArguments(DartType type) {
       LinkBuilder<DartType> arguments = new LinkBuilder<DartType>();
       bool hasTypeArgumentMismatch = resolveTypeArguments(
           visitor, node, const Link<DartType>(), arguments);
       if (hasTypeArgumentMismatch) {
         return new MalformedType(
             new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
                 {'type': node}, typeName.source, visitor.enclosingElement),
                 type, arguments.toLink());
       }
       return type;
     }
 
+    // Now try to construct the type from the element.

[floitsch, 2014/03/03 14:18:06]

-Now-

[sigurdm, 2014/03/04 12:36:19]

Done.

     DartType type;
     if (element == null) {
       type = reportFailureAndCreateType(
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
     } else if (element.isAmbiguous()) {
       AmbiguousElement ambiguous = element;
       type = reportFailureAndCreateType(
           ambiguous.messageKind, ambiguous.messageArguments);
       ambiguous.diagnose(visitor.mapping.currentElement, compiler);
     } else if (!element.impliesType()) {
       type = reportFailureAndCreateType(
           MessageKind.NOT_A_TYPE, {'node': node.typeName});
+    } else if (element.isErroneous()) {
+      ErroneousElement erroneousElement = element;
+      type = reportFailureAndCreateType(
+          erroneousElement.messageKind, erroneousElement.messageArguments,
+          erroneousElement: erroneousElement);
     } else {
       bool addTypeVariableBoundsCheck = false;
       if (identical(element, compiler.types.voidType.element) ||
           identical(element, compiler.dynamicClass)) {
         type = checkNoTypeArguments(element.computeType(compiler));
       } else if (element.isClass()) {
         ClassElement cls = element;
         compiler.resolver._ensureClassWillBeResolved(cls);
         element.computeType(compiler);
         var arguments = new LinkBuilder<DartType>();
@@ skipping 1390 matching lines @@
     return node.accept(new ConstructorResolver(compiler, this));
   }
 
   FunctionElement resolveRedirectingFactory(Return node,
                                             {bool inConstContext: false}) {
     return node.accept(new ConstructorResolver(compiler, this,
                                                inConstContext: inConstContext));
   }
 
   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);
       compiler.backend.registerRequiredType(type, enclosingElement);
     }
     return type;
   }
 
   visitModifiers(Modifiers node) {
     internalError(node, 'modifiers');
@@ skipping 1274 matching lines @@
       } else {
         type = element.getEnclosingClass().computeType(compiler).asRaw();
       }
     }
     resolver.mapping.setType(expression, type);
     return element;
   }
 
   Element visitTypeAnnotation(TypeAnnotation node) {
     assert(invariant(node, type == null));
+    // This is not really resolving a type-annotation, but the name of the
+    // constructor. Therefore we allow deferred types.
     type = resolver.resolveTypeAnnotation(node,
-                                          malformedIsError: inConstContext);
+                                          malformedIsError: inConstContext,
+                                          deferredIsMalformed: false);
     compiler.backend.registerRequiredType(type, resolver.enclosingElement);
     return type.element;
   }
 
   Element visitSend(Send node) {
     Element element = visit(node.receiver);
     assert(invariant(node.receiver, element != null,
         message: 'No element return for $node.receiver.'));
     if (Elements.isUnresolved(element)) return element;
     Identifier name = node.selector.asIdentifier();
@@ skipping 51 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }