dart2js cps: Clone small constants to use site.

pkg/compiler/lib/src/tree_ir/optimization/statement_rewriter.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.optimization.statement_rewriter;
 
 import 'optimization.dart' show Pass;
 import '../tree_ir_nodes.dart';
 import '../../io/source_information.dart';
 import '../../elements/elements.dart';
@@ skipping 221 matching lines @@
   /// If the given expression always returns the value of one of its
   /// subexpressions, returns that subexpression, otherwise `null`.
   Expression getValueSubexpression(Expression e) {
     if (e is SetField) return e.value;
     return null;
   }
 
   /// If the given expression always returns the value of one of its
   /// subexpressions, and that subexpression is a variable use, returns that
   /// variable. Otherwise `null`.
-  Variable getRightHand(Expression e) {
+  Variable getRightHandVariable(Expression e) {
     Expression value = getValueSubexpression(e);
     return value is VariableUse ? value.variable : null;
   }
 
+  Constant getRightHandConstant(Expression e) {
+    Expression value = getValueSubexpression(e);
+    return value is Constant ? value : null;
+  }
+
   /// True if the given expression (taken from [constantEnvironment]) uses a
   /// variable that might have been reassigned since [node] was evaluated.
   bool hasUnsafeVariableUse(Expression node) {
     bool wasFound = false;
     VariableUseVisitor.visit(node, (VariableUse use) {
       if (dominatingAssignments[use.variable] > 1) {
         wasFound = true;
       }
     });
     return wasFound;
@@ skipping 58 matching lines @@
         return visitExpression(binding);
       }
 
       // Is the most recently evaluated impure expression known to have the
       // value of this variable?
       //
       // If so, we can replace this use with the impure expression, e.g:
       //
       //     { E.foo = x; bar(x) } ==> bar(E.foo = x)
       //
-      if (getRightHand(binding) == node.variable) {
+      if (getRightHandVariable(binding) == node.variable) {
         environment.removeLast();
         --node.variable.readCount;
         return visitExpression(binding);
       }
     }
 
     // If the definition could not be propagated, leave the variable use.
     return node;
   }
 
@@ skipping 242 matching lines @@
     });
 
     return node;
   }
 
   Expression visitNot(Not node) {
     node.operand = visitExpression(node.operand);
     return node;
   }
 
+  bool isNullConstant(Expression node) {
+    return node is Constant && node.value.isNull;
+  }
+
   Statement visitReturn(Return node) {
-    node.value = visitExpression(node.value);
+    if (!isNullConstant(node.value)) {
+      // Do not chain assignments into a null return.
+      node.value = visitExpression(node.value);
+    }
     return node;
   }
 
   Statement visitThrow(Throw node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
   Statement visitRethrow(Rethrow node) {
     return node;
@@ skipping 102 matching lines @@
       node.tryBody = visitStatement(node.tryBody);
       safeForInlining = saved;
       node.catchParameters.forEach(pushDominatingAssignment);
       node.catchBody = visitStatement(node.catchBody);
       node.catchParameters.forEach(popDominatingAssignment);
     });
     return node;
   }
 
   Expression visitConstant(Constant node) {
+    if (!environment.isEmpty) {
+      Constant constant = getRightHandConstant(environment.last);
+      if (constant != null && constant.value == node.value) {
+        return visitExpression(environment.removeLast());
+      }
+    }
     return node;
   }
 
   Expression visitThis(This node) {
     return node;
   }
 
   Expression visitLiteralList(LiteralList node) {
     _rewriteList(node.values);
     return node;
@@ skipping 568 matching lines @@
   VariableUseCallback callback;
 
   VariableUseVisitor(this.callback);
 
   visitVariableUse(VariableUse use) => callback(use);
 
   static void visit(Expression node, VariableUseCallback callback) {
     new VariableUseVisitor(callback).visitExpression(node);
   }
 }