dart2js cps: Keep interceptors in a separate field.

pkg/compiler/lib/src/js_backend/codegen/unsugar.dart

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
 import '../../cps_ir/optimizers.dart' show Pass;
 import '../../constants/values.dart';
 import '../../elements/elements.dart';
 import '../../js_backend/codegen/glue.dart';
 import '../../universe/selector.dart' show Selector;
-import '../../cps_ir/cps_ir_builder.dart' show ThisParameterLocal;
 import '../../cps_ir/cps_fragment.dart';
 import '../../common/names.dart';
 
 class ExplicitReceiverParameterEntity implements Local {
   String get name => 'receiver';
   final ExecutableElement executableContext;
   ExplicitReceiverParameterEntity(this.executableContext);
   toString() => 'ExplicitReceiverParameterEntity($executableContext)';
 }
 
@@ skipping 10 matching lines @@
 /// special nodes that respect JavaScript behavior.
 ///
 /// Performs the following rewrites:
 ///  - Add interceptors at call sites that use interceptor calling convention.
 ///  - Add explicit receiver argument for methods that are called in interceptor
 ///    calling convention.
 ///  - Convert two-parameter exception handlers to one-parameter ones.
 class UnsugarVisitor extends TrampolineRecursiveVisitor implements Pass {
   Glue _glue;
 
-  Parameter thisParameter;
-  Parameter explicitReceiverParameter;
+  FunctionDefinition function;
+
+  Parameter get receiverParameter => function.receiverParameter;
+
+  /// The interceptor of the receiver.  For some methods, this is the receiver
+  /// itself, for others, it is the interceptor parameter.
+  Parameter receiverInterceptor;
 
   // In a catch block, rethrow implicitly throws the block's exception
   // parameter.  This is the exception parameter when nested in a catch
   // block and null otherwise.
   Parameter _exceptionParameter = null;
 
   UnsugarVisitor(this._glue);
 
   String get passName => 'Unsugaring';
 
-  bool methodUsesReceiverArgument(FunctionElement function) {
-    assert(_glue.isInterceptedMethod(function));
-    ClassElement clazz = function.enclosingClass.declaration;
-    return _glue.isInterceptorClass(clazz) ||
-           _glue.isUsedAsMixin(clazz);
-  }
-
   void rewrite(FunctionDefinition function) {
-    thisParameter = function.thisParameter;
+    this.function = function;
     bool inInterceptedMethod = _glue.isInterceptedMethod(function.element);
 
     if (function.element.name == '==' &&
         function.parameters.length == 1 &&
         !_glue.operatorEqHandlesNullArgument(function.element)) {
       // Insert the null check that the language semantics requires us to
       // perform before calling operator ==.
       insertEqNullCheck(function);
     }
 
     if (inInterceptedMethod) {
-      ThisParameterLocal holder = thisParameter.hint;
-      explicitReceiverParameter = new Parameter(
-          new ExplicitReceiverParameterEntity(holder.executableContext));
-      explicitReceiverParameter.parent = function;
-      function.parameters.insert(0, explicitReceiverParameter);
-    }
-
-    if (inInterceptedMethod && methodUsesReceiverArgument(function.element)) {
-      thisParameter.replaceUsesWith(explicitReceiverParameter);
+      function.interceptorParameter = new Parameter(null)..parent = function;
+      // Since the receiver won't be compiled to "this", set a hint on it
+      // so the parameter gets a meaningful name.
+      function.receiverParameter.hint =
+          new ExplicitReceiverParameterEntity(function.element);
+      // If we need an interceptor for the receiver, use the receiver itself
+      // if possible, otherwise the interceptor argument.
+      receiverInterceptor = _glue.methodUsesReceiverArgument(function.element)
+          ? function.interceptorParameter
+          : receiverParameter;
     }
 
     visit(function);
   }
 
   Constant get trueConstant {
     return new Constant(new TrueConstantValue());
   }
 
   Constant get falseConstant {
@@ skipping 112 matching lines @@
         node.argumentRefs.length == 1 &&
         isNullConstant(node.argument(0))) {
       node.replaceWith(new ApplyBuiltinOperator(
           BuiltinOperator.Identical,
           [node.receiver, node.argument(0)],
           node.sourceInformation));
       return;
     }
 
     Primitive receiver = node.receiver;
-    Primitive newReceiver;
+    Primitive interceptor;
 
-    if (receiver == explicitReceiverParameter) {
-      // If the receiver is the explicit receiver, we are calling a method in
+    if (receiver == receiverParameter && receiverInterceptor != null) {
+      // TODO(asgerf): This could be done by GVN.
+      // If the receiver is 'this', we are calling a method in
       // the same interceptor:
       //  Change 'receiver.foo()'  to  'this.foo(receiver)'.
-      newReceiver = thisParameter;
+      interceptor = receiverInterceptor;
     } else {
-      newReceiver = new Interceptor(receiver, node.sourceInformation);
+      interceptor = new Interceptor(receiver, node.sourceInformation);
       if (receiver.hint != null) {
-        newReceiver.hint = new InterceptorEntity(receiver.hint);
+        interceptor.hint = new InterceptorEntity(receiver.hint);
       }
-      new LetPrim(newReceiver).insertAbove(node.parent);
+      new LetPrim(interceptor).insertAbove(node.parent);
     }
-    node.argumentRefs.insert(0, node.receiverRef);
-    node.receiverRef = new Reference<Primitive>(newReceiver)..parent = node;
-    node.callingConvention = CallingConvention.Intercepted;
+    assert(node.interceptorRef == null);
+    node.makeIntercepted(interceptor);
   }
 
   processInvokeMethodDirectly(InvokeMethodDirectly node) {
     if (!_glue.isInterceptedMethod(node.target)) return;
 
     Primitive receiver = node.receiver;
-    Primitive newReceiver;
+    Primitive interceptor;
 
-    if (receiver == explicitReceiverParameter) {
-      // If the receiver is the explicit receiver, we are calling a method in
+    if (receiver == receiverParameter && receiverInterceptor != null) {
+      // If the receiver is 'this', we are calling a method in
       // the same interceptor:
       //  Change 'receiver.foo()'  to  'this.foo(receiver)'.
-      newReceiver = thisParameter;
+      interceptor = receiverInterceptor;
     } else {
-      newReceiver = new Interceptor(receiver, node.sourceInformation);
+      interceptor = new Interceptor(receiver, node.sourceInformation);
       if (receiver.hint != null) {
-        newReceiver.hint = new InterceptorEntity(receiver.hint);
+        interceptor.hint = new InterceptorEntity(receiver.hint);
       }
-      new LetPrim(newReceiver).insertAbove(node.parent);
+      new LetPrim(interceptor).insertAbove(node.parent);
     }
-    node.argumentRefs.insert(0, node.receiverRef);
-    node.receiverRef = new Reference<Primitive>(newReceiver)..parent = node;
-    node.callingConvention = CallingConvention.Intercepted;
+    assert(node.interceptorRef == null);
+    node.makeIntercepted(interceptor);
   }
 }