Make instance methods whose names collide with intercepted methods have the interceptor calling con…

sdk/lib/_internal/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 1291 matching lines @@
                  List<HInstruction> inputs,
                  [bool isIntercepted = false])
     : super(inputs),
       this.selector = selector,
       specializer = isIntercepted
           ? InvokeDynamicSpecializer.lookupSpecializer(selector)
           : const InvokeDynamicSpecializer();
   toString() => 'invoke dynamic: $selector';
   HInstruction get receiver => inputs[0];
 
+  /**
+   * Returns whether this call is on an intercepted method.
+   */
   bool get isInterceptorCall {
     // We know it's a selector call if it follows the interceptor
     // calling convention, which adds the actual receiver as a
     // parameter to the call.
     return inputs.length - 2 == selector.argumentCount;
   }
 
+  /**
+   * Returns whether this call is on an interceptor object.
+   */
+  bool get isCallOnInterceptor {
+    // When the optimizers know this call does not need an
+    // interceptor, they udpate the receiver of the call to be the
+    // actual receiver.
+    return isInterceptorCall && inputs[0] != inputs[1];

[sra1, 2013/02/27 05:13:28]

Consider a.sb.add(123)
The optimization you mention does

t1 = a.sb
t2 = getInterceptor(t1);
t3 = t2.add$1(t1, 123);
-->
t1 = a.sb;
t3 = t1.add$1(t1, 123);

There is a further optimization of replacing argument t1 with junk if we know it
is not used:
t1 = a.sb;
t3 = t1.add$1(0, 123);
-->
t3 = a.sb.add$1(0, 123);

We can substitute junk for the explicit receiver if the function set for add$1
at that point uniformly ignores the explicit receiver parameter*.

However, the predicate you wrote will be confused by this (a.sb != 0).
I suggest inspecting inputs[0] rather than rely on this fragile invariant. 

* If we make mixins work by copying compiled methods into the appropriate
prototypes, some methods will use their explicit receiver, even though they are
methods on a plain class, because they are also copied onto an interceptor class
- I expect there will be a lot of this eventually for the DOM classes. 

[ngeoffray, 2013/02/28 10:39:42]

inputs[0] can either be a call to getInterceptor or a constant. So decoding it a
bit annoying. I added a TODO to stop relying on this fragile invariant. I will
do the optimization of replacing with 0 in a following CL.

+  }
+
   int typeCode() => HInstruction.INVOKE_DYNAMIC_TYPECODE;
   bool typeEquals(other) => other is HInvokeDynamic;
   bool dataEquals(HInvokeDynamic other) {
     return selector == other.selector && element == other.element;
   }
 }
 
 class HInvokeClosure extends HInvokeDynamic {
   HInvokeClosure(Selector selector, List<HInstruction> inputs)
     : super(selector, null, inputs) {
@@ skipping 1227 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }