Make some ErrorCode-s compile-time errors and some just type warnings

compiler/java/com/google/dart/compiler/resolver/Resolver.java

 // Copyright (c) 2011, 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.
 
 package com.google.dart.compiler.resolver;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.Sets;
 import com.google.dart.compiler.DartCompilationPhase;
 import com.google.dart.compiler.DartCompilerContext;
@@ skipping 402 matching lines @@
     }
 
     @Override
     public Element visitVariableStatement(DartVariableStatement node) {
       resolveVariableStatement(node, false);
       return null;
     }
 
     private void resolveVariableStatement(DartVariableStatement node,
                                           boolean isImplicitlyInitialized) {
-       Type type = resolveType(node.getTypeNode(), inStaticContext(currentMethod));
+      Type type =
+          resolveType(
+              node.getTypeNode(),
+              inStaticContext(currentMethod),
+              TypeErrorCode.NO_SUCH_TYPE);
        for (DartVariable variable : node.getVariables()) {
          Elements.setType(resolveVariable(variable, node.getModifiers()), type);
          checkVariableStatement(node, variable, isImplicitlyInitialized);
        }
      }
 
     @Override
     public Element visitLabel(DartLabel x) {
       LabelElement previousLabel = currentLabel;
       currentLabel = Elements.labelElement(x, x.getName(), innermostFunction);
@@ skipping 261 matching lines @@
       }
 
       // If we we haven't resolved the identifier, it will be normalized to
       // this.<identifier>.
 
       return recordElement(x, element);
     }
 
     @Override
     public Element visitTypeNode(DartTypeNode x) {
-      return resolveType(x, inStaticContext(currentMethod)).getElement();
+      return resolveType(x, inStaticContext(currentMethod), ResolverErrorCode.NO_SUCH_TYPE).getElement();
     }
 
     @Override
     public Element visitPropertyAccess(DartPropertyAccess x) {
       Element qualifier = resolveQualifier(x.getQualifier());
       Element element = null;
       switch (ElementKind.of(qualifier)) {
         case CLASS:
           // Must be a static field.
           element = Elements.findElement(((ClassElement) qualifier), x.getPropertyName());
@@ skipping 160 matching lines @@
 
       if (x.isConst()) {
         for (DartExpression arg : x.getArgs()) {
          checkConstantExpression(arg);
         }
       }
 
       Element element = x.getConstructor().accept(getContext().new Selector() {
         // Only 'new' expressions can have a type in a property access.
         @Override public Element visitTypeNode(DartTypeNode type) {
-          return recordType(type, resolveType(type, inStaticContext(currentMethod)));
+          return recordType(
+              type,
+              resolveType(type, inStaticContext(currentMethod), ResolverErrorCode.NO_SUCH_TYPE));
         }
 
         @Override public Element visitPropertyAccess(DartPropertyAccess node) {
           Element element = node.getQualifier().accept(this);
           if (ElementKind.of(element).equals(ElementKind.CLASS)) {
             return Elements.lookupConstructor(((ClassElement) element), node.getPropertyName());
           } else {
             return null;
           }
         }
@@ skipping 290 matching lines @@
            }
            break;
         }
       }
       return null;
     }
 
     @Override
     public Element visitMapLiteral(DartMapLiteral node) {
       List<DartTypeNode> typeArgs = node.getTypeArguments();
-      InterfaceType type = topLevelContext.instantiateParameterizedType(
-        defaultLiteralMapType.getElement(), node, typeArgs, inStaticContext(currentMethod));
+      InterfaceType type =
+          topLevelContext.instantiateParameterizedType(
+              defaultLiteralMapType.getElement(),
+              node,
+              typeArgs,
+              inStaticContext(currentMethod),
+              ResolverErrorCode.NO_SUCH_TYPE);
       // instantiateParametersType() will complain for wrong number of parameters (!=2)
       recordType(node, type);
       visit(node.getEntries());
       return null;
     }
 
     @Override
     public Element visitArrayLiteral(DartArrayLiteral node) {
       List<DartTypeNode> typeArgs = node.getTypeArguments();
-      InterfaceType type = topLevelContext.instantiateParameterizedType(rawArrayType.getElement(),
-        node, typeArgs, inStaticContext(currentMethod));
+      InterfaceType type =
+          topLevelContext.instantiateParameterizedType(
+              rawArrayType.getElement(),
+              node,
+              typeArgs,
+              inStaticContext(currentMethod),
+              ResolverErrorCode.NO_SUCH_TYPE);
       // instantiateParametersType() will complain for wrong number of parameters (!=1)
       recordType(node, type);
       visit(node.getExpressions());
       return null;
     }
 
     private ConstructorElement checkIsConstructor(DartNewExpression source, Element element) {
       if (!ElementKind.of(element).equals(ElementKind.CONSTRUCTOR)) {
         if (!context.shouldWarnOnNoSuchType()) {
           onError(source.getConstructor(), ResolverErrorCode.NEW_EXPRESSION_NOT_CONSTRUCTOR);
@@ skipping 172 matching lines @@
         ClassElement nextClass = (ClassElement) nextConstructorElement.getEnclosingElement();
         ClassElement currentClass = (ClassElement) constructor.getEnclosingElement();
         if (nextClass.getName().equals(currentClass.getName())) {
           return nextConstructorElement;
         }
       }
     }
     return null;
   }
 }