Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../common/names.dart' show
     Names,
     Selectors;
 import '../common/tasks.dart' show
     CompilerTask;
 import '../compiler.dart' show
     Compiler;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
+import '../diagnostics/diagnostic_listener.dart' show
+    DiagnosticReporter;
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show
     SynthesizedConstructorElementX,
     ConstructorBodyElementX,
     FunctionSignatureX;
 import '../io/source_information.dart';
 import '../js_backend/js_backend.dart' show
     JavaScriptBackend,
@@ skipping 48 matching lines @@
       : super(compiler);
 
   String get name => 'CPS builder';
 
   ir.FunctionDefinition buildNode(AstElement element) {
     return measure(() {
       bailoutMessage = null;
 
       TreeElements elementsMapping = element.resolvedAst.elements;
       element = element.implementation;
-      return compiler.withCurrentElement(element, () {
+      return reporter.withCurrentElement(element, () {
         SourceInformationBuilder sourceInformationBuilder =
             sourceInformationStrategy.createBuilderForContext(element);
 
         IrBuilderVisitor builder =
             new JsIrBuilderVisitor(
                 elementsMapping, compiler, sourceInformationBuilder);
         ir.FunctionDefinition irNode = builder.buildExecutable(element);
         if (irNode == null) {
           bailoutMessage = builder.bailoutMessage;
         } else if (builderCallback != null) {
@@ skipping 56 matching lines @@
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
   /// Construct a top-level visitor.
   IrBuilderVisitor(this.elements,
                    this.compiler,
                    this.sourceInformationBuilder);
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   String bailoutMessage = null;
 
   @override
   ir.Primitive apply(ast.Node node, _) => node.accept(this);
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   /**
    * Builds the [ir.FunctionDefinition] for an executable element. In case the
@@ skipping 55 matching lines @@
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ## Statements ##
   visitBlock(ast.Block node) {
     irBuilder.buildBlock(node.statements.nodes, build);
   }
 
   ir.Primitive visitBreakStatement(ast.BreakStatement node) {
     if (!irBuilder.buildBreak(elements.getTargetOf(node))) {
-      compiler.internalError(node, "'break' target not found");
+      reporter.internalError(node, "'break' target not found");
     }
     return null;
   }
 
   ir.Primitive visitContinueStatement(ast.ContinueStatement node) {
     if (!irBuilder.buildContinue(elements.getTargetOf(node))) {
-      compiler.internalError(node, "'continue' target not found");
+      reporter.internalError(node, "'continue' target not found");
     }
     return null;
   }
 
   // Build(EmptyStatement, C) = C
   ir.Primitive visitEmptyStatement(ast.EmptyStatement node) {
     assert(irBuilder.isOpen);
     return null;
   }
 
@@ skipping 1995 matching lines @@
       return action();
     } catch(e) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
 
   internalError(ast.Node node, String message) {
-    compiler.internalError(node, message);
+    reporter.internalError(node, message);
   }
 
   @override
   visitNode(ast.Node node) {
     giveup(node, "Unhandled node");
   }
 
   dynamic giveup(ast.Node node, [String reason]) {
     bailoutMessage = '($node): $reason';
     throw ABORT_IRNODE_BUILDER;
@@ skipping 367 matching lines @@
             root = buildStaticFieldInitializer(element);
           } else {
             // Instance field initializers are inlined in the constructor,
             // so we shouldn't need to build anything here.
             // TODO(asgerf): But what should we return?
             return null;
           }
           break;
 
         default:
-          compiler.internalError(element, "Unexpected element type $element");
+          reporter.internalError(element, "Unexpected element type $element");
       }
       return root;
     });
   }
 
   ir.FunctionDefinition buildStaticFieldInitializer(FieldElement element) {
     if (!backend.constants.lazyStatics.contains(element)) {
       return null; // Nothing to do.
     }
     closureClassMap =
@@ skipping 238 matching lines @@
           Selector selector = elements.getSelector(initializer);
           List<ir.Primitive> arguments = initializer.arguments.mapToList(visit);
           evaluateConstructorCallFromInitializer(
               target,
               selector.callStructure,
               arguments,
               supers,
               fieldValues);
           hasConstructorCall = true;
         } else {
-          compiler.internalError(initializer,
+          reporter.internalError(initializer,
                                  "Unexpected initializer type $initializer");
         }
       }
     }
     // If no super() or this() was found, also call default superconstructor.
     if (!hasConstructorCall && !enclosingClass.isObject) {
       ClassElement superClass = enclosingClass.superclass;
       FunctionElement target = superClass.lookupDefaultConstructor();
       if (target == null) {
-        compiler.internalError(superClass, "No default constructor available.");
+        reporter.internalError(superClass, "No default constructor available.");
       }
       target = target.implementation;
       evaluateConstructorCallFromInitializer(
           target,
           CallStructure.NO_ARGS,
           const [],
           supers,
           fieldValues);
     }
     // Add this constructor after the superconstructors.
@@ skipping 435 matching lines @@
         internalError(node, 'Expected at least $minimum arguments.');
       }
     }
 
     /// Call a helper method from the isolate library. The isolate library uses
     /// its own isolate structure, that encapsulates dart2js's isolate.
     ir.Primitive buildIsolateHelperInvocation(String helperName,
                                               CallStructure callStructure) {
       Element element = backend.isolateHelperLibrary.find(helperName);
       if (element == null) {
-        compiler.internalError(node,
+        reporter.internalError(node,
             'Isolate library and compiler mismatch.');
       }
       List<ir.Primitive> arguments = translateStaticArguments(argumentList,
           element, callStructure);
       return irBuilder.buildStaticFunctionInvocation(element,
           callStructure, arguments,
           sourceInformation:
                 sourceInformationBuilder.buildCall(node, node.selector));
     }
 
@@ skipping 190 matching lines @@
     if (compiler.backend.isForeign(function)) {
       return handleForeignCode(node, function, argumentList, callStructure);
     } else {
       return irBuilder.buildStaticFunctionInvocation(function, callStructure,
           translateStaticArguments(argumentList, function, callStructure),
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }