Report info messages together with their error, warning, or hint.

pkg/compiler/lib/src/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.
 
 library dart2js.resolution.members;
 
 import '../common/names.dart' show
     Selectors;
 import '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart' show
     RedirectingFactoryConstantConstructor;
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
+import '../diagnostics/diagnostic_listener.dart' show
+    DiagnosticMessage;
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../diagnostics/messages.dart' show
     MessageKind;
 import '../diagnostics/spannable.dart' show
     Spannable;
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show
     ConstructorElementX,
     ErroneousElementX,
@@ skipping 174 matching lines @@
     if (enclosingElement is FunctionElement) {
       FunctionElement function = enclosingElement;
       return function.asyncMarker;
     }
     return AsyncMarker.SYNC;
   }
 
   Element reportLookupErrorIfAny(Element result, Node node, String name) {
     if (!Elements.isUnresolved(result)) {
       if (!inInstanceContext && result.isInstanceMember) {
-        compiler.reportError(
+        compiler.reportErrorMessage(
             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.reportError(
-            node, ambiguous.messageKind, ambiguous.messageArguments);
-        ambiguous.diagnose(enclosingElement, compiler);
-        return new ErroneousElementX(ambiguous.messageKind,
-                                     ambiguous.messageArguments,
-                                     name, enclosingElement);
+        return reportAndCreateErroneousElement(
+              node,
+              name,
+              ambiguous.messageKind,
+              ambiguous.messageArguments,
+              infos: ambiguous.computeInfos(enclosingElement, compiler),
+              isError: true);
       }
     }
     return result;
   }
 
   // Create, or reuse an already created, target element for a statement.
   JumpTarget getOrDefineTarget(Node statement) {
     JumpTarget element = registry.getTargetDefinition(statement);
     if (element == null) {
       element = new JumpTargetX(statement,
@@ skipping 60 matching lines @@
         message: "No resolution result for $node."));
 
     return result;
   }
 
   ErroneousElement reportAndCreateErroneousElement(
       Node node,
       String name,
       MessageKind kind,
       Map arguments,
-      {bool isError: false}) {
+      {List<DiagnosticMessage> infos: const <DiagnosticMessage>[],
+       bool isError: false}) {
     if (isError) {
-      compiler.reportError(node, kind, arguments);
+      compiler.reportError(
+          compiler.createMessage(node, kind, arguments), infos);
     } else {
-      compiler.reportWarning(node, kind, arguments);
+      compiler.reportWarning(
+          compiler.createMessage(node, kind, arguments), infos);
     }
     // TODO(ahe): Use [allowedCategory] to synthesize a more precise subclass
     // of [ErroneousElementX]. For example, [ErroneousFieldElementX],
     // [ErroneousConstructorElementX], etc.
     return new ErroneousElementX(kind, arguments, name, enclosingElement);
   }
 
   /// Report a warning or error on an unresolved access in non-instance context.
   ///
   /// The [ErroneousElement] corresponding to the message is returned.
@@ skipping 28 matching lines @@
       kind = MessageKind.CANNOT_RESOLVE;
     }
     registry.registerThrowNoSuchMethod();
     return reportAndCreateErroneousElement(
         node, name, kind, arguments, isError: inInitializer);
   }
 
   ResolutionResult visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
-        error(node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
+        compiler.reportErrorMessage(
+            node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
       }
       return const NoneResult();
     } else if (node.isSuper()) {
       if (!inInstanceContext) {
-        error(node, MessageKind.NO_SUPER_IN_STATIC);
+        compiler.reportErrorMessage(
+            node, MessageKind.NO_SUPER_IN_STATIC);
       }
       if ((ElementCategory.SUPER & allowedCategory) == 0) {
-        error(node, MessageKind.INVALID_USE_OF_SUPER);
+        compiler.reportErrorMessage(
+            node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return const NoneResult();
     } else {
       String name = node.source;
       Element element = lookupInScope(compiler, node, scope, name);
       if (Elements.isUnresolved(element) && name == 'dynamic') {
         // TODO(johnniwinther): Remove this hack when we can return more complex
         // objects than [Element] from this method.
         element = compiler.typeClass;
         // Set the type to be `dynamic` to mark that this is a type literal.
@@ skipping 65 matching lines @@
       final ClassElement classElement = constructor.enclosingClass;
       return classElement.lookupConstructor(selector.name);
     }
     return null;
   }
 
   void setupFunction(FunctionExpression node, FunctionElement function) {
     Element enclosingElement = function.enclosingElement;
     if (node.modifiers.isStatic &&
         enclosingElement.kind != ElementKind.CLASS) {
-      compiler.reportError(node, MessageKind.ILLEGAL_STATIC);
+      compiler.reportErrorMessage(node, MessageKind.ILLEGAL_STATIC);
     }
 
     scope = new MethodScope(scope, function);
     // Put the parameters in scope.
     FunctionSignature functionParameters = function.functionSignature;
     Link<Node> parameterNodes = (node.parameters == null)
         ? const Link<Node>() : node.parameters.nodes;
     functionParameters.forEachParameter((ParameterElementX element) {
       // TODO(karlklose): should be a list of [FormalElement]s, but the actual
       // implementation uses [Element].
@@ skipping 35 matching lines @@
     if (inCheckContext) {
       functionParameters.forEachParameter((ParameterElement element) {
         registry.registerIsCheck(element.type);
       });
     }
   }
 
   ResolutionResult visitAssert(Assert node) {
     if (!compiler.enableAssertMessage) {
       if (node.hasMessage) {
-        compiler.reportError(node, MessageKind.EXPERIMENTAL_ASSERT_MESSAGE);
+        compiler.reportErrorMessage(
+            node, MessageKind.EXPERIMENTAL_ASSERT_MESSAGE);
       }
     }
     // TODO(sra): We could completely ignore the assert in production mode if we
     // didn't need it to be resolved for type checking.
     registry.registerAssert(node.hasMessage);
     visit(node.condition);
     visit(node.message);
     return const NoneResult();
   }
 
@@ skipping 73 matching lines @@
   /// [inFunctionDeclaration] is `true` when the current node is the immediate
   /// child of a function declaration.
   ///
   /// This is used to distinguish local function declarations from anonymous
   /// function expressions.
   ResolutionResult visitFunctionExpression(
       FunctionExpression node,
       {bool inFunctionDeclaration: false}) {
     bool doAddToScope = inFunctionDeclaration;
     if (!inFunctionDeclaration && node.name != null) {
-      compiler.reportError(
+      compiler.reportErrorMessage(
           node.name,
           MessageKind.NAMED_FUNCTION_EXPRESSION,
           {'name': node.name});
     }
     visit(node.returnType);
     String name;
     if (node.name == null) {
       name = "";
     } else {
       name = node.name.asIdentifier().source;
@@ skipping 144 matching lines @@
         if (seenNamedArguments.containsKey(source)) {
           reportDuplicateDefinition(
               source,
               argument,
               seenNamedArguments[source]);
           isValidAsConstant = false;
         } else {
           seenNamedArguments[source] = namedArgument;
         }
       } else if (!seenNamedArguments.isEmpty) {
-        error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
+        compiler.reportErrorMessage(
+            argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
         isValidAsConstant = false;
       }
       argumentCount++;
     }
     sendIsMemberAccess = oldSendIsMemberAccess;
     return new ArgumentsResult(
         new CallStructure(argumentCount, namedArguments),
         argumentResults,
         isValidAsConstant: isValidAsConstant);
   }
@@ skipping 464 matching lines @@
           case UnaryOperatorKind.COMPLEMENT:
             isValidConstant =
                 knownExpressionType == coreTypes.intType;
             break;
           case UnaryOperatorKind.NEGATE:
             isValidConstant =
                 knownExpressionType == coreTypes.intType ||
                 knownExpressionType == coreTypes.doubleType;
             break;
           case UnaryOperatorKind.NOT:
-            internalError(node,
+            compiler.internalError(node,
                 "Unexpected user definable unary operator: $operator");
         }
         if (isValidConstant) {
           // TODO(johnniwinther): Handle potentially invalid constant
           // expressions.
           ConstantExpression constant =
               new UnaryConstantExpression(operator, expressionConstant);
           registry.setConstant(node, constant);
           result = new ConstantResult(node, constant);
         }
@@ skipping 197 matching lines @@
             isValidConstant =
                 knownLeftType == coreTypes.intType &&
                 knownRightType == coreTypes.intType;
             break;
           case BinaryOperatorKind.INDEX:
             isValidConstant = false;
             break;
           case BinaryOperatorKind.LOGICAL_AND:
           case BinaryOperatorKind.LOGICAL_OR:
           case BinaryOperatorKind.IF_NULL:
-            internalError(node, "Unexpected binary operator '${operator}'.");
+            compiler.internalError(
+                node, "Unexpected binary operator '${operator}'.");
             break;
         }
         if (isValidConstant) {
           // TODO(johnniwinther): Handle potentially invalid constant
           // expressions.
           ConstantExpression constant = new BinaryConstantExpression(
               leftResult.constant,
               operator,
               rightResult.constant);
           registry.setConstant(node, constant);
@@ skipping 29 matching lines @@
         case BinaryOperatorKind.LTEQ:
         case BinaryOperatorKind.LT:
         case BinaryOperatorKind.AND:
         case BinaryOperatorKind.OR:
         case BinaryOperatorKind.XOR:
           sendStructure = new BinaryStructure(semantics, operator);
           break;
         case BinaryOperatorKind.LOGICAL_AND:
         case BinaryOperatorKind.LOGICAL_OR:
         case BinaryOperatorKind.IF_NULL:
-          internalError(node, "Unexpected binary operator '${operator}'.");
+          compiler.internalError(
+              node, "Unexpected binary operator '${operator}'.");
           break;
       }
       registry.registerSendStructure(node, sendStructure);
     }
     return result;
   }
 
   /// Handle an invocation of an expression, like `(){}()` or `(foo)()`.
   ResolutionResult handleExpressionInvoke(Send node) {
     assert(invariant(node, node.isCall,
@@ skipping 43 matching lines @@
             new UniverseSelector(selector, null));
       }
       registry.registerSendStructure(node,
           new InvokeStructure(accessSemantics, selector));
       // TODO(23998): Remove this when all information goes through
       // the [SendStructure].
       registry.setSelector(node, selector);
       return const NoneResult();
     } else {
       // TODO(johnniwinther): Handle get of `this` when it is a [Send] node.
-      internalError(node, "Unexpected node '$node'.");
+      compiler.internalError(
+          node, "Unexpected node '$node'.");
     }
     return const NoneResult();
   }
 
   /// Handle access of a super property, like `super.foo` and `super.foo()`.
   ResolutionResult handleSuperPropertyAccess(Send node, Name name) {
     Element target;
     Selector selector;
     CallStructure callStructure;
     if (node.isCall) {
@@ skipping 33 matching lines @@
               new UniverseSelector(selector, null));
           break;
         case AccessKind.SUPER_SETTER:
         case AccessKind.UNRESOLVED_SUPER:
           // NoSuchMethod registered in [computeSuperSemantics].
           break;
         case AccessKind.INVALID:
           // 'super' is not allowed.
           break;
         default:
-          internalError(node, "Unexpected super property access $semantics.");
+          compiler.internalError(
+              node, "Unexpected super property access $semantics.");
           break;
       }
       registry.registerSendStructure(node,
           isIncompatibleInvoke
               ? new IncompatibleInvokeStructure(semantics, selector)
               : new InvokeStructure(semantics, selector));
     } else {
       switch (semantics.kind) {
         case AccessKind.SUPER_METHOD:
           // TODO(johnniwinther): Method this should be registered as a
           // closurization.
           registry.registerStaticUse(semantics.element);
           break;
         case AccessKind.SUPER_FIELD:
         case AccessKind.SUPER_FINAL_FIELD:
         case AccessKind.SUPER_GETTER:
           registry.registerStaticUse(semantics.element);
           break;
         case AccessKind.SUPER_SETTER:
         case AccessKind.UNRESOLVED_SUPER:
           // NoSuchMethod registered in [computeSuperSemantics].
           break;
         case AccessKind.INVALID:
           // 'super' is not allowed.
           break;
         default:
-          internalError(node, "Unexpected super property access $semantics.");
+          compiler.internalError(
+              node, "Unexpected super property access $semantics.");
           break;
       }
       registry.registerSendStructure(node, new GetStructure(semantics));
     }
     target = semantics.element;
 
     // TODO(23998): Remove these when all information goes through
     // the [SendStructure].
     registry.useElement(node, target);
     registry.setSelector(node, selector);
@@ skipping 825 matching lines @@
   /// Handle access to an ambiguous element, that is, a name imported twice.
   ResolutionResult handleAmbiguousSend(
       Send node,
       Name name,
       AmbiguousElement element) {
 
     ErroneousElement error = reportAndCreateErroneousElement(
         node,
         name.text,
         element.messageKind,
-        element.messageArguments);
-    element.diagnose(enclosingElement, compiler);
+        element.messageArguments,
+        infos: element.computeInfos(enclosingElement, compiler));
     registry.registerThrowNoSuchMethod();
 
     // TODO(johnniwinther): Support ambiguous access as an [AccessSemantics].
     AccessSemantics semantics = new StaticAccess.unresolved(error);
     return handleErroneousAccess(node, name, semantics);
   }
 
   /// Handle update to an ambiguous element, that is, a name imported twice.
   ResolutionResult handleAmbiguousUpdate(
       SendSet node,
       Name name,
       AmbiguousElement element) {
 
     ErroneousElement error = reportAndCreateErroneousElement(
         node,
         name.text,
         element.messageKind,
-        element.messageArguments);
-    element.diagnose(enclosingElement, compiler);
+        element.messageArguments,
+        infos: element.computeInfos(enclosingElement, compiler));
     registry.registerThrowNoSuchMethod();
 
     // TODO(johnniwinther): Support ambiguous access as an [AccessSemantics].
     AccessSemantics accessSemantics = new StaticAccess.unresolved(error);
     return handleUpdate(node, name, accessSemantics);
   }
 
   /// Report access of an instance [member] from a non-instance context.
   AccessSemantics reportStaticInstanceAccess(Send node, Name name) {
     ErroneousElement error = reportAndCreateErroneousElement(
@@ skipping 29 matching lines @@
           break;
         case AccessKind.PARAMETER:
         case AccessKind.FINAL_PARAMETER:
         case AccessKind.LOCAL_VARIABLE:
         case AccessKind.FINAL_LOCAL_VARIABLE:
           selector = callStructure.callSelector;
           registry.registerDynamicInvocation(
               new UniverseSelector(selector, null));
           break;
         default:
-          internalError(node,
+          compiler.internalError(node,
               "Unexpected local access $semantics.");
           break;
       }
       registry.registerSendStructure(node,
           isIncompatibleInvoke
               ? new IncompatibleInvokeStructure(semantics, selector)
               : new InvokeStructure(semantics, selector));
     } else {
       switch (semantics.kind) {
         case AccessKind.LOCAL_VARIABLE:
@@ skipping 25 matching lines @@
           if (element.isConst) {
             result = new ConstantResult(
                 node,
                 new VariableConstantExpression(element),
                 element: element);
           } else {
             result = new ElementResult(element);
           }
           break;
         default:
-          internalError(node,
+          compiler.internalError(node,
               "Unexpected local access $semantics.");
           break;
       }
       selector = new Selector.getter(name);
       registry.registerSendStructure(node, new GetStructure(semantics));
     }
 
     // TODO(23998): Remove these when all information goes through
     // the [SendStructure].
     registry.useElement(node, element);
@@ skipping 69 matching lines @@
     } else {
       member = element;
     }
     // TODO(johnniwinther): Needed to provoke a parsing and with it discovery
     // of parse errors to make [element] erroneous. Fix this!
     member.computeType(compiler);
 
 
     if (member == compiler.mirrorSystemGetNameFunction &&
         !compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
-      compiler.reportHint(
+      compiler.reportHintMessage(
           node.selector, MessageKind.STATIC_FUNCTION_BLOAT,
           {'class': compiler.mirrorSystemClass.name,
            'name': compiler.mirrorSystemGetNameFunction.name});
     }
 
     Selector selector;
     AccessSemantics semantics =
         computeStaticOrTopLevelAccessSemantics(node, member);
     if (node.isCall) {
       ArgumentsResult argumentsResult =
@@ skipping 37 matching lines @@
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
           registry.registerThrowNoSuchMethod();
           member = reportAndCreateErroneousElement(
               node.selector, name.text,
               MessageKind.CANNOT_RESOLVE_GETTER, const {});
           break;
         default:
-          internalError(node,
+          compiler.internalError(node,
               "Unexpected statically resolved access $semantics.");
           break;
       }
       registry.registerSendStructure(node,
           isIncompatibleInvoke
               ? new IncompatibleInvokeStructure(semantics, selector)
               : new InvokeStructure(semantics, selector));
     } else {
       selector = new Selector.getter(name);
       switch (semantics.kind) {
@@ skipping 14 matching lines @@
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
           registry.registerThrowNoSuchMethod();
           member = reportAndCreateErroneousElement(
               node.selector, name.text,
               MessageKind.CANNOT_RESOLVE_GETTER, const {});
           break;
         default:
-          internalError(node,
+          compiler.internalError(node,
               "Unexpected statically resolved access $semantics.");
           break;
       }
       registry.registerSendStructure(node, new GetStructure(semantics));
       if (member.isConst) {
         FieldElement field = member;
         result = new ConstantResult(
             node, new VariableConstantExpression(field), element: field);
       } else {
         result = new ElementResult(member);
@@ skipping 142 matching lines @@
       return handleTypedefTypeLiteralAccess(node, name, element);
     } else if (element.isTypeVariable) {
       return handleTypeVariableTypeLiteralAccess(node, name, element);
     } else if (element.isPrefix) {
       return handleLibraryPrefix(node, name, element);
     } else if (element.isLocal) {
       return handleLocalAccess(node, name, element);
     } else if (element.isStatic || element.isTopLevel) {
       return handleStaticOrTopLevelAccess(node, name, element);
     }
-    return internalError(node, "Unexpected resolved send: $element");
+    return compiler.internalError(node, "Unexpected resolved send: $element");
   }
 
   /// Handle update to resolved [element].
   ResolutionResult handleResolvedSendSet(
       SendSet node, Name name, Element element) {
     if (element.isAmbiguous) {
       return handleAmbiguousUpdate(node, name, element);
     }
     if (element.isErroneous) {
       // This handles elements with parser errors.
@@ skipping 17 matching lines @@
       // `C = b`, `C++`, or 'C += b` where 'F' is a typedef.
       return handleTypedefTypeLiteralUpdate(node, name, element);
     } else if (element.isTypeVariable) {
       // `T = b`, `T++`, or 'T += b` where 'T' is a type variable.
       return handleTypeVariableTypeLiteralUpdate(node, name, element);
     } else if (element.isLocal) {
       return handleLocalUpdate(node, name, element);
     } else if (element.isStatic || element.isTopLevel) {
       return handleStaticOrTopLevelUpdate(node, name, element);
     }
-    return internalError(node, "Unexpected resolved send: $element");
+    return compiler.internalError(node, "Unexpected resolved send: $element");
   }
 
   /// Handle an unqualified [Send], that is where the `node.receiver` is null,
   /// like `a`, `a()`, `this()`, `assert()`, and `(){}()`.
   ResolutionResult handleUnqualifiedSend(Send node) {
     Identifier selector = node.selector.asIdentifier();
     if (selector == null) {
       // `(){}()` and `(foo)()`.
       return handleExpressionInvoke(node);
     }
@@ skipping 310 matching lines @@
       AssignmentOperator operator = AssignmentOperator.parse(operatorText);
       if (operator.kind == AssignmentOperatorKind.ASSIGN) {
         // `super.a = b`.
         if (semantics == null) {
           semantics =
               computeSuperAccessSemanticsForSelector(
                   node, setterSelector, alternateName: name);
           registry.registerStaticInvocation(semantics.setter);
           switch (semantics.kind) {
             case AccessKind.SUPER_FINAL_FIELD:
-              compiler.reportWarning(
+              compiler.reportWarningMessage(
                   node,
                   MessageKind.ASSIGNING_FINAL_FIELD_IN_SUPER,
                   {'name': name,
                    'superclassName': semantics.setter.enclosingClass.name});
               // TODO(johnniwinther): This shouldn't be needed.
               registry.registerDynamicInvocation(
                   new UniverseSelector(setterSelector, null));
               registry.registerSuperNoSuchMethod();
               break;
             case AccessKind.SUPER_METHOD:
-              compiler.reportWarning(
+              compiler.reportWarningMessage(
                   node, MessageKind.ASSIGNING_METHOD_IN_SUPER,
                   {'name': name,
                    'superclassName': semantics.setter.enclosingClass.name});
               // TODO(johnniwinther): This shouldn't be needed.
               registry.registerDynamicInvocation(
                   new UniverseSelector(setterSelector, null));
               registry.registerSuperNoSuchMethod();
               break;
             default:
               registry.registerStaticInvocation(semantics.setter);
@@ skipping 181 matching lines @@
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ConstantResult visitLiteralSymbol(LiteralSymbol node) {
     registry.registerInstantiatedClass(compiler.symbolClass);
     registry.registerStaticUse(compiler.symbolConstructor.declaration);
     String name = node.slowNameString;
     registry.registerConstSymbol(name);
     if (!validateSymbol(node, name, reportError: false)) {
-      compiler.reportError(node,
+      compiler.reportErrorMessage(
+          node,
           MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
           {'value': name});
     }
     analyzeConstantDeferred(node);
     ConstantExpression constant = new SymbolConstantExpression(name);
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
   ResolutionResult visitStringJuxtaposition(StringJuxtaposition node) {
@@ skipping 11 matching lines @@
 
   ResolutionResult visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       visit(link.head);
     }
     return const NoneResult();
   }
 
   ResolutionResult visitRethrow(Rethrow node) {
     if (!inCatchBlock) {
-      error(node, MessageKind.THROW_WITHOUT_EXPRESSION);
+      compiler.reportErrorMessage(
+          node, MessageKind.THROW_WITHOUT_EXPRESSION);
     }
     return const NoneResult();
   }
 
   ResolutionResult visitReturn(Return node) {
     Node expression = node.expression;
     if (expression != null) {
       if (enclosingElement.isGenerativeConstructor) {
         // It is a compile-time error if a return statement of the form
         // `return e;` appears in a generative constructor.  (Dart Language
         // Specification 13.12.)
-        compiler.reportError(expression,
-                             MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR);
+        compiler.reportErrorMessage(
+            expression,
+            MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR);
       } else if (!node.isArrowBody && currentAsyncMarker.isYielding) {
-        compiler.reportError(
+        compiler.reportErrorMessage(
             node,
             MessageKind.RETURN_IN_GENERATOR,
             {'modifier': currentAsyncMarker});
       }
     }
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitYield(Yield node) {
     compiler.streamClass.ensureResolved(compiler);
     compiler.iterableClass.ensureResolved(compiler);
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     final isSymbolConstructor = enclosingElement == compiler.symbolConstructor;
     if (!enclosingElement.isFactoryConstructor) {
-      compiler.reportError(
+      compiler.reportErrorMessage(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
-      compiler.reportHint(
+      compiler.reportHintMessage(
           enclosingElement, MessageKind.MISSING_FACTORY_KEYWORD);
     }
     ConstructorElementX constructor = enclosingElement;
     bool isConstConstructor = constructor.isConst;
     bool isValidAsConstant = isConstConstructor;
     ConstructorElement redirectionTarget = resolveRedirectingFactory(
         node, inConstContext: isConstConstructor).element;
     constructor.immediateRedirectionTarget = redirectionTarget;
 
     Node constructorReference = node.constructorReference;
     if (constructorReference is Send) {
       constructor.redirectionDeferredPrefix =
           compiler.deferredLoadTask.deferredPrefixElement(constructorReference,
                                                           registry.mapping);
     }
 
     registry.setRedirectingTargetConstructor(node, redirectionTarget);
     if (Elements.isUnresolved(redirectionTarget)) {
       registry.registerThrowNoSuchMethod();
       return const NoneResult();
     } else {
       if (isConstConstructor &&
           !redirectionTarget.isConst) {
-        compiler.reportError(node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
+        compiler.reportErrorMessage(
+            node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
         isValidAsConstant = false;
       }
       if (redirectionTarget == constructor) {
-        compiler.reportError(node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
+        compiler.reportErrorMessage(
+            node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
         // TODO(johnniwinther): Create constant constructor for this case and
         // let evaluation detect the cyclicity.
         isValidAsConstant = false;
       }
     }
 
     // Check that the target constructor is type compatible with the
     // redirecting constructor.
     ClassElement targetClass = redirectionTarget.enclosingClass;
     InterfaceType type = registry.getType(node);
     FunctionType targetType = redirectionTarget.computeType(compiler)
         .subst(type.typeArguments, targetClass.typeVariables);
     FunctionType constructorType = constructor.computeType(compiler);
     bool isSubtype = compiler.types.isSubtype(targetType, constructorType);
     if (!isSubtype) {
-      warning(node, MessageKind.NOT_ASSIGNABLE,
-              {'fromType': targetType, 'toType': constructorType});
+      compiler.reportWarningMessage(
+          node,
+          MessageKind.NOT_ASSIGNABLE,
+          {'fromType': targetType, 'toType': constructorType});
       // TODO(johnniwinther): Handle this (potentially) erroneous case.
       isValidAsConstant = false;
     }
 
     redirectionTarget.computeType(compiler);
     FunctionSignature targetSignature = redirectionTarget.functionSignature;
     constructor.computeType(compiler);
     FunctionSignature constructorSignature = constructor.functionSignature;
     if (!targetSignature.isCompatibleWith(constructorSignature)) {
       assert(!isSubtype);
@@ skipping 69 matching lines @@
       Node modifierNode;
       for (Link<Node> nodes = modifiers.nodes.nodes;
            !nodes.isEmpty;
            nodes = nodes.tail) {
         if (modifier == nodes.head.asIdentifier().source) {
           modifierNode = nodes.head;
           break;
         }
       }
       assert(modifierNode != null);
-      compiler.reportError(modifierNode, MessageKind.EXTRANEOUS_MODIFIER,
+      compiler.reportErrorMessage(
+          modifierNode, MessageKind.EXTRANEOUS_MODIFIER,
           {'modifier': modifier});
     }
     if (modifiers.isFinal && (modifiers.isConst || modifiers.isVar)) {
       reportExtraModifier('final');
     }
     if (modifiers.isVar && (modifiers.isConst || node.type != null)) {
       reportExtraModifier('var');
     }
     if (enclosingElement.isFunction) {
       if (modifiers.isAbstract) {
@@ skipping 55 matching lines @@
     constructor.computeType(compiler);
     if (!callSelector.applies(constructor, compiler.world)) {
       registry.registerThrowNoSuchMethod();
     }
 
     // [constructor] might be the implementation element
     // and only declaration elements may be registered.
     registry.registerStaticUse(constructor.declaration);
     ClassElement cls = constructor.enclosingClass;
     if (cls.isEnumClass && currentClass != cls) {
-      compiler.reportError(node,
-                           MessageKind.CANNOT_INSTANTIATE_ENUM,
-                           {'enumName': cls.name});
+      compiler.reportErrorMessage(
+          node,
+          MessageKind.CANNOT_INSTANTIATE_ENUM,
+          {'enumName': cls.name});
       isValidAsConstant = false;
     }
 
     InterfaceType type = registry.getType(node);
     if (node.isConst && type.containsTypeVariables) {
-      compiler.reportError(node.send.selector,
-                           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
+      compiler.reportErrorMessage(
+          node.send.selector,
+          MessageKind.TYPE_VARIABLE_IN_CONSTANT);
       isValidAsConstant = false;
     }
     // TODO(johniwinther): Avoid registration of `type` in face of redirecting
     // factory constructors.
     registry.registerInstantiatedType(type);
     if (constructor.isGenerativeConstructor && cls.isAbstract) {
       isValidAsConstant = false;
     }
 
     if (isSymbolConstructor) {
       if (node.isConst) {
         Node argumentNode = node.send.arguments.head;
         ConstantExpression constant =
             compiler.resolver.constantCompiler.compileNode(
                 argumentNode, registry.mapping);
         ConstantValue name = compiler.constants.getConstantValue(constant);
         if (!name.isString) {
           DartType type = name.getType(coreTypes);
-          compiler.reportError(argumentNode, MessageKind.STRING_EXPECTED,
-                                   {'type': type});
+          compiler.reportErrorMessage(
+              argumentNode,
+              MessageKind.STRING_EXPECTED,
+              {'type': type});
         } else {
           StringConstantValue stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             registry.registerConstSymbol(nameString);
           }
         }
       } else {
         if (!compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(
                 enclosingElement)) {
-          compiler.reportHint(
+          compiler.reportHintMessage(
               node.newToken, MessageKind.NON_CONST_BLOAT,
               {'name': compiler.symbolClass.name});
         }
         registry.registerNewSymbol();
       }
     } else if (isMirrorsUsedConstant) {
       compiler.mirrorUsageAnalyzerTask.validate(node, registry.mapping);
     }
     if (node.isConst) {
       analyzeConstantDeferred(node);
@@ skipping 33 matching lines @@
   void checkConstMapKeysDontOverrideEquals(Spannable spannable,
                                            MapConstantValue map) {
     for (ConstantValue key in map.keys) {
       if (!key.isObject) continue;
       ObjectConstantValue objectConstant = key;
       DartType keyType = objectConstant.type;
       ClassElement cls = keyType.element;
       if (cls == compiler.stringClass) continue;
       Element equals = cls.lookupMember('==');
       if (equals.enclosingClass != compiler.objectClass) {
-        compiler.reportError(spannable,
-                             MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
-                             {'type': keyType});
+        compiler.reportErrorMessage(
+            spannable,
+            MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
+            {'type': keyType});
       }
     }
   }
 
   void analyzeConstant(Node node, {enforceConst: true}) {
     ConstantExpression constant =
         compiler.resolver.constantCompiler.compileNode(
             node, registry.mapping, enforceConst: enforceConst);
 
     if (constant == null) {
       assert(invariant(node, compiler.compilationFailed));
       return;
     }
 
     ConstantValue value = compiler.constants.getConstantValue(constant);
     if (value.isMap) {
       checkConstMapKeysDontOverrideEquals(node, value);
     }
 
     // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
     // a class that will be instantiated outside the program by attaching a
     // native class dispatch record referencing the interceptor.
     if (argumentsToJsInterceptorConstant != null &&
         argumentsToJsInterceptorConstant.contains(node)) {
       if (value.isType) {
         TypeConstantValue typeConstant = value;
         if (typeConstant.representedType is InterfaceType) {
           registry.registerInstantiatedType(typeConstant.representedType);
         } else {
-          compiler.reportError(node,
+          compiler.reportErrorMessage(
+              node,
               MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
         }
       } else {
-        compiler.reportError(node,
+        compiler.reportErrorMessage(
+            node,
             MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
       }
     }
   }
 
   void analyzeConstantDeferred(Node node, {bool enforceConst: true}) {
     addDeferredAction(enclosingElement, () {
       analyzeConstant(node, enforceConst: enforceConst);
     });
   }
 
   bool validateSymbol(Node node, String name, {bool reportError: true}) {
     if (name.isEmpty) return true;
     if (name.startsWith('_')) {
       if (reportError) {
-        compiler.reportError(node, MessageKind.PRIVATE_IDENTIFIER,
-                             {'value': name});
+        compiler.reportErrorMessage(
+            node, MessageKind.PRIVATE_IDENTIFIER, {'value': name});
       }
       return false;
     }
     if (!symbolValidationPattern.hasMatch(name)) {
       if (reportError) {
-        compiler.reportError(node, MessageKind.INVALID_SYMBOL,
-                             {'value': name});
+        compiler.reportErrorMessage(
+            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.
@@ skipping 25 matching lines @@
   ResolutionResult visitLiteralList(LiteralList node) {
     bool isValidAsConstant = true;
     sendIsMemberAccess = false;
 
     NodeList arguments = node.typeArguments;
     DartType typeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
         // The syntax [: <>[] :] is not allowed.
-        error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
+        compiler.reportErrorMessage(
+            arguments, MessageKind.MISSING_TYPE_ARGUMENT);
         isValidAsConstant = false;
       } else {
         typeArgument = resolveTypeAnnotation(nodes.head);
         for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
-          warning(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
+          compiler.reportWarningMessage(
+              nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
           resolveTypeAnnotation(nodes.head);
         }
       }
     }
     DartType listType;
     if (typeArgument != null) {
       if (node.isConst && typeArgument.containsTypeVariables) {
-        compiler.reportError(arguments.nodes.head,
+        compiler.reportErrorMessage(
+            arguments.nodes.head,
             MessageKind.TYPE_VARIABLE_IN_CONSTANT);
         isValidAsConstant = false;
       }
       listType = coreTypes.listType(typeArgument);
     } else {
       listType = coreTypes.listType();
     }
     registry.setType(node, listType);
     registry.registerInstantiatedType(listType);
     registry.registerRequiredType(listType, enclosingElement);
@@ skipping 73 matching lines @@
       return new ConstantResult(node, constant);
     }
     return const NoneResult();
   }
 
   ResolutionResult visitBreakStatement(BreakStatement node) {
     JumpTarget target;
     if (node.target == null) {
       target = statementScope.currentBreakTarget();
       if (target == null) {
-        error(node, MessageKind.NO_BREAK_TARGET);
+        compiler.reportErrorMessage(
+            node, MessageKind.NO_BREAK_TARGET);
         return const NoneResult();
       }
       target.isBreakTarget = true;
     } else {
       String labelName = node.target.source;
       LabelDefinition label = statementScope.lookupLabel(labelName);
       if (label == null) {
-        error(node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
+        compiler.reportErrorMessage(
+            node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
         return const NoneResult();
       }
       target = label.target;
       if (!target.statement.isValidBreakTarget()) {
-        error(node.target, MessageKind.INVALID_BREAK);
+        compiler.reportErrorMessage(
+            node.target, MessageKind.INVALID_BREAK);
         return const NoneResult();
       }
       label.setBreakTarget();
       registry.useLabel(node, label);
     }
     registry.registerTargetOf(node, target);
     return const NoneResult();
   }
 
   ResolutionResult visitContinueStatement(ContinueStatement node) {
     JumpTarget target;
     if (node.target == null) {
       target = statementScope.currentContinueTarget();
       if (target == null) {
-        error(node, MessageKind.NO_CONTINUE_TARGET);
+        compiler.reportErrorMessage(
+            node, MessageKind.NO_CONTINUE_TARGET);
         return const NoneResult();
       }
       target.isContinueTarget = true;
     } else {
       String labelName = node.target.source;
       LabelDefinition label = statementScope.lookupLabel(labelName);
       if (label == null) {
-        error(node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
+        compiler.reportErrorMessage(
+            node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
         return const NoneResult();
       }
       target = label.target;
       if (!target.statement.isValidContinueTarget()) {
-        error(node.target, MessageKind.INVALID_CONTINUE);
+        compiler.reportErrorMessage(
+            node.target, MessageKind.INVALID_CONTINUE);
       }
       label.setContinueTarget();
       registry.useLabel(node, label);
     }
     registry.registerTargetOf(node, target);
     return const NoneResult();
   }
 
   registerImplicitInvocation(Selector selector) {
     registry.registerDynamicInvocation(new UniverseSelector(selector, null));
@@ skipping 49 matching lines @@
 
     Send send = declaration.asSend();
     VariableDefinitions variableDefinitions =
         declaration.asVariableDefinitions();
     Element loopVariable;
     Selector loopVariableSelector;
     if (send != null) {
       loopVariable = registry.getDefinition(send);
       Identifier identifier = send.selector.asIdentifier();
       if (identifier == null) {
-        compiler.reportError(send.selector, MessageKind.INVALID_FOR_IN);
+        compiler.reportErrorMessage(
+            send.selector, MessageKind.INVALID_FOR_IN);
       } else {
         loopVariableSelector = new Selector.setter(
             new Name(identifier.source, library));
       }
       if (send.receiver != null) {
-        compiler.reportError(send.receiver, MessageKind.INVALID_FOR_IN);
+        compiler.reportErrorMessage(
+            send.receiver, MessageKind.INVALID_FOR_IN);
       }
     } else if (variableDefinitions != null) {
       Link<Node> nodes = variableDefinitions.definitions.nodes;
       if (!nodes.tail.isEmpty) {
-        compiler.reportError(nodes.tail.head, MessageKind.INVALID_FOR_IN);
+        compiler.reportErrorMessage(
+            nodes.tail.head, MessageKind.INVALID_FOR_IN);
       }
       Node first = nodes.head;
       Identifier identifier = first.asIdentifier();
       if (identifier == null) {
-        compiler.reportError(first, MessageKind.INVALID_FOR_IN);
+        compiler.reportErrorMessage(
+            first, MessageKind.INVALID_FOR_IN);
       } else {
         loopVariableSelector = new Selector.setter(
             new Name(identifier.source, library));
         loopVariable = registry.getDefinition(identifier);
       }
     } else {
-      compiler.reportError(declaration, MessageKind.INVALID_FOR_IN);
+      compiler.reportErrorMessage(
+          declaration, MessageKind.INVALID_FOR_IN);
     }
     if (loopVariableSelector != null) {
       registry.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 15 matching lines @@
       LabelDefinition element = targetElement.addLabel(label, labelName);
       labelElements[labelName] = element;
     }
     statementScope.enterLabelScope(labelElements);
     visit(node.statement);
     statementScope.exitLabelScope();
     labelElements.forEach((String labelName, LabelDefinition element) {
       if (element.isTarget) {
         registry.defineLabel(element.label, element);
       } else {
-        warning(element.label, MessageKind.UNUSED_LABEL,
-                {'labelName': labelName});
+        compiler.reportWarningMessage(
+            element.label,
+            MessageKind.UNUSED_LABEL,
+            {'labelName': labelName});
       }
     });
     if (!targetElement.isTarget) {
       registry.undefineTarget(body);
     }
     return const NoneResult();
   }
 
   ResolutionResult visitLiteralMap(LiteralMap node) {
     bool isValidAsConstant = true;
     sendIsMemberAccess = false;
 
     NodeList arguments = node.typeArguments;
     DartType keyTypeArgument;
     DartType valueTypeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
         // The syntax [: <>{} :] is not allowed.
-        error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
+        compiler.reportErrorMessage(
+            arguments, MessageKind.MISSING_TYPE_ARGUMENT);
         isValidAsConstant = false;
       } else {
         keyTypeArgument = resolveTypeAnnotation(nodes.head);
         nodes = nodes.tail;
         if (nodes.isEmpty) {
-          warning(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
+          compiler.reportWarningMessage(
+              arguments, MessageKind.MISSING_TYPE_ARGUMENT);
         } else {
           valueTypeArgument = resolveTypeAnnotation(nodes.head);
           for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
-            warning(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
+            compiler.reportWarningMessage(
+                nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
             resolveTypeAnnotation(nodes.head);
           }
         }
       }
     }
     DartType mapType;
     if (valueTypeArgument != null) {
       mapType = coreTypes.mapType(keyTypeArgument, valueTypeArgument);
     } else {
       mapType = coreTypes.mapType();
     }
     if (node.isConst && mapType.containsTypeVariables) {
-      compiler.reportError(arguments,
+      compiler.reportErrorMessage(
+          arguments,
           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
       isValidAsConstant = false;
     }
     registry.registerMapLiteral(node, mapType, node.isConst);
     registry.registerRequiredType(mapType, enclosingElement);
     if (node.isConst) {
 
       List<ConstantExpression> keyExpressions = <ConstantExpression>[];
       List<ConstantExpression> valueExpressions = <ConstantExpression>[];
       inConstantContext(() {
@@ skipping 48 matching lines @@
 
   bool overridesEquals(DartType type) {
     ClassElement cls = type.element;
     Element equals = cls.lookupMember('==');
     return equals.enclosingClass != compiler.objectClass;
   }
 
   void checkCaseExpressions(SwitchStatement node) {
     CaseMatch firstCase = null;
     DartType firstCaseType = null;
-    bool hasReportedProblem = false;
+    DiagnosticMessage error;
+    List<DiagnosticMessage> infos = <DiagnosticMessage>[];
 
     for (Link<Node> cases = node.cases.nodes;
          !cases.isEmpty;
          cases = cases.tail) {
       SwitchCase switchCase = cases.head;
 
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch == null) continue;
 
         // Analyze the constant.
         ConstantExpression constant =
             registry.getConstant(caseMatch.expression);
         assert(invariant(node, constant != null,
             message: 'No constant computed for $node'));
 
         ConstantValue value = compiler.constants.getConstantValue(constant);
         DartType caseType = typeOfConstant(value);
 
         if (firstCaseType == null) {
           firstCase = caseMatch;
           firstCaseType = caseType;
 
           // We only report the bad type on the first class element. All others
           // get a "type differs" error.
           if (caseType.element == compiler.doubleClass) {
-            compiler.reportError(node,
-                                 MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
-                                 {'type': "double"});
+            compiler.reportErrorMessage(
+                node,
+                MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
+                {'type': "double"});
           } else if (caseType.element == compiler.functionClass) {
-            compiler.reportError(node, MessageKind.SWITCH_CASE_FORBIDDEN,
-                                 {'type': "Function"});
+            compiler.reportErrorMessage(
+                node, MessageKind.SWITCH_CASE_FORBIDDEN,
+                {'type': "Function"});
           } else if (value.isObject && overridesEquals(caseType)) {
-            compiler.reportError(firstCase.expression,
+            compiler.reportErrorMessage(
+                firstCase.expression,
                 MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
                 {'type': caseType});
           }
         } else {
           if (caseType != firstCaseType) {
-            if (!hasReportedProblem) {
-              compiler.reportError(
+            if (error == null) {
+              error = compiler.createMessage(
                   node,
                   MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL,
                   {'type': firstCaseType});
-              compiler.reportInfo(
+              infos.add(compiler.createMessage(
                   firstCase.expression,
                   MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
-                  {'type': firstCaseType});
-              hasReportedProblem = true;
+                  {'type': firstCaseType}));
             }
-            compiler.reportInfo(
+            infos.add(compiler.createMessage(
                 caseMatch.expression,
                 MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
-                {'type': caseType});
+                {'type': caseType}));
           }
         }
       }
     }
+    if (error != null) {
+      compiler.reportError(error, infos);
+    }
   }
 
   ResolutionResult visitSwitchStatement(SwitchStatement node) {
     node.expression.accept(this);
 
     JumpTarget breakElement = getOrDefineTarget(node);
     Map<String, LabelDefinition> continueLabels = <String, LabelDefinition>{};
     Link<Node> cases = node.cases.nodes;
     while (!cases.isEmpty) {
       SwitchCase switchCase = cases.head;
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch != null) {
           analyzeConstantDeferred(caseMatch.expression);
           continue;
         }
         Label label = labelOrCase;
         String labelName = label.labelName;
 
         LabelDefinition existingElement = continueLabels[labelName];
         if (existingElement != null) {
           // It's an error if the same label occurs twice in the same switch.
           compiler.reportError(
-              label,
-              MessageKind.DUPLICATE_LABEL, {'labelName': labelName});
-          compiler.reportInfo(
-              existingElement.label,
-              MessageKind.EXISTING_LABEL, {'labelName': labelName});
+              compiler.createMessage(
+                  label,
+                  MessageKind.DUPLICATE_LABEL,
+                  {'labelName': labelName}),
+              <DiagnosticMessage>[
+                  compiler.createMessage(
+                    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) {
             compiler.reportWarning(
-                label,
-                MessageKind.DUPLICATE_LABEL, {'labelName': labelName});
-            compiler.reportInfo(
-                existingElement.label,
-                MessageKind.EXISTING_LABEL, {'labelName': labelName});
+                compiler.createMessage(
+                    label,
+                    MessageKind.DUPLICATE_LABEL,
+                    {'labelName': labelName}),
+                <DiagnosticMessage>[
+                    compiler.createMessage(
+                        existingElement.label,
+                        MessageKind.EXISTING_LABEL,
+                        {'labelName': labelName}),
+                ]);
           }
         }
 
         JumpTarget targetElement = getOrDefineTarget(switchCase);
         LabelDefinition labelElement = targetElement.addLabel(label, labelName);
         registry.defineLabel(label, labelElement);
         continueLabels[labelName] = labelElement;
       }
       cases = cases.tail;
       // Test that only the last case, if any, is a default case.
       if (switchCase.defaultKeyword != null && !cases.isEmpty) {
-        error(switchCase, MessageKind.INVALID_CASE_DEFAULT);
+        compiler.reportErrorMessage(
+            switchCase, MessageKind.INVALID_CASE_DEFAULT);
       }
     }
 
     addDeferredAction(enclosingElement, () {
       checkCaseExpressions(node);
     });
 
     statementScope.enterSwitch(breakElement, continueLabels);
     node.cases.accept(this);
     statementScope.exitSwitch();
@@ skipping 24 matching lines @@
     return const NoneResult();
   }
 
   ResolutionResult visitTryStatement(TryStatement node) {
     // TODO(karlklose): also track the information about mutated variables,
     // catch, and finally-block.
     registry.registerTryStatement();
 
     visit(node.tryBlock);
     if (node.catchBlocks.isEmpty && node.finallyBlock == null) {
-      error(node.getEndToken().next, MessageKind.NO_CATCH_NOR_FINALLY);
+      compiler.reportErrorMessage(
+          node.getEndToken().next, MessageKind.NO_CATCH_NOR_FINALLY);
     }
     visit(node.catchBlocks);
     visit(node.finallyBlock);
     return const NoneResult();
   }
 
   ResolutionResult visitCatchBlock(CatchBlock node) {
     registry.registerCatchStatement();
     // Check that if catch part is present, then
     // it has one or two formal parameters.
     VariableDefinitions exceptionDefinition;
     VariableDefinitions stackTraceDefinition;
     if (node.formals != null) {
       Link<Node> formalsToProcess = node.formals.nodes;
       if (formalsToProcess.isEmpty) {
-        error(node, MessageKind.EMPTY_CATCH_DECLARATION);
+        compiler.reportErrorMessage(
+            node, MessageKind.EMPTY_CATCH_DECLARATION);
       } else {
         exceptionDefinition = formalsToProcess.head.asVariableDefinitions();
         formalsToProcess = formalsToProcess.tail;
         if (!formalsToProcess.isEmpty) {
           stackTraceDefinition = formalsToProcess.head.asVariableDefinitions();
           formalsToProcess = formalsToProcess.tail;
           if (!formalsToProcess.isEmpty) {
             for (Node extra in formalsToProcess) {
-              error(extra, MessageKind.EXTRA_CATCH_DECLARATION);
+              compiler.reportErrorMessage(
+                  extra, MessageKind.EXTRA_CATCH_DECLARATION);
             }
           }
           registry.registerStackTraceInCatch();
         }
       }
 
       // Check that the formals aren't optional and that they have no
       // modifiers or type.
       for (Link<Node> link = node.formals.nodes;
            !link.isEmpty;
            link = link.tail) {
         // If the formal parameter is a node list, it means that it is a
         // sequence of optional parameters.
         NodeList nodeList = link.head.asNodeList();
         if (nodeList != null) {
-          error(nodeList, MessageKind.OPTIONAL_PARAMETER_IN_CATCH);
+          compiler.reportErrorMessage(
+              nodeList, MessageKind.OPTIONAL_PARAMETER_IN_CATCH);
         } else {
           VariableDefinitions declaration = link.head;
           for (Node modifier in declaration.modifiers.nodes) {
-            error(modifier, MessageKind.PARAMETER_WITH_MODIFIER_IN_CATCH);
+            compiler.reportErrorMessage(
+                modifier, MessageKind.PARAMETER_WITH_MODIFIER_IN_CATCH);
           }
           TypeAnnotation type = declaration.type;
           if (type != null) {
-            error(type, MessageKind.PARAMETER_WITH_TYPE_IN_CATCH);
+            compiler.reportErrorMessage(
+                type, MessageKind.PARAMETER_WITH_TYPE_IN_CATCH);
           }
         }
       }
     }
 
     Scope blockScope = new BlockScope(scope);
     doInCheckContext(() => visitIn(node.type, blockScope));
     visitIn(node.formals, blockScope);
     var oldInCatchBlock = inCatchBlock;
     inCatchBlock = true;
@@ skipping 16 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }