Support for interpolated declarations in the js parser.

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;
 
-// TODO(sigurdm): Avoid using variables in templates. It could blow up memory
-// use.
 // TODO(sigurdm): Move the try/catch expression to a js_helper function.
 // That would also simplify the sync* case, where the error can just be thrown.
 
 import "dart:math" show max;
 import 'dart:collection';
 
 import 'package:_internal/compiler/js_lib/shared/async_await_error_codes.dart'
     as error_codes;
 
 import "js.dart" as js;
@@ skipping 575 matching lines @@
   /// Returning from an async* function calls the [streamHelper] with an
   /// [endOfIteration] marker.
   void addExit() {
     if (analysis.hasExplicitReturns || isAsyncStar) {
       beginLabel(exitLabel);
     } else {
       addStatement(new js.Comment("implicit return"));
     }
     switch (async) {
       case const js.AsyncModifier.async():
-        String returnValue =
-            analysis.hasExplicitReturns ? returnValueName : "null";
         addStatement(js.js.statement(
-            "return #thenHelper($returnValue, #successCode, "
-                "$completerName, null)", {
-             "thenHelper": asyncHelper,
-             "successCode": js.number(error_codes.SUCCESS)}));
+            "return #runtimeHelper(#returnValue, #successCode, "
+                "#completer, null)", {
+             "runtimeHelper": asyncHelper,
+             "successCode": js.number(error_codes.SUCCESS),
+             "returnValue": analysis.hasExplicitReturns
+                 ? returnValueName
+                 : new js.LiteralNull(),
+             "completer": completerName}));
         break;
       case const js.AsyncModifier.syncStar():
         addStatement(new js.Return(new js.Call(endOfIteration, [])));
         break;
       case const js.AsyncModifier.asyncStar():
         addStatement(js.js.statement(
-            "return #streamHelper(null, #successCode, $controllerName)", {
+            "return #streamHelper(null, #successCode, #controller)", {
           "streamHelper": streamHelper,
-          "successCode": js.number(error_codes.SUCCESS)}));
+          "successCode": js.number(error_codes.SUCCESS),
+          "controller": controllerName}));
         break;
       default:
         diagnosticListener.internalError(
             spannable, "Internal error, unexpected asyncmodifier $async");
     }
     if (isAsync || isAsyncStar) {
       beginLabel(rethrowLabel);
       addStatement(js.js.statement(
-          "return #thenHelper($currentErrorName, #errorCode, "
-          "${isAsync ? completerName : controllerName})", {
+          "return #thenHelper(#currentError, #errorCode, #controller)", {
             "thenHelper": isAsync ? asyncHelper : streamHelper,
-            "errorCode": js.number(error_codes.ERROR)}));
+            "errorCode": js.number(error_codes.ERROR),
+            "currentError": currentErrorName,
+            "controller": isAsync ? completerName : controllerName}));
     } else {
       assert(isSyncStar);
       beginLabel(rethrowLabel);
       addStatement(new js.Return(new js.Call(uncaughtErrorExpression,
           [new js.VariableUse(currentErrorName)])));
     }
   }
 
   /// The initial call to [asyncHelper]/[streamHelper].
   ///
   /// There is no value to await/yield, so the first argument is `null` and
   /// also the errorCallback is `null`.
   ///
   /// Returns the [Future]/[Stream] coming from [completerName]/
   /// [controllerName].
   js.Statement generateInitializer() {
     if (isAsync) {
       return js.js.statement(
-          "return #asyncHelper(null, $bodyName, $completerName, null);", {
-        "asyncHelper": asyncHelper
+          "return #asyncHelper(null, #body, #completer, null);", {
+        "asyncHelper": asyncHelper,
+        "body": bodyName,
+        "completer": completerName,
       });
     } else if (isAsyncStar) {
       return js.js.statement(
-          "return #streamOfController($controllerName);", {
-        "streamOfController": streamOfController
+          "return #streamOfController(#controller);", {
+        "streamOfController": streamOfController,
+        "controller": controllerName,
       });
     } else {
       throw diagnosticListener.internalError(
           spannable, "Unexpected asyncModifier: $async");
     }
   }
 
   /// Rewrites an async/sync*/async* function to a normal Javascript function.
   ///
   /// The control flow is flattened by simulating 'goto' using a switch in a
@@ skipping 154 matching lines @@
     visitStatement(body);
     jumpTargets.removeLast();
     addExit();
 
     List<js.SwitchClause> clauses = labelledParts.keys.map((label) {
       return new js.Case(js.number(label), new js.Block(labelledParts[label]));
     }).toList();
     js.Statement helperBody =
         new js.Switch(new js.VariableUse(gotoName), clauses);
     if (hasJumpThoughOuterLabel) {
-      helperBody = js.js.statement("$outerLabelName: #", [helperBody]);
+      helperBody = new js.LabeledStatement(outerLabelName, helperBody);
     }
     helperBody = js.js.statement("""
         try {
           #body
-        } catch ($errorName){
-          $currentErrorName = $errorName;
-          $gotoName = $handlerName;
-        }""", {"body": helperBody});
+        } catch (#error){
+          #currentError = #error;
+          #goto = #handler;
+        }""", {
+          "body": helperBody,
+          "goto": gotoName,
+          "error": errorName,
+          "currentError": currentErrorName,
+          "handler": handlerName,
+        });
     List<js.VariableInitialization> inits = <js.VariableInitialization>[];
 
     js.VariableInitialization makeInit(String name, js.Expression initValue) {
       return new js.VariableInitialization(
           new js.VariableDeclaration(name), initValue);
     }
 
     inits.add(makeInit(gotoName, js.number(0)));
     if (isAsync) {
       inits.add(makeInit(completerName, new js.New(newCompleter, [])));
@@ skipping 21 matching lines @@
       return new js.VariableInitialization(decl, null);
     }));
     inits.addAll(new Iterable.generate(tempVarHighWaterMark,
         (int i) => makeInit(useTempVar(i + 1).name, null)));
     js.VariableDeclarationList varDecl = new js.VariableDeclarationList(inits);
     // TODO(sigurdm): Explain the difference between these cases.
     if (isSyncStar) {
       return js.js("""
           function (#params) {
             if (#needsThis)
-              var $selfName = this;
+              var #self = this;
             return new #newIterable(function () {
               #varDecl;
-              return function $bodyName() {
+              return function #body() {
                 while (true)
                   #helperBody;
               };
             });
           }
           """, {
         "params": node.params,
         "needsThis": analysis.hasThis,
         "helperBody": helperBody,
         "varDecl": varDecl,
-        "newIterable": newIterable
+        "newIterable": newIterable,
+        "body": bodyName,
+        "self": selfName,
       });
     }
     return js.js("""
         function (#params) {
           #varDecl;
-          function $bodyName($errorCodeName, $resultName) {
+          function #bodyName(#errorCode, #result) {
             if (#hasYield)
-              switch ($errorCodeName) {
-                case #streamWasCanceled:
-                  $nextName = $nextWhenCanceledName;
-                  $gotoName = $nextName.pop();
+              switch (#errorCode) {
+                case #STREAM_WAS_CANCELED:
+                  #next = #nextWhenCanceled;
+                  #goto = #next.pop();
                   break;
-                case #errorCode:
-                  $currentErrorName = $resultName;
-                  $gotoName = $handlerName;
+                case #ERROR:
+                  #currentError = #result;
+                  #goto = #handler;
               }
             else
-              if ($errorCodeName == #errorCode) {
-                  $currentErrorName = $resultName;
-                  $gotoName = $handlerName;
+              if (#errorCode == #ERROR) {
+                  #currentError = #result;
+                  #goto = #handler;
               }
             while (true)
               #helperBody;
           }
           #init;
         }""", {
       "params": node.params,
       "varDecl": varDecl,
-      "streamWasCanceled": js.number(error_codes.STREAM_WAS_CANCELED),
-      "errorCode": js.number(error_codes.ERROR),
+      "STREAM_WAS_CANCELED": js.number(error_codes.STREAM_WAS_CANCELED),
+      "ERROR": js.number(error_codes.ERROR),
       "hasYield": analysis.hasYield,
       "helperBody": helperBody,
-      "init": generateInitializer()
+      "init": generateInitializer(),
+      "bodyName": bodyName,
+      "currentError": currentErrorName,
+      "goto": gotoName,
+      "handler": handlerName,
+      "next": nextName,
+      "nextWhenCanceled": nextWhenCanceledName,
+      "errorCode": errorCodeName,
+      "result": resultName,
     });
   }
 
   @override
   js.Expression visitAccess(js.PropertyAccess node) {
     return withExpression2(node.receiver, node.selector,
         (receiver, selector) => new js.PropertyAccess(receiver, selector));
   }
 
   @override
@@ skipping 38 matching lines @@
   ///
   /// See the comments of [visitFun] 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(js.js.statement("""
           return #asyncHelper(#value,
-                              $bodyName,
-                              ${isAsync ? completerName : controllerName});
+                              #body,
+                              #controller);
           """, {
         "asyncHelper": isAsync ? asyncHelper : streamHelper,
         "value": value,
+        "body": bodyName,
+        "controller": isAsync ? completerName : controllerName,
       }));
     }, store: false);
     beginLabel(afterAwait);
     return new js.VariableUse(resultName);
   }
 
   /// Checks if [node] is the variable named [resultName].
   ///
   /// [resultName] is used to hold the result of a transformed computation
   /// for example the result of awaiting, or the result of a conditional or
@@ skipping 156 matching lines @@
       // 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]));
+      addStatement(js.js.statement("# = #", [nextName, jsJumpStack]));
     }
     addGoto(firstTarget);
   }
 
   @override
   void visitDefault(js.Default node) => unreachable(node);
 
   @override
   void visitDo(js.Do node) {
     if (!shouldTransform(node)) {
@@ skipping 152 matching lines @@
     }
     beginLabel(joinLabel);
   }
 
   @override
   visitInterpolatedExpression(js.InterpolatedExpression node) {
     return unsupported(node);
   }
 
   @override
+  visitInterpolatedDeclaration(js.InterpolatedDeclaration node) {
+    return unsupported(node);
+  }
+
+  @override
   visitInterpolatedLiteral(js.InterpolatedLiteral node) => unsupported(node);
 
   @override
   visitInterpolatedParameter(js.InterpolatedParameter node) {
     return unsupported(node);
   }
 
   @override
   visitInterpolatedSelector(js.InterpolatedSelector node) {
     return unsupported(node);
@@ skipping 127 matching lines @@
 
   @override
   js.Expression visitRegExpLiteral(js.RegExpLiteral node) => node;
 
   @override
   void visitReturn(js.Return node) {
     assert(node.value == null || !isSyncStar && !isAsyncStar);
     js.Node target = analysis.targets[node];
     if (node.value != null) {
       withExpression(node.value, (js.Expression value) {
-        addStatement(js.js.statement("$returnValueName = #", [value]));
+        addStatement(js.js.statement("# = #", [returnValueName, value]));
       }, store: false);
     }
     translateJump(target, exitLabel);
   }
 
   @override
   void visitSwitch(js.Switch node) {
     if (!node.cases.any(shouldTransform)) {
       // If only the key has an await, translation can be simplified.
       bool oldInsideUntranslated = insideUntranslatedBreakable;
@@ skipping 160 matching lines @@
 
     js.Node last = jumpTargets.removeLast();
     assert(last == node);
 
     if (node.finallyPart == null) {
       setErrorHandler();
       addGoto(afterFinallyLabel);
     } else {
       // The handler is reset as the first thing in the finally block.
       addStatement(
-          js.js.statement("$nextName = [#];", [js.number(afterFinallyLabel)]));
+          js.js.statement("# = [#];",
+                          [nextName, js.number(afterFinallyLabel)]));
       addGoto(finallyLabel);
     }
 
     if (node.catchPart != null) {
       beginLabel(handlerLabel);
       // [uncaughtLabel] is the handler for the code in the catch-part.
       // It ensures that [nextName] is set up to run the right finally blocks.
       handlerLabels[node.catchPart] = uncaughtLabel;
       jumpTargets.add(node.catchPart);
       setErrorHandler();
       // The catch declaration name can shadow outer variables, so a fresh name
       // is needed to avoid collisions.  See Ecma 262, 3rd edition,
       // section 12.14.
       String errorRename = freshName(node.catchPart.declaration.name);
       localVariables.add(new js.VariableDeclaration(errorRename));
       variableRenamings
           .add(new Pair(node.catchPart.declaration.name, errorRename));
       addExpressionStatement(new js.Assignment(
           new js.VariableUse(errorRename),
           new js.VariableUse(currentErrorName)));
       visitStatement(node.catchPart.body);
       variableRenamings.removeLast();
       if (node.finallyPart != null) {
         // The error has been caught, so after the finally, continue after the
         // try.
-        addStatement(js.js.statement("$nextName = [#];",
-                                     [js.number(afterFinallyLabel)]));
+        addStatement(js.js.statement("# = [#];",
+                                     [nextName, js.number(afterFinallyLabel)]));
         addGoto(finallyLabel);
       } else {
         addGoto(afterFinallyLabel);
       }
       js.Node last = jumpTargets.removeLast();
       assert(last == node.catchPart);
     }
 
     // The "uncaught"-handler tells the finally-block to continue with
     // the enclosing finally-blocks until the current catch-handler.
     beginLabel(uncaughtLabel);
 
     List<int> enclosingFinallies = _finalliesUpToAndEnclosingHandler();
 
     int nextLabel = enclosingFinallies.removeLast();
     if (enclosingFinallies.isNotEmpty) {
       // [enclosingFinallies] can be empty if there is no surrounding finally
       // blocks. Then [nextLabel] will be [rethrowLabel].
       addStatement(
-          js.js.statement("$nextName = #;", new js.ArrayInitializer(
-              enclosingFinallies.map(js.number).toList())));
+          js.js.statement("# = #;", [nextName, new js.ArrayInitializer(
+              enclosingFinallies.map(js.number).toList())]));
     }
     if (node.finallyPart == null) {
       // The finally-block belonging to [node] will be visited because of
       // fallthrough. If it does not exist, add an explicit goto.
       addGoto(nextLabel);
     }
     if (node.finallyPart != null) {
       js.Node last = jumpTargets.removeLast();
       assert(last == node.finallyPart);
 
       beginLabel(finallyLabel);
       setErrorHandler();
       visitStatement(node.finallyPart);
       addStatement(new js.Comment("// goto the next finally handler"));
-      addStatement(js.js.statement("$gotoName = $nextName.pop();"));
+      addStatement(js.js.statement("# = #.pop();", [gotoName, nextName]));
       addBreak();
     }
     beginLabel(afterFinallyLabel);
   }
 
   @override
   visitVariableDeclaration(js.VariableDeclaration node) {
     unreachable(node);
   }
 
@@ skipping 82 matching lines @@
   /// must be run in case the stream was canceled.
   void addAsyncYield(js.DartYield node, js.Expression expression) {
     assert(isAsyncStar);
     // 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("$nextWhenCanceledName = #",
-        [new js.ArrayInitializer(enclosingFinallyLabels.map(js.number)
-            .toList())]));
+    addStatement(js.js.statement("# = #;",
+        [nextWhenCanceledName, new js.ArrayInitializer(
+            enclosingFinallyLabels.map(js.number).toList())]));
     addStatement(js.js.statement("""
-        return #streamHelper(#yieldExpression(#expression),
-            $bodyName, $controllerName);""", {
+        return #streamHelper(#yieldExpression(#expression), #body,
+            #controller);""", {
       "streamHelper": streamHelper,
       "yieldExpression": node.hasStar ? yieldStarExpression : yieldExpression,
       "expression": expression,
+      "body": bodyName,
+      "controller": controllerName,
     }));
   }
 
   @override
   void visitDartYield(js.DartYield node) {
     assert(isSyncStar || isAsyncStar);
     int label = newLabel("after yield");
     // Don't do a break here for the goto, but instead a return in either
     // addSynYield or addAsyncYield.
     withExpression(node.expression, (js.Expression expression) {
@@ skipping 228 matching lines @@
     bool otherwise = visit(node.otherwise);
     return condition || then || otherwise;
   }
 
   @override
   bool visitInterpolatedExpression(js.InterpolatedExpression node) {
     return unsupported(node);
   }
 
   @override
+  bool visitInterpolatedDeclaration(js.InterpolatedDeclaration node) {
+    return unsupported(node);
+  }
+
+  @override
   bool visitInterpolatedLiteral(js.InterpolatedLiteral node) {
     return unsupported(node);
   }
 
   @override
   bool visitInterpolatedParameter(js.InterpolatedParameter node) {
     return unsupported(node);
   }
 
   @override
@@ skipping 169 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }