dart2js: rewrite_async: Don't call JavaScript factory constructor with 'new'

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:collection';
 import 'dart:math' show max;
 
 import 'package:js_runtime/shared/async_await_error_codes.dart' as error_codes;
@@ skipping 10 matching lines @@
 ///
 /// 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 [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>();
+  List<js.VariableDeclaration> localVariables = <js.VariableDeclaration>[];
 
   Map<js.Node, int> continueLabels = new Map<js.Node, int>();
   Map<js.Node, int> breakLabels = new Map<js.Node, int>();
 
   /// The label of a finally part.
   Map<js.Block, int> finallyLabels = new Map<js.Block, int>();
 
   /// The label of the catch handler of a [js.Try] or a [js.Fun] or [js.Catch].
   ///
   /// These mark the points an error can be consumed.
@@ skipping 15 matching lines @@
   /// * The function, signalling a return or uncaught throw.
   /// * Loops.
   /// * LabeledStatements (also used for 'continue' when attached to loops).
   /// * Try statements, for catch and finally handlers.
   /// * Catch handlers, when inside a catch-part of a try, the catch-handler is
   ///   used to associate with a synthetic handler that will ensure the right
   ///   finally blocks are visited.
   ///
   /// When jumping to a target it is necessary to visit all finallies that
   /// are on the way to target (i.e. more nested than the jump target).
-  List<js.Node> jumpTargets = new List<js.Node>();
+  List<js.Node> jumpTargets = <js.Node>[];
 
-  List<int> continueStack = new List<int>();
-  List<int> breakStack = new List<int>();
-  List<int> returnStack = new List<int>();
+  List<int> continueStack = <int>[];
+  List<int> breakStack = <int>[];
+  List<int> returnStack = <int>[];
 
-  List<Pair<String, String>> variableRenamings =
-      new List<Pair<String, String>>();
+  List<Pair<String, String>> variableRenamings = <Pair<String, String>>[];
 
   PreTranslationAnalysis analysis;
 
   final Function safeVariableName;
 
   // All the <x>Name variables are names of Javascript variables used in the
   // transformed code.
 
   /// Contains the result of an awaited expression, or a conditional or
   /// lazy boolean operator.
@@ skipping 206 matching lines @@
   /// 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 js.js.statement('# = #;', [goto, 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>();
+    List<js.Statement> statements = <js.Statement>[];
     if (labelComments.containsKey(label)) {
       statements.add(new js.Comment("goto ${labelComments[label]}"));
     }
     statements.add(setGotoVariable(label));
     if (insideUntranslatedBreakable) {
       hasJumpThoughOuterLabel = true;
       statements.add(new js.Break(outerLabelName));
     } else {
       statements.add(new js.Break(null));
     }
@@ skipping 363 matching lines @@
     addFunctionExits();
 
     List<js.SwitchClause> clauses = labelledParts.keys.map((label) {
       return new js.Case(js.number(label), new js.Block(labelledParts[label]));
     }).toList();
     js.Statement rewrittenBody = new js.Switch(goto, clauses);
     if (hasJumpThoughOuterLabel) {
       rewrittenBody = new js.LabeledStatement(outerLabelName, rewrittenBody);
     }
     rewrittenBody = js.js.statement('while (true) {#}', rewrittenBody);
-    List<js.VariableInitialization> variables =
-        new List<js.VariableInitialization>();
+    List<js.VariableInitialization> variables = <js.VariableInitialization>[];
 
     variables.add(_makeVariableInitializer(goto, js.number(0)));
     variables.addAll(variableInitializations());
     variables.add(_makeVariableInitializer(handler, js.number(rethrowLabel)));
     variables.add(_makeVariableInitializer(currentError, null));
     if (analysis.hasFinally || (isAsyncStar && analysis.hasYield)) {
       variables.add(_makeVariableInitializer(
           next, new js.ArrayInitializer(<js.Expression>[])));
     }
     if (analysis.hasThis && !isSyncStar) {
@@ skipping 234 matching lines @@
   /// 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 [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>();
+    List<int> jumpStack = <int>[];
     for (js.Node node in jumpTargets.reversed) {
       if (finallyLabels[node] != null) {
         jumpStack.add(finallyLabels[node]);
       } else if (node == target) {
         jumpStack.add(targetLabel);
         break;
       }
       // Ignore other nodes.
     }
     jumpStack = jumpStack.reversed.toList();
@@ skipping 407 matching lines @@
       }, store: true);
 
       if (defaultIndex == null) {
         addGoto(after);
       } else {
         addGoto(labels[defaultIndex]);
       }
     } else {
       bool hasDefault = false;
       int i = 0;
-      List<js.SwitchClause> clauses = new List<js.SwitchClause>();
+      List<js.SwitchClause> clauses = <js.SwitchClause>[];
       for (js.SwitchClause clause in node.cases) {
         if (clause is js.Case) {
           labels[i] = newLabel("case");
           clauses.add(new js.Case(
               visitExpression(clause.expression), gotoAndBreak(labels[i])));
         } else if (clause is js.Default) {
           labels[i] = newLabel("default");
           clauses.add(new js.Default(gotoAndBreak(labels[i])));
           hasDefault = true;
         } else {
@@ skipping 33 matching lines @@
     }, store: false);
   }
 
   setErrorHandler([int errorHandler]) {
     js.Expression label =
         (errorHandler == null) ? currentErrorHandler : js.number(errorHandler);
     addStatement(js.js.statement('# = #;', [handler, label]));
   }
 
   List<int> _finalliesUpToAndEnclosingHandler() {
-    List<int> result = new List<int>();
+    List<int> result = <int>[];
     for (int i = jumpTargets.length - 1; i >= 0; i--) {
       js.Node node = jumpTargets[i];
       int handlerLabel = handlerLabels[node];
       if (handlerLabel != null) {
         result.add(handlerLabel);
         break;
       }
       int finallyLabel = finallyLabels[node];
       if (finallyLabel != null) {
         result.add(finallyLabel);
@@ skipping 237 matching lines @@
   /// For a throw it is called with:
   ///
   /// - The error to complete the completer with.
   /// - [error_codes.ERROR]
   /// - The completer object [completer]
   final js.Expression asyncHelper;
 
   /// Contructor used to initialize the [completer] variable.
   ///
   /// Specific to async methods.
-  final js.Expression newCompleter;
+  final js.Expression completerFactory;
 
   final js.Expression wrapBody;
 
   AsyncRewriter(DiagnosticReporter reporter, Spannable spannable,
       {this.asyncHelper,
-      this.newCompleter,
+      this.completerFactory,
       this.wrapBody,
       String safeVariableName(String proposedName),
       js.Name bodyName})
       : super(reporter, spannable, safeVariableName, bodyName);
 
   @override
   void addYield(js.DartYield node, js.Expression expression) {
     reporter.internalError(spannable, "Yield in non-generating async function");
   }
 
@@ skipping 22 matching lines @@
       "runtimeHelper": asyncHelper,
       "successCode": js.number(error_codes.SUCCESS),
       "returnValue":
           analysis.hasExplicitReturns ? returnValue : new js.LiteralNull(),
       "completer": completer
     }));
   }
 
   @override
   Iterable<js.VariableInitialization> variableInitializations() {
-    List<js.VariableInitialization> variables =
-        new List<js.VariableInitialization>();
-    variables
-        .add(_makeVariableInitializer(completer, new js.New(newCompleter, [])));
+    List<js.VariableInitialization> variables = <js.VariableInitialization>[];
+    variables.add(
+        _makeVariableInitializer(completer, new js.Call(completerFactory, [])));
     if (analysis.hasExplicitReturns) {
       variables.add(_makeVariableInitializer(returnValue, null));
     }
     return variables;
   }
 
   @override
   void initializeNames() {
     completerName = freshName("completer");
   }
@@ skipping 49 matching lines @@
           "wrapBody": wrapBody,
         }).withSourceInformation(sourceInformation);
   }
 }
 
 class SyncStarRewriter extends AsyncRewriterBase {
   bool get isSyncStar => true;
 
   /// Contructor creating the Iterable for a sync* method. Called with
   /// [bodyName].
-  final js.Expression newIterable;
+  final js.Expression iterableFactory;
 
   /// A JS Expression that creates a marker showing that iteration is over.
   ///
   /// Called without arguments.
   final js.Expression endOfIteration;
 
   /// A JS Expression that creates a marker indication a 'yield*' statement.
   ///
   /// Called with the stream to yield from.
   final js.Expression yieldStarExpression;
 
   /// Used by sync* functions to throw exeptions.
   final js.Expression uncaughtErrorExpression;
 
   SyncStarRewriter(DiagnosticReporter diagnosticListener, spannable,
       {this.endOfIteration,
-      this.newIterable,
+      this.iterableFactory,
       this.yieldStarExpression,
       this.uncaughtErrorExpression,
       String safeVariableName(String proposedName),
       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.
@@ skipping 11 matching lines @@
   js.Fun finishFunction(
       List<js.Parameter> parameters,
       js.Statement rewrittenBody,
       js.VariableDeclarationList variableDeclarations,
       SourceInformation sourceInformation) {
     // Each iterator invocation on the iterable should work on its own copy of
     // the parameters.
     // TODO(sigurdm): We only need to do this copying for parameters that are
     // mutated.
     List<js.VariableInitialization> declarations =
-        new List<js.VariableInitialization>();
-    List<js.Parameter> renamedParameters = new List<js.Parameter>();
+        <js.VariableInitialization>[];
+    List<js.Parameter> renamedParameters = <js.Parameter>[];
     for (js.Parameter parameter in parameters) {
       String name = parameter.name;
       String renamedName = freshName(name);
       renamedParameters.add(new js.Parameter(renamedName));
       declarations.add(new js.VariableInitialization(
           new js.VariableDeclaration(name), new js.VariableUse(renamedName)));
     }
     js.VariableDeclarationList copyParameters =
         new js.VariableDeclarationList(declarations);
     return js.js(
         """
           function (#renamedParameters) {
             if (#needsThis)
               var #self = this;
-            return new #newIterable(function () {
+            return #iterableFactory(function () {
               if (#hasParameters) {
                 #copyParameters;
               }
               #varDecl;
               return function #body(#errorCode, #result) {
                 if (#errorCode === #ERROR) {
                     #currentError = #result;
                     #goto = #handler;
                 }
                 #helperBody;
               };
             });
           }
           """,
         {
           "renamedParameters": renamedParameters,
           "needsThis": analysis.hasThis,
           "helperBody": rewrittenBody,
           "hasParameters": parameters.isNotEmpty,
           "copyParameters": copyParameters,
           "varDecl": variableDeclarations,
           "errorCode": errorCodeName,
-          "newIterable": newIterable,
+          "iterableFactory": iterableFactory,
           "body": bodyName,
           "self": selfName,
           "result": resultName,
           "goto": goto,
           "handler": handler,
           "currentError": currentErrorName,
           "ERROR": js.number(error_codes.ERROR),
         }).withSourceInformation(sourceInformation);
   }
 
   void addErrorExit() {
     beginLabel(rethrowLabel);
     addStatement(js.js
         .statement('return #(#);', [uncaughtErrorExpression, currentError]));
   }
 
   /// Returning from a sync* function returns an [endOfIteration] marker.
   void addSuccesExit() {
     if (analysis.hasExplicitReturns) {
       beginLabel(exitLabel);
     } else {
       addStatement(new js.Comment("implicit return"));
     }
     addStatement(js.js.statement('return #();', [endOfIteration]));
   }
 
   @override
   Iterable<js.VariableInitialization> variableInitializations() {
-    List<js.VariableInitialization> variables =
-        new List<js.VariableInitialization>();
+    List<js.VariableInitialization> variables = <js.VariableInitialization>[];
     return variables;
   }
 
   @override
   js.Statement awaitStatement(js.Expression value) {
     throw reporter.internalError(
         spannable, "Sync* functions cannot contain await statements.");
   }
 
   @override
@@ skipping 172 matching lines @@
     addStatement(js.js
         .statement("return #streamHelper(null, #successCode, #controller);", {
       "streamHelper": asyncStarHelper,
       "successCode": js.number(error_codes.SUCCESS),
       "controller": controllerName
     }));
   }
 
   @override
   Iterable<js.VariableInitialization> variableInitializations() {
-    List<js.VariableInitialization> variables =
-        new List<js.VariableInitialization>();
+    List<js.VariableInitialization> variables = <js.VariableInitialization>[];
     variables.add(_makeVariableInitializer(
         controller, js.js('#(#)', [newController, bodyName])));
     if (analysis.hasYield) {
       variables.add(_makeVariableInitializer(nextWhenCanceled, null));
     }
     return variables;
   }
 
   @override
   void initializeNames() {
@@ skipping 21 matching lines @@
 /// 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.
 class PreTranslationAnalysis extends js.NodeVisitor<bool> {
   Set<js.Node> hasAwaitOrYield = new Set<js.Node>();
 
   Map<js.Node, js.Node> targets = new Map<js.Node, js.Node>();
-  List<js.Node> loopsAndSwitches = new List<js.Node>();
-  List<js.LabeledStatement> labelledStatements =
-      new List<js.LabeledStatement>();
+  List<js.Node> loopsAndSwitches = <js.Node>[];
+  List<js.LabeledStatement> labelledStatements = <js.LabeledStatement>[];
   Set<String> usedNames = new Set<String>();
 
   bool hasExplicitReturns = false;
 
   bool hasThis = false;
 
   bool hasYield = false;
 
   bool hasFinally = false;
 
@@ skipping 421 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }