dart2js cps: Add instruction for null checks.

pkg/compiler/lib/src/cps_ir/type_propagation.dart

 // Copyright (c) 2014, 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.
 library dart2js.cps_ir.type_propagation;
 
 import 'optimizers.dart';
 
 import '../closure.dart' show
     ClosureClassElement;
 import '../common.dart';
@@ skipping 665 matching lines @@
   /// reachable method matching the selector may be targeted.
   AbstractConstantValue getInvokeReturnType(Selector selector, TypeMask mask) {
     return fromMask(typeSystem.getInvokeReturnType(selector, mask));
   }
 
   AbstractConstantValue fromMask(TypeMask mask) {
     ConstantValue constantValue = typeSystem.getConstantOf(mask);
     if (constantValue != null) return constant(constantValue, mask);
     return nonConstant(mask);
   }
+
+  AbstractConstantValue nonNullable(AbstractConstantValue value) {
+    if (value.isNullConstant) return nothing;
+    if (!value.isNullable) return value;
+    return nonConstant(value.type.nonNullable());
+  }
 }
 
 /**
  * Propagates types (including value types for constants) throughout the IR, and
  * replaces branches with fixed jumps as well as side-effect free expressions
  * with known constant results.
  *
  * Should be followed by the [ShrinkingReducer] pass.
  *
  * Implemented according to 'Constant Propagation with Conditional Branches'
@@ skipping 385 matching lines @@
     ///     if (typeof x !== 'number') return x.$lt();
     ///
     /// The [guard] must accept all possible non-null values for the receiver,
     /// but should be as specific as possible so the VM gets more information
     /// from the check.
     Primitive guardReceiver(CpsFragment cps, BuiltinOperator guard) {
       if (guard == null || getValue(node.dartReceiver).isDefinitelyNotNull) {
         return node.dartReceiver;
       }
       if (!trustPrimitives) {
+        // TODO(asgerf): Perhaps a separate optimization should decide that
+        // the guarded check is better based on the type?

[sra1, 2015/12/11 03:34:06]

We should also consider generating something like

   if (typeof x != "number") return J.$lt(x, arg)

when x is broader than [null|num] but only num has $lt.

[asgerf, 2015/12/11 10:15:40]

I see.  NullCheck would certainly not be an appropriate instruction for that. 
Maybe what we need is a variant of TypeCast that throws a NoSuchMethodError.

         Primitive check = cps.applyBuiltin(guard, [node.dartReceiver]);
-        cps.ifFalsy(check)
-           ..invokeMethod(node.dartReceiver, node.selector,
-             typeSystem.nullType, [])
-           ..put(new Unreachable());
+        return cps.letPrim(new NullCheck.guarded(check, node.dartReceiver,
+          node.selector, node.sourceInformation));
+      } else {
+        // Refine the receiver to be non-null for use in the operator.
+        // This restricts code motion and improves the type computed for the
+        // built-in operator that depends on it.
+        // This must be done even if trusting primitives.
+        return cps.letPrim(
+            new Refinement(node.dartReceiver, typeSystem.nonNullType));
       }
-      // Refine the receiver to be non-null for use in the operator.
-      // This restricts code motion and improves the type computed for the
-      // built-in operator that depends on it.
-      // This must be done even if trusting primitives.
-      Primitive refined = cps.letPrim(
-          new Refinement(node.dartReceiver, typeSystem.nonNullType));
-      return refined;
     }
 
     /// Replaces the call with [operator], using the receiver and first argument
     /// as operands (in that order).
     ///
     /// If [guard] is given, the receiver is checked using [guardReceiver],
     /// unless it is known kot to be null.
     CpsFragment makeBinary(BuiltinOperator operator, {BuiltinOperator guard}) {
       CpsFragment cps = new CpsFragment(node.sourceInformation);
       Primitive left = guardReceiver(cps, guard);
@@ skipping 43 matching lines @@
         }
         if (behavesLikeIdentical) {
           return makeBinary(BuiltinOperator.Identical);
         }
       } else {
         if (lattice.isDefinitelyNum(left, allowNull: true) &&
             lattice.isDefinitelyNum(right, allowNull: trustPrimitives)) {
           // Try to insert a numeric operator.
           BuiltinOperator operator = NumBinaryBuiltins[opname];
           if (operator != null) {
-            return makeBinary(operator, guard: BuiltinOperator.IsNumber);
+            return makeBinary(operator, guard: BuiltinOperator.IsNotNumber);
           }
           // Shift operators are not in [NumBinaryBuiltins] because Dart shifts
           // behave different to JS shifts, especially in the handling of the
           // shift count.
           // Try to insert a shift-left operator.
           if (opname == '<<' &&
               lattice.isDefinitelyInt(left, allowNull: true) &&
               lattice.isDefinitelyIntInRange(right, min: 0, max: 31)) {
             return makeBinary(BuiltinOperator.NumShl,
-                guard: BuiltinOperator.IsNumber);
+                guard: BuiltinOperator.IsNotNumber);
           }
           // Try to insert a shift-right operator. JavaScript's right shift is
           // consistent with Dart's only for left operands in the unsigned
           // 32-bit range.
           if (opname == '>>' &&
               lattice.isDefinitelyUint32(left, allowNull: true) &&
               lattice.isDefinitelyIntInRange(right, min: 0, max: 31)) {
             return makeBinary(BuiltinOperator.NumShr,
-                guard: BuiltinOperator.IsNumber);
+                guard: BuiltinOperator.IsNotNumber);
           }
           // Try to use remainder for '%'. Both operands must be non-negative
           // and the divisor must be non-zero.
           if (opname == '%' &&
               lattice.isDefinitelyUint(left, allowNull: true) &&
               lattice.isDefinitelyUint(right) &&
               lattice.isDefinitelyIntInRange(right, min: 1)) {
             return makeBinary(BuiltinOperator.NumRemainder,
-                guard: BuiltinOperator.IsNumber);
+                guard: BuiltinOperator.IsNotNumber);
           }
 
           if (opname == '~/' &&
               lattice.isDefinitelyUint32(left, allowNull: true) &&
               lattice.isDefinitelyIntInRange(right, min: 2)) {
             return makeBinary(BuiltinOperator.NumTruncatingDivideToSigned32,
-                guard: BuiltinOperator.IsNumber);
+                guard: BuiltinOperator.IsNotNumber);
           }
         }
         if (lattice.isDefinitelyString(left, allowNull: trustPrimitives) &&
             lattice.isDefinitelyString(right, allowNull: trustPrimitives) &&
             opname == '+') {
           // TODO(asgerf): Add IsString builtin so we can use a guard here.
           return makeBinary(BuiltinOperator.StringConcatenate);
         }
       }
     }
     if (node.selector.isOperator && node.arguments.length == 1) {
       Primitive argument = node.dartReceiver;
       AbstractConstantValue value = getValue(argument);
 
       if (lattice.isDefinitelyNum(value, allowNull: true)) {
         String opname = node.selector.name;
         if (opname == '~') {
           return makeUnary(BuiltinOperator.NumBitNot,
-              guard: BuiltinOperator.IsNumber);
+              guard: BuiltinOperator.IsNotNumber);
         }
         if (opname == 'unary-') {
           return makeUnary(BuiltinOperator.NumNegate,
-              guard: BuiltinOperator.IsNumber);
+              guard: BuiltinOperator.IsNotNumber);
         }
       }
     }
     if (node.selector.isCall) {
       String name = node.selector.name;
       Primitive receiver = node.dartReceiver;
       AbstractConstantValue receiverValue = getValue(receiver);
       if (name == 'remainder') {
         if (node.arguments.length == 2) {
           Primitive arg = node.dartArgument(0);
           AbstractConstantValue argValue = getValue(arg);
           if (lattice.isDefinitelyInt(receiverValue, allowNull: true) &&
               lattice.isDefinitelyInt(argValue) &&
               isIntNotZero(argValue)) {
             return makeBinary(BuiltinOperator.NumRemainder,
-                guard: BuiltinOperator.IsNumber);
+                guard: BuiltinOperator.IsNotNumber);
           }
         }
       } else if (name == 'codeUnitAt') {
         if (node.arguments.length == 2) {
           Primitive index = node.dartArgument(0);
           if (lattice.isDefinitelyString(receiverValue) &&
               lattice.isDefinitelyInt(getValue(index))) {
             SourceInformation sourceInfo = node.sourceInformation;
             CpsFragment cps = makeBoundsCheck(receiver, index, sourceInfo);
             ApplyBuiltinOperator get =
@@ skipping 63 matching lines @@
       Primitive isTooSmall = cps.applyBuiltin(
           BuiltinOperator.NumLt,
           <Primitive>[index, cps.makeZero()]);
       cps.ifTruthy(isTooSmall).invokeContinuation(fail);
     }
     Primitive isTooLarge = cps.applyBuiltin(
         BuiltinOperator.NumGe,
         <Primitive>[index, cps.letPrim(new GetLength(list))]);
     cps.ifTruthy(isTooLarge).invokeContinuation(fail);
     cps.insideContinuation(fail).invokeStaticThrower(
-        helpers.throwIndexOutOfBoundsError,
+        helpers.throwIndexOutOfRangeException,
         <Primitive>[list, index]);
     return cps;
   }
 
   /// Create a check that throws if the length of [list] is not equal to
   /// [originalLength].
   ///
   /// Returns a CPS fragment whose context is the branch where no error
   /// was thrown.
   CpsFragment makeConcurrentModificationCheck(Primitive list,
@@ skipping 94 matching lines @@
           return null;
         }
         if (!isExtendable) return null;
         CpsFragment cps = new CpsFragment(sourceInfo);
         Primitive length = cps.letPrim(new GetLength(list));
         Primitive isEmpty = cps.applyBuiltin(
             BuiltinOperator.StrictEq,
             [length, cps.makeZero()]);
         CpsFragment fail = cps.ifTruthy(isEmpty);
         fail.invokeStaticThrower(
-            helpers.throwIndexOutOfBoundsError,
+            helpers.throwIndexOutOfRangeException,
             [list, fail.makeConstant(new IntConstantValue(-1))]);
         Primitive removedItem = cps.invokeBuiltin(BuiltinMethod.Pop,
             list,
             <Primitive>[]);
         removedItem.hint = node.hint;
         node.replaceUsesWith(removedItem);
         return cps;
 
       case 'addAll':
         if (!node.selector.isCall ||
@@ skipping 939 matching lines @@
             functionCompiler.glue.getInterceptedClassesOn(invoke.selector);
         if (interceptedClasses.contains(helpers.jsDoubleClass)) return false;
         if (interceptedClasses.contains(helpers.jsIntClass)) return false;
         continue;
       }
       // Other uses need full distinction.
       return false;
     }
     return true;
   }
+
+  visitNullCheck(NullCheck node) {
+    if (!getValue(node.value.definition).isNullable) {
+      node.replaceUsesWith(node.value.definition);
+      return new CpsFragment();
+    }
+    return null;
+  }
 }
 
 /**
  * Runs an analysis pass on the given function definition in order to detect
  * const-ness as well as reachability, both of which are used in the subsequent
  * transformation pass.
  */
 class TypePropagationVisitor implements Visitor {
   // The node worklist stores nodes that are both reachable and need to be
   // processed, but have not been processed yet. Using a worklist avoids deep
@@ skipping 767 matching lines @@
     if (value.isNothing ||
         typeSystem.areDisjoint(value.type, node.refineType)) {
       setValue(node, nothing);
     } else if (value.isConstant) {
       setValue(node, value);
     } else {
       setValue(node,
           nonConstant(value.type.intersection(node.refineType, classWorld)));
     }
   }
+
+  @override
+  void visitNullCheck(NullCheck node) {
+    setValue(node, lattice.nonNullable(getValue(node.value.definition)));
+  }
 }
 
 /// Represents the abstract value of a primitive value at some point in the
 /// program. Abstract values of all kinds have a type [T].
 ///
 /// The different kinds of abstract values represents the knowledge about the
 /// constness of the value:
 ///   NOTHING:  cannot have any value
 ///   CONSTANT: is a constant. The value is stored in the [constant] field,
 ///             and the type of the constant is in the [type] field.
@@ skipping 92 matching lines @@
   processLetPrim(LetPrim node) {
     node.primitive.type = null;
     values[node.primitive] = null;
   }
 
   processLetMutable(LetMutable node) {
     node.variable.type = null;
     values[node.variable] = null;
   }
 }