Make new of an ambiguous a warning.

pkg/compiler/lib/src/resolution/constructors.dart

 // Copyright (c) 2015, 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.
 
 library dart2js.resolution.constructors;
 
 import '../common.dart';
 import '../common/resolution.dart' show
     Feature;
 import '../compiler.dart' show
@@ skipping 467 matching lines @@
 
   ConstructorResult reportAndCreateErroneousConstructorElement(
       Spannable diagnosticNode,
       ConstructorResultKind resultKind,
       DartType type,
       Element enclosing,
       String name,
       MessageKind kind,
       Map arguments,
       {bool isError: false,
-       bool missingConstructor: false}) {
+       bool missingConstructor: false,
+       List<DiagnosticMessage> infos: const <DiagnosticMessage>[]}) {
     if (missingConstructor) {
       registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     } else {
       registry.registerFeature(Feature.THROW_RUNTIME_ERROR);
     }
+    DiagnosticMessage message =
+        reporter.createMessage(diagnosticNode, kind, arguments);
     if (isError || inConstContext) {
-      reporter.reportErrorMessage(
-          diagnosticNode, kind, arguments);
+      reporter.reportError(message, infos);
     } else {
-      reporter.reportWarningMessage(
-          diagnosticNode, kind, arguments);
+      reporter.reportWarning(message, infos);
     }
     ErroneousElement error = new ErroneousConstructorElementX(
         kind, arguments, name, enclosing);
     if (type == null) {
       type = new MalformedType(error, null);
     }
     return new ConstructorResult.forError(resultKind, error, type);
   }
 
   ConstructorResult resolveConstructor(
@@ skipping 99 matching lines @@
     // constructor. Therefore we allow deferred types.
     DartType type = resolver.resolveTypeAnnotation(
         node,
         malformedIsError: inConstContext,
         deferredIsMalformed: false);
     Send send = node.typeName.asSend();
     PrefixElement prefix;
     if (send != null) {
       // The type name is of the form [: prefix . identifier :].
       String name = send.receiver.asIdentifier().source;
-      Element element = resolver.reportLookupErrorIfAny(
-          lookupInScope(reporter, send, resolver.scope, name), node, name);
+      Element element = lookupInScope(reporter, send, resolver.scope, name);
       if (element != null && element.isPrefix) {
         prefix = element;
       }
     }
     return constructorResultForType(node, type, prefix: prefix);
   }
 
   ConstructorResult visitSend(Send node) {
     ConstructorResult receiver = visit(node.receiver);
     assert(invariant(node.receiver, receiver != null,
@@ skipping 28 matching lines @@
       return constructorResultForElement(
           node, name.source, member, prefix: prefix);
     } else {
       return reporter.internalError(
           node.receiver, 'unexpected receiver $receiver');
     }
   }
 
   ConstructorResult visitIdentifier(Identifier node) {
     String name = node.source;
-    Element element = resolver.reportLookupErrorIfAny(
-        lookupInScope(reporter, node, resolver.scope, name), node, name);
+    Element element = lookupInScope(reporter, node, resolver.scope, name);
     registry.useElement(node, element);
-    // TODO(johnniwinther): Change errors to warnings, cf. 11.11.1.
     return constructorResultForElement(node, name, element);
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   ConstructorResult visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     Node constructorReference = node.constructorReference;
     return finishConstructorReference(visit(constructorReference),
         constructorReference, node);
   }
 
   ConstructorResult constructorResultForElement(
       Node node, String name, Element element,
       {PrefixElement prefix}) {
     element = Elements.unwrap(element, reporter, node);
     if (element == null) {
       return reportAndCreateErroneousConstructorElement(
           node,
           ConstructorResultKind.INVALID_TYPE, null,
           resolver.enclosingElement, name,
           MessageKind.CANNOT_RESOLVE,
           {'name': name});
+    } else if (element.isAmbiguous) {
+      AmbiguousElement ambiguous = element;
+      return reportAndCreateErroneousConstructorElement(
+          node,
+          ConstructorResultKind.INVALID_TYPE, null,
+          resolver.enclosingElement, name,
+          ambiguous.messageKind,
+          ambiguous.messageArguments,
+          infos: ambiguous.computeInfos(resolver.enclosingElement, reporter));
     } else if (element.isMalformed) {
       return constructorResultForErroneous(node, element);
     } else if (element.isClass) {
       ClassElement cls = element;
       cls.computeType(resolution);
       return constructorResultForType(node, cls.rawType, prefix: prefix);
     } else if (element.isPrefix) {
       return new ConstructorResult.forPrefix(element);
     } else if (element.isTypedef) {
       TypedefElement typdef = element;
@@ skipping 156 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }