anchor.diff:    Statement buildCatchBody(Statement exceptionVariable,
                              Statement stackTraceVariable);
   
  +  visitForInStatement(ForInStatement node) {
  +    if (node.isAsync) {
  +      // Transform
  +      //
  +      //   await for (var variable in <stream-expression>) { ... }
  +      //
  +      // To:
  +      //
  +      //   {
  +      //     var :for-iterator = new StreamIterator(<stream-expression>);
  +      //     try {
  +      //       while (await :for-iterator.moveNext()) {
  +      //         var <variable> = :for-iterator.current;
  +      //         ...
  +      //       }
  +      //     } finally {
  +      //       :for-iterator.cancel();
  +      //     }
  +      //   }
  +      var iteratorVariable = new VariableDeclaration(
  +          ':for-iterator',
  +          initializer: new ConstructorInvocation(
  +            helper.streamIteratorConstructor,
  +            new Arguments([expressionRewriter.rewrite(node.iterable)])));
  +
  +      // await iterator.moveNext()
  +      var condition = new AwaitExpression(new MethodInvocation(
  +            new VariableGet(iteratorVariable),
  +            new Name('moveNext'),
  +            new Arguments([])));
  +
  +      // var <variable> = iterator.current;
  +      var valueVariable = node.variable;
  +      valueVariable.initializer = new PropertyGet(
  +          new VariableGet(iteratorVariable),
  +          new Name('current'));
  +      valueVariable.initializer.parent = valueVariable;
  +
  +      var whileBody = new Block([valueVariable, node.body]);
  +      var tryBody = new WhileStatement(condition, whileBody);
  +
  +      // iterator.cancel();
  +      var tryFinalizer = new ExpressionStatement(
  +          new MethodInvocation(
  +            new VariableGet(iteratorVariable),
  +            new Name('cancel'),
  +            new Arguments([])));
  +
  +      var tryFinally = new TryFinally(tryBody, tryFinalizer);
  +
  +      var block = new Block([
  +          iteratorVariable,
  +          tryFinally,
  +      ]);
  +      return block.accept(this);
  +    } else {
  +      return super.visitForInStatement(node);
  +    }
  +  }
  +
     defaultExpression(TreeNode node) {
       return expressionRewriter.rewrite(node);
     }
  
positive.code:         findProcedure(coreLibrary, 'print'),
          findFactoryConstructor(completerClass, 'sync'),
          findConstructor(syncIterableClass, ''),
          findFactoryConstructor(futureClass, 'microtask'),
          findConstructor(streamControllerClass, ''),
          findProcedure(asyncLibrary, '_asyncThenWrapperHelper'),
  
negative.code: 
      var completerClass = findClass(asyncLibrary, 'Completer');
      var futureClass = findClass(asyncLibrary, 'Future');
      var streamIteratorClass = findClass(asyncLibrary, '_StreamIteratorImpl');
      var syncIterableClass = findClass(coreLibrary, '_SyncIterable');
      var streamControllerClass = findClass(
          asyncLibrary, '_AsyncStarStreamController');
  