dart2js: Use an abstract Name class for names in the generated JavaScript ast.

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 97 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;
+  js.Name 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);
   String gotoName;
 
   /// Variable containing the label of the current error handler.
   js.VariableUse get handler => new js.VariableUse(handlerName);
@@ skipping 39 matching lines @@
   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.suggestedBodyName)
+                    this.bodyName)
       : _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(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 964 matching lines @@
   @override
   visitLiteralStatement(js.LiteralStatement node) => unsupported(node);
 
   @override
   js.Expression visitLiteralString(js.LiteralString node) => node;
 
   @override
   js.Expression visitStringConcatenation(js.StringConcatenation node) => node;
 
   @override
+  js.Name visitName(js.Name node) => node;
+
+  @override
   visitNamedFunction(js.NamedFunction node) {
     unsupported(node);
   }
 
   @override
   js.Expression visitDeferredExpression(js.DeferredExpression node) => node;
 
   @override
   js.Expression visitDeferredNumber(js.DeferredNumber node) => node;
 
@@ skipping 483 matching lines @@
   ///
   /// Specific to async methods.
   final js.Expression newCompleter;
 
 
   AsyncRewriter(DiagnosticListener diagnosticListener,
                 spannable,
                 {this.asyncHelper,
                  this.newCompleter,
                  String safeVariableName(String proposedName),
-                 String bodyName})
+                 js.Name bodyName})
         : super(diagnosticListener,
                 spannable,
                 safeVariableName,
                 bodyName);
 
   @override
   void addYield(js.DartYield node, js.Expression expression) {
     diagnosticListener.internalError(spannable,
         "Yield in non-generating async function");
   }
@@ skipping 42 matching lines @@
 
   @override
   void initializeNames() {
     completerName = freshName("completer");
   }
 
   @override
   js.Statement awaitStatement(js.Expression value) {
     return js.js.statement("""
           return #asyncHelper(#value,
-                              #body,
+                              #bodyName,
                               #completer);
           """, {
             "asyncHelper": asyncHelper,
             "value": value,
-            "body": body,
+            "bodyName": bodyName,
             "completer": completer});
   }
 
   @override
   js.Fun finishFunction(List<js.Parameter> parameters,
                         js.Statement rewrittenBody,
                         js.VariableDeclarationList variableDeclarations) {
     return js.js("""
         function (#parameters) {
           #variableDeclarations;
@@ skipping 43 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,
                  String safeVariableName(String proposedName),
-                 String bodyName})
+                 js.Name bodyName})
         : super(diagnosticListener,
                 spannable,
                 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
@@ skipping 149 matching lines @@
   final js.Expression yieldStarExpression;
 
   AsyncStarRewriter(DiagnosticListener diagnosticListener,
                 spannable,
                 {this.asyncStarHelper,
                  this.streamOfController,
                  this.newController,
                  this.yieldExpression,
                  this.yieldStarExpression,
                  String safeVariableName(String proposedName),
-                 String bodyName})
+                 js.Name bodyName})
         : super(diagnosticListener,
                 spannable,
                 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.
   @override
   void addYield(js.DartYield node, js.Expression expression) {
     // Find all the finally blocks that should be performed if the stream is
     // canceled during the yield.
     // At the bottom of the stack is the return label.
     List<int> enclosingFinallyLabels = <int>[exitLabel];
     enclosingFinallyLabels.addAll(jumpTargets
         .where((js.Node node) => finallyLabels[node] != null)
         .map((js.Block node) => finallyLabels[node]));
     addStatement(js.js.statement("# = #;",
         [nextWhenCanceled, new js.ArrayInitializer(
             enclosingFinallyLabels.map(js.number).toList())]));
     addStatement(js.js.statement("""
-        return #asyncStarHelper(#yieldExpression(#expression), #body,
+        return #asyncStarHelper(#yieldExpression(#expression), #bodyName,
             #controller);""", {
       "asyncStarHelper": asyncStarHelper,
       "yieldExpression": node.hasStar ? yieldStarExpression : yieldExpression,
       "expression": expression,
-      "body": body,
+      "bodyName": bodyName,
       "controller": controllerName,
     }));
   }
 
   @override
   js.Fun finishFunction(List<js.Parameter> parameters,
                         js.Statement rewrittenBody,
                         js.VariableDeclarationList variableDeclarations) {
     return js.js("""
         function (#parameters) {
@@ skipping 77 matching lines @@
   @override
   void initializeNames() {
     controllerName = freshName("controller");
     nextWhenCanceledName = freshName("nextWhenCanceled");
   }
 
   @override
   js.Statement awaitStatement(js.Expression value) {
     return js.js.statement("""
           return #asyncHelper(#value,
-                              #body,
+                              #bodyName,
                               #controller);
           """, {
             "asyncHelper": asyncStarHelper,
             "value": value,
-            "body": body,
+            "bodyName": bodyName,
             "controller": controllerName});
   }
 }
 
 /// Finds out
 ///
 /// - which expressions have yield or await nested in them.
 /// - targets of jumps
 /// - a set of used names.
 /// - if any [This]-expressions are used.
@@ skipping 299 matching lines @@
   bool visitLiteralString(js.LiteralString node) {
     return false;
   }
 
   @override
   bool visitStringConcatenation(js.StringConcatenation node) {
     return true;
   }
 
   @override
+  bool visitName(js.Name node) {
+    return true;
+  }
+
+  @override
   bool visitNamedFunction(js.NamedFunction node) {
     return false;
   }
 
   @override
   bool visitNew(js.New node) {
     return visitCall(node);
   }
 
   @override
@@ skipping 114 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }