Use more js templates in async rewrite.

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 387 matching lines @@
     assert(!labelledParts.containsKey(label));
     currentStatementBuffer = new List<js.Statement>();
     labelledParts[label] = currentStatementBuffer;
     addStatement(new js.Comment(labelComments[label]));
   }
 
   /// Returns a statement assigning to the variable named [gotoName].
   /// This should be followed by a break for the goto to be executed. Use
   /// [gotoWithBreak] or [addGoto] for this.
   js.Statement setGotoVariable(int label) {
-    return new js.ExpressionStatement(
-        new js.Assignment(new js.VariableUse(gotoName), js.number(label)));
+    return js.js.statement('# = #', [gotoName, js.number(label)]);
   }
 
   /// Returns a block that has a goto to [label] including the break.
   ///
   /// Also inserts a comment describing the label if available.
   js.Block gotoAndBreak(int label) {
     List<js.Statement> statements = new List<js.Statement>();
     if (labelComments.containsKey(label)) {
       statements.add(new js.Comment("goto ${labelComments[label]}"));
     }
@@ skipping 80 matching lines @@
   /// - _storeIfNecessary(someLiteral) returns someLiteral.
   /// - _storeIfNecessary(someVariable)
   ///   inserts: var tempX = someVariable
   ///   returns: tempX
   ///   where tempX is a fresh temporary variable.
   js.Expression _storeIfNecessary(js.Expression result) {
     // Note that RegExes, js.ArrayInitializer and js.ObjectInitializer are not
     // [js.Literal]s.
     if (result is js.Literal) return result;
     js.Expression tempVar = useTempVar(allocateTempVar());
-    addExpressionStatement(new js.Assignment(tempVar, result));
+    addStatement(js.js.statement('# = #;', [tempVar, result]));

[floitsch, 2015/02/23 16:15:34]

apparently you don't need the ";". (At least you don't have it in line 408.
Either add it there too, or remove it here.

[sigurdm, 2015/02/24 13:16:20]

I'll add it everywhere

     return tempVar;
   }
 
   withExpression(js.Expression node, fn(js.Expression result), {bool store}) {
     int oldTempVarIndex = currentTempVarIndex;
     js.Expression visited = visitExpression(node);
     if (store) {
       visited = _storeIfNecessary(visited);
     }
     var result = fn(visited);
@@ skipping 79 matching lines @@
             "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, [])));
+        addStatement(js.js.statement('return #();', [endOfIteration]));
         break;
       case const js.AsyncModifier.asyncStar():
         addStatement(js.js.statement(
             "return #streamHelper(null, #successCode, #controller)", {
           "streamHelper": streamHelper,
           "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(#currentError, #errorCode, #controller)", {
             "thenHelper": isAsync ? asyncHelper : streamHelper,
             "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)])));
+      addStatement(js.js.statement('return #(#);',
+                   [uncaughtErrorExpression, 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].
@@ skipping 188 matching lines @@
     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, [])));
     } else if (isAsyncStar) {
       inits.add(makeInit(controllerName,
-          new js.Call(newController, [new js.VariableUse(bodyName)])));
+          js.js('#(#)', [newController, bodyName])));
     }
     inits.add(makeInit(handlerName, js.number(rethrowLabel)));
     inits.add(makeInit(currentErrorName, null));
     if (hasJumpThroughFinally || analysis.hasYield) {
       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
       // function.
-      inits.add(makeInit(selfName, new js.This()));
+      inits.add(makeInit(selfName, js.js('this')));
     }
     inits.addAll(localVariables.map((js.VariableDeclaration decl) {
       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 #self = this;
             return new #newIterable(function () {
               #varDecl;
               return function #body(#errorCode, #result) {
-                if (#errorCode == #ERROR) {
+                if (#errorCode === #ERROR) {
                     #currentError = #result;
                     #goto = #handler;
                 }
                 while (true)
                   #helperBody;
               };
             });
           }
           """, {
         "params": node.params,
@@ skipping 19 matching lines @@
               switch (#errorCode) {
                 case #STREAM_WAS_CANCELED:
                   #next = #nextWhenCanceled;
                   #goto = #next.pop();
                   break;
                 case #ERROR:
                   #currentError = #result;
                   #goto = #handler;
               }
             else
-              if (#errorCode == #ERROR) {
+              if (#errorCode === #ERROR) {
                   #currentError = #result;
                   #goto = #handler;
               }
             while (true)
               #helperBody;
           }
           #init;
         }""", {
       "params": node.params,
       "varDecl": varDecl,
       "STREAM_WAS_CANCELED": js.number(error_codes.STREAM_WAS_CANCELED),
       "ERROR": js.number(error_codes.ERROR),
       "hasYield": analysis.hasYield,
       "helperBody": helperBody,
       "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));
+        (receiver, selector) => js.js('#[#]', [receiver, selector]));
   }
 
   @override
   js.Expression visitArrayHole(js.ArrayHole node) {
     return node;
   }
 
   @override
   js.Expression visitArrayInitializer(js.ArrayInitializer node) {
     return withExpressions(node.elements, (elements) {
@@ skipping 64 matching lines @@
   }
 
   @override
   js.Expression visitBinary(js.Binary node) {
     if (shouldTransform(node.right) && (node.op == "||" || node.op == "&&")) {
       int thenLabel = newLabel("then");
       int joinLabel = newLabel("join");
       withExpression(node.left, (js.Expression left) {
         js.Statement assignLeft = isResult(left)
             ? new js.Block.empty()
-            : new js.ExpressionStatement(
-                new js.Assignment(new js.VariableUse(resultName), left));
+            : js.js.statement('# = #', [resultName, left]);

[floitsch, 2015/02/23 16:15:34]

ditto.

[sigurdm, 2015/02/24 13:16:20]

Acknowledged.

         if (node.op == "||") {
-          addStatement(new js.If(left, gotoAndBreak(thenLabel), assignLeft));
+          addStatement(js.js.statement('if (#) {#} else #',

[floitsch, 2015/02/23 16:15:34]

you don't need the "{}" around the 'then' block.

[sigurdm, 2015/02/24 13:16:20]

Yes, otherwise the js parser sees # else as a hole named #else

+              [left, gotoAndBreak(thenLabel), assignLeft]));
         } else {
           assert(node.op == "&&");
-          addStatement(new js.If(left, assignLeft, gotoAndBreak(thenLabel)));
+          addStatement(js.js.statement('if (#) {#} else #',

[floitsch, 2015/02/23 16:15:34]

ditto

[sigurdm, 2015/02/24 13:16:20]

Acknowledged.

+              [left, assignLeft, gotoAndBreak(thenLabel)]));
         }
       }, store: true);
       addGoto(joinLabel);
       beginLabel(thenLabel);
       withExpression(node.right, (js.Expression value) {
         if (!isResult(value)) {
-          addExpressionStatement(
-              new js.Assignment(new js.VariableUse(resultName), value));
+          addStatement(js.js.statement('# = #', [resultName, value]));

[floitsch, 2015/02/23 16:15:34]

";" or not. (depending on above).

[sigurdm, 2015/02/24 13:16:20]

Done.

         }
       }, store: false);
       beginLabel(joinLabel);
       return new js.VariableUse(resultName);
     }
 
     return withExpression2(node.left, node.right,
         (left, right) => new js.Binary(node.op, left, right));
   }
 
@@ skipping 36 matching lines @@
 
   @override
   void visitComment(js.Comment node) {
     addStatement(node);
   }
 
   @override
   js.Expression visitConditional(js.Conditional node) {
     if (!shouldTransform(node.then) && !shouldTransform(node.otherwise)) {
       return withExpression(node.condition, (js.Expression condition) {
-        return new js.Conditional(condition, node.then, node.otherwise);
+        return js.js('# ? # : #', [condition, node.then, node.otherwise]);
       });
     }
     int thenLabel = newLabel("then");
     int joinLabel = newLabel("join");
     int elseLabel = newLabel("else");
     withExpression(node.condition, (js.Expression condition) {
-      addExpressionStatement(new js.Assignment(new js.VariableUse(gotoName),
-          new js.Conditional(
-              condition, js.number(thenLabel), js.number(elseLabel))));
+      addStatement(js.js.statement('# = # ? # : #;',
+          [gotoName, condition, js.number(thenLabel), js.number(elseLabel)]));
     }, store: false);
     addBreak();
     beginLabel(thenLabel);
     withExpression(node.then, (js.Expression value) {
       if (!isResult(value)) {
-        addExpressionStatement(
-            new js.Assignment(new js.VariableUse(resultName), value));
+        addStatement(js.js.statement('# = #', [resultName, value]));
       }
     }, store: false);
     addGoto(joinLabel);
     beginLabel(elseLabel);
     withExpression(node.otherwise, (js.Expression value) {
       if (!isResult(value)) {
-        addExpressionStatement(
-            new js.Assignment(new js.VariableUse(resultName), value));
+        addStatement(js.js.statement('# = #', [resultName, value]));
       }
     }, store: false);
     beginLabel(joinLabel);
     return new js.VariableUse(resultName);
   }
 
   @override
   void visitContinue(js.Continue node) {
     js.Node target = analysis.targets[node];
     if (!shouldTransform(target)) {
@@ skipping 48 matching lines @@
 
   @override
   void visitDefault(js.Default node) => unreachable(node);
 
   @override
   void visitDo(js.Do node) {
     if (!shouldTransform(node)) {
       bool oldInsideUntranslatedBreakable = insideUntranslatedBreakable;
       insideUntranslatedBreakable = true;
       withExpression(node.condition, (js.Expression condition) {
-        addStatement(new js.Do(translateInBlock(node.body), condition));
+        addStatement(js.js.statement('do {#} while #', [node.body, condition]));

[floitsch, 2015/02/23 16:15:34]

no need for "{ }".

[sigurdm, 2015/02/24 13:16:20]

Ditto

       }, store: false);
       insideUntranslatedBreakable = oldInsideUntranslatedBreakable;
       return;
     }
     int startLabel = newLabel("do body");
 
     int continueLabel = newLabel("do condition");
     continueLabels[node] = continueLabel;
 
     int afterLabel = newLabel("after do");
     breakLabels[node] = afterLabel;
 
     beginLabel(startLabel);
 
     jumpTargets.add(node);
     visitStatement(node.body);
     jumpTargets.removeLast();
 
     beginLabel(continueLabel);
     withExpression(node.condition, (js.Expression condition) {
-      addStatement(new js.If.noElse(condition, gotoAndBreak(startLabel)));
+      addStatement(js.js.statement('if (#) #',
+          [condition, gotoAndBreak(startLabel)]));
     }, store: false);
     beginLabel(afterLabel);
   }
 
   @override
   void visitEmptyStatement(js.EmptyStatement node) {
     addStatement(node);
   }
 
   void visitExpressionInStatementContext(js.Expression node) {
@@ skipping 16 matching lines @@
       bool oldInsideUntranslated = insideUntranslatedBreakable;
       insideUntranslatedBreakable = true;
       // Note that node.init, node.condition, node.update all can be null, but
       // withExpressions handles that.
       withExpressions([
         node.init,
         node.condition,
         node.update
       ], (List<js.Expression> transformed) {
         addStatement(new js.For(transformed[0], transformed[1], transformed[2],
-            translateInBlock(node.body)));
+             translateInBlock(node.body)));
       });
       insideUntranslatedBreakable = oldInsideUntranslated;
       return;
     }
 
     if (node.init != null) {
       visitExpressionInStatementContext(node.init);
     }
     int startLabel = newLabel("for condition");
     // If there is no update, continuing the loop is the same as going to the
@@ skipping 1033 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }