Use type mask to figure out if we can constant fold boolify operations.

sdk/lib/_internal/compiler/implementation/ssa/optimize.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 165 matching lines @@
   HInstruction visitInstruction(HInstruction node) {
     return node;
   }
 
   HInstruction visitBoolify(HBoolify node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     HType type = input.instructionType;
     if (type.isBoolean()) return input;
-    // All values !== true are boolified to false.
-    if (!type.isBooleanOrNull() && !type.isUnknown()) {
+    // All values that cannot be 'true' are boolified to false.
+    DartType booleanType = backend.jsBoolClass.computeType(compiler);

[karlklose, 2013/03/05 09:29:21]

You could use '.rawType' here.

Long term I think we want to get away from using computeType, because it has led
to confusion about what the returned type means.  For interface types we have
raw type (which is what most of the backend wants to use) and thisType (which
contains the type variables and is most used in resolver and type-checker).

+    TypeMask mask = type.computeMask(compiler);
+    // TODO(kasperl): Get rid of the null check here once all HTypes
+    // have a proper mask.
+    if (mask != null && !mask.contains(booleanType, compiler)) {
       return graph.addConstantBool(false, constantSystem);
     }
     return node;
   }
 
   HInstruction visitNot(HNot node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input is HConstant) {
@@ skipping 1341 matching lines @@
     HBasicBlock block = user.block;
     block.addAfter(user, interceptor);
     block.rewrite(user, interceptor);
     block.remove(user);
 
     // The interceptor will be removed in the dead code elimination
     // phase. Note that removing it here would not work because of how
     // the [visitBasicBlock] is implemented.
   }
 }