Fix null receiver guard an uncached site.

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 362 matching lines @@
         dartReceiver == null ? null : abstractType(dartReceiver);
     List<TypeMask> abstractArguments =
         invoke.arguments.map(abstractType).toList();
     var cachedResult = _inliner.cache.get(target, callStructure,
         abstractReceiver,
         abstractArguments);
 
     // Negative inlining result in the cache.
     if (cachedResult == InliningCache.NO_INLINE) return null;
 
-    // Positive inlining result in the cache.
-    if (cachedResult is FunctionDefinition) {
-      FunctionDefinition function = cachedResult;
+    Primitive finish(FunctionDefinition function) {
       _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 = 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);
     }
 
+    // Positive inlining result in the cache.
+    if (cachedResult is FunctionDefinition) {
+      return finish(cachedResult);
+    }
+
     // We have not seen this combination of target and abstract arguments
     // before.  Make an inlining decision.
     assert(cachedResult == InliningCache.ABSENT);
     Primitive doNotInline() {
       _inliner.cache.putNegative(target, callStructure, abstractReceiver,
           abstractArguments);
       return null;
     }
     if (backend.annotations.noInline(target)) return doNotInline();
     if (isRecursive(target, callStructure)) return doNotInline();
@@ skipping 23 matching lines @@
     // Inline calls in the body.
     _inliner.rewrite(function, callStructure);
 
     // Compute the size.
     // TODO(kmillikin): Tune the size bound.
     int size = SizeVisitor.sizeOf(invoke, function);
     if (!_inliner.isCalledOnce(target) && size > 11) return doNotInline();
 
     _inliner.cache.putPositive(target, callStructure, abstractReceiver,
         abstractArguments, function);
-    _fragment = new CpsFragment(invoke.sourceInformation);
-    Primitive receiver = invoke.receiver?.definition;
-    List<Primitive> arguments =
-        invoke.arguments.map((Reference ref) => ref.definition).toList();
-    if (dartReceiver != null && abstractReceiver.isNullable) {
-      Primitive check =
-          _fragment.letPrim(new NullCheck(dartReceiver.definition,
-              invoke.sourceInformation));
-      check.type = abstractReceiver.nonNullable();
-      if (invoke.callingConvention == CallingConvention.Intercepted) {
-        arguments[0] = check;
-      } else {
-        receiver = check;
-      }
-    }
-    return _fragment.inlineFunction(function, receiver, arguments,
-        hint: invoke.hint);
+    return finish(function);
   }
 
   Primitive nullReceiverGuard(InvocationPrimitive invoke,
                               CpsFragment fragment,
                               Primitive dartReceiver,
                               TypeMask abstractReceiver) {
     Selector selector = invoke is InvokeMethod ? invoke.selector : null;
     if (typeSystem.isDefinitelyNum(abstractReceiver, allowNull: true)) {
       Primitive condition = _fragment.letPrim(
           new ApplyBuiltinOperator(BuiltinOperator.IsNotNumber,
@@ skipping 45 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);
   }
 }