Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/js/rewrite_async.dart

 // Copyright (c) 2015, 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 rewrite_async;
 
 import "dart:math" show max;
 import 'dart:collection';
 
 import 'package:js_runtime/shared/async_await_error_codes.dart'
@@ skipping 140 matching lines @@
   ///
   /// Used if there are untransformed loops containing break or continues to
   /// targets outside the loop.
   String outerLabelName;
 
   /// If javascript `this` is used, it is accessed via this variable, in the
   /// [bodyName] function.
   js.VariableUse get self => new js.VariableUse(selfName);
   String selfName;
 
-  final DiagnosticListener diagnosticListener;
+  final DiagnosticReporter reporter;
   // For error reporting only.
   Spannable get spannable {
     return (_spannable == null) ? NO_LOCATION_SPANNABLE : _spannable;
   }
 
   Spannable _spannable;
 
   int _currentLabel = 0;
 
   // The highest temporary variable index currently in use.
   int currentTempVarIndex = 0;
   // The highest temporary variable index ever in use in this function.
   int tempVarHighWaterMark = 0;
   Map<int, js.Expression> tempVarNames = new Map<int, js.Expression>();
 
   bool get isAsync => false;
   bool get isSyncStar => false;
   bool get isAsyncStar => false;
 
-  AsyncRewriterBase(this.diagnosticListener,
-                    spannable,
+  AsyncRewriterBase(this.reporter,
+                    this._spannable,
                     this.safeVariableName,
-                    this.bodyName)
-      : _spannable = spannable;
+                    this.bodyName);
 
   /// Initialize names used by the subClass.
   void initializeNames();
 
   /// Main entry point.
   /// Rewrites a sync*/async/async* function to an equivalent normal function.
   ///
   /// [spannable] can be passed to have a location for error messages.
   js.Fun rewrite(js.Fun node, [Spannable spannable]) {
     _spannable = spannable;
@@ skipping 149 matching lines @@
   bool shouldTransform(js.Node node) {
     return analysis.hasAwaitOrYield.contains(node);
   }
 
   void unsupported(js.Node node) {
     throw new UnsupportedError(
         "Node $node cannot be transformed by the await-sync transformer");
   }
 
   void unreachable(js.Node node) {
-    diagnosticListener.internalError(
+    reporter.internalError(
         spannable, "Internal error, trying to visit $node");
   }
 
   visitStatement(js.Statement node) {
     node.accept(this);
   }
 
   /// Visits [node] to ensure its sideeffects are performed, but throwing away
   /// the result.
   ///
@@ skipping 1003 matching lines @@
       for (js.SwitchClause clause in node.cases) {
         if (clause is js.Case) {
           labels[i] = newLabel("case");
           clauses.add(new js.Case(visitExpression(clause.expression),
                                   gotoAndBreak(labels[i])));
         } else if (clause is js.Default) {
           labels[i] = newLabel("default");
           clauses.add(new js.Default(gotoAndBreak(labels[i])));
           hasDefault = true;
         } else {
-          diagnosticListener.internalError(
+          reporter.internalError(
               spannable, "Unknown clause type $clause");
         }
         i++;
       }
       if (!hasDefault) {
         clauses.add(new js.Default(gotoAndBreak(after)));
       }
       withExpression(node.key, (js.Expression key) {
         addStatement(new js.Switch(key, clauses));
       }, store: false);
@@ skipping 298 matching lines @@
   /// - The completer object [completer]
   final js.Expression asyncHelper;
 
   /// Contructor used to initialize the [completer] variable.
   ///
   /// Specific to async methods.
   final js.Expression newCompleter;
 
   final js.Expression wrapBody;
 
-  AsyncRewriter(DiagnosticListener diagnosticListener,
-                spannable,
+  AsyncRewriter(DiagnosticReporter reporter,
+                Spannable spannable,
                 {this.asyncHelper,
                  this.newCompleter,
                  this.wrapBody,
                  String safeVariableName(String proposedName),
                  js.Name bodyName})
-        : super(diagnosticListener,
+        : super(reporter,
                 spannable,
                 safeVariableName,
                 bodyName);
 
   @override
   void addYield(js.DartYield node, js.Expression expression) {
-    diagnosticListener.internalError(spannable,
+    reporter.internalError(spannable,
         "Yield in non-generating async function");
   }
 
   void addErrorExit() {
     beginLabel(rethrowLabel);
     addStatement(js.js.statement(
         "return #thenHelper(#currentError, #errorCode, #completer);", {
           "thenHelper": asyncHelper,
           "errorCode": js.number(error_codes.ERROR),
           "currentError": currentError,
@@ skipping 97 matching lines @@
   final js.Expression endOfIteration;
 
   /// A JS Expression that creates a marker indication a 'yield*' statement.
   ///
   /// Called with the stream to yield from.
   final js.Expression yieldStarExpression;
 
   /// Used by sync* functions to throw exeptions.
   final js.Expression uncaughtErrorExpression;
 
-  SyncStarRewriter(DiagnosticListener diagnosticListener,
+  SyncStarRewriter(DiagnosticReporter diagnosticListener,
                 spannable,
                 {this.endOfIteration,
                  this.newIterable,
                  this.yieldStarExpression,
                  this.uncaughtErrorExpression,
                  String safeVariableName(String proposedName),
                  js.Name bodyName})
         : super(diagnosticListener,
                 spannable,
                 safeVariableName,
@@ skipping 89 matching lines @@
 
   @override
   Iterable<js.VariableInitialization> variableInitializations() {
     List<js.VariableInitialization> variables =
         new List<js.VariableInitialization>();
     return variables;
   }
 
   @override
   js.Statement awaitStatement(js.Expression value) {
-    throw diagnosticListener.internalError(spannable,
+    throw reporter.internalError(spannable,
         "Sync* functions cannot contain await statements.");
   }
 
   @override
   void initializeNames() {}
 }
 
 class AsyncStarRewriter extends AsyncRewriterBase {
 
   bool get isAsyncStar => true;
@@ skipping 40 matching lines @@
   /// Called with the value to yield.
   final js.Expression yieldExpression;
 
   /// A JS Expression that creates a marker indication a 'yield*' statement.
   ///
   /// Called with the stream to yield from.
   final js.Expression yieldStarExpression;
 
   final js.Expression wrapBody;
 
-  AsyncStarRewriter(DiagnosticListener diagnosticListener,
-                spannable,
-                {this.asyncStarHelper,
-                 this.streamOfController,
-                 this.newController,
-                 this.yieldExpression,
-                 this.yieldStarExpression,
-                 this.wrapBody,
-                 String safeVariableName(String proposedName),
-                 js.Name bodyName})
-        : super(diagnosticListener,
+  AsyncStarRewriter(DiagnosticReporter reporter,
+                    Spannable spannable,
+                    {this.asyncStarHelper,
+                     this.streamOfController,
+                     this.newController,
+                     this.yieldExpression,
+                     this.yieldStarExpression,
+                     this.wrapBody,
+                     String safeVariableName(String proposedName),
+                     js.Name bodyName})
+        : super(reporter,
                 spannable,
                 safeVariableName,
                 bodyName);
 
 
   /// Translates a yield/yield* in an async* function.
   ///
   /// yield/yield* in an async* function is translated much like the `await` is
   /// translated in [visitAwait], only the object is wrapped in a
   /// [yieldExpression]/[yieldStarExpression] to let [asyncStarHelper]
@@ skipping 575 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }