// 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;

// TODO(sigurdm): Throws in catch-handlers are handled wrong.
// TODO(sigurdm): Avoid using variables in templates. It could blow up memory
// use.

import "dart:math" show max;
import 'dart:collection';

import "js.dart" as js;

import '../util/util.dart';
import '../dart2jslib.dart' show DiagnosticListener;

import "../helpers/helpers.dart";

/// 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 [visitFun], [visitDartYield] and [visitAwait] for more explanation.
class AsyncRewriter 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>();
  Map<js.Node, int> finallyLabels = new Map<js.Node, int>();
  int exitLabel;

  // A stack of all enclosing jump targets (including the function for
  // representing the target of a return, and all enclosing try-blocks that have
  // finally part, this way ensuring all the finally blocks between a jump and
  // its target are run before the jump.
  List<js.Node> targetsAndTries = new List<js.Node>();

  List<int> continueStack = new List<int>();
  List<int> breakStack = new List<int>();
  List<int> returnStack = new List<int>();

  List<Pair<String, String>> variableRenamings =
      new List<Pair<String, String>>();

  PreTranslationAnalysis analysis;

  List<int> errorHandlerLabels = new List<int>();

  final Function safeVariableName;

  // All the <x>Name variables are names of Javascript variables used in the
  // transformed code.

  /// Contains the result of an awaited expression, or a conditional or
  /// lazy boolean operator.
  ///
  /// For example a conditional expression is roughly translated like:
  /// [[cond ? a : b]]
  ///
  /// Becomes:
  ///
  /// while true { // outer while loop
  ///   switch (goto) { // Simulates goto
  ///     ...
  ///       goto = [[cond]] ? thenLabel : elseLabel
  ///       break;
  ///     case thenLabel:
  ///       result = [[a]];
  ///       goto = joinLabel;
  ///     case elseLabel:
  ///       result = [[b]];
  ///     case joinLabel:
  ///       // Now the result of computing the condition is in result.
  ///     ....
  ///   }
  /// }
  ///
  /// It is a parameter to the [helperName] function, so that [thenHelper] and
  /// [streamHelper] can call [helperName] with the result of an awaited Future.
  String resultName;

  /// The name of the inner function that is scheduled to do each await/yield,
  /// and called to do a new iteration for sync*.
  String helperName;

  /// The Completer that will finish an async function.
  ///
  /// Not used for sync* or async* functions.
  String completerName;

  /// The StreamController that controls an async* function.
  ///
  /// Not used for async and sync* functions
  String controllerName;

  /// Used to simulate a goto.
  ///
  /// To "goto" a label, the label is assigned to this
  /// variable, and break out of the switch to take another iteration in the
  /// while loop. See [addGoto]
  String gotoName;

  /// The label of the current error handler.
  String handlerName;

  /// Current caught error.
  String errorName;

  /// A stack of labels of finally blocks to visit, and the label to go to after
  /// the last.
  String nextName;

  /// The current returned value (a finally block may overwrite it).
  String returnValueName;

  /// The label of the outer loop.
  ///
  /// 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
  /// [helperName] function.
  String selfName;

  // These expressions are hooks for communicating with the runtime.

  /// The function called by an async function to simulate an await or return.
  ///
  /// For an await it is called with:
  ///
  /// - The value to await
  /// - The [helperName]
  /// - The [completerName]
  /// - A JavaScript function that is executed if the future completed with
  ///   an error. That function is responsible for executing the right error
  ///   handler and/or finally blocks).
  ///
  /// For a return it is called with:
  ///
  /// - The value to complete the completer with.
  /// - null
  /// - The [completerName]
  /// - null.
  final js.Expression thenHelper;

  /// The function called by an async* function to simulate an await, yield or
  /// yield*.
  ///
  /// For an await/yield/yield* it is called with:
  ///
  /// - The value to await/yieldExpression(value to yield)/
  /// yieldStarExpression(stream to yield)
  /// - The [helperName]
  /// - The [controllerName]
  /// - A JavaScript function that is executed if the future completed with
  ///   an error. That function is responsible for executing the right error
  ///   handler and/or finally blocks).
  ///
  /// For a return it is called with:
  ///
  /// - null
  /// - null
  /// - The [controllerName]
  /// - null.
  final js.Expression streamHelper;

  /// Contructor used to initialize the [completerName] variable.
  ///
  /// Specific to async methods.
  final js.Expression newCompleter;

  /// Contructor used to initialize the [controllerName] variable.
  ///
  /// Specific to async* methods.
  final js.Expression newController;

  /// Used to get the `Stream` out of the [controllerName] variable.
  ///
  /// Specific to async* methods.
  final js.Expression streamOfController;

  /// Contructor creating the Iterable for a sync* method. Called with
  /// [helperName].
  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 indicating a 'yield' statement.
  ///
  /// 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 DiagnosticListener diagnosticListener;
  // 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>();

  js.AsyncModifier async;

  bool get isSync => async == const js.AsyncModifier.sync();
  bool get isAsync => async == const js.AsyncModifier.async();
  bool get isSyncStar => async == const js.AsyncModifier.syncStar();
  bool get isAsyncStar => async == const js.AsyncModifier.asyncStar();

  AsyncRewriter(this.diagnosticListener,
                spannable,
                {this.thenHelper,
                 this.streamHelper,
                 this.streamOfController,
                 this.newCompleter,
                 this.newController,
                 this.endOfIteration,
                 this.newIterable,
                 this.yieldExpression,
                 this.yieldStarExpression,
                 this.safeVariableName})
      : _spannable = spannable;

  /// 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;

    async = node.asyncModifier;
    assert(!isSync);

    analysis = new PreTranslationAnalysis(unsupported);
    analysis.analyze(node);

    // To avoid name collisions with existing names, the fresh names are
    // generated after the analysis.
    resultName = freshName("result");
    completerName = freshName("completer");
    controllerName = freshName("controller");
    helperName = freshName("helper");
    gotoName = freshName("goto");
    handlerName = freshName("handler");
    errorName = freshName("error");
    nextName = freshName("next");
    returnValueName = freshName("returnValue");
    outerLabelName = freshName("outer");
    selfName = freshName("self");

    return node.accept(this);
  }

  js.Expression get currentErrorHandler {
    return errorHandlerLabels.isEmpty
        ? new js.LiteralNull()
        : js.number(errorHandlerLabels.last);
  }

  int allocateTempVar() {
    assert(tempVarHighWaterMark >= currentTempVarIndex);
    currentTempVarIndex++;
    tempVarHighWaterMark = max(currentTempVarIndex, tempVarHighWaterMark);
    return currentTempVarIndex;
  }

  js.VariableUse useTempVar(int i) {
    return tempVarNames.putIfAbsent(
        i, () => new js.VariableUse(freshName("temp$i")));
  }

  /// Generates a variable name with [safeVariableName] based on [originalName]
  /// with a suffix to guarantee it does not collide with already used names.
  String freshName(String originalName) {
    String safeName = safeVariableName(originalName);
    String result = safeName;
    int counter = 1;
    while (analysis.usedNames.contains(result)) {
      result = "$safeName$counter";
      ++counter;
    }
    analysis.usedNames.add(result);
    return result;
  }

  /// All the pieces are collected in this map, to create a switch with a case
  /// for each label.
  ///
  /// The order is important, therefore the type is explicitly LinkedHashMap.
  LinkedHashMap<int, List<js.Statement>> labelledParts =
      new LinkedHashMap<int, List<js.Statement>>();

  /// Description of each label for readability of the non-minified output.
  Map<int, String> labelComments = new Map<int, String>();

  /// True if the function has any try blocks containing await.
  bool hasTryBlocks = false;

  /// True if any return, break or continue passes through a finally.
  bool hasJumpThroughFinally = false;

  /// True if the traversion currently is inside a loop or switch for which
  /// [shouldTransform] is false.
  bool insideUntranslatedBreakable = false;

  /// True if a label is used to break to an outer switch-statement.
  bool hasJumpThoughOuterLabel = false;

  /// True if there is a catch-handler protected by a finally with no enclosing
  /// catch-handlers.
  bool needsRethrow = false;

  /// Buffer for collecting translated statements belonging to the same switch
  /// case.
  List<js.Statement> currentStatementBuffer;

  // Labels will become cases in the big switch expression, and `goto label`
  // is expressed by assigning to the switch key [gotoName] and breaking out of
  // the switch.

  int newLabel([String comment]) {
    int result = _currentLabel;
    _currentLabel++;
    if (comment != null) {
      labelComments[result] = comment;
    }
    return result;
  }

  /// Begins outputting statements to a new buffer with label [label].
  ///
  /// Each buffer ends up as its own case part in the big state-switch.
  void beginLabel(int label) {
    assert(!labelledParts.containsKey(label));
    currentStatementBuffer = new List<js.Statement>();
    labelledParts[label] = currentStatementBuffer;
    addStatement(new js.Comment(labelComments[label]));
  }

  /// Returns a statement assigning to the variable named [gotoName].
  /// This should be followed by a break for the goto to be executed. Use
  /// [gotoWithBreak] or [addGoto] for this.
  js.Statement setGotoVariable(int label) {
    return new js.ExpressionStatement(
        new js.Assignment(new js.VariableUse(gotoName), js.number(label)));
  }

  /// Returns a block that has a goto to [label] including the break.
  ///
  /// Also inserts a comment describing the label if available.
  js.Block gotoAndBreak(int label) {
    List<js.Statement> statements = new List<js.Statement>();
    if (labelComments.containsKey(label)) {
      statements.add(new js.Comment("goto ${labelComments[label]}"));
    }
    statements.add(setGotoVariable(label));
    if (insideUntranslatedBreakable) {
      hasJumpThoughOuterLabel = true;
      statements.add(new js.Break(outerLabelName));
    } else {
      statements.add(new js.Break(null));
    }
    return new js.Block(statements);
  }

  /// Adds a goto to [label] including the break.
  ///
  /// Also inserts a comment describing the label if available.
  void addGoto(int label) {
    if (labelComments.containsKey(label)) {
      addStatement(new js.Comment("goto ${labelComments[label]}"));
    }
    addStatement(setGotoVariable(label));

    addBreak();
  }

  void addStatement(js.Statement node) {
    currentStatementBuffer.add(node);
  }

  void addExpressionStatement(js.Expression node) {
    addStatement(new js.ExpressionStatement(node));
  }

  /// True if there is an await or yield in [node] or some subexpression.
  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(
        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
  /// statements, and these statements could affect the value of node1.
  ///
  /// For example:
  ///
  /// - _storeIfNecessary(someLiteral) returns someLiteral.
  /// - _storeIfNecessary(someVariable)
  ///   inserts: var tempX = someVariable
  ///   returns: tempX
  ///   where tempX is a fresh temporary variable.
  js.Expression _storeIfNecessary(js.Expression result) {
    // Note that RegExes, js.ArrayInitializer and js.ObjectInitializer are not
    // [js.Literal]s.
    if (result is js.Literal) return result;
    js.Expression tempVar = useTempVar(allocateTempVar());
    addExpressionStatement(new js.Assignment(tempVar, result));
    return tempVar;
  }

  withExpression(js.Expression node, fn(js.Expression result), {bool store}) {
    int oldTempVarIndex = currentTempVarIndex;
    js.Expression visited = visitExpression(node);
    if (store) {
      visited = _storeIfNecessary(visited);
    }
    var result = fn(visited);
    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,
      fn(js.Expression result1, js.Expression result2)) {
    int oldTempVarIndex = currentTempVarIndex;
    js.Expression r1 = visitExpression(node1);
    if (shouldTransform(node2)) {
      r1 = _storeIfNecessary(r1);
    }
    js.Expression r2 = visitExpression(node2);
    var result = fn(r1, r2);
    currentTempVarIndex = oldTempVarIndex;
    return result;
  }

  /// Calls [fn] with the value of evaluating all [nodes].
  ///
  /// All results before the last node where `shouldTransform(node)` are stored
  /// in temporary variables.
  ///
  /// See more explanation on [withExpression2].
  ///
  /// If any of the nodes are null, they are ignored, and a null is passed to
  /// [fn] in that place.
  withExpressions(List<js.Expression> nodes, fn(List<js.Expression> results)) {
    int oldTempVarIndex = currentTempVarIndex;
    // Find last occurence of a 'transform' expression in [nodes].
    // All expressions before that must be stored in temp-vars.
    int lastTransformIndex = 0;
    for (int i = nodes.length - 1; i >= 0; --i) {
      if (nodes[i] == null) continue;
      if (shouldTransform(nodes[i])) {
        lastTransformIndex = i;
        break;
      }
    }
    List<js.Node> visited = nodes.take(lastTransformIndex).map((js.Node node) {
      return node == null ? null : _storeIfNecessary(visitExpression(node));
    }).toList();
    visited.addAll(nodes.skip(lastTransformIndex).map((js.Node node) {
      return node == null ? null : visitExpression(node);
    }));
    var result = fn(visited);
    currentTempVarIndex = oldTempVarIndex;
    return result;
  }

  /// Emits the return block that all returns should jump to (after going
  /// through all the enclosing finally blocks). The jump to here is made in
  /// [visitReturn].
  ///
  /// Returning from an async method calls the [thenHelper] with the result.
  /// (the result might have been stored in [returnValueName] by some finally
  /// block).
  ///
  /// Returning from a sync* function returns an [endOfIteration] marker.
  ///
  /// Returning from an async* function calls the [streamHelper] with an
  /// [endOfIteration] marker.
  void addExit() {
    if (analysis.hasExplicitReturns || isAsyncStar) {
      beginLabel(exitLabel);
    } else {
      addStatement(new js.Comment("implicit return"));
    }
    switch (async) {
      case const js.AsyncModifier.async():
        String returnValue =
            analysis.hasExplicitReturns ? returnValueName : "null";
        addStatement(js.js.statement(
            "return #thenHelper($returnValue, null, $completerName, null)", {
          "thenHelper": thenHelper
        }));
        break;
      case const js.AsyncModifier.syncStar():
        addStatement(new js.Return(new js.Call(endOfIteration, [])));
        break;
      case const js.AsyncModifier.asyncStar():
        addStatement(js.js.statement(
            "return #streamHelper(null, null, $controllerName, null)", {
          "streamHelper": streamHelper
        }));
        break;
      default:
        diagnosticListener.internalError(
            spannable, "Internal error, unexpected asyncmodifier $async");
    }
  }

  /// The initial call to [thenHelper]/[streamHelper].
  ///
  /// There is no value to await/yield, so the first argument is `null` and
  /// also the errorCallback is `null`.
  ///
  /// Returns the [Future]/[Stream] coming from [completerName]/
  /// [controllerName].
  js.Statement generateInitializer() {
    if (isAsync) {
      return js.js.statement(
          "return #thenHelper(null, $helperName, $completerName, null);", {
        "thenHelper": thenHelper
      });
    } else if (isAsyncStar) {
      return js.js.statement(
          "return #streamOfController($controllerName);", {
        "streamOfController": streamOfController
      });
    } else {
      throw diagnosticListener.internalError(
          spannable, "Unexpected asyncModifier: $async");
    }
  }

  /// 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 [gotoName] inside a helper-function that can be
  /// called back by [thenHelper]/[streamHelper]/the [Iterator].
  ///
  /// Local variables are hoisted outside the helper.
  ///
  /// Awaits in async/async* are translated to code that remembers the current
  /// location (so the function can resume from where it was) followed by a call
  /// to the [thenHelper]. The helper sets up the waiting for the awaited value
  /// and returns a future which is immediately returned by the translated
  /// await.
  /// Yields in async* are translated to a call to the [streamHelper]. They,
  /// too, need to be prepared to be interrupted in case the stream is paused or
  /// canceled. (Currently we always suspend - this is different from the spec,
  /// see `streamHelper` in `js_helper.dart`).
  ///
  /// Yield/yield* in a sync* function is translated to a return of the value,
  /// wrapped into a "IterationMarker" that signals the type (yield or yield*).
  /// Sync* functions are executed on demand (when the user requests a value) by
  /// the Iterable that knows how to handle these values.
  ///
  /// Simplified examples (not the exact translation, but intended to show the
  /// ideas):
  ///
  /// function (x, y, z) async {
  ///   var p = await foo();
  ///   return bar(p);
  /// }
  ///
  /// Becomes:
  ///
  /// function(x, y, z) {
  ///   var goto = 0, returnValue, completer = new Completer(), p;
  ///   function helper(result) {
  ///     while (true) {
  ///       switch (goto) {
  ///         case 0:
  ///           goto = 1 // Remember where to continue when the future succeeds.
  ///           return thenHelper(foo(), helper, completer, null);
  ///         case 1:
  ///           p = result;
  ///           returnValue = bar(p);
  ///           goto = 2;
  ///           break;
  ///         case 2:
  ///           return thenHelper(returnValue, null, completer, null)
  ///       }
  ///     }
  ///     return thenHelper(null, helper, completer, null);
  ///   }
  /// }
  ///
  /// Try/catch is implemented by maintaining [handlerName] to contain the label
  /// of the current handler. The switch is nested inside a try/catch that will
  /// redirect the flow to the current handler.
  ///
  /// A `finally` clause is compiled similar to normal code, with the additional
  /// complexity that `finally` clauses need to know where to jump to after the
  /// clause is done. In the translation, each flow-path that enters a `finally`
  /// sets up the variable [nextName] with a stack of finally-blocks and a final
  /// jump-target (exit, catch, ...).
  ///
  /// function (x, y, z) async {
  ///   try {
  ///     try {
  ///       throw "error";
  ///     } finally {
  ///       finalize1();
  ///     }
  ///   } catch (e) {
  ///     handle(e);
  ///   } finally {
  ///     finalize2();
  ///   }
  /// }
  ///
  /// Translates into (besides the fact that structures not containing
  /// await/yield/yield* are left intact):
  ///
  /// function(x, y, z) {
  ///   var goto = 0;
  ///   var returnValue;
  ///   var completer = new Completer();
  ///   var handler = null;
  ///   var p;
  ///   // The result can be either the result of an awaited future, or an
  ///   // error if the future completed with an error.
  ///   function helper(result) {
  ///     while (true) {
  ///       try {
  ///         switch (goto) {
  ///           case 0:
  ///             handler = 4; // The outer catch-handler
  ///             handler = 1; // The inner (implicit) catch-handler
  ///             throw "error";
  ///             next = [3];
  ///             // After the finally (2) continue normally after the try.
  ///             goto = 2;
  ///             break;
  ///           case 1: // (implicit) catch handler for inner try.
  ///             next = [3]; // destination after the finally.
  ///             // fall-though to the finally handler.
  ///           case 2: // finally for inner try
  ///             handler = 4; // catch-handler for outer try.
  ///             finalize1();
  ///             goto = next.pop();
  ///             break;
  ///           case 3: // exiting inner try.
  ///             next = [6];
  ///             goto = 5; // finally handler for outer try.
  ///             break;
  ///           case 4: // catch handler for outer try.
  ///             e = result;
  ///             handle(e);
  ///             // Fall through to finally.
  ///           case 5: // finally handler for outer try.
  ///             handler = null;
  ///             finalize2();
  ///             goto = next.pop();
  ///             break;
  ///           case 6: // Exiting outer try.
  ///           case 7: // return
  ///             return thenHelper(returnValue, null, completer, null);
  ///         }
  ///       } catch (error) {
  ///         result = error;
  ///         goto = handler;
  ///       }
  ///     }
  ///     return thenHelper(null, helper, completer, null);
  ///   }
  /// }
  ///
  @override
  js.Expression visitFun(js.Fun node) {
    if (isSync) return node;

    beginLabel(newLabel("Function start"));
    // AsyncStar needs a returnlabel for its handling of cancelation. See
    // [visitDartYield].
    exitLabel =
        analysis.hasExplicitReturns || isAsyncStar ? newLabel("return") : null;
    js.Statement body = node.body;
    targetsAndTries.add(node);
    visitStatement(body);
    targetsAndTries.removeLast();
    addExit();

    List<js.SwitchClause> clauses = labelledParts.keys.map((label) {
      return new js.Case(js.number(label), new js.Block(labelledParts[label]));
    }).toList();
    js.Statement helperBody =
        new js.Switch(new js.VariableUse(gotoName), clauses);
    if (hasJumpThoughOuterLabel) {
      helperBody = js.js.statement("$outerLabelName: #", [helperBody]);
    }
    if (hasTryBlocks) {
      helperBody = js.js.statement("""
          try {
            #body
          } catch ($errorName){
            if ($handlerName === null)
              throw $errorName;
            $resultName = $errorName;
            $gotoName = $handlerName;
          }""", {"body": helperBody});
    }
    List<js.VariableInitialization> inits = <js.VariableInitialization>[];

    js.VariableInitialization makeInit(String name, js.Expression initValue) {
      return new js.VariableInitialization(
          new js.VariableDeclaration(name), initValue);
    }

    inits.add(makeInit(gotoName, js.number(0)));
    if (isAsync) {
      inits.add(makeInit(completerName, new js.New(newCompleter, [])));
    } else if (isAsyncStar) {
      inits.add(makeInit(controllerName,
          new js.Call(newController, [new js.VariableUse(helperName)])));
    }
    if (hasTryBlocks) {
      inits.add(makeInit(handlerName, new js.LiteralNull()));
    }
    if (hasJumpThroughFinally) {
      inits.add(makeInit(nextName, null));
    }
    if (analysis.hasExplicitReturns && isAsync) {
      inits.add(makeInit(returnValueName, null));
    }
    if (analysis.hasThis && !isSyncStar) {
      // Sync* functions must remember `this` on the level of the outer
      // function.
      inits.add(makeInit(selfName, new js.This()));
    }
    inits.addAll(localVariables.map((js.VariableDeclaration decl) {
      return new js.VariableInitialization(decl, null);
    }));
    inits.addAll(new Iterable.generate(tempVarHighWaterMark,
        (int i) => makeInit(useTempVar(i + 1).name, null)));
    js.VariableDeclarationList varDecl = new js.VariableDeclarationList(inits);
    if (isSyncStar) {
      return js.js("""
          function (#params) {
            if (#needsThis)
              var $selfName = this;
            return new #newIterable(function () {
              #varDecl;
              return function $helperName($resultName) {
                while (true)
                  #helperBody;
              };
            });
          }
          """, {
        "params": node.params,
        "needsThis": analysis.hasThis,
        "helperBody": helperBody,
        "varDecl": varDecl,
        "newIterable": newIterable
      });
    }
    return js.js("""
        function (#params) {
          #varDecl;
          function $helperName($resultName) {
            while (true)
              #helperBody;
          }
          #init;
        }""", {
      "params": node.params,
      "helperBody": helperBody,
      "varDecl": varDecl,
      "init": generateInitializer()
    });
  }

  @override
  js.Expression visitAccess(js.PropertyAccess node) {
    return withExpression2(node.receiver, node.selector,
        (receiver, selector) => new js.PropertyAccess(receiver, selector));
  }

  @override
  js.Expression visitArrayHole(js.ArrayHole node) {
    return node;
  }

  @override
  js.Expression visitArrayInitializer(js.ArrayInitializer node) {
    return withExpressions(node.elements, (elements) {
      return new js.ArrayInitializer(elements);
    });
  }

  @override
  js.Expression visitAssignment(js.Assignment node) {
    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) {
        return new js.Assignment(leftHandSide, value);
      }, store: false);
    } else if (leftHandSide is js.PropertyAccess) {
      return withExpressions([
        leftHandSide.receiver,
        leftHandSide.selector,
        node.value
      ], (evaluated) {
        return new js.Assignment.compound(
            new js.PropertyAccess(evaluated[0], evaluated[1]), node.op,
            evaluated[2]);
      });
    } else {
      throw "Unexpected assignment left hand side $leftHandSide";
    }
  }

  /// An await is translated to a call to [thenHelper]/[streamHelper].
  ///
  /// See the comments of [visitFun] for an example.
  @override
  js.Expression visitAwait(js.Await node) {
    assert(isAsync || isAsyncStar);
    int afterAwait = newLabel("returning from await.");
    withExpression(node.expression, (js.Expression value) {
      addStatement(setGotoVariable(afterAwait));
      js.Expression errorCallback = errorHandlerLabels.isEmpty
          ? new js.LiteralNull()
          : js.js("""
            function($errorName) {
              $gotoName = #currentHandler;
              $helperName($errorName);
            }""", {"currentHandler": currentErrorHandler});

      addStatement(js.js.statement("""
          return #thenHelper(#value,
                             $helperName,
                             ${isAsync ? completerName : controllerName},
                             #errorCallback);
          """, {
        "thenHelper": isAsync ? thenHelper : streamHelper,
        "value": value,
        "errorCallback": errorCallback
      }));
    }, store: false);
    beginLabel(afterAwait);
    return new js.VariableUse(resultName);
  }

  /// Checks if [node] is the variable named [resultName].
  ///
  /// [resultName] is used to hold the result of a transformed computation
  /// for example the result of awaiting, or the result of a conditional or
  /// short-circuiting expression.
  /// If the subexpression of some transformed node already is transformed and
  /// visiting it returns [resultName], it is not redundantly assigned to itself
  /// again.
  bool isResult(js.Expression node) {
    return node is js.VariableUse && node.name == resultName;
  }

  @override
  js.Expression visitBinary(js.Binary node) {
    if (shouldTransform(node.right) && (node.op == "||" || node.op == "&&")) {
      int thenLabel = newLabel("then");
      int joinLabel = newLabel("join");
      withExpression(node.left, (js.Expression left) {
        js.Statement assignLeft = isResult(left)
            ? new js.Block.empty()
            : new js.ExpressionStatement(
                new js.Assignment(new js.VariableUse(resultName), left));
        if (node.op == "||") {
          addStatement(new js.If(left, gotoAndBreak(thenLabel), assignLeft));
        } else {
          assert(node.op == "&&");
          addStatement(new js.If(left, assignLeft, gotoAndBreak(thenLabel)));
        }
      }, store: true);
      addGoto(joinLabel);
      beginLabel(thenLabel);
      withExpression(node.right, (js.Expression value) {
        if (!isResult(value)) {
          addExpressionStatement(
              new js.Assignment(new js.VariableUse(resultName), value));
        }
      }, store: false);
      beginLabel(joinLabel);
      return new js.VariableUse(resultName);
    }

    return withExpression2(node.left, node.right,
        (left, right) => new js.Binary(node.op, left, right));
  }

  @override
  js.Expression visitBlob(js.Blob node) {
    return node;
  }

  @override
  void visitBlock(js.Block node) {
    for (js.Statement statement in node.statements) {
      visitStatement(statement);
    }
  }

  @override
  void visitBreak(js.Break node) {
    js.Node target = analysis.targets[node];
    if (!shouldTransform(target)) {
      addStatement(node);
      return;
    }
    translateJump(target, breakLabels[target]);
  }

  @override
  js.Expression visitCall(js.Call node) {
    bool storeTarget = node.arguments.any(shouldTransform);
    return withExpression(node.target, (target) {
      return withExpressions(node.arguments, (List<js.Expression> arguments) {
        return new js.Call(target, arguments);
      });
    }, store: storeTarget);
  }

  @override
  void visitCase(js.Case node) {
    return unreachable(node);
  }

  @override
  void visitCatch(js.Catch node) {
    return unreachable(node);
  }

  @override
  void visitComment(js.Comment node) {
    addStatement(node);
  }

  @override
  js.Expression visitConditional(js.Conditional node) {
    if (!shouldTransform(node.then) && !shouldTransform(node.otherwise)) {
      return withExpression(node.condition, (js.Expression condition) {
        return new js.Conditional(condition, node.then, node.otherwise);
      });
    }
    int thenLabel = newLabel("then");
    int joinLabel = newLabel("join");
    int elseLabel = newLabel("else");
    withExpression(node.condition, (js.Expression condition) {
      addExpressionStatement(new js.Assignment(new js.VariableUse(gotoName),
          new js.Conditional(
              condition, js.number(thenLabel), js.number(elseLabel))));
    }, store: false);
    addBreak();
    beginLabel(thenLabel);
    withExpression(node.then, (js.Expression value) {
      if (!isResult(value)) {
        addExpressionStatement(
            new js.Assignment(new js.VariableUse(resultName), value));
      }
    }, store: false);
    addGoto(joinLabel);
    beginLabel(elseLabel);
    withExpression(node.otherwise, (js.Expression value) {
      if (!isResult(value)) {
        addExpressionStatement(
            new js.Assignment(new js.VariableUse(resultName), value));
      }
    }, store: false);
    beginLabel(joinLabel);
    return new js.VariableUse(resultName);
  }

  @override
  void visitContinue(js.Continue node) {
    js.Node target = analysis.targets[node];
    if (!shouldTransform(target)) {
      addStatement(node);
      return;
    }
    translateJump(target, continueLabels[target]);
  }

  /// Emits a break statement that exits the big switch statement.
  void addBreak() {
    if (insideUntranslatedBreakable) {
      hasJumpThoughOuterLabel = true;
      addStatement(new js.Break(outerLabelName));
    } else {
      addStatement(new js.Break(null));
    }
  }

  /// Common code for handling break, continue, return.
  ///
  /// It is necessary to run all nesting finally-handlers between the jump and
  /// the target. For that [nextName] is used as a stack of places to go.
  ///
  /// See also [visitFun].
  void translateJump(js.Node target, int targetLabel) {
    // Compute a stack of all the 'finally' nodes that must be visited before
    // the jump.
    // The bottom of the stack is the label where the jump goes to.
    List<int> jumpStack = new List<int>();
    for (js.Node node in targetsAndTries.reversed) {
      if (node is js.Try) {
        assert(node.finallyPart != null);
        jumpStack.add(finallyLabels[node]);
      } else if (node == target) {
        jumpStack.add(targetLabel);
        break;
      }
      // Ignore other nodes.
    }
    jumpStack = jumpStack.reversed.toList();
    // As the program jumps directly to the top of the stack, it is taken off
    // now.
    int firstTarget = jumpStack.removeLast();
    if (jumpStack.isNotEmpty) {
      hasJumpThroughFinally = true;
      js.Expression jsJumpStack = new js.ArrayInitializer(
          jumpStack.map((int label) => js.number(label)).toList());
      addStatement(js.js.statement("$nextName = #", [jsJumpStack]));
    }
    addGoto(firstTarget);
  }

  @override
  void visitDefault(js.Default node) => unreachable(node);

  @override
  void visitDo(js.Do node) {
    if (!shouldTransform(node)) {
      bool oldInsideUntranslatedBreakable = insideUntranslatedBreakable;
      insideUntranslatedBreakable = true;
      withExpression(node.condition, (js.Expression condition) {
        addStatement(new js.Do(translateInBlock(node.body), condition));
      }, store: false);
      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);

    targetsAndTries.add(node);
    visitStatement(node.body);
    targetsAndTries.removeLast();

    beginLabel(continueLabel);
    withExpression(node.condition, (js.Expression condition) {
      addStatement(new js.If.noElse(condition, gotoAndBreak(startLabel)));
    }, store: false);
    beginLabel(afterLabel);
  }

  @override
  void visitEmptyStatement(js.EmptyStatement node) {
    addStatement(node);
  }

  void visitExpressionInStatementContext(js.Expression node) {
    if (node is js.VariableDeclarationList) {
      // Treat js.VariableDeclarationList as a statement.
      visitVariableDeclarationList(node);
    } else {
      visitExpressionIgnoreResult(node);
    }
  }

  @override
  void visitExpressionStatement(js.ExpressionStatement node) {
    visitExpressionInStatementContext(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) {
        addStatement(new js.For(transformed[0], transformed[1], transformed[2],
            translateInBlock(node.body)));
      });
      insideUntranslatedBreakable = oldInsideUntranslated;
      return;
    }

    if (node.init != null) {
      visitExpressionInStatementContext(node.init);
    }
    int startLabel = newLabel("for condition");
    // If there is no update, continuing the loop is the same as going to the
    // start.
    int continueLabel =
        (node.update == null) ? startLabel : newLabel("for update");
    continueLabels[node] = continueLabel;
    int afterLabel = newLabel("after for");
    breakLabels[node] = afterLabel;
    beginLabel(startLabel);
    js.Expression condition = node.condition;
    if (condition == null ||
        (condition is js.LiteralBool && condition.value == true)) {
      addStatement(new js.Comment("trivial condition"));
    } else {
      withExpression(condition, (js.Expression condition) {
        addStatement(new js.If.noElse(
            new js.Prefix("!", condition), gotoAndBreak(afterLabel)));
      }, store: false);
    }
    targetsAndTries.add(node);
    visitStatement(node.body);
    targetsAndTries.removeLast();
    if (node.update != null) {
      beginLabel(continueLabel);
      visitExpressionIgnoreResult(node.update);
    }
    addGoto(startLabel);
    beginLabel(afterLabel);
  }

  @override
  void visitForIn(js.ForIn node) {
    // The dart output currently never uses for-in loops.
    throw "Javascript for-in not implemented yet in the await transformation";
  }

  @override
  void visitFunctionDeclaration(js.FunctionDeclaration node) {
    unsupported(node);
  }

  // Only used for code where `!shouldTransform(node)`.
  js.Block translateInBlock(js.Statement node) {
    assert(!shouldTransform(node));
    List<js.Statement> oldBuffer = currentStatementBuffer;
    currentStatementBuffer = new List();
    List<js.Statement> resultBuffer = currentStatementBuffer;
    visitStatement(node);
    currentStatementBuffer = oldBuffer;
    return new js.Block(resultBuffer);
  }

  @override
  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");

    withExpression(node.condition, (js.Expression condition) {
      addExpressionStatement(
          new js.Assignment(
              new js.VariableUse(gotoName),
              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);
  }

  @override
  visitInterpolatedExpression(js.InterpolatedExpression node) {
    return unsupported(node);
  }

  @override
  visitInterpolatedLiteral(js.InterpolatedLiteral node) => unsupported(node);

  @override
  visitInterpolatedParameter(js.InterpolatedParameter node) {
    return unsupported(node);
  }

  @override
  visitInterpolatedSelector(js.InterpolatedSelector node) {
    return unsupported(node);
  }

  @override
  visitInterpolatedStatement(js.InterpolatedStatement node) {
    return unsupported(node);
  }

  @override
  void visitLabeledStatement(js.LabeledStatement node) {
    if (!shouldTransform(node)) {
      addStatement(
          new js.LabeledStatement(node.label, translateInBlock(node.body)));
      return;
    }
    int breakLabel = newLabel("break ${node.label}");
    int continueLabel = newLabel("continue ${node.label}");
    breakLabels[node] = breakLabel;
    continueLabels[node] = continueLabel;

    beginLabel(continueLabel);
    targetsAndTries.add(node);
    visitStatement(node.body);
    targetsAndTries.removeLast();
    beginLabel(breakLabel);
  }

  @override
  js.Expression visitLiteralBool(js.LiteralBool node) => node;

  @override
  visitLiteralExpression(js.LiteralExpression node) => unsupported(node);

  @override
  js.Expression visitLiteralNull(js.LiteralNull node) => node;

  @override
  js.Expression visitLiteralNumber(js.LiteralNumber node) => node;

  @override
  visitLiteralStatement(js.LiteralStatement node) => unsupported(node);

  @override
  js.Expression visitLiteralString(js.LiteralString node) => node;

  @override
  visitNamedFunction(js.NamedFunction node) {
    unsupported(node);
  }

  @override
  js.Expression visitNew(js.New node) {
    bool storeTarget = node.arguments.any(shouldTransform);
    return withExpression(node.target, (target) {
      return withExpressions(node.arguments, (List<js.Expression> arguments) {
        return new js.New(target, arguments);
      });
    }, store: storeTarget);
  }

  @override
  js.Expression visitObjectInitializer(js.ObjectInitializer node) {
    return withExpressions(
        node.properties.map((js.Property property) => property.value).toList(),
        (List<js.Node> values) {
      List<js.Property> properties = new List.generate(values.length, (int i) {
        return new js.Property(node.properties[i].name, values[i]);
      });
      return new js.ObjectInitializer(properties);
    });
  }

  @override
  visitParameter(js.Parameter node) => unreachable(node);

  @override
  js.Expression visitPostfix(js.Postfix node) {
    if (node.op == "++" || node.op == "--") {
      js.Expression argument = node.argument;
      if (argument is js.VariableUse) {
        return new js.Postfix(node.op, argument);
      } else if (argument is js.PropertyAccess) {
        return withExpression2(argument.receiver, argument.selector,
            (receiver, selector) {
          return new js.Postfix(
              node.op, new js.PropertyAccess(receiver, selector));
        });
      } else {
        throw "Unexpected postfix ${node.op} "
            "operator argument ${node.argument}";
      }
    }
    return withExpression(node.argument,
        (js.Expression argument) => new js.Postfix(node.op, argument),
        store: false);
  }

  @override
  js.Expression visitPrefix(js.Prefix node) {
    if (node.op == "++" || node.op == "--") {
      js.Expression argument = node.argument;
      if (argument is js.VariableUse) {
        return new js.Prefix(node.op, argument);
      } else if (argument is js.PropertyAccess) {
        return withExpression2(argument.receiver, argument.selector,
            (receiver, selector) {
          return new js.Prefix(
              node.op, new js.PropertyAccess(receiver, selector));
        });
      } else {
        throw "Unexpected prefix ${node.op} operator "
            "argument ${node.argument}";
      }
    }
    return withExpression(node.argument,
        (js.Expression argument) => new js.Prefix(node.op, argument),
        store: false);
  }

  @override
  visitProgram(js.Program node) => unsupported(node);

  @override
  js.Property visitProperty(js.Property node) {
    return withExpression(
        node.value, (js.Expression value) => new js.Property(node.name, value),
        store: false);
  }

  @override
  js.Expression visitRegExpLiteral(js.RegExpLiteral node) => node;

  @override
  void visitReturn(js.Return node) {
    assert(node.value == null || !isSyncStar && !isAsyncStar);
    js.Node target = analysis.targets[node];
    if (node.value != null) {
      withExpression(node.value, (js.Expression value) {
        addStatement(js.js.statement("$returnValueName = #", [value]));
      }, store: false);
    }
    translateJump(target, exitLabel);
  }

  @override
  void visitSwitch(js.Switch node) {
    if (!node.cases.any(shouldTransform)) {
      // If only the key has an await, translation can be simplified.
      bool oldInsideUntranslated = insideUntranslatedBreakable;
      insideUntranslatedBreakable = true;
      withExpression(node.key, (js.Expression key) {
        List<js.SwitchClause> cases = node.cases.map((js.SwitchClause clause) {
          if (clause is js.Case) {
            return new js.Case(
                clause.expression, translateInBlock(clause.body));
          } else if (clause is js.Default) {
            return new js.Default(translateInBlock(clause.body));
          }
        }).toList();
        addStatement(new js.Switch(key, cases));
      }, store: false);
      insideUntranslatedBreakable = oldInsideUntranslated;
      return;
    }
    int before = newLabel("switch");
    int after = newLabel("after switch");
    breakLabels[node] = after;

    beginLabel(before);
    List<int> labels = new List<int>(node.cases.length);

    bool anyCaseExpressionTransformed = node.cases.any(
        (js.SwitchClause x) => x is js.Case && shouldTransform(x.expression));
    if (anyCaseExpressionTransformed) {
      int defaultIndex = null; // Null means no default was found.
      // If there is an await in one of the keys, a chain of ifs has to be used.

      withExpression(node.key, (js.Expression key) {
        int i = 0;
        for (js.SwitchClause clause in node.cases) {
          if (clause is js.Default) {
            // The goto for the default case is added after all non-default
            // clauses have been handled.
            defaultIndex = i;
            labels[i] = newLabel("default");
            continue;
          } else if (clause is js.Case) {
            labels[i] = newLabel("case");
            withExpression(clause.expression, (expression) {
              addStatement(new js.If.noElse(
                  new js.Binary("===", key, expression),
                  gotoAndBreak(labels[i])));
            }, store: false);
          }
          i++;
        }
      }, store: true);

      if (defaultIndex == null) {
        addGoto(after);
      } 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(clause.expression, gotoAndBreak(labels[i])));
        } else if (i is js.Default) {
          labels[i] = newLabel("default");
          clauses.add(new js.Default(gotoAndBreak(labels[i])));
          hasDefault = true;
        } else {
          diagnosticListener.internalError(
              spannable, "Unknown clause type $clause");
        }
        i++;
      }
      withExpression(node.key, (js.Expression key) {
        addStatement(new js.Switch(key, clauses));
      }, store: false);
      if (!hasDefault) {
        addGoto(after);
      }
    }

    targetsAndTries.add(node);
    for (int i = 0; i < labels.length; i++) {
      beginLabel(labels[i]);
      visitStatement(node.cases[i].body);
    }
    beginLabel(after);
    targetsAndTries.removeLast();
  }

  @override
  js.Expression visitThis(js.This node) {
    return new js.VariableUse(selfName);
  }

  @override
  void visitThrow(js.Throw node) {
    withExpression(node.expression, (js.Expression expression) {
      addStatement(new js.Throw(expression));
    }, store: false);
  }

  setErrorHandler() {
    addExpressionStatement(new js.Assignment(
        new js.VariableUse(handlerName), currentErrorHandler));
  }

  @override
  void visitTry(js.Try node) {
    if (!shouldTransform(node)) {
      js.Block body = translateInBlock(node.body);
      js.Catch catchPart = (node.catchPart == null)
          ? null
          : new js.Catch(node.catchPart.declaration,
              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 handlerLabel = newLabel("catch");
    int finallyLabel = newLabel("finally");
    int afterFinallyLabel = newLabel("after finally");
    errorHandlerLabels.add(handlerLabel);
    // Set the error handler here. It must be cleared on every path out;
    // normal and error exit.
    setErrorHandler();
    if (node.finallyPart != null) {
      finallyLabels[node] = finallyLabel;
      targetsAndTries.add(node);
    }
    visitStatement(node.body);
    errorHandlerLabels.removeLast();
    addStatement(
        js.js.statement("$nextName = [#];", [js.number(afterFinallyLabel)]));
    if (node.finallyPart == null) {
      setErrorHandler();
      addGoto(afterFinallyLabel);
    } else {
      // The handler is set as the first thing in the finally block.
      addGoto(finallyLabel);
    }
    beginLabel(handlerLabel);
    if (node.catchPart != null) {
      setErrorHandler();
      // The catch declaration name can shadow outer variables, so a fresh name
      // is needed to avoid collisions.  See Ecma 262, 3rd edition,
      // section 12.14.
      String errorRename = freshName(node.catchPart.declaration.name);
      localVariables.add(new js.VariableDeclaration(errorRename));
      variableRenamings
          .add(new Pair(node.catchPart.declaration.name, errorRename));
      addExpressionStatement(new js.Assignment(
          new js.VariableUse(errorRename), new js.VariableUse(resultName)));
      visitStatement(node.catchPart.body);
      variableRenamings.removeLast();
    }
    if (node.finallyPart != null) {
      targetsAndTries.removeLast();
      setErrorHandler();
      // This belongs to the catch-part, but is only needed if there is a
      // `finally`. Therefore it is in this branch.
      // This is needed even if there is no explicit catch-branch, because
      // if an exception is raised the finally part has to be run.
      addStatement(
          js.js.statement("$nextName = [#];", [js.number(afterFinallyLabel)]));
      beginLabel(finallyLabel);
      setErrorHandler();
      visitStatement(node.finallyPart);
      addStatement(new js.Comment("// goto the next finally handler"));
      addStatement(js.js.statement("$gotoName = $nextName.pop();"));
      addBreak();
    }
    beginLabel(afterFinallyLabel);
  }

  @override
  visitVariableDeclaration(js.VariableDeclaration node) {
    unreachable(node);
  }

  @override
  void visitVariableDeclarationList(js.VariableDeclarationList node) {
    // Declaration of local variables is hoisted outside the helper but the
    // initialization is done here.
    for (js.VariableInitialization initialization in node.declarations) {
      js.VariableDeclaration declaration = initialization.declaration;
      localVariables.add(declaration);
      if (initialization.value != null) {
        withExpression(initialization.value, (js.Expression value) {
          addStatement(new js.ExpressionStatement(
              new js.Assignment(new js.VariableUse(declaration.name), value)));
        }, store: false);
      }
    }
  }

  @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);
    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) {
        addStatement(new js.While(condition, translateInBlock(node.body)));
      }, store: false);
      insideUntranslatedBreakable = oldInsideUntranslated;
      return;
    }
    int continueLabel = newLabel("while condition");
    continueLabels[node] = continueLabel;
    beginLabel(continueLabel);

    int afterLabel = newLabel("after while");
    breakLabels[node] = afterLabel;
    js.Expression condition = node.condition;
    // If the condition is `true`, a test is not needed.
    if (!(condition is js.LiteralBool && condition.value == true)) {
      withExpression(node.condition, (js.Expression condition) {
        addStatement(new js.If.noElse(
            new js.Prefix("!", condition), gotoAndBreak(afterLabel)));
      }, store: false);
    }
    targetsAndTries.add(node);
    visitStatement(node.body);
    targetsAndTries.removeLast();
    addGoto(continueLabel);
    beginLabel(afterLabel);
  }

  /// Translates a yield/yield* in an sync*.
  ///
  /// `yield` in a sync* function just returns [value].
  /// `yield*` wraps [value] in a [yieldStarExpression] and returns it.
  void addSyncYield(js.DartYield node, js.Expression expression) {
    assert(isSyncStar);
    if (node.hasStar) {
      addStatement(
          new js.Return(new js.Call(yieldStarExpression, [expression])));
    } else {
      addStatement(new js.Return(expression));
    }
  }

  /// 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 [streamHelper] distinguish.
  ///
  /// Because there is no Future that can fail (as there is in await) null is
  /// passed as the errorCallback.
  void addAsyncYield(js.DartYield node, js.Expression expression) {
    assert(isAsyncStar);
    // 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(targetsAndTries
        .where((js.Node node) => node is js.Try)
        .map((js.Try node) => finallyLabels[node]));
    int destinationOnCancel = enclosingFinallyLabels.removeLast();
    js.ArrayInitializer finallyListInitializer = new js.ArrayInitializer(
        enclosingFinallyLabels.map(js.number).toList());
    addStatement(js.js.statement("""
        return #streamHelper(#yieldExpression(#expression),
            $helperName, $controllerName, function () {
              if (#notEmptyFinallyList)
                $nextName = #finallyList;
              $gotoName = #destinationOnCancel;
              $helperName();
            });""", {
      "streamHelper": streamHelper,
      "yieldExpression": node.hasStar ? yieldStarExpression : yieldExpression,
      "expression": expression,
      "notEmptyFinallyList": enclosingFinallyLabels.isNotEmpty,
      "finallyList": finallyListInitializer,
      "destinationOnCancel": js.number(destinationOnCancel)
    }));
  }

  @override
  void visitDartYield(js.DartYield node) {
    assert(isSyncStar || isAsyncStar);
    int label = newLabel("after yield");
    // 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));
      if (isSyncStar) {
        addSyncYield(node, expression);
      } else {
        addAsyncYield(node, expression);
      }
    }, store: false);
    beginLabel(label);
  }
}

/// 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> {
  Set<js.Node> hasAwaitOrYield = new Set<js.Node>();

  Map<js.Node, js.Node> targets = new Map<js.Node, js.Node>();
  List<js.Node> loopsAndSwitches = new List<js.Node>();
  List<js.LabeledStatement> labelledStatements =
      new List<js.LabeledStatement>();
  Set<String> usedNames = new Set<String>();

  bool hasExplicitReturns = false;

  bool hasThis = false;

  // The function currently being analyzed.
  js.Fun currentFunction;

  // For error messages.
  final Function unsupported;

  PreTranslationAnalysis(void this.unsupported(js.Node node));

  bool visit(js.Node node) {
    bool containsAwait = node.accept(this);
    if (containsAwait) {
      hasAwaitOrYield.add(node);
    }
    return containsAwait;
  }

  analyze(js.Fun node) {
    currentFunction = node;
    node.params.forEach(visit);
    visit(node.body);
  }

  @override
  bool visitAccess(js.PropertyAccess node) {
    bool receiver = visit(node.receiver);
    bool selector = visit(node.selector);
    return receiver || selector;
  }

  @override
  bool visitArrayHole(js.ArrayHole node) {
    return false;
  }

  @override
  bool visitArrayInitializer(js.ArrayInitializer node) {
    bool containsAwait = false;
    for (js.Expression element in node.elements) {
      if (visit(element)) containsAwait = true;
    }
    return containsAwait;
  }

  @override
  bool visitAssignment(js.Assignment node) {
    bool leftHandSide = visit(node.leftHandSide);
    bool value = (node.value == null) ? false : visit(node.value);
    return leftHandSide || value;
  }

  @override
  bool visitAwait(js.Await node) {
    visit(node.expression);
    return true;
  }

  @override
  bool visitBinary(js.Binary node) {
    bool left = visit(node.left);
    bool right = visit(node.right);
    return left || right;
  }

  @override
  bool visitBlob(js.Blob node) {
    return false;
  }

  @override
  bool visitBlock(js.Block node) {
    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) {
        return statement.label == node.targetLabel;
      });
    } else {
      targets[node] = loopsAndSwitches.last;
    }
    return false;
  }

  @override
  bool visitCall(js.Call node) {
    bool containsAwait = visit(node.target);
    for (js.Expression argument in node.arguments) {
      if (visit(argument)) containsAwait = true;
    }
    return containsAwait;
  }

  @override
  bool visitCase(js.Case node) {
    bool expression = visit(node.expression);
    bool body = visit(node.body);
    return expression || body;
  }

  @override
  bool visitCatch(js.Catch node) {
    bool declaration = visit(node.declaration);
    bool body = visit(node.body);
    return declaration || body;
  }

  @override
  bool visitComment(js.Comment node) {
    return false;
  }

  @override
  bool visitConditional(js.Conditional node) {
    bool condition = visit(node.condition);
    bool then = visit(node.then);
    bool otherwise = visit(node.otherwise);
    return condition || then || otherwise;
  }

  @override
  bool visitContinue(js.Continue node) {
    if (node.targetLabel != null) {
      targets[node] = labelledStatements.lastWhere(
          (js.LabeledStatement stm) => stm.label == node.targetLabel);
    } else {
      targets[node] =
          loopsAndSwitches.lastWhere((js.Node node) => node is! js.Switch);
    }
    assert(() {
      js.Node target = targets[node];
      return target is js.Loop ||
          (target is js.LabeledStatement && target.body is js.Loop);
    });
    return false;
  }

  @override
  bool visitDefault(js.Default node) {
    return visit(node.body);
  }

  @override
  bool visitDo(js.Do node) {
    loopsAndSwitches.add(node);
    bool body = visit(node.body);
    bool condition = visit(node.condition);
    loopsAndSwitches.removeLast();
    return body || condition;
  }

  @override
  bool visitEmptyStatement(js.EmptyStatement node) {
    return false;
  }

  @override
  bool visitExpressionStatement(js.ExpressionStatement node) {
    return visit(node.expression);
  }

  @override
  bool visitFor(js.For node) {
    bool init = (node.init == null) ? false : visit(node.init);
    bool condition = (node.condition == null) ? false : visit(node.condition);
    bool update = (node.update == null) ? false : visit(node.update);
    loopsAndSwitches.add(node);
    bool body = visit(node.body);
    loopsAndSwitches.removeLast();
    return init || condition || update || body;
  }

  @override
  bool visitForIn(js.ForIn node) {
    bool object = visit(node.object);
    loopsAndSwitches.add(node);
    bool body = visit(node.body);
    loopsAndSwitches.removeLast();
    return object || body;
  }

  @override
  bool visitFun(js.Fun node) {
    return false;
  }

  @override
  bool visitFunctionDeclaration(js.FunctionDeclaration node) {
    return false;
  }

  @override
  bool visitIf(js.If node) {
    bool condition = visit(node.condition);
    bool then = visit(node.then);
    bool otherwise = visit(node.otherwise);
    return condition || then || otherwise;
  }

  @override
  bool visitInterpolatedExpression(js.InterpolatedExpression node) {
    return unsupported(node);
  }

  @override
  bool visitInterpolatedLiteral(js.InterpolatedLiteral node) {
    return unsupported(node);
  }

  @override
  bool visitInterpolatedParameter(js.InterpolatedParameter node) {
    return unsupported(node);
  }

  @override
  bool visitInterpolatedSelector(js.InterpolatedSelector node) {
    return unsupported(node);
  }

  @override
  bool visitInterpolatedStatement(js.InterpolatedStatement node) {
    return unsupported(node);
  }

  @override
  bool visitLabeledStatement(js.LabeledStatement node) {
    usedNames.add(node.label);
    labelledStatements.add(node);
    bool containsAwait = visit(node.body);
    labelledStatements.removeLast();
    return containsAwait;
  }

  @override
  bool visitLiteralBool(js.LiteralBool node) {
    return false;
  }

  @override
  bool visitLiteralExpression(js.LiteralExpression node) {
    return unsupported(node);
  }

  @override
  bool visitLiteralNull(js.LiteralNull node) {
    return false;
  }

  @override
  bool visitLiteralNumber(js.LiteralNumber node) {
    return false;
  }

  @override
  bool visitLiteralStatement(js.LiteralStatement node) {
    return unsupported(node);
  }

  @override
  bool visitLiteralString(js.LiteralString node) {
    return false;
  }

  @override
  bool visitNamedFunction(js.NamedFunction node) {
    return false;
  }

  @override
  bool visitNew(js.New node) {
    return visitCall(node);
  }

  @override
  bool visitObjectInitializer(js.ObjectInitializer node) {
    bool containsAwait = false;
    for (js.Property property in node.properties) {
      if (visit(property)) containsAwait = true;
    }
    return containsAwait;
  }

  @override
  bool visitParameter(js.Parameter node) {
    usedNames.add(node.name);
    return false;
  }

  @override
  bool visitPostfix(js.Postfix node) {
    return visit(node.argument);
  }

  @override
  bool visitPrefix(js.Prefix node) {
    return visit(node.argument);
  }

  @override
  bool visitProgram(js.Program node) {
    throw "Unexpected";
  }

  @override
  bool visitProperty(js.Property node) {
    return visit(node.value);
  }

  @override
  bool visitRegExpLiteral(js.RegExpLiteral node) {
    return false;
  }

  @override
  bool visitReturn(js.Return node) {
    hasExplicitReturns = true;
    targets[node] = currentFunction;
    if (node.value == null) return false;
    return visit(node.value);
  }

  @override
  bool visitSwitch(js.Switch node) {
    loopsAndSwitches.add(node);
    bool result = visit(node.key);
    for (js.SwitchClause clause in node.cases) {
      if (visit(clause)) result = true;
    }
    loopsAndSwitches.removeLast();
    return result;
  }

  @override
  bool visitThis(js.This node) {
    hasThis = true;
    return false;
  }

  @override
  bool visitThrow(js.Throw node) {
    return visit(node.expression);
  }

  @override
  bool visitTry(js.Try node) {
    bool body = visit(node.body);
    bool catchPart = (node.catchPart == null) ? false : visit(node.catchPart);
    bool finallyPart =
        (node.finallyPart == null) ? false : visit(node.finallyPart);
    return body || catchPart || finallyPart;
  }

  @override
  bool visitVariableDeclaration(js.VariableDeclaration node) {
    usedNames.add(node.name);
    return false;
  }

  @override
  bool visitVariableDeclarationList(js.VariableDeclarationList node) {
    bool result = false;
    for (js.VariableInitialization init in node.declarations) {
      if (visit(init)) result = true;
    }
    return result;
  }

  @override
  bool visitVariableInitialization(js.VariableInitialization node) {
    return visitAssignment(node);
  }

  @override
  bool visitVariableUse(js.VariableUse node) {
    usedNames.add(node.name);
    return false;
  }

  @override
  bool visitWhile(js.While node) {
    loopsAndSwitches.add(node);
    bool condition = visit(node.condition);
    bool body = visit(node.body);
    loopsAndSwitches.removeLast();
    return condition || body;
  }

  @override
  bool visitDartYield(js.DartYield node) {
    visit(node.expression);
    return true;
  }
}