Remove BlockExpression from the Kernel language.

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 35 matching lines @@
   /// of statements by emitting statements into this list.  This list is built
   /// in reverse because children are visited right-to-left.
   ///
   /// 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 and
-  /// wrapping any emitted statements in a [BlockExpression].
+  /// [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
@@ skipping 11 matching lines @@
 
   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).
-  Expression rewrite(Expression expression) {
+  ///
+  /// Rewriting an expression produces a sequence of statements and an
+  /// expression.  The sequence of statements are added to the given list.  Pass
+  /// an empty list if the rewritten expression should be delimited from the
+  /// surrounding context.
+  Expression rewrite(Expression expression, List<Statement> outer) {
     assert(statements.isEmpty);
     assert(nameIndex == 0);
     seenAwait = false;
-    var result = expression.accept(this);
+    Expression result = expression.accept(this);
+    outer.addAll(statements.reversed);
+    statements.clear();
     nameIndex = 0;
-    if (statements.isNotEmpty) {
-      result = new BlockExpression(blockOf(statements), result);
-      statements = <Statement>[];
-    }
     return result;
   }
 
   // Perform an action with a given list of statements so that it cannot emit
   // statements into the 'outer' list.
   Expression delimit(Expression action(), List<Statement> inner) {
     var index = nameIndex;
     var outer = statements;
     statements = inner;
     Expression result = action();
@@ skipping 293 matching lines @@
     ++nameIndex;
     seenAwait = seenAwait || thenAwait || otherwiseAwait;
     return new VariableGet(result);
   }
 
   // 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)]);
+    statements.add(new ExpressionStatement(
+        new StaticInvocation(R.helper.awaitHelper, arguments)));
+
     seenAwait = false;
     var index = nameIndex;
-    var operand = expr.operand.accept(this);
-
-    // The statements are in reverse order, so name the result first if
-    // necessary and then add these two in reverse.
-    statements.add(R.createContinuationPoint());
-    statements.add(new ExpressionStatement(
-        new StaticInvocation(R.helper.awaitHelper,
-            new Arguments(<Expression>[
-                operand,
-                new VariableGet(R.thenContinuationVariable),
-                new VariableGet(R.catchErrorContinuationVariable)]))));
+    arguments.positional[0] = expr.operand.accept(this)..parent = arguments;

[Kevin Millikin (Google), 2016/10/31 12:29:32]

This was a bug: the translated operand should occur before the continuation
point, so it must be translated after because the statements are accumulated in
reverse order.

 
     if (shouldName) nameIndex = index + 1;
     seenAwait = true;
     return result;
   }
 
   TreeNode visitFunctionExpression(FunctionExpression expr) {
     expr.transformChildren(this);
     return expr;
   }
 
   TreeNode visitLet(Let expr) {
-    expr.body = expr.body.accept(this)..parent = expr;
-    VariableDeclaration variable = expr.variable;
-    variable.initializer =
-        variable.initializer.accept(this)..parent = variable;
-    return expr;
-  }
-
-  TreeNode visitBlockExpression(BlockExpression expr) {
-    var length = statements.length;
-    expr.value.accept(this)..parent = expr;
-    if (statements.length == length) {
-      // The statements in the body do not need be translated right-to-left
-      // because all subexpressions will be treated as delimited and so
-      // prevented from emitting statements into the list of statements.
-      expr.body = expr.body.accept(continuationRewriter)..parent = expr;
-      return expr;
-    } else {
-      // Statements were emitted from the translation of the value.  The
-      // statements in the body must be executed before them.  Copy the body's
-      // statements to the accumulated statement list in reverse order.
-      for (var statement in expr.body.statements.reversed) {
-        statements.add(statement.accept(continuationRewriter));
-      }
-      return expr.value;
-    }
+    return transform(expr, () {
+      expr.body = expr.body.accept(this)..parent = expr;
+      VariableDeclaration variable = expr.variable;
+      variable.initializer =
+          variable.initializer.accept(this)..parent = variable;
+    });
   }
 
   visitFunctionNode(FunctionNode node) {
     var nestedRewriter = new RecursiveContinuationRewriter(
         continuationRewriter.helper);
     return node.accept(nestedRewriter);
   }
 }