dart2js cps: Add logical rewriter rules to favor null-aware operators.

pkg/compiler/lib/src/tree_ir/optimization/logical_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.logical_rewriter;
 
 import '../tree_ir_nodes.dart';
 import 'optimization.dart' show Pass;
 import '../../constants/values.dart' as values;
 
@@ skipping 288 matching lines @@
     node.condition = makeCondition(node.condition, true);
 
     // !x ? y : z ==> x ? z : y
     if (node.condition is Not) {
       node.condition = (node.condition as Not).operand;
       Expression tmp = node.thenExpression;
       node.thenExpression = node.elseExpression;
       node.elseExpression = tmp;
     }
 
+    // x ? y : x ==> x && y
+    if (isSameVariable(node.condition, node.elseExpression)) {
+      destroyVariableUse(node.elseExpression);
+      return new LogicalOperator.and(node.condition, node.thenExpression);
+    }
+    // x ? x : y ==> x || y
+    if (isSameVariable(node.condition, node.thenExpression)) {
+      destroyVariableUse(node.thenExpression);
+      return new LogicalOperator.or(node.condition, node.elseExpression);
+    }
+
     return node;
   }
 
   Expression visitLogicalOperator(LogicalOperator node) {
     node.left = visitExpression(node.left);
     node.right = visitExpression(node.right);
     return node;
   }
 
   /// True if the given expression is known to evaluate to a boolean.
@@ skipping 142 matching lines @@
         Expression tmp = e.thenExpression;
         e.thenExpression = e.elseExpression;
         e.elseExpression = tmp;
       }
       // x ? !y : !z ==> !(x ? y : z)  (only if lifting nots)
       if (e.thenExpression is Not && e.elseExpression is Not && liftNots) {
         e.thenExpression = (e.thenExpression as Not).operand;
         e.elseExpression = (e.elseExpression as Not).operand;
         return new Not(e);
       }
+
+      // x ? y : x ==> x && y
+      if (isSameVariable(e.condition, e.elseExpression)) {
+        destroyVariableUse(e.elseExpression);
+        return new LogicalOperator.and(e.condition, e.thenExpression);
+      }
+      // x ? x : y ==> x || y
+      if (isSameVariable(e.condition, e.thenExpression)) {
+        destroyVariableUse(e.thenExpression);
+        return new LogicalOperator.or(e.condition, e.elseExpression);
+      }
+
       return e;
     }
     if (e is Constant && e.value.isBool) {
       // !true ==> false
       if (!polarity) {
         values.BoolConstantValue value = e.value;
         return new Constant.bool(value.negate());
       }
       return e;
     }
@@ skipping 21 matching lines @@
     }
   }
 
   Expression makeOr(Expression e1, Expression e2, {bool liftNots: true}) {
     if (e1 is Not && e2 is Not && liftNots) {
       return new Not(new LogicalOperator.and(e1.operand, e2.operand));
     } else {
       return new LogicalOperator.or(e1, e2);
     }
   }
+
+  /// True if [e2] is known to return the same value as [e1] 
+  /// (with no additional side effects) if evaluated immediately after [e1].
+  /// 
+  /// Concretely, this is true if [e1] and [e2] are uses of the same variable,
+  /// or if [e2] is a use of a variable assigned by [e1].
+  bool isSameVariable(Expression e1, Expression e2) {
+    if (e1 is VariableUse) {
+      return e2 is VariableUse && e1.variable == e2.variable;
+    } else if (e1 is Assign) {
+      return e2 is VariableUse && e1.variable == e2.variable;
+    }
+    return false;
+  }
+
+  void destroyVariableUse(VariableUse node) {
+    --node.variable.readCount;
+  }
 }