dart2js cps: Keep interceptors in a separate field.

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 204 matching lines @@
     new ShrinkingReducer().rewrite(node);
   }
 }
 
 /// Compute an abstract size of an IR function definition.
 ///
 /// The size represents the cost of inlining at a call site.
 class SizeVisitor extends TrampolineRecursiveVisitor {
   int size = 0;
 
-  void countArgument(Reference<Primitive> argument, Parameter parameter) {
+  void countArgument(Primitive argument, Parameter parameter) {
     // If a parameter is unused and the corresponding argument has only the
     // one use at the invocation, then inlining the call might enable
     // elimination of the argument.  This 'pays for itself' by decreasing the
     // cost of inlining at the call site.
-    if (argument != null &&
-        argument.definition.hasExactlyOneUse &&
-        parameter.hasNoUses) {
+    if (argument != null && argument.hasExactlyOneUse && parameter.hasNoUses) {
       --size;
     }
   }
 
   static int sizeOf(InvocationPrimitive invoke, FunctionDefinition function) {
     SizeVisitor visitor = new SizeVisitor();
     visitor.visit(function);
-    visitor.countArgument(invoke.receiverRef, function.thisParameter);
+    if (invoke.callingConvention == CallingConvention.Intercepted) {
+      // Note that if the invocation is a dummy-intercepted call, then the
+      // target has an unused interceptor parameter, but the caller provides
+      // no interceptor argument.
+      visitor.countArgument(invoke.interceptor, function.interceptorParameter);
+    }
+    visitor.countArgument(invoke.receiver, function.receiverParameter);
     for (int i = 0; i < invoke.argumentRefs.length; ++i) {
-      visitor.countArgument(invoke.argumentRefs[i], function.parameters[i]);
+      visitor.countArgument(invoke.argument(i), function.parameters[i]);
     }
     return visitor.size;
   }
 
   // Inlining a function incurs a cost equal to the number of primitives and
   // non-jump tail expressions.
   // TODO(kmillikin): Tune the size computation and size bound.
   processLetPrim(LetPrim node) => ++size;
   processLetMutable(LetMutable node) => ++size;
   processBranch(Branch node) => ++size;
@@ skipping 25 matching lines @@
     return super.visitNode(node);
   }
 
   visitInterpolatedExpression(js.InterpolatedExpression node) {
     // Suppress call to visitNode.  Placeholders should not be counted, because
     // the argument has already been counted, and will in most cases be inserted
     // directly in the placeholder.
   }
 }
 
-
 class InliningVisitor extends TrampolineRecursiveVisitor {
   final Inliner _inliner;
 
   // A successful inlining attempt returns the [Primitive] that represents the
   // result of the inlined call or null.  If the result is non-null, the body
   // of the inlined function is available in this field.
   CpsFragment _fragment;
 
   InliningVisitor(this._inliner);
 
@@ skipping 22 matching lines @@
     // A successful inlining attempt will set the node's body to null, so it is
     // read before visiting the primitive.
     Expression next = node.body;
     Primitive replacement = visit(node.primitive);
     if (replacement != null) {
       node.primitive.replaceWithFragment(_fragment, replacement);
     }
     return next;
   }
 
-  TypeMask abstractType(Reference<Primitive> ref) {
-    return ref.definition.type ?? typeSystem.dynamicType;
+  TypeMask abstractType(Primitive def) {
+    return def.type ?? typeSystem.dynamicType;
   }
 
   /// Build the IR term for the function that adapts a call site targeting a
   /// function that takes optional arguments not passed at the call site.
   FunctionDefinition buildAdapter(InvokeMethod node, FunctionElement target) {
     Parameter thisParameter = new Parameter(new ThisParameterLocal(target))
         ..type = node.receiver.type;
+    Parameter interceptorParameter = node.interceptorRef != null
+        ? new Parameter(null)
+        : null;
     List<Parameter> parameters = new List<Parameter>.generate(
         node.argumentRefs.length,
         (int index) {
           // TODO(kmillikin): Use a hint for the parameter names.
           return new Parameter(null)
               ..type = node.argument(index).type;
         });
     Continuation returnContinuation = new Continuation.retrn();
     CpsFragment cps = new CpsFragment();
 
     FunctionSignature signature = target.functionSignature;
     int requiredParameterCount = signature.requiredParameterCount;
-    if (node.callingConvention == CallingConvention.Intercepted ||
-        node.callingConvention == CallingConvention.DummyIntercepted) {
-      ++requiredParameterCount;
-    }
     List<Primitive> arguments = new List<Primitive>.generate(
         requiredParameterCount,
         (int index) => parameters[index]);
 
     int parameterIndex = requiredParameterCount;
     CallStructure newCallStructure;
     if (signature.optionalParametersAreNamed) {
       List<String> incomingNames =
           node.selector.callStructure.getOrderedNamedArguments();
       List<String> outgoingNames = <String>[];
@@ skipping 23 matching lines @@
           defaultValue.type = typeSystem.getParameterType(formal);
           arguments.add(defaultValue);
         }
       });
       newCallStructure = new CallStructure(signature.parameterCount);
     }
 
     Selector newSelector =
         new Selector(node.selector.kind, node.selector.memberName,
             newCallStructure);
-    Primitive result = cps.invokeMethod(thisParameter, newSelector, node.mask,
-        arguments, node.callingConvention);
+    Primitive result = cps.invokeMethod(thisParameter,
+        newSelector,
+        node.mask,
+        arguments,
+        interceptor: interceptorParameter,
+        callingConvention: node.callingConvention);
     result.type = typeSystem.getInvokeReturnType(node.selector, node.mask);
     returnContinuation.parameters.single.type = result.type;
     cps.invokeContinuation(returnContinuation, <Primitive>[result]);
     return new FunctionDefinition(target, thisParameter, parameters,
         returnContinuation,
-        cps.root);
+        cps.root,
+        interceptorParameter: interceptorParameter);
   }
 
   // Given an invocation and a known target, possibly perform inlining.
   //
   // An optional call structure indicates a dynamic call.  Calls that are
   // already resolved statically have a null call structure.
   //
   // The [Primitive] representing the result of the inlined call is returned
   // if the call was inlined, and the inlined function body is available in
   // [_fragment].  If the call was not inlined, null is returned.
@@ skipping 20 matching lines @@
     }
 
     if (isBlacklisted(target)) return null;
 
     if (invoke.callingConvention == CallingConvention.OneShotIntercepted) {
       // One-shot interceptor calls with a known target are only inserted on
       // uncommon code paths, so they should not be inlined.
       return null;
     }
 
-    Reference<Primitive> dartReceiver = invoke.dartReceiverRef;
+    Primitive receiver = invoke.receiver;
     TypeMask abstractReceiver =
-        dartReceiver == null ? null : abstractType(dartReceiver);
+        receiver == null ? null : abstractType(receiver);
     // 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.isEmptyOrNull
             ? abstractReceiver
             : abstractReceiver.nonNullable();
     List<TypeMask> abstractArguments =
-        invoke.argumentRefs.map(abstractType).toList();
+        invoke.arguments.map(abstractType).toList();
     var cachedResult = _inliner.cache.get(target, callStructure,
         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;
       List<Primitive> arguments = invoke.arguments.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;
-        }
+      if (receiver != null && abstractReceiver.isNullable) {
+        receiver = nullReceiverGuard(
+            invoke, _fragment, receiver, abstractReceiver);
       }
       return _fragment.inlineFunction(function, receiver, arguments,
-          hint: invoke.hint);
+            interceptor: invoke.interceptor, 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);
@@ skipping 13 matching lines @@
       // formal parameter count.  Build the IR term for an adapter function
       // body.
       if (backend.isNative(target)) {
         // TODO(25548): Generate correct adaptor for native methods.
         return doNotInline();
       } else {
         function = buildAdapter(invoke, target);
       }
     } else {
       function = compileToCpsIr(target);
-      void setValue(Variable variable, Reference<Primitive> value) {
-        variable.type = value.definition.type;
+      if (function.receiverParameter != null) {
+        function.receiverParameter.type = abstractReceiverInMethod;
       }
-      if (invoke.callingConvention == CallingConvention.Intercepted) {
-        setValue(function.thisParameter, invoke.receiverRef);
-        function.parameters[0].type = abstractReceiverInMethod;
-        for (int i = 1; i < invoke.argumentRefs.length; ++i) {
-          setValue(function.parameters[i], invoke.argumentRefs[i]);
-        }
-      } else {
-        if (invoke.receiverRef != null) {
-          function.thisParameter.type = abstractReceiverInMethod;
-        }
-        for (int i = 0; i < invoke.argumentRefs.length; ++i) {
-          setValue(function.parameters[i], invoke.argumentRefs[i]);
-        }
+      for (int i = 0; i < invoke.argumentRefs.length; ++i) {
+        function.parameters[i].type = invoke.argument(i).type;
       }
       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);
@@ skipping 33 matching lines @@
   }
 
 
   @override
   Primitive visitInvokeStatic(InvokeStatic node) {
     return tryInlining(node, node.target, null);
   }
 
   @override
   Primitive visitInvokeMethod(InvokeMethod node) {
-    Primitive receiver = node.dartReceiver;
+    Primitive receiver = node.receiver;
     Element element = world.locateSingleElement(node.selector, receiver.type);
     if (element == null || element is! FunctionElement) return null;
     if (node.selector.isGetter != element.isGetter) return null;
     if (node.selector.isSetter != element.isSetter) return null;
     if (node.selector.name != element.name) return null;
 
     return tryInlining(node, element.asFunctionElement(),
         node.selector.callStructure);
   }
 
@@ skipping 23 matching lines @@
         (enclosingClass == backend.helpers.jsNumberClass ||
          enclosingClass == backend.helpers.jsDoubleClass ||
          enclosingClass == backend.helpers.jsIntClass)) {
       // These should be handled by operator specialization.
       return true;
     }
     if (target == backend.helpers.stringInterpolationHelper) return true;
     return false;
   }
 }