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

lib/compiler/implementation/ssa/optimize.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 OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
@@ skipping 223 matching lines @@
     }
 
     if (left.isNonPrimitive() && node.operation.isUserDefinable()) {
       SourceString methodName = Elements.constructOperatorName(
           const SourceString('operator'), node.operation.name);
       return fromInterceptorToDynamicInvocation(node, methodName);
     }
     return node;
   }
 
+  HInstruction visitRelational(HRelational node) {
+    if (node.usedBy.length == 1 && node.usedBy[0] is HBoolify) {

[ngeoffray, 2012/04/25 11:48:08]

I'd check if all the users are HBoolify instead.

[floitsch, 2012/04/25 16:01:49]

Done.

+      Interceptors interceptors = compiler.builder.interceptors;
+      HStatic oldTarget = node.target;
+      Element boolifiedInterceptor =
+          interceptors.getBoolifiedVersionOfInterceptor(oldTarget.element);
+      if (boolifiedInterceptor !== null) {
+        HStatic boolifiedTarget = new HStatic(boolifiedInterceptor);
+        // We don't remove the [oldTarget] in case it is used by other
+        // instructions. If it is unused it will be treated as dead code and
+        // discarded.
+        oldTarget.block.addAfter(oldTarget, boolifiedTarget);
+        // Remove us from the usedBy list of the old target.

[ngeoffray, 2012/04/25 11:48:08]

Please move that code into the HInstruction class.

[floitsch, 2012/04/25 16:01:49]

Moved into HBasicBlock class.

+        if (oldTarget.usedBy.length == 1) {
+          oldTarget.usedBy.clear();
+        } else {
+          List<HInstruction> users = oldTarget.usedBy;
+          int length = users.length;
+          for (int i = 0; i < length; i++) {
+            if (users[i] === node) {
+              users[i] = users[length - 1];
+              users.length = length - 1;
+            }
+          }
+        }
+        // Replace old target with boolified target.
+        assert(node.target == node.inputs[0]);
+        node.inputs[0] = boolifiedTarget;
+        boolifiedTarget.usedBy.add(node);
+        node.usesBoolifiedInterceptor = true;
+        node.propagatedType = HType.BOOLEAN;
+      }
+    }
+    // This node stays the same, but the Boolify node will go away.

[ngeoffray, 2012/04/25 11:48:08]

Move that comment one line up (in the if clause).

[floitsch, 2012/04/25 16:01:49]

Done.

+    // Note that we still have to call [super] to make sure that we end up
+    // in the remaining optimizations.
+    return super.visitRelational(node);
+  }
+
   HInstruction visitEquals(HEquals node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
 
     if (left.isConstant() && right.isConstant()) {
       return visitInvokeBinary(node);

[ngeoffray, 2012/04/25 11:48:08]

Should that be changed to super.visitEquals(node) ?

[floitsch, 2012/04/25 16:01:49]

Done.

     }
 
     if (left.isNonPrimitive()) {
       HNonPrimitiveType type = left.propagatedType;
       Element element = type.lookupMember(Namer.OPERATOR_EQUALS);
       if (element !== null) {
         // If the left-hand side is guaranteed to be a non-primitive
         // type and and it defines operator==, we emit a call to that
         // operator.
         return visitInvokeBinary(node);
@@ skipping 16 matching lines @@
         return graph.addConstantBool(false);
       } else {
         // TODO(floitsch): cache interceptors.
         HStatic target = new HStatic(
             compiler.builder.interceptors.getEqualsNullInterceptor());
         node.block.addBefore(node, target);
         return new HEquals(target, node.left, node.right);
       }
     }
 
-    // All other cases are dealt with by the [visitInvokeBinary].
-    return visitInvokeBinary(node);
+    // All other cases are dealt with by the [visitRelational] and
+    // [visitInvokeBinary], which are visited by invoking the [super]'s
+    // visit method.
+    return super.visitEquals(node);
   }
 
   HInstruction visitTypeGuard(HTypeGuard node) {
     HInstruction value = node.guarded;
     HType combinedType = value.propagatedType.combine(node.guardedType);
     return (combinedType == value.propagatedType) ? value : node;
   }
 
   HInstruction visitIntegerCheck(HIntegerCheck node) {
     HInstruction value = node.value;
@@ skipping 518 matching lines @@
         }
       }
       if (!canBeMoved) continue;
 
       // This is safe because we are running after GVN.
       // TODO(ngeoffray): ensure GVN has been run.
       set_.add(current);
     }
   }
 }