dartfmt pkg/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'
-    as error_codes;
+import 'package:js_runtime/shared/async_await_error_codes.dart' as error_codes;
 
 import "js.dart" as js;
 
 import '../common.dart';
-import '../util/util.dart' show
-    Pair;
+import '../util/util.dart' show Pair;
 
 /// Rewrites a [js.Fun] with async/sync*/async* functions and await and yield
 /// (with dart-like semantics) to an equivalent function without these.
 /// await-for is not handled and must be rewritten before. (Currently handled
 /// in ssa/builder.dart).
 ///
 /// When generating the input to this, special care must be taken that
 /// parameters to sync* functions that are mutated in the body must be boxed.
 /// (Currently handled in closure.dart).
 ///
 /// Look at [rewriteFunction], [visitDartYield] and [visitAwait] for more
 /// explanation.
 abstract class AsyncRewriterBase extends js.NodeVisitor {
-
   // Local variables are hoisted to the top of the function, so they are
   // collected here.
   List<js.VariableDeclaration> localVariables =
       new List<js.VariableDeclaration>();
 
   Map<js.Node, int> continueLabels = new Map<js.Node, int>();
   Map<js.Node, int> breakLabels = new Map<js.Node, int>();
 
   /// The label of a finally part.
   Map<js.Block, int> finallyLabels = new Map<js.Block, int>();
@@ skipping 127 matching lines @@
   // 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.reporter,
-                    this._spannable,
-                    this.safeVariableName,
-                    this.bodyName);
+  AsyncRewriterBase(
+      this.reporter, this._spannable, this.safeVariableName, 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 12 matching lines @@
     currentErrorName = freshName("currentError");
     outerLabelName = freshName("outer");
     selfName = freshName("self");
     // Initialize names specific to the subclass.
     initializeNames();
 
     return rewriteFunction(node);
   }
 
   js.Expression get currentErrorHandler {
-    return js.number(handlerLabels[jumpTargets.lastWhere(
-        (node) => handlerLabels[node] != null)]);
+    return js.number(handlerLabels[
+        jumpTargets.lastWhere((node) => handlerLabels[node] != null)]);
   }
 
   int allocateTempVar() {
     assert(tempVarHighWaterMark >= currentTempVarIndex);
     currentTempVarIndex++;
     tempVarHighWaterMark = max(currentTempVarIndex, tempVarHighWaterMark);
     return currentTempVarIndex;
   }
 
   js.VariableUse useTempVar(int i) {
@@ skipping 115 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) {
-    reporter.internalError(
-        spannable, "Internal error, trying to visit $node");
+    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.
   ///
   /// If the return value of visiting [node] is an expression guaranteed to have
   /// no side effect, it is dropped.
   void visitExpressionIgnoreResult(js.Expression node) {
     js.Expression result = node.accept(this);
     if (!(result is js.Literal || result is js.VariableUse)) {
       addExpressionStatement(result);
     }
   }
 
   js.Expression visitExpression(js.Expression node) {
     return node.accept(this);
   }
 
-
   /// Calls [fn] with the value of evaluating [node1] and [node2].
   ///
   /// Both nodes are evaluated in order.
   ///
   /// If node2 must be transformed (see [shouldTransform]), then the evaluation
   /// of node1 is added to the current statement-list and the result is stored
   /// in a temporary variable. The evaluation of node2 is then free to emit
   /// statements without affecting the result of node1.
   ///
   /// This is necessary, because await or yield expressions have to emit
@@ skipping 35 matching lines @@
   /// If [store] is true the result of evaluating [node] is stored in a
   /// temporary.
   ///
   /// We cannot rewrite `<receiver>.m()` to:
   ///     temp = <receiver>.m;
   ///     temp();
   /// Because this leaves `this` unbound in the call. But because of dart
   /// evaluation order we can write:
   ///     temp = <receiver>;
   ///     temp.m();
-  withCallTargetExpression(js.Expression node,
-                           fn(js.Expression result), {bool store}) {
+  withCallTargetExpression(js.Expression node, fn(js.Expression result),
+      {bool store}) {
     int oldTempVarIndex = currentTempVarIndex;
     js.Expression visited = visitExpression(node);
     js.Expression selector;
     js.Expression storedIfNeeded;
     if (store) {
       if (visited is js.PropertyAccess) {
         js.PropertyAccess propertyAccess = visited;
         selector = propertyAccess.selector;
         visited = propertyAccess.receiver;
       }
       storedIfNeeded = _storeIfNecessary(visited);
     } else {
       storedIfNeeded = visited;
     }
     js.Expression result;
     if (selector == null) {
       result = fn(storedIfNeeded);
     } else {
       result = fn(new js.PropertyAccess(storedIfNeeded, selector));
     }
     currentTempVarIndex = oldTempVarIndex;
     return result;
   }
 
-
   /// Calls [fn] with the value of evaluating [node1] and [node2].
   ///
   /// If `shouldTransform(node2)` the first expression is stored in a temporary
   /// variable.
   ///
   /// This is because node1 must be evaluated before visiting node2,
   /// because the evaluation of an await or yield cannot be expressed as
   /// an expression, visiting node2 it will output statements that
   /// might have an influence on the value of node1.
   withExpression2(js.Expression node1, js.Expression node2,
@@ skipping 49 matching lines @@
   /// Emits the block that control flows to if an error has been thrown
   /// but not caught. (after going through all the enclosing finally blocks).
   void addErrorExit();
 
   void addFunctionExits() {
     addSuccesExit();
     addErrorExit();
   }
 
   /// Returns the rewritten function.
-  js.Fun finishFunction(List<js.Parameter> parameters,
-                          js.Statement rewrittenBody,
-                          js.VariableDeclarationList variableDeclarations);
+  js.Fun finishFunction(
+      List<js.Parameter> parameters,
+      js.Statement rewrittenBody,
+      js.VariableDeclarationList variableDeclarations);
 
   Iterable<js.VariableInitialization> variableInitializations();
 
   /// Rewrites an async/sync*/async* function to a normal Javascript function.
   ///
   /// The control flow is flattened by simulating 'goto' using a switch in a
   /// loop and a state variable [goto] inside a nested function [body]
   /// that can be called back by [asyncStarHelper]/[asyncStarHelper]/the
   /// [Iterator].
   ///
@@ skipping 136 matching lines @@
     handlerLabels[node] = rethrowLabel;
     js.Statement body = node.body;
     jumpTargets.add(node);
     visitStatement(body);
     jumpTargets.removeLast();
     addFunctionExits();
 
     List<js.SwitchClause> clauses = labelledParts.keys.map((label) {
       return new js.Case(js.number(label), new js.Block(labelledParts[label]));
     }).toList();
-    js.Statement rewrittenBody =
-        new js.Switch(goto, clauses);
+    js.Statement rewrittenBody = new js.Switch(goto, clauses);
     if (hasJumpThoughOuterLabel) {
       rewrittenBody = new js.LabeledStatement(outerLabelName, rewrittenBody);
     }
     rewrittenBody = js.js.statement('while (true) {#}', rewrittenBody);
     List<js.VariableInitialization> variables =
         new List<js.VariableInitialization>();
 
     variables.add(_makeVariableInitializer(goto, js.number(0)));
     variables.addAll(variableInitializations());
-    variables.add(
-        _makeVariableInitializer(handler, js.number(rethrowLabel)));
+    variables.add(_makeVariableInitializer(handler, js.number(rethrowLabel)));
     variables.add(_makeVariableInitializer(currentError, null));
     if (analysis.hasFinally || (isAsyncStar && analysis.hasYield)) {
-      variables.add(_makeVariableInitializer(next,
-          new js.ArrayInitializer(<js.Expression>[])));
+      variables.add(_makeVariableInitializer(
+          next, new js.ArrayInitializer(<js.Expression>[])));
     }
     if (analysis.hasThis && !isSyncStar) {
       // Sync* functions must remember `this` on the level of the outer
       // function.
       variables.add(_makeVariableInitializer(self, js.js('this')));
     }
-    variables.addAll(localVariables.map(
-        (js.VariableDeclaration declaration) {
+    variables.addAll(localVariables.map((js.VariableDeclaration declaration) {
       return new js.VariableInitialization(declaration, null);
     }));
     variables.addAll(new Iterable.generate(tempVarHighWaterMark,
         (int i) => _makeVariableInitializer(useTempVar(i + 1).name, null)));
     js.VariableDeclarationList variableDeclarations =
         new js.VariableDeclarationList(variables);
 
     return finishFunction(node.params, rewrittenBody, variableDeclarations);
   }
 
   @override
   js.Expression visitFun(js.Fun node) {
     if (node.asyncModifier.isAsync || node.asyncModifier.isYielding) {
       // The translation does not handle nested functions that are generators
       // or asynchronous.  These functions should only be ones that are
       // introduced by JS foreign code from our own libraries.
-      reporter.internalError(spannable,
-          'Nested function is a generator or asynchronous.');
+      reporter.internalError(
+          spannable, 'Nested function is a generator or asynchronous.');
     }
     return node;
   }
 
   @override
   js.Expression visitAccess(js.PropertyAccess node) {
     return withExpression2(node.receiver, node.selector,
         (receiver, selector) => js.js('#[#]', [receiver, selector]));
   }
 
@@ skipping 14 matching lines @@
     if (!shouldTransform(node)) {
       return new js.Assignment.compound(visitExpression(node.leftHandSide),
           node.op, visitExpression(node.value));
     }
     js.Expression leftHandSide = node.leftHandSide;
     if (leftHandSide is js.VariableUse) {
       return withExpression(node.value, (js.Expression value) {
         // A non-compound [js.Assignment] has `op==null`. So it works out to
         // use [js.Assignment.compound] for all cases.
         // Visit the [js.VariableUse] to ensure renaming is done correctly.
-        return new js.Assignment.compound(visitExpression(leftHandSide),
-                                          node.op,
-                                          value);
+        return new js.Assignment.compound(
+            visitExpression(leftHandSide), node.op, value);
       }, store: false);
     } else if (leftHandSide is js.PropertyAccess) {
-      return withExpressions([
-        leftHandSide.receiver,
-        leftHandSide.selector,
-        node.value
-      ], (evaluated) {
+      return withExpressions(
+          [leftHandSide.receiver, leftHandSide.selector, node.value],
+          (evaluated) {
         return new js.Assignment.compound(
-            new js.PropertyAccess(evaluated[0], evaluated[1]), node.op,
+            new js.PropertyAccess(evaluated[0], evaluated[1]),
+            node.op,
             evaluated[2]);
       });
     } else {
       throw "Unexpected assignment left hand side $leftHandSide";
     }
   }
 
   js.Statement awaitStatement(js.Expression value);
 
   /// An await is translated to an [awaitStatement].
@@ skipping 94 matching lines @@
   }
 
   @override
   void visitComment(js.Comment node) {
     addStatement(node);
   }
 
   @override
   js.Expression visitConditional(js.Conditional node) {
     if (!shouldTransform(node.then) && !shouldTransform(node.otherwise)) {
-      return js.js('# ? # : #', [visitExpression(node.condition),
-                                 visitExpression(node.then),
-                                 visitExpression(node.otherwise)]);
+      return js.js('# ? # : #', [
+        visitExpression(node.condition),
+        visitExpression(node.then),
+        visitExpression(node.otherwise)
+      ]);
     }
     int thenLabel = newLabel("then");
     int joinLabel = newLabel("join");
     int elseLabel = newLabel("else");
     withExpression(node.condition, (js.Expression condition) {
       addStatement(js.js.statement('# = # ? # : #;',
           [goto, condition, js.number(thenLabel), js.number(elseLabel)]));
     }, store: false);
     addBreak();
     beginLabel(thenLabel);
@@ skipping 67 matching lines @@
 
   @override
   void visitDefault(js.Default node) => unreachable(node);
 
   @override
   void visitDo(js.Do node) {
     if (!shouldTransform(node)) {
       bool oldInsideUntranslatedBreakable = insideUntranslatedBreakable;
       insideUntranslatedBreakable = true;
       addStatement(js.js.statement('do {#} while (#)',
-                                   [translateInBlock(node.body),
-                                    visitExpression(node.condition)]));
+          [translateInBlock(node.body), visitExpression(node.condition)]));
       insideUntranslatedBreakable = oldInsideUntranslatedBreakable;
       return;
     }
     int startLabel = newLabel("do body");
 
     int continueLabel = newLabel("do condition");
     continueLabels[node] = continueLabel;
 
     int afterLabel = newLabel("after do");
     breakLabels[node] = afterLabel;
 
     beginLabel(startLabel);
 
     jumpTargets.add(node);
     visitStatement(node.body);
     jumpTargets.removeLast();
 
     beginLabel(continueLabel);
     withExpression(node.condition, (js.Expression condition) {
-      addStatement(js.js.statement('if (#) #',
-          [condition, gotoAndBreak(startLabel)]));
+      addStatement(
+          js.js.statement('if (#) #', [condition, gotoAndBreak(startLabel)]));
     }, store: false);
     beginLabel(afterLabel);
   }
 
   @override
   void visitEmptyStatement(js.EmptyStatement node) {
     addStatement(node);
   }
 
-
   @override
   void visitExpressionStatement(js.ExpressionStatement node) {
     visitExpressionIgnoreResult(node.expression);
   }
 
   @override
   void visitFor(js.For node) {
     if (!shouldTransform(node)) {
       bool oldInsideUntranslated = insideUntranslatedBreakable;
       insideUntranslatedBreakable = true;
       // Note that node.init, node.condition, node.update all can be null, but
       // withExpressions handles that.
-      withExpressions([
-        node.init,
-        node.condition,
-        node.update
-      ], (List<js.Expression> transformed) {
+      withExpressions([node.init, node.condition, node.update],
+          (List<js.Expression> transformed) {
         addStatement(new js.For(transformed[0], transformed[1], transformed[2],
-             translateInBlock(node.body)));
+            translateInBlock(node.body)));
       });
       insideUntranslatedBreakable = oldInsideUntranslated;
       return;
     }
 
     if (node.init != null) {
       visitExpressionIgnoreResult(node.init);
     }
     int startLabel = newLabel("for condition");
     // If there is no update, continuing the loop is the same as going to the
@@ skipping 51 matching lines @@
   void visitIf(js.If node) {
     if (!shouldTransform(node.then) && !shouldTransform(node.otherwise)) {
       withExpression(node.condition, (js.Expression condition) {
         addStatement(new js.If(condition, translateInBlock(node.then),
             translateInBlock(node.otherwise)));
       }, store: false);
       return;
     }
     int thenLabel = newLabel("then");
     int joinLabel = newLabel("join");
-    int elseLabel = (node.otherwise is js.EmptyStatement)
-        ? joinLabel
-        : newLabel("else");
+    int elseLabel =
+        (node.otherwise is js.EmptyStatement) ? joinLabel : newLabel("else");
 
     withExpression(node.condition, (js.Expression condition) {
-      addExpressionStatement(
-          new js.Assignment(
-              goto,
-              new js.Conditional(
-                  condition,
-                  js.number(thenLabel),
-                  js.number(elseLabel))));
+      addExpressionStatement(new js.Assignment(
+          goto,
+          new js.Conditional(
+              condition, js.number(thenLabel), js.number(elseLabel))));
     }, store: false);
     addBreak();
     beginLabel(thenLabel);
     visitStatement(node.then);
     if (node.otherwise is! js.EmptyStatement) {
       addGoto(joinLabel);
       beginLabel(elseLabel);
       visitStatement(node.otherwise);
     }
     beginLabel(joinLabel);
@@ skipping 163 matching lines @@
         store: false);
   }
 
   @override
   js.Expression visitRegExpLiteral(js.RegExpLiteral node) => node;
 
   @override
   void visitReturn(js.Return node) {
     js.Node target = analysis.targets[node];
     if (node.value != null) {
-      if(isSyncStar || isAsyncStar) {
+      if (isSyncStar || isAsyncStar) {
         // Even though `return expr;` is not allowed in the dart sync* and
         // async*  code, the backend sometimes generates code like this, but
         // only when it is known that the 'expr' throws, and the return is just
         // to tell the JavaScript VM that the code won't continue here.
         // It is therefore interpreted as `expr; return;`
         visitExpressionIgnoreResult(node.value);
       } else {
         withExpression(node.value, (js.Expression value) {
           addStatement(js.js.statement("# = #;", [returnValue, value]));
         }, store: false);
@@ skipping 61 matching lines @@
       } else {
         addGoto(labels[defaultIndex]);
       }
     } else {
       bool hasDefault = false;
       int i = 0;
       List<js.SwitchClause> clauses = new List<js.SwitchClause>();
       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])));
+          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 {
-          reporter.internalError(
-              spannable, "Unknown clause type $clause");
+          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 15 matching lines @@
   }
 
   @override
   void visitThrow(js.Throw node) {
     withExpression(node.expression, (js.Expression expression) {
       addStatement(new js.Throw(expression));
     }, store: false);
   }
 
   setErrorHandler([int errorHandler]) {
-    js.Expression label = (errorHandler == null)
-        ? currentErrorHandler
-        : js.number(errorHandler);
-    addStatement(js.js.statement('# = #;',[handler, label]));
+    js.Expression label =
+        (errorHandler == null) ? currentErrorHandler : js.number(errorHandler);
+    addStatement(js.js.statement('# = #;', [handler, label]));
   }
 
   List<int> _finalliesUpToAndEnclosingHandler() {
     List<int> result = new List<int>();
     for (int i = jumpTargets.length - 1; i >= 0; i--) {
       js.Node node = jumpTargets[i];
       int handlerLabel = handlerLabels[node];
       if (handlerLabel != null) {
         result.add(handlerLabel);
         break;
@@ skipping 16 matching lines @@
               translateInBlock(node.catchPart.body));
       js.Block finallyPart = (node.finallyPart == null)
           ? null
           : translateInBlock(node.finallyPart);
       addStatement(new js.Try(body, catchPart, finallyPart));
       return;
     }
 
     hasTryBlocks = true;
     int uncaughtLabel = newLabel("uncaught");
-    int handlerLabel = (node.catchPart == null)
-        ? uncaughtLabel
-        : newLabel("catch");
+    int handlerLabel =
+        (node.catchPart == null) ? uncaughtLabel : newLabel("catch");
 
     int finallyLabel = newLabel("finally");
     int afterFinallyLabel = newLabel("after finally");
     if (node.finallyPart != null) {
       finallyLabels[node.finallyPart] = finallyLabel;
       jumpTargets.add(node.finallyPart);
     }
 
     handlerLabels[node] = handlerLabel;
     jumpTargets.add(node);
@@ skipping 30 matching lines @@
       String errorRename = freshName(node.catchPart.declaration.name);
       localVariables.add(new js.VariableDeclaration(errorRename));
       variableRenamings
           .add(new Pair(node.catchPart.declaration.name, errorRename));
       addStatement(js.js.statement("# = #;", [errorRename, currentError]));
       visitStatement(node.catchPart.body);
       variableRenamings.removeLast();
       if (node.finallyPart != null) {
         // The error has been caught, so after the finally, continue after the
         // try.
-        addStatement(
-            js.js.statement("#.push(#);",
-                            [next, js.number(afterFinallyLabel)]));
+        addStatement(js.js
+            .statement("#.push(#);", [next, js.number(afterFinallyLabel)]));
         addGoto(finallyLabel);
       } else {
         addGoto(afterFinallyLabel);
       }
       js.Node last = jumpTargets.removeLast();
       assert(last == node.catchPart);
     }
 
     // The "uncaught"-handler tells the finally-block to continue with
     // the enclosing finally-blocks until the current catch-handler.
     beginLabel(uncaughtLabel);
 
     List<int> enclosingFinallies = _finalliesUpToAndEnclosingHandler();
 
     int nextLabel = enclosingFinallies.removeLast();
     if (enclosingFinallies.isNotEmpty) {
       // [enclosingFinallies] can be empty if there is no surrounding finally
       // blocks. Then [nextLabel] will be [rethrowLabel].
-      addStatement(
-          js.js.statement("# = #;", [next, new js.ArrayInitializer(
-              enclosingFinallies.map(js.number).toList())]));
+      addStatement(js.js.statement("# = #;", [
+        next,
+        new js.ArrayInitializer(enclosingFinallies.map(js.number).toList())
+      ]));
     }
     if (node.finallyPart == null) {
       // The finally-block belonging to [node] will be visited because of
       // fallthrough. If it does not exist, add an explicit goto.
       addGoto(nextLabel);
     }
     if (node.finallyPart != null) {
       js.Node last = jumpTargets.removeLast();
       assert(last == node.finallyPart);
 
@@ skipping 28 matching lines @@
   }
 
   @override
   void visitVariableInitialization(js.VariableInitialization node) {
     unreachable(node);
   }
 
   @override
   js.Expression visitVariableUse(js.VariableUse node) {
     Pair<String, String> renaming = variableRenamings.lastWhere(
-        (Pair renaming) => renaming.a == node.name, orElse: () => null);
+        (Pair renaming) => renaming.a == node.name,
+        orElse: () => null);
     if (renaming == null) return node;
     return new js.VariableUse(renaming.b);
   }
 
   @override
   void visitWhile(js.While node) {
     if (!shouldTransform(node)) {
       bool oldInsideUntranslated = insideUntranslatedBreakable;
       insideUntranslatedBreakable = true;
       withExpression(node.condition, (js.Expression condition) {
@@ skipping 32 matching lines @@
     // Don't do a break here for the goto, but instead a return in either
     // addSynYield or addAsyncYield.
     withExpression(node.expression, (js.Expression expression) {
       addStatement(setGotoVariable(label));
       addYield(node, expression);
     }, store: false);
     beginLabel(label);
   }
 }
 
-js.VariableInitialization
-    _makeVariableInitializer(dynamic variable, js.Expression initValue) {
+js.VariableInitialization _makeVariableInitializer(
+    dynamic variable, js.Expression initValue) {
   js.VariableDeclaration declaration;
   if (variable is js.VariableUse) {
     declaration = new js.VariableDeclaration(variable.name);
   } else if (variable is String) {
     declaration = new js.VariableDeclaration(variable);
   } else {
     assert(variable is js.VariableDeclaration);
     declaration = variable;
   }
   return new js.VariableInitialization(declaration, initValue);
 }
 
 class AsyncRewriter extends AsyncRewriterBase {
-
   bool get isAsync => true;
 
   /// The Completer that will finish an async function.
   ///
   /// Not used for sync* or async* functions.
   String completerName;
   js.VariableUse get completer => new js.VariableUse(completerName);
 
   /// The function called by an async function to simulate an await or return.
   ///
@@ skipping 16 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(DiagnosticReporter reporter,
-                Spannable spannable,
-                {this.asyncHelper,
-                 this.newCompleter,
-                 this.wrapBody,
-                 String safeVariableName(String proposedName),
-                 js.Name bodyName})
-        : super(reporter,
-                spannable,
-                safeVariableName,
-                bodyName);
+  AsyncRewriter(DiagnosticReporter reporter, Spannable spannable,
+      {this.asyncHelper,
+      this.newCompleter,
+      this.wrapBody,
+      String safeVariableName(String proposedName),
+      js.Name bodyName})
+      : super(reporter, spannable, safeVariableName, bodyName);
 
   @override
   void addYield(js.DartYield node, js.Expression expression) {
-    reporter.internalError(spannable,
-        "Yield in non-generating async function");
+    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,
-          "completer": completer}));
+      "thenHelper": asyncHelper,
+      "errorCode": js.number(error_codes.ERROR),
+      "currentError": currentError,
+      "completer": completer
+    }));
   }
 
   /// Returning from an async method calls [asyncStarHelper] with the result.
   /// (the result might have been stored in [returnValue] by some finally
   /// block).
   void addSuccesExit() {
     if (analysis.hasExplicitReturns) {
       beginLabel(exitLabel);
     } else {
       addStatement(new js.Comment("implicit return"));
     }
     addStatement(js.js.statement(
         "return #runtimeHelper(#returnValue, #successCode, "
-            "#completer, null);", {
-         "runtimeHelper": asyncHelper,
-         "successCode": js.number(error_codes.SUCCESS),
-         "returnValue": analysis.hasExplicitReturns
-             ? returnValue
-             : new js.LiteralNull(),
-         "completer": completer}));
+        "#completer, null);",
+        {
+          "runtimeHelper": asyncHelper,
+          "successCode": js.number(error_codes.SUCCESS),
+          "returnValue":
+              analysis.hasExplicitReturns ? returnValue : new js.LiteralNull(),
+          "completer": completer
+        }));
   }
 
   @override
   Iterable<js.VariableInitialization> variableInitializations() {
     List<js.VariableInitialization> variables =
         new List<js.VariableInitialization>();
-    variables.add(_makeVariableInitializer(completer,
-                                        new js.New(newCompleter, [])));
+    variables
+        .add(_makeVariableInitializer(completer, new js.New(newCompleter, [])));
     if (analysis.hasExplicitReturns) {
       variables.add(_makeVariableInitializer(returnValue, null));
     }
     return variables;
   }
 
   @override
   void initializeNames() {
     completerName = freshName("completer");
   }
 
   @override
   js.Statement awaitStatement(js.Expression value) {
-    return js.js.statement("""
+    return js.js.statement(
+        """
           return #asyncHelper(#value,
                               #bodyName,
                               #completer);
-          """, {
-            "asyncHelper": asyncHelper,
-            "value": value,
-            "bodyName": bodyName,
-            "completer": completer});
+          """,
+        {
+          "asyncHelper": asyncHelper,
+          "value": value,
+          "bodyName": bodyName,
+          "completer": completer
+        });
   }
 
   @override
-  js.Fun finishFunction(List<js.Parameter> parameters,
-                        js.Statement rewrittenBody,
-                        js.VariableDeclarationList variableDeclarations) {
-    return js.js("""
+  js.Fun finishFunction(
+      List<js.Parameter> parameters,
+      js.Statement rewrittenBody,
+      js.VariableDeclarationList variableDeclarations) {
+    return js.js(
+        """
         function (#parameters) {
           #variableDeclarations;
           var #bodyName = #wrapBody(function (#errorCode, #result) {
             if (#errorCode === #ERROR) {
                 #currentError = #result;
                 #goto = #handler;
             }
             #rewrittenBody;
           });
           return #asyncHelper(null, #bodyName, #completer, null);
-        }""", {
+        }""",
+        {
           "parameters": parameters,
           "variableDeclarations": variableDeclarations,
           "ERROR": js.number(error_codes.ERROR),
           "rewrittenBody": rewrittenBody,
           "bodyName": bodyName,
           "currentError": currentError,
           "goto": goto,
           "handler": handler,
           "errorCode": errorCodeName,
           "result": resultName,
           "asyncHelper": asyncHelper,
           "completer": completer,
           "wrapBody": wrapBody,
         });
   }
 }
 
 class SyncStarRewriter extends AsyncRewriterBase {
-
   bool get isSyncStar => true;
 
   /// Contructor creating the Iterable for a sync* method. Called with
   /// [bodyName].
   final js.Expression newIterable;
 
   /// A JS Expression that creates a marker showing that iteration is over.
   ///
   /// Called without arguments.
   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(DiagnosticReporter diagnosticListener,
-                spannable,
-                {this.endOfIteration,
-                 this.newIterable,
-                 this.yieldStarExpression,
-                 this.uncaughtErrorExpression,
-                 String safeVariableName(String proposedName),
-                 js.Name bodyName})
-        : super(diagnosticListener,
-                spannable,
-                safeVariableName,
-                bodyName);
+  SyncStarRewriter(DiagnosticReporter diagnosticListener, spannable,
+      {this.endOfIteration,
+      this.newIterable,
+      this.yieldStarExpression,
+      this.uncaughtErrorExpression,
+      String safeVariableName(String proposedName),
+      js.Name bodyName})
+      : super(diagnosticListener, spannable, safeVariableName, bodyName);
 
   /// Translates a yield/yield* in an sync*.
   ///
   /// `yield` in a sync* function just returns [value].
   /// `yield*` wraps [value] in a [yieldStarExpression] and returns it.
   @override
   void addYield(js.DartYield node, js.Expression expression) {
     if (node.hasStar) {
       addStatement(
           new js.Return(new js.Call(yieldStarExpression, [expression])));
     } else {
       addStatement(new js.Return(expression));
     }
   }
 
   @override
-  js.Fun finishFunction(List<js.Parameter> parameters,
-                        js.Statement rewrittenBody,
-                        js.VariableDeclarationList variableDeclarations) {
+  js.Fun finishFunction(
+      List<js.Parameter> parameters,
+      js.Statement rewrittenBody,
+      js.VariableDeclarationList variableDeclarations) {
     // Each iterator invocation on the iterable should work on its own copy of
     // the parameters.
     // TODO(sigurdm): We only need to do this copying for parameters that are
     // mutated.
     List<js.VariableInitialization> declarations =
         new List<js.VariableInitialization>();
     List<js.Parameter> renamedParameters = new List<js.Parameter>();
     for (js.Parameter parameter in parameters) {
       String name = parameter.name;
       String renamedName = freshName(name);
       renamedParameters.add(new js.Parameter(renamedName));
-      declarations.add(
-          new js.VariableInitialization(new js.VariableDeclaration(name),
-                                        new js.VariableUse(renamedName)));
+      declarations.add(new js.VariableInitialization(
+          new js.VariableDeclaration(name), new js.VariableUse(renamedName)));
     }
     js.VariableDeclarationList copyParameters =
         new js.VariableDeclarationList(declarations);
-    return js.js("""
+    return js.js(
+        """
           function (#renamedParameters) {
             if (#needsThis)
               var #self = this;
             return new #newIterable(function () {
               if (#hasParameters) {
                 #copyParameters;
               }
               #varDecl;
               return function #body(#errorCode, #result) {
                 if (#errorCode === #ERROR) {
                     #currentError = #result;
                     #goto = #handler;
                 }
                 #helperBody;
               };
             });
           }
-          """, {
-            "renamedParameters": renamedParameters,
-            "needsThis": analysis.hasThis,
-            "helperBody": rewrittenBody,
-            "hasParameters": parameters.isNotEmpty,
-            "copyParameters": copyParameters,
-            "varDecl": variableDeclarations,
-            "errorCode": errorCodeName,
-            "newIterable": newIterable,
-            "body": bodyName,
-            "self": selfName,
-            "result": resultName,
-            "goto": goto,
-            "handler": handler,
-            "currentError": currentErrorName,
-            "ERROR": js.number(error_codes.ERROR),
-          });
+          """,
+        {
+          "renamedParameters": renamedParameters,
+          "needsThis": analysis.hasThis,
+          "helperBody": rewrittenBody,
+          "hasParameters": parameters.isNotEmpty,
+          "copyParameters": copyParameters,
+          "varDecl": variableDeclarations,
+          "errorCode": errorCodeName,
+          "newIterable": newIterable,
+          "body": bodyName,
+          "self": selfName,
+          "result": resultName,
+          "goto": goto,
+          "handler": handler,
+          "currentError": currentErrorName,
+          "ERROR": js.number(error_codes.ERROR),
+        });
   }
 
   void addErrorExit() {
     beginLabel(rethrowLabel);
-    addStatement(js.js.statement('return #(#);',
-                 [uncaughtErrorExpression, currentError]));
+    addStatement(js.js
+        .statement('return #(#);', [uncaughtErrorExpression, currentError]));
   }
 
   /// Returning from a sync* function returns an [endOfIteration] marker.
   void addSuccesExit() {
     if (analysis.hasExplicitReturns) {
       beginLabel(exitLabel);
     } else {
       addStatement(new js.Comment("implicit return"));
     }
     addStatement(js.js.statement('return #();', [endOfIteration]));
   }
 
   @override
   Iterable<js.VariableInitialization> variableInitializations() {
     List<js.VariableInitialization> variables =
         new List<js.VariableInitialization>();
     return variables;
   }
 
   @override
   js.Statement awaitStatement(js.Expression value) {
-    throw reporter.internalError(spannable,
-        "Sync* functions cannot contain await statements.");
+    throw reporter.internalError(
+        spannable, "Sync* functions cannot contain await statements.");
   }
 
   @override
   void initializeNames() {}
 }
 
 class AsyncStarRewriter extends AsyncRewriterBase {
-
   bool get isAsyncStar => true;
 
   /// The stack of labels of finally blocks to assign to [next] if the
   /// async* [StreamSubscription] was canceled during a yield.
   js.VariableUse get nextWhenCanceled {
     return new js.VariableUse(nextWhenCanceledName);
   }
+
   String nextWhenCanceledName;
 
   /// The StreamController that controls an async* function.
   String controllerName;
   js.VariableUse get controller => new js.VariableUse(controllerName);
 
   /// The function called by an async* function to simulate an await, yield or
   /// yield*.
   ///
   /// For an await/yield/yield* it is called with:
@@ skipping 24 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(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);
-
+  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]
   /// distinguish them.
   /// Also [nextWhenCanceled] is set up to contain the finally blocks that
   /// must be run in case the stream was canceled.
   @override
   void addYield(js.DartYield node, js.Expression expression) {
     // Find all the finally blocks that should be performed if the stream is
     // canceled during the yield.
     // At the bottom of the stack is the return label.
     List<int> enclosingFinallyLabels = <int>[exitLabel];
     enclosingFinallyLabels.addAll(jumpTargets
         .where((js.Node node) => finallyLabels[node] != null)
         .map((js.Block node) => finallyLabels[node]));
-    addStatement(js.js.statement("# = #;",
-        [nextWhenCanceled, new js.ArrayInitializer(
-            enclosingFinallyLabels.map(js.number).toList())]));
-    addStatement(js.js.statement("""
+    addStatement(js.js.statement("# = #;", [
+      nextWhenCanceled,
+      new js.ArrayInitializer(enclosingFinallyLabels.map(js.number).toList())
+    ]));
+    addStatement(js.js.statement(
+        """
         return #asyncStarHelper(#yieldExpression(#expression), #bodyName,
-            #controller);""", {
-      "asyncStarHelper": asyncStarHelper,
-      "yieldExpression": node.hasStar ? yieldStarExpression : yieldExpression,
-      "expression": expression,
-      "bodyName": bodyName,
-      "controller": controllerName,
-    }));
+            #controller);""",
+        {
+          "asyncStarHelper": asyncStarHelper,
+          "yieldExpression":
+              node.hasStar ? yieldStarExpression : yieldExpression,
+          "expression": expression,
+          "bodyName": bodyName,
+          "controller": controllerName,
+        }));
   }
 
   @override
-  js.Fun finishFunction(List<js.Parameter> parameters,
-                        js.Statement rewrittenBody,
-                        js.VariableDeclarationList variableDeclarations) {
-    return js.js("""
+  js.Fun finishFunction(
+      List<js.Parameter> parameters,
+      js.Statement rewrittenBody,
+      js.VariableDeclarationList variableDeclarations) {
+    return js.js(
+        """
         function (#parameters) {
           var #bodyName = #wrapBody(function (#errorCode, #result) {
             if (#hasYield) {
               switch (#errorCode) {
                 case #STREAM_WAS_CANCELED:
                   #next = #nextWhenCanceled;
                   #goto = #next.pop();
                   break;
                 case #ERROR:
                   #currentError = #result;
                   #goto = #handler;
               }
             } else {
               if (#errorCode === #ERROR) {
                 #currentError = #result;
                 #goto = #handler;
               }
             }
             #rewrittenBody;
           });
           #variableDeclarations;
           return #streamOfController(#controller);
-        }""", {
+        }""",
+        {
           "parameters": parameters,
           "variableDeclarations": variableDeclarations,
           "STREAM_WAS_CANCELED": js.number(error_codes.STREAM_WAS_CANCELED),
           "ERROR": js.number(error_codes.ERROR),
           "hasYield": analysis.hasYield,
           "rewrittenBody": rewrittenBody,
           "bodyName": bodyName,
           "currentError": currentError,
           "goto": goto,
           "handler": handler,
           "next": next,
           "nextWhenCanceled": nextWhenCanceled,
           "errorCode": errorCodeName,
           "result": resultName,
           "streamOfController": streamOfController,
           "controller": controllerName,
           "wrapBody": wrapBody,
         });
   }
 
   @override
   void addErrorExit() {
     beginLabel(rethrowLabel);
     addStatement(js.js.statement(
         "return #asyncHelper(#currentError, #errorCode, #controller);", {
-          "asyncHelper": asyncStarHelper,
-          "errorCode": js.number(error_codes.ERROR),
-          "currentError": currentError,
-          "controller": controllerName}));
+      "asyncHelper": asyncStarHelper,
+      "errorCode": js.number(error_codes.ERROR),
+      "currentError": currentError,
+      "controller": controllerName
+    }));
   }
 
   /// Returning from an async* function calls the [streamHelper] with an
   /// [endOfIteration] marker.
   @override
   void addSuccesExit() {
     beginLabel(exitLabel);
 
-    addStatement(js.js.statement(
-      "return #streamHelper(null, #successCode, #controller);", {
+    addStatement(js.js
+        .statement("return #streamHelper(null, #successCode, #controller);", {
       "streamHelper": asyncStarHelper,
       "successCode": js.number(error_codes.SUCCESS),
-      "controller": controllerName}));
+      "controller": controllerName
+    }));
   }
 
   @override
   Iterable<js.VariableInitialization> variableInitializations() {
     List<js.VariableInitialization> variables =
         new List<js.VariableInitialization>();
-    variables.add(_makeVariableInitializer(controller,
-                         js.js('#(#)',
-                               [newController, bodyName])));
+    variables.add(_makeVariableInitializer(
+        controller, js.js('#(#)', [newController, bodyName])));
     if (analysis.hasYield) {
       variables.add(_makeVariableInitializer(nextWhenCanceled, null));
     }
     return variables;
   }
 
   @override
   void initializeNames() {
     controllerName = freshName("controller");
     nextWhenCanceledName = freshName("nextWhenCanceled");
   }
 
   @override
   js.Statement awaitStatement(js.Expression value) {
-    return js.js.statement("""
+    return js.js.statement(
+        """
           return #asyncHelper(#value,
                               #bodyName,
                               #controller);
-          """, {
-            "asyncHelper": asyncStarHelper,
-            "value": value,
-            "bodyName": bodyName,
-            "controller": controllerName});
+          """,
+        {
+          "asyncHelper": asyncStarHelper,
+          "value": value,
+          "bodyName": bodyName,
+          "controller": controllerName
+        });
   }
 }
 
 /// Finds out
 ///
 /// - which expressions have yield or await nested in them.
 /// - targets of jumps
 /// - a set of used names.
 /// - if any [This]-expressions are used.
 class PreTranslationAnalysis extends js.NodeVisitor<bool> {
@@ skipping 81 matching lines @@
     bool containsAwait = false;
     for (js.Statement statement in node.statements) {
       if (visit(statement)) containsAwait = true;
     }
     return containsAwait;
   }
 
   @override
   bool visitBreak(js.Break node) {
     if (node.targetLabel != null) {
-      targets[node] = labelledStatements.lastWhere(
-          (js.LabeledStatement statement) {
+      targets[node] =
+          labelledStatements.lastWhere((js.LabeledStatement statement) {
         return statement.label == node.targetLabel;
       });
     } else {
       targets[node] = loopsAndSwitches.last;
     }
     return false;
   }
 
   @override
   bool visitCall(js.Call node) {
@@ skipping 334 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }