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

pkg/compiler/lib/src/cps_ir/type_propagation.dart

 // Copyright (c) 2014, 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.
 
 import 'optimizers.dart';
 
 import '../common/names.dart' show
     Selectors;
 import '../compiler.dart' as dart2js show
     Compiler;
@@ skipping 56 matching lines @@
         new TypeMask.nonNullSubtype(classWorld.numClass, classWorld);
     TypeMask anyString =
         new TypeMask.nonNullSubtype(classWorld.stringClass, classWorld);
     TypeMask anyBool =
         new TypeMask.nonNullSubtype(classWorld.boolClass, classWorld);
     numStringBoolType =
       new TypeMask.unionOf(<TypeMask>[anyNum, anyString, anyBool],
                            classWorld);
   }
 
+  bool methodUsesReceiverArgument(FunctionElement function) {
+    assert(backend.isInterceptedMethod(function));
+    ClassElement clazz = function.enclosingClass.declaration;
+    return clazz.isSubclassOf(backend.jsInterceptorClass) || 
+           classWorld.isUsedAsMixin(clazz);
+  }
+
   Element locateSingleElement(TypeMask mask, Selector selector) {
     return mask.locateSingleElement(selector, mask, classWorld.compiler);
   }
 
   ClassElement singleClass(TypeMask mask) {
     return mask.singleClass(classWorld);
   }
 
   bool needsNoSuchMethodHandling(TypeMask mask, Selector selector) {
     return mask.needsNoSuchMethodHandling(selector, classWorld);
   }
 
   TypeMask getReceiverType(MethodElement method) {
     assert(method.isInstanceMember);
-    return nonNullSubclass(method.enclosingClass);
+    if (classWorld.isUsedAsMixin(method.enclosingClass.declaration)) {
+      // If used as a mixin, the receiver could be any of the classes that mix
+      // in the class, and these are not considered subclasses.
+      // TODO(asgerf): Exclude the subtypes that only `implement` the class.
+      return nonNullSubtype(method.enclosingClass);
+    } else {
+      return nonNullSubclass(method.enclosingClass);
+    }
   }
 
   TypeMask getParameterType(ParameterElement parameter) {
     return inferrer.getGuaranteedTypeOfElement(parameter);
   }
 
   TypeMask getReturnType(FunctionElement function) {
     return inferrer.getGuaranteedReturnTypeOfElement(function);
   }
 
@@ skipping 19 matching lines @@
     // TODO(asgerf): Maybe closure conversion should create a new ClassWorld?
     if (element.isClosure) return functionType;
     return new TypeMask.nonNullExact(element.declaration, classWorld);
   }
 
   TypeMask nonNullSubclass(ClassElement element) {
     if (element.isClosure) return functionType;
     return new TypeMask.nonNullSubclass(element.declaration, classWorld);
   }
 
+  TypeMask nonNullSubtype(ClassElement element) {
+    if (element.isClosure) return functionType;
+    return new TypeMask.nonNullSubtype(element.declaration, classWorld);
+  }
+
   bool isDefinitelyBool(TypeMask t, {bool allowNull: false}) {
     if (!allowNull && t.isNullable) return false;
     return t.nonNullable().containsOnlyBool(classWorld);
   }
 
   bool isDefinitelyNum(TypeMask t, {bool allowNull: false}) {
     if (!allowNull && t.isNullable) return false;
     return t.nonNullable().containsOnlyNum(classWorld);
   }
 
@@ skipping 1433 matching lines @@
   void visitInvokeMethod(InvokeMethod node) {
     if (constifyExpression(node)) return;
     if (specializeOperatorCall(node)) return;
     if (specializeFieldAccess(node)) return;
     if (specializeIndexableAccess(node)) return;
     if (specializeArrayAccess(node)) return;
     if (specializeClosureCall(node)) return;
 
     AbstractValue receiver = getValue(node.receiver.definition);
     node.receiverIsNotNull = receiver.isDefinitelyNotNull;
+
+    if (isInterceptedSelector(node.selector) &&
+        node.receiver.definition == node.arguments[0].definition) {
+      // The receiver and first argument are the same; that means we already
+      // determined in visitInterceptor that we are targeting a non-interceptor.
+
+      // Check if any of the possible targets depend on the extra receiver
+      // argument. Mixins do this, and tear-offs always needs the extra receiver
+      // argument because BoundClosure uses it for equality and hash code.

[sra1, 2015/08/26 15:04:43]

SSA backend has this TODO.

          // TODO(15933): Make automatically generated property extraction
          // closures work with the dummy receiver optimization.

Add a TODO here.
We loose a lot of opportunities for better looking code on get$length.

+      bool needsReceiver(Element target) {
+        if (target is! FunctionElement) return false;
+        FunctionElement function = target;
+        return typeSystem.methodUsesReceiverArgument(function) ||
+               node.selector.isGetter && !function.isGetter;
+      }
+      if (!getAllTargets(receiver.type, node.selector).any(needsReceiver)) {
+        // Replace the extra receiver argument with a dummy value if the
+        // target definitely does not use it.
+        Constant dummy = makeConstantPrimitive(new IntConstantValue(0));

[sra1, 2015/08/26 15:04:43]

There is a special constant for this purpose.
In constants/values.dart, SyntheticConstantValue.
The type of the constant is not 'int'.
The syntax '0' is deferred to the js generation.

SSA backend constructs this so:

            ConstantValue constant = new SyntheticConstantValue(
                SyntheticConstantKind.DUMMY_INTERCEPTOR,
                receiverArgument.instructionType);

+        insertLetPrim(node, dummy);
+        node.arguments[0].unlink();
+        node.arguments[0] = new Reference<Primitive>(dummy);
+      }
+    }
   }
 
   void visitTypeCast(TypeCast node) {
     Continuation cont = node.continuation.definition;
 
     AbstractValue value = getValue(node.value.definition);
     switch (lattice.isSubtypeOf(value, node.type, allowNull: true)) {
       case AbstractBool.Maybe:
       case AbstractBool.Nothing:
         break;
@@ skipping 471 matching lines @@
     values[node] = newValue;
     defWorklist.add(node);
   }
 
   // -------------------------- Visitor overrides ------------------------------
   void visit(Node node) { node.accept(this); }
 
   void visitFunctionDefinition(FunctionDefinition node) {
     int firstActualParameter = 0;
     if (backend.isInterceptedMethod(node.element)) {
-      setValue(node.thisParameter, nonConstant(typeSystem.nonNullType));
-      setValue(node.parameters[0],
-               nonConstant(typeSystem.getReceiverType(node.element)));
+      if (typeSystem.methodUsesReceiverArgument(node.element)) {
+        setValue(node.thisParameter, nonConstant(typeSystem.nonNullType));
+        setValue(node.parameters[0],
+                 nonConstant(typeSystem.getReceiverType(node.element)));
+      } else {
+        setValue(node.thisParameter, 
+              nonConstant(typeSystem.getReceiverType(node.element)));
+        setValue(node.parameters[0], nonConstant());
+      }
       firstActualParameter = 1;
     } else if (node.thisParameter != null) {
       setValue(node.thisParameter,
                nonConstant(typeSystem.getReceiverType(node.element)));
     }
     for (Parameter param in node.parameters.skip(firstActualParameter)) {
       // TODO(karlklose): remove reference to the element model.
       TypeMask type = param.hint is ParameterElement
           ? typeSystem.getParameterType(param.hint)
           : typeSystem.dynamicType;
@@ skipping 584 matching lines @@
   }
 
   processLetPrim(LetPrim node) {
     values.remove(node.primitive);
   }
 
   processLetMutable(LetMutable node) {
     values.remove(node.variable);
   }
 }