anchor.diff:          ])));
     }
   
  +  Statement buildReturn(Statement body) {
  +    // Async* functions cannot return a value.  The returns from the function
  +    // have been translated into breaks from the labeled body.
  +    return new Block(<Statement>[
  +      body,
  +      new ExpressionStatement(new MethodInvocation(
  +          new VariableGet(controllerVariable),
  +          new Name("close", helper.asyncLibrary),
  +          new Arguments(<Expression>[]))),
  +      new ReturnStatement()
  +    ]);
  +  }
  +
     TreeNode visitYieldStatement(YieldStatement stmt) {
       Expression expr = expressionRewriter.rewrite(stmt.expression, statements);
   
  
positive.code:   }
  
    TreeNode visitReturnStatement(ReturnStatement node) {
      // async* functions cannot have normal [ReturnStatement]s in them.
      assert(node.expression == null || node.expression is NullLiteral);
  
      statements.add(new ExpressionStatement(new MethodInvocation(
          new VariableGet(controllerVariable),
          new Name("close", helper.asyncLibrary),
          new Arguments(<Expression>[]))));
      statements.add(new ReturnStatement());
      return null;
    }
  }
  
  class AsyncFunctionRewriter extends AsyncRewriterBase {
    VariableDeclaration completerVariable;
  
    AsyncFunctionRewriter(helper, enclosingFunction)
        : super(helper, enclosingFunction);
  
negative.code:   }
  
    Statement buildWrappedBody() {
      labeledBody = new LabeledStatement(null);
      labeledBody.body = visitDelimited(enclosingFunction.body)
        ..parent = labeledBody;
  
      var exceptionVariable = new VariableDeclaration(":exception");
      var stackTraceVariable = new VariableDeclaration(":stack_trace");
  
      return new TryCatch(buildReturn(labeledBody), <Catch>[
        new Catch(
            exceptionVariable,
            new Block(<Statement>[
              buildCatchBody(exceptionVariable, stackTraceVariable)
            ]),
            stackTrace: stackTraceVariable)
      ]);
    }
  
    Statement buildCatchBody(
        Statement exceptionVariable, Statement stackTraceVariable);
  
    Statement buildReturn(Statement body);
  
    List<Statement> statements = <Statement>[];
  
  