Support ExpressionStatement in the dart2dart backend.

sdk/lib/_internal/compiler/implementation/ir/ir_builder.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import 'ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 218 matching lines @@
    * such as [:foo(){ }:].
    */
   void ensureReturn(ast.FunctionExpression node) {
     if (!isOpen) return;
     ir.Constant constant = new ir.Constant(constantSystem.createNull());
     add(new ir.LetPrim(constant));
     add(new ir.InvokeContinuation(returnContinuation, constant));
     current = null;
   }
 
+  // Build(EmptyStatement, C) = C
   ir.Definition visitEmptyStatement(ast.EmptyStatement node) {
     assert(isOpen);
     return null;
   }
 
+  // Build(Block(stamements), C) = C'
+  //   where C' = statements.fold(Build, C)
   ir.Definition visitBlock(ast.Block node) {
     assert(isOpen);
     for (var n in node.statements.nodes) {
       n.accept(this);
       if (!isOpen) return null;
     }
     return null;
   }
 
-  // Build(Return)    = let val x = null in InvokeContinuation(return, x)
-  // Build(Return(e)) = C[InvokeContinuation(return, x)]
-  //   where (C, x) = Build(e)
+  // Build(ExpressionStatement(e), C) = C'
+  //   where (C', _) = Build(e, C)
+  ir.Definition visitExpressionStatement(ast.ExpressionStatement node) {
+    assert(isOpen);
+    node.expression.accept(this);
+    return null;
+  }
+
+  // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
+  //   where (C', x) = Build(e, C)
+  //
+  // Return without a subexpression is translated as if it were return null.
   ir.Definition visitReturn(ast.Return node) {
     assert(isOpen);
     // TODO(lry): support native returns.
     if (node.beginToken.value == 'native') return giveup();
     ir.Definition value;
     if (node.expression == null) {
       value = new ir.Constant(constantSystem.createNull());
       add(new ir.LetPrim(value));
     } else {
       value = node.expression.accept(this);
       if (!isOpen) return null;
     }
     add(new ir.InvokeContinuation(returnContinuation, value));
     current = null;
     return null;
   }
 
   // For all simple literals:
-  // Build(Literal(c)) = (let val x = Constant(c) in [], x)
+  // Build(Literal(c), C) = C[let val x = Constant(c) in [], x]
   ir.Definition visitLiteralBool(ast.LiteralBool node) {
     assert(isOpen);
     ir.Constant constant =
         new ir.Constant(constantSystem.createBool(node.value));
     add(new ir.LetPrim(constant));
     return constant;
   }
 
   ir.Definition visitLiteralDouble(ast.LiteralDouble node) {
     assert(isOpen);
@@ skipping 40 matching lines @@
   }
 
   ir.Definition visitGetterSend(ast.Send node) {
     return giveup();
   }
 
   ir.Definition visitOperatorSend(ast.Send node) {
     return giveup();
   }
 
-  // Build(StaticSend(f, a...)) = C[InvokeStatic(f, x...)]
-  //   where (C, x...) = BuildList(a...)
+  // Build(StaticSend(f, arguments), C) = C[C'[InvokeStatic(f, xs)]]
+  //   where (C', xs) = arguments.fold(Build, C)
   ir.Definition visitStaticSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
     // TODO(lry): support static fields. (separate IR instruction?)
     if (element.isField() || element.isGetter()) return giveup();
+    // TODO(kmillikin): support static setters.
+    if (element.isSetter()) return giveup();
     // TODO(lry): support constructors / factory calls.
     if (element.isConstructor()) return giveup();
     // TODO(lry): support foreign functions.
     if (element.isForeign(compiler)) return giveup();
     // TODO(lry): for elements that could not be resolved emit code to throw a
     // [NoSuchMethodError].
     if (element.isErroneous()) return giveup();
     // TODO(lry): generate IR for object identicality.
     if (element == compiler.identicalFunction) giveup();
 
@@ skipping 54 matching lines @@
 // Verify that types are ones that can be reconstructed by the type emitter.
 class SupportedTypeVerifier extends DartTypeVisitor<bool, Null> {
   bool visitType(DartType type, Null _) => false;
 
   bool visitVoidType(VoidType type, Null _) => true;
 
   // Currently, InterfaceType and TypedefType are supported so long as they
   // do not have type parameters.  They are subclasses of GenericType.
   bool visitGenericType(GenericType type, Null _) => !type.isGeneric;
 }