Initialize "next" variable in async rewrite whenever there is a finally.

pkg/compiler/lib/src/js/rewrite_async.dart

 // Copyright (c) 2015, 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 rewrite_async;
 
 import "dart:math" show max;
 import 'dart:collection';
 
 import 'package:_internal/compiler/js_lib/shared/async_await_error_codes.dart'
@@ skipping 342 matching lines @@
   /// The order is important, therefore the type is explicitly LinkedHashMap.
   LinkedHashMap<int, List<js.Statement>> labelledParts =
       new LinkedHashMap<int, List<js.Statement>>();
 
   /// Description of each label for readability of the non-minified output.
   Map<int, String> labelComments = new Map<int, String>();
 
   /// True if the function has any try blocks containing await.
   bool hasTryBlocks = false;
 
-  /// True if any return, break or continue passes through a finally.
-  bool hasJumpThroughFinally = false;
-
   /// True if the traversion currently is inside a loop or switch for which
   /// [shouldTransform] is false.
   bool insideUntranslatedBreakable = false;
 
   /// True if a label is used to break to an outer switch-statement.
   bool hasJumpThoughOuterLabel = false;
 
   /// True if there is a catch-handler protected by a finally with no enclosing
   /// catch-handlers.
   bool needsRethrow = false;
@@ skipping 462 matching lines @@
 
     inits.add(makeInit(gotoName, js.number(0)));
     if (isAsync) {
       inits.add(makeInit(completerName, new js.New(newCompleter, [])));
     } else if (isAsyncStar) {
       inits.add(makeInit(controllerName,
           new js.Call(newController, [new js.VariableUse(bodyName)])));
     }
     inits.add(makeInit(handlerName, js.number(rethrowLabel)));
     inits.add(makeInit(currentErrorName, null));
-    if (hasJumpThroughFinally || analysis.hasYield) {
+    if (analysis.hasFinally) {

[sigurdm, 2015/02/24 10:06:49]

Should be 
if (analysis.hasFinally || (isAsyncStar && analysis.hasYield)) {

[zarah, 2015/02/24 10:28:44]

Done.

       inits.add(makeInit(nextName, null));
     }
     if (isAsyncStar && analysis.hasYield) {
       inits.add(makeInit(nextWhenCanceledName, null));
     }
     if (analysis.hasExplicitReturns && isAsync) {
       inits.add(makeInit(returnValueName, null));
     }
     if (analysis.hasThis && !isSyncStar) {
       // Sync* functions must remember `this` on the level of the outer
@@ skipping 310 matching lines @@
         jumpStack.add(targetLabel);
         break;
       }
       // Ignore other nodes.
     }
     jumpStack = jumpStack.reversed.toList();
     // As the program jumps directly to the top of the stack, it is taken off
     // now.
     int firstTarget = jumpStack.removeLast();
     if (jumpStack.isNotEmpty) {
-      hasJumpThroughFinally = true;
       js.Expression jsJumpStack = new js.ArrayInitializer(
           jumpStack.map((int label) => js.number(label)).toList());
       addStatement(js.js.statement("# = #", [nextName, jsJumpStack]));
     }
     addGoto(firstTarget);
   }
 
   @override
   void visitDefault(js.Default node) => unreachable(node);
 
@@ skipping 708 matching lines @@
   List<js.LabeledStatement> labelledStatements =
       new List<js.LabeledStatement>();
   Set<String> usedNames = new Set<String>();
 
   bool hasExplicitReturns = false;
 
   bool hasThis = false;
 
   bool hasYield = false;
 
+  bool hasFinally = false;
+
   // The function currently being analyzed.
   js.Fun currentFunction;
 
   // For error messages.
   final Function unsupported;
 
   PreTranslationAnalysis(void this.unsupported(js.Node node));
 
   bool visit(js.Node node) {
     bool containsAwait = node.accept(this);
@@ skipping 335 matching lines @@
   bool visitThrow(js.Throw node) {
     return visit(node.expression);
   }
 
   @override
   bool visitTry(js.Try node) {
     bool body = visit(node.body);
     bool catchPart = (node.catchPart == null) ? false : visit(node.catchPart);
     bool finallyPart =
         (node.finallyPart == null) ? false : visit(node.finallyPart);
+    if (finallyPart != null) hasFinally = true;
     return body || catchPart || finallyPart;
   }
 
   @override
   bool visitVariableDeclaration(js.VariableDeclaration node) {
     usedNames.add(node.name);
     return false;
   }
 
   @override
@@ skipping 25 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }