Support ExpressionStatement in the dart2dart backend.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_tree.dart

 // Copyright (c) 2014, 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 dart_tree;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../util/util.dart';
 import '../elements/elements.dart' show FunctionElement, FunctionSignature;
@@ skipping 47 matching lines @@
     identifier = Emitter.makeIdentifier(name);
     return identifier;
   }
 
   final bool isPure = true;
 
   accept(Visitor visitor) => visitor.visitVariable(this);
 }
 
 /**
+ * A sequence of expressions.
+ */
+class Sequence extends Expression {
+  final List<Expression> expressions;
+
+  Sequence(this.expressions);
+
+  bool get isPure => expressions.every((e) => e.isPure);
+
+  accept(Visitor visitor) => visitor.visitSequence(this);
+}
+
+/**
  * A local binding of a [Variable] to an [Expression].
  *
  * In contrast to the CPS-based IR, non-primitive expressions can be named
  * with let.
  */
 class LetVal extends Expression {
   final Variable variable;
   final Expression definition;
   final Expression body;
 
@@ skipping 49 matching lines @@
   accept(Visitor visitor) => visitor.visitConstant(this);
 }
 
 abstract class Visitor<T> {
   // Abstract classes.
   T visitNode(Node node) => node.accept(this);
   T visitExpression(Expression node) => visitNode(node);
 
   // Concrete classes.
   T visitVariable(Variable node) => visitExpression(node);
+  T visitSequence(Sequence node) => visitExpression(node);
   T visitLetVal(LetVal node) => visitExpression(node);
   T visitInvokeStatic(InvokeStatic node) => visitExpression(node);
   T visitReturn(Return node) => visitExpression(node);
   T visitConstant(Constant node) => visitExpression(node);
 }
 
 /**
  * Builder translates from CPS-based IR to direct-style Tree.
  *
  * A call `Invoke(fun, cont, args)`, where cont is a singly-referenced
@@ skipping 43 matching lines @@
 
   Expression visitFunction(ir.Function node) {
     // Functions are simplistically translated to their bodies.  For now this
     // is good enough.
     returnContinuation = node.returnContinuation;
     return node.body.accept(this);
   }
 
   Expression visitLetPrim(ir.LetPrim node) {
     // LetPrim is translated to LetVal.
-    Variable variable = new Variable();
     Expression definition = node.primitive.accept(this);
-    variables[node.primitive] = variable;
-    return new LetVal(variable, definition, node.body.accept(this));
+    if (node.primitive.hasAtLeastOneUse) {
+      Variable variable = new Variable();
+      variables[node.primitive] = variable;
+      return new LetVal(variable, definition, node.body.accept(this));
+    } else {
+      return new Sequence([definition, node.body.accept(this)]);
+    }
   }
 
   Expression visitLetCont(ir.LetCont node) {
     // TODO(kmillikin): Allow continuations to have multiple uses.  This could
     // arise due to the representation of local control flow or due to
     // optimization.
     assert(node.continuation.hasAtMostOneUse);
     return node.body.accept(this);
   }
 
   Expression visitInvokeStatic(ir.InvokeStatic node) {
     // Calls are translated to direct style.
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeStatic(node.target, arguments);
     ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
       return new Return(invoke);
     } else {
       assert(cont.hasExactlyOneUse);
-      Variable variable = new Variable();
-      variables[cont.parameter] = variable;
-      return new LetVal(variable, invoke, cont.body.accept(this));
+      if (cont.parameter.hasAtLeastOneUse) {
+        Variable variable = new Variable();
+        variables[cont.parameter] = variable;
+        return new LetVal(variable, invoke, cont.body.accept(this));
+      } else {
+        return new Sequence([invoke, cont.body.accept(this)]);
+      }
     }
   }
 
   Expression visitInvokeContinuation(ir.InvokeContinuation node) {
     // TODO(kmillikin): Support non-return continuations.  These could arise
     // due to local control flow or due to inlining or other optimization.
     assert(node.continuation.definition == returnContinuation);
     return new Return(variables[node.argument.definition]);
   }
 
@@ skipping 77 matching lines @@
       } else if (!environment[i].definition.isPure) {
         // Once the first impure definition is seen, impure definitions should
         // no longer be propagated.  Continue searching for a pure definition.
         seenImpure = true;
       }
     }
     // If the definition could not be propagated, leave the variable use.
     return node;
   }
 
+  Expression visitSequence(Sequence node) {
+    for (int i = 0; i < node.expressions.length; ++i) {
+      node.expressions[i] = node.expressions[i].accept(this);
+    }
+    return node;
+  }
+
   Expression visitLetVal(LetVal node) {
     environment.add(node);
     Expression body = node.body.accept(this);
 
     // TODO(kmillikin): Allow definitions that are not propagated.  Currently,
     // the only bindings are anonymous intermediate values (which only have one
     // use in the absence of optimizations) and they are not reordered.
     assert(!environment.contains(node));
     return body;
   }
@@ skipping 139 matching lines @@
       ast.Expression value = (body as ast.Return).expression;
       if (value is ast.LiteralNull) {
         // '{ return null; }' is '{}'.
         body = makeBlock([]);
       } else {
         // '{ return e; }' is '=> e;'.
         body = new ast.Return(new SymbolToken(FUNCTION_INFO, -1),
                               semicolon,
                               value);
       }
+    } else if (body is ast.Block) {
+      // Remove a final 'return null' that ends the body block.
+      Link<ast.Node> nodes = (body as ast.Block).statements.nodes;
+      ast.Node last;
+      for (var n in nodes) {

[floitsch, 2014/04/04 11:14:27]

Why not ast.Node last = nodes.last; or even
if (nodes.last is ast.Return) {
  ...
}

Where do you check that it is Null?

+        last = n;
+      }
+      if (last is ast.Return) {
+        List<ast.Node> statements =
+            (body as ast.Block).statements.nodes.toList();
+        statements.removeLast();
+        body = makeBlock(statements);
+      }
     }
 
     return new ast.FunctionExpression(name, parameters, body, returnType,
         ast.Modifiers.EMPTY, null, null);
   }
 
   /**
    * Translate a list of arguments to an AST NodeList.
    */
   ast.NodeList translateArguments(List<Expression> args) {
@@ skipping 35 matching lines @@
         new ast.NodeList(openBrace, statements.toLink(), closeBrace));
   }
 
   ast.Node visitVariable(Variable node) {
     // The scope of variables is the body of their binding, so a name has
     // already been generated when we visit a variable.
     assert(node.identifier != null);
     return new ast.Send(null, node.identifier);
   }
 
+  ast.Node visitSequence(Sequence node) {
+    return node.expressions.map((e) => e.accept(this)).reduce(concatenate);
+  }
+
   ast.Node visitLetVal(LetVal node) {
     // Let bindings translate into assignments.
     ast.Identifier identifier = node.variable.assignIdentifier();
     variables.add(identifier);
 
     ast.Expression expression = node.definition.accept(this);
     ast.Expression assignment = makeAssignment(identifier, expression);
 
     ast.Node rest = node.body.accept(this);
     return concatenate(assignment, rest);
@@ skipping 122 matching lines @@
   }
 
   ast.Expression visitInterceptor(dart2js.InterceptorConstant constant) {
     return unimplemented();
   }
 
   ast.Expression visitDummy(dart2js.DummyConstant constant) {
     return unimplemented();
   }
 }