Extract DiagnosticReporter implementation from Compiler.

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;
+    DiagnosticMessage,
+    DiagnosticReporter;
 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 168 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.reportErrorMessage(
+        reporter.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;
         return reportAndCreateErroneousElement(
               node,
               name,
               ambiguous.messageKind,
               ambiguous.messageArguments,
-              infos: ambiguous.computeInfos(enclosingElement, compiler),
+              infos: ambiguous.computeInfos(enclosingElement, reporter),
               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) {
@@ skipping 64 matching lines @@
   }
 
   ErroneousElement reportAndCreateErroneousElement(
       Node node,
       String name,
       MessageKind kind,
       Map arguments,
       {List<DiagnosticMessage> infos: const <DiagnosticMessage>[],
        bool isError: false}) {
     if (isError) {
-      compiler.reportError(
-          compiler.createMessage(node, kind, arguments), infos);
+      reporter.reportError(
+          reporter.createMessage(node, kind, arguments), infos);
     } else {
-      compiler.reportWarning(
-          compiler.createMessage(node, kind, arguments), infos);
+      reporter.reportWarning(
+          reporter.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) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
       }
       return const NoneResult();
     } else if (node.isSuper()) {
       if (!inInstanceContext) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             node, MessageKind.NO_SUPER_IN_STATIC);
       }
       if ((ElementCategory.SUPER & allowedCategory) == 0) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return const NoneResult();
     } else {
       String name = node.source;
-      Element element = lookupInScope(compiler, node, scope, name);
+      Element element = lookupInScope(reporter, 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.
         registry.setType(node, const DynamicType());
       }
       element = reportLookupErrorIfAny(element, node, name);
       if (element == null) {
         if (!inInstanceContext) {
@@ skipping 60 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.reportErrorMessage(node, MessageKind.ILLEGAL_STATIC);
+      reporter.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.reportErrorMessage(
+        reporter.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 74 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.reportErrorMessage(
+      reporter.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) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
         isValidAsConstant = false;
       }
       argumentCount++;
     }
     sendIsMemberAccess = oldSendIsMemberAccess;
     return new ArgumentsResult(
         new CallStructure(argumentCount, namedArguments),
         argumentResults,
         isValidAsConstant: isValidAsConstant);
@@ skipping 465 matching lines @@
           case UnaryOperatorKind.COMPLEMENT:
             isValidConstant =
                 knownExpressionType == coreTypes.intType;
             break;
           case UnaryOperatorKind.NEGATE:
             isValidConstant =
                 knownExpressionType == coreTypes.intType ||
                 knownExpressionType == coreTypes.doubleType;
             break;
           case UnaryOperatorKind.NOT:
-            compiler.internalError(node,
+            reporter.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:
-            compiler.internalError(
+            reporter.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);
@@ skipping 30 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:
-          compiler.internalError(
+          reporter.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) {
@@ skipping 44 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.
-      compiler.internalError(
+      reporter.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;
@@ skipping 34 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:
-          compiler.internalError(
+          reporter.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:
-          compiler.internalError(
+          reporter.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);
@@ skipping 827 matching lines @@
   ResolutionResult handleAmbiguousSend(
       Send node,
       Name name,
       AmbiguousElement element) {
 
     ErroneousElement error = reportAndCreateErroneousElement(
         node,
         name.text,
         element.messageKind,
         element.messageArguments,
-        infos: element.computeInfos(enclosingElement, compiler));
+        infos: element.computeInfos(enclosingElement, reporter));
     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,
-        infos: element.computeInfos(enclosingElement, compiler));
+        infos: element.computeInfos(enclosingElement, reporter));
     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:
-          compiler.internalError(node,
+          reporter.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:
-          compiler.internalError(node,
+          reporter.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(resolution);
 
 
     if (member == compiler.mirrorSystemGetNameFunction &&
         !compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
-      compiler.reportHintMessage(
+      reporter.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:
-          compiler.internalError(node,
+          reporter.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:
-          compiler.internalError(node,
+          reporter.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 compiler.internalError(node, "Unexpected resolved send: $element");
+    return reporter.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 compiler.internalError(node, "Unexpected resolved send: $element");
+    return reporter.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);
     }
     String text = selector.source;
     if (text == 'this') {
       // `this()`.
       return handleThisAccess(node);
     }
     // `name` or `name()`
     Name name = new Name(text, enclosingElement.library);
-    Element element = lookupInScope(compiler, node, scope, text);
+    Element element = lookupInScope(reporter, node, scope, text);
     if (element == null) {
       if (text == 'dynamic') {
         // `dynamic` or `dynamic()` where 'dynamic' is not declared in the
         // current scope.
         return handleDynamicTypeLiteralAccess(node);
       } else if (inInstanceContext) {
         // Implicitly `this.name`.
         return handleThisPropertyAccess(node, name);
       } else {
         // Create [ErroneousElement] for unresolved access.
         ErroneousElement error = reportCannotResolve(node, text);
         return handleUnresolvedAccess(node, name, error);
       }
     } else {
       return handleResolvedSend(node, name, element);
     }
   }
 
   /// Handle an unqualified [SendSet], that is where the `node.receiver` is
   /// null, like `a = b`, `a++`, and `a += b`.
   ResolutionResult handleUnqualifiedSendSet(SendSet node) {
     Identifier selector = node.selector.asIdentifier();
     String text = selector.source;
     Name name = new Name(text, enclosingElement.library);
-    Element element = lookupInScope(compiler, node, scope, text);
+    Element element = lookupInScope(reporter, node, scope, text);
     if (element == null) {
       if (text == 'dynamic') {
         // `dynamic = b`, `dynamic++`, or `dynamic += b` where 'dynamic' is not
         // declared in the current scope.
         return handleDynamicTypeLiteralUpdate(node);
       } else if (inInstanceContext) {
         // Left-hand side is implicitly `this.name`.
         return handleThisPropertyUpdate(node, name, null);
       } else {
         // Create [ErroneousElement] for unresolved access.
@@ skipping 33 matching lines @@
   void handleForeignCall(Send node,
                          Element target,
                          CallStructure callStructure) {
     if (target != null && compiler.backend.isForeign(target)) {
       registry.registerForeignCall(node, target, callStructure, this);
     }
   }
 
   /// Callback for native enqueuer to parse a type.  Returns [:null:] on error.
   DartType resolveTypeFromString(Node node, String typeName) {
-    Element element = lookupInScope(compiler, node, scope, typeName);
+    Element element = lookupInScope(reporter, node, scope, typeName);
     if (element == null) return null;
     if (element is! ClassElement) return null;
     ClassElement cls = element;
     cls.ensureResolved(resolution);
     return cls.computeType(resolution);
   }
 
   /// Handle index operations like `a[b] = c`, `a[b] += c`, and `a[b]++`.
   ResolutionResult handleIndexSendSet(SendSet node) {
     String operatorText = node.assignmentOperator.source;
@@ skipping 201 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.reportWarningMessage(
+              reporter.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.reportWarningMessage(
+              reporter.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.reportErrorMessage(
+      reporter.reportErrorMessage(
           node,
           MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
           {'value': name});
     }
     analyzeConstantDeferred(node);
     ConstantExpression constant = new SymbolConstantExpression(name);
     registry.setConstant(node, constant);
     return new ConstantResult(node, constant);
   }
 
@@ skipping 12 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) {
-      compiler.reportErrorMessage(
+      reporter.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.reportErrorMessage(
+        reporter.reportErrorMessage(
             expression,
             MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR);
       } else if (!node.isArrowBody && currentAsyncMarker.isYielding) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             node,
             MessageKind.RETURN_IN_GENERATOR,
             {'modifier': currentAsyncMarker});
       }
     }
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitYield(Yield node) {
     compiler.streamClass.ensureResolved(resolution);
     compiler.iterableClass.ensureResolved(resolution);
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     final isSymbolConstructor = enclosingElement == compiler.symbolConstructor;
     if (!enclosingElement.isFactoryConstructor) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
-      compiler.reportHintMessage(
+      reporter.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.reportErrorMessage(
+        reporter.reportErrorMessage(
             node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
         isValidAsConstant = false;
       }
       if (redirectionTarget == constructor) {
-        compiler.reportErrorMessage(
+        reporter.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(resolution)
         .subst(type.typeArguments, targetClass.typeVariables);
     FunctionType constructorType = constructor.computeType(resolution);
     bool isSubtype = compiler.types.isSubtype(targetType, constructorType);
     if (!isSubtype) {
-      compiler.reportWarningMessage(
+      reporter.reportWarningMessage(
           node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': targetType, 'toType': constructorType});
       // TODO(johnniwinther): Handle this (potentially) erroneous case.
       isValidAsConstant = false;
     }
 
     redirectionTarget.computeType(resolution);
     FunctionSignature targetSignature = redirectionTarget.functionSignature;
     constructor.computeType(resolution);
@@ skipping 72 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.reportErrorMessage(
+      reporter.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) {
@@ skipping 56 matching lines @@
     constructor.computeType(resolution);
     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.reportErrorMessage(
+      reporter.reportErrorMessage(
           node,
           MessageKind.CANNOT_INSTANTIATE_ENUM,
           {'enumName': cls.name});
       isValidAsConstant = false;
     }
 
     InterfaceType type = registry.getType(node);
     if (node.isConst && type.containsTypeVariables) {
-      compiler.reportErrorMessage(
+      reporter.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.reportErrorMessage(
+          reporter.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.reportHintMessage(
+          reporter.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.reportErrorMessage(
+        reporter.reportErrorMessage(
             spannable,
             MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
             {'type': keyType});
       }
     }
   }
 
   void analyzeConstant(Node node, {enforceConst: true}) {
     ConstantExpression constant =
         compiler.resolver.constantCompiler.compileNode(
@@ skipping 13 matching lines @@
   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.reportErrorMessage(
+        reporter.reportErrorMessage(
             node, MessageKind.PRIVATE_IDENTIFIER, {'value': name});
       }
       return false;
     }
     if (!symbolValidationPattern.hasMatch(name)) {
       if (reportError) {
-        compiler.reportErrorMessage(
+        reporter.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
@@ skipping 26 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.
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             arguments, MessageKind.MISSING_TYPE_ARGUMENT);
         isValidAsConstant = false;
       } else {
         typeArgument = resolveTypeAnnotation(nodes.head);
         for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
-          compiler.reportWarningMessage(
+          reporter.reportWarningMessage(
               nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
           resolveTypeAnnotation(nodes.head);
         }
       }
     }
     DartType listType;
     if (typeArgument != null) {
       if (node.isConst && typeArgument.containsTypeVariables) {
-        compiler.reportErrorMessage(
+        reporter.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);
@@ skipping 74 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) {
-        compiler.reportErrorMessage(
+        reporter.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) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
         return const NoneResult();
       }
       target = label.target;
       if (!target.statement.isValidBreakTarget()) {
-        compiler.reportErrorMessage(
+        reporter.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) {
-        compiler.reportErrorMessage(
+        reporter.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) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
         return const NoneResult();
       }
       target = label.target;
       if (!target.statement.isValidContinueTarget()) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             node.target, MessageKind.INVALID_CONTINUE);
       }
       label.setContinueTarget();
       registry.useLabel(node, label);
     }
     registry.registerTargetOf(node, target);
     return const NoneResult();
   }
 
   registerImplicitInvocation(Selector selector) {
@@ skipping 50 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.reportErrorMessage(
+        reporter.reportErrorMessage(
             send.selector, MessageKind.INVALID_FOR_IN);
       } else {
         loopVariableSelector = new Selector.setter(
             new Name(identifier.source, library));
       }
       if (send.receiver != null) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             send.receiver, MessageKind.INVALID_FOR_IN);
       }
     } else if (variableDefinitions != null) {
       Link<Node> nodes = variableDefinitions.definitions.nodes;
       if (!nodes.tail.isEmpty) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             nodes.tail.head, MessageKind.INVALID_FOR_IN);
       }
       Node first = nodes.head;
       Identifier identifier = first.asIdentifier();
       if (identifier == null) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             first, MessageKind.INVALID_FOR_IN);
       } else {
         loopVariableSelector = new Selector.setter(
             new Name(identifier.source, library));
         loopVariable = registry.getDefinition(identifier);
       }
     } else {
-      compiler.reportErrorMessage(
+      reporter.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) {
@@ skipping 16 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 {
-        compiler.reportWarningMessage(
+        reporter.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.
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             arguments, MessageKind.MISSING_TYPE_ARGUMENT);
         isValidAsConstant = false;
       } else {
         keyTypeArgument = resolveTypeAnnotation(nodes.head);
         nodes = nodes.tail;
         if (nodes.isEmpty) {
-          compiler.reportWarningMessage(
+          reporter.reportWarningMessage(
               arguments, MessageKind.MISSING_TYPE_ARGUMENT);
         } else {
           valueTypeArgument = resolveTypeAnnotation(nodes.head);
           for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
-            compiler.reportWarningMessage(
+            reporter.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.reportErrorMessage(
+      reporter.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>[];
@@ skipping 77 matching lines @@
         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.reportErrorMessage(
+            reporter.reportErrorMessage(
                 node,
                 MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
                 {'type': "double"});
           } else if (caseType.element == compiler.functionClass) {
-            compiler.reportErrorMessage(
+            reporter.reportErrorMessage(
                 node, MessageKind.SWITCH_CASE_FORBIDDEN,
                 {'type': "Function"});
           } else if (value.isObject && overridesEquals(caseType)) {
-            compiler.reportErrorMessage(
+            reporter.reportErrorMessage(
                 firstCase.expression,
                 MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
                 {'type': caseType});
           }
         } else {
           if (caseType != firstCaseType) {
             if (error == null) {
-              error = compiler.createMessage(
+              error = reporter.createMessage(
                   node,
                   MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL,
                   {'type': firstCaseType});
-              infos.add(compiler.createMessage(
+              infos.add(reporter.createMessage(
                   firstCase.expression,
                   MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
                   {'type': firstCaseType}));
             }
-            infos.add(compiler.createMessage(
+            infos.add(reporter.createMessage(
                 caseMatch.expression,
                 MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
                 {'type': caseType}));
           }
         }
       }
     }
     if (error != null) {
-      compiler.reportError(error, infos);
+      reporter.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(
-              compiler.createMessage(
+          reporter.reportError(
+              reporter.createMessage(
                   label,
                   MessageKind.DUPLICATE_LABEL,
                   {'labelName': labelName}),
               <DiagnosticMessage>[
-                  compiler.createMessage(
+                  reporter.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(
-                compiler.createMessage(
+            reporter.reportWarning(
+                reporter.createMessage(
                     label,
                     MessageKind.DUPLICATE_LABEL,
                     {'labelName': labelName}),
                 <DiagnosticMessage>[
-                    compiler.createMessage(
+                    reporter.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) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             switchCase, MessageKind.INVALID_CASE_DEFAULT);
       }
     }
 
     addDeferredAction(enclosingElement, () {
       checkCaseExpressions(node);
     });
 
     statementScope.enterSwitch(breakElement, continueLabels);
     node.cases.accept(this);
@@ skipping 25 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) {
-      compiler.reportErrorMessage(
+      reporter.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) {
-        compiler.reportErrorMessage(
+        reporter.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) {
-              compiler.reportErrorMessage(
+              reporter.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) {
-          compiler.reportErrorMessage(
+          reporter.reportErrorMessage(
               nodeList, MessageKind.OPTIONAL_PARAMETER_IN_CATCH);
         } else {
           VariableDefinitions declaration = link.head;
           for (Node modifier in declaration.modifiers.nodes) {
-            compiler.reportErrorMessage(
+            reporter.reportErrorMessage(
                 modifier, MessageKind.PARAMETER_WITH_MODIFIER_IN_CATCH);
           }
           TypeAnnotation type = declaration.type;
           if (type != null) {
-            compiler.reportErrorMessage(
+            reporter.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;
@@ skipping 13 matching lines @@
       VariableElementX stackTraceElement =
           registry.getDefinition(stackTraceVariable);
       registry.registerInstantiatedClass(compiler.stackTraceClass);
       stackTraceElement.variables.type = compiler.stackTraceClass.rawType;
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
-Element lookupInScope(Compiler compiler, Node node,
+Element lookupInScope(DiagnosticReporter reporter, Node node,
                       Scope scope, String name) {
-  return Elements.unwrap(scope.lookup(name), compiler, node);
+  return Elements.unwrap(scope.lookup(name), reporter, node);
 }