Differentiate between unresolved class and constructor.

pkg/compiler/lib/src/resolution/access_semantics.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.
 
 // TODO(johnniwinther): Temporarily copied from analyzer2dart. Merge when
 // we shared code with the analyzer and this semantic visitor is complete.
 
 /**
  * Code for classifying the semantics of identifiers appearing in a Dart file.
  */
@@ skipping 370 matching lines @@
   /// class.
   ///
   /// For instance
   ///     abstract class C {
   ///       C();
   ///     }
   ///     m() => new C();
   ///
   ABSTRACT,
 
-  /// An invocation of an unresolved constructor or an unresolved type.
+  /// An invocation of a constructor on an unresolved type.
+  ///
+  /// For instance
+  ///     m() => new Unresolved();
+  ///
+  UNRESOLVED_TYPE,
+
+  /// An invocation of an unresolved constructor.
   ///
   /// For instance
   ///     class C {
   ///       C();
   ///     }
-  ///     m1() => new C.unresolved();
-  ///     m2() => new Unresolved();
+  ///     m() => new C.unresolved();
   ///
-  // TODO(johnniwinther): Differentiate between error types.
-  ERRONEOUS,
+  UNRESOLVED_CONSTRUCTOR,
+
+  /// An const invocation of an non-constant constructor.
+  ///
+  /// For instance
+  ///     class C {
+  ///       C();
+  ///     }
+  ///     m() => const C();
+  ///
+  NON_CONSTANT_CONSTRUCTOR,
 
   /// An invocation of an ill-defined redirecting factory constructor.
   ///
   /// For instance
   ///     class C {
   ///       factory C() = Unresolved;
   ///     }
   ///     m() => new C();
   ///
   ERRONEOUS_REDIRECTING_FACTORY,
@@ skipping 12 matching lines @@
 
   ConstructorAccessSemantics(this.kind, this.element, this.type);
 
   /// The effect target of the access. Used to defined redirecting factory
   /// constructor invocations.
   ConstructorAccessSemantics get effectiveTargetSemantics => this;
 
   /// `true` if this invocation is erroneous.
   bool get isErroneous {
     return kind == ConstructorAccessKind.ABSTRACT ||
-           kind == ConstructorAccessKind.ERRONEOUS ||
+           kind == ConstructorAccessKind.UNRESOLVED_TYPE ||
+           kind == ConstructorAccessKind.UNRESOLVED_CONSTRUCTOR ||
+           kind == ConstructorAccessKind.NON_CONSTANT_CONSTRUCTOR ||
            kind == ConstructorAccessKind.ERRONEOUS_REDIRECTING_FACTORY;
   }
 }
 
 /// Data structure used to classify the semantics of a redirecting factory
 /// constructor invocation.
 class RedirectingFactoryConstructorAccessSemantics
     extends ConstructorAccessSemantics {
   final ConstructorAccessSemantics effectiveTargetSemantics;
 
   RedirectingFactoryConstructorAccessSemantics(
       ConstructorAccessKind kind,
       Element element,
       DartType type,
       this.effectiveTargetSemantics)
       : super(kind, element, type);
 }