Implementation of async-await transformation on js ast.

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

Index: pkg/compiler/lib/src/js/rewrite_async.dart
diff --git a/pkg/compiler/lib/src/js/rewrite_async.dart b/pkg/compiler/lib/src/js/rewrite_async.dart
new file mode 100644
index 0000000000000000000000000000000000000000..54f5bbed9faf0883967d314b2f0dd8063c873457
--- /dev/null
+++ b/pkg/compiler/lib/src/js/rewrite_async.dart
@@ -0,0 +1,2153 @@
+// 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;
+
+  /// 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.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 #streamHelper(null, $helperName, $controllerName, null);", {
+        "streamHelper": streamHelper
+      });
+    } 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(declaration, 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;
+  }
+}