Differentiate between unresolved class and constructor.

pkg/compiler/lib/src/resolution/semantic_visitor.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.semantics_visitor;
 
 import '../constants/expressions.dart';
-import '../dart2jslib.dart' show invariant;
+import '../dart2jslib.dart' show invariant, MessageKind;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../helpers/helpers.dart';
 import '../tree/tree.dart';
 import '../universe/universe.dart';
 import '../util/util.dart' show Spannable, SpannableAssertionFailure;
 import 'access_semantics.dart';
 import 'operators.dart';
 import 'resolution.dart';
 import 'send_structure.dart';
@@ skipping 3002 matching lines @@
   /// Invocation of an unresolved [constructor] on [type] with [arguments].
   ///
   /// For instance
   ///   class C<T> {
   ///     C();
   ///   }
   ///   m() => new C<int>.unresolved(true, 42);
   ///
   /// where [type] is `C<int>`.
   ///
-  // TODO(johnniwinther): Update [type] to be [InterfaceType] when this is no
-  // longer a catch-all clause for the erroneous constructor invocations.
-  R errorUnresolvedConstructorInvoke(
+  // TODO(johnniwinther): Change [type] to [InterfaceType] when is it not
+  // `dynamic`.
+  R visitUnresolvedConstructorInvoke(
       NewExpression node,
       Element constructor,
       DartType type,
       NodeList arguments,
       Selector selector,
       A arg);
 
   /// Invocation of a constructor on an unresolved [type] with [arguments].
   ///
   /// For instance
   ///   m() => new Unresolved(true, 42);
   ///
   /// where [type] is the malformed type `Unresolved`.
   ///
-  R errorUnresolvedClassConstructorInvoke(
+  // TODO(johnniwinther): Change [type] to [MalformedType] when is it not
+  // `dynamic`.
+  R visitUnresolvedClassConstructorInvoke(
       NewExpression node,
       Element element,
       MalformedType type,
       NodeList arguments,
       Selector selector,
       A arg);
 
+  /// Constant invocation of a non-constant constructor.
+  ///
+  /// For instance
+  ///   class C {
+  ///     C(a, b);
+  ///   }
+  ///   m() => const C(true, 42);
+  ///
+  R errorNonConstantConstructorInvoke(
+      NewExpression node,
+      Element element,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg);
+
   /// Invocation of a constructor on an abstract [type] with [arguments].
   ///
   /// For instance
   ///   m() => new Unresolved(true, 42);
   ///
   /// where [type] is the malformed type `Unresolved`.
   ///
-  R errorAbstractClassConstructorInvoke(
+  R visitAbstractClassConstructorInvoke(
       NewExpression node,
       ConstructorElement element,
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg);
 
   /// Invocation of a factory [constructor] on [type] with [arguments] where
   /// [effectiveTarget] and [effectiveTargetType] are the constructor effective
   /// invoked and its type, respectively.
   ///
   /// For instance
   ///   class C {
   ///     factory C(a, b) = Unresolved;
   ///     factory C.a(a, b) = C.unresolved;
   ///   }
   ///   m1() => new C(true, 42);
   ///   m2() => new C.a(true, 42);
   ///
-  R errorUnresolvedRedirectingFactoryConstructorInvoke(
+  R visitUnresolvedRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 }
 
 abstract class SemanticDeclarationVisitor<R, A> {
   R apply(Node node, A arg);
 
   /// Apply this visitor to the [parameters].
   applyParameters(NodeList parameters, A arg);
 
   /// Apply this visitor to the constructor [initializers].
@@ skipping 531 matching lines @@
   ///       C() : this._(42);
   ///     }
   ///
   R errorUnresolvedThisConstructorInvoke(
       Send node,
       Element element,
       NodeList arguments,
       Selector selector,
       A arg);
 }