Optimize boolean asserts

frog/member.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.
 
 /** A formal parameter to a [Method]. */
 class Parameter {
   FormalNode definition;
 
   String name;
   Type type;
@@ skipping 121 matching lines @@
   void providePropertySyntax() =>
       world.internalError('can not be property', span);
 
   Definition get initDelegate() {
     world.internalError('cannot have initializers', span);
   }
   Definition set initDelegate(ctor) {
     world.internalError('cannot have initializers', span);
   }
 
+  /**
+   * The inferred returnType. Right now this is just used to track
+   * non-nullable bools.
+   */
+  Type get inferredResult() {
+    var t = returnType;
+    if (t.isBool && (library.isCore || library.isCoreImpl)) {
+      // We trust our core libraries not to return null from bools.
+      // I hope this trust is well placed!
+      return world.nonNullBool;
+    }
+    return t;
+  }
+
   Definition get definition() => null;
 
   List<Parameter> get parameters() => [];
 
   // TODO(jmesserly): isDynamic isn't a great name for this, something better?
   abstract Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic]);
 
   abstract Value _set(MethodGenerator context, Node node, Value target,
       Value value, [bool isDynamic]);
@@ skipping 414 matching lines @@
     var type = baseMember.resolveType(node, isRequired);
     return type.resolveTypeParams(declaringType);
   }
 
   // TODO(jimhug): Add support for type params.
   bool override(Member other) => baseMember.override(other);
 
   Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
     Value ret = baseMember._get(context, node, target, isDynamic);
-    return new Value(returnType, ret.code, node.span);
+    return new Value(inferredResult, ret.code, node.span);
   }
 
   Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
     // TODO(jimhug): Check arg types in context of concrete type.
     Value ret = baseMember._set(context, node, target, value, isDynamic);
     return new Value(returnType, ret.code, node.span);
   }
 
   Value invoke(MethodGenerator context, Node node, Value target, Arguments args,
       [bool isDynamic=false]) {
     // TODO(jimhug): Check arg types in context of concrete type.
     Value ret = baseMember.invoke(context, node, target, args, isDynamic);
     var code = ret.code;
     if (isConstructor) {
       // TODO(jimhug): Egregious hack - won't live through the weekend.
       code = code.replaceFirst(
           declaringType.genericType.jsname, declaringType.jsname);
     }
     declaringType.genMethod(this);
-    return new Value(returnType, code, node.span);
+    return new Value(inferredResult, code, node.span);
   }
 }
 
 
 /** Represents a Dart method or top-level function. */
 class MethodMember extends Member {
   FunctionDefinition definition;
   Type returnType;
   List<Parameter> parameters;
 
@@ skipping 291 matching lines @@
     }
 
     var argsString = Strings.join(argsCode, ', ');
 
     if (isConstructor) {
       return _invokeConstructor(context, node, target, args, argsString);
     }
 
     // TODO(jimhug): target really shouldn't ever be null...
     if (target != null && target.isSuper) {
-      return new Value(returnType,
+      return new Value(inferredResult,
           '${declaringType.jsname}.prototype.$jsname.call($argsString)',
           node.span);
     }
 
     if (name.startsWith('\$')) {
-      return _invokeBuiltin(context, node, target, args, argsCode);
+      return _invokeBuiltin(context, node, target, args, argsCode, isDynamic);
     }
 
     if (isFactory) {
-      return new Value(returnType, '$generatedFactoryName($argsString)',
+      return new Value(inferredResult, '$generatedFactoryName($argsString)',
         node.span);
     }
 
     if (isStatic) {
       if (declaringType.isTop) {
         // TODO(jimhug): Explore moving libraries into their own namespaces
-        return new Value(returnType, '$jsname($argsString)', node != null ? node.span : node);
+        return new Value(inferredResult, '$jsname($argsString)', node != null ? node.span : node);
       }
-      return new Value(returnType,
+      return new Value(inferredResult,
         '${declaringType.jsname}.$jsname($argsString)', node.span);
     }
 
     var code = '${target.code}.$jsname($argsString)';
     // optimize expressions which we know statically their value.
     if (target.isConst) {
       if (target is GlobalValue) {
         target = target.dynamic.exp; // TODO: an inline "cast" would be nice.
       }
       if (name == 'get\$length') {
         if (target is ConstListValue || target is ConstMapValue) {
           code = '${target.dynamic.values.length}';
         }
       } else if (name == 'isEmpty') {
         if (target is ConstListValue || target is ConstMapValue) {
           code = '${target.dynamic.values.isEmpty()}';
         }
       }
     }
 
     // TODO(jmesserly): factor this better
     if (name == 'get\$typeName' && declaringType.library == world.dom) {
       world.gen.corejs.useTypeNameOf = true;
     }
 
-    return new Value(returnType, code, node.span);
+    return new Value(inferredResult, code, node.span);
   }
 
   Value _invokeConstructor(MethodGenerator context, Node node,
       Value target, Arguments args, argsString) {
     declaringType.markUsed();
 
     if (target != null) {
       // initializer call to another constructor
       var code = (constructorName != '')
           ? '${declaringType.jsname}.${constructorName}\$ctor.call($argsString)'
@@ skipping 110 matching lines @@
       }
     }
 
     return world.gen.globalForConst(
         new ConstObjectValue(declaringType, fields, code, node.span),
         args.values);
   }
 
 
   Value _invokeBuiltin(MethodGenerator context, Node node, Value target,
-      Arguments args, argsCode) {
+      Arguments args, argsCode, bool isDynamic) {
     var allConst = target.isConst && args.values.every((arg) => arg.isConst);
+
     // Handle some fast paths for Number, String, List and DOM.
     if (declaringType.isNum) {
       // TODO(jimhug): This fails in bad ways when argsCode[1] is not num.
       // TODO(jimhug): What about null?
       if (!allConst) {
         var code;
         if (name == '\$negate') {
           code = '-${target.code}';
         } else if (name == '\$bit_not') {
           code = '~${target.code}';
         } else if (name == '\$truncdiv' || name == '\$mod') {
           world.gen.corejs.useOperator(name);
           code = '$name(${target.code}, ${argsCode[0]})';
         } else {
           var op = TokenKind.rawOperatorFromMethod(name);
           code = '${target.code} $op ${argsCode[0]}';
         }
 
-        return new Value(returnType, code, node.span);
+        return new Value(inferredResult, code, node.span);
       } else {
         var value;
         num val0, val1, ival0, ival1;
         val0 = target.dynamic.actualValue;
         ival0 = val0.toInt();
         if (args.values.length > 0) {
           val1 = args.values[0].dynamic.actualValue;
           ival1 = val1.toInt();
         }
         switch (name) {
@@ skipping 13 matching lines @@
 
           // Note: unfortunatelly bit operations fail on doubles in dartvm
           case '\$bit_not': value = (~ival0).toDouble(); break;
           case '\$bit_or': value = (ival0 | ival1).toDouble(); break;
           case '\$bit_xor': value = (ival0 ^ ival1).toDouble(); break;
           case '\$bit_and': value = (ival0 & ival1).toDouble(); break;
           case '\$shl': value = (ival0 << ival1).toDouble(); break;
           case '\$sar': value = (ival0 >> ival1).toDouble(); break;
           case '\$shr': value = (ival0 >>> ival1).toDouble(); break;
         }
-        return new EvaluatedValue(returnType, value, "$value", node.span);
+        return new EvaluatedValue(inferredResult, value, "$value", node.span);
       }
     } else if (declaringType.isString) {
       if (name == '\$index') {
         // Note: this could technically propagate constness, but that's not
         // specified explicitly and the VM doesn't do that.
         return new Value(declaringType, '${target.code}[${argsCode[0]}]',
           node.span);
       } else if (name == '\$add') {
         if (allConst) {
           var val0 = target.dynamic.actualValue;
@@ skipping 19 matching lines @@
         return new Value(returnType, '${target.code}[${argsCode[0]}]', node.span);
       } else if (name == '\$setindex') {
         return new Value(returnType,
           '${target.code}[${argsCode[0]}] = ${argsCode[1]}', node.span);
       }
     }
 
     // TODO(jimhug): Optimize null on lhs as well.
     if (name == '\$eq' || name == '\$ne') {
       final op = name == '\$eq' ? '==' : '!=';
+
+      if (name == '\$ne') {
+        // Ensure == is generated.
+        target.invoke(context, '\$eq', node, args, isDynamic);
+      }
+
       if (allConst) {
         var val0 = target.dynamic.actualValue;
         var val1 = args.values[0].dynamic.actualValue;
         var newVal = name == '\$eq' ? val0 == val1 : val0 != val1;
-        return new EvaluatedValue(world.boolType,
+        return new EvaluatedValue(world.nonNullBool,
             newVal, "$newVal", node.span);
       }
       // Optimize test when null is on the rhs.
       if (argsCode[0] == 'null') {
-        return new Value(returnType, '${target.code} $op null', node.span);
+        return new Value(inferredResult, '${target.code} $op null', node.span);
       } else if (target.type.isNum || target.type.isString) {
         // TODO(jimhug): Maybe check rhs.
-        return new Value(returnType, '${target.code} $op ${argsCode[0]}',
+        return new Value(inferredResult, '${target.code} $op ${argsCode[0]}',
           node.span);
       }
       world.gen.corejs.useOperator(name);
-      return new Value(returnType, '$name(${target.code}, ${argsCode[0]})',
+      return new Value(inferredResult, '$name(${target.code}, ${argsCode[0]})',
         node.span);
     }
 
     if (name == '\$call') {
       declaringType.markUsed();
-      return new Value(returnType,
+      return new Value(inferredResult,
         '${target.code}(${Strings.join(argsCode, ", ")})', node.span);
     }
 
     if (name == '\$index') {
       world.gen.corejs.useIndex = true;
     } else if (name == '\$setindex') {
       world.gen.corejs.useSetIndex = true;
     }
 
     // Fall back to normal method invocation.
     var argsString = Strings.join(argsCode, ', ');
-    return new Value(returnType, '${target.code}.$jsname($argsString)',
+    return new Value(inferredResult, '${target.code}.$jsname($argsString)',
       node.span);
   }
 
 
   resolve(Type inType) {
     // TODO(jimhug): cut-and-paste-and-edit from Field.resolve
     isStatic = inType.isTop;
     isConst = false;
     isFactory = false;
     isAbstract = !declaringType.isClass;
@@ skipping 354 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }