Merge kernel closure conversion into the Dart SDK

pkg/kernel/lib/transformations/async.dart

 // Copyright (c) 2016, 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 kernel.transformations.async;
 
 import '../kernel.dart';
 import 'continuation.dart';
 
 /// A transformer that introduces temporary variables for all subexpressions
@@ skipping 38 matching lines @@
   /// If an expression should be named it is named before visiting its children
   /// so the naming assignment appears in the list before all statements
   /// implementating the translation of the children.
   ///
   /// Children that are conditionally evaluated, such as some parts of logical
   /// and conditional expressions, must be delimited so that they do not emit
   /// unguarded statements into [statements].  This is implemented by setting
   /// [statements] to a fresh empty list before transforming those children.
   List<Statement> statements = <Statement>[];
 
-
   /// The number of currently live named intermediate values.
   ///
   /// This index is used to allocate names to temporary values.  Because
   /// children are visited right-to-left, names are assigned in reverse order of
   /// index.
   ///
   /// When an assignment is emitted into [statements] to name an expression
   /// before visiting its children, the index is not immediately reserved
   /// because a child can freely use the same name as its parent.  In practice,
   /// this will be the rightmost named child.
   ///
   /// After visiting the children of a named expression, [nameIndex] is set to
   /// indicate one more live value (the value of the expression) than before
   /// visiting the expression.
   ///
   /// After visiting the children of an expression that is not named,
   /// [nameIndex] may still account for names of subexpressions.
   int nameIndex = 0;
 
-  final VariableDeclaration asyncResult =
-      new VariableDeclaration(':result');
+  final VariableDeclaration asyncResult = new VariableDeclaration(':result');
   final List<VariableDeclaration> variables = <VariableDeclaration>[];
 
   ExpressionLifter(this.continuationRewriter);
 
   Block blockOf(List<Statement> stmts) => new Block(stmts.reversed.toList());
 
   /// Rewrite a toplevel expression (toplevel wrt. a statement).
   ///
   /// Rewriting an expression produces a sequence of statements and an
   /// expression.  The sequence of statements are added to the given list.  Pass
@@ skipping 78 matching lines @@
     var shouldName = seenAwait;
 
     // 1. If there is an await in a sibling to the right, emit an assignment to
     // a temporary variable before transforming the children.
     var result = shouldName ? name(expr) : expr;
 
     // 2. Remember the number of live temporaries before transforming the
     // children.
     var index = nameIndex;
 
-
     // 3. Transform the children.  Initially they do not have an await in a
     // sibling to their right.
     seenAwait = false;
     action();
 
-
     // 4. If the expression was named then the variables used for children are
     // no longer live but the variable used for the expression is.
     if (shouldName) {
       nameIndex = index + 1;
       seenAwait = true;
     }
     return result;
   }
 
   // Unary expressions.
   Expression unary(Expression expr) {
-    return transform(expr, () { expr.transformChildren(this); });
+    return transform(expr, () {
+      expr.transformChildren(this);
+    });
   }
 
   TreeNode visitVariableSet(VariableSet expr) => unary(expr);
   TreeNode visitPropertyGet(PropertyGet expr) => unary(expr);
   TreeNode visitDirectPropertyGet(DirectPropertyGet expr) => unary(expr);
   TreeNode visitSuperPropertySet(SuperPropertySet expr) => unary(expr);
   TreeNode visitStaticSet(StaticSet expr) => unary(expr);
   TreeNode visitNot(Not expr) => unary(expr);
   TreeNode visitIsExpression(IsExpression expr) => unary(expr);
   TreeNode visitAsExpression(AsExpression expr) => unary(expr);
@@ skipping 34 matching lines @@
   }
 
   TreeNode visitDirectMethodInvocation(DirectMethodInvocation expr) {
     return transform(expr, () {
       visitArguments(expr.arguments);
       expr.receiver = expr.receiver.accept(this)..parent = expr;
     });
   }
 
   TreeNode visitSuperMethodInvocation(SuperMethodInvocation expr) {
-    return transform(expr, () { visitArguments(expr.arguments); });
+    return transform(expr, () {
+      visitArguments(expr.arguments);
+    });
   }
 
   TreeNode visitStaticInvocation(StaticInvocation expr) {
-    return transform(expr, () { visitArguments(expr.arguments); });
+    return transform(expr, () {
+      visitArguments(expr.arguments);
+    });
   }
 
   TreeNode visitConstructorInvocation(ConstructorInvocation expr) {
-    return transform(expr, () { visitArguments(expr.arguments); });
+    return transform(expr, () {
+      visitArguments(expr.arguments);
+    });
   }
 
   TreeNode visitStringConcatenation(StringConcatenation expr) {
     return transform(expr, () {
       var expressions = expr.expressions;
       for (var i = expressions.length - 1; i >= 0; --i) {
         expressions[i] = expressions[i].accept(this)..parent = expr;
       }
     });
   }
@@ skipping 17 matching lines @@
   }
 
   // Control flow.
   TreeNode visitLogicalExpression(LogicalExpression expr) {
     var shouldName = seenAwait;
 
     // Right is delimited because it is conditionally evaluated.
     var rightStatements = <Statement>[];
     seenAwait = false;
     expr.right = delimit(() => expr.right.accept(this), rightStatements)
-        ..parent = expr;
+      ..parent = expr;
     var rightAwait = seenAwait;
 
     if (rightStatements.isEmpty) {
       // Easy case: right did not emit any statements.
       seenAwait = shouldName;
       return transform(expr, () {
         expr.left = expr.left.accept(this)..parent = expr;
         seenAwait = seenAwait || rightAwait;
       });
     }
 
     // If right has emitted statements we will produce a temporary t and emit
     // for && (there is an analogous case for ||):
     //
     // t = [left] == true;
     // if (t) {
     //   t = [right] == true;
     // }
 
     // Recall that statements are emitted in reverse order, so first emit the if
     // statement, then the assignment of [left] == true, and then translate left
     // so any statements it emits occur after in the accumulated list (that is,
     // so they occur before in the corresponding block).
     var rightBody = blockOf(rightStatements);
     var result = allocateTemporary(nameIndex);
-    rightBody.addStatement(new ExpressionStatement(
-        new VariableSet(
-            result,
-            new MethodInvocation(
-                expr.right,
-                new Name('=='),
-                new Arguments(<Expression>[new BoolLiteral(true)])))));
+    rightBody.addStatement(new ExpressionStatement(new VariableSet(
+        result,
+        new MethodInvocation(expr.right, new Name('=='),
+            new Arguments(<Expression>[new BoolLiteral(true)])))));
     var then, otherwise;
     if (expr.operator == '&&') {
       then = rightBody;
       otherwise = null;
     } else {
       then = new EmptyStatement();
       otherwise = rightBody;
     }
     statements.add(new IfStatement(new VariableGet(result), then, otherwise));
 
-    var test =
-        new MethodInvocation(
-            expr.left,
-            new Name('=='),
-            new Arguments(<Expression>[new BoolLiteral(true)]));
-    statements.add(
-        new ExpressionStatement(new VariableSet(result, test)));
+    var test = new MethodInvocation(expr.left, new Name('=='),
+        new Arguments(<Expression>[new BoolLiteral(true)]));
+    statements.add(new ExpressionStatement(new VariableSet(result, test)));
 
     seenAwait = false;
     test.receiver = test.receiver.accept(this)..parent = test;
 
     ++nameIndex;
     seenAwait = seenAwait || rightAwait;
     return new VariableGet(result);
   }
 
   TreeNode visitConditionalExpression(ConditionalExpression expr) {
     // Then and otherwise are delimited because they are conditionally
     // evaluated.
     var shouldName = seenAwait;
 
     var thenStatements = <Statement>[];
     seenAwait = false;
     expr.then = delimit(() => expr.then.accept(this), thenStatements)
-        ..parent = expr;
+      ..parent = expr;
     var thenAwait = seenAwait;
 
     var otherwiseStatements = <Statement>[];
     seenAwait = false;
-    expr.otherwise = delimit(() => expr.otherwise.accept(this),
-        otherwiseStatements)..parent = expr;
+    expr.otherwise =
+        delimit(() => expr.otherwise.accept(this), otherwiseStatements)
+          ..parent = expr;
     var otherwiseAwait = seenAwait;
 
     if (thenStatements.isEmpty && otherwiseStatements.isEmpty) {
       // Easy case: neither then nor otherwise emitted any statements.
       seenAwait = shouldName;
       return transform(expr, () {
         expr.condition = expr.condition.accept(this)..parent = expr;
         seenAwait = seenAwait || thenAwait || otherwiseAwait;
       });
     }
@@ skipping 27 matching lines @@
   // Others.
   TreeNode visitAwaitExpression(AwaitExpression expr) {
     final R = continuationRewriter;
     var shouldName = seenAwait;
     var result = new VariableGet(asyncResult);
     // The statements are in reverse order, so name the result first if
     // necessary and then add the two other statements in reverse.
     if (shouldName) result = name(result);
     statements.add(R.createContinuationPoint());
     Arguments arguments = new Arguments(<Expression>[
-        expr.operand,
-        new VariableGet(R.thenContinuationVariable),
-        new VariableGet(R.catchErrorContinuationVariable)]);
+      expr.operand,
+      new VariableGet(R.thenContinuationVariable),
+      new VariableGet(R.catchErrorContinuationVariable)
+    ]);
     statements.add(new ExpressionStatement(
         new StaticInvocation(R.helper.awaitHelper, arguments)));
 
     seenAwait = false;
     var index = nameIndex;
     arguments.positional[0] = expr.operand.accept(this)..parent = arguments;
 
     if (shouldName) nameIndex = index + 1;
     seenAwait = true;
     return result;
@@ skipping 22 matching lines @@
       // and return the body's value.
       //
       // So x is in scope for all the body's statements and the body's value.
       // This has the unpleasant consequence that all let-bound variables with
       // await in the let's body will end up hoisted out the the expression and
       // allocated to the context in the VM, even if they have no uses
       // (`let _ = e0 in e1` can be used for sequencing of `e0` and `e1`).
       statements.add(variable);
       var index = nameIndex;
       seenAwait = false;
-      variable.initializer =
-          variable.initializer.accept(this)..parent = variable;
+      variable.initializer = variable.initializer.accept(this)
+        ..parent = variable;
       // Temporaries used in the initializer or the body are not live but the
       // temporary used for the body is.
       nameIndex = index + 1;
       seenAwait = true;
       return body;
     } else {
       // The body in `let x = initializer in body` did not contain an await.  We
       // can leave a let expression.
       seenAwait = shouldName;
       return transform(expr, () {
         // The body has already been translated.
         expr.body = body..parent = expr;
-        variable.initializer =
-            variable.initializer.accept(this)..parent = variable;
+        variable.initializer = variable.initializer.accept(this)
+          ..parent = variable;
       });
     }
   }
 
   visitFunctionNode(FunctionNode node) {
-    var nestedRewriter = new RecursiveContinuationRewriter(
-        continuationRewriter.helper);
+    var nestedRewriter =
+        new RecursiveContinuationRewriter(continuationRewriter.helper);
     return node.accept(nestedRewriter);
   }
 }