Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   final SsaCodeGeneratorTask generator;
   final SsaBuilderTask builder;
   final SsaOptimizerTask optimizer;
@@ skipping 42 matching lines @@
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
 
   String get name => 'SSA builder';
 
   SsaBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
     : emitter = backend.emitter,
       backend = backend,
       super(backend.compiler);
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   HGraph build(CodegenWorkItem work) {
     return measure(() {
       Element element = work.element.implementation;
-      return compiler.withCurrentElement(element, () {
+      return reporter.withCurrentElement(element, () {
         HInstruction.idCounter = 0;
         SsaBuilder builder =
             new SsaBuilder(
                 backend, work, emitter.nativeEmitter,
                 sourceInformationFactory);
         HGraph graph;
         ElementKind kind = element.kind;
         if (kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
           graph = compileConstructor(builder, work);
         } else if (kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
                    kind == ElementKind.FUNCTION ||
                    kind == ElementKind.GETTER ||
                    kind == ElementKind.SETTER) {
           graph = builder.buildMethod(element);
         } else if (kind == ElementKind.FIELD) {
           if (element.isInstanceMember) {
             assert(compiler.enableTypeAssertions);
             graph = builder.buildCheckedSetter(element);
           } else {
             graph = builder.buildLazyInitializer(element);
           }
         } else {
-          compiler.internalError(element, 'Unexpected element kind $kind.');
+          reporter.internalError(element, 'Unexpected element kind $kind.');
         }
         assert(graph.isValid());
         if (!identical(kind, ElementKind.FIELD)) {
           FunctionElement function = element;
           FunctionSignature signature = function.functionSignature;
           signature.forEachOptionalParameter((ParameterElement parameter) {
             // This ensures the default value will be computed.
             ConstantValue constant =
                 backend.constants.getConstantValueForVariable(parameter);
             CodegenRegistry registry = work.registry;
@@ skipping 332 matching lines @@
   /**
    * Returns an [HInstruction] for the given element. If the element is
    * boxed or stored in a closure then the method generates code to retrieve
    * the value.
    */
   HInstruction readLocal(Local local,
                          {SourceInformation sourceInformation}) {
     if (isAccessedDirectly(local)) {
       if (directLocals[local] == null) {
         if (local is TypeVariableElement) {
-          builder.compiler.internalError(builder.compiler.currentElement,
+          builder.reporter.internalError(builder.compiler.currentElement,
               "Runtime type information not available for $local.");
         } else {
-          builder.compiler.internalError(local,
+          builder.reporter.internalError(local,
               "Cannot find value $local.");
         }
       }
       HInstruction value = directLocals[local];
       if (sourceInformation != null) {
         value = new HRef(value, sourceInformation);
         builder.add(value);
       }
       return value;
     } else if (isStoredInClosureField(local)) {
@@ skipping 329 matching lines @@
   bool hasAnyBreak();
   void close();
   final JumpTarget target;
   List<LabelDefinition> labels();
 }
 
 // Insert break handler used to avoid null checks when a target isn't
 // used as the target of a break, and therefore doesn't need a break
 // handler associated with it.
 class NullJumpHandler implements JumpHandler {
-  final Compiler compiler;
+  final DiagnosticReporter reporter;
 
-  NullJumpHandler(this.compiler);
+  NullJumpHandler(this.reporter);
 
   void generateBreak([LabelDefinition label]) {
-    compiler.internalError(CURRENT_ELEMENT_SPANNABLE,
+    reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
         'NullJumpHandler.generateBreak should not be called.');
   }
 
   void generateContinue([LabelDefinition label]) {
-    compiler.internalError(CURRENT_ELEMENT_SPANNABLE,
+    reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
         'NullJumpHandler.generateContinue should not be called.');
   }
 
   void forEachBreak(Function ignored) { }
   void forEachContinue(Function ignored) { }
   void close() { }
   bool hasAnyContinue() => false;
   bool hasAnyBreak() => false;
 
   List<LabelDefinition> labels() => const <LabelDefinition>[];
@@ skipping 282 matching lines @@
       this.rti = backend.rti,
       this.elements = work.resolutionTree {
     graph.element = work.element;
     localsHandler = new LocalsHandler(this, work.element, null);
     sourceElementStack.add(work.element);
     sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(
             work.element.implementation);
   }
 
+
+  DiagnosticReporter get reporter => compiler.reporter;
+
   // TODO(johnniwinther): Avoid the need for this.
   Resolution get resolution => compiler.resolution;
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   @override
   void visitNode(ast.Node node) {
     internalError(node, "Unhandled node: $node");
   }
@@ skipping 371 matching lines @@
   }
 
   bool isCalledOnce(Element element) {
     if (!allInlinedFunctionsCalledOnce) return false;
     TypesInferrer inferrer = compiler.typesTask.typesInferrer;
     return inferrer.isCalledOnce(element);
   }
 
   inlinedFrom(Element element, f()) {
     assert(element is FunctionElement || element is VariableElement);
-    return compiler.withCurrentElement(element, () {
+    return reporter.withCurrentElement(element, () {
       // The [sourceElementStack] contains declaration elements.
       SourceInformationBuilder oldSourceInformationBuilder =
           sourceInformationBuilder;
       sourceInformationBuilder =
           sourceInformationBuilder.forContext(element.implementation);
       sourceElementStack.add(element.declaration);
       var result = f();
       sourceInformationBuilder = oldSourceInformationBuilder;
       sourceElementStack.removeLast();
       return result;
@@ skipping 351 matching lines @@
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructors] must contain only implementation elements.
    */
   void inlineSuperOrRedirect(ConstructorElement callee,
                              List<HInstruction> compiledArguments,
                              List<FunctionElement> constructors,
                              Map<Element, HInstruction> fieldValues,
                              FunctionElement caller) {
     callee = callee.implementation;
-    compiler.withCurrentElement(callee, () {
+    reporter.withCurrentElement(callee, () {
       constructors.add(callee);
       ClassElement enclosingClass = callee.enclosingClass;
       if (backend.classNeedsRti(enclosingClass)) {
         // If [enclosingClass] needs RTI, we have to give a value to its
         // type parameters.
         ClassElement currentClass = caller.enclosingClass;
         // For a super constructor call, the type is the supertype of
         // [currentClass]. For a redirecting constructor, the type is
         // the current type. [InterfaceType.asInstanceOf] takes care
         // of both.
@@ skipping 94 matching lines @@
               compileArgument,
               handleConstantForOptionalParameter);
       if (!match) {
         if (compiler.elementHasCompileTimeError(constructor)) {
           return;
         }
         // If this fails, the selector we constructed for the call to a
         // forwarding constructor in a mixin application did not match the
         // constructor (which, for example, may happen when the libraries are
         // not compatible for private names, see issue 20394).
-        compiler.internalError(constructor,
+        reporter.internalError(constructor,
                                'forwarding constructor call does not match');
       }
       inlineSuperOrRedirect(
           target,
           arguments,
           constructors,
           fieldValues,
           constructor);
       return;
     }
@@ skipping 41 matching lines @@
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
       ClassElement enclosingClass = constructor.enclosingClass;
       ClassElement superClass = enclosingClass.superclass;
       if (!enclosingClass.isObject) {
         assert(superClass != null);
         assert(superClass.isResolved);
         // TODO(johnniwinther): Should we find injected constructors as well?
         FunctionElement target = superClass.lookupDefaultConstructor();
         if (target == null) {
-          compiler.internalError(superClass,
+          reporter.internalError(superClass,
               "No default constructor available.");
         }
         List<HInstruction> arguments =
             CallStructure.NO_ARGS.makeArgumentsList(
                 const Link<ast.Node>(),
                 target.implementation,
                 null,
                 handleConstantForOptionalParameter);
         inlineSuperOrRedirect(target,
                               arguments,
                               constructors,
                               fieldValues,
                               constructor);
       }
     }
   }
 
   /**
    * Run through the fields of [cls] and add their potential
    * initializers.
    *
    * Invariant: [classElement] must be an implementation element.
    */
   void buildFieldInitializers(ClassElement classElement,
                               Map<Element, HInstruction> fieldValues) {
     assert(invariant(classElement, classElement.isImplementation));
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, VariableElement member) {
           if (compiler.elementHasCompileTimeError(member)) return;
-          compiler.withCurrentElement(member, () {
+          reporter.withCurrentElement(member, () {
             TreeElements definitions = member.treeElements;
             ast.Node node = member.node;
             ast.Expression initializer = member.initializer;
             if (initializer == null) {
               // Unassigned fields of native classes are not initialized to
               // prevent overwriting pre-initialized native properties.
               if (!Elements.isNativeOrExtendsNative(classElement)) {
                 fieldValues[member] = graph.addConstantNull(compiler);
               }
             } else {
@@ skipping 567 matching lines @@
   visitBlock(ast.Block node) {
     assert(!isAborted());
     if (!isReachable) return;  // This can only happen when inlining.
     for (Link<ast.Node> link = node.statements.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       if (!isReachable) {
         // The block has been aborted by a return or a throw.
         if (!stack.isEmpty) {
-          compiler.internalError(node, 'Non-empty instruction stack.');
+          reporter.internalError(node, 'Non-empty instruction stack.');
         }
         return;
       }
     }
     assert(!current.isClosed());
     if (!stack.isEmpty) {
-      compiler.internalError(node, 'Non-empty instruction stack.');
+      reporter.internalError(node, 'Non-empty instruction stack.');
     }
   }
 
   visitClassNode(ast.ClassNode node) {
-    compiler.internalError(node,
+    reporter.internalError(node,
         'SsaBuilder.visitClassNode should not be called.');
   }
 
   visitThrowExpression(ast.Expression expression) {
     bool old = inExpressionOfThrow;
     try {
       inExpressionOfThrow = true;
       visit(expression);
     } finally {
       inExpressionOfThrow = old;
@@ skipping 519 matching lines @@
 
   @override
   void visitThisGet(ast.Identifier node, [_]) {
     stack.add(localsHandler.readThis());
   }
 
   visitIdentifier(ast.Identifier node) {
     if (node.isThis()) {
       visitThisGet(node);
     } else {
-      compiler.internalError(node,
+      reporter.internalError(node,
           "SsaFromAstMixin.visitIdentifier on non-this.");
     }
   }
 
   visitIf(ast.If node) {
     assert(isReachable);
     handleIf(
         node,
         visitCondition: () => visit(node.condition),
         visitThen: () => visit(node.thenPart),
@@ skipping 842 matching lines @@
     generateCallInvoke(node, localsHandler.readLocal(function),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   void handleForeignJs(ast.Send node) {
     Link<ast.Node> link = node.arguments;
     // Don't visit the first argument, which is the type, and the second
     // argument, which is the foreign code.
     if (link.isEmpty || link.tail.isEmpty) {
       // We should not get here because the call should be compiled to NSM.
-      compiler.internalError(node.argumentsNode,
+      reporter.internalError(node.argumentsNode,
           'At least two arguments expected.');
     }
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
 
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(link.tail.tail, inputs);
 
     if (nativeBehavior.codeTemplate.positionalArgumentCount != inputs.length) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           node, MessageKind.GENERIC,
           {'text':
             'Mismatch between number of placeholders'
             ' and number of arguments.'});
       stack.add(graph.addConstantNull(compiler));  // Result expected on stack.
       return;
     }
 
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
@@ skipping 13 matching lines @@
           effects: nativeBehavior.sideEffects,
           nativeBehavior: nativeBehavior)
               ..sourceInformation = sourceInformation);
     }
   }
 
   void handleJsStringConcat(ast.Send node) {
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(node.arguments, inputs);
     if (inputs.length != 2) {
-      compiler.internalError(node.argumentsNode, 'Two arguments expected.');
+      reporter.internalError(node.argumentsNode, 'Two arguments expected.');
     }
     push(new HStringConcat(inputs[0], inputs[1], node, backend.stringType));
   }
 
   void handleForeignJsCurrentIsolateContext(ast.Send node) {
     if (!node.arguments.isEmpty) {
-      compiler.internalError(node,
+      reporter.internalError(node,
           'Too many arguments to JS_CURRENT_ISOLATE_CONTEXT.');
     }
 
     if (!compiler.hasIsolateSupport) {
       // If the isolate library is not used, we just generate code
       // to fetch the static state.
       String name = backend.namer.staticStateHolder;
       push(new HForeignCode(js.js.parseForeignJS(name),
                             backend.dynamicType,
                             <HInstruction>[]));
     } else {
       // Call a helper method from the isolate library. The isolate
       // library uses its own isolate structure, that encapsulates
       // Leg's isolate.
       Element element = backend.isolateHelperLibrary.find('_currentIsolate');
       if (element == null) {
-        compiler.internalError(node,
+        reporter.internalError(node,
             'Isolate library and compiler mismatch.');
       }
       pushInvokeStatic(null, element, [], typeMask: backend.dynamicType);
     }
   }
 
   void handleForeignJsGetFlag(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
      ast.Node argument;
      switch (arguments.length) {
      case 0:
-       compiler.reportErrorMessage(
+       reporter.reportErrorMessage(
            node, MessageKind.GENERIC,
            {'text': 'Error: Expected one argument to JS_GET_FLAG.'});
        return;
      case 1:
        argument = arguments[0];
        break;
      default:
        for (int i = 1; i < arguments.length; i++) {
-         compiler.reportErrorMessage(
+         reporter.reportErrorMessage(
              arguments[i], MessageKind.GENERIC,
              {'text': 'Error: Extra argument to JS_GET_FLAG.'});
        }
        return;
      }
      ast.LiteralString string = argument.asLiteralString();
      if (string == null) {
-       compiler.reportErrorMessage(
+       reporter.reportErrorMessage(
            argument, MessageKind.GENERIC,
            {'text': 'Error: Expected a literal string.'});
      }
      String name = string.dartString.slowToString();
      bool value = false;
      switch (name) {
        case 'MUST_RETAIN_METADATA':
          value = backend.mustRetainMetadata;
          break;
        case 'USE_CONTENT_SECURITY_POLICY':
          value = compiler.useContentSecurityPolicy;
          break;
        default:
-         compiler.reportErrorMessage(
+         reporter.reportErrorMessage(
              node, MessageKind.GENERIC,
              {'text': 'Error: Unknown internal flag "$name".'});
      }
      stack.add(graph.addConstantBool(value, compiler));
   }
 
   void handleForeignJsGetName(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node argument;
     switch (arguments.length) {
     case 0:
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           node, MessageKind.GENERIC,
           {'text': 'Error: Expected one argument to JS_GET_NAME.'});
       return;
     case 1:
       argument = arguments[0];
       break;
     default:
       for (int i = 1; i < arguments.length; i++) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             arguments[i], MessageKind.GENERIC,
             {'text': 'Error: Extra argument to JS_GET_NAME.'});
       }
       return;
     }
     Element element = elements[argument];
     if (element == null ||
         element is! FieldElement ||
         element.enclosingClass != backend.jsGetNameEnum) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           argument, MessageKind.GENERIC,
           {'text': 'Error: Expected a JsGetName enum value.'});
     }
     EnumClassElement enumClass = element.enclosingClass;
     int index = enumClass.enumValues.indexOf(element);
     stack.add(
         addConstantStringFromName(
             backend.namer.getNameForJsGetName(
                 argument, JsGetName.values[index])));
   }
 
   void handleForeignJsBuiltin(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node argument;
     if (arguments.length < 2) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           node, MessageKind.GENERIC,
           {'text': 'Error: Expected at least two arguments to JS_BUILTIN.'});
     }
 
     Element builtinElement = elements[arguments[1]];
     if (builtinElement == null ||
         (builtinElement is! FieldElement) ||
         builtinElement.enclosingClass != backend.jsBuiltinEnum) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           argument, MessageKind.GENERIC,
           {'text': 'Error: Expected a JsBuiltin enum value.'});
     }
     EnumClassElement enumClass = builtinElement.enclosingClass;
     int index = enumClass.enumValues.indexOf(builtinElement);
 
     js.Template template =
         backend.emitter.builtinTemplateFor(JsBuiltin.values[index]);
 
     List<HInstruction> compiledArguments = <HInstruction>[];
@@ skipping 13 matching lines @@
                           compiledArguments,
                           nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsEmbeddedGlobal(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node globalNameNode;
     switch (arguments.length) {
     case 0:
     case 1:
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           node, MessageKind.GENERIC,
           {'text': 'Error: Expected two arguments to JS_EMBEDDED_GLOBAL.'});
       return;
     case 2:
       // The type has been extracted earlier. We are only interested in the
       // name in this function.
       globalNameNode = arguments[1];
       break;
     default:
       for (int i = 2; i < arguments.length; i++) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             arguments[i], MessageKind.GENERIC,
             {'text': 'Error: Extra argument to JS_EMBEDDED_GLOBAL.'});
       }
       return;
     }
     visit(globalNameNode);
     HInstruction globalNameHNode = pop();
     if (!globalNameHNode.isConstantString()) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           arguments[1], MessageKind.GENERIC,
           {'text': 'Error: Expected String as second argument '
                    'to JS_EMBEDDED_GLOBAL.'});
       return;
     }
     HConstant hConstant = globalNameHNode;
     StringConstantValue constant = hConstant.constant;
     String globalName = constant.primitiveValue.slowToString();
     js.Template expr = js.js.expressionTemplateYielding(
         backend.emitter.generateEmbeddedGlobalAccess(globalName));
@@ skipping 16 matching lines @@
         ConstantValue argumentConstant = argumentInstruction.constant;
         if (argumentConstant is TypeConstantValue) {
           ConstantValue constant =
               new InterceptorConstantValue(argumentConstant.representedType);
           HInstruction instruction = graph.addConstant(constant, compiler);
           stack.add(instruction);
           return;
         }
       }
     }
-    compiler.reportErrorMessage(
+    reporter.reportErrorMessage(
         node,
         MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     stack.add(graph.addConstantNull(compiler));
   }
 
   void handleForeignJsCallInIsolate(ast.Send node) {
     Link<ast.Node> link = node.arguments;
     if (!compiler.hasIsolateSupport) {
       // If the isolate library is not used, we just invoke the
       // closure.
       visit(link.tail.head);
       push(new HInvokeClosure(new Selector.callClosure(0),
                               <HInstruction>[pop()],
                               backend.dynamicType));
     } else {
       // Call a helper method from the isolate library.
       Element element = backend.isolateHelperLibrary.find('_callInIsolate');
       if (element == null) {
-        compiler.internalError(node,
+        reporter.internalError(node,
             'Isolate library and compiler mismatch.');
       }
       List<HInstruction> inputs = <HInstruction>[];
       addGenericSendArgumentsToList(link, inputs);
       pushInvokeStatic(node, element, inputs, typeMask: backend.dynamicType);
     }
   }
 
   FunctionSignature handleForeignRawFunctionRef(ast.Send node, String name) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
-      compiler.internalError(node.argumentsNode,
+      reporter.internalError(node.argumentsNode,
           '"$name" requires exactly one argument.');
     }
     ast.Node closure = node.arguments.head;
     Element element = elements[closure];
     if (!Elements.isStaticOrTopLevelFunction(element)) {
-      compiler.internalError(closure,
+      reporter.internalError(closure,
           '"$name" requires a static or top-level method.');
     }
     FunctionElement function = element;
     // TODO(johnniwinther): Try to eliminate the need to distinguish declaration
     // and implementation signatures. Currently it is need because the
     // signatures have different elements for parameters.
     FunctionElement implementation = function.implementation;
     FunctionSignature params = implementation.functionSignature;
     if (params.optionalParameterCount != 0) {
-      compiler.internalError(closure,
+      reporter.internalError(closure,
           '"$name" does not handle closure with optional parameters.');
     }
 
     registry.registerStaticUse(element);
     push(new HForeignCode(
         js.js.expressionTemplateYielding(
             backend.emitter.staticFunctionAccess(element)),
         backend.dynamicType,
         <HInstruction>[],
         nativeBehavior: native.NativeBehavior.PURE));
     return params;
   }
 
   void handleForeignDartClosureToJs(ast.Send node, String name) {
     // TODO(ahe): This implements DART_CLOSURE_TO_JS and should probably take
     // care to wrap the closure in another closure that saves the current
     // isolate.
     handleForeignRawFunctionRef(node, name);
   }
 
   void handleForeignJsSetStaticState(ast.Send node) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
-      compiler.internalError(node.argumentsNode,
+      reporter.internalError(node.argumentsNode,
           'Exactly one argument required.');
     }
     visit(node.arguments.head);
     String isolateName = backend.namer.staticStateHolder;
     SideEffects sideEffects = new SideEffects.empty();
     sideEffects.setAllSideEffects();
     push(new HForeignCode(
         js.js.parseForeignJS("$isolateName = #"),
         backend.dynamicType,
         <HInstruction>[pop()],
         nativeBehavior: native.NativeBehavior.PURE,
         effects: sideEffects));
   }
 
   void handleForeignJsGetStaticState(ast.Send node) {
     if (!node.arguments.isEmpty) {
-      compiler.internalError(node.argumentsNode, 'Too many arguments.');
+      reporter.internalError(node.argumentsNode, 'Too many arguments.');
     }
     push(new HForeignCode(js.js.parseForeignJS(backend.namer.staticStateHolder),
                           backend.dynamicType,
                           <HInstruction>[]));
   }
 
   void handleForeignSend(ast.Send node, FunctionElement element) {
     String name = element.name;
     if (name == 'JS') {
       handleForeignJs(node);
@@ skipping 17 matching lines @@
       handleForeignJsBuiltin(node);
     } else if (name == 'JS_GET_FLAG') {
       handleForeignJsGetFlag(node);
     } else if (name == 'JS_EFFECT') {
       stack.add(graph.addConstantNull(compiler));
     } else if (name == 'JS_INTERCEPTOR_CONSTANT') {
       handleJsInterceptorConstant(node);
     } else if (name == 'JS_STRING_CONCAT') {
       handleJsStringConcat(node);
     } else {
-      compiler.internalError(node, "Unknown foreign: ${element}");
+      reporter.internalError(node, "Unknown foreign: ${element}");
     }
   }
 
   generateDeferredLoaderGet(ast.Send node,
                             FunctionElement deferredLoader,
                             SourceInformation sourceInformation) {
     // Until now we only handle these as getters.
     invariant(node, deferredLoader.isDeferredLoaderGetter);
     Element loadFunction = compiler.loadLibraryFunction;
     PrefixElement prefixElement = deferredLoader.enclosingElement;
@@ skipping 406 matching lines @@
       // The type variable is stored in a parameter of the method.
       return localsHandler.readLocal(
           typeVariableLocal, sourceInformation: sourceInformation);
     } else if (member.isInstanceMember) {
       // The type variable is stored on the object.
       return readTypeVariable(
           member.enclosingClass,
           type.element,
           sourceInformation: sourceInformation);
     } else {
-      compiler.internalError(type.element,
+      reporter.internalError(type.element,
           'Unexpected type variable in static context.');
       return null;
     }
   }
 
   HInstruction analyzeTypeArgument(
       DartType argument,
       {SourceInformation sourceInformation}) {
 
     assert(assertTypeInContext(argument));
@@ skipping 666 matching lines @@
             inputs, backend.dynamicType)
         ..sourceInformation = sourceInformation);
   }
 
   visitGetterSend(ast.Send node) {
     internalError(node, "Unexpected visitGetterSend");
   }
 
   // TODO(antonm): migrate rest of SsaFromAstMixin to internalError.
   internalError(Spannable node, String reason) {
-    compiler.internalError(node, reason);
+    reporter.internalError(node, reason);
   }
 
   void generateError(ast.Node node, String message, Element helper) {
     HInstruction errorMessage = addConstantString(message);
     pushInvokeStatic(node, helper, [errorMessage]);
   }
 
   void generateRuntimeError(ast.Node node, String message) {
     generateError(node, message, backend.getThrowRuntimeError());
   }
@@ skipping 1299 matching lines @@
     stack.add(stringBuilder.result);
   }
 
   void visitLiteralNull(ast.LiteralNull node) {
     stack.add(graph.addConstantNull(compiler));
   }
 
   visitNodeList(ast.NodeList node) {
     for (Link<ast.Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       if (isAborted()) {
-        compiler.reportHintMessage(
+        reporter.reportHintMessage(
             link.head,
             MessageKind.GENERIC,
             {'text': 'dead code'});
       } else {
         visit(link.head);
       }
     }
   }
 
   void visitParenthesizedExpression(ast.ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitOperator(ast.Operator node) {
     // Operators are intercepted in their surrounding Send nodes.
-    compiler.internalError(node,
+    reporter.internalError(node,
         'SsaBuilder.visitOperator should not be called.');
   }
 
   visitCascade(ast.Cascade node) {
     visit(node.expression);
     // Remove the result and reveal the duplicated receiver on the stack.
     pop();
   }
 
   visitCascadeReceiver(ast.CascadeReceiver node) {
     visit(node.expression);
     dup();
   }
 
   void handleInTryStatement() {
     if (!inTryStatement) return;
     HBasicBlock block = close(new HExitTry());
     HBasicBlock newBlock = graph.addNewBlock();
     block.addSuccessor(newBlock);
     open(newBlock);
   }
 
   visitRethrow(ast.Rethrow node) {
     HInstruction exception = rethrowableException;
     if (exception == null) {
       exception = graph.addConstantNull(compiler);
-      compiler.internalError(node,
+      reporter.internalError(node,
           'rethrowableException should not be null.');
     }
     handleInTryStatement();
     closeAndGotoExit(
         new HThrow(exception,
                    sourceInformationBuilder.buildThrow(node),
                    isRethrow: true));
   }
 
   visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) {
@@ skipping 104 matching lines @@
 
   visitAwait(ast.Await node) {
     visit(node.expression);
     HInstruction awaited = pop();
     // TODO(herhut): Improve this type.
     push(new HAwait(awaited, new TypeMask.subclass(compiler.objectClass,
                                                    compiler.world)));
   }
 
   visitTypeAnnotation(ast.TypeAnnotation node) {
-    compiler.internalError(node,
+    reporter.internalError(node,
         'Visiting type annotation in SSA builder.');
   }
 
   visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isReachable);
     for (Link<ast.Node> link = node.definitions.nodes;
          !link.isEmpty;
          link = link.tail) {
       ast.Node definition = link.head;
       LocalElement local = elements[definition];
@@ skipping 55 matching lines @@
   }
 
   visitStringInterpolation(ast.StringInterpolation node) {
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result);
   }
 
   visitStringInterpolationPart(ast.StringInterpolationPart node) {
     // The parts are iterated in visitStringInterpolation.
-    compiler.internalError(node,
+    reporter.internalError(node,
       'SsaBuilder.visitStringInterpolation should not be called.');
   }
 
   visitEmptyStatement(ast.EmptyStatement node) {
     // Do nothing, empty statement.
   }
 
   visitModifiers(ast.Modifiers node) {
     compiler.unimplemented(node, 'SsaFromAstMixin.visitModifiers.');
   }
@@ skipping 34 matching lines @@
    * a special "null handler" is returned.
    *
    * [isLoopJump] is [:true:] when the jump handler is for a loop. This is used
    * to distinguish the synthetized loop created for a switch statement with
    * continue statements from simple switch statements.
    */
   JumpHandler createJumpHandler(ast.Statement node, {bool isLoopJump}) {
     JumpTarget element = elements.getTargetDefinition(node);
     if (element == null || !identical(element.statement, node)) {
       // No breaks or continues to this node.
-      return new NullJumpHandler(compiler);
+      return new NullJumpHandler(reporter);
     }
     if (isLoopJump && node is ast.SwitchStatement) {
       // Create a special jump handler for loops created for switch statements
       // with continue statements.
       return new SwitchCaseJumpHandler(this, element, node);
     }
     return new JumpHandler(this, element);
   }
 
   visitAsyncForIn(ast.AsyncForIn node) {
@@ skipping 246 matching lines @@
       HInstruction addInstruction =
           new HAdd(index, one, null, backend.positiveIntType);
       add(addInstruction);
       localsHandler.updateLocal(indexVariable, addInstruction);
     }
 
     handleLoop(node, buildInitializer, buildCondition, buildUpdate, buildBody);
   }
 
   visitLabel(ast.Label node) {
-    compiler.internalError(node, 'SsaFromAstMixin.visitLabel.');
+    reporter.internalError(node, 'SsaFromAstMixin.visitLabel.');
   }
 
   visitLabeledStatement(ast.LabeledStatement node) {
     ast.Statement body = node.statement;
     if (body is ast.Loop
         || body is ast.SwitchStatement
         || Elements.isUnusedLabel(node, elements)) {
       // Loops and switches handle their own labels.
       visit(body);
       return;
@@ skipping 309 matching lines @@
         if (!isAborted()) {
           // Ensure that we break the loop if the case falls through. (This
           // is only possible for the last case.)
           jumpTargets[switchTarget].generateBreak();
         }
       }
       // Pass a [NullJumpHandler] because the target for the contained break
       // is not the generated switch statement but instead the loop generated
       // in the call to [handleLoop] below.
       handleSwitch(node,
-                   new NullJumpHandler(compiler),
+                   new NullJumpHandler(reporter),
                    buildExpression, node.cases, getConstants,
                    (_) => false, // No case is default.
                    buildSwitchCase);
     }
 
     void buildLoop() {
       handleLoop(node,
           () {},
           buildCondition,
           () {},
@@ skipping 146 matching lines @@
         new HSwitchBlockInformation(expressionInfo,
                                     statements,
                                     jumpHandler.target,
                                     jumpHandler.labels()),
         joinBlock);
 
     jumpHandler.close();
   }
 
   visitSwitchCase(ast.SwitchCase node) {
-    compiler.internalError(node, 'SsaFromAstMixin.visitSwitchCase.');
+    reporter.internalError(node, 'SsaFromAstMixin.visitSwitchCase.');
   }
 
   visitCaseMatch(ast.CaseMatch node) {
-    compiler.internalError(node, 'SsaFromAstMixin.visitCaseMatch.');
+    reporter.internalError(node, 'SsaFromAstMixin.visitCaseMatch.');
   }
 
   /// Calls [buildTry] inside a synthetic try block with [buildFinally] in the
   /// finally block.
   ///
   /// Note that to get the right locals behavior, the code visited by [buildTry]
   /// and [buildFinally] must have been analyzed as if inside a try-statement by
   /// [ClosureTranslator].
   void buildProtectedByFinally(void buildTry(), void buildFinally()) {
     // Save the current locals. The finally block must not reuse the existing
@@ skipping 130 matching lines @@
 
       pushInvokeStatic(node, backend.getExceptionUnwrapper(), [exception]);
       HInvokeStatic unwrappedException = pop();
       tryInstruction.exception = exception;
       Link<ast.Node> link = node.catchBlocks.nodes;
 
       void pushCondition(ast.CatchBlock catchBlock) {
         if (catchBlock.onKeyword != null) {
           DartType type = elements.getType(catchBlock.type);
           if (type == null) {
-            compiler.internalError(catchBlock.type, 'On with no type.');
+            reporter.internalError(catchBlock.type, 'On with no type.');
           }
           HInstruction condition =
               buildIsNode(catchBlock.type, type, unwrappedException);
           push(condition);
         } else {
           ast.VariableDefinitions declaration = catchBlock.formals.nodes.head;
           HInstruction condition = null;
           if (declaration.type == null) {
             condition = graph.addConstantBool(true, compiler);
             stack.add(condition);
           } else {
             // TODO(aprelev@gmail.com): Once old catch syntax is removed
             // "if" condition above and this "else" branch should be deleted as
             // type of declared variable won't matter for the catch
             // condition.
             DartType type = elements.getType(declaration.type);
             if (type == null) {
-              compiler.internalError(catchBlock, 'Catch with unresolved type.');
+              reporter.internalError(catchBlock, 'Catch with unresolved type.');
             }
             condition = buildIsNode(declaration.type, type, unwrappedException);
             push(condition);
           }
         }
       }
 
       void visitThen() {
         ast.CatchBlock catchBlock = link.head;
         link = link.tail;
@@ skipping 118 matching lines @@
 
   visitCatchBlock(ast.CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(ast.Typedef node) {
     compiler.unimplemented(node, 'SsaFromAstMixin.visitTypedef.');
   }
 
   visitTypeVariable(ast.TypeVariable node) {
-    compiler.internalError(node, 'SsaFromAstMixin.visitTypeVariable.');
+    reporter.internalError(node, 'SsaFromAstMixin.visitTypeVariable.');
   }
 
   /**
    * This method is invoked before inlining the body of [function] into this
    * [SsaBuilder].
    */
   void enterInlinedMethod(FunctionElement function,
                           ast.Node _,
                           List<HInstruction> compiledArguments,
                           {InterfaceType instanceType}) {
@@ skipping 116 matching lines @@
 
   StringBuilderVisitor(this.builder, this.diagnosticNode);
 
   Compiler get compiler => builder.compiler;
 
   void visit(ast.Node node) {
     node.accept(this);
   }
 
   visitNode(ast.Node node) {
-    builder.compiler.internalError(node, 'Unexpected node.');
+    builder.reporter.internalError(node, 'Unexpected node.');
   }
 
   void visitExpression(ast.Node node) {
     node.accept(builder);
     HInstruction expression = builder.pop();
 
     // We want to use HStringify when:
     //   1. The value is known to be a primitive type, because it might get
     //      constant-folded and codegen has some tricks with JavaScript
     //      conversions.
@@ skipping 571 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }