Stop creating selectors in the SSA builder that were already created by the resolver.

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 2226 matching lines @@
         stack.add(graph.addConstant(folded));
         return;
       }
     }
 
     HInvokeDynamicMethod result =
         buildInvokeDynamic(node, elements.getSelector(node), operand, []);
     pushWithPosition(result, node);
   }
 
-  void visitBinary(
-      HInstruction left, Operator op, HInstruction right, Send send) {
-    Selector selector = null;
-    // TODO(ngeoffray): The resolver creates these selectors already
-    // but does not put them on the [send] instruction.
+  void visitBinary(HInstruction left,
+                   Operator op,
+                   HInstruction right,
+                   Selector selector,
+                   Send send) {
     switch (op.source.stringValue) {
-      case "+":
-      case "+=":
-      case "++":
-        selector = new Selector.binaryOperator(const SourceString('+'));
-        break;
-      case "-":
-      case "-=":
-      case "--":
-        selector = new Selector.binaryOperator(const SourceString('-'));
-        break;
-      case "*":
-      case "*=":
-        selector = new Selector.binaryOperator(const SourceString('*'));
-        break;
-      case "/":
-      case "/=":
-        selector = new Selector.binaryOperator(const SourceString('/'));
-        break;
-      case "~/":
-      case "~/=":
-        selector = new Selector.binaryOperator(const SourceString('~/'));
-        break;
-      case "%":
-      case "%=":
-        selector = new Selector.binaryOperator(const SourceString('%'));
-        break;
-      case "<<":
-      case "<<=":
-        selector = new Selector.binaryOperator(const SourceString('<<'));
-        break;
-      case ">>":
-      case ">>=":
-        selector = new Selector.binaryOperator(const SourceString('>>'));
-        break;
-      case "|":
-      case "|=":
-        selector = new Selector.binaryOperator(const SourceString('|'));
-        break;
-      case "&":
-      case "&=":
-        selector = new Selector.binaryOperator(const SourceString('&'));
-        break;
-      case "^":
-      case "^=":
-        selector = new Selector.binaryOperator(const SourceString('^'));
-        break;
-      case "==":
-      case "!=":
-        selector = new Selector.binaryOperator(const SourceString('=='));
-        break;
-      case "<":
-        selector = new Selector.binaryOperator(const SourceString('<'));
-        break;
-      case "<=":
-        selector = new Selector.binaryOperator(const SourceString('<='));
-        break;
-      case ">":
-        selector = new Selector.binaryOperator(const SourceString('>'));
-        break;
-      case ">=":
-        selector = new Selector.binaryOperator(const SourceString('>='));
-        break;
       case "===":
         pushWithPosition(new HIdentity(left, right), op);
         return;
       case "!==":
         HIdentity eq = new HIdentity(left, right);
         add(eq);
         pushWithPosition(new HNot(eq), op);
         return;
-      default:
-        compiler.internalError("Unexpected operator $op", node: op);
-        break;
     }
 
     pushWithPosition(
           buildInvokeDynamic(send, selector, left, [right]),
           op);
     if (op.source.stringValue == '!=') {
       pushWithPosition(new HNot(popBoolified()), op);
     }
   }
 
@@ skipping 16 matching lines @@
 
   /**
    * Returns a set of interceptor classes that contain a member whose
    * signature matches the given [selector].
    */
   Set<ClassElement> getInterceptedClassesOn(Selector selector) {
     return backend.getInterceptedClassesOn(selector);
   }
 
   void generateInstanceGetterWithCompiledReceiver(Send send,
+                                                  Selector selector,
                                                   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);
 
     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.
@@ skipping 32 matching lines @@
         }
         // TODO(5346): Try to avoid the need for calling [declaration] before
         // creating an [HStatic].
         push(new HStatic(element.declaration));
         if (element.isGetter()) {
           push(new HInvokeStatic(<HInstruction>[pop()], HType.UNKNOWN));
         }
       }
     } else if (Elements.isInstanceSend(send, elements)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
-      generateInstanceGetterWithCompiledReceiver(send, receiver);
+      generateInstanceGetterWithCompiledReceiver(
+          send, elements.getSelector(send), receiver);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       // TODO(5346): Try to avoid the need for calling [declaration] before
       // creating an [HStatic].
       push(new HStatic(element.declaration));
       // TODO(ahe): This should be registered in codegen.
       compiler.enqueuer.codegen.registerGetOfStaticFunction(element);
     } else if (Elements.isErroneousElement(element)) {
       // An erroneous element indicates an unresolved static getter.
       generateThrowNoSuchMethod(send,
                                 getTargetName(element, 'get'),
@@ skipping 272 matching lines @@
       DartType type = elements.getType(typeAnnotation);
       HInstruction converted = expression.convertType(
           compiler, type, HTypeConversion.CAST_TYPE_CHECK);
       if (converted != expression) add(converted);
       stack.add(converted);
     } else {
       visit(node.receiver);
       visit(node.argumentsNode);
       var right = pop();
       var left = pop();
-      visitBinary(left, op, right, node);
+      visitBinary(left, op, right, elements.getSelector(node), node);
     }
   }
 
   void addDynamicSendArgumentsToList(Send node, List<HInstruction> list) {
     Selector selector = elements.getSelector(node);
     if (selector.namedArgumentCount == 0) {
       addGenericSendArgumentsToList(node.arguments, list);
     } else {
       // Visit positional arguments and add them to the list.
       Link<Node> arguments = node.arguments;
@@ skipping 386 matching lines @@
     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);
+    if (Elements.isUnresolved(element)) {
+      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 (node.isPropertyAccess) {
       push(new HInvokeSuper(inputs));
     } else if (element.isFunction() || element.isGenerativeConstructor()) {
       // TODO(5347): Try to avoid the need for calling [implementation] before
@@ skipping 486 matching lines @@
         bool isPrefix = !node.isPostfix;
         if (isCompoundAssignment) {
           value = pop();
           index = pop();
         } else {
           index = pop();
           value = graph.addConstantInt(1, constantSystem);
         }
 
         HInvokeDynamicMethod left = buildInvokeDynamic(
-            node, new Selector.index(), receiver, [index]);
+            node,
+            elements.getGetterSelectorInComplexSendSet(node),
+            receiver,
+            <HInstruction>[index]);
         add(left);
-        visitBinary(left, op, value, node);
+        visitBinary(left, op, value,
+                    elements.getOperatorSelectorInComplexSendSet(node), node);
         value = pop();
         HInvokeDynamicMethod assign = buildInvokeDynamic(
-            node, new Selector.indexSet(), receiver, [index, value]);
+            node, elements.getSelector(node), receiver, [index, value]);
         add(assign);
         if (isPrefix) {
           stack.add(value);
         } else {
           stack.add(left);
         }
       }
     } else if (const SourceString("=") == op.source) {
       Link<Node> link = node.arguments;
       assert(!link.isEmpty && link.tail.isEmpty);
       visit(link.head);
       HInstruction value = pop();
       generateSetter(node, element, value);
     } else if (identical(op.source.stringValue, "is")) {
       compiler.internalError("is-operator as SendSet", node: op);
     } else {
       assert(const SourceString("++") == op.source ||
              const SourceString("--") == op.source ||
              node.assignmentOperator.source.stringValue.endsWith("="));
       bool isCompoundAssignment = !node.arguments.isEmpty;
       bool isPrefix = !node.isPostfix;  // Compound assignments are prefix.
 
       // [receiver] is only used if the node is an instance send.
       HInstruction receiver = null;
       if (Elements.isInstanceSend(node, elements)) {
         receiver = generateInstanceSendReceiver(node);
-        generateInstanceGetterWithCompiledReceiver(node, receiver);
+        generateInstanceGetterWithCompiledReceiver(
+            node, elements.getGetterSelectorInComplexSendSet(node), receiver);
       } else {
         generateGetter(node, elements[node.selector]);
       }
       HInstruction left = pop();
       HInstruction right;
       if (isCompoundAssignment) {
         visit(node.argumentsNode);
         right = pop();
       } else {
         right = graph.addConstantInt(1, constantSystem);
       }
-      visitBinary(left, op, right, node);
+      visitBinary(left, op, right,
+                  elements.getOperatorSelectorInComplexSendSet(node), node);
       HInstruction operation = pop();
       assert(operation != null);
       if (Elements.isInstanceSend(node, elements)) {
         assert(receiver != null);
         generateInstanceSetterWithCompiledReceiver(node, receiver, operation);
       } else {
         assert(receiver == null);
         generateSetter(node, element, operation);
       }
       if (!isPrefix) {
@@ skipping 225 matching lines @@
     // Generate a structure equivalent to:
     //   Iterator<E> $iter = <iterable>.iterator;
     //   while ($iter.moveNext()) {
     //     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());
+      Selector selector = elements.getIteratorSelector(node);
       Set<ClassElement> interceptedClasses = getInterceptedClassesOn(selector);
       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 =
             new HInvokeDynamicGetter(selector, null, interceptor, !hasGetter);
         // Add the receiver as an argument to the getter call on the
         // interceptor.
         iterator.inputs.add(receiver);
       }
       add(iterator);
     }
     HInstruction buildCondition() {
-      SourceString name = const SourceString('moveNext');
-      Selector selector = new Selector.call(
-          name, currentElement.getLibrary(), 0);
+      Selector selector = elements.getMoveNextSelector(node);
       push(new HInvokeDynamicMethod(selector, <HInstruction>[iterator]));
       return popBoolified();
     }
     void buildBody() {
-      SourceString name = const SourceString('current');
-      Selector call = new Selector.getter(name, currentElement.getLibrary());
+      Selector call = elements.getCurrentSelector(node);
       bool hasGetter = compiler.world.hasAnyUserDefinedGetter(call);
       push(new HInvokeDynamicGetter(call, null, iterator, !hasGetter));
 
       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];
@@ skipping 1071 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;
   }
 }