Throw a NoSuchMethodException when attempting to call an undefined constructor.

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 1512 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) {
-    FunctionElement constructor =
-        node.accept(new ConstructorResolver(compiler, this));
     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);
-    return constructor;
+    ConstructorResolver visitor =
+        new ConstructorResolver(compiler, this, node.isConst());
+    return node.accept(visitor);
   }
 
   Type resolveTypeRequired(TypeAnnotation node) {
     bool old = typeRequired;
     typeRequired = true;
     Type result = resolveTypeAnnotation(node);
     typeRequired = old;
     return result;
   }
 
@@ skipping 795 matching lines @@
 
   // TODO(ahe): This is temporary.
   ClassElement get currentClass {
     return enclosingElement.isMember()
       ? enclosingElement.getEnclosingClass() : null;
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<Element> {
   final ResolverVisitor resolver;
+  final bool inConstContext;

[ahe, 2012/09/21 09:35:45]

What is this for?

 
-  ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
+  ConstructorResolver(Compiler compiler, this.resolver,
+                      [bool this.inConstContext = false])

[ahe, 2012/09/21 09:35:45]

Why is this argument optional?

+      : 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 warning  =
-          new ResolutionWarning(MessageKind.CANNOT_FIND_CONSTRUCTOR,
-                                [fullConstructorName]);
-      compiler.reportWarning(diagnosticNode, warning);
-      return new ErroneousFunctionElement(warning.message, cls);
+      if (inConstContext) {
+        error(diagnosticNode, MessageKind.CANNOT_FIND_CONSTRUCTOR,

[ahe, 2012/09/21 09:35:45]

Why is this not returning an erroneous element?

+              [fullConstructorName]);
+      } else {
+        ResolutionWarning warning  =
+            new ResolutionWarning(MessageKind.CANNOT_FIND_CONSTRUCTOR,
+                                  [fullConstructorName]);
+        compiler.reportWarning(diagnosticNode, warning);
+        return new ErroneousFunctionElement(warning.message, cls);
+      }
     }
     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);
@@ skipping 170 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';
 }