Add name and library to selectors.

lib/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 971 matching lines @@
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
       ClassElement enclosingClass = constructor.getEnclosingClass();
       ClassElement superClass = enclosingClass.superclass;
       if (enclosingClass != compiler.objectClass) {
         assert(superClass !== null);
         assert(superClass.resolutionState == ClassElement.STATE_DONE);
+        Selector selector =
+            new Selector.call(superClass.name, enclosingClass.getLibrary(), 0);
         FunctionElement target = superClass.lookupConstructor(superClass.name);
         if (target === null) {
           compiler.internalError("no default constructor available");
         }
         inlineSuperOrRedirect(target,
-                              Selector.INVOCATION_0,
+                              selector,
                               const EmptyLink<Node>(),
                               constructors,
                               fieldValues);
       }
     }
   }
 
   /**
    * Build the factory function corresponding to the constructor
    * [functionElement]:
@@ skipping 758 matching lines @@
     }
   }
 
   void generateGetter(Send send, Element element) {
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.kind == ElementKind.FIELD && !element.isAssignable()) {
         // A static final. Get its constant value and inline it.
         Constant value = compiler.constantHandler.compileVariable(element);
         stack.add(graph.addConstant(value));
       } else {
-        Selector selector = elements.getSelector(send);
         push(new HStatic(element));
         if (element.kind == ElementKind.GETTER) {
-          push(new HInvokeStatic(selector, <HInstruction>[pop()]));
+          push(new HInvokeStatic(<HInstruction>[pop()]));
         }
       }
     } else if (Elements.isInstanceSend(send, elements)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceGetterWithCompiledReceiver(send, receiver);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       push(new HStatic(element));
       // TODO(ahe): This should be registered in codegen.
       compiler.enqueuer.codegen.registerGetOfStaticFunction(element);
     } else {
@@ skipping 19 matching lines @@
           selector, dartSetterName, inputs, setter: true));
     } else {
       add(new HInvokeDynamicSetter(selector, null, dartSetterName,
                                    receiver, value));
     }
     stack.add(value);
   }
 
   void generateSetter(SendSet send, Element element, HInstruction value) {
     if (Elements.isStaticOrTopLevelField(element)) {
-      Selector selector = elements.getSelector(send);
       if (element.kind == ElementKind.SETTER) {
         HStatic target = new HStatic(element);
         add(target);
-        add(new HInvokeStatic(selector, <HInstruction>[target, value]));
+        add(new HInvokeStatic(<HInstruction>[target, value]));
       } else {
         add(new HStaticStore(element, value));
       }
       stack.add(value);
     } else if (element === null || Elements.isInstanceField(element)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceSetterWithCompiledReceiver(send, receiver, value);
     } else {
       stack.add(value);
       // If the value does not already have a name, give it here.
       if (value.sourceElement === null) {
         value.sourceElement = element;
       }
       HInstruction checked = potentiallyCheckType(value, element);
       if (checked !== value) {
         pop();
         stack.add(checked);
       }
       localsHandler.updateLocal(element, checked);
     }
   }
 
+  void pushInvokeHelper0(Element helper) {
+    HInstruction reference = new HStatic(helper);
+    add(reference);
+    List<HInstruction> inputs = <HInstruction>[reference];
+    HInstruction result = new HInvokeStatic(inputs);
+    push(result);
+  }
+
+  void pushInvokeHelper1(Element helper, HInstruction a0) {
+    HInstruction reference = new HStatic(helper);
+    add(reference);
+    List<HInstruction> inputs = <HInstruction>[reference, a0];
+    HInstruction result = new HInvokeStatic(inputs);
+    push(result);
+  }
+
+  void pushInvokeHelper2(Element helper, HInstruction a0, HInstruction a1) {
+    HInstruction reference = new HStatic(helper);
+    add(reference);
+    List<HInstruction> inputs = <HInstruction>[reference, a0, a1];
+    HInstruction result = new HInvokeStatic(inputs);
+    push(result);
+  }
+
   visitOperatorSend(node) {
     assert(node.selector is Operator);
     if (!methodInterceptionEnabled) {
       visitDynamicSend(node);
       return;
     }
 
     Operator op = node.selector;
     if (const SourceString("[]") == op.source) {
       HStatic target = new HStatic(interceptors.getIndexInterceptor());
@@ skipping 19 matching lines @@
       // TODO(ngeoffray): Duplicating pattern in resolver. We should
       // add a new kind of node.
       if (typeAnnotation == null) {
         typeAnnotation = argument.asSend().receiver;
         isNot = true;
       }
 
       Type type = elements.getType(typeAnnotation);
       HInstruction typeInfo = null;
       if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
-        HInstruction typeInfoGetter =
-            new HStatic(interceptors.getGetRuntimeTypeInfo());
-        add(typeInfoGetter);
-        typeInfo = new HInvokeStatic(Selector.INVOCATION_1,
-                                     <HInstruction>[typeInfoGetter,
-                                                    expression]);
-        add(typeInfo);
+        pushInvokeHelper1(interceptors.getGetRuntimeTypeInfo(), expression);
+        typeInfo = pop();
       }
       if (type.element.kind === ElementKind.TYPE_VARIABLE) {
         // TODO(karlklose): We emulate the frog behavior and answer
         // true to any is check involving a type variable -- both is T
         // and is !T -- until we have a proper implementation of
         // reified generics.
         stack.add(graph.addConstantBool(true));
       } else {
         HInstruction instruction;
         if (typeInfo !== null) {
@@ skipping 233 matching lines @@
     } else {
       // Call a helper method from the isolate library. The isolate
       // library uses its own isolate structure, that encapsulates
       // Leg's isolate.
       Element element = compiler.isolateLibrary.find(
           const SourceString('_currentIsolate'));
       if (element === null) {
         compiler.cancel(
             'Isolate library and compiler mismatch', node: node);
       }
-      HStatic target = new HStatic(element);
-      add(target);
-      push(new HInvokeStatic(Selector.INVOCATION_0,
-                             <HInstruction>[target]));
+      pushInvokeHelper0(element);
     }
   }
 
   void handleForeignJsCallInIsolate(Send node) {
     Link<Node> link = node.arguments;
     if (!compiler.hasIsolateSupport()) {
       // If the isolate library is not used, we just invoke the
       // closure.
       visit(link.tail.head);
-      push(new HInvokeClosure(Selector.INVOCATION_0,
-                              <HInstruction>[pop()]));
+      Selector selector = new Selector.callAny(0);
+      push(new HInvokeClosure(selector, <HInstruction>[pop()]));
     } else {
       // Call a helper method from the isolate library.
       Element element = compiler.isolateLibrary.find(
           const SourceString('_callInIsolate'));
       if (element === null) {
         compiler.cancel(
             'Isolate library and compiler mismatch', node: node);
       }
       HStatic target = new HStatic(element);
       add(target);
       List<HInstruction> inputs = <HInstruction>[target];
       addGenericSendArgumentsToList(link, inputs);
-      push(new HInvokeStatic(Selector.INVOCATION_0, inputs));
+      push(new HInvokeStatic(inputs));
     }
   }
 
   void handleForeignDartClosureToJs(Send node) {
     if (node.arguments.isEmpty() || !node.arguments.tail.isEmpty()) {
       compiler.cancel('Exactly one argument required',
                       node: node.argumentsNode);
     }
     Node closure = node.arguments.head;
     Element element = elements[closure];
     if (!Elements.isStaticOrTopLevelFunction(element)) {
       compiler.cancel(
           'JS_TO_CLOSURE requires a static or top-level method',
           node: closure);
     }
     FunctionElement function = element;
     FunctionSignature params = function.computeSignature(compiler);
     if (params.optionalParameterCount !== 0) {
       compiler.cancel(
           'JS_TO_CLOSURE does not handle closure with optional parameters',
           node: closure);
     }
     visit(closure);
     List<HInstruction> inputs = <HInstruction>[pop()];
     String invocationName = compiler.namer.closureInvocationName(
-        new Selector.invocation(params.requiredParameterCount));
+        new Selector.callAny(params.requiredParameterCount));
     push(new HForeign(new DartString.literal('#.$invocationName'),
                       const LiteralDartString('var'),
                       inputs));
   }
 
   visitForeignSend(Send node) {
     Element element = elements[node];
     if (element.name == const SourceString('JS')) {
       handleForeignJs(node);
     } else if (element.name == const SourceString('UNINTERCEPTED')) {
@@ skipping 19 matching lines @@
     HInstruction self = localsHandler.readThis();
     Identifier identifier = node.selector.asIdentifier();
     String name = identifier.source.slowToString();
     // TODO(ahe): Add the arguments to this list.
     push(new HLiteralList([]));
     var inputs = <HInstruction>[
         target,
         self,
         graph.addConstantString(new DartString.literal(name), node),
         pop()];
-    push(new HInvokeSuper(Selector.INVOCATION_2, inputs));
+    push(new HInvokeSuper(inputs));
   }
 
   visitSend(Send node) {
     Element element = elements[node];
     if (element !== null && element === work.element) {
       graph.isRecursiveMethod = true;
     }
     super.visitSend(node);
   }
 
   visitSuperSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element === null) return generateSuperNoSuchMethodSend(node);
     HInstruction target = new HStatic(element);
     HInstruction context = localsHandler.readThis();
     add(target);
     var inputs = <HInstruction>[target, context];
     if (node.isPropertyAccess) {
-      push(new HInvokeSuper(selector, inputs));
+      push(new HInvokeSuper(inputs));
     } else if (element.kind == ElementKind.FUNCTION ||
                element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element, inputs);
       if (!succeeded) {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented non-matching static call', node);
       }
-      push(new HInvokeSuper(selector, inputs));
+      push(new HInvokeSuper(inputs));
     } else {
-      target = new HInvokeSuper(Selector.GETTER, inputs);
+      target = new HInvokeSuper(inputs);
       add(target);
       inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       push(new HInvokeClosure(selector, inputs));
     }
   }
 
   visitNewSend(Send node) {
     computeType(element) {
       Element originalElement = elements[node];
@@ skipping 24 matching lines @@
     inputs.add(target);
     bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                   element, inputs);
     if (!succeeded) {
       // TODO(ngeoffray): Match the VM behavior and throw an
       // exception at runtime.
       compiler.cancel('Unimplemented non-matching static call', node: node);
     }
 
     HType elementType = computeType(element);
-    HInstruction newInstance = new HInvokeStatic(selector, inputs, elementType);
+    HInstruction newInstance = new HInvokeStatic(inputs, elementType);
     pushWithPosition(newInstance, node);
 
     TypeAnnotation annotation = getTypeAnnotationFromSend(node);
     Type type = elements.getType(annotation);
     generateSetRuntimeTypeInformation(newInstance, type);
   }
 
   generateSetRuntimeTypeInformation(HInstruction instance, Type type) {
     if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
       String typeString = compiler.codegenWorld.rti.asJsString(type);
       HInstruction typeInfo = new HForeign(new LiteralDartString(typeString),
                                            new LiteralDartString('Object'),
                                            <HInstruction>[]);
       add(typeInfo);
-      HInstruction typeInfoSetter =
-          new HStatic(interceptors.getSetRuntimeTypeInfo());
+      Element typeInfoSetterElement = interceptors.getSetRuntimeTypeInfo();
+      HInstruction typeInfoSetter = new HStatic(typeInfoSetterElement);
       add(typeInfoSetter);
-      Selector setSelector = Selector.INVOCATION_2;
       var inputs = <HInstruction>[typeInfoSetter, instance, typeInfo];
-      add(new HInvokeStatic(setSelector, inputs));
+      add(new HInvokeStatic(inputs));
     }
   }
 
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element === compiler.assertMethod && !compiler.enableUserAssertions) {
       stack.add(graph.addConstantNull());
       return;
     }
     compiler.ensure(element.kind !== ElementKind.GENERATIVE_CONSTRUCTOR);
     HInstruction target = new HStatic(element);
     add(target);
     var inputs = <HInstruction>[];
     inputs.add(target);
     if (element.kind == ElementKind.FUNCTION) {
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element, inputs);
       if (!succeeded) {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented non-matching static call', node: node);
       }
-      pushWithPosition(new HInvokeStatic(selector, inputs), node);
+      pushWithPosition(new HInvokeStatic(inputs), node);
     } else {
       if (element.kind == ElementKind.GETTER) {
-        target = new HInvokeStatic(Selector.GETTER, inputs);
+        target = new HInvokeStatic(inputs);
         add(target);
         inputs = <HInstruction>[target];
       }
       addDynamicSendArgumentsToList(node, inputs);
       pushWithPosition(new HInvokeClosure(selector, inputs), node);
     }
   }
 
   visitGetterSend(Send node) {
     generateGetter(node, elements[node]);
@@ skipping 25 matching lines @@
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
       stack.add(graph.addConstant(constant));
     } else {
       visitNewSend(node.send);
     }
   }
 
   visitSendSet(SendSet node) {
     Operator op = node.assignmentOperator;
     if (node.isSuperCall) {
-      Selector selector = elements.getSelector(node);
       Element element = elements[node];
       if (element === null) return generateSuperNoSuchMethodSend(node);
       HInstruction target = new HStatic(element);
       HInstruction context = localsHandler.readThis();
       add(target);
       var inputs = <HInstruction>[target, context];
       addDynamicSendArgumentsToList(node, inputs);
-      push(new HInvokeSuper(selector, inputs));
+      push(new HInvokeSuper(inputs));
     } else if (node.isIndex) {
       if (!methodInterceptionEnabled) {
         assert(op.source.stringValue === '=');
         visitDynamicSend(node);
       } else {
         HStatic target = new HStatic(
             interceptors.getIndexAssignmentInterceptor());
         add(target);
         visit(node.receiver);
         HInstruction receiver = pop();
@@ skipping 285 matching lines @@
   }
 
   visitForIn(ForIn node) {
     // Generate a structure equivalent to:
     //   Iterator<E> $iter = <iterable>.iterator()
     //   while ($iter.hasNext()) {
     //     E <declaredIdentifier> = $iter.next();
     //     <body>
     //   }
 
-    // All the generated calls are to zero-argument functions.
-    Selector selector = Selector.INVOCATION_0;
     // The iterator is shared between initializer, condition and body.
     HInstruction iterator;
     void buildInitializer() {
       SourceString iteratorName = const SourceString("iterator");
       Element interceptor = interceptors.getStaticInterceptor(iteratorName, 0);
       assert(interceptor != null);
-      HStatic target = new HStatic(interceptor);
-      add(target);
       visit(node.expression);
-      List<HInstruction> inputs = <HInstruction>[target, pop()];
-      iterator = new HInvokeInterceptor(selector, iteratorName, inputs);
-      add(iterator);
+      pushInvokeHelper1(interceptor, pop());
+      iterator = pop();
     }
     HInstruction buildCondition() {
-      push(new HInvokeDynamicMethod(
-           selector, const SourceString('hasNext'), <HInstruction>[iterator]));
+      SourceString name = const SourceString('hasNext');
+      Selector call = new Selector.call(name, work.element.getLibrary(), 0);
+      push(new HInvokeDynamicMethod(call, name, <HInstruction>[iterator]));
       return popBoolified();
     }
     void buildBody() {
-      push(new HInvokeDynamicMethod(
-           selector, const SourceString('next'), <HInstruction>[iterator]));
+      SourceString name = const SourceString('next');
+      Selector call = new Selector.call(name, work.element.getLibrary(), 0);
+      push(new HInvokeDynamicMethod(call, name, <HInstruction>[iterator]));
 
       Element variable;
       if (node.declaredIdentifier.asSend() !== null) {
         variable = elements[node.declaredIdentifier];
       } else {
         assert(node.declaredIdentifier.asVariableDefinitions() !== null);
         VariableDefinitions variableDefinitions = node.declaredIdentifier;
         variable = elements[variableDefinitions.definitions.nodes.head];
       }
       localsHandler.updateLocal(variable, pop());
@@ skipping 65 matching lines @@
     }
     List<HInstruction> inputs = <HInstruction>[];
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty();
          link = link.tail) {
       visit(link.head);
       inputs.addLast(pop());
       inputs.addLast(pop());
     }
     HLiteralList keyValuePairs = new HLiteralList(inputs);
-    HStatic mapMaker = new HStatic(interceptors.getMapMaker());
     add(keyValuePairs);
-    add(mapMaker);
-    inputs = <HInstruction>[mapMaker, keyValuePairs];
-    // TODO(ngeoffray): give the concrete type of our map literal.
-    push(new HInvokeStatic(Selector.INVOCATION_1, inputs, HType.UNKNOWN));
+    pushInvokeHelper1(interceptors.getMapMaker(), keyValuePairs);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
@@ skipping 109 matching lines @@
       if (switchCase.isDefaultCase) {
         // An HSwitch has n inputs and n+1 successors, the last being the
         // default case.
         expressionBlock.addSuccessor(block);
         hasDefault = true;
       }
       open(block);
       localsHandler = new LocalsHandler.from(savedLocals);
       visit(switchCase.statements);
       if (!isAborted() && caseIterator.hasNext()) {
-        push(new HStatic(getFallThroughErrorElement));
-        HInstruction error = new HInvokeStatic(
-             Selector.INVOCATION_0, <HInstruction>[pop()]);
-        add(error);
+        pushInvokeHelper0(getFallThroughErrorElement);
+        HInstruction error = pop();
         close(new HThrow(error));
       }
       statements.add(
           new HSubGraphBlockInformation(new SubGraph(block, lastOpenedBlock)));
     }
 
     // Add a join-block if necessary.
     // We create [joinBlock] early, and then go through the cases that might
     // want to jump to it. In each case, if we add [joinBlock] as a successor
     // of another block, we also add an element to [caseLocals] that is used
@@ skipping 60 matching lines @@
 
     SwitchCase node = cases.head;
     // Called for the statements on all but the last case block.
     // Ensures that a user expecting a fallthrough gets an error.
     void visitStatementsAndAbort() {
       visit(node.statements);
       if (!isAborted()) {
         compiler.reportWarning(node, 'Missing break at end of switch case');
         Element element =
             compiler.findHelper(const SourceString("getFallThroughError"));
-        push(new HStatic(element));
-        HInstruction error = new HInvokeStatic(
-             Selector.INVOCATION_0, <HInstruction>[pop()]);
-        add(error);
+        pushInvokeHelper0(element);
+        HInstruction error = pop();
         close(new HThrow(error));
       }
     }
 
     Link<Node> skipLabels(Link<Node> labelsAndCases) {
       while (!labelsAndCases.isEmpty() && labelsAndCases.head is Label) {
         labelsAndCases = labelsAndCases.tail;
       }
       return labelsAndCases;
     }
@@ skipping 132 matching lines @@
       HBasicBlock block = graph.addNewBlock();
       enterBlock.addSuccessor(block);
       open(block);
       // Note that the name of this element is irrelevant.
       Element element = new Element(
           const SourceString('exception'), ElementKind.PARAMETER, work.element);
       exception = new HParameterValue(element);
       add(exception);
       HInstruction oldRethrowableException = rethrowableException;
       rethrowableException = exception;
-      push(new HStatic(interceptors.getExceptionUnwrapper()));
-      List<HInstruction> inputs = <HInstruction>[pop(), exception];
-      HInvokeStatic unwrappedException =
-          new HInvokeStatic(Selector.INVOCATION_1, inputs);
-      add(unwrappedException);
+
+      pushInvokeHelper1(interceptors.getExceptionUnwrapper(), exception);
+      HInvokeStatic unwrappedException = pop();
       tryInstruction.exception = exception;
-
       Link<Node> link = node.catchBlocks.nodes;
 
       void pushCondition(CatchBlock catchBlock) {
         VariableDefinitions declaration = catchBlock.formals.nodes.head;
         HInstruction condition = null;
         if (declaration.type == null) {
           condition = graph.addConstantBool(true);
           stack.add(condition);
         } else {
           Type type = elements.getType(declaration.type);
           if (type == null) {
             compiler.cancel('Catch with unresolved type', node: catchBlock);
           }
           condition = new HIs(type, unwrappedException, nullOk: true);
           push(condition);
         }
       }
 
       void visitThen() {
         CatchBlock catchBlock = link.head;
         link = link.tail;
         localsHandler.updateLocal(elements[catchBlock.exception],
                                   unwrappedException);
         Node trace = catchBlock.trace;
         if (trace != null) {
-          push(new HStatic(interceptors.getTraceFromException()));
-          HInstruction traceInstruction = new HInvokeStatic(
-              Selector.INVOCATION_1, <HInstruction>[pop(), exception]);
-          add(traceInstruction);
+          pushInvokeHelper1(interceptors.getTraceFromException(), exception);
+          HInstruction traceInstruction = pop();
           localsHandler.updateLocal(elements[trace], traceInstruction);
         }
         visit(catchBlock);
       }
 
       void visitElse() {
         if (link.isEmpty()) {
           close(new HThrow(exception, isRethrow: true));
         } else {
           CatchBlock newBlock = link.head;
@@ skipping 363 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;
   }
 }