Better NullCheck for null-or-number

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

 // Copyright (c) 2015, 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 cps_ir.optimization.inline;
 
 import 'cps_fragment.dart';
 import 'cps_ir_builder.dart' show ThisParameterLocal;
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
@@ skipping 361 matching lines @@
     // Positive inlining result in the cache.
     if (cachedResult is FunctionDefinition) {
       FunctionDefinition function = cachedResult;
       _fragment = new CpsFragment(invoke.sourceInformation);
       Primitive receiver = invoke.receiver?.definition;
       List<Primitive> arguments =
           invoke.arguments.map((Reference ref) => ref.definition).toList();
       // Add a null check to the inlined function body if necessary.  The
       // cached function body does not contain the null check.
       if (dartReceiver != null && abstractReceiver.isNullable) {
-        Primitive check =
-            _fragment.letPrim(new NullCheck(dartReceiver.definition,
-                invoke.sourceInformation));
-        check.type = abstractReceiver.nonNullable();
+        Primitive check = nullReceiverGuard(
+            invoke, _fragment, dartReceiver.definition, abstractReceiver);
         if (invoke.callingConvention == CallingConvention.Intercepted) {
           arguments[0] = check;
         } else {
           receiver = check;
         }
       }
       return _fragment.inlineFunction(function, receiver, arguments,
           hint: invoke.hint);
     }
 
@@ skipping 52 matching lines @@
       if (invoke.callingConvention == CallingConvention.Intercepted) {
         arguments[0] = check;
       } else {
         receiver = check;
       }
     }
     return _fragment.inlineFunction(function, receiver, arguments,
         hint: invoke.hint);
   }
 
+  Primitive nullReceiverGuard(InvocationPrimitive invoke,
+                              CpsFragment fragment,
+                              Primitive dartReceiver,
+                              TypeMask abstractReceiver) {
+    Selector selector = invoke is InvokeMethod ? invoke.selector : null;

[Harry Terkelsen, 2015/12/28 19:30:41]

maybe move inside the "if" since that is the only place selector is used?

+    if (typeSystem.isDefinitelyNum(abstractReceiver, allowNull: true)) {
+      Primitive condition = _fragment.letPrim(
+          new ApplyBuiltinOperator(BuiltinOperator.IsNotNumber,
+                                   <Primitive>[dartReceiver],
+                                   invoke.sourceInformation));
+      condition.type = typeSystem.boolType;
+      Primitive check = _fragment.letPrim(
+          new NullCheck.guarded(
+              condition, dartReceiver, selector, invoke.sourceInformation));
+      check.type = abstractReceiver.nonNullable();
+      return check;
+    }
+
+    Primitive check = _fragment.letPrim(
+        new NullCheck(dartReceiver, invoke.sourceInformation));
+    check.type = abstractReceiver.nonNullable();
+    return check;
+  }
+
+
   @override
   Primitive visitInvokeStatic(InvokeStatic node) {
     return tryInlining(node, node.target, null);
   }
 
   @override
   Primitive visitInvokeMethod(InvokeMethod node) {
     Primitive receiver = node.dartReceiver;
     Element element = world.locateSingleElement(node.selector, receiver.type);
     if (element == null || element is! FunctionElement) return null;
@@ skipping 18 matching lines @@
       // We cannot inline a constructor invocation containing type arguments
       // because CreateInstance in the body does not know the type arguments.
       // We would incorrectly instantiate a class like A instead of A<B>.
       // TODO(kmillikin): try to fix this.
       GenericType generic = node.dartType;
       if (generic.typeArguments.any((DartType t) => !t.isDynamic)) return null;
     }
     return tryInlining(node, node.target, null);
   }
 }