dart2js: Do not use the async rewriter on nested functions.

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:js_runtime/shared/async_await_error_codes.dart'
     as error_codes;
 
 import "js.dart" as js;
 
 import '../common.dart';
 import '../util/util.dart' show
     Pair;
 
 /// Rewrites a [js.Fun] with async/sync*/async* functions and await and yield
 /// (with dart-like semantics) to an equivalent function without these.
 /// await-for is not handled and must be rewritten before. (Currently handled
 /// in ssa/builder.dart).
 ///
 /// When generating the input to this, special care must be taken that
 /// parameters to sync* functions that are mutated in the body must be boxed.
 /// (Currently handled in closure.dart).
 ///
-/// Look at [visitFun], [visitDartYield] and [visitAwait] for more explanation.
+/// Look at [rewriteFunction], [visitDartYield] and [visitAwait] for more
+/// explanation.
 abstract class AsyncRewriterBase extends js.NodeVisitor {
 
   // Local variables are hoisted to the top of the function, so they are
   // collected here.
   List<js.VariableDeclaration> localVariables =
       new List<js.VariableDeclaration>();
 
   Map<js.Node, int> continueLabels = new Map<js.Node, int>();
   Map<js.Node, int> breakLabels = new Map<js.Node, int>();
 
@@ skipping 161 matching lines @@
     gotoName = freshName("goto");
     handlerName = freshName("handler");
     nextName = freshName("next");
     returnValueName = freshName("returnValue");
     currentErrorName = freshName("currentError");
     outerLabelName = freshName("outer");
     selfName = freshName("self");
     // Initialize names specific to the subclass.
     initializeNames();
 
-    return node.accept(this);
+    return rewriteFunction(node);
   }
 
   js.Expression get currentErrorHandler {
     return js.number(handlerLabels[jumpTargets.lastWhere(
         (node) => handlerLabels[node] != null)]);
   }
 
   int allocateTempVar() {
     assert(tempVarHighWaterMark >= currentTempVarIndex);
     currentTempVarIndex++;
@@ skipping 437 matching lines @@
   ///         case 7: // return
   ///           return thenHelper(returnValue, 0, completer);
   ///         case 8: // Rethrow
   ///           return thenHelper(currentError, 1, completer);
   ///       }
   ///     }
   ///     return thenHelper(null, helper, completer);
   ///   }
   /// }
   ///
-  @override
-  js.Expression visitFun(js.Fun node) {
+  js.Expression rewriteFunction(js.Fun node) {
     beginLabel(newLabel("Function start"));
     // AsyncStar needs a returnlabel for its handling of cancelation. See
     // [visitDartYield].
     exitLabel = (analysis.hasExplicitReturns || isAsyncStar)
         ? newLabel("return")
         : null;
     rethrowLabel = newLabel("rethrow");
     handlerLabels[node] = rethrowLabel;
     js.Statement body = node.body;
     jumpTargets.add(node);
@@ skipping 33 matching lines @@
     }));
     variables.addAll(new Iterable.generate(tempVarHighWaterMark,
         (int i) => _makeVariableInitializer(useTempVar(i + 1).name, null)));
     js.VariableDeclarationList variableDeclarations =
         new js.VariableDeclarationList(variables);
 
     return finishFunction(node.params, rewrittenBody, variableDeclarations);
   }
 
   @override
+  js.Expression visitFun(js.Fun node) {
+    if (node.asyncModifier.isAsync || node.asyncModifier.isYielding) {
+      // The translation does not handle nested functions that are generators
+      // or asynchronous.  These functions should only be ones that are
+      // introduced by JS foreign code from our own libraries.
+      reporter.internalError(spannable,
+          'Nested function is a generator or asynchronous.');
+    }
+    return node;
+  }
+
+  @override
   js.Expression visitAccess(js.PropertyAccess node) {
     return withExpression2(node.receiver, node.selector,
         (receiver, selector) => js.js('#[#]', [receiver, selector]));
   }
 
   @override
   js.Expression visitArrayHole(js.ArrayHole node) {
     return node;
   }
 
@@ skipping 32 matching lines @@
       });
     } else {
       throw "Unexpected assignment left hand side $leftHandSide";
     }
   }
 
   js.Statement awaitStatement(js.Expression value);
 
   /// An await is translated to an [awaitStatement].
   ///
-  /// See the comments of [visitFun] for an example.
+  /// See the comments of [rewriteFunction] for an example.
   @override
   js.Expression visitAwait(js.Await node) {
     assert(isAsync || isAsyncStar);
     int afterAwait = newLabel("returning from await.");
     withExpression(node.expression, (js.Expression value) {
       addStatement(setGotoVariable(afterAwait));
       addStatement(awaitStatement(value));
     }, store: false);
     beginLabel(afterAwait);
     return result;
@@ skipping 136 matching lines @@
     } else {
       addStatement(new js.Break(null));
     }
   }
 
   /// Common code for handling break, continue, return.
   ///
   /// It is necessary to run all nesting finally-handlers between the jump and
   /// the target. For that [next] is used as a stack of places to go.
   ///
-  /// See also [visitFun].
+  /// See also [rewriteFunction].
   void translateJump(js.Node target, int targetLabel) {
     // Compute a stack of all the 'finally' nodes that must be visited before
     // the jump.
     // The bottom of the stack is the label where the jump goes to.
     List<int> jumpStack = new List<int>();
     for (js.Node node in jumpTargets.reversed) {
       if (finallyLabels[node] != null) {
         jumpStack.add(finallyLabels[node]);
       } else if (node == target) {
         jumpStack.add(targetLabel);
@@ skipping 482 matching lines @@
         break;
       }
       int finallyLabel = finallyLabels[node];
       if (finallyLabel != null) {
         result.add(finallyLabel);
       }
     }
     return result.reversed.toList();
   }
 
-  /// See the comments of [visitFun] for more explanation.
+  /// See the comments of [rewriteFunction] for more explanation.
   void visitTry(js.Try node) {
     if (!shouldTransform(node)) {
       js.Block body = translateInBlock(node.body);
       js.Catch catchPart = (node.catchPart == null)
           ? null
           : new js.Catch(node.catchPart.declaration,
               translateInBlock(node.catchPart.body));
       js.Block finallyPart = (node.finallyPart == null)
           ? null
           : translateInBlock(node.finallyPart);
@@ skipping 1135 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }