Throw a runtime error when trying to call a constructor of a class that could not be resolved.

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 1204 matching lines @@
         return null;
       }
       if (currentClass.supertype === null) {
         // This is just to guard against internal errors, so no need
         // for a real error message.
         error(node.receiver, MessageKind.GENERIC, ["Object has no superclass"]);
       }
       target = currentClass.lookupSuperMember(name);
       // [target] may be null which means invoking noSuchMethod on
       // super.
-    } else if (resolvedReceiver === null) {
+    } else if (Element.isInvalid(resolvedReceiver)) {
       return null;
     } else if (resolvedReceiver.kind === ElementKind.CLASS) {
       ClassElement receiverClass = resolvedReceiver;
       target = receiverClass.ensureResolved(compiler).lookupLocalMember(name);
       if (target === null) {
         error(node, MessageKind.METHOD_NOT_FOUND, [receiverClass.name, name]);
       } else if (target.isInstanceMember()) {
         error(node, MessageKind.MEMBER_NOT_STATIC, [receiverClass.name, name]);
       }
     } else if (resolvedReceiver.kind === ElementKind.PREFIX) {
@@ skipping 82 matching lines @@
       if (argument.asNamedArgument() != null) {
         seenNamedArgument = true;
       } else if (seenNamedArgument) {
         error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
       }
     }
   }
 
   visitSend(Send node) {
     Element target = resolveSend(node);
-    if (target != null && target.kind == ElementKind.ABSTRACT_FIELD) {
+    if (!Element.isInvalid(target)
+        && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       target = field.getter;
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source.stringValue;
       if (operatorString === 'is' || operatorString === 'as') {
         assert(node.arguments.tail.isEmpty());
         resolveTypeTest(node.arguments.head);
         resolvedArguments = true;
       }
     }
 
     if (!resolvedArguments) {
       resolveArguments(node.argumentsNode);
     }
 
     // If the selector is null, it means that we will not be generating
     // code for this as a send.
     Selector selector = mapping.getSelector(node);
     if (selector === null) return;
 
     // If we don't know what we're calling or if we are calling a getter,
     // we need to register that fact that we may be calling a closure
     // with the same arguments.
     if (node.isCall &&
-        (target === null ||
+        (Element.isInvalid(target) ||
          target.isGetter() ||
          Elements.isClosureSend(node, target))) {
       Selector call = new Selector.callClosureFrom(selector);
       world.registerDynamicInvocation(call.name, call);
     }
 
     // TODO(ngeoffray): We should do the check in
     // visitExpressionStatement instead.
     if (target === compiler.assertMethod && !node.isCall) {
       // We can only use assert by calling it.
@@ skipping 183 matching lines @@
       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) {
-    TypeAnnotation annotation = getTypeAnnotationFromSend(node.send);
-    // TODO(karlklose): clean up: the type should be resolved in the
-    // constructor resolver visitor to avoid visiting the node twice.
-    resolveTypeRequired(annotation);
+    // Resolve the constructor that [node] refers to.
     ConstructorResolver visitor =
         new ConstructorResolver(compiler, this, node.isConst());
-    return node.accept(visitor);
+    FunctionElement constructor = node.accept(visitor);
+    // Try to resolve the type that the new-expression constructs.
+    TypeAnnotation annotation = getTypeAnnotationFromSend(node.send);
+    if (Element.isInvalid(constructor)) {
+      // Resolve the type arguments. We cannot create a type and check the
+      // number of type arguments for this annotation, because we do not know
+      // the element.
+      Link arguments = const EmptyLink<Node>();
+      if (annotation.typeArguments != null) {
+        arguments = annotation.typeArguments.nodes;
+      }
+      for (Node argument in arguments) {
+        resolveTypeRequired(argument);
+      }
+    } else {
+      // Resolve and store the type this annotation resolves to. The type
+      // is used in the backend, e.g., for creating runtime type information.
+      // TODO(karlklose): This will resolve the class element again. Refactor
+      // so we can use the TypeResolver.
+      resolveTypeRequired(annotation);
+    }
+    return constructor;
   }
 
   Type resolveTypeRequired(TypeAnnotation node) {
     bool old = typeRequired;
     typeRequired = true;
     Type result = resolveTypeAnnotation(node);
     typeRequired = old;
     return result;
   }
 
@@ skipping 818 matching lines @@
   final bool inConstContext;
 
   ConstructorResolver(Compiler compiler, this.resolver,
                       [bool this.inConstContext = false])
       : super(compiler);
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
+  failOrReturnErroneousElement(Element enclosing, Node diagnosticNode,
+                               MessageKind kind, List arguments) {
+    if (inConstContext) {
+      error(diagnosticNode, kind, arguments);
+    } else {
+      ResolutionWarning warning  = new ResolutionWarning(kind, arguments);
+      compiler.reportWarning(diagnosticNode, warning);
+      return new ErroneousFunctionElement(warning.message, enclosing);
+    }
+  }
+
   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()}';
       }
-      if (inConstContext) {
-        error(diagnosticNode, MessageKind.CANNOT_FIND_CONSTRUCTOR,
-              [fullConstructorName]);
-      } else {
-        ResolutionWarning warning  =
-            new ResolutionWarning(MessageKind.CANNOT_FIND_CONSTRUCTOR,
-                                  [fullConstructorName]);
-        compiler.reportWarning(diagnosticNode, warning);
-        return new ErroneousFunctionElement(warning.message, cls);
-      }
+      return failOrReturnErroneousElement(cls, diagnosticNode,
+                                          MessageKind.CANNOT_FIND_CONSTRUCTOR,
+                                          [fullConstructorName]);
     }
     return result;
   }
 
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     Element e = visit(selector);
     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 = 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.
-
+    if (Element.isInvalid(e)) return e;
     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]);
       }
       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.
+        return failOrReturnErroneousElement(e, name,
+                                            MessageKind.CANNOT_RESOLVE,
+                                            [name]);
       } else if (e.kind !== ElementKind.CLASS) {
         error(node, MessageKind.NOT_A_TYPE, [name]);
       }
     } else {
       internalError(node.receiver, 'unexpected element $e');
     }
     return e;
   }
 
   Element visitIdentifier(Identifier node) {
     SourceString name = node.source;
     Element e = resolver.lookup(node, name);
     if (e === null) {
-      error(node, MessageKind.CANNOT_RESOLVE, [name]);
-      // TODO(ahe): Return erroneous element.
+      return failOrReturnErroneousElement(resolver.enclosingElement, node,
+                                          MessageKind.CANNOT_RESOLVE, [name]);
     } else if (e.kind === ElementKind.TYPEDEF) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF, [name]);
     } else if (e.kind !== ElementKind.CLASS && e.kind !== ElementKind.PREFIX) {
       error(node, MessageKind.NOT_A_TYPE, [name]);
     }
     return e;
   }
 }
 
 class Scope {
@@ skipping 111 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';
 }