Cleanup how we query for interceptors.

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;
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 27 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);
   }
 
-  // TODO(karlklose,kasperl): change uses of getStatic[Get|Set]Interceptor to
-  // use this function.
-  Element getStaticInterceptorBySelector(Selector selector) {
+  Element getStaticInterceptor(Selector selector) {
+    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.
-      return getStaticGetInterceptor(selector.name);
+      String mangledName = "get\$$name";
+      return compiler.findInterceptor(new SourceString(mangledName));
     } else if (selector.isSetter()) {
-      return getStaticSetInterceptor(selector.name);
+      String mangledName = "set\$$name";
+      return compiler.findInterceptor(new SourceString(mangledName));
     } else {
-      return getStaticInterceptor(selector.name, selector.argumentCount);
+      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));
     }
   }
 
-  Element getStaticInterceptor(SourceString name, int parameters) {
-    String mangledName = name.slowToString();
-    Element element = compiler.findInterceptor(new SourceString(mangledName));
-    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) == parameters + 1) return element;
-    }
-    String longMangledName = "$mangledName\$$parameters";
-    return compiler.findInterceptor(new SourceString(longMangledName));
-  }
-
-  Element getStaticGetInterceptor(SourceString name) {
-    String mangledName = "get\$${name.slowToString()}";
-    return compiler.findInterceptor(new SourceString(mangledName));
-  }
-
-  Element getStaticSetInterceptor(SourceString name) {
-    String mangledName = "set\$${name.slowToString()}";
-    return compiler.findInterceptor(new SourceString(mangledName));
-  }
-
   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";
     return compiler.findHelper(new SourceString(boolifiedName));
   }
@@ skipping 2181 matching lines @@
     // 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 staticInterceptor = null;
     if (elements[send] == null && methodInterceptionEnabled) {
-      staticInterceptor = interceptors.getStaticGetInterceptor(getterName);
+      staticInterceptor = interceptors.getStaticInterceptor(selector);
     }
     bool hasGetter = compiler.world.hasAnyUserDefinedGetter(selector);
     if (staticInterceptor != null) {
       HStatic target = new HStatic(staticInterceptor);
       add(target);
       List<HInstruction> inputs = <HInstruction>[target, receiver];
       pushWithPosition(new HInvokeInterceptor(selector, inputs, !hasGetter),
                        send);
     } else {
       pushWithPosition(
@@ skipping 42 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 staticInterceptor = null;
     if (elements[send] == null && methodInterceptionEnabled) {
-      staticInterceptor = interceptors.getStaticSetInterceptor(setterName);
+      staticInterceptor = interceptors.getStaticInterceptor(selector);
     }
     bool hasSetter = compiler.world.hasAnyUserDefinedSetter(selector);
     if (staticInterceptor != null) {
       HStatic target = new HStatic(staticInterceptor);
       add(target);
       List<HInstruction> inputs = <HInstruction>[target, receiver, value];
       addWithPosition(new HInvokeInterceptor(selector, inputs), send);
     } else {
       addWithPosition(
           new HInvokeDynamicSetter(selector, null, receiver, value, !hasSetter),
@@ skipping 249 matching lines @@
       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 = null;
     if (methodInterceptionEnabled && elements[node] == null) {
-      interceptor = interceptors.getStaticInterceptor(dartMethodName,
-                                                      node.argumentCount());
+      interceptor = interceptors.getStaticInterceptor(selector);
     }
     if (interceptor != null) {
       HStatic target = new HStatic(interceptor);
       add(target);
       inputs.add(target);
       visit(node.receiver);
       inputs.add(pop());
       addGenericSendArgumentsToList(node.arguments, inputs);
       pushWithPosition(new HInvokeInterceptor(selector, inputs), node);
       return;
@@ skipping 1047 matching lines @@
     //   Iterator<E> $iter = <iterable>.iterator()
     //   while ($iter.hasNext) {
     //     E <declaredIdentifier> = $iter.next();
     //     <body>
     //   }
 
     // The iterator is shared between initializer, condition and body.
     HInstruction iterator;
     void buildInitializer() {
       SourceString iteratorName = const SourceString("iterator");
-      Element interceptor = interceptors.getStaticInterceptor(iteratorName, 0);
+      Selector selector =
+          new Selector.call(iteratorName, work.element.getLibrary(), 0);
+      Element interceptor = interceptors.getStaticInterceptor(selector);
       assert(interceptor != null);
       visit(node.expression);
       pushInvokeHelper1(interceptor, pop());
       iterator = pop();
     }
     HInstruction buildCondition() {
       SourceString name = const SourceString('hasNext');
       Selector selector = new Selector.getter(name, work.element.getLibrary());
-      if (interceptors.getStaticGetInterceptor(name) != null) {
+      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);
@@ skipping 1062 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;
   }
 }