Optimize boolean asserts

frog/gen.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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 990 matching lines @@
     world.gen.genMethod(meth, this);
     return meth;
   }
 
   visitBool(Expression node) {
     // Boolean conversions in if/while/do/for/conditions require non-null bool.
 
     // TODO(jmesserly): why do we have this rule? It seems inconsistent with
     // the rest of the type system, and just causes bogus asserts unless all
     // bools are initialized to false.
-    return visitValue(node).convertToNonNullBool(this, node);
+    return visitValue(node).convertTo(this, world.nonNullBool, node);
   }
 
   visitValue(Expression node) {
     if (node == null) return null;
 
     var value = node.visit(this);
     value.checkFirstClass(node.span);
     return value;
   }
 
@@ skipping 568 matching lines @@
     if (kind == TokenKind.AND || kind == TokenKind.OR) {
       var x = visitValue(node.x);
       var y = visitValue(node.y);
       final code = '${x.code} ${node.op} ${y.code}';
       if (x.isConst && y.isConst) {
         var value = (kind == TokenKind.AND)
             ? x.actualValue && y.actualValue : x.actualValue || y.actualValue;
         return new EvaluatedValue(x.type, value, '$value', node.span);
       }
       var ret = new Value(Type.union(x.type, y.type), code, node.span);
-      return ret.convertToNonNullBool(this, node);
+      return ret.convertTo(this, world.nonNullBool, node);
     } else if (kind == TokenKind.EQ_STRICT || kind == TokenKind.NE_STRICT) {
       var x = visitValue(node.x);
       var y = visitValue(node.y);
       if (x.isConst && y.isConst) {
         var value = kind == TokenKind.EQ_STRICT
             // Note: it is ok to use == and not === here since all of these
             // constant comparisons are applied to doubles, bool, or strings.
             // We need it for the compile-time evaluator because
             // (9).toDouble() === 9.0 is false in dartvm.
             ? x.actualValue == y.actualValue : x.actualValue != y.actualValue;
-        return new EvaluatedValue(world.boolType, value, "$value", node.span);
+        return new EvaluatedValue(world.nonNullBool, value, "$value",
+            node.span);
       }
       if (x.code == 'null' || y.code == 'null') {
         // Switching to == ensures that null and undefined are interchangable.
         final op = node.op.toString().substring(0,2);
-        return new Value(world.boolType, '${x.code} $op ${y.code}', node.span);
+        return new Value(world.nonNullBool, '${x.code} $op ${y.code}',
+            node.span);
       } else {
         // TODO(jimhug): Resolve issue with undefined and null here.
-        return new Value(world.boolType, '${x.code} ${node.op} ${y.code}',
+        return new Value(world.nonNullBool, '${x.code} ${node.op} ${y.code}',
           node.span);
       }
     }
 
     final assignKind = TokenKind.kindFromAssign(node.op.kind);
     if (assignKind == -1) {
       final x = visitValue(node.x);
       final y = visitValue(node.y);
       var name = TokenKind.binaryMethodName(node.op.kind);
       if (node.op.kind == TokenKind.NE) {
@@ skipping 171 matching lines @@
             new TypeReference(node.span, world.numType), '1', node.span);
 
           return _visitAssign(kind, node.self, operand, node, null);
         }
       case TokenKind.NOT:
         // TODO(jimhug): Issue #359 seeks to clarify this behavior.
         if (value.type.isBool && value.isConst) {
           var newVal = !value.actualValue;
           return new EvaluatedValue(value.type, newVal, '${newVal}', node.span);
         } else {
-          var newVal = value.convertToNonNullBool(this, node);
-          return new Value(world.boolType, '!${newVal.code}', node.span);
+          var newVal = value.convertTo(this, world.nonNullBool, node);
+          return new Value(newVal.type, '!${newVal.code}', node.span);
         }
 
       case TokenKind.ADD:
         // TODO(jimhug): Issue #359 seeks to clarify this behavior.
         return value.convertTo(this, world.numType, node);
 
       case TokenKind.SUB:
       case TokenKind.BIT_NOT:
         if (node.op.kind == TokenKind.BIT_NOT) {
           return value.invoke(this, '\$bit_not', node, Arguments.EMPTY);
@@ skipping 403 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }