anchor.diff:  
       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');
  
positive.code:         findProcedure(coreLibrary, 'print'),
          findFactoryConstructor(completerClass, 'sync'),
          findConstructor(syncIterableClass, ''),
          findFactoryConstructor(futureClass, 'microtask'),
          findConstructor(streamControllerClass, ''),
          findProcedure(asyncLibrary, '_asyncThenWrapperHelper'),
  
negative.code:   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);
    }
  