Rename the inner function of async 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:_internal/compiler/js_lib/shared/async_await_error_codes.dart'
@@ skipping 99 matching lines @@
   ///
   /// It is a parameter to the [body] function, so that [awaitStatement] can
   /// call [body] with the result of an awaited Future.
   js.VariableUse get result => new js.VariableUse(resultName);
   String resultName;
 
   /// A parameter to the [bodyName] function. Indicating if we are in success
   /// or error case.
   String errorCodeName;
 
+  final String suggestedBodyName;
   /// The inner function that is scheduled to do each await/yield,
   /// and called to do a new iteration for sync*.
   js.VariableUse get body => new js.VariableUse(bodyName);
   String bodyName;
 
   /// Used to simulate a goto.
   ///
   /// To "goto" a label, the label is assigned to this variable, and break out
   /// of the switch to take another iteration in the while loop. See [addGoto]
   js.VariableUse get goto => new js.VariableUse(gotoName);
@@ skipping 42 matching lines @@
   // The highest temporary variable index ever in use in this function.
   int tempVarHighWaterMark = 0;
   Map<int, js.Expression> tempVarNames = new Map<int, js.Expression>();
 
   bool get isAsync => false;
   bool get isSyncStar => false;
   bool get isAsyncStar => false;
 
   AsyncRewriterBase(this.diagnosticListener,
                     spannable,
-                    this.safeVariableName)
+                    this.safeVariableName,
+                    this.suggestedBodyName)
       : _spannable = spannable;
 
   /// Initialize names used by the subClass.
   void initializeNames();
 
   /// Main entry point.
   /// Rewrites a sync*/async/async* function to an equivalent normal function.
   ///
   /// [spannable] can be passed to have a location for error messages.
   js.Fun rewrite(js.Fun node, [Spannable spannable]) {
     _spannable = spannable;
 
     analysis = new PreTranslationAnalysis(unsupported);
     analysis.analyze(node);
 
     // To avoid name collisions with existing names, the fresh names are
     // generated after the analysis.
     resultName = freshName("result");
     errorCodeName = freshName("errorCode");
-    bodyName = freshName("body");
+    bodyName = freshName(suggestedBodyName);
     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();
 
@@ skipping 1454 matching lines @@
   /// Contructor used to initialize the [completer] variable.
   ///
   /// Specific to async methods.
   final js.Expression newCompleter;
 
 
   AsyncRewriter(DiagnosticListener diagnosticListener,
                 spannable,
                 {this.asyncHelper,
                  this.newCompleter,
-                 safeVariableName})
+                 String safeVariableName(String proposedName),
+                 String bodyName})
         : super(diagnosticListener,
                 spannable,
-                safeVariableName);
+                safeVariableName,
+                bodyName);
 
   @override
   void addYield(js.DartYield node, js.Expression expression) {
     diagnosticListener.internalError(spannable,
         "Yield in non-generating async function");
   }
 
   void addErrorExit() {
     beginLabel(rethrowLabel);
     addStatement(js.js.statement(
@@ skipping 106 matching lines @@
 
   /// Used by sync* functions to throw exeptions.
   final js.Expression uncaughtErrorExpression;
 
   SyncStarRewriter(DiagnosticListener diagnosticListener,
                 spannable,
                 {this.endOfIteration,
                  this.newIterable,
                  this.yieldStarExpression,
                  this.uncaughtErrorExpression,
-                 safeVariableName})
+                 String safeVariableName(String proposedName),
+                 String bodyName})
         : super(diagnosticListener,
                 spannable,
-                safeVariableName);
+                safeVariableName,
+                bodyName);
 
   /// Translates a yield/yield* in an sync*.
   ///
   /// `yield` in a sync* function just returns [value].
   /// `yield*` wraps [value] in a [yieldStarExpression] and returns it.
   @override
   void addYield(js.DartYield node, js.Expression expression) {
     if (node.hasStar) {
       addStatement(
           new js.Return(new js.Call(yieldStarExpression, [expression])));
@@ skipping 144 matching lines @@
   /// Called with the stream to yield from.
   final js.Expression yieldStarExpression;
 
   AsyncStarRewriter(DiagnosticListener diagnosticListener,
                 spannable,
                 {this.asyncStarHelper,
                  this.streamOfController,
                  this.newController,
                  this.yieldExpression,
                  this.yieldStarExpression,
-                 String safeVariableName(String original)})
+                 String safeVariableName(String proposedName),
+                 String bodyName})
         : super(diagnosticListener,
                 spannable,
-                safeVariableName);
+                safeVariableName,
+                bodyName);
 
 
   /// Translates a yield/yield* in an async* function.
   ///
   /// yield/yield* in an async* function is translated much like the `await` is
   /// translated in [visitAwait], only the object is wrapped in a
   /// [yieldExpression]/[yieldStarExpression] to let [asyncStarHelper]
   /// distinguish them.
   /// Also [nextWhenCanceled] is set up to contain the finally blocks that
   /// must be run in case the stream was canceled.
@@ skipping 545 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }