Clean up error handling.

dart/sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 209 matching lines @@
       Element originParameter = originParameters.head;
       Element patchParameter = patchParameters.head;
       // Hack: Use unparser to test parameter equality. This only works because
       // we are restricting patch uses and the approach cannot be used
       // elsewhere.
       String originParameterText =
           originParameter.parseNode(compiler).toString();
       String patchParameterText =
           patchParameter.parseNode(compiler).toString();
       if (originParameterText != patchParameterText) {
-        compiler.reportErrorCode(
+        compiler.reportError(
             originParameter.parseNode(compiler),
             MessageKind.PATCH_PARAMETER_MISMATCH,
             {'methodName': origin.name,
              'originParameter': originParameterText,
              'patchParameter': patchParameterText});
         compiler.reportMessage(
             compiler.spanFromSpannable(patchParameter),
             MessageKind.PATCH_POINT_TO_PARAMETER.error(
                 {'parameterName': patchParameter.name}),
             Diagnostic.INFO);
       }
       DartType originParameterType = originParameter.computeType(compiler);
       DartType patchParameterType = patchParameter.computeType(compiler);
       if (originParameterType != patchParameterType) {
-        compiler.reportErrorCode(
+        compiler.reportError(
             originParameter.parseNode(compiler),
             MessageKind.PATCH_PARAMETER_TYPE_MISMATCH,
             {'methodName': origin.name,
              'parameterName': originParameter.name,
              'originParameterType': originParameterType,
              'patchParameterType': patchParameterType});
         compiler.reportMessage(
             compiler.spanFromSpannable(patchParameter),
             MessageKind.PATCH_POINT_TO_PARAMETER.error(
                 {'parameterName': patchParameter.name}),
@@ skipping 219 matching lines @@
   /**
    * Load and resolve the supertypes of [cls].
    *
    * Warning: do not call this method directly. It should only be
    * called by [resolveClass] and [ClassSupertypeResolver].
    */
   void loadSupertypes(ClassElement cls, Spannable from) {
     compiler.withCurrentElement(cls, () => measure(() {
       if (cls.supertypeLoadState == STATE_DONE) return;
       if (cls.supertypeLoadState == STATE_STARTED) {
-        compiler.reportErrorCode(from, MessageKind.CYCLIC_CLASS_HIERARCHY,
+        compiler.reportError(from, MessageKind.CYCLIC_CLASS_HIERARCHY,
                                  {'className': cls.name});
         cls.supertypeLoadState = STATE_DONE;
         cls.allSupertypes = const Link<DartType>().prepend(
             compiler.objectClass.computeType(compiler));
         cls.supertype = cls.allSupertypes.head;
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
       compiler.withCurrentElement(cls, () {
         // TODO(ahe): Cache the node in cls.
@@ skipping 90 matching lines @@
     } else {
       checkClassMembers(element);
     }
   }
 
   void checkMixinApplication(MixinApplicationElement mixinApplication) {
     Modifiers modifiers = mixinApplication.modifiers;
     int illegalFlags = modifiers.flags & ~Modifiers.FLAG_ABSTRACT;
     if (illegalFlags != 0) {
       Modifiers illegalModifiers = new Modifiers.withFlags(null, illegalFlags);
-      compiler.reportErrorCode(
+      compiler.reportError(
           modifiers,
           MessageKind.ILLEGAL_MIXIN_APPLICATION_MODIFIERS,
           {'modifiers': illegalModifiers});
     }
 
     // In case of cyclic mixin applications, the mixin chain will have
     // been cut. If so, we have already reported the error to the
     // user so we just return from here.
     ClassElement mixin = mixinApplication.mixin;
     if (mixin == null) return;
 
     // Check that we're not trying to use Object as a mixin.
     if (mixin.superclass == null) {
-      compiler.reportErrorCode(mixinApplication,
+      compiler.reportError(mixinApplication,
                                MessageKind.ILLEGAL_MIXIN_OBJECT);
       // Avoid reporting additional errors for the Object class.
       return;
     }
 
     // Check that the mixed in class has Object as its superclass.
     if (!mixin.superclass.isObject(compiler)) {
-      compiler.reportErrorCode(mixin, MessageKind.ILLEGAL_MIXIN_SUPERCLASS);
+      compiler.reportError(mixin, MessageKind.ILLEGAL_MIXIN_SUPERCLASS);
     }
 
     // Check that the mixed in class doesn't have any constructors and
     // make sure we aren't mixing in methods that use 'super'.
     mixin.forEachLocalMember((Element member) {
       if (member.isGenerativeConstructor() && !member.isSynthesized) {
-        compiler.reportErrorCode(member, MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR);
+        compiler.reportError(member, MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR);
       } else {
         // Get the resolution tree and check that the resolved member
         // doesn't use 'super'. This is the part of the 'super' mixin
         // check that happens when a function is resolved before the
         // mixin application has been performed.
         checkMixinSuperUses(
             compiler.enqueuer.resolution.resolvedElements[member],
             mixinApplication,
             mixin);
       }
     });
   }
 
   void checkMixinSuperUses(TreeElements resolutionTree,
                            MixinApplicationElement mixinApplication,
                            ClassElement mixin) {
     if (resolutionTree == null) return;
     Set<Node> superUses = resolutionTree.superUses;
     if (superUses.isEmpty) return;
-    compiler.reportErrorCode(mixinApplication,
+    compiler.reportError(mixinApplication,
                              MessageKind.ILLEGAL_MIXIN_WITH_SUPER,
                              {'className': mixin.name});

[kustermann, 2013/07/27 09:50:29]

Indentation.

[ahe, 2013/07/28 09:05:51]

Done.

     // Show the user the problematic uses of 'super' in the mixin.
     for (Node use in superUses) {
-      CompilationError error = MessageKind.ILLEGAL_MIXIN_SUPER_USE.error();
-      compiler.reportMessage(compiler.spanFromNode(use),
-                             error, Diagnostic.INFO);
+      compiler.reportInfo(
+          use,
+          MessageKind.ILLEGAL_MIXIN_SUPER_USE);
     }
   }
 
   void checkClassMembers(ClassElement cls) {
     assert(invariant(cls, cls.isDeclaration));
     if (cls.isObject(compiler)) return;
     // TODO(johnniwinther): Should this be done on the implementation element as
     // well?
     cls.forEachMember((holder, member) {
       compiler.withCurrentElement(member, () {
         // Perform various checks as side effect of "computing" the type.
         member.computeType(compiler);
 
         // Check modifiers.
         if (member.isFunction() && member.modifiers.isFinal()) {
-          compiler.reportErrorCode(
+          compiler.reportError(
               member, MessageKind.ILLEGAL_FINAL_METHOD_MODIFIER);
         }
         if (member.isConstructor()) {
           final mismatchedFlagsBits =
               member.modifiers.flags &
               (Modifiers.FLAG_STATIC | Modifiers.FLAG_ABSTRACT);
           if (mismatchedFlagsBits != 0) {
             final mismatchedFlags =
                 new Modifiers.withFlags(null, mismatchedFlagsBits);
-            compiler.reportErrorCode(
+            compiler.reportError(
                 member,
                 MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS,
                 {'modifiers': mismatchedFlags});
           }
         }
         checkAbstractField(member);
         checkValidOverride(member, cls.lookupSuperMember(member.name));
         checkUserDefinableOperator(member);
       });
     });
@@ skipping 17 matching lines @@
     }
     AbstractFieldElement field = lookupElement;
 
     if (field.getter == null) return;
     if (field.setter == null) return;
     int getterFlags = field.getter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
     int setterFlags = field.setter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
     if (!identical(getterFlags, setterFlags)) {
       final mismatchedFlags =
         new Modifiers.withFlags(null, getterFlags ^ setterFlags);
-      compiler.reportErrorCode(
+      compiler.reportError(
           field.getter,
           MessageKind.GETTER_MISMATCH,
           {'modifiers': mismatchedFlags});
-      compiler.reportErrorCode(
+      compiler.reportError(
           field.setter,
           MessageKind.SETTER_MISMATCH,
           {'modifiers': mismatchedFlags});
     }
   }
 
   void checkUserDefinableOperator(Element member) {
     FunctionElement function = member.asFunctionElement();
     if (function == null) return;
     String value = member.name.stringValue;
@@ skipping 69 matching lines @@
           //     int operator -(a, b) {}
           //                       ^
           //
           // since the correction might not be to remove 'b' but instead to
           // remove 'a, b'.
           errorNode = node.parameters;
         } else {
           errorNode = node.parameters.nodes.skip(requiredParameterCount).head;
         }
       }
-      compiler.reportErrorCode(
+      compiler.reportError(
           errorNode, messageKind, {'operatorName': function.name});
     }
     if (signature.optionalParameterCount != 0) {
       Node errorNode =
           node.parameters.nodes.skip(signature.requiredParameterCount).head;
       if (signature.optionalParametersAreNamed) {
-        compiler.reportErrorCode(
+        compiler.reportError(
             errorNode,
             MessageKind.OPERATOR_NAMED_PARAMETERS,
             {'operatorName': function.name});
       } else {
-        compiler.reportErrorCode(
+        compiler.reportError(
             errorNode,
             MessageKind.OPERATOR_OPTIONAL_PARAMETERS,
             {'operatorName': function.name});
       }
     }
   }
 
   reportErrorWithContext(Element errorneousElement,
                          MessageKind errorMessage,
                          Element contextElement,
                          MessageKind contextMessage) {
-    compiler.reportErrorCode(
+    compiler.reportError(
         errorneousElement,
         errorMessage,
         {'memberName': contextElement.name,
          'className': contextElement.getEnclosingClass().name});
     compiler.reportMessage(
         compiler.spanFromElement(contextElement),
         contextMessage.error(),
         Diagnostic.INFO);
   }
 
@@ skipping 117 matching lines @@
       ResolverVisitor visitor = visitorFor(context);
       node.accept(visitor);
       annotation.value = compiler.metadataHandler.compileNodeWithDefinitions(
           node, visitor.mapping, isConst: true);
 
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
   error(Node node, MessageKind kind, [arguments = const {}]) {
-    ResolutionError message = new ResolutionError(kind, arguments);
-    compiler.reportError(node, message);
+    // TODO(ahe): Make non-fatal.
+    compiler.reportFatalError(node, kind, arguments);
   }
 }
 
 class InitializerResolver {
   final ResolverVisitor visitor;
   final Map<Element, Node> initialized;
   Link<Node> initializers;
   bool hasSuper;
 
   InitializerResolver(this.visitor)
@@ skipping 10 matching lines @@
   bool isFieldInitializer(SendSet node) {
     if (node.selector.asIdentifier() == null) return false;
     if (node.receiver == null) return true;
     if (node.receiver.asIdentifier() == null) return false;
     return node.receiver.asIdentifier().isThis();
   }
 
   reportDuplicateInitializerError(Element field, Node init, Node existing) {
     visitor.compiler.reportError(
         init,
-        new ResolutionError(MessageKind.DUPLICATE_INITIALIZER,
-                            {'fieldName': field.name}));
-    visitor.compiler.reportMessage(
-        visitor.compiler.spanFromNode(existing),
-        new ResolutionError(MessageKind.ALREADY_INITIALIZED,
-                            {'fieldName': field.name}),
-        Diagnostic.INFO);
+        MessageKind.DUPLICATE_INITIALIZER, {'fieldName': field.name});
+    visitor.compiler.reportInfo(
+        existing,
+        MessageKind.ALREADY_INITIALIZED, {'fieldName': field.name});
   }
 
   void checkForDuplicateInitializers(Element field, Node init) {
     // [field] can be null if it could not be resolved.
     if (field == null) return;
     SourceString name = field.name;
     if (initialized.containsKey(field)) {
       reportDuplicateInitializerError(field, init, initialized[field]);
     } else if (field.modifiers.isFinal()) {
       Node fieldNode = field.parseNode(visitor.compiler).asSendSet();
       if (fieldNode != null) {
         reportDuplicateInitializerError(field, init, fieldNode);
       }
     }
     initialized[field] = init;
   }
 
   void resolveFieldInitializer(FunctionElement constructor, SendSet init) {
     // init is of the form [this.]field = value.
     final Node selector = init.selector;
     final SourceString name = selector.asIdentifier().source;
     // Lookup target field.
     Element target;
     if (isFieldInitializer(init)) {
       target = constructor.getEnclosingClass().lookupLocalMember(name);
       if (target == null) {
-        error(selector, MessageKind.CANNOT_RESOLVE, {'name': name});
+        error(selector, MessageKind.CANNOT_RESOLVE.error, {'name': name});
       } else if (target.kind != ElementKind.FIELD) {
         error(selector, MessageKind.NOT_A_FIELD, {'fieldName': name});
       } else if (!target.isInstanceMember()) {
         error(selector, MessageKind.INIT_STATIC_FIELD, {'fieldName': name});
       }
     } else {
       error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
     }
     visitor.useElement(init, target);
     visitor.world.registerStaticUse(target);
@@ skipping 99 matching lines @@
       Selector constructorSelector) {
     if (lookedupConstructor == null
         || !lookedupConstructor.isGenerativeConstructor()) {
       var fullConstructorName =
           visitor.compiler.resolver.constructorNameForDiagnostics(
               className,
               constructorSelector.name);
       MessageKind kind = isImplicitSuperCall
           ? MessageKind.CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT
           : MessageKind.CANNOT_RESOLVE_CONSTRUCTOR;
-      visitor.compiler.reportErrorCode(
+      visitor.compiler.reportError(
           diagnosticNode, kind, {'constructorName': fullConstructorName});
     } else {
       if (!call.applies(lookedupConstructor, visitor.compiler)) {
         MessageKind kind = isImplicitSuperCall
                            ? MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT
                            : MessageKind.NO_MATCHING_CONSTRUCTOR;
-        visitor.compiler.reportErrorCode(diagnosticNode, kind);
+        visitor.compiler.reportError(diagnosticNode, kind);
       } else if (caller.modifiers.isConst()
                  && !lookedupConstructor.modifiers.isConst()) {
-        visitor.compiler.reportErrorCode(
+        visitor.compiler.reportError(
             diagnosticNode, MessageKind.CONST_CALLS_NON_CONST);
       }
     }
   }
 
   FunctionElement resolveRedirection(FunctionElement constructor,
                                      FunctionExpression functionNode) {
     if (functionNode.initializers == null) return null;
     Link<Node> link = functionNode.initializers.nodes;
     if (!link.isEmpty && Initializers.isConstructorRedirect(link.head)) {
@@ skipping 84 matching lines @@
     cancel(node,
            'internal error: Unhandled node: ${node.getObjectDescription()}');
   }
 
   R visitEmptyStatement(Node node) => null;
 
   /** Convenience method for visiting nodes that may be null. */
   R visit(Node node) => (node == null) ? null : node.accept(this);
 
   void error(Node node, MessageKind kind, [Map arguments = const {}]) {
-    ResolutionError message  = new ResolutionError(kind, arguments);
-    compiler.reportError(node, message);
+    compiler.reportFatalError(node, kind, arguments);
+  }
+
+  void dualError(Node node, DualKind kind, [Map arguments = const {}]) {
+    error(node, kind.error, arguments);
   }
 
   void warning(Node node, MessageKind kind, [Map arguments = const {}]) {
     ResolutionWarning message  = new ResolutionWarning(kind, arguments);
     compiler.reportWarning(node, message);
   }
 
+  void dualWarning(Node node, DualKind kind, [Map arguments = const {}]) {
+    warning(node, kind.warning, arguments);
+  }
+
   void cancel(Node node, String message) {
     compiler.cancel(message, node: node);
   }
 
   void internalError(Node node, String message) {
     compiler.internalError(message, node: node);
   }
 
   void unimplemented(Node node, String message) {
     compiler.unimplemented(message, node: node);
@@ skipping 130 matching lines @@
         return scope.lookup(typeName.source);
       }
     }
   }
 
   // TODO(johnniwinther): Change  [onFailure] and [whenResolved] to use boolean
   // flags instead of closures.
   DartType resolveTypeAnnotation(
       MappingVisitor visitor,
       TypeAnnotation node,
-      {onFailure(Node node, MessageKind kind, [Map arguments])}) {
+      {onFailure(Node node, DualKind kind, [Map arguments])}) {
     if (onFailure == null) {
       onFailure = (n, k, [arguments]) {};
     }
     return resolveTypeAnnotationInContext(visitor, node, onFailure);
   }
 
-  DartType resolveTypeAnnotationInContext(MappingVisitor visitor,
-                                          TypeAnnotation node,
-                                          onFailure) {
+  DartType resolveTypeAnnotationInContext(
+      MappingVisitor visitor,
+      TypeAnnotation node,
+      onFailure(Node node, DualKind kind, [Map arguments])) {
     Identifier typeName;
     SourceString prefixName;
     Send send = node.typeName.asSend();
     if (send != null) {
       // The type name is of the form [: prefix . identifier :].
       prefixName = send.receiver.asIdentifier().source;
       typeName = send.selector.asIdentifier();
     } else {
       typeName = node.typeName.asIdentifier();
     }
 
     Element element = resolveTypeName(visitor.scope, prefixName, typeName);
     DartType type;
 
-    DartType reportFailureAndCreateType(MessageKind messageKind,
+    DartType reportFailureAndCreateType(DualKind messageKind,
                                         Map messageArguments) {
       onFailure(node, messageKind, messageArguments);
       var erroneousElement = new ErroneousElementX(
-          messageKind, messageArguments, typeName.source,
+          messageKind.error, messageArguments, typeName.source,
           visitor.enclosingElement);
       var arguments = new LinkBuilder<DartType>();
       resolveTypeArguments(
           visitor, node, null,
           onFailure, arguments);
       return new MalformedType(erroneousElement, null, arguments.toLink());
     }
 
     DartType checkNoTypeArguments(DartType type) {
       var arguments = new LinkBuilder<DartType>();
@@ skipping 68 matching lines @@
       } else if (element.isTypeVariable()) {
         Element outer =
             visitor.enclosingElement.getOutermostEnclosingMemberOrTopLevel();
         bool isInFactoryConstructor =
             outer != null && outer.isFactoryConstructor();
         if (!outer.isClass() &&
             !outer.isTypedef() &&
             !isInFactoryConstructor &&
             Elements.isInStaticContext(visitor.enclosingElement)) {
           compiler.backend.registerThrowRuntimeError(visitor.mapping);
-          compiler.reportWarning(node,
-              MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER.message(
-                  {'typeVariableName': node}));
+          compiler.reportWarningCode(
+              node,
+              MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER.warning,
+              {'typeVariableName': node});
           type = new MalformedType(
               new ErroneousElementX(
-                  MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
+                  MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER.error,
                   {'typeVariableName': node},
                   typeName.source, visitor.enclosingElement),
                   element.computeType(compiler));
         } else {
           type = element.computeType(compiler);
         }
         type = checkNoTypeArguments(type);
       } else {
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
     }
     visitor.useType(node, type);
     return type;
   }
 
   /**
    * Resolves the type arguments of [node] and adds these to [arguments].
    *
    * Returns [: true :] if the number of type arguments did not match the
    * number of type variables.
    */
   bool resolveTypeArguments(
       MappingVisitor visitor,
       TypeAnnotation node,
       Link<DartType> typeVariables,
-      onFailure,
+      onFailure(Node node, DualKind kind, [Map arguments]),
       LinkBuilder<DartType> arguments) {
     if (node.typeArguments == null) {
       return false;
     }
     bool typeArgumentCountMismatch = false;
     for (Link<Node> typeArguments = node.typeArguments.nodes;
          !typeArguments.isEmpty;
          typeArguments = typeArguments.tail) {
       if (typeVariables != null && typeVariables.isEmpty) {
         onFailure(typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
@@ skipping 116 matching lines @@
            !element.enclosingElement.isTypedef()),
       inCatchBlock = false,
       super(compiler, mapping);
 
   ResolutionEnqueuer get world => compiler.enqueuer.resolution;
 
   Element lookup(Node node, SourceString name) {
     Element result = scope.lookup(name);
     if (!Elements.isUnresolved(result)) {
       if (!inInstanceContext && result.isInstanceMember()) {
-        compiler.reportErrorCode(
+        compiler.reportError(
             node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': name});
         return new ErroneousElementX(MessageKind.NO_INSTANCE_AVAILABLE,
                                      {'name': name},
                                      name, enclosingElement);
       } else if (result.isAmbiguous()) {
         AmbiguousElement ambiguous = result;
-        compiler.reportErrorCode(
-            node, ambiguous.messageKind, ambiguous.messageArguments);
+        compiler.reportError(
+            node, ambiguous.messageKind.error, ambiguous.messageArguments);
         ambiguous.diagnose(enclosingElement, compiler);
-        return new ErroneousElementX(ambiguous.messageKind,
+        return new ErroneousElementX(ambiguous.messageKind.error,
                                      ambiguous.messageArguments,
                                      name, enclosingElement);
       }
     }
     return result;
   }
 
   // Create, or reuse an already created, statement element for a statement.
   TargetElement getOrCreateTargetElement(Node statement) {
     TargetElement element = mapping[statement];
@@ skipping 21 matching lines @@
     inInstanceContext = wasInstanceContext;
     return result;
   }
 
   visitInStaticContext(Node node) {
     inStaticContext(() => visit(node));
   }
 
   ErroneousElement warnAndCreateErroneousElement(Node node,
                                                  SourceString name,
-                                                 MessageKind kind,
+                                                 DualKind kind,
                                                  [Map arguments = const {}]) {
-    ResolutionWarning warning = new ResolutionWarning(kind, arguments);
+    ResolutionWarning warning = new ResolutionWarning(kind.warning, arguments);
     compiler.reportWarning(node, warning);
-    return new ErroneousElementX(kind, arguments, name, enclosingElement);
+    return new ErroneousElementX(kind.error, arguments, name, enclosingElement);
   }
 
   Element visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
       }
       return null;
     } else if (node.isSuper()) {
       if (!inInstanceContext) error(node, MessageKind.NO_SUPER_IN_STATIC);
       if ((ElementCategory.SUPER & allowedCategory) == 0) {
         error(node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return null;
     } else {
       Element element = lookup(node, node.source);
       if (element == null) {
         if (!inInstanceContext) {
-          element = warnAndCreateErroneousElement(node, node.source,
-                                                  MessageKind.CANNOT_RESOLVE,
-                                                  {'name': node});
+          element = warnAndCreateErroneousElement(
+              node, node.source, MessageKind.CANNOT_RESOLVE,
+              {'name': node});
           compiler.backend.registerThrowNoSuchMethod(mapping);
         }
       } else if (element.isErroneous()) {
         // Use the erroneous element.
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC,
                 {'text': "is not an expression $element"});
         }
@@ skipping 17 matching lines @@
     return null;
   }
 
   Element defineElement(Node node, Element element,
                         {bool doAddToScope: true}) {
     compiler.ensure(element != null);
     mapping[node] = element;
     if (doAddToScope) {
       Element existing = scope.add(element);
       if (existing != element) {
-        compiler.reportErrorCode(
+        compiler.reportError(
             node, MessageKind.DUPLICATE_DEFINITION, {'name': node});
         compiler.reportMessage(
             compiler.spanFromSpannable(existing),
             MessageKind.EXISTING_DEFINITION.error({'name': node}),
             Diagnostic.INFO);
       }
     }
     return element;
   }
 
@@ skipping 25 matching lines @@
       final ClassElement classElement = constructor.getEnclosingClass();
       return classElement.lookupConstructor(selector);
     }
     return null;
   }
 
   void setupFunction(FunctionExpression node, FunctionElement function) {
     Element enclosingElement = function.enclosingElement;
     if (node.modifiers.isStatic() &&
         enclosingElement.kind != ElementKind.CLASS) {
-      compiler.reportErrorCode(node, MessageKind.ILLEGAL_STATIC);
+      compiler.reportError(node, MessageKind.ILLEGAL_STATIC);
     }
 
     scope = new MethodScope(scope, function);
     // Put the parameters in scope.
     FunctionSignature functionParameters =
         function.computeSignature(compiler);
     Link<Node> parameterNodes = (node.parameters == null)
         ? const Link<Node>() : node.parameters.nodes;
     functionParameters.forEachParameter((Element element) {
       if (element == functionParameters.optionalParameters.head) {
@@ skipping 214 matching lines @@
       target = receiverClass.lookupLocalMember(name);
       if (target == null || target.isInstanceMember()) {
         compiler.backend.registerThrowNoSuchMethod(mapping);
         // TODO(johnniwinther): With the simplified [TreeElements] invariant,
         // try to resolve injected elements if [currentClass] is in the patch
         // library of [receiverClass].
 
         // TODO(karlklose): this should be reported by the caller of
         // [resolveSend] to select better warning messages for getters and
         // setters.
-        MessageKind kind = (target == null)
+        DualKind kind = (target == null)
             ? MessageKind.MEMBER_NOT_FOUND
             : MessageKind.MEMBER_NOT_STATIC;
         return warnAndCreateErroneousElement(node, name, kind,
                                              {'className': receiverClass.name,
                                               'memberName': name});
       }
     } else if (identical(resolvedReceiver.kind, ElementKind.PREFIX)) {
       PrefixElement prefix = resolvedReceiver;
       target = prefix.lookupLocalMember(name);
       if (Elements.isUnresolved(target)) {
@@ skipping 81 matching lines @@
   void resolveArguments(NodeList list) {
     if (list == null) return;
     Map<SourceString, Node> seenNamedArguments = new Map<SourceString, Node>();
     for (Link<Node> link = list.nodes; !link.isEmpty; link = link.tail) {
       Expression argument = link.head;
       visit(argument);
       NamedArgument namedArgument = argument.asNamedArgument();
       if (namedArgument != null) {
         SourceString source = namedArgument.name.source;
         if (seenNamedArguments.containsKey(source)) {
-          compiler.reportErrorCode(
+          compiler.reportError(
               argument,
               MessageKind.DUPLICATE_DEFINITION,
               {'name': source});
           compiler.reportMessage(
               compiler.spanFromSpannable(seenNamedArguments[source]),
               MessageKind.EXISTING_DEFINITION.error({'name': source}),
               Diagnostic.INFO);
         } else {
           seenNamedArguments[source] = namedArgument;
         }
@@ skipping 106 matching lines @@
     if (node.isPropertyAccess && Elements.isStaticOrTopLevelFunction(target)) {
       world.registerGetOfStaticFunction(target.declaration);
     }
     return node.isPropertyAccess ? target : null;
   }
 
   void warnArgumentMismatch(Send node, Element target) {
     compiler.backend.registerThrowNoSuchMethod(mapping);
     // TODO(karlklose): we can be more precise about the reason of the
     // mismatch.
-    warning(node.argumentsNode, MessageKind.INVALID_ARGUMENTS,
+    warning(node.argumentsNode, MessageKind.INVALID_ARGUMENTS.warning,
             {'methodName': target.name});
   }
 
   /// Callback for native enqueuer to parse a type.  Returns [:null:] on error.
   DartType resolveTypeFromString(String typeName) {
     Element element = scope.lookup(new SourceString(typeName));
     if (element == null) return null;
     if (element is! ClassElement) return null;
     ClassElement cls = element;
     cls.ensureResolved(compiler);
@@ skipping 147 matching lines @@
     if (node.isRedirectingFactoryBody) {
       handleRedirectingFactoryBody(node);
     } else {
       visit(node.expression);
     }
   }
 
   void handleRedirectingFactoryBody(Return node) {
     final isSymbolConstructor = enclosingElement == compiler.symbolConstructor;
     if (!enclosingElement.isFactoryConstructor()) {
-      compiler.reportErrorCode(
+      compiler.reportError(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
-      compiler.reportErrorCode(
+      compiler.reportHint(
           enclosingElement, MessageKind.MISSING_FACTORY_KEYWORD);
     }
     FunctionElement redirectionTarget = resolveRedirectingFactory(node);
     useElement(node.expression, redirectionTarget);
     FunctionElement constructor = enclosingElement;
     if (constructor.modifiers.isConst() &&
         !redirectionTarget.modifiers.isConst()) {
       error(node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
     }
     constructor.defaultImplementation = redirectionTarget;
     if (Elements.isUnresolved(redirectionTarget)) {
       compiler.backend.registerThrowNoSuchMethod(mapping);
       return;
     }
 
     // Check that the target constructor is type compatible with the
     // redirecting constructor.
     ClassElement targetClass = redirectionTarget.getEnclosingClass();
     InterfaceType type = mapping.getType(node.expression);
     FunctionType targetType = redirectionTarget.computeType(compiler)
         .subst(type.typeArguments, targetClass.typeVariables);
     FunctionType constructorType = constructor.computeType(compiler);
     if (!compiler.types.isSubtype(targetType, constructorType)) {
-      warning(node, MessageKind.NOT_ASSIGNABLE,
+      warning(node, MessageKind.NOT_ASSIGNABLE.warning,
               {'fromType': targetType, 'toType': constructorType});
     }
 
     FunctionSignature targetSignature =
         redirectionTarget.computeSignature(compiler);
     FunctionSignature constructorSignature =
         constructor.computeSignature(compiler);
     if (!targetSignature.isCompatibleWith(constructorSignature)) {
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
@@ skipping 71 matching lines @@
       warnArgumentMismatch(node.send, constructor);
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
 
     // [constructor] might be the implementation element
     // and only declaration elements may be registered.
     world.registerStaticUse(constructor.declaration);
     ClassElement cls = constructor.getEnclosingClass();
     InterfaceType type = mapping.getType(node);
     if (node.isConst() && type.containsTypeVariables) {
-      compiler.reportErrorCode(node.send.selector,
+      compiler.reportError(node.send.selector,
                                MessageKind.TYPE_VARIABLE_IN_CONSTANT);
     }
     world.registerInstantiatedType(type, mapping);
     if (constructor.isFactoryConstructor() && !type.typeArguments.isEmpty) {
       world.registerFactoryWithTypeArguments(mapping);
     }
     if (cls.isAbstract(compiler)) {
       compiler.backend.registerAbstractClassInstantiation(mapping);
     }
 
     if (isSymbolConstructor) {
       if (node.isConst()) {
         Node argumentNode = node.send.arguments.head;
         Constant name = compiler.metadataHandler.compileNodeWithDefinitions(
             argumentNode, mapping, isConst: true);
         if (!name.isString()) {
           DartType type = name.computeType(compiler);
-          compiler.reportErrorCode(argumentNode, MessageKind.STRING_EXPECTED,
+          compiler.reportError(argumentNode, MessageKind.STRING_EXPECTED,
                                    {'type': type});
         } else {
           StringConstant stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             world.registerConstSymbol(nameString, mapping);
           }
         }
       } else {
         compiler.reportHint(
             node.newToken, MessageKind.NON_CONST_BLOAT,
             {'name': compiler.symbolClass.name});
         world.registerNewSymbol(mapping);
       }
     }
 
     return null;
   }
 
   bool validateSymbol(Node node, String name) {
     if (name.isEmpty) return true;
     if (name.startsWith('_')) {
-      compiler.reportErrorCode(node, MessageKind.PRIVATE_IDENTIFIER,
+      compiler.reportError(node, MessageKind.PRIVATE_IDENTIFIER,
                                {'value': name});
       return false;
     }
     if (!symbolValidationPattern.hasMatch(name)) {
-      compiler.reportErrorCode(node, MessageKind.INVALID_SYMBOL,
+      compiler.reportError(node, MessageKind.INVALID_SYMBOL,
                                {'value': name});
       return false;
     }
     return true;
   }
 
 
   /**
    * 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) {
     return node.accept(new ConstructorResolver(compiler, this));
   }
 
   FunctionElement resolveRedirectingFactory(Return node) {
     return node.accept(new ConstructorResolver(compiler, this));
   }
 
   DartType resolveTypeRequired(TypeAnnotation node) {
     bool old = typeRequired;
     typeRequired = true;
     DartType result = resolveTypeAnnotation(node);
     typeRequired = old;
     return result;
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node) {
-    Function report = typeRequired ? error : warning;
+    Function report = typeRequired ? dualError : dualWarning;
     DartType type = typeResolver.resolveTypeAnnotation(
         this, node, onFailure: report);
     if (type == null) return null;
     if (inCheckContext) {
       compiler.enqueuer.resolution.registerIsCheck(type, mapping);
     }
     if (typeRequired || inCheckContext) {
       compiler.backend.registerRequiredType(type, enclosingElement);
     }
     return type;
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
     NodeList arguments = node.typeArguments;
     DartType typeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
-        error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
+        error(arguments, MessageKind.MISSING_TYPE_ARGUMENT.error);
       } else {
         typeArgument = resolveTypeRequired(nodes.head);
         for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
-          error(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
+          error(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT.error);
           resolveTypeRequired(nodes.head);
         }
       }
     }
     DartType listType;
     if (typeArgument != null) {
       if (node.isConst() && typeArgument.containsTypeVariables) {
-        compiler.reportErrorCode(arguments.nodes.head,
+        compiler.reportError(arguments.nodes.head,
             MessageKind.TYPE_VARIABLE_IN_CONSTANT);
       }
       listType = new InterfaceType(compiler.listClass,
                                    new Link<DartType>.fromList([typeArgument]));
     } else {
       compiler.listClass.computeType(compiler);
       listType = compiler.listClass.rawType;
     }
     mapping.setType(node, listType);
     world.registerInstantiatedType(listType, mapping);
@@ skipping 95 matching lines @@
 
     Send send = declaration.asSend();
     VariableDefinitions variableDefinitions =
         declaration.asVariableDefinitions();
     Element loopVariable;
     Selector loopVariableSelector;
     if (send != null) {
       loopVariable = mapping[send];
       Identifier identifier = send.selector.asIdentifier();
       if (identifier == null) {
-        compiler.reportErrorCode(send.selector, MessageKind.INVALID_FOR_IN);
+        compiler.reportError(send.selector, MessageKind.INVALID_FOR_IN);
       } else {
         loopVariableSelector = new Selector.setter(identifier.source, library);
       }
       if (send.receiver != null) {
-        compiler.reportErrorCode(send.receiver, MessageKind.INVALID_FOR_IN);
+        compiler.reportError(send.receiver, MessageKind.INVALID_FOR_IN);
       }
     } else if (variableDefinitions != null) {
       Link<Node> nodes = variableDefinitions.definitions.nodes;
       if (!nodes.tail.isEmpty) {
-        compiler.reportErrorCode(nodes.tail.head, MessageKind.INVALID_FOR_IN);
+        compiler.reportError(nodes.tail.head, MessageKind.INVALID_FOR_IN);
       }
       Node first = nodes.head;
       Identifier identifier = first.asIdentifier();
       if (identifier == null) {
-        compiler.reportErrorCode(first, MessageKind.INVALID_FOR_IN);
+        compiler.reportError(first, MessageKind.INVALID_FOR_IN);
       } else {
         loopVariableSelector = new Selector.setter(identifier.source, library);
         loopVariable = mapping[identifier];
       }
     } else {
-      compiler.reportErrorCode(declaration, MessageKind.INVALID_FOR_IN);
+      compiler.reportError(declaration, MessageKind.INVALID_FOR_IN);
     }
     if (loopVariableSelector != null) {
       mapping.setSelector(declaration, loopVariableSelector);
       registerSend(loopVariableSelector, loopVariable);
     } else {
       // The selector may only be null if we reported an error.
       assert(invariant(declaration, compiler.compilationFailed));
     }
     if (loopVariable != null) {
       // loopVariable may be null if it could not be resolved.
@@ skipping 34 matching lines @@
     }
   }
 
   visitLiteralMap(LiteralMap node) {
     NodeList arguments = node.typeArguments;
     DartType keyTypeArgument;
     DartType valueTypeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
-        error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
+        error(arguments, MessageKind.MISSING_TYPE_ARGUMENT.error);
       } else {
         keyTypeArgument = resolveTypeRequired(nodes.head);
         nodes = nodes.tail;
         if (nodes.isEmpty) {
-          error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
+          error(arguments, MessageKind.MISSING_TYPE_ARGUMENT.error);
         } else {
           valueTypeArgument = resolveTypeRequired(nodes.head);
           for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
-            error(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
+            error(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT.error);
             resolveTypeRequired(nodes.head);
           }
         }
       }
     }
     DartType mapType;
     if (valueTypeArgument != null) {
       mapType = new InterfaceType(compiler.mapClass,
           new Link<DartType>.fromList([keyTypeArgument, valueTypeArgument]));
     } else {
       compiler.mapClass.computeType(compiler);
       mapType = compiler.mapClass.rawType;
     }
     if (node.isConst() && mapType.containsTypeVariables) {
-      compiler.reportErrorCode(arguments,
+      compiler.reportError(arguments,
           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
     }
     mapping.setType(node, mapType);
     world.registerInstantiatedClass(compiler.mapClass, mapping);
     if (node.isConst()) {
       compiler.backend.registerConstantMap(mapping);
     }
     node.visitChildren(this);
   }
 
@@ skipping 14 matching lines @@
     while (!cases.isEmpty) {
       SwitchCase switchCase = cases.head;
       for (Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is! Label) continue;
         Label label = labelOrCase;
         String labelName = label.slowToString();
 
         LabelElement existingElement = continueLabels[labelName];
         if (existingElement != null) {
           // It's an error if the same label occurs twice in the same switch.
-          warning(label, MessageKind.DUPLICATE_LABEL, {'labelName': labelName});
-          error(existingElement.label, MessageKind.EXISTING_LABEL,
-                {'labelName': labelName});
+          compiler.reportError(
+              label,
+              MessageKind.DUPLICATE_LABEL.error, {'labelName': labelName});
+          compiler.reportInfo(
+              existingElement.label,
+              MessageKind.EXISTING_LABEL, {'labelName': labelName});
         } else {
           // It's only a warning if it shadows another label.
           existingElement = statementScope.lookupLabel(labelName);
           if (existingElement != null) {
-            warning(label, MessageKind.DUPLICATE_LABEL,
-                    {'labelName': labelName});
-            warning(existingElement.label,
-                    MessageKind.EXISTING_LABEL, {'labelName': labelName});
+            compiler.reportWarningCode(
+                label,
+                MessageKind.DUPLICATE_LABEL.warning, {'labelName': labelName});
+            compiler.reportInfo(
+                existingElement.label,
+                MessageKind.EXISTING_LABEL, {'labelName': labelName});
           }
         }
 
         TargetElement targetElement = getOrCreateTargetElement(switchCase);
         LabelElement labelElement = targetElement.addLabel(label, labelName);
         mapping[label] = labelElement;
         continueLabels[labelName] = labelElement;
       }
       cases = cases.tail;
       // Test that only the last case, if any, is a default case.
@@ skipping 143 matching lines @@
       TypeVariable typeNode = nodeLink.head;
       if (nameSet.contains(typeName)) {
         error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME,
               {'typeVariableName': typeName});
       }
       nameSet.add(typeName);
 
       TypeVariableElement variableElement = typeVariable.element;
       if (typeNode.bound != null) {
         DartType boundType = typeResolver.resolveTypeAnnotation(
-            this, typeNode.bound, onFailure: warning);
+            this, typeNode.bound, onFailure: dualWarning);
         variableElement.bound = boundType;
 
         void checkTypeVariableBound() {
           Link<TypeVariableElement> seenTypeVariables =
               const Link<TypeVariableElement>();
           seenTypeVariables = seenTypeVariables.prepend(variableElement);
           DartType bound = boundType;
           while (bound.element.isTypeVariable()) {
             TypeVariableElement element = bound.element;
             if (seenTypeVariables.contains(element)) {
@@ skipping 111 matching lines @@
     }
 
     assert(element.interfaces == null);
     element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
     calculateAllSupertypes(element);
 
     if (!element.hasConstructor) {
       Element superMember =
           element.superclass.localLookup(const SourceString(''));
       if (superMember == null || !superMember.isGenerativeConstructor()) {
-        MessageKind kind = MessageKind.CANNOT_FIND_CONSTRUCTOR;
+        DualKind kind = MessageKind.CANNOT_FIND_CONSTRUCTOR;
         Map arguments = {'constructorName': const SourceString('')};
-        compiler.reportErrorCode(node, kind, arguments);
+        // TODO(ahe): Why is this a compile-time error? Or if it is an error,
+        // why do we bother to registerThrowNoSuchMethod below?
+        compiler.reportError(node, kind.error, arguments);
         superMember = new ErroneousElementX(
-            kind, arguments, const SourceString(''), element);
+            kind.error, arguments, const SourceString(''), element);
         compiler.backend.registerThrowNoSuchMethod(mapping);
       }
       FunctionElement constructor =
           new SynthesizedConstructorElementX.forDefault(superMember, element);
       element.setDefaultConstructor(constructor, compiler);
     }
     return element.computeType(compiler);
   }
 
   DartType visitNamedMixinApplication(NamedMixinApplication node) {
@@ skipping 91 matching lines @@
                                DartType mixinType) {
     ClassElement mixin = mixinType.element;
     mixin.ensureResolved(compiler);
 
     // Check for cycles in the mixin chain.
     ClassElement previous = mixinApplication;  // For better error messages.
     ClassElement current = mixin;
     while (current != null && current.isMixinApplication) {
       MixinApplicationElement currentMixinApplication = current;
       if (currentMixinApplication == mixinApplication) {
-        compiler.reportErrorCode(
+        compiler.reportError(
             mixinApplication, MessageKind.ILLEGAL_MIXIN_CYCLE,
             {'mixinName1': current.name, 'mixinName2': previous.name});
         // We have found a cycle in the mixin chain. Return null as
         // the mixin for this application to avoid getting into
         // infinite recursion when traversing members.
         return null;
       }
       previous = current;
       current = currentMixinApplication.mixin;
     }
     compiler.world.registerMixinUse(mixinApplication, mixin);
     return mixin;
   }
 
   DartType resolveType(TypeAnnotation node) {
     // TODO(johnniwinther): Report errors/warnings on resolution failures.
     return typeResolver.resolveTypeAnnotation(this, node);
   }
 
   DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
     DartType supertype = typeResolver.resolveTypeAnnotation(
-        this, superclass, onFailure: error);
+        this, superclass, onFailure: dualError);
     if (supertype != null) {
       if (identical(supertype.kind, TypeKind.MALFORMED_TYPE)) {
         // Error has already been reported.
         return null;
       } else if (!identical(supertype.kind, TypeKind.INTERFACE)) {
         // TODO(johnniwinther): Handle dynamic.
         error(superclass.typeName, MessageKind.CLASS_NAME_EXPECTED);
         return null;
       } else if (isBlackListed(supertype)) {
         error(superclass, MessageKind.CANNOT_EXTEND, {'type': supertype});
         return null;
       }
     }
     return supertype;
   }
 
   Link<DartType> resolveInterfaces(NodeList interfaces, Node superclass) {
     Link<DartType> result = const Link<DartType>();
     if (interfaces == null) return result;
     for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
       DartType interfaceType = typeResolver.resolveTypeAnnotation(
-          this, link.head, onFailure: error);
+          this, link.head, onFailure: dualError);
       if (interfaceType != null) {
         if (identical(interfaceType.kind, TypeKind.MALFORMED_TYPE)) {
           // Error has already been reported.
         } else if (!identical(interfaceType.kind, TypeKind.INTERFACE)) {
           // TODO(johnniwinther): Handle dynamic.
           TypeAnnotation typeAnnotation = link.head;
           error(typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED);
         } else {
           if (interfaceType == element.supertype) {
-            compiler.reportErrorCode(
+            compiler.reportError(
                 superclass,
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
                 {'type': interfaceType});
-            compiler.reportErrorCode(
+            compiler.reportError(
                 link.head,
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
                 {'type': interfaceType});
           }
           if (result.contains(interfaceType)) {
-            compiler.reportErrorCode(
+            compiler.reportError(
                 link.head,
                 MessageKind.DUPLICATE_IMPLEMENTS,
                 {'type': interfaceType});
           }
           result = result.prepend(interfaceType);
           if (isBlackListed(interfaceType)) {
             error(link.head, MessageKind.CANNOT_IMPLEMENT,
                   {'type': interfaceType});
           }
         }
@@ skipping 137 matching lines @@
     visitNodeList(node.interfaces);
   }
 
   void visitTypeAnnotation(TypeAnnotation node) {
     node.typeName.accept(this);
   }
 
   void visitIdentifier(Identifier node) {
     Element element = context.lookup(node.source);
     if (element == null) {
-      error(node, MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node});
+      error(node, MessageKind.CANNOT_RESOLVE_TYPE.error, {'typeName': node});
     } else if (!element.impliesType()) {
-      error(node, MessageKind.NOT_A_TYPE, {'node': node});
+      error(node, MessageKind.NOT_A_TYPE.error, {'node': node});
     } else {
       if (element.isClass()) {
         loadSupertype(element, node);
       } else {
-        compiler.reportErrorCode(node, MessageKind.CLASS_NAME_EXPECTED);
+        compiler.reportError(node, MessageKind.CLASS_NAME_EXPECTED);
       }
     }
   }
 
   void visitSend(Send node) {
     Identifier prefix = node.receiver.asIdentifier();
     if (prefix == null) {
       error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
       return;
     }
     Element element = context.lookup(prefix.source);
     if (element == null || !identical(element.kind, ElementKind.PREFIX)) {
       error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
       return;
     }
     PrefixElement prefixElement = element;
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType()) {
-      error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE,
+      error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE.error,
             {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }
 
 class VariableDefinitionsVisitor extends CommonResolverVisitor<SourceString> {
   VariableDefinitions definitions;
   ResolverVisitor resolver;
@@ skipping 180 matching lines @@
    */
   static FunctionSignature analyze(Compiler compiler,
                                    NodeList formalParameters,
                                    Node returnNode,
                                    Element element) {
     SignatureResolver visitor = new SignatureResolver(compiler, element);
     Link<Element> parameters = const Link<Element>();
     int requiredParameterCount = 0;
     if (formalParameters == null) {
       if (!element.isGetter()) {
-        compiler.reportErrorCode(element, MessageKind.MISSING_FORMALS);
+        compiler.reportError(element, MessageKind.MISSING_FORMALS);
       }
     } else {
       if (element.isGetter()) {
         if (!identical(formalParameters.getEndToken().next.stringValue,
                        // TODO(ahe): Remove the check for native keyword.
                        'native')) {
           if (compiler.rejectDeprecatedFeatures &&
               // TODO(ahe): Remove isPlatformLibrary check.
               !element.getLibrary().isPlatformLibrary) {
-            compiler.reportErrorCode(formalParameters,
+            compiler.reportError(formalParameters,
                                      MessageKind.EXTRA_FORMALS);
           } else {
             compiler.onDeprecatedFeature(formalParameters, 'getter parameters');
           }
         }
       }
       LinkBuilder<Element> parametersBuilder =
         visitor.analyzeNodes(formalParameters.nodes);
       requiredParameterCount  = parametersBuilder.length;
       parameters = parametersBuilder.toLink();
     }
     DartType returnType;
     if (element.isFactoryConstructor()) {
       returnType = element.getEnclosingClass().computeType(compiler);
       // Because there is no type annotation for the return type of
       // this element, we explicitly add one.
       if (compiler.enableTypeAssertions) {
         compiler.enqueuer.resolution.registerIsCheck(
             returnType, new TreeElementMapping(element));
       }
     } else {
       returnType = compiler.resolveReturnType(element, returnNode);
     }
 
     if (element.isSetter() && (requiredParameterCount != 1 ||
                                visitor.optionalParameterCount != 0)) {
       // If there are no formal parameters, we already reported an error above.
       if (formalParameters != null) {
-        compiler.reportErrorCode(formalParameters,
+        compiler.reportError(formalParameters,
                                  MessageKind.ILLEGAL_SETTER_FORMALS);
       }
     }
     if (element.isGetter() && (requiredParameterCount != 0
                                || visitor.optionalParameterCount != 0)) {
-      compiler.reportErrorCode(formalParameters, MessageKind.EXTRA_FORMALS);
+      compiler.reportError(formalParameters, MessageKind.EXTRA_FORMALS);
     }
     return new FunctionSignatureX(parameters,
                                   visitor.optionalParameters,
                                   requiredParameterCount,
                                   visitor.optionalParameterCount,
                                   visitor.optionalParametersAreNamed,
                                   returnType);
   }
 
   // TODO(ahe): This is temporary.
@@ skipping 15 matching lines @@
   bool inConstContext = false;
   DartType type;
 
   ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
   failOrReturnErroneousElement(Element enclosing, Node diagnosticNode,
-                               SourceString targetName, MessageKind kind,
+                               SourceString targetName, DualKind kind,
                                Map arguments) {
     if (kind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
       compiler.backend.registerThrowNoSuchMethod(resolver.mapping);
     } else {
       compiler.backend.registerThrowRuntimeError(resolver.mapping);
     }
     if (inConstContext) {
-      error(diagnosticNode, kind, arguments);
+      error(diagnosticNode, kind.error, arguments);
     } else {
-      ResolutionWarning warning  = new ResolutionWarning(kind, arguments);
+      ResolutionWarning warning  =
+          new ResolutionWarning(kind.warning, arguments);
       compiler.reportWarning(diagnosticNode, warning);
-      return new ErroneousElementX(kind, arguments, targetName, enclosing);
+      return new ErroneousElementX(
+          kind.error, arguments, targetName, enclosing);
     }
   }
 
   Selector createConstructorSelector(SourceString constructorName) {
     return constructorName == const SourceString('')
         ? new Selector.callDefaultConstructor(
             resolver.enclosingElement.getLibrary())
         : new Selector.callConstructor(
             constructorName,
             resolver.enclosingElement.getLibrary());
@@ skipping 67 matching lines @@
     if (name == null) internalError(node.selector, 'unexpected node');
 
     if (identical(e.kind, ElementKind.CLASS)) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
       return lookupConstructor(cls, name, name.source);
     } else if (identical(e.kind, ElementKind.PREFIX)) {
       PrefixElement prefix = e;
       e = prefix.lookupLocalMember(name.source);
       if (e == null) {
-        return failOrReturnErroneousElement(resolver.enclosingElement, name,
-                                            name.source,
-                                            MessageKind.CANNOT_RESOLVE,
-                                            {'name': name});
+        return failOrReturnErroneousElement(
+            resolver.enclosingElement, name,
+            name.source,
+            MessageKind.CANNOT_RESOLVE,
+            {'name': name});
       } else if (!identical(e.kind, ElementKind.CLASS)) {
-        error(node, MessageKind.NOT_A_TYPE, {'node': name});
+        error(node, MessageKind.NOT_A_TYPE.error, {'node': name});
       }
     } else {
       internalError(node.receiver, 'unexpected element $e');
     }
     return e;
   }
 
   Element visitIdentifier(Identifier node) {
     SourceString name = node.source;
     Element e = resolver.lookup(node, name);
     // TODO(johnniwinther): Change errors to warnings, cf. 11.11.1.
     if (e == null) {
       return failOrReturnErroneousElement(resolver.enclosingElement, node, name,
                                           MessageKind.CANNOT_RESOLVE,
                                           {'name': name});
     } else if (e.isErroneous()) {
       return e;
     } else if (identical(e.kind, ElementKind.TYPEDEF)) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
             {'typedefName': name});
     } else if (identical(e.kind, ElementKind.TYPE_VARIABLE)) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
             {'typeVariableName': name});
     } else if (!identical(e.kind, ElementKind.CLASS)
         && !identical(e.kind, ElementKind.PREFIX)) {
-      error(node, MessageKind.NOT_A_TYPE, {'node': name});
+      error(node, MessageKind.NOT_A_TYPE.error, {'node': name});
     }
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }