Fix a bug with await in finally.

lib/transformations/continuation.dart

 // Copyright (c) 2016, 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 kernel.transformations.continuation;
 
 import 'dart:math' as math;
 
 import '../ast.dart';
 import '../visitor.dart';
@@ skipping 163 matching lines @@
 }
 
 abstract class AsyncRewriterBase extends ContinuationRewriterBase {
   final VariableDeclaration nestedClosureVariable =
       new VariableDeclaration(":async_op");
   final VariableDeclaration thenContinuationVariable =
       new VariableDeclaration(":async_op_then");
   final VariableDeclaration catchErrorContinuationVariable =
       new VariableDeclaration(":async_op_error");
 
+  LabeledStatement labeledBody;
+
   ExpressionLifter expressionRewriter;
 
   AsyncRewriterBase(helper, enclosingFunction)
       // Body is wrapped in the try-catch so initial currentTryDepth is 1.
       : super(helper, enclosingFunction, currentTryDepth: 1) {}
 
   void setupAsyncContinuations(List<Statement> statements) {
     expressionRewriter = new ExpressionLifter(this);
 
     // var :async_op_then;
@@ skipping 38 matching lines @@
     final boundCatchErrorClosure = new StaticInvocation(
         helper.asyncErrorWrapper,
         new Arguments(<Expression>[new VariableGet(nestedClosureVariable)]));
     final catchErrorClosureVariableAssign = new ExpressionStatement(
         new VariableSet(
             catchErrorContinuationVariable, boundCatchErrorClosure));
     statements.add(catchErrorClosureVariableAssign);
   }
 
   Statement buildWrappedBody() {
-    // No explicit return at the end of the body => we will add one!
-    var body = addReturnStatementIfNecessary(enclosingFunction.body);
-    var userBody = visitDelimited(body);
+    labeledBody = new LabeledStatement(null);
+    labeledBody.body = visitDelimited(enclosingFunction.body)
+      ..parent = labeledBody;
 
     var exceptionVariable = new VariableDeclaration(":exception");
     var stackTraceVariable = new VariableDeclaration(":stack_trace");
 
-    var completeErrorStatement =
-        buildCatchBody(exceptionVariable, stackTraceVariable);
-
-    var catchBody = new Block(<Statement>[completeErrorStatement]);
-    var catches = <Catch>[
-      new Catch(exceptionVariable, catchBody, stackTrace: stackTraceVariable)
-    ];
-    return new TryCatch(userBody, catches);
-  }
-
-  Statement addReturnStatementIfNecessary(Statement body) {
-    if (body is Block) {
-      Block block = body;
-      if (block.statements.isEmpty ||
-          block.statements.last is! ReturnStatement) {
-        var returnStatement = new ReturnStatement();
-        block.statements.add(returnStatement);
-        returnStatement.parent = block;
-      }
-    } else if (body is! ReturnStatement) {
-      var returnStatement = new ReturnStatement();
-      body = new Block(<Statement>[body, returnStatement]);
-    }
-    return body;
+    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>[];
 
   TreeNode visitInvalidStatement(InvalidStatement stmt) {
     statements.add(stmt);
     return null;
   }
 
   TreeNode visitExpressionStatement(ExpressionStatement stmt) {
     stmt.expression = expressionRewriter.rewrite(stmt.expression, statements)
       ..parent = stmt;
@@ skipping 309 matching lines @@
     stmt.condition = expressionRewriter.rewrite(stmt.condition, statements)
       ..parent = stmt;
     stmt.then = visitDelimited(stmt.then)..parent = stmt;
     if (stmt.otherwise != null) {
       stmt.otherwise = visitDelimited(stmt.otherwise)..parent = stmt;
     }
     statements.add(stmt);
     return null;
   }
 
-  TreeNode visitReturnStatement(ReturnStatement stmt) {
-    if (stmt.expression != null) {
-      stmt.expression = expressionRewriter.rewrite(stmt.expression, statements)
-        ..parent = stmt;
-    }
-    statements.add(stmt);
-    return null;
-  }
-
   TreeNode visitTryCatch(TryCatch stmt) {
     ++currentTryDepth;
     stmt.body = visitDelimited(stmt.body)..parent = stmt;
     --currentTryDepth;
 
     ++currentCatchDepth;
     for (var clause in stmt.catches) {
       clause.body = visitDelimited(clause.body)..parent = clause;
     }
     --currentCatchDepth;
@@ skipping 41 matching lines @@
   AsyncStarFunctionRewriter(helper, enclosingFunction)
       : super(helper, enclosingFunction);
 
   FunctionNode rewrite() {
     var statements = <Statement>[];
 
     // var :controller;
     controllerVariable = new VariableDeclaration(":controller");
     statements.add(controllerVariable);
 
-    super.setupAsyncContinuations(statements);
+    setupAsyncContinuations(statements);
 
     // :controller = new _AsyncController(:async_op);
     var arguments =
         new Arguments(<Expression>[new VariableGet(nestedClosureVariable)]);
     var buildController = new ConstructorInvocation(
         helper.streamControllerConstructor, arguments);
     var setController = new ExpressionStatement(
         new VariableSet(controllerVariable, buildController));
     statements.add(setController);
 
@@ skipping 12 matching lines @@
   Statement buildCatchBody(exceptionVariable, stackTraceVariable) {
     return new ExpressionStatement(new MethodInvocation(
         new VariableGet(controllerVariable),
         new Name("completeError", helper.asyncLibrary),
         new Arguments(<Expression>[
           new VariableGet(exceptionVariable),
           new VariableGet(stackTraceVariable)
         ])));
   }
 
+  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);
 
     var addExpression = new MethodInvocation(
         new VariableGet(controllerVariable),
         new Name(stmt.isYieldStar ? 'addStream' : 'add', helper.asyncLibrary),
         new Arguments(<Expression>[expr]));
 
     statements.add(new IfStatement(addExpression,
         new ReturnStatement(new NullLiteral()), createContinuationPoint()));
     return null;
   }
 
   TreeNode visitReturnStatement(ReturnStatement node) {
-    // async* functions cannot have normal [ReturnStatement]s in them.
+    // Async* functions cannot return a value.
     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());
+    statements
+        .add(new BreakStatement(labeledBody)..fileOffset = node.fileOffset);
     return null;
   }
 }
 
 class AsyncFunctionRewriter extends AsyncRewriterBase {
   VariableDeclaration completerVariable;
+  VariableDeclaration returnVariable;
 
   AsyncFunctionRewriter(helper, enclosingFunction)
       : super(helper, enclosingFunction);
 
   FunctionNode rewrite() {
     var statements = <Statement>[];
 
     // var :completer = new Completer.sync();
     completerVariable = new VariableDeclaration(":completer",
         initializer: new StaticInvocation(
             helper.completerConstructor, new Arguments([])),
         isFinal: true);
     statements.add(completerVariable);
 
-    super.setupAsyncContinuations(statements);
+    returnVariable = new VariableDeclaration(":return_value");
+    statements.add(returnVariable);
+
+    setupAsyncContinuations(statements);
 
     // new Future.microtask(:async_op);
     var newMicrotaskStatement = new ExpressionStatement(new StaticInvocation(
         helper.futureMicrotaskConstructor,
         new Arguments([new VariableGet(nestedClosureVariable)])));
     statements.add(newMicrotaskStatement);
 
     // return :completer.future;
     var completerGet = new VariableGet(completerVariable);
     var returnStatement = new ReturnStatement(
         new PropertyGet(completerGet, new Name('future', helper.asyncLibrary)));
     statements.add(returnStatement);
 
     enclosingFunction.body = new Block(statements);
     enclosingFunction.body.parent = enclosingFunction;
     enclosingFunction.asyncMarker = AsyncMarker.Sync;
     return enclosingFunction;
   }
 
   Statement buildCatchBody(exceptionVariable, stackTraceVariable) {
     return new ExpressionStatement(new MethodInvocation(
         new VariableGet(completerVariable),
         new Name("completeError", helper.asyncLibrary),
         new Arguments([
           new VariableGet(exceptionVariable),
           new VariableGet(stackTraceVariable)
         ])));
   }
 
+  Statement buildReturn(Statement body) {
+    // Returns from the body have all been translated into assignments to the
+    // return value variable followed by a break from the labeled body.
+    return new Block(<Statement>[
+      body,
+      new ExpressionStatement(new MethodInvocation(
+          new VariableGet(completerVariable),
+          new Name("complete", helper.asyncLibrary),
+          new Arguments([new VariableGet(returnVariable)]))),
+      new ReturnStatement()
+    ]);
+  }
+
   visitReturnStatement(ReturnStatement node) {
-    var expr;
-    if (node.expression == null) {
-      expr = new NullLiteral();
-    } else {
-      expr = expressionRewriter.rewrite(node.expression, statements);
-    }
-
-    statements.add(new ExpressionStatement(new MethodInvocation(
-        new VariableGet(completerVariable),
-        new Name("complete", helper.asyncLibrary),
-        new Arguments([expr]))));
-    statements.add(new ReturnStatement(new NullLiteral()));
+    var expr = node.expression == null
+        ? new NullLiteral()
+        : expressionRewriter.rewrite(node.expression, statements);
+    statements
+        .add(new ExpressionStatement(new VariableSet(returnVariable, expr)));
+    statements
+        .add(new BreakStatement(labeledBody)..fileOffset = node.fileOffset);
     return null;
   }
 }
 
 class HelperNodes {
   final Library asyncLibrary;
   final Library coreLibrary;
   final Procedure printProcedure;
   final Procedure completerConstructor;
   final Procedure futureMicrotaskConstructor;
@@ skipping 84 matching lines @@
         findFactoryConstructor(completerClass, 'sync'),
         findConstructor(syncIterableClass, ''),
         findConstructor(streamIteratorClass, ''),
         findFactoryConstructor(futureClass, 'microtask'),
         findConstructor(streamControllerClass, ''),
         findProcedure(asyncLibrary, '_asyncThenWrapperHelper'),
         findProcedure(asyncLibrary, '_asyncErrorWrapperHelper'),
         findProcedure(asyncLibrary, '_awaitHelper'));
   }
 }