anchor.diff:      continueTargets = <JumpTarget>[];
       currentExceptionName = null;
       currentStackTraceName = null;
  +    currentStream = null;
       awaits = analysis.awaits;
       labels = analysis.labels;
       names = analysis.names;
  
positive.code:     });
    };
  
    visitForEachStatement(ast.ForEachStatement node) {
      var stmt = make.emptyBlock();
      var it = newName('it');
      stmt.statements.add(
  
negative.code:               scanner.Keyword.keywords[node.loopVariable.keyword.lexeme],
                [make.variableDeclaration(
                     node.loopVariable.identifier.name,
                     make.propertyAccess(make.identifier(it), 'current'))],
                node.loopVariable.type),
             node.body]);
      }
      stmt.statements.add(make.whileStatement(
          make.methodInvocation(make.identifier(it), 'moveNext', []),
          body));
      return stmt;
    }
  
    visitForEachStatement(ast.ForEachStatement node) {
      if (node.awaitKeyword == null) {
        var stmt = _translateSynchronousForEach(node);
        return visitBlock(stmt);
      }
      return (rk, ek, sk) {
        return visit(node.iterator)(ek, (expr) {
          if (currentStream != null) {
            addStatement(make.methodInvocation(
                make.identifier(currentStream), 'pause', []));
          }
  
          var streamName = newName('s');
          var savedBlock = currentBlock;
          var doneBlock = currentBlock = make.emptyBlock();
          if (currentStream != null) {
            addStatement(make.methodInvocation(
                make.identifier(currentStream), 'resume', []));
          }
          sk();
  
          var listenBlock = currentBlock = make.emptyBlock();
          var parameter = newName('x');
          if (node.identifier != null) {
            addStatement(make.assignmentExpression(
                node.identifier, make.identifier(parameter)));
          } else {
            assert(node.loopVariable != null);
            addStatement(make.variableDeclarationStatement(
                scanner.Keyword.keywords[node.loopVariable.keyword.lexeme],
                [make.variableDeclaration(
                     node.loopVariable.identifier.name,
                     make.identifier(parameter))],
                node.loopVariable.type));
          }
  
          var savedStream = currentStream;
          currentStream = streamName;
          visit(node.body)((v) {
            if (savedStream != null) {
              addStatement(make.methodInvocation(
                  make.identifier(savedStream), 'resume', []));
            }
            return rk(v);
          }, ek, () {});
  
          currentStream = savedStream;
          currentBlock = savedBlock;
          if (currentStream != null) {
            addStatement(make.methodInvocation(
                make.identifier(currentStream), 'pause', []));
          }
          // A declaration and then assignment of the stream is required here,
          // because the stream occurs in the closure on the right-hand side
          // of the initialization/assignment.
          addStatement(make.variableDeclarationStatement(
              scanner.Keyword.VAR, [make.variableDeclaration(streamName)]));
          addStatement(make.assignmentExpression(
              make.identifier(streamName),
              make.methodInvocation(expr, 'listen',
                  [make.functionExpression([parameter], listenBlock),
                   make.namedExpression('onDone',
                       make.functionExpression([], doneBlock))])));
        });
      };
    }
  
    _translateForUpdaters(List<ast.Expression> exprs, ek, sk) {
  