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

sdk/lib/_internal/compiler/implementation/ssa/optimize.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 OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 299 matching lines @@
         result.element = target;
         return result;
       }
     } else if (selector.isGetter()) {
       if (selector.applies(backend.jsArrayLength, compiler)) {
         HInstruction optimized = tryOptimizeLengthInterceptedGetter(node);
         if (optimized != null) return optimized;
       }
     }
 
-    // Check if this call does not need to be intercepted.
-    HType type = input.instructionType;
-    // TODO(kasperl): Get rid of this refinement once the receiver
-    // specialization phase takes care of it.
-    Selector refined = type.refine(selector, compiler);
-    Set<ClassElement> classes = backend.getInterceptedClassesOn(
-        refined, canBeNull: type.canBeNull());
-    if (classes == null) {
-      if (selector.isGetter()) {
-        // Change the call to a regular invoke dynamic call.
-        return new HInvokeDynamicGetter(selector, null, input, false);
-      } else if (selector.isSetter()) {
-        return new HInvokeDynamicSetter(
-            selector, null, input, node.inputs[2], false);
-      } else {
-        // Change the call to a regular invoke dynamic call.
-        return new HInvokeDynamicMethod(
-            selector, node.inputs.getRange(1, node.inputs.length - 1));
-      }
-    }
-
     // If the intercepted call is through a constant interceptor, we
     // know which element to call.
     if (node is !HOneShotInterceptor
         && interceptor.isConstant()
         && selector.isCall()) {
       DartType type = interceptor.instructionType.computeType(compiler);
       ClassElement cls = type.element;
       node.element = cls.lookupSelector(selector);
     }
     return node;
@@ skipping 16 matching lines @@
   }
 
   HInstruction visitInvokeStatic(HInvokeStatic node) {
     if (isFixedSizeListConstructor(node)) {
       node.instructionType = HType.FIXED_ARRAY;
     }
     return node;
   }
 
   HInstruction visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
-    if (node.isInterceptorCall) return handleInterceptorCall(node);
+    if (node.isCallOnInterceptor) return handleInterceptorCall(node);
     HType receiverType = node.receiver.instructionType;
     Selector selector = receiverType.refine(node.selector, compiler);
     Element element = compiler.world.locateSingleElement(selector);
     // TODO(ngeoffray): Also fold if it's a getter or variable.
     if (element != null && element.isFunction()) {
       FunctionElement method = element;
       FunctionSignature parameters = method.computeSignature(compiler);
       // TODO(ngeoffray): If the method has optional parameters,
       // we should pass the default values.
       if (parameters.optionalParameterCount == 0
@@ skipping 213 matching lines @@
         HInvokeStatic call = node.receiver;
         if (isFixedSizeListConstructor(call)) {
           return call.inputs[1];
         }
       }
     }
     return node;
   }
 
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
-    if (node.isInterceptorCall) return handleInterceptorCall(node);
+    if (node.isCallOnInterceptor) return handleInterceptorCall(node);
 
     Element field =
         findConcreteFieldForDynamicAccess(node.receiver, node.selector);
     if (field == null) return node;
 
     Modifiers modifiers = field.modifiers;
     bool isFinalOrConst = modifiers.isFinal() || modifiers.isConst();
     if (!compiler.resolverWorld.hasInvokedSetter(field, compiler)) {
       // If no setter is ever used for this field it is only initialized in the
       // initializer list.
@@ skipping 15 matching lines @@
         }
       }
       if (type != null) {
         result.instructionType = type;
       }
     }
     return result;
   }
 
   HInstruction visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
-    if (node.isInterceptorCall) return handleInterceptorCall(node);
+    if (node.isCallOnInterceptor) return handleInterceptorCall(node);
 
     Element field =
         findConcreteFieldForDynamicAccess(node.receiver, node.selector);
     if (field == null || !field.isAssignable()) return node;
-    HInstruction value = node.inputs[1];
+    // Use [:node.inputs.last:] in case the call follows the
+    // interceptor calling convention, but is not a call on an
+    // interceptor.
+    HInstruction value = node.inputs.last;
     if (compiler.enableTypeAssertions) {
       HInstruction other = value.convertType(
           compiler,
           field.computeType(compiler),
           HTypeConversion.CHECKED_MODE_CHECK);
       if (other != value) {
         node.block.addBefore(node, other);
         value = other;
       }
     }
     return new HFieldSet(field, node.inputs[0], value);
   }
 
   HInstruction visitStringConcat(HStringConcat node) {
     DartString folded = const LiteralDartString("");
     for (int i = 0; i < node.inputs.length; i++) {
       HInstruction part = node.inputs[i];
       if (!part.isConstant()) return node;
       HConstant constant = part;
       if (!constant.constant.isPrimitive()) return node;
       PrimitiveConstant primitive = constant.constant;
       folded = new DartString.concat(folded, primitive.toDartString());
     }
     return graph.addConstant(constantSystem.createString(folded, node.node));
   }
 
   HInstruction visitInterceptor(HInterceptor node) {
     if (node.isConstant()) return node;
+    // If the intercepted object does not need to be intercepted, just
+    // return the object (the [:getInterceptor:] method would have
+    // returned the object).
+    HType type = node.receiver.instructionType;
+    if (!type.canBePrimitive()) {
+
+      if (!(type.canBeNull()
+            && node.interceptedClasses.contains(compiler.objectClass))) {
+        return node.receiver;
+      }
+    }
     HInstruction constant = tryComputeConstantInterceptor(
         node.inputs[0], node.interceptedClasses);
     if (constant == null) return node;
+
     return constant;
   }
 
   HInstruction tryComputeConstantInterceptor(HInstruction input,
                                              Set<ClassElement> intercepted) {
     HType type = input.instructionType;
     ClassElement constantInterceptor;
     if (type.isInteger()) {
       constantInterceptor = backend.jsIntClass;
     } else if (type.isDouble()) {
@@ skipping 840 matching lines @@
     HBasicBlock block = user.block;
     block.addAfter(user, interceptor);
     block.rewrite(user, interceptor);
     block.remove(user);
 
     // The interceptor will be removed in the dead code elimination
     // phase. Note that removing it here would not work because of how
     // the [visitBasicBlock] is implemented.
   }
 }