dart2js cps: Introduce some built-in operators in type propagation.

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 192 matching lines @@
     node.left = makeCondition(node.left, true);
     node.right = makeCondition(node.right, true);
     return node;
   }
 
   /// True if the given expression is known to evaluate to a boolean.
   /// This will not recursively traverse [Conditional] expressions, but if
   /// applied to the result of [visitExpression] conditionals will have been
   /// rewritten anyway.
   bool isBooleanValued(Expression e) {
-    return isTrue(e) || isFalse(e) || e is Not || e is LogicalOperator;
+    return isTrue(e) ||
+           isFalse(e) ||
+           e is Not ||
+           e is LogicalOperator ||
+           e is ApplyBuiltinOperator && operatorReturnsBool(e.operator);
+  }
+
+  /// True if the given operator always returns `true` or `false`.
+  bool operatorReturnsBool(BuiltinOperator operator) {
+    switch (operator) {
+      case BuiltinOperator.StrictEq:
+      case BuiltinOperator.StrictNeq:
+      case BuiltinOperator.LooseEq:
+      case BuiltinOperator.LooseNeq:
+      case BuiltinOperator.NumLt:
+      case BuiltinOperator.NumLe:
+      case BuiltinOperator.NumGt:
+      case BuiltinOperator.NumGe:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  BuiltinOperator negateBuiltin(BuiltinOperator operator) {
+    switch (operator) {
+      case BuiltinOperator.StrictEq: return BuiltinOperator.StrictNeq;
+      case BuiltinOperator.StrictNeq: return BuiltinOperator.StrictEq;
+      case BuiltinOperator.LooseEq: return BuiltinOperator.LooseNeq;
+      case BuiltinOperator.LooseNeq: return BuiltinOperator.LooseEq;
+
+      // Because of NaN, these do not have a negated form.
+      case BuiltinOperator.NumLt:
+      case BuiltinOperator.NumLe:
+      case BuiltinOperator.NumGt:
+      case BuiltinOperator.NumGe:
+        return null;
+
+      default:
+        return null;
+    }
   }
 
   /// Rewrite an expression that was originally processed in a non-boolean
   /// context.
   Expression putInBooleanContext(Expression e) {
     if (e is Not && e.operand is Not) {
       return (e.operand as Not).operand;
     } else {
       return e;
     }
@@ skipping 26 matching lines @@
       }
       // !x && !y ==> !(x || y)  (only if lifting nots)
       if (e.left is Not && e.right is Not && liftNots) {
         e.left = (e.left as Not).operand;
         e.right = (e.right as Not).operand;
         e.isAnd = !e.isAnd;
         return new Not(e);
       }
       return e;
     }
+    if (e is ApplyBuiltinOperator && polarity == false) {
+      BuiltinOperator negated = negateBuiltin(e.operator);
+      if (negated != null) {
+        e.operator = negated;
+        return visitExpression(e);
+      } else {
+        return new Not(visitExpression(e));
+      }
+    }
     if (e is Conditional) {
       // Handle polarity by: !(x ? y : z) ==> x ? !y : !z
       // Rewrite individual branches now. The condition will be rewritten
       // when we know what polarity to use (depends on which rewrite is used).
       e.thenExpression = makeCondition(e.thenExpression, polarity);
       e.elseExpression = makeCondition(e.elseExpression, polarity);
 
       // x ? true : false ==> x
       if (isTrue(e.thenExpression) && isFalse(e.elseExpression)) {
         return makeCondition(e.condition, true, liftNots: liftNots);
@@ skipping 74 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);
     }
   }
 }