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..579a041eb907040b4fc41471ea936450ba454d69
--- /dev/null
+++ b/pkg/compiler/lib/src/js/rewrite_async.dart
@@ -0,0 +1,1817 @@
+// 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): Avoid using variables in templates. It could blow up memory
+// use.
+
+import "dart:math" show max;
+import 'dart:collection';
+
+import "js.dart";
+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).
+
+class AsyncRewriter extends NodeVisitor {
+
+  // Local variables are hoisted to the top of the function, so we collect them
+  // here.
+  List<VariableDeclaration> localVariables = new List<VariableDeclaration>();
+
+  Map<Node, int> continueLabels = new Map<Node, int>();
+  Map<Node, int> breakLabels = new Map<Node, int>();
+  Map<Node, int> finallyLabels = new Map<Node, int>();
+  int returnLabel;
+
+  // 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, so we can ensure all the finally blocks between a jump and
+  // its target are run before the jump.
+  List<Node> targetsAndTries = new List<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;
+
+  String resultName;
+  String helperName;
+  String controllerName;
+  String gotoName;
+  String handlerName;
+  String errorName;
+  String nextName;
+  String returnValueName;
+  String outerLabelName;
+  String selfName;
+
+  final Expression thenHelper;
+  final Expression newController;
+  final Expression endOfIteration;
+  final Expression newIterable;
+  final Expression yieldExpression;
+  final 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, Expression> tempVarNames = new Map<int, Expression>();
+
+  AsyncModifier async;
+
+  bool get isSync => async == const AsyncModifier.sync();
+  bool get isAsync => async == const AsyncModifier.async();
+  bool get isSyncStar => async == const AsyncModifier.syncStar();
+  bool get isAsyncStar => async == const AsyncModifier.asyncStar();
+
+  AsyncRewriter(this.diagnosticListener,
+                spannable,
+                {this.thenHelper,
+                 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.
+  Fun rewrite(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");
+    controllerName = freshName("completer");
+    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);
+  }
+
+  Expression get currentErrorHandler {
+    return errorHandlerLabels.isEmpty ?
+        new LiteralNull() :
+        new LiteralNumber("${errorHandlerLabels.last}");
+  }
+
+  int allocateTempVar() {
+    assert(tempVarHighWaterMark >= currentTempVarIndex);
+    currentTempVarIndex++;
+    tempVarHighWaterMark = max(currentTempVarIndex, tempVarHighWaterMark);
+    return currentTempVarIndex;
+  }
+
+  VariableUse useTempVar(int i) {
+    return tempVarNames.putIfAbsent(i, () =>
+        new 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;
+  }
+
+  /// We collect all the pieces in this map, and output a switch with a case
+  /// for each label.
+  ///
+  /// The order is important, therefore the type is explicitly LinkedHashMap.
+  LinkedHashMap<int, List<Statement>> labelledParts =
+      new LinkedHashMap<int, List<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 we use a label to break to the outer switch-statement.
+  bool hasJumpThoughOuterLabel = false;
+
+  /// Buffer for collecting translated statements belonging to the same switch
+  /// case.
+  List<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 will end up as its own case part in the big state-switch.
+  void beginLabel(int label) {
+    assert(!labelledParts.containsKey(label));
+    currentStatementBuffer = new List<Statement>();
+    labelledParts[label] = currentStatementBuffer;
+    addStatement(new 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.
+  Statement setGotoVariable(int label) {
+    return new ExpressionStatement(
+        new Assignment(new VariableUse(gotoName), new LiteralNumber("$label")));
+  }
+
+  /// Return a block that has a goto to [label] including the break.
+  ///
+  /// Will also insert a comment describing the label if available.
+  Block gotoAndBreak(int label) {
+    List<Statement> statements = new List<Statement>();
+    if (labelComments.containsKey(label)) {
+      statements.add(new Comment("goto ${labelComments[label]}"));
+    }
+    statements.add(setGotoVariable(label));
+    statements.add(breakStatement());
+    return new Block(statements);
+  }
+
+  /// Add a goto to [label] including the break.
+  ///
+  /// Will also insert a comment describing the label if available.
+  void addGoto(int label) {
+    if (labelComments.containsKey(label)) {
+      addStatement(new Comment("goto ${labelComments[label]}"));
+    }
+    addStatement(setGotoVariable(label));
+
+    addBreak();
+  }
+
+  void addStatement(Statement node) {
+    currentStatementBuffer.add(node);
+  }
+
+  void addExpressionStatement(Expression node) {
+    addStatement(new ExpressionStatement(node));
+  }
+
+  /// True if there is an await or yield in [node] or some subexpression.
+  bool shouldTransform(Node node) {
+    return analysis.hasAwaitOrYield.contains(node);
+  }
+
+  void unsupported(Node node) {
+    throw new UnsupportedError(
+        "Node $node cannot be transformed by the await-sync transformer");
+  }
+
+  void unreachable(Node node) {
+    diagnosticListener.internalError(spannable,
+        "Internal error, trying to visit $node");
+  }
+
+  visitStatement(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 we can guarantee
+  /// has no side effect, it is dropped.
+  void visitExpressionIgnoreResult(Expression node) {
+    Expression result = node.accept(this);
+    if (!(result is Literal || result is VariableUse)) {
+      addExpressionStatement(result);
+    }
+  }
+
+  Expression visitExpression(Expression node) {
+    return node.accept(this);
+  }
+
+  /// Emits an assignment of [result] to a temporary variable unless it can
+  /// be guaranteed that evaluating [result] has no side-effect, and has
+  /// constant value.
+  /// Returns the temporary variable or the result itself.
+  ///
+  /// For example:
+  ///
+  /// - _storeIfNecessary(someLiteral) returns someLiteral.
+  /// - _storeIfNecessary(someVariable)
+  ///   inserts: var tempX = someVariable
+  ///   returns: tempX
+  ///   where tempX is a fresh temporary variable.
+  Expression _storeIfNecessary(Expression result) {
+    // Note that RegExes, ArrayInitializer and ObjectInitializer are not
+    // [Literal]s.
+    if (result is Literal) return result;
+    Expression tempVar = useTempVar(allocateTempVar());
+    addExpressionStatement(new Assignment(tempVar, result));
+    return tempVar;
+  }
+
+  withExpression(Expression node, fn(Expression result), {bool store}) {
+    int oldTempVarIndex = currentTempVarIndex;
+    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)` we store the first expression in a temporary
+  /// variable.
+  ///
+  /// This is because we need to ensure evaluating node1 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(Expression node1, Expression node2, fn(Expression result1,
+      Expression result2)) {
+    int oldTempVarIndex = currentTempVarIndex;
+    Expression r1 = visitExpression(node1);
+    if (shouldTransform(node2)) {
+      r1 = _storeIfNecessary(r1);
+    }
+    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)` we store 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<Expression> nodes, fn(List<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<Node> visited = nodes.take(lastTransformIndex).map((Node node) {
+      return node == null
+          ? null
+          : _storeIfNecessary(visitExpression(node));
+    }).toList();
+    visited.addAll(nodes.skip(lastTransformIndex).map((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.
+  ///
+  /// Returning from an async method calls the helper with the result.
+  /// (the result might been stored in [returnValueName] by some finally block).
+  ///
+  /// Returning from a sync* will return a [endOfIteration] marker.
+  void addReturn() {
+    if (analysis.hasExplicitReturns || isAsyncStar) {
+      beginLabel(returnLabel);
+    } else {
+      addStatement(new Comment("implicit return"));
+    }
+    switch (async) {
+      case const AsyncModifier.async():
+        String returnValue = analysis.hasExplicitReturns
+            ? returnValueName
+            : "null";
+        addStatement(js.statement(
+            "return #thenHelper($returnValue, null, $controllerName, null)",
+            {"thenHelper": thenHelper}));
+        break;
+      case const AsyncModifier.syncStar():
+        addStatement(new Return(new Call(endOfIteration, [])));
+        break;
+      case const AsyncModifier.asyncStar():
+        addStatement(js.statement(
+            "return #thenHelper(null, null, $controllerName, null)",
+            {"thenHelper": thenHelper}));
+        break;
+      default:
+        throw "Internal error, unexpected asyncmodifier";
+    }
+  }
+
+  /// Initializing a controller. (This is a Completer for async,
+  /// a StreamController for async* and nothing for a sync*).
+  /// The controller is be passed to each call to [thenHelper].
+  Statement generateInitializer() {
+    switch (async) {
+      case const AsyncModifier.async():
+        return js.statement(
+            "return #thenHelper(null, $helperName, $controllerName, null);",
+                     {"thenHelper": thenHelper});
+      case const AsyncModifier.syncStar():
+        throw "Not handled here";
+      case const AsyncModifier.asyncStar():
+        return js.statement(
+            "return #thenHelper(null, $helperName, $controllerName, null);",
+                     {"thenHelper": thenHelper});      default:
+        throw "Internal error, unexpected asyncmodifier";
+    }
+  }
+
+  @override
+  visitFun(Fun node) {
+    if (isSync) return node;
+
+    beginLabel(newLabel("Function start"));
+    // AsyncStar needs a returnlabel for its handling of cancelation. See
+    // [visitYield].
+    returnLabel = analysis.hasExplicitReturns || isAsyncStar
+        ? newLabel("Return")
+        : null;
+    Statement body = node.body;
+    targetsAndTries.add(node);
+    visitStatement(body);
+    targetsAndTries.removeLast();
+    addReturn();
+
+    List<SwitchClause> clauses = labelledParts.keys.map((label) {
+      return new Case(
+          new LiteralNumber("$label"),
+          new Block(labelledParts[label]));
+    }).toList();
+    Statement helperBody = new Switch(new VariableUse(gotoName), clauses);
+    if (hasJumpThoughOuterLabel) {
+      helperBody = js.statement("$outerLabelName: #", [helperBody]);
+    }
+    if (hasTryBlocks) {
+      helperBody = js.statement("""
+          try {
+            #body
+          } catch ($errorName){
+            if ($handlerName === null)
+              throw $errorName;
+            $resultName = $errorName;
+            $gotoName = $handlerName;
+          }""", {"body": helperBody});
+    }
+    List<VariableInitialization> inits = <VariableInitialization>[];
+
+    VariableInitialization makeInit(String name, Expression initValue) {
+      return new VariableInitialization(new VariableDeclaration(name),
+                                        initValue);
+    }
+
+    inits.add(makeInit(gotoName, new LiteralNumber("0")));
+    if (isAsync || isAsyncStar) {
+      inits.add(makeInit(controllerName, newController));
+    }
+    if (hasTryBlocks) {
+      inits.add(makeInit(handlerName, new LiteralNull()));
+    }
+    if (hasJumpThroughFinally) {
+      inits.add(makeInit(nextName, null));
+    }
+    if (analysis.hasExplicitReturns && isAsync) {
+      inits.add(makeInit(returnValueName, null));
+    }
+    if (analysis.hasThis) {
+      inits.add(makeInit(selfName, new This()));
+    }
+    inits.addAll(localVariables.map(
+        (VariableDeclaration decl) => new VariableInitialization(decl, null)));
+    inits.addAll(new Iterable.generate(tempVarHighWaterMark,
+        (int i) => makeInit(useTempVar(i + 1).name, null)));
+    VariableDeclarationList varDecl = new VariableDeclarationList(inits);
+    if (isSyncStar) {
+      return js("""
+          function (#params) {
+            return new #newIterable(function () {
+              #varDecl;
+              return function $helperName($resultName) {
+                while (true)
+                  #helperBody;
+              };
+            });
+          }
+          """, {"params": node.params,
+      "helperBody": helperBody,
+      "varDecl": varDecl,
+      "newIterable": newIterable});
+    }
+    return js("""
+        function (#params) {
+          #varDecl;
+          function $helperName($resultName) {
+            while (true)
+              #helperBody;
+          }
+          #init;
+        }""", {"params": node.params,
+               "helperBody": helperBody,
+               "varDecl": varDecl,
+               "init": generateInitializer()});
+  }
+
+  @override
+  visitAccess(PropertyAccess node) {
+    return withExpression2(
+        node.receiver,
+        node.selector,
+        (receiver, selector) => new PropertyAccess(receiver, selector));
+  }
+
+  @override
+  visitArrayHole(ArrayHole node) {
+    return node;
+  }
+
+  @override
+  visitArrayInitializer(ArrayInitializer node) {
+    return withExpressions(node.elements, (elements) {
+      return new ArrayInitializer(elements);
+    });
+  }
+
+  @override
+  visitAssignment(Assignment node) {
+    if (!shouldTransform(node)) {
+      return new Assignment.compound(visitExpression(node.leftHandSide),
+                                     node.op,
+                                     visitExpression(node.value));
+    }
+    Expression leftHandSide = node.leftHandSide;
+    if (leftHandSide is VariableUse) {
+      return withExpression(node.value, (Expression value) {
+        return new Assignment(leftHandSide, value);
+      }, store: false);
+    } else if (leftHandSide is PropertyAccess) {
+      return withExpressions(
+          [leftHandSide.receiver, leftHandSide.selector, node.value],
+          (evaluated) {
+        return new Assignment.compound(
+            new PropertyAccess(evaluated[0], evaluated[1]),
+            node.op,
+            evaluated[2]);
+      });
+    } else {
+      throw "Unexpected assignment left hand side $leftHandSide";
+    }
+  }
+
+  @override
+  Expression visitAwait(Await node) {
+    int afterWait = newLabel("returning from await.");
+    withExpression(node.expression, (Expression expression) {
+      addStatement(setGotoVariable(afterWait));
+      if (errorHandlerLabels.isEmpty) {
+        addStatement(js.statement("""
+            return #thenHelper(#expression, $helperName, $controllerName, null);
+            """, {"thenHelper": thenHelper, "expression": expression}));
+      } else {
+        addStatement(js.statement("""
+            return #thenHelper(#expression, $helperName, $controllerName,
+                function($errorName) {
+              $gotoName = #currentHandler;
+              $helperName($errorName);
+            });""", {"thenHelper": thenHelper,
+                     "expression": expression,
+                     "currentHandler": currentErrorHandler}));
+      }
+    }, store: false);
+    beginLabel(afterWait);
+    return new 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], we can avoid reduntdantly assigning it
+  /// to itself again.
+  bool isResult(Expression node) {
+    return node is VariableUse && node.name == resultName;
+  }
+
+  @override
+  Expression visitBinary(Binary node) {
+    if (shouldTransform(node.right) &&
+        (node.op == "||" || node.op == "&&")) {
+      int thenLabel = newLabel("then");
+      int joinLabel = newLabel("join");
+      withExpression(node.left, (Expression left) {
+        Statement assignLeft = isResult(left)
+            ? new Block.empty()
+            : new ExpressionStatement(
+                new Assignment(new VariableUse(resultName), left));
+        if (node.op == "||") {
+          addStatement(new If(left, gotoAndBreak(thenLabel), assignLeft));
+        } else {
+          assert(node.op == "&&");
+          addStatement(new If(left, assignLeft, gotoAndBreak(thenLabel)));
+        }
+      }, store: true);
+      addGoto(joinLabel);
+      beginLabel(thenLabel);
+      withExpression(node.right, (Expression value) {
+        if (!isResult(value)) {
+          addExpressionStatement(
+              new Assignment(new VariableUse(resultName), value));
+        }
+      }, store: false);
+      beginLabel(joinLabel);
+      return new VariableUse(resultName);
+    }
+
+    return withExpression2(
+        node.left,
+        node.right,
+        (left, right) => new Binary(node.op, left, right));
+  }
+
+  @override
+  visitBlob(Blob node) {
+    return node;
+  }
+
+  @override
+  void visitBlock(Block node) {
+    for (Statement statement in node.statements) {
+      visitStatement(statement);
+    }
+  }
+
+  @override
+  void visitBreak(Break node) {
+    Node target = analysis.targets[node];
+    if (!shouldTransform(target)) {
+      addStatement(node);
+      return;
+    }
+    translateJump(target, breakLabels[target]);
+  }
+
+  @override
+  Expression visitCall(Call node) {
+    bool storeTarget = node.arguments.any(shouldTransform);
+    return withExpression(node.target, (target) {
+      return withExpressions(node.arguments, (List<Expression> arguments) {
+        return new Call(target, arguments);
+      });
+    }, store: storeTarget);
+  }
+
+  @override
+  visitCase(Case node) {
+    return unreachable(node);
+  }
+
+  @override
+  visitCatch(Catch node) {
+    return unreachable(node);
+  }
+
+  @override
+  visitComment(Comment node) {
+    addStatement(node);
+  }
+
+  @override
+  Expression visitConditional(Conditional node) {
+    if (!shouldTransform(node.then) && !shouldTransform(node.otherwise)) {
+      return withExpression(node.condition, (Expression condition) {
+        return new Conditional(condition, node.then, node.otherwise);
+      });
+    }
+    int thenLabel = newLabel("then");
+    int joinLabel = newLabel("join");
+    int elseLabel = newLabel("else");
+    withExpression(node.condition, (Expression condition) {
+      addExpressionStatement(
+          new Assignment(
+              new VariableUse(gotoName),
+              new Conditional(
+                  condition,
+                  new LiteralNumber("$thenLabel"),
+                  new LiteralNumber("$elseLabel"))));
+    }, store: false);
+    addBreak();
+    beginLabel(thenLabel);
+    withExpression(node.then, (Expression value) {
+      if (!isResult(value)) {
+        addExpressionStatement(
+            new Assignment(new VariableUse(resultName), value));
+      }
+    }, store: false);
+    addGoto(joinLabel);
+    beginLabel(elseLabel);
+    withExpression(node.otherwise, (Expression value) {
+      if (!isResult(value)) {
+        addExpressionStatement(
+            new Assignment(new VariableUse(resultName), value));
+      }
+    }, store: false);
+    beginLabel(joinLabel);
+    return new VariableUse(resultName);
+  }
+
+  @override
+  visitContinue(Continue node) {
+    Node target = analysis.targets[node];
+    if (!shouldTransform(target)) {
+      addStatement(node);
+      return;
+    }
+    translateJump(target, continueLabels[target]);
+  }
+
+  /// Returns a break statement that exits the big switch statement.
+  Statement breakStatement() {
+    if (insideUntranslatedBreakable) {
+      hasJumpThoughOuterLabel = true;
+      return new Break(outerLabelName);
+    } else {
+      return new Break(null);
+    }
+  }
+
+  /// Convenience wrapper around [breakStatement].
+  void addBreak() {
+    addStatement(breakStatement());
+  }
+
+  /// Common code for handling break, continue, return.
+  ///
+  /// It is necessary to run all nesting finally-handlers between the jump and
+  /// the target. For that we use [nextName] as a stack of places to go.
+  void translateJump(Node target, int targetLabel) {
+    // Compute a stack of all the 'finally' nodes we must visit before the jump.
+    // The bottom of the stack is the label where the jump goes to.
+    List<int> jumpStack = new List<int>();
+    for (Node node in targetsAndTries.reversed) {
+      if (node is Try) {
+        assert(node.finallyPart != null);
+        jumpStack.add(finallyLabels[node]);
+      } else if (node == target) {
+        jumpStack.add(targetLabel);
+        break;
+      }
+      // Ignore other nodes.
+    }
+    jumpStack = jumpStack.reversed.toList();
+    // We jump directly to the top of the stack, so take it off now.
+    int firstTarget = jumpStack.removeLast();
+    if (jumpStack.isNotEmpty) {
+      hasJumpThroughFinally = true;
+      Expression jsJumpStack = new ArrayInitializer(
+          jumpStack.map((int label) => new LiteralNumber("$label"))
+                      .toList());
+      addStatement(js.statement("$nextName = #", [jsJumpStack]));
+    }
+    addGoto(firstTarget);
+  }
+
+  @override
+  visitDefault(Default node) => unreachable(node);
+
+  @override
+  visitDo(Do node) {
+    if (!shouldTransform(node)) {
+      bool oldInsideUntranslatedBreakable = insideUntranslatedBreakable;
+      insideUntranslatedBreakable = true;
+      withExpression(node.condition, (Expression condition) {
+        addStatement(new 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, (Expression condition) {
+      addStatement(new If.noElse(condition,
+                                 gotoAndBreak(startLabel)));
+    }, store: false);
+    beginLabel(afterLabel);
+  }
+
+  @override
+  visitEmptyStatement(EmptyStatement node) => node;
+
+  visitExpressionInStatementContext(Expression node) {
+    if (node is VariableDeclarationList) {
+      // Treat VariableDeclarationList as a statement.
+      visitVariableDeclarationList(node);
+    } else {
+      visitExpressionIgnoreResult(node);
+    }
+  }
+
+  @override
+  visitExpressionStatement(ExpressionStatement node) {
+    visitExpressionInStatementContext(node.expression);
+  }
+
+  @override
+  visitFor(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<Expression> transformed) {
+        addStatement(new 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);
+    Expression condition = node.condition;
+    if (condition != null &&
+        !(condition is LiteralBool && condition.value == true)) {
+      // No condition is the same as true. We don't have to check.
+      withExpression(node.condition, (Expression condition) {
+        addStatement(new If.noElse(new 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
+  visitForIn(ForIn node) {
+    // The dart output currently never uses for-in loops.
+    throw "Javascript for-in not implemented yet in the await transformation";
+  }
+
+  @override
+  visitFunctionDeclaration(FunctionDeclaration node) {
+    return node;
+  }
+
+  // Only used for code where `!shouldTransform(node)`.
+  Block translateInBlock(Statement node) {
+    assert(!shouldTransform(node));
+    List<Statement> oldBuffer = currentStatementBuffer;
+    currentStatementBuffer = new List();
+    List<Statement> resultBuffer = currentStatementBuffer;
+    visitStatement(node);
+    currentStatementBuffer = oldBuffer;
+    return new Block(resultBuffer);
+  }
+
+  @override
+  visitIf(If node) {
+    if (!shouldTransform(node.then) && !shouldTransform(node.otherwise)) {
+      withExpression(node.condition, (Expression condition) {
+        addStatement(
+            new If(
+                condition,
+                translateInBlock(node.then),
+                translateInBlock(node.otherwise)));
+      }, store: false);
+      return;
+    }
+    int thenLabel = newLabel("then");
+    int joinLabel = newLabel("join");
+    int elseLabel =
+        node.otherwise is EmptyStatement ? joinLabel : newLabel("else");
+
+    withExpression(node.condition, (Expression condition) {
+      addExpressionStatement(
+          new Assignment(
+              new VariableUse(gotoName),
+              new Conditional(
+                  condition,
+                  new LiteralNumber("$thenLabel"),
+                  new LiteralNumber("$elseLabel"))));
+    }, store: false);
+    addBreak();
+    beginLabel(thenLabel);
+    visitStatement(node.then);
+    if (node.otherwise is! EmptyStatement) {
+      addGoto(joinLabel);
+      beginLabel(elseLabel);
+      visitStatement(node.otherwise);
+    }
+    beginLabel(joinLabel);
+  }
+
+  @override
+  visitInterpolatedExpression(InterpolatedExpression node) => unsupported(node);
+
+  @override
+  visitInterpolatedLiteral(InterpolatedLiteral node) => unsupported(node);
+
+  @override
+  visitInterpolatedParameter(InterpolatedParameter node) => unsupported(node);
+
+  @override
+  visitInterpolatedSelector(InterpolatedSelector node) => unsupported(node);
+
+  @override
+  visitInterpolatedStatement(InterpolatedStatement node) => unsupported(node);
+
+  @override
+  visitLabeledStatement(LabeledStatement node) {
+    if (!shouldTransform(node)) {
+      addStatement(
+          new 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
+  visitLiteralBool(LiteralBool node) => node;
+
+  @override
+  visitLiteralExpression(LiteralExpression node) => unsupported(node);
+
+  @override
+  visitLiteralNull(LiteralNull node) => node;
+
+  @override
+  visitLiteralNumber(LiteralNumber node) => node;
+
+  @override
+  visitLiteralStatement(LiteralStatement node) => unsupported(node);
+
+  @override
+  visitLiteralString(LiteralString node) => node;
+
+  @override
+  visitNamedFunction(NamedFunction node) {
+    throw new UnimplementedError("Internal error: "
+        "Named functions are not handled yet by the javascript async "
+        "transform");
+  }
+
+  @override
+  visitNew(New node) {
+    bool storeTarget = node.arguments.any(shouldTransform);
+    return withExpression(node.target, (target) {
+      return withExpressions(node.arguments, (List<Expression> arguments) {
+        return new New(target, arguments);
+      });
+    }, store: storeTarget);
+  }
+
+  @override
+  visitObjectInitializer(ObjectInitializer node) {
+    return withExpressions(
+        node.properties.map((Property property) => property.value).toList(),
+        (List<Node> values) {
+      List<Property> properties = new List.generate(values.length, (int i) {
+        return new Property(node.properties[i].name, values[i]);
+      });
+      return new ObjectInitializer(properties);
+    });
+  }
+
+  @override
+  visitParameter(Parameter node) => unreachable(node);
+
+  @override
+  visitPostfix(Postfix node) {
+    if (node.op == "++" || node.op == "--") {
+      Expression argument = node.argument;
+      if (argument is VariableUse) {
+        return new Postfix(node.op, argument);
+      } else if (argument is PropertyAccess) {
+        return withExpression2(argument.receiver, argument.selector,
+            (receiver, selector) {
+          return new Postfix(node.op, new PropertyAccess(receiver, selector));
+        });
+      } else {
+        throw "Unexpected postfix ${node.op} "
+              "operator argument ${node.argument}";
+      }
+    }
+    return withExpression(
+        node.argument,
+        (Expression argument) => new Postfix(node.op, argument),
+        store: false);
+  }
+
+  @override
+  visitPrefix(Prefix node) {
+    if (node.op == "++" || node.op == "--") {
+      Expression argument = node.argument;
+      if (argument is VariableUse) {
+        return new Prefix(node.op, argument);
+      } else if (argument is PropertyAccess) {
+        return withExpression2(argument.receiver, argument.selector,
+            (receiver, selector) {
+          return new Prefix(node.op, new PropertyAccess(receiver, selector));
+        });
+      } else {
+        throw "Unexpected prefix ${node.op} operator "
+              "argument ${node.argument}";
+      }
+    }
+    return withExpression(
+        node.argument,
+        (Expression argument) => new Prefix(node.op, argument),
+        store: false);
+  }
+
+  @override
+  visitProgram(Program node) => throw "Unsupported";
+
+  @override
+  visitProperty(Property node) {
+    return withExpression(
+        node.value,
+        (Expression value) => new Property(node.name, value),
+        store: false);
+  }
+
+  @override
+  visitRegExpLiteral(RegExpLiteral node) => node;
+
+  @override
+  visitReturn(Return node) {
+    assert(node.value == null || !isSyncStar && !isAsyncStar);
+    Node target = analysis.targets[node];
+    if (node.value != null) {
+      withExpression(node.value, (Expression value) {
+        addStatement(js.statement("$returnValueName = #", [value]));
+      }, store: false);
+    }
+    translateJump(target, returnLabel);
+  }
+
+  @override
+  visitSwitch(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, (Expression key) {
+        List<SwitchClause> cases = node.cases.map((SwitchClause clause) {
+          if (clause is Case) {
+            return new Case(clause.expression, translateInBlock(clause.body));
+          } else if (clause is Default) {
+            return new Default(translateInBlock(clause.body));
+          }
+        }).toList();
+        addStatement(new 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);
+
+    if (!node.cases.every(
+        (SwitchClause x) => !(x is Case && shouldTransform(x.expression)))) {
+      int defaultIndex = null; // Null means no default was found.
+      // If there is an await in one of the keys, we have to use a chain of ifs.
+
+      withExpression(node.key, (Expression key) {
+        int i = 0;
+        for (SwitchClause clause in node.cases) {
+          if (clause is 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 Case) {
+            labels[i] = newLabel("case");
+            withExpression(clause.expression, (expression) {
+              addStatement(
+                  new If.noElse(new 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<SwitchClause> clauses = new List<SwitchClause>();
+      for (SwitchClause clause in node.cases) {
+        if (clause is Case) {
+          labels[i] = newLabel("case");
+          clauses.add(new Case(clause.expression, gotoAndBreak(labels[i])));
+        } else if (i is Default) {
+          labels[i] = newLabel("default");
+          clauses.add(new Default(gotoAndBreak(labels[i])));
+          hasDefault = true;
+        } else {
+          diagnosticListener.internalError(spannable,
+                                           "Unknown clause type $clause");
+        }
+        i++;
+      }
+      withExpression(node.key, (Expression key) {
+        addStatement(new 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
+  visitThis(This node) {
+    return new VariableUse(selfName);
+  }
+
+  @override
+  visitThrow(Throw node) {
+    withExpression(node.expression, (Expression expression) {
+      addStatement(new Throw(expression));
+    }, store: false);
+  }
+
+  setHandler() {
+    addExpressionStatement(
+        new Assignment(new VariableUse(handlerName), currentErrorHandler));
+  }
+
+  @override
+  void visitTry(Try node) {
+    if (!shouldTransform(node)) {
+      Block body = translateInBlock(node.body);
+      Catch catchPart = (node.catchPart == null)
+          ? null
+          : new Catch(node.catchPart.declaration,
+                    translateInBlock(node.catchPart.body));
+      Block finallyPart = (node.finallyPart == null)
+          ? null
+          : translateInBlock(node.finallyPart);
+      addStatement(new Try(body, catchPart, finallyPart));
+      return;
+    }
+    hasTryBlocks = true;
+    int handlerLabel = newLabel("catch");
+    int finallyLabel = newLabel("finally");
+    int afterFinallyLabel = newLabel("after finally");
+    errorHandlerLabels.add(handlerLabel);
+    // We set the error handler here. It must be cleared on every path out.
+    // Normal and error exit.
+    setHandler();
+    if (node.finallyPart != null) {
+      finallyLabels[node] = finallyLabel;
+      targetsAndTries.add(node);
+    }
+    visitStatement(node.body);
+    errorHandlerLabels.removeLast();
+    setHandler();
+    addStatement(js.statement("$nextName = [#];",
+        [new LiteralNumber("$afterFinallyLabel")]));
+    if (node.finallyPart != null) {
+      addGoto(finallyLabel);
+    } else {
+      addGoto(afterFinallyLabel);
+    }
+    beginLabel(handlerLabel);
+    if (node.catchPart != null) {
+      setHandler();
+      // The catch declaration name can shadow outer variables, so we need
+      // a fresh name to avoid collisions.
+      String errorRename = freshName(node.catchPart.declaration.name);
+      localVariables.add(new VariableDeclaration(errorRename));
+      variableRenamings.add(
+          new Pair(node.catchPart.declaration.name, errorRename));
+      addExpressionStatement(
+          new Assignment(new VariableUse(errorRename),
+                         new VariableUse(resultName)));
+      visitStatement(node.catchPart.body);
+      variableRenamings.removeLast();
+    }
+    if (node.finallyPart != null) {
+      targetsAndTries.removeLast();
+      // This belongs to the catch-part, but is only needed if there is a
+      // finally therefore it is in this branch.
+      addStatement(js.statement("$nextName = [#];",
+          [new LiteralNumber("$afterFinallyLabel")]));
+      beginLabel(finallyLabel);
+      visitStatement(node.finallyPart);
+      addStatement(new Comment("// goto the next finally handler"));
+      addStatement(js.statement("$gotoName = $nextName.pop();"));
+      addBreak();
+    }
+    beginLabel(afterFinallyLabel);
+  }
+
+  @override
+  visitVariableDeclaration(VariableDeclaration node) {
+    throw "TODO";
+  }
+
+  @override
+  void visitVariableDeclarationList(VariableDeclarationList node) {
+    // Declaration of local variables is hoisted outside the helper but the
+    // initialization is done here.
+    for (VariableInitialization initialization in node.declarations) {
+      VariableDeclaration declaration = initialization.declaration;
+      localVariables.add(declaration);
+      if (initialization.value != null) {
+        withExpression(initialization.value, (Expression value) {
+          addStatement(
+              new ExpressionStatement(new Assignment(declaration, value)));
+        }, store: false);
+      }
+    }
+  }
+
+  @override
+  visitVariableInitialization(VariableInitialization node) {
+    // These should be handled by visitVariableDeclarationList.
+    throw "Unexpected variableInitialization";
+  }
+
+  @override
+  visitVariableUse(VariableUse node) {
+    String renaming = variableRenamings.lastWhere(
+        (Pair renaming) => renaming.a == node.name,
+        orElse: () => new Pair(null, null)).b;
+    if (renaming == null) return node;
+    return new VariableUse(renaming);
+  }
+
+  @override
+  visitWhile(While node) {
+    if (!shouldTransform(node)) {
+      bool oldInsideUntranslated = insideUntranslatedBreakable;
+      insideUntranslatedBreakable = true;
+      withExpression(node.condition, (Expression condition) {
+        addStatement(new 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;
+    Expression condition = node.condition;
+    // If the condition is `true`, we don't need a test.
+    if (!(condition is LiteralBool && condition.value == true)) {
+      withExpression(node.condition, (Expression condition) {
+        addStatement(new If.noElse(new Prefix("!", condition),
+                                   gotoAndBreak(afterLabel)));
+      }, store: false);
+    }
+    targetsAndTries.add(node);
+    visitStatement(node.body);
+    targetsAndTries.removeLast();
+    addGoto(continueLabel);
+    beginLabel(afterLabel);
+  }
+
+  @override
+  visitDartYield(DartYield node) {
+    assert(isSyncStar || isAsyncStar);
+    if (isSyncStar) {
+      int label = newLabel("after yield");
+      withExpression(node.expression, (Expression expression) {
+        // We don't do a break here for the goto, but instead a return below.
+        addStatement(setGotoVariable(label));
+        if (node.hasStar) {
+          addStatement(new Return(new Call(yieldStarExpression, [expression])));
+        } else {
+          addStatement(new Return(expression));
+        }
+        beginLabel(label);
+      }, store: false);
+    } else {
+      int label = newLabel("after yield");
+      withExpression(node.expression, (Expression expression) {
+        // We don't do a break here for the goto, but instead a return below.
+        addStatement(setGotoVariable(label));
+        // 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>[returnLabel];
+        enclosingFinallyLabels.addAll(targetsAndTries
+            .where((Node node) => node is Try)
+            .map((Try node) => finallyLabels[node]));
+        int destinationOnCancel = enclosingFinallyLabels.removeLast();
+        addStatement(js.statement("""
+            return #thenHelper(#yieldExpression(#expression),
+                $helperName, $controllerName, function () {
+                  if (#notEmptyFinallyList) {
+                    $nextName = #finallyList;
+                  }
+                  $gotoName = #destinationOnCancel;
+                  $helperName();
+                });""",
+            {"thenHelper": thenHelper,
+             "yieldExpression": node.hasStar
+                  ? yieldStarExpression
+                  : yieldExpression,
+             "expression": expression,
+             "notEmptyFinallyList": enclosingFinallyLabels.isNotEmpty,
+             "finallyList": new ArrayInitializer(enclosingFinallyLabels.map(
+                 (int label) => new LiteralNumber("$label")).toList()),
+             "destinationOnCancel": new LiteralNumber("$destinationOnCancel")
+            }));
+        beginLabel(label);
+      }, store: false);
+    }
+  }
+}
+
+/// 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 NodeVisitor<bool> {
+  Set<Node> hasAwaitOrYield = new Set<Node>();
+
+  Map<Node, Node> targets = new Map<Node, Node>();
+  List<Node> loopsAndSwitches = new List<Node>();
+  List<LabeledStatement> labelledStatements = new List<LabeledStatement>();
+  Set<String> usedNames = new Set<String>();
+
+  bool hasExplicitReturns = false;
+
+  bool hasThis = false;
+
+  // The function currently being analyzed.
+  Fun currentFunction;
+
+  // For error messages.
+  final Function unsupported;
+
+  PreTranslationAnalysis(this.unsupported);
+
+  bool visit(Node node) {
+    bool containsAwait = node.accept(this);
+    if (containsAwait) {
+      hasAwaitOrYield.add(node);
+    }
+    return containsAwait;
+  }
+
+  analyze(Fun node) {
+    currentFunction = node;
+    node.params.forEach(visit);
+    visit(node.body);
+  }
+
+  @override
+  bool visitAccess(PropertyAccess node) {
+    bool receiver = visit(node.receiver);
+    bool selector = visit(node.selector);
+    return receiver || selector;
+  }
+
+  @override
+  bool visitArrayHole(ArrayHole node) {
+    return false;
+  }
+
+  @override
+  bool visitArrayInitializer(ArrayInitializer node) {
+    bool containsAwait = false;
+    for (Expression element in node.elements) {
+      if (visit(element)) containsAwait = true;
+    }
+    return containsAwait;
+  }
+
+  @override
+  bool visitAssignment(Assignment node) {
+    bool leftHandSide = visit(node.leftHandSide);
+    bool value = (node.value == null) ? false : visit(node.value);
+    return leftHandSide || value;
+  }
+
+  @override
+  bool visitAwait(Await node) {
+    visit(node.expression);
+    return true;
+  }
+
+  @override
+  bool visitBinary(Binary node) {
+    bool left = visit(node.left);
+    bool right = visit(node.right);
+    return left || right;
+  }
+
+  @override
+  bool visitBlob(Blob node) {
+    return false;
+  }
+
+  @override
+  bool visitBlock(Block node) {
+    bool containsAwait = false;
+    for (Statement statement in node.statements) {
+      if (visit(statement)) containsAwait = true;
+    }
+    return containsAwait;
+  }
+
+  @override
+  bool visitBreak(Break node) {
+    if (node.targetLabel != null) {
+      targets[node] = labelledStatements.lastWhere(
+          (LabeledStatement statement) => statement.label == node.targetLabel);
+    } else {
+      targets[node] = loopsAndSwitches.last;
+    }
+    return false;
+  }
+
+  @override
+  bool visitCall(Call node) {
+    bool containsAwait = visit(node.target);
+    for (Expression argument in node.arguments) {
+      if (visit(argument)) containsAwait = true;
+    }
+    return containsAwait;
+  }
+
+  @override
+  bool visitCase(Case node) {
+    bool expression = visit(node.expression);
+    bool body = visit(node.body);
+    return expression || body;
+  }
+
+  @override
+  bool visitCatch(Catch node) {
+    bool declaration = visit(node.declaration);
+    bool body = visit(node.body);
+    return declaration || body;
+  }
+
+  @override
+  bool visitComment(Comment node) {
+    return false;
+  }
+
+  @override
+  bool visitConditional(Conditional node) {
+    bool condition = visit(node.condition);
+    bool then = visit(node.then);
+    bool otherwise = visit(node.otherwise);
+    return condition || then || otherwise;
+  }
+
+  @override
+  bool visitContinue(Continue node) {
+    if (node.targetLabel != null) {
+      targets[node] = labelledStatements.lastWhere(
+          (LabeledStatement stm) => stm.label == node.targetLabel);
+    } else {
+      targets[node] =
+          loopsAndSwitches.lastWhere((Node node) => node is! Switch);
+    }
+    assert(targets[node] is Loop || targets[node] is LabeledStatement);
+    return false;
+  }
+
+  @override
+  bool visitDefault(Default node) {
+    return visit(node.body);
+  }
+
+  @override
+  bool visitDo(Do node) {
+    loopsAndSwitches.add(node);
+    bool body = visit(node.body);
+    bool condition = visit(node.condition);
+    loopsAndSwitches.removeLast();
+    return body || condition;
+  }
+
+  @override
+  bool visitEmptyStatement(EmptyStatement node) {
+    return false;
+  }
+
+  @override
+  bool visitExpressionStatement(ExpressionStatement node) {
+    return visit(node.expression);
+  }
+
+  @override
+  bool visitFor(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(ForIn node) {
+    bool object = visit(node.object);
+    loopsAndSwitches.add(node);
+    bool body = visit(node.body);
+    loopsAndSwitches.removeLast();
+    return object || body;
+  }
+
+  @override
+  bool visitFun(Fun node) {
+    return false;
+  }
+
+  @override
+  bool visitFunctionDeclaration(FunctionDeclaration node) {
+    return false;
+  }
+
+  @override
+  bool visitIf(If node) {
+    bool condition = visit(node.condition);
+    bool then = visit(node.then);
+    bool otherwise = visit(node.otherwise);
+    return condition || then || otherwise;
+  }
+
+  @override
+  bool visitInterpolatedExpression(InterpolatedExpression node) {
+    return unsupported(node);
+  }
+
+  @override
+  bool visitInterpolatedLiteral(InterpolatedLiteral node) {
+    return unsupported(node);
+  }
+
+  @override
+  bool visitInterpolatedParameter(InterpolatedParameter node) {
+    return unsupported(node);
+  }
+
+  @override
+  bool visitInterpolatedSelector(InterpolatedSelector node) {
+    return unsupported(node);
+  }
+
+  @override
+  bool visitInterpolatedStatement(InterpolatedStatement node) {
+    return unsupported(node);
+  }
+
+  @override
+  bool visitLabeledStatement(LabeledStatement node) {
+    usedNames.add(node.label);
+    labelledStatements.add(node);
+    bool containsAwait = visit(node.body);
+    labelledStatements.removeLast();
+    return containsAwait;
+  }
+
+  @override
+  bool visitLiteralBool(LiteralBool node) {
+    return false;
+  }
+
+  @override
+  bool visitLiteralExpression(LiteralExpression node) {
+    return unsupported(node);
+  }
+
+  @override
+  bool visitLiteralNull(LiteralNull node) {
+    return false;
+  }
+
+  @override
+  bool visitLiteralNumber(LiteralNumber node) {
+    return false;
+  }
+
+  @override
+  bool visitLiteralStatement(LiteralStatement node) {
+    return unsupported(node);
+  }
+
+  @override
+  bool visitLiteralString(LiteralString node) {
+    return false;
+  }
+
+  @override
+  bool visitNamedFunction(NamedFunction node) {
+    return false;
+  }
+
+  @override
+  bool visitNew(New node) {
+    return visitCall(node);
+  }
+
+  @override
+  bool visitObjectInitializer(ObjectInitializer node) {
+    bool containsAwait = false;
+    for (Property property in node.properties) {
+      if (visit(property)) containsAwait = true;
+    }
+    return containsAwait;
+  }
+
+  @override
+  bool visitParameter(Parameter node) {
+    usedNames.add(node.name);
+    return false;
+  }
+
+  @override
+  bool visitPostfix(Postfix node) {
+    return visit(node.argument);
+  }
+
+  @override
+  bool visitPrefix(Prefix node) {
+    return visit(node.argument);
+  }
+
+  @override
+  bool visitProgram(Program node) {
+    throw "Unexpected";
+  }
+
+  @override
+  bool visitProperty(Property node) {
+    return visit(node.value);
+  }
+
+  @override
+  bool visitRegExpLiteral(RegExpLiteral node) {
+    return false;
+  }
+
+  @override
+  bool visitReturn(Return node) {
+    hasExplicitReturns = true;
+    targets[node] = currentFunction;
+    if (node.value == null) return false;
+    return visit(node.value);
+  }
+
+  @override
+  bool visitSwitch(Switch node) {
+    loopsAndSwitches.add(node);
+    bool result = visit(node.key);
+    for (SwitchClause clause in node.cases) {
+      if (visit(clause)) result = true;
+    }
+    loopsAndSwitches.removeLast();
+    return result;
+  }
+
+  @override
+  bool visitThis(This node) {
+    hasThis = true;
+    return false;
+  }
+
+  @override
+  bool visitThrow(Throw node) {
+    return visit(node.expression);
+  }
+
+  @override
+  bool visitTry(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(VariableDeclaration node) {
+    usedNames.add(node.name);
+    return false;
+  }
+
+  @override
+  bool visitVariableDeclarationList(VariableDeclarationList node) {
+    bool result = false;
+    for (VariableInitialization init in node.declarations) {
+      if (visit(init)) result = true;
+    }
+    return result;
+  }
+
+  @override
+  bool visitVariableInitialization(VariableInitialization node) {
+    return visitAssignment(node);
+  }
+
+  @override
+  bool visitVariableUse(VariableUse node) {
+    usedNames.add(node.name);
+    return false;
+  }
+
+  @override
+  bool visitWhile(While node) {
+    loopsAndSwitches.add(node);
+    bool condition = visit(node.condition);
+    bool body = visit(node.body);
+    loopsAndSwitches.removeLast();
+    return condition || body;
+  }
+
+  @override
+  bool visitDartYield(DartYield node) {
+    visit(node.expression);
+    return true;
+  }
+}