dart2js cps: Streamline expressions and primitives.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.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 tree_ir_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../util/util.dart' show CURRENT_ELEMENT_SPANNABLE;
@@ skipping 240 matching lines @@
     }
     return first;
   }
 
   visit(cps_ir.Node node) => node.accept(this);
 
   unexpectedNode(cps_ir.Node node) {
     internalError(CURRENT_ELEMENT_SPANNABLE, 'Unexpected IR node: $node');
   }
 
-  Statement visitSetField(cps_ir.SetField node) {
-    return new ExpressionStatement(
-        new SetField(getVariableUse(node.object),
-                     node.field,
-                     getVariableUse(node.value)),
-        visit(node.body));
+  Expression visitSetField(cps_ir.SetField node) {
+    return new SetField(getVariableUse(node.object),
+                        node.field,
+                        getVariableUse(node.value));
   }
 
   Expression visitInterceptor(cps_ir.Interceptor node) {
     return new Interceptor(getVariableUse(node.input), node.interceptedClasses);
   }
 
   Expression visitCreateInstance(cps_ir.CreateInstance node) {
     return new CreateInstance(
         node.classElement,
         translateArguments(node.arguments),
@@ skipping 16 matching lines @@
   }
 
   // Executable definitions are not visited directly.  They have 'build'
   // functions as entry points.
   visitFunctionDefinition(cps_ir.FunctionDefinition node) {
     return unexpectedNode(node);
   }
 
   Statement visitLetPrim(cps_ir.LetPrim node) {
     Variable variable = getVariable(node.primitive);
-
-    // Don't translate unused primitives.
-    if (variable == null) return visit(node.body);

[asgerf, 2015/07/20 13:35:23]

This was dead code, left behind after another refactoring.

-
     Expression value = visit(node.primitive);
-    return Assign.makeStatement(variable, value, visit(node.body));
+    if (node.primitive.hasAtLeastOneUse) {
+      return Assign.makeStatement(variable, value, visit(node.body));
+    } else {
+      return new ExpressionStatement(value, visit(node.body));
+    }
   }
 
   Statement visitLetCont(cps_ir.LetCont node) {
     // Introduce labels for continuations that need them.
     for (cps_ir.Continuation continuation in node.continuations) {
       if (continuation.hasMultipleUses || continuation.isRecursive) {
         labels[continuation] = new Label();
       }
     }
     Statement body = visit(node.body);
@@ skipping 90 matching lines @@
     Variable variable = addMutableVariable(node.variable);
     Expression value = getVariableUse(node.value);
     Statement body = visit(node.body);
     return Assign.makeStatement(variable, value, body);
   }
 
   Expression visitGetMutableVariable(cps_ir.GetMutableVariable node) {
     return getMutableVariableUse(node.variable);
   }
 
-  Statement visitSetMutableVariable(cps_ir.SetMutableVariable node) {
+  Expression visitSetMutableVariable(cps_ir.SetMutableVariable node) {
     Variable variable = getMutableVariable(node.variable.definition);
     Expression value = getVariableUse(node.value);
-    return Assign.makeStatement(variable, value, visit(node.body));
+    return new Assign(variable, value);
   }
 
   Statement visitTypeCast(cps_ir.TypeCast node) {
     Expression value = getVariableUse(node.value);
     List<Expression> typeArgs = translateArguments(node.typeArguments);
     Expression expression =
         new TypeOperator(value, node.type, typeArgs, isTypeTest: false);
     return continueWithExpression(node.continuation, expression);
   }
 
@@ skipping 146 matching lines @@
     return new GetStatic(node.element, node.sourceInformation);
   }
 
   Statement visitGetLazyStatic(cps_ir.GetLazyStatic node) {
     // In the tree IR, GetStatic handles lazy fields because tree
     // expressions are allowed to have side effects.
     GetStatic value = new GetStatic(node.element, node.sourceInformation);
     return continueWithExpression(node.continuation, value);
   }
 
-  Statement visitSetStatic(cps_ir.SetStatic node) {
-    SetStatic setStatic = new SetStatic(
+  Expression visitSetStatic(cps_ir.SetStatic node) {
+    return new SetStatic(
         node.element,
         getVariableUse(node.value),
         node.sourceInformation);
-    return new ExpressionStatement(setStatic, visit(node.body));
   }
 
   Expression visitApplyBuiltinOperator(cps_ir.ApplyBuiltinOperator node) {
     if (node.operator == BuiltinOperator.IsFalsy) {
       return new Not(getVariableUse(node.arguments.single));
     }
     return new ApplyBuiltinOperator(node.operator,
                                     translateArguments(node.arguments));
   }
 
@@ skipping 26 matching lines @@
                         getVariableUse(node.index));
   }
 
   Expression visitSetIndex(cps_ir.SetIndex node) {
     return new SetIndex(getVariableUse(node.object),
                         getVariableUse(node.index),
                         getVariableUse(node.value));
   }
 }