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

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.
  */
 class InterceptedElement extends ElementX {
   final HType ssaType;
   InterceptedElement(this.ssaType, Element enclosing)
       : super(const SourceString('receiver'),

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

Changed the name to '_' in case of a non-interceptor class.

               ElementKind.PARAMETER,
               enclosing);
 
   DartType computeType(Compiler compiler) => ssaType.computeType(compiler);
 }
 
 class SsaBuilderTask extends CompilerTask {
   final CodeEmitterTask emitter;
   final JavaScriptBackend backend;
 
@@ skipping 292 matching lines @@
       // not have any thisElement if the closure was created inside a static
       // context.
       HThis thisInstruction = new HThis(
           closureData.thisElement, getTypeOfThis());
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
 
     // If this method is an intercepted method, add the extra
-    // parameter to it, that is the actual receiver.
+    // parameter to it, that is the actual receiver for intercepted
+    // classes, or the same as [:this:] for non-intercepted classes.
     ClassElement cls = element.getEnclosingClass();
-    if (builder.backend.isInterceptorClass(cls)) {
+    if (builder.backend.isInterceptedMethod(element)) {
       HType type = HType.UNKNOWN;
       if (cls == builder.backend.jsArrayClass) {
         type = HType.READABLE_ARRAY;
       } else if (cls == builder.backend.jsStringClass) {
         type = HType.STRING;
       } else if (cls == builder.backend.jsNumberClass) {
         type = HType.NUMBER;
       } else if (cls == builder.backend.jsIntClass) {
         type = HType.INTEGER;
       } else if (cls == builder.backend.jsDoubleClass) {
         type = HType.DOUBLE;
       } else if (cls == builder.backend.jsNullClass) {
         type = HType.NULL;
       } else if (cls == builder.backend.jsBoolClass) {
         type = HType.BOOLEAN;
       }
       Element parameter = new InterceptedElement(type, element);
       HParameterValue value = new HParameterValue(parameter);
       builder.graph.entry.addAfter(
           directLocals[closureData.thisElement], value);
-      directLocals[closureData.thisElement] = value;
+      if (builder.backend.isInterceptorClass(cls.declaration)) {
+        // Only use the extra parameter in intercepted classes.
+        directLocals[closureData.thisElement] = value;
+      }
       value.instructionType = type;
     }
   }
 
   bool hasValueForDirectLocal(Element element) {
     assert(element != null);
     assert(isAccessedDirectly(element));
     return directLocals[element] != null;
   }
 
@@ skipping 526 matching lines @@
     FunctionExpression function = functionElement.parseNode(compiler);
     assert(function != null);
     assert(!function.modifiers.isExternal());
     assert(elements[function] != null);
     openFunction(functionElement, function);
     SourceString name = functionElement.name;
     // If [functionElement] is operator== we explicitely add a null
     // check at the beginning of the method. This is to avoid having
     // call sites do the null check.
     if (name == const SourceString('==')) {
+      if (functionElement.getEnclosingClass() == compiler.objectClass) {
+        // We special case [Object.operator==] because we know the
+        // receiver is not null and therefore can just do an identity
+        // check on [:this:]. The interceptor classes have their own
+        // synthesized [:operator==:] method.
+        HInstruction parameter = parameters.values.first;
+        HIdentity identity = new HIdentity(graph.thisInstruction, parameter);
+        add(identity);
+        HReturn ret = new HReturn(identity);
+        close(ret).addSuccessor(graph.exit);
+        return closeFunction();
+      }
       handleIf(
           function,
           () {
             HParameterValue parameter = parameters.values.first;
             push(new HIdentity(
                 parameter, graph.addConstantNull(constantSystem)));
           },
           () {
             HReturn ret = new HReturn(
                 graph.addConstantBool(false, constantSystem));
@@ skipping 1436 matching lines @@
 
   String getTargetName(ErroneousElement error, [String prefix]) {
     String result = error.name.slowToString();
     if (?prefix) {
       result = '$prefix $result';
     }
     return result;
   }
 
   /**
-   * Returns a set of interceptor classes that contain a member whose
-   * signature matches the given [selector].
+   * Returns a set of interceptor classes that contain the given
+   * [selector].
    */
-  Set<ClassElement> getInterceptedClassesOn(Selector selector) {
-    return backend.getInterceptedClassesOn(selector);
-  }
-
   void generateInstanceGetterWithCompiledReceiver(Send send,
                                                   HInstruction receiver) {
     assert(Elements.isInstanceSend(send, elements));
     // TODO(kasperl): This is a convoluted way of checking if we're
     // generating code for a compound assignment. If we are, we need
     // to get the selector from the mapping for the AST selector node.
     Selector selector = (send.asSendSet() == null)
         ? elements.getSelector(send)
         : elements.getSelector(send.selector);
     assert(selector.isGetter());
     SourceString getterName = selector.name;
-    Set<ClassElement> interceptedClasses = getInterceptedClassesOn(selector);
+    Set<ClassElement> interceptedClasses =
+        backend.getInterceptedClassesOn(getterName);
 
     bool hasGetter = compiler.world.hasAnyUserDefinedGetter(selector);
     HInstruction instruction;
     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.
       instruction =
           invokeInterceptor(interceptedClasses, receiver, send);
       instruction = new HInvokeDynamicGetter(
@@ skipping 54 matching lines @@
   }
 
   void generateInstanceSetterWithCompiledReceiver(Send send,
                                                   HInstruction receiver,
                                                   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(selector);
+    Set<ClassElement> interceptedClasses =
+        backend.getInterceptedClassesOn(setterName);
     if (interceptedClasses != null) {
       // If we're using an interceptor class, emit a call to the
       // getInterceptor method and then the actual dynamic call on the
       // interceptor object.
       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.
@@ skipping 636 matching lines @@
         constantSystem.createInt(selector.invocationMirrorKind);
 
     pushInvokeHelper5(createInvocationMirror,
                       graph.addConstant(nameConstant),
                       graph.addConstant(internalNameConstant),
                       graph.addConstant(kindConstant),
                       argumentsInstruction,
                       argumentNamesInstruction,
                       HType.UNKNOWN);
 
-    var inputs = <HInstruction>[
-        target,
-        self,
-        pop()];
+    var inputs = <HInstruction>[target, self];
+    if (backend.isInterceptedMethod(element)) {
+      inputs.add(self);
+    }
+    inputs.add(pop());
     push(new HInvokeSuper(inputs));
   }
 
   visitSend(Send node) {
     Element element = elements[node];
     if (element != null && identical(element, currentElement)) {
       graph.isRecursiveMethod = true;
     }
     super.visitSend(node);
   }
 
   visitSuperSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element == null) return generateSuperNoSuchMethodSend(node);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
     HInstruction target = new HStatic(element.declaration);
     HInstruction context = localsHandler.readThis();
     add(target);
     var inputs = <HInstruction>[target, context];
+    if (backend.isInterceptedMethod(element)) {
+      inputs.add(context);
+    }
     if (node.isPropertyAccess) {
       push(new HInvokeSuper(inputs));
     } else if (element.isFunction() || element.isGenerativeConstructor()) {
       // TODO(5347): Try to avoid the need for calling [implementation] before
       // calling [addStaticSendArgumentsToList].
       FunctionElement function = element.implementation;
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     function, inputs);
       if (!succeeded) {
         generateWrongArgumentCountError(node, element, node.arguments);
@@ skipping 419 matching lines @@
           visitNewSend(send, type);
         }
       }
     }
   }
 
   HInvokeDynamicMethod buildInvokeDynamic(Node node,
                                           Selector selector,
                                           HInstruction receiver,
                                           List<HInstruction> arguments) {
-    Set<ClassElement> interceptedClasses = getInterceptedClassesOn(selector);
+    Set<ClassElement> interceptedClasses =
+        backend.getInterceptedClassesOn(selector.name);
     List<HInstruction> inputs = <HInstruction>[];
     bool isIntercepted = interceptedClasses != null;
     if (isIntercepted) {
       assert(!interceptedClasses.isEmpty);
       inputs.add(invokeInterceptor(interceptedClasses, receiver, node));
     }
     inputs.add(receiver);
     inputs.addAll(arguments);
     return new HInvokeDynamicMethod(selector, inputs, isIntercepted);
   }
@@ skipping 333 matching lines @@
     //     E <declaredIdentifier> = $iter.current;
     //     <body>
     //   }
 
     // The iterator is shared between initializer, condition and body.
     HInstruction iterator;
     void buildInitializer() {
       SourceString iteratorName = const SourceString("iterator");
       Selector selector =
           new Selector.getter(iteratorName, currentElement.getLibrary());
-      Set<ClassElement> interceptedClasses = getInterceptedClassesOn(selector);
+      Set<ClassElement> interceptedClasses =
+          backend.getInterceptedClassesOn(selector.name);
       visit(node.expression);
       HInstruction receiver = pop();
       bool hasGetter = compiler.world.hasAnyUserDefinedGetter(selector);
       if (interceptedClasses == null) {
         iterator =
             new HInvokeDynamicGetter(selector, null, receiver, !hasGetter);
       } else {
         HInterceptor interceptor =
             invokeInterceptor(interceptedClasses, receiver, null);
         iterator =
@@ skipping 1098 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;
   }
 }