Check const expressions for malformed 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 2559 matching lines @@
       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source;
       if (identical(operatorString, 'is')) {
         // TODO(johnniwinther): Use seen type tests to avoid registration of
         // mutation/access to unpromoted variables.
         DartType type =
-            resolveTypeExpression(node.typeAnnotationFromIsCheckOrCast);
+            resolveTypeAnnotation(node.typeAnnotationFromIsCheckOrCast);
         if (type != null) {
           compiler.enqueuer.resolution.registerIsCheck(type, mapping);
         }
         resolvedArguments = true;
       } else if (identical(operatorString, 'as')) {
-        DartType type = resolveTypeExpression(node.arguments.head);
+        DartType type = resolveTypeAnnotation(node.arguments.head);
         if (type != null) {
           compiler.enqueuer.resolution.registerAsCheck(type, mapping);
         }
         resolvedArguments = true;
       } else if (identical(operatorString, '&&')) {
         doInPromotionScope(node.arguments.head,
             () => resolveArguments(node.argumentsNode));
         resolvedArguments = true;
       }
     }
@@ skipping 248 matching lines @@
   }
 
   void handleRedirectingFactoryBody(Return node) {
     final isSymbolConstructor = enclosingElement == compiler.symbolConstructor;
     if (!enclosingElement.isFactoryConstructor()) {
       compiler.reportError(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
       compiler.reportHint(
           enclosingElement, MessageKind.MISSING_FACTORY_KEYWORD);
     }
-    FunctionElement redirectionTarget = resolveRedirectingFactory(node);
+    FunctionElement constructor = enclosingElement;
+    bool isConstConstructor = constructor.modifiers.isConst();
+    FunctionElement redirectionTarget = resolveRedirectingFactory(
+        node, inConstContext: isConstConstructor);
+    constructor.defaultImplementation = redirectionTarget;
     useElement(node.expression, redirectionTarget);
-    FunctionElement constructor = enclosingElement;
-    if (constructor.modifiers.isConst() &&
-        !redirectionTarget.modifiers.isConst()) {
-      error(node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
-    }
-    if (redirectionTarget == constructor) {
-      compiler.reportError(node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
-      return;
-    }
-    constructor.defaultImplementation = redirectionTarget;
     if (Elements.isUnresolved(redirectionTarget)) {
       compiler.backend.registerThrowNoSuchMethod(mapping);
       return;
+    } else {
+      if (isConstConstructor &&
+          !redirectionTarget.modifiers.isConst()) {
+        compiler.reportError(node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
+      }
+      if (redirectionTarget == constructor) {
+        compiler.reportError(node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
+        return;
+      }
     }
 
     // Check that the target constructor is type compatible with the
     // redirecting constructor.
     ClassElement targetClass = redirectionTarget.getEnclosingClass();
     InterfaceType type = mapping.getType(node.expression);
     FunctionType targetType = redirectionTarget.computeType(compiler)
         .subst(type.typeArguments, targetClass.typeVariables);
     FunctionType constructorType = constructor.computeType(compiler);
     bool isSubtype = compiler.types.isSubtype(targetType, constructorType);
@@ skipping 104 matching lines @@
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
 
     // [constructor] might be the implementation element
     // and only declaration elements may be registered.
     world.registerStaticUse(constructor.declaration);
     ClassElement cls = constructor.getEnclosingClass();
     InterfaceType type = mapping.getType(node);
     if (node.isConst() && type.containsTypeVariables) {
       compiler.reportError(node.send.selector,
-                               MessageKind.TYPE_VARIABLE_IN_CONSTANT);
+                           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
     }
     world.registerInstantiatedType(type, mapping);
     if (constructor.isFactoryConstructor() && !type.typeArguments.isEmpty) {
       world.registerFactoryWithTypeArguments(mapping);
     }
     if (constructor.isGenerativeConstructor() && cls.isAbstract(compiler)) {
       warning(node, MessageKind.ABSTRACT_CLASS_INSTANTIATION);
       compiler.backend.registerAbstractClassInstantiation(mapping);
     }
 
@@ skipping 60 matching lines @@
 
   /**
    * Try to resolve the constructor that is referred to by [node].
    * Note: this function may return an ErroneousFunctionElement instead of
    * [null], if there is no corresponding constructor, class or library.
    */
   FunctionElement resolveConstructor(NewExpression node) {
     return node.accept(new ConstructorResolver(compiler, this));
   }
 
-  FunctionElement resolveRedirectingFactory(Return node) {
-    return node.accept(new ConstructorResolver(compiler, this));
+  FunctionElement resolveRedirectingFactory(Return node,
+                                            {bool inConstContext: false}) {
+    return node.accept(new ConstructorResolver(compiler, this,
+                                               inConstContext: inConstContext));
   }
 
-  DartType resolveTypeExpression(TypeAnnotation node) {
-    return resolveTypeAnnotation(node);
-  }
-
-  DartType resolveTypeAnnotation(TypeAnnotation node) {
-    DartType type = typeResolver.resolveTypeAnnotation(this, node);
+  DartType resolveTypeAnnotation(TypeAnnotation node,
+                                 {bool malformedIsError: false}) {
+    DartType type = typeResolver.resolveTypeAnnotation(
+        this, node, malformedIsError: malformedIsError);
     if (type == null) return null;
     if (inCheckContext) {
       compiler.enqueuer.resolution.registerIsCheck(type, mapping);
       compiler.backend.registerRequiredType(type, enclosingElement);
     }
     return type;
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
     NodeList arguments = node.typeArguments;
     DartType typeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
         // The syntax [: <>[] :] is not allowed.
         error(arguments, MessageKind.MISSING_TYPE_ARGUMENT.error);
       } else {
-        typeArgument = resolveTypeExpression(nodes.head);
+        typeArgument = resolveTypeAnnotation(nodes.head);
         for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
           warning(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT.warning);
           resolveTypeAnnotation(nodes.head);
         }
       }
     }
     DartType listType;
     if (typeArgument != null) {
       if (node.isConst() && typeArgument.containsTypeVariables) {
         compiler.reportError(arguments.nodes.head,
@@ skipping 194 matching lines @@
   visitLiteralMap(LiteralMap node) {
     NodeList arguments = node.typeArguments;
     DartType keyTypeArgument;
     DartType valueTypeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
         // The syntax [: <>{} :] is not allowed.
         error(arguments, MessageKind.MISSING_TYPE_ARGUMENT.error);
       } else {
-        keyTypeArgument = resolveTypeExpression(nodes.head);
+        keyTypeArgument = resolveTypeAnnotation(nodes.head);
         nodes = nodes.tail;
         if (nodes.isEmpty) {
           warning(arguments, MessageKind.MISSING_TYPE_ARGUMENT.warning);
         } else {
-          valueTypeArgument = resolveTypeExpression(nodes.head);
+          valueTypeArgument = resolveTypeAnnotation(nodes.head);
           for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
             warning(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT.warning);
             resolveTypeAnnotation(nodes.head);
           }
         }
       }
     }
     DartType mapType;
     if (valueTypeArgument != null) {
       mapType = new InterfaceType(compiler.mapClass,
@@ skipping 1160 matching lines @@
 
   // TODO(ahe): This is temporary.
   ClassElement get currentClass {
     return enclosingElement.isMember()
       ? enclosingElement.getEnclosingClass() : null;
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<Element> {
   final ResolverVisitor resolver;
-  bool inConstContext = false;
+  bool inConstContext;
   DartType type;
 
-  ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
+  ConstructorResolver(Compiler compiler, this.resolver,
+                      {bool this.inConstContext: false})
+      : super(compiler);
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
   failOrReturnErroneousElement(Element enclosing, Node diagnosticNode,
                                String targetName, DualKind kind,
                                Map arguments) {
     if (kind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
       compiler.backend.registerThrowNoSuchMethod(resolver.mapping);
     } else {
       compiler.backend.registerThrowRuntimeError(resolver.mapping);
     }
     if (inConstContext) {
       compiler.reportError(diagnosticNode, kind.error, arguments);
     } else {
       ResolutionWarning warning  =
           new ResolutionWarning(
               kind.warning, arguments, compiler.terseDiagnostics);
       compiler.reportWarning(diagnosticNode, warning);
-      return new ErroneousElementX(
-          kind.error, arguments, targetName, enclosing);
     }
+    return new ErroneousElementX(
+        kind.error, arguments, targetName, enclosing);
   }
 
   Selector createConstructorSelector(String constructorName) {
     return constructorName == ''
         ? new Selector.callDefaultConstructor(
             resolver.enclosingElement.getLibrary())
         : new Selector.callConstructor(
             constructorName,
             resolver.enclosingElement.getLibrary());
   }
@@ skipping 15 matching lines @@
           diagnosticNode,
           fullConstructorName,
           MessageKind.CANNOT_FIND_CONSTRUCTOR,
           {'constructorName': fullConstructorName});
     } else if (inConstContext && !result.modifiers.isConst()) {
       error(diagnosticNode, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
     }
     return result;
   }
 
-  visitNewExpression(NewExpression node) {
+  Element visitNewExpression(NewExpression node) {
     inConstContext = node.isConst();
     Node selector = node.send.selector;
-    Element e = visit(selector);
-    return finishConstructorReference(e, node.send.selector, node);
+    Element element = visit(selector);
+    assert(invariant(selector, element != null,
+        message: 'No element return for $selector.'));
+    return finishConstructorReference(element, node.send.selector, node);
   }
 
   /// Finishes resolution of a constructor reference and records the
   /// type of the constructed instance on [expression].
-  FunctionElement finishConstructorReference(Element e,
+  FunctionElement finishConstructorReference(Element element,
                                              Node diagnosticNode,
                                              Node expression) {
+    assert(invariant(diagnosticNode, element != null,
+        message: 'No element return for $diagnosticNode.'));
     // Find the unnamed constructor if the reference resolved to a
     // class.
-    if (!Elements.isUnresolved(e) && !e.isConstructor()) {
-      if (e.isClass()) {
-        ClassElement cls = e;
+    if (!Elements.isUnresolved(element) && !element.isConstructor()) {
+      if (element.isClass()) {
+        ClassElement cls = element;
         cls.ensureResolved(compiler);
         // The unnamed constructor may not exist, so [e] may become unresolved.
-        e = lookupConstructor(cls, diagnosticNode, '');
+        element = lookupConstructor(cls, diagnosticNode, '');
       } else {
-        e = failOrReturnErroneousElement(
-              e, diagnosticNode, e.name, MessageKind.NOT_A_TYPE,
-              {'node': diagnosticNode});
+        element = failOrReturnErroneousElement(
+            element, diagnosticNode, element.name, MessageKind.NOT_A_TYPE,
+            {'node': diagnosticNode});
       }
     }
     if (type == null) {
-      if (Elements.isUnresolved(e)) {
+      if (Elements.isUnresolved(element)) {
         type = compiler.types.dynamicType;
       } else {
-        type = e.getEnclosingClass().computeType(compiler).asRaw();
+        type = element.getEnclosingClass().computeType(compiler).asRaw();
       }
     }
     resolver.mapping.setType(expression, type);
-    return e;
+    return element;
   }
 
-  visitTypeAnnotation(TypeAnnotation node) {
+  Element visitTypeAnnotation(TypeAnnotation node) {
     assert(invariant(node, type == null));
-    type = resolver.resolveTypeExpression(node);
+    type = resolver.resolveTypeAnnotation(node,
+                                          malformedIsError: inConstContext);
     compiler.backend.registerRequiredType(type, resolver.enclosingElement);
-    return resolver.mapping[node];
+    return type.element;
   }
 
-  visitSend(Send node) {
-    Element e = visit(node.receiver);
-    if (Elements.isUnresolved(e)) return e;
+  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();
     if (name == null) internalError(node.selector, 'unexpected node');
 
-    if (identical(e.kind, ElementKind.CLASS)) {
-      ClassElement cls = e;
+    if (element.isClass()) {
+      ClassElement cls = element;
       cls.ensureResolved(compiler);
       return lookupConstructor(cls, name, name.source);
-    } else if (identical(e.kind, ElementKind.PREFIX)) {
-      PrefixElement prefix = e;
-      e = prefix.lookupLocalMember(name.source);
-      e = Elements.unwrap(e, compiler, node);
-      if (e == null) {
+    } else if (element.isPrefix()) {
+      PrefixElement prefix = element;
+      element = prefix.lookupLocalMember(name.source);
+      element = Elements.unwrap(element, compiler, node);
+      if (element == null) {
         return failOrReturnErroneousElement(
             resolver.enclosingElement, name,
             name.source,
             MessageKind.CANNOT_RESOLVE,
             {'name': name});
-      } else if (!identical(e.kind, ElementKind.CLASS)) {
+      } else if (!element.isClass()) {
         error(node, MessageKind.NOT_A_TYPE.error, {'node': name});
       }
     } else {
-      internalError(node.receiver, 'unexpected element $e');
+      internalError(node.receiver, 'unexpected element $element');
     }
-    return e;
+    return element;
   }
 
   Element visitIdentifier(Identifier node) {
     String name = node.source;
-    Element e = resolver.reportLookupErrorIfAny(
+    Element element = resolver.reportLookupErrorIfAny(
         lookupInScope(compiler, node, resolver.scope, name), node, name);
     // TODO(johnniwinther): Change errors to warnings, cf. 11.11.1.
-    if (e == null) {
+    if (element == null) {
       return failOrReturnErroneousElement(resolver.enclosingElement, node, name,
                                           MessageKind.CANNOT_RESOLVE,
                                           {'name': name});
-    } else if (e.isErroneous()) {
-      return e;
-    } else if (identical(e.kind, ElementKind.TYPEDEF)) {
+    } else if (element.isErroneous()) {
+      return element;
+    } else if (element.isTypedef()) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
             {'typedefName': name});
-    } else if (identical(e.kind, ElementKind.TYPE_VARIABLE)) {
+    } else if (element.isTypeVariable()) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
             {'typeVariableName': name});
-    } else if (!identical(e.kind, ElementKind.CLASS)
-        && !identical(e.kind, ElementKind.PREFIX)) {
+    } else if (!element.isClass() && !element.isPrefix()) {
       error(node, MessageKind.NOT_A_TYPE.error, {'node': name});
     }
-    return e;
+    return element;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     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);
 }