Add erroneous elements for function types and use them to allow unresolvable constructors to be han…

lib/compiler/implementation/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 1433 matching lines @@
     visit(node.condition);
     visitLoopBodyIn(node, node.body, new BlockScope(scope));
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
-
     FunctionElement constructor = resolveConstructor(node);
     resolveSelector(node.send);
     resolveArguments(node.send.argumentsNode);
-    if (constructor === null) return null;
+    useElement(node.send, constructor);
+    if (Element.isInvalid(constructor)) return constructor;
     // TODO(karlklose): handle optional arguments.
     if (node.send.argumentCount() != constructor.parameterCount(compiler)) {
       // TODO(ngeoffray): resolution error with wrong number of
       // parameters. We cannot do this rigth now because of the
       // List constructor.
     }
-    useElement(node.send, constructor);
     world.registerStaticUse(constructor);
     compiler.withCurrentElement(constructor, () {
       FunctionExpression tree = constructor.parseNode(compiler);
       compiler.resolver.resolveConstructorImplementation(constructor, tree);
     });
     world.registerStaticUse(constructor.defaultImplementation);
     ClassElement cls = constructor.defaultImplementation.getEnclosingClass();
     world.registerInstantiatedClass(cls);
     cls.forEachInstanceField(
         includeBackendMembers: false,
@@ skipping 10 matching lines @@
     } else if (send.selector.asSend() !== null) {
       Send selector = send.selector;
       if (selector.receiver.asTypeAnnotation() !== null) {
         return selector.receiver;
       }
     } else {
       compiler.internalError("malformed send in new expression");
     }
   }
 
+  /**
+   * 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) {
     FunctionElement constructor =
         node.accept(new ConstructorResolver(compiler, this));
     TypeAnnotation annotation = getTypeAnnotationFromSend(node.send);
-    Type type = resolveTypeRequired(annotation);
-    if (constructor === null) {
-      Element resolved = (type != null) ? type.element : null;
-      if (resolved !== null && resolved.kind === ElementKind.TYPE_VARIABLE) {
-        error(node, MessageKind.TYPE_VARIABLE_AS_CONSTRUCTOR);
-        return null;
-      } else {
-        error(node.send, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node.send]);
-        return null;
-      }
-    }
+    // TODO(karlklose): clean up: the type should be resolved in the
+    // constructor resolver visitor to avoid visiting the node twice.
+    resolveTypeRequired(annotation);
     return constructor;
   }
 
   Type resolveTypeRequired(TypeAnnotation node) {
     bool old = typeRequired;
     typeRequired = true;
     Type result = resolveTypeAnnotation(node);
     typeRequired = old;
     return result;
   }
@@ skipping 796 matching lines @@
 
   // TODO(ahe): This is temporary.
   ClassElement get currentClass() {
     return enclosingElement.isMember()
       ? enclosingElement.getEnclosingClass() : null;
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<Element> {
   final ResolverVisitor resolver;
+
   ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
+  FunctionElement lookupConstructor(ClassElement cls,
+                                    Node diagnosticNode,
+                                    SourceString constructorName) {
+    cls.ensureResolved(compiler);
+    Element result = cls.lookupConstructor(cls.name, constructorName);
+    if (result === null) {
+      String fullConstructorName = cls.name.slowToString();
+      if (constructorName !== const SourceString('')) {
+        fullConstructorName = '$fullConstructorName'
+                              '.${constructorName.slowToString()}';
+      }
+      ResolutionWarning message  =
+          new ResolutionWarning(MessageKind.CANNOT_FIND_CONSTRUCTOR,
+                                [fullConstructorName]);
+      compiler.reportWarning(diagnosticNode, message);
+      return new ErroneousFunctionElement(message, cls);
+    }
+    return result;
+  }
+
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     Element e = visit(selector);
-    if (e !== null && e.kind === ElementKind.CLASS) {
+    if (!Element.isInvalid(e) && e.kind === ElementKind.CLASS) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
       if (cls.isInterface() && (cls.defaultClass === null)) {
         error(selector, MessageKind.CANNOT_INSTANTIATE_INTERFACE, [cls.name]);
       }
-      e = cls.lookupConstructor(cls.name);
+      e = lookupConstructor(cls, selector, const SourceString(''));
     }
     return e;
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     // TODO(ahe): Do not ignore type arguments.
     return visit(node.typeName);
   }
 
   visitSend(Send node) {
     Element e = visit(node.receiver);
     if (e === null) return null; // TODO(ahe): Return erroneous element.
 
     Identifier name = node.selector.asIdentifier();
     if (name === null) internalError(node.selector, 'unexpected node');
 
     if (e.kind === ElementKind.CLASS) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
       if (cls.isInterface() && (cls.defaultClass === null)) {
         error(node.receiver, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
               [cls.name]);
       }
-      SourceString constructorName =
-        Elements.constructConstructorName(cls.name, name.source);
-      FunctionElement constructor = cls.lookupConstructor(constructorName);
-      if (constructor === null) {
-        error(name, MessageKind.CANNOT_FIND_CONSTRUCTOR, [name]);
-      }
-      e = constructor;
+      return lookupConstructor(cls, name, name.source);
     } else if (e.kind === ElementKind.PREFIX) {
       PrefixElement prefix = e;
       e = prefix.lookupLocalMember(name.source);
       if (e === null) {
         error(name, MessageKind.CANNOT_RESOLVE, [name]);
         // TODO(ahe): Return erroneous element.
       } else if (e.kind !== ElementKind.CLASS) {
         error(node, MessageKind.NOT_A_TYPE, [name]);
       }
     } else {
@@ skipping 132 matching lines @@
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }