Optimize boolean asserts

frog/value.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.
 
 /**
  * Represents a meta-value for code generation.
  */
 class Value {
   /** The [Type] of the [Value]. */
   Type type;
@@ skipping 49 matching lines @@
       return member._set(context, node, this, value, isDynamic);
     } else {
       return invokeNoSuchMethod(context, 'set:$name', node,
           new Arguments(null, [value]));
     }
   }
 
 
   Value invoke(MethodGenerator context, String name, Node node, Arguments args,
       [bool isDynamic=false]) {
-    // TODO(jimhug): The != method is weird - understand it better.
+    // TODO(jmesserly): try to get rid of this code path. We're generating a
+    // synthetic != on Object (see DefinedType._createNotEqualMember) already.
+    // So it should be pretty easy to make this go away.

[jimhug, 2011/11/12 00:26:36]

+1

     if (_typeIsVarOrParameterType && name == '\$ne') {
       if (args.values.length != 1) {
         world.warning('wrong number of arguments for !=', node.span);
       }
+      // Ensure the == operator is generated, and get its type
+      var eq = invoke(context, '\$eq', node, args, isDynamic);
       world.gen.corejs.useOperator('\$ne');
-      return new Value(world.varType, '\$ne($code, ${args.values[0].code})',
-        node.span);
+      return new Value(eq.type, '\$ne($code, ${args.values[0].code})',
+          node.span);
     }
 
     // TODO(jmesserly): it'd be nice to remove these special cases
     // We could create a $call (and $ne) in world members, and have
     // those guys handle the canInvoke/Invoke logic.
 
     // Note: this check is a little different than the one in canInvoke, because
     // sometimes we need to call dynamically even if we found the $call method
     // statically.
 
@@ skipping 171 matching lines @@
     }
 
     // TODO(jmesserly): remove the special case for "num" when our num handling
     // is better.
     bool bothNum = type.isNum && toType.isNum;
     if (!checked || fromType.isSubtypeOf(toType) || bothNum) {
       // No checks needed for a widening conversion.
       return this;
     }
 
-    if (!toType.isSubtypeOf(type)) {
+    if (checked && !toType.isSubtypeOf(type)) {
       // According to the static types, this conversion can't work.
       convertWarning(toType, node);
     }
 
     // Generate a runtime checks if they're turned on, otherwise skip it.
     if (options.enableTypeChecks) {
       return _typeAssert(context, toType, node);
     } else {
       return this;
     }
   }
 
-  // TODO(jmesserly): this generates an unnecessary check for the 90%
-  // case where the thing passed in was a non-overloaded == or != expression
-  // We'll want to eliminate these, probably by tracking non-null bools in the
-  // type system.
-  // This matches the interesting Boolean Conversion section of the spec.
-  Value convertToNonNullBool(MethodGenerator context, Node node) {
-    if (!type.isAssignable(world.boolType)) {
-      convertWarning(world.boolType, node);
-    }
-    if (!options.enableTypeChecks) {
-      // TODO(jimhug): If type != world.boolType, this should return
-      //  this.code === true according to the spec.
-      return this;
-    } else {
-      // TODO(jmesserly): this is hacky.
-      if (code.startsWith('\$notnull_bool')) {
-        return this;
-      } else {
-        world.gen.corejs.useNotNullBool = true;
-        return new Value(world.boolType, '\$notnull_bool($code)', span);
-      }
-    }
-  }
-
   bool _isDomCallback(toType) {
     return (toType.definition is FunctionTypeDefinition
         && toType.library == world.dom);
   }
 
   Value _wrapDomCallback(Type toType, int arity) {
     return new Value(toType, '\$wrap_call\$$arity($code)', span);
   }
 
   /**
@@ skipping 22 matching lines @@
     // TypeError. Alternatively we could define fallbacks on Object that throw.
     String check;
     if (toType.isVoid) {
       check = '\$assert_void($code)';
       if (toType.typeCheckCode == null) {
         toType.typeCheckCode = '''
 function \$assert_void(x) {
   return x == null ? x : x.is\$void(); // throws TypeError
 }''';
       }
+    } else if (toType == world.nonNullBool) {
+      // This could be made less of a special case
+      world.gen.corejs.useNotNullBool = true;
+      check = '\$notnull_bool($code)';
+
     } else if (toType.library.isCore && toType.typeofName != null) {
       check = '\$assert_${toType.name}($code)';
 
       if (toType.typeCheckCode == null) {
         toType.typeCheckCode = '''
 function \$assert_${toType.name}(x) {
   if (x == null || typeof(x) == "${toType.typeofName}") return x;
   throw new TypeError("'" + x + "' is not a ${toType.name}.");
 }''';
       }
@@ skipping 17 matching lines @@
    * - If it's a non-generic class, use instanceof.
    * - Otherwise add a fake member to test for.  This value is generated
    *   as a function so that it can be called for a runtime failure.
    */
   Value instanceOf(MethodGenerator context, Type toType, SourceSpan span,
       [bool isTrue=true, bool forceCheck=false]) {
     // TODO(jimhug): Optimize away tests that will always pass unless
     //    forceCheck is true.
     if (toType.isVar) {
       world.error('can not resolve type', span);
-      return new EvaluatedValue(world.boolType, true, 'true', null);
+      return new EvaluatedValue(world.nonNullBool, true, 'true', null);
     }
 
     if (toType is ParameterType) {
-      return new EvaluatedValue(world.boolType, true, 'true', null);
+      return new EvaluatedValue(world.nonNullBool, true, 'true', null);
     }
 
     String testCode = null;
     if (toType.library.isCore) {
       var typeofName = toType.typeofName;
       if (typeofName != null) {
         testCode = "(typeof($code) ${isTrue ? '==' : '!='} '$typeofName')";
       }
     }
     if (toType.isClass && toType is !ConcreteType) {
@@ skipping 15 matching lines @@
         // Add !! to convert to boolean.
         // TODO(jimhug): only do this if needed
         testCode = '!!' + testCode;
       } else {
         // The single ! here nicely converts undefined to false and function
         // to true.
         testCode = '!' + testCode;
       }
       if (this != temp) context.freeTemp(temp);
     }
-    return new Value(world.boolType, testCode, span);
+    return new Value(world.nonNullBool, testCode, span);
   }
 
   void convertWarning(Type toType, Node node) {
     // TODO(jmesserly): better error messages for type conversion failures
     world.warning('type "${type.name}" is not assignable to "${toType.name}"',
         node.span);
   }
 
   Value invokeNoSuchMethod(MethodGenerator context, String name, Node node,
       [Arguments args]) {
@@ skipping 247 matching lines @@
 
     // Then look for members in my library.
     member = home.library.lookup(name, span);
     if (member != null) {
       return member;
     }
 
     return null;
   }
 }