Cleanup after the interceptor refactoring work, and add a new SSA instruction for an interceptor, s…

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 42 matching lines @@
     if (identical(name, '<<=')) return const SourceString('shl');
     if (identical(name, '>>=')) return const SourceString('shr');
     if (identical(name, '|=')) return const SourceString('or');
     if (identical(name, '&=')) return const SourceString('and');
     if (identical(name, '^=')) return const SourceString('xor');
     if (identical(name, '++')) return const SourceString('add');
     if (identical(name, '--')) return const SourceString('sub');
     compiler.unimplemented('Unknown operator', node: op);
   }
 
-  Element getStaticInterceptor(Selector selector) {
-    // Check if we have an interceptor method implemented with
-    // interceptor classes.
+  /**
+   * Returns a set of interceptor classes that contain a member whose
+   * signature matches the given [selector].
+   */
+  Set<ClassElement> getInterceptedClassesOn(Selector selector) {
     JavaScriptBackend backend = compiler.backend;
-    if (backend.shouldInterceptSelector(selector)) {
-      return backend.getInterceptorMethod;
-    }
-
-    // Fall back to the old interceptor mechanism.
-    String name = selector.name.slowToString();
-    if (selector.isGetter()) {
-      // TODO(lrn): If there is no get-interceptor, but there is a
-      // method-interceptor, we should generate a get-interceptor automatically.
-      String mangledName = "get\$$name";
-      return compiler.findInterceptor(new SourceString(mangledName));
-    } else if (selector.isSetter()) {
-      String mangledName = "set\$$name";
-      return compiler.findInterceptor(new SourceString(mangledName));
-    } else {
-      Element element = compiler.findInterceptor(new SourceString(name));
-      if (element != null && element.isFunction()) {
-        // Only pick the function element with the short name if the
-        // number of parameters it expects matches the number we're
-        // passing modulo the receiver.
-        FunctionElement function = element;
-        if (function.parameterCount(compiler) == selector.argumentCount + 1) {
-          return element;
-        }
-      }
-      String longMangledName = "$name\$${selector.argumentCount}";
-      return compiler.findInterceptor(new SourceString(longMangledName));
-    }
+    return backend.getInterceptedClassesOn(selector);
   }
 
   Element getOperatorInterceptor(Operator op) {
     SourceString name = mapOperatorToMethodName(op);
     return compiler.findHelper(name);
   }
 
   Element getBoolifiedVersionOf(Element interceptor) {
     if (interceptor == null) return interceptor;
     String boolifiedName = "${interceptor.name.slowToString()}B";
@@ skipping 2297 matching lines @@
   }
 
   String getTargetName(ErroneousElement error, [String prefix]) {
     String result = error.name.slowToString();
     if (?prefix) {
       result = '$prefix $result';
     }
     return result;
   }
 
-  Element getInterceptor(Send send, Selector selector) {
+  Set<ClassElement> getInterceptedClassesOn(Send send, Selector selector) {
     if (!methodInterceptionEnabled) return null;
     if (!backend.isInterceptorClass(currentElement.getEnclosingClass())
         && send.receiver == null) {
       // The call applies to [:this:] which can not be an interceptor
       // object.
       return null;
     }
-    return interceptors.getStaticInterceptor(selector);
+    return interceptors.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;
-    Element interceptor = getInterceptor(send, selector);
+    Set<ClassElement> interceptedClasses = getInterceptedClassesOn(send, selector);

[Johnni Winther, 2012/11/21 13:36:56]

Long line

[ngeoffray, 2012/11/21 13:41:05]

Done.

 
     bool hasGetter = compiler.world.hasAnyUserDefinedGetter(selector);
-    if (interceptor == backend.getInterceptorMethod && interceptor != null) {
+    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(interceptor, receiver);
+        pushInvokeInterceptor(interceptedClasses, receiver);
         instruction = pop();
       }
       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(
@@ skipping 40 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;
-    Element interceptor = getInterceptor(send, selector);
     bool hasSetter = compiler.world.hasAnyUserDefinedSetter(selector);
-    if (interceptor != null && interceptor == backend.getInterceptorMethod) {
+    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
       // interceptor object.
       HInstruction instruction;
       if (backend.isInterceptorClass(currentElement.getEnclosingClass())
           && send.receiver == null) {
         instruction = thisInstruction;
       } else {
-        pushInvokeInterceptor(interceptor, receiver);
+        pushInvokeInterceptor(interceptedClasses, receiver);
         instruction = pop();
       }
       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(
@@ skipping 31 matching lines @@
       HInstruction checked = potentiallyCheckType(
           value, element.computeType(compiler));
       if (!identical(checked, value)) {
         pop();
         stack.add(checked);
       }
       localsHandler.updateLocal(element, checked);
     }
   }
 
-  void pushInvokeInterceptor(Element element, HInstruction receiver) {
-    HInstruction interceptor = new HStatic(element);
-    add(interceptor);
-    List<HInstruction> inputs = <HInstruction>[interceptor, receiver];
-    HInstruction result = new HInvokeStatic(inputs);
-    result.isSideEffectFree = true;
-    push(result);
+  void pushInvokeInterceptor(Set<ClassElement> intercepted,
+                             HInstruction receiver) {
+    push(new HInterceptor(intercepted, receiver));
   }
 
   void pushInvokeHelper0(Element helper) {
     HInstruction reference = new HStatic(helper);
     add(reference);
     List<HInstruction> inputs = <HInstruction>[reference];
     HInstruction result = new HInvokeStatic(inputs);
     push(result);
   }
 
@@ skipping 199 matching lines @@
           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;
     }
 
-    Element interceptor = getInterceptor(node, selector);
+    Set<ClassElement> interceptedClasses =
+        getInterceptedClassesOn(node, selector);
 
-    if (interceptor != null) {
-      if (interceptor == backend.getInterceptorMethod) {
-        if (backend.isInterceptorClass(currentElement.getEnclosingClass())
-            && node.receiver == null) {
-          inputs.add(thisInstruction);
-          inputs.add(localsHandler.readThis());
-        } else {
-          visit(node.receiver);
-          HInstruction receiver = pop();
-          pushInvokeInterceptor(interceptor, 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;
+    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;
       }
     }
 
     if (node.receiver == null) {
@@ skipping 1030 matching lines @@
     //     E <declaredIdentifier> = $iter.next();
     //     <body>
     //   }
 
     // The iterator is shared between initializer, condition and body.
     HInstruction iterator;
     void buildInitializer() {
       SourceString iteratorName = const SourceString("iterator");
       Selector selector =
           new Selector.call(iteratorName, work.element.getLibrary(), 0);
-      Element element = interceptors.getStaticInterceptor(selector);
+      Set<ClassElement> interceptedClasses =
+          interceptors.getInterceptedClassesOn(selector);
       visit(node.expression);
       HInstruction receiver = pop();
-      if (element == null) {
+      if (interceptedClasses == null) {
         iterator = new HInvokeDynamicMethod(selector, <HInstruction>[receiver]);
       } else {
-        pushInvokeInterceptor(element, receiver);
-        HInvokeStatic interceptor = pop();
+        pushInvokeInterceptor(interceptedClasses, receiver);
+        HInterceptor interceptor = pop();
         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());
-      if (interceptors.getStaticInterceptor(selector) != null) {
-        compiler.internalError("hasNext getter must not be intercepted",
-                               node: node);
-      }
       bool hasGetter = compiler.world.hasAnyUserDefinedGetter(selector);
       push(new HInvokeDynamicGetter(selector, null, iterator, !hasGetter));
       return popBoolified();
     }
     void buildBody() {
       SourceString name = const SourceString('next');
       Selector call = new Selector.call(name, work.element.getLibrary(), 0);
       push(new HInvokeDynamicMethod(call, <HInstruction>[iterator]));
 
       Element variable;
@@ skipping 1059 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;
   }
 }