Avoid "=== true" inside code by calling a function that does this for us.

lib/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2011, 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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 572 matching lines @@
 
   static void rewriteInput(HInstruction instruction,
                            HInstruction from,
                            HInstruction to) {
     List inputs = instruction.inputs;
     for (int i = 0; i < inputs.length; i++) {
       if (inputs[i] === from) inputs[i] = to;
     }
   }
 
+  static void removeUser(HInstruction instruction, HInstruction user) {

[ngeoffray, 2012/04/26 08:40:00]

Why a static function and not a function on HInstruction?

[floitsch, 2012/04/26 10:36:09]

Will change in a new CL.

+    List<HInstruction> users = instruction.usedBy;
+    int length = users.length;
+    if (length == 1) {
+      users.clear();
+    } else {
+      for (int i = 0; i < length; i++) {
+        if (users[i] === user) {
+          users[i] = users[length - 1];
+          users.length = length - 1;
+          return;
+        }
+      }
+    }
+  }
+
   bool isExitBlock() {
     return first === last && first is HExit;
   }
 
   void addDominatedBlock(HBasicBlock block) {
     assert(isClosed());
     assert(id !== null && block.id !== null);
     assert(dominatedBlocks.indexOf(block) < 0);
     // Keep the list of dominated blocks sorted such that if there are two
     // succeeding blocks in the list, the predecessor is before the successor.
@@ skipping 1307 matching lines @@
     if (logicalOperatorType == IS_AND) return "&&";
     assert(logicalOperatorType == IS_OR);
     return "||";
   }
 
   toString() => 'phi';
   accept(HVisitor visitor) => visitor.visitPhi(this);
 }
 
 class HRelational extends HInvokeBinary {
+  bool usesBoolifiedInterceptor = false;
   HRelational(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
   void prepareGvn() {
     // Relational expressions can take part in global value numbering
     // and do not have any side-effects if we know all the inputs are
     // numbers. This can be improved for at least equality.
     if (builtin) {
       clearAllSideEffects();
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
   HType computeTypeFromInputTypes() {
-    if (left.isNumber()) return HType.BOOLEAN;
+    if (left.isNumber() || usesBoolifiedInterceptor) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
+  HType get guaranteedType() {
+    if (usesBoolifiedInterceptor) return HType.BOOLEAN;
+    return HType.UNKNOWN;
+  }
+
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // For all relational operations exept HEquals, we expect to get numbers
     // only. With numbers the outgoing type is a boolean. If something else
     // is desired, then numbers are incorrect, though.
     if (propagatedType.isUnknown() || propagatedType.isBoolean()) {
       if (left.isTypeUnknown() || left.isNumber()) return HType.NUMBER;
     }
     return HType.UNKNOWN;
   }
 
@@ skipping 10 matching lines @@
   accept(HVisitor visitor) => visitor.visitEquals(this);
 
   bool get builtin() {
     // All useful types have === semantics.
     // Note that this includes all constants except the user-constructed
     // objects.
     return left.isConstantNull() || left.propagatedType.isUseful();
   }
 
   HType computeTypeFromInputTypes() {
-    if (builtin) return HType.BOOLEAN;
+    if (builtin || usesBoolifiedInterceptor) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     if (input == left && right.propagatedType.isUseful()) {
       // All our useful types have === semantics. But we don't want to
       // speculatively test for all possible types. Therefore we try to match
       // the two types. That is, if we see x == 3, then we speculatively test
       // if x is a number and bailout if it isn't.
       if (right.isNumber()) return HType.NUMBER;  // No need to be more precise.
@@ skipping 341 matching lines @@
   final bool isAnd;
   final SubExpression left;
   final SubExpression right;
   final HBasicBlock joinBlock;
   HAndOrBlockInformation(this.isAnd,
                          this.left,
                          this.right,
                          this.joinBlock);
   bool accept(HBlockInformationVisitor visitor) => visitor.visitAndOrInfo(this);
 }