Specializations of instance methods have non-null receiver.

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 353 matching lines @@
     // V8 does not optimize functions containing a try statement.  Inlining
     // code containing a try statement will make the optimizable calling code
     // become unoptimizable.
     if (target.resolvedAst.elements.containsTryStatement) {
       return null;
     }
 
     Reference<Primitive> dartReceiver = invoke.dartReceiverReference;
     TypeMask abstractReceiver =
         dartReceiver == null ? null : abstractType(dartReceiver);
+    // The receiver is non-null in a method body, unless the receiver is known
+    // to be `null` (isEmpty covers `null` and unreachable).
+    TypeMask abstractReceiverInMethod = abstractReceiver == null
+        ? null
+        : abstractReceiver.isEmpty
+            ? abstractReceiver
+            : abstractReceiver.nonNullable();
     List<TypeMask> abstractArguments =
         invoke.arguments.map(abstractType).toList();
     var cachedResult = _inliner.cache.get(target, callStructure,
-        abstractReceiver,
+        abstractReceiverInMethod,
         abstractArguments);
 
     // Negative inlining result in the cache.
     if (cachedResult == InliningCache.NO_INLINE) return null;
 
     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();
@@ skipping 14 matching lines @@
 
     // 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);
+      _inliner.cache.putNegative(
+          target, callStructure, abstractReceiverInMethod, abstractArguments);
       return null;
     }
     if (backend.annotations.noInline(target)) return doNotInline();
     if (isRecursive(target, callStructure)) return doNotInline();
 
     FunctionDefinition function;
     if (callStructure != null &&
         target.functionSignature.parameterCount !=
             callStructure.argumentCount) {
       // The argument count at the call site does not match the target's
       // formal parameter count.  Build the IR term for an adapter function
       // body.
       function = buildAdapter(invoke, target);
     } else {
       function = _inliner.functionCompiler.compileToCpsIr(target);
       void setValue(Variable variable, Reference<Primitive> value) {
         variable.type = value.definition.type;
       }
-      if (invoke.receiver != null) {
+      if (invoke.callingConvention == CallingConvention.Intercepted) {
         setValue(function.thisParameter, invoke.receiver);
-      }
-      for (int i = 0; i < invoke.arguments.length; ++i) {
-        setValue(function.parameters[i], invoke.arguments[i]);
+        function.parameters[0].type = abstractReceiverInMethod;
+        for (int i = 1; i < invoke.arguments.length; ++i) {
+          setValue(function.parameters[i], invoke.arguments[i]);
+        }
+      } else {
+        if (invoke.receiver != null) {
+          function.thisParameter.type = abstractReceiverInMethod;
+        }
+        for (int i = 0; i < invoke.arguments.length; ++i) {
+          setValue(function.parameters[i], invoke.arguments[i]);
+        }
       }
       optimizeBeforeInlining(function);
     }
 
     // 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,
+    _inliner.cache.putPositive(target, callStructure, abstractReceiverInMethod,
         abstractArguments, function);
     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)) {
@@ skipping 47 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);
   }
 }