Address review comments on issue 11412105.

sdk/lib/_internal/compiler/implementation/ssa/builder.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;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 2420 matching lines @@
     assert(selector.isGetter());
     SourceString getterName = selector.name;
     Set<ClassElement> interceptedClasses =
         getInterceptedClassesOn(send, selector);
 
     bool hasGetter = compiler.world.hasAnyUserDefinedGetter(selector);
     if (interceptedClasses != null) {
       // If we're using an interceptor class, emit a call to the
       // interceptor method and then the actual dynamic call on the
       // interceptor object.
-      HInstruction instruction;
-      if (backend.isInterceptorClass(currentElement.getEnclosingClass())
-          && send.receiver == null) {
-        instruction = thisInstruction;
-      } else {
-        pushInvokeInterceptor(interceptedClasses, receiver);
-        instruction = pop();
-      }
+      HInstruction instruction =
+          invokeInterceptor(interceptedClasses, receiver, send);
       instruction = new HInvokeDynamicGetter(
           selector, null, instruction, !hasGetter);
       // Add the receiver as an argument to the getter call on the
       // interceptor.
       instruction.inputs.add(receiver);
       pushWithPosition(instruction, send);
     } else {
       pushWithPosition(
           new HInvokeDynamicGetter(selector, null, receiver, !hasGetter), send);
     }
@@ skipping 43 matching lines @@
                                                   HInstruction value) {
     assert(Elements.isInstanceSend(send, elements));
     Selector selector = elements.getSelector(send);
     assert(selector.isSetter());
     SourceString setterName = selector.name;
     bool hasSetter = compiler.world.hasAnyUserDefinedSetter(selector);
     Set<ClassElement> interceptedClasses =
         getInterceptedClassesOn(send, selector);
     if (interceptedClasses != null) {
       // If we're using an interceptor class, emit a call to the
-      // interceptor method and then the actual dynamic call on the
+      // getInterceptor method and then the actual dynamic call on the
       // interceptor object.
-      HInstruction instruction;
-      if (backend.isInterceptorClass(currentElement.getEnclosingClass())
-          && send.receiver == null) {
-        instruction = thisInstruction;
-      } else {
-        pushInvokeInterceptor(interceptedClasses, receiver);
-        instruction = pop();
-      }
+      HInstruction instruction =
+          invokeInterceptor(interceptedClasses, receiver, send);
       instruction = new HInvokeDynamicSetter(
           selector, null, instruction, receiver, !hasSetter);
       // Add the value as an argument to the setter call on the
       // interceptor.
       instruction.inputs.add(value);
       addWithPosition(instruction, send);
     } else {
       addWithPosition(
           new HInvokeDynamicSetter(selector, null, receiver, value, !hasSetter),
           send);
@@ skipping 29 matching lines @@
       HInstruction checked = potentiallyCheckType(
           value, element.computeType(compiler));
       if (!identical(checked, value)) {
         pop();
         stack.add(checked);
       }
       localsHandler.updateLocal(element, checked);
     }
   }
 
-  void pushInvokeInterceptor(Set<ClassElement> intercepted,
-                             HInstruction receiver) {
-    push(new HInterceptor(intercepted, receiver));
+  HInstruction invokeInterceptor(Set<ClassElement> intercepted,
+                                 HInstruction receiver,
+                                 Send send) {
+    if (send != null
+        && backend.isInterceptorClass(currentElement.getEnclosingClass())
+        && send.receiver == null) {
+      return thisInstruction;
+    }
+    HInterceptor interceptor = new HInterceptor(intercepted, receiver);
+    add(interceptor);
+    return interceptor;
   }
 
   void pushInvokeHelper0(Element helper) {
     HInstruction reference = new HStatic(helper);
     add(reference);
     List<HInstruction> inputs = <HInstruction>[reference];
     HInstruction result = new HInvokeStatic(inputs);
     push(result);
   }
 
@@ skipping 183 matching lines @@
 
   void addGenericSendArgumentsToList(Link<Node> link, List<HInstruction> list) {
     for (; !link.isEmpty; link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
   }
 
   visitDynamicSend(Send node) {
     Selector selector = elements.getSelector(node);
-    var inputs = <HInstruction>[];
 
     SourceString dartMethodName;
     bool isNotEquals = false;
     if (node.isIndex && !node.arguments.tail.isEmpty) {
       dartMethodName = Elements.constructOperatorName(
           const SourceString('[]='), false);
     } else if (node.selector.asOperator() != null) {
       SourceString name = node.selector.asIdentifier().source;
       isNotEquals = identical(name.stringValue, '!=');
       dartMethodName = Elements.constructOperatorName(
           name, node.argumentsNode is Prefix);
     } else {
       dartMethodName = node.selector.asIdentifier().source;
     }
 
-    Set<ClassElement> interceptedClasses =
-        getInterceptedClassesOn(node, selector);
-
-    if (interceptedClasses != null) {
-      if (backend.isInterceptorClass(currentElement.getEnclosingClass())
-          && node.receiver == null) {
-        inputs.add(thisInstruction);
-        inputs.add(localsHandler.readThis());
-      } else {
-        visit(node.receiver);
-        HInstruction receiver = pop();
-        pushInvokeInterceptor(interceptedClasses, receiver);
-        inputs.add(pop());
-        inputs.add(receiver);
-      }
-      addDynamicSendArgumentsToList(node, inputs);
-      // The first entry in the inputs list is the interceptor. The
-      // second is the receiver, and the others are the arguments.
-      HInstruction instruction = new HInvokeDynamicMethod(selector, inputs);
-      pushWithPosition(instruction, node);
-      return;
-    }
-
     Element element = elements[node];
     if (element != null && compiler.world.hasNoOverridingMember(element)) {
       if (tryInlineMethod(element, selector, node.arguments)) {
         return;
       }
     }
 
+    HInstruction receiver;
     if (node.receiver == null) {
-      inputs.add(localsHandler.readThis());
+      receiver = localsHandler.readThis();
     } else {
       visit(node.receiver);
-      inputs.add(pop());
+      receiver = pop();
     }
 
+    List<HInstruction> inputs = <HInstruction>[];
+    Set<ClassElement> interceptedClasses =
+        interceptors.getInterceptedClassesOn(selector);
+    if (interceptedClasses != null) {
+      inputs.add(invokeInterceptor(interceptedClasses, receiver, node));
+    }
+    inputs.add(receiver);
+
     addDynamicSendArgumentsToList(node, inputs);
 
-    // The first entry in the inputs list is the receiver.
     pushWithPosition(new HInvokeDynamicMethod(selector, inputs), node);
 
     if (isNotEquals) {
       HNot not = new HNot(popBoolified());
       push(not);
     }
   }
 
   visitClosureSend(Send node) {
     Selector selector = elements.getSelector(node);
@@ skipping 978 matching lines @@
       SourceString iteratorName = const SourceString("iterator");
       Selector selector =
           new Selector.call(iteratorName, work.element.getLibrary(), 0);
       Set<ClassElement> interceptedClasses =
           interceptors.getInterceptedClassesOn(selector);
       visit(node.expression);
       HInstruction receiver = pop();
       if (interceptedClasses == null) {
         iterator = new HInvokeDynamicMethod(selector, <HInstruction>[receiver]);
       } else {
-        pushInvokeInterceptor(interceptedClasses, receiver);
-        HInterceptor interceptor = pop();
+        HInterceptor interceptor =
+            invokeInterceptor(interceptedClasses, receiver, null);
         iterator = new HInvokeDynamicMethod(
             selector, <HInstruction>[interceptor, receiver]);
       }
       add(iterator);
     }
     HInstruction buildCondition() {
       SourceString name = const SourceString('hasNext');
       Selector selector = new Selector.getter(name, work.element.getLibrary());
       bool hasGetter = compiler.world.hasAnyUserDefinedGetter(selector);
       push(new HInvokeDynamicGetter(selector, null, iterator, !hasGetter));
@@ skipping 1067 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }