anchor.diff:        Primitive argument = node.dartReceiver;
         AbstractValue value = getValue(argument);
   
  -      if (lattice.isDefinitelyNum(value, allowNull: false)) {
  +      if (lattice.isDefinitelyNum(value, allowNull: true)) {
           String opname = node.selector.name;
           if (opname == '~') {
  -          return replaceWithUnary(BuiltinOperator.NumBitNot, argument);
  +          return makeUnary(BuiltinOperator.NumBitNot,
  +              guard: BuiltinOperator.IsNumber);
           }
           if (opname == 'unary-') {
  -          return replaceWithUnary(BuiltinOperator.NumNegate, argument);
  +          return makeUnary(BuiltinOperator.NumNegate,
  +              guard: BuiltinOperator.IsNumber);
           }
         }
       }
  
positive.code:           }
          }
          if (behavesLikeIdentical) {
            return replaceWithBinary(BuiltinOperator.Identical,
                leftArg, rightArg);
          }
        } else {
          if (lattice.isDefinitelyNum(left, allowNull: trustPrimitives) &&
              lattice.isDefinitelyNum(right, allowNull: trustPrimitives)) {
            // Try to insert a numeric operator.
            BuiltinOperator operator = NumBinaryBuiltins[opname];
            if (operator != null) {
              return replaceWithBinary(operator, leftArg, rightArg);
            }
            // 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: trustPrimitives) &&
                lattice.isDefinitelyIntInRange(right, min: 0, max: 31)) {
              return replaceWithBinary(BuiltinOperator.NumShl, leftArg, rightArg);
            }
            // 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: trustPrimitives) &&
                lattice.isDefinitelyIntInRange(right, min: 0, max: 31)) {
              return replaceWithBinary(BuiltinOperator.NumShr, leftArg, rightArg);
            }
            // Try to use remainder for '%'. Both operands must be non-negative
            // and the divisor must be non-zero.
            if (opname == '%' &&
                lattice.isDefinitelyUint(left, allowNull: trustPrimitives) &&
                lattice.isDefinitelyUint(right) &&
                lattice.isDefinitelyIntInRange(right, min: 1)) {
              return replaceWithBinary(
                  BuiltinOperator.NumRemainder, leftArg, rightArg);
            }
  
            if (opname == '~/' &&
                lattice.isDefinitelyUint32(left, allowNull: trustPrimitives) &&
                lattice.isDefinitelyIntInRange(right, min: 2)) {
              return replaceWithBinary(
                  BuiltinOperator.NumTruncatingDivideToSigned32,
                  leftArg, rightArg);
            }
          }
          if (lattice.isDefinitelyString(left, allowNull: trustPrimitives) &&
              lattice.isDefinitelyString(right, allowNull: trustPrimitives) &&
              opname == '+') {
            return replaceWithBinary(BuiltinOperator.StringConcatenate,
                                     leftArg, rightArg);
          }
        }
      }
  
negative.code:         // fact that Dart-null corresponds to both JS-null and JS-undefined.
          // Please see documentation for IsFalsy, StrictEq, and LooseEq.
          if (left.isNullConstant || right.isNullConstant) {
            return makeBinary(BuiltinOperator.Identical);
          }
          // There are several implementations of == that behave like identical.
          // Specialize it if we definitely call one of those.
  