dart2js cps: Use 'this' instead of receiver when possible.

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 ParentVisitor;
 import '../../constants/values.dart';
 import '../../elements/elements.dart';
 import '../../io/source_information.dart';
 import '../../js_backend/codegen/glue.dart';
 import '../../universe/universe.dart' show Selector;
@@ skipping 34 matching lines @@
 
   Map<Primitive, Interceptor> interceptors = <Primitive, Interceptor>{};
 
   // 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);
 
+  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;
     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) {
-      thisParameter = function.thisParameter;
       ThisParameterLocal holder = thisParameter.hint;
       explicitReceiverParameter = new Parameter(
           new ExplicitReceiverParameterEntity(
               holder.executableContext));
       function.parameters.insert(0, explicitReceiverParameter);
     }
 
     // Set all parent pointers.
     _parentVisitor.visit(function);
 
-    if (inInterceptedMethod) {
+    if (inInterceptedMethod && methodUsesReceiverArgument(function.element)) {
       explicitReceiverParameter.substituteFor(thisParameter);
     }
 
     visit(function);
   }
 
   Constant get trueConstant {
     return new Constant(new TrueConstantValue());
   }
 
@@ skipping 139 matching lines @@
 
   /// Returns an interceptor for the given value, capable of responding to
   /// [selector].
   ///
   /// A single getInterceptor call will be created per primitive, bound
   /// immediately after the primitive is bound.
   ///
   /// The type propagation pass will later narrow the set of interceptors
   /// based on the input type, and the let sinking pass will propagate the
   /// getInterceptor call closer to its use when this is profitable.
-  Interceptor getInterceptorFor(Primitive prim, Selector selector,
-                                SourceInformation sourceInformation) {
+  Primitive getInterceptorFor(Primitive prim, Selector selector,
+                              SourceInformation sourceInformation) {
+    if (prim == explicitReceiverParameter) {
+      // If the receiver is the explicit receiver, we are calling a method in
+      // the same interceptor.
+      return thisParameter;
+    }
     assert(prim is! Interceptor);
     Interceptor interceptor = interceptors[prim];
     if (interceptor == null) {
       interceptor = new Interceptor(prim, sourceInformation);
       interceptors[prim] = interceptor;
       InteriorNode parent = prim.parent;
       insertLetPrim(interceptor, parent.body);
       if (prim.hint != null) {
         interceptor.hint = new InterceptorEntity(prim.hint);
       }
     }
     // Add the interceptor classes that can respond to the given selector.
     interceptor.interceptedClasses.addAll(
         _glue.getInterceptedClassesOn(selector));
     return interceptor;
   }
 
   processInvokeMethod(InvokeMethod node) {
-    Selector selector = node.selector;
-    if (!_glue.isInterceptedSelector(selector)) return;
-
-    Primitive receiver = node.receiver.definition;
-    Primitive newReceiver;
-
-    if (receiver == explicitReceiverParameter) {
-      // If the receiver is the explicit receiver, we are calling a method in
-      // the same interceptor:
-      //  Change 'receiver.foo()'  to  'this.foo(receiver)'.
-      newReceiver = thisParameter;
-    } else {
-      newReceiver = getInterceptorFor(
-          receiver, node.selector, node.sourceInformation);
+    if (_glue.isInterceptedSelector(node.selector)) {
+      // Rewrite `x.foo()` => `INTERCEPTOR.foo(x, ..)`.
+      Primitive receiver = node.receiver.definition;
+      Primitive newReceiver = 
+          getInterceptorFor(receiver, node.selector, node.sourceInformation);
+      node.arguments.insert(0, node.receiver);
+      node.receiver = new Reference<Primitive>(newReceiver);
     }
-
-    node.arguments.insert(0, node.receiver);
-    node.receiver = new Reference<Primitive>(newReceiver);
   }
 
   processInvokeMethodDirectly(InvokeMethodDirectly node) {
     if (_glue.isInterceptedMethod(node.target)) {
-      Primitive nullPrim = nullConstant;
-      insertLetPrim(nullPrim, node);
+      // Rewrite `x.foo()` => `INTERCEPTOR.foo(x, ..)`.
+      Primitive receiver = node.receiver.definition;
+      Primitive newReceiver = 
+          getInterceptorFor(receiver, node.selector, node.sourceInformation);
       node.arguments.insert(0, node.receiver);
-      // TODO(sra): `null` is not adequate.  Interceptors project the class
-      // hierarchy onto an interceptor hierarchy.  A super call that does a
-      // method call will use the javascript 'this' parameter to avoid calling
-      // getInterceptor again, so the receiver must be the interceptor (likely
-      // `this`), not `null`.
-      node.receiver = new Reference<Primitive>(nullPrim);
+      node.receiver = new Reference<Primitive>(newReceiver);
     }
   }
 
   processBranch(Branch node) {
     // TODO(karlklose): implement the checked mode part of boolean conversion.
     InteriorNode parent = node.parent;
     IsTrue condition = node.condition;
 
     // Do not rewrite conditions that are foreign code.
     // It is redundant, and causes infinite recursion (if not optimized)
@@ skipping 22 matching lines @@
     condition.value.unlink();
     node.trueContinuation.unlink();
     node.falseContinuation.unlink();
     parent.body = newNode;
   }
 
   processInterceptor(Interceptor node) {
     _glue.registerSpecializedGetInterceptor(node.interceptedClasses);
   }
 }