Use CallStructure instead of Selector in SemanticSendVisitor.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 202 matching lines @@
       FunctionElement target,
       List<ir.Primitive> arguments);
 
   /// Normalizes the argument list of a dynamic invocation (i.e. where the
   /// target element is unknown).
   ///
   /// For the JS backend, normalizes order of named arguments.
   ///
   /// For the Dart backend, returns [arguments].
   List<ir.Primitive> normalizeDynamicArguments(
-      Selector selector,
+      CallStructure callStructure,
       List<ir.Primitive> arguments);
 
   ir.RootNode _makeFunctionBody(FunctionElement element,
                                 ast.FunctionExpression node) {
     FunctionSignature signature = element.functionSignature;
     List<ParameterElement> parameters = [];
     signature.orderedForEachParameter(parameters.add);
 
     irBuilder.buildFunctionHeader(parameters,
                                   closureScope: getClosureScopeForNode(node),
@@ skipping 423 matching lines @@
     return visit(node.expression);
   }
 
   @override
   ir.Primitive visitExpressionInvoke(ast.Send node,
                                      ast.Node expression,
                                      ast.NodeList arguments,
                                      Selector selector, _) {
     ir.Primitive receiver = visit(expression);
     List<ir.Primitive> arguments = node.arguments.mapToList(visit);
-    arguments = normalizeDynamicArguments(selector, arguments);
-    return irBuilder.buildCallInvocation(receiver, selector, arguments);
+    arguments = normalizeDynamicArguments(selector.callStructure, arguments);
+    return irBuilder.buildCallInvocation(
+        receiver, selector.callStructure, arguments);
   }
 
   /// Returns `true` if [node] is a super call.
   // TODO(johnniwinther): Remove the need for this.
   bool isSuperCall(ast.Send node) {
     return node != null && node.receiver != null && node.receiver.isSuper();
   }
 
   @override
   ir.Primitive handleConstantGet(
@@ skipping 174 matching lines @@
         isTypeTest: true,
         isNotCheck: true);
   }
 
   ir.Primitive translateBinary(ast.Node left,
                                op.BinaryOperator operator,
                                ast.Node right) {
     Selector selector = new Selector.binaryOperator(operator.selectorName);
     ir.Primitive receiver = visit(left);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(right)];
-    arguments = normalizeDynamicArguments(selector, arguments);
+    arguments = normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(receiver, selector, arguments);
   }
 
   @override
   ir.Primitive visitBinary(ast.Send node,
                            ast.Node left,
                            op.BinaryOperator operator,
                            ast.Node right, _) {
     return translateBinary(left, operator, right);
   }
 
   @override
   ir.Primitive visitIndex(ast.Send node,
                           ast.Node receiver,
                           ast.Node index, _) {
     Selector selector = new Selector.index();
     ir.Primitive target = visit(receiver);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(index)];
-    arguments = normalizeDynamicArguments(selector, arguments);
+    arguments = normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(target, selector, arguments);
   }
 
   ir.Primitive translateSuperBinary(FunctionElement function,
                                     op.BinaryOperator operator,
                                     ast.Node argument) {
-    Selector selector = new Selector.binaryOperator(operator.selectorName);
+    CallStructure callStructure = CallStructure.ONE_ARG;
     List<ir.Primitive> arguments = <ir.Primitive>[visit(argument)];
-    arguments = normalizeDynamicArguments(selector, arguments);
-    return irBuilder.buildSuperMethodInvocation(function, selector, arguments);
+    arguments = normalizeDynamicArguments(callStructure, arguments);
+    return irBuilder.buildSuperMethodInvocation(
+        function, callStructure, arguments);
   }
 
   @override
   ir.Primitive visitSuperBinary(
       ast.Send node,
       FunctionElement function,
       op.BinaryOperator operator,
       ast.Node argument,
       _) {
     return translateSuperBinary(function, operator, argument);
   }
 
   @override
   ir.Primitive visitSuperIndex(
       ast.Send node,
       FunctionElement function,
       ast.Node index,
       _) {
-    Selector selector = new Selector.index();
-    List<ir.Primitive> arguments = <ir.Primitive>[visit(index)];
-    arguments = normalizeDynamicArguments(selector, arguments);
-    return irBuilder.buildSuperMethodInvocation(function, selector, arguments);
+    return irBuilder.buildSuperIndex(function, visit(index));
   }
 
   @override
   ir.Primitive visitEquals(
       ast.Send node,
       ast.Node left,
       ast.Node right,
       _) {
     return translateBinary(left, op.BinaryOperator.EQ, right);
   }
@@ skipping 46 matching lines @@
     ir.Primitive receiver = translateReceiver(expression);
     return irBuilder.buildDynamicInvocation(receiver, selector, const []);
   }
 
   @override
   ir.Primitive visitSuperUnary(
       ast.Send node,
       op.UnaryOperator operator,
       FunctionElement function,
       _) {
-    // TODO(johnniwinther): Clean up the creation of selectors.
-    Selector selector = new Selector(
-        SelectorKind.OPERATOR,
-        new PublicName(operator.selectorName),
-        CallStructure.NO_ARGS);
-    return irBuilder.buildSuperMethodInvocation(function, selector, const []);
+    return irBuilder.buildSuperMethodInvocation(
+        function, CallStructure.NO_ARGS, const []);
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
   List<ir.Primitive> translateDynamicArguments(ast.NodeList nodeList,
-                                               Selector selector) {
+                                               CallStructure callStructure) {
     List<ir.Primitive> arguments = nodeList.nodes.mapToList(visit);
-    return normalizeDynamicArguments(selector, arguments);
+    return normalizeDynamicArguments(callStructure, arguments);
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
   List<ir.Primitive> translateStaticArguments(ast.NodeList nodeList,
                                               Element element,
                                               CallStructure callStructure) {
     List<ir.Primitive> arguments = nodeList.nodes.mapToList(visit);
     return normalizeStaticArguments(callStructure, element, arguments);
   }
 
   ir.Primitive translateCallInvoke(ir.Primitive target,
                                    ast.NodeList arguments,
-                                   Selector selector) {
+                                   CallStructure callStructure) {
 
-    return irBuilder.buildCallInvocation(target, selector,
-        translateDynamicArguments(arguments, selector));
-  }
-
-  ir.Primitive translateConstantInvoke(ConstantExpression constant,
-                                       ast.NodeList arguments,
-                                       Selector selector) {
-    return translateCallInvoke(
-        irBuilder.buildConstantLiteral(constant),
-        arguments,
-        selector);
+    return irBuilder.buildCallInvocation(target, callStructure,
+        translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive handleConstantInvoke(
       ast.Send node,
       ConstantExpression constant,
       ast.NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
-    return translateConstantInvoke(constant, arguments, selector);
+    return translateCallInvoke(
+        irBuilder.buildConstantLiteral(constant),
+        arguments,
+        callStructure);
   }
 
   @override
   ir.Primitive handleDynamicInvoke(
       ast.Send node,
       ast.Node receiver,
       ast.NodeList arguments,
       Selector selector,
       _) {
     return irBuilder.buildDynamicInvocation(
         translateReceiver(receiver), selector,
-        translateDynamicArguments(arguments, selector));
+        translateDynamicArguments(arguments, selector.callStructure));
   }
 
   ir.Primitive handleLocalInvoke(
       ast.Send node,
       LocalElement element,
       ast.NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
-    return irBuilder.buildLocalVariableInvocation(element, selector,
-        translateDynamicArguments(arguments, selector));
+    return irBuilder.buildLocalVariableInvocation(element, callStructure,
+        translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive visitLocalFunctionInvoke(
       ast.Send node,
       LocalFunctionElement function,
       ast.NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
-    return irBuilder.buildLocalFunctionInvocation(function, selector,
-        translateDynamicArguments(arguments, selector));
+    return irBuilder.buildLocalFunctionInvocation(function, callStructure,
+        translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive handleStaticFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
-    return irBuilder.buildStaticFieldInvocation(field, selector,
-        translateDynamicArguments(arguments, selector));
+    return irBuilder.buildStaticFieldInvocation(field, callStructure,
+        translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive handleStaticFunctionInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
     // TODO(karlklose): support foreign functions.
     if (function.isForeign(compiler.backend)) {
       return giveup(node, 'handleStaticFunctionInvoke: foreign: $function');
     }
-    return irBuilder.buildStaticFunctionInvocation(function, selector,
-        translateStaticArguments(arguments, function, selector.callStructure),
+    return irBuilder.buildStaticFunctionInvocation(function, callStructure,
+        translateStaticArguments(arguments, function, callStructure),
         sourceInformation: sourceInformationBuilder.buildCall(node));
   }
 
   @override
   ir.Primitive handleStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
-    return irBuilder.buildStaticGetterInvocation(getter, selector,
-        translateDynamicArguments(arguments, selector));
+    return irBuilder.buildStaticGetterInvocation(getter, callStructure,
+        translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive visitSuperFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
-    return irBuilder.buildSuperFieldInvocation(field, selector,
-        translateDynamicArguments(arguments, selector));
+    return irBuilder.buildSuperFieldInvocation(field, callStructure,
+        translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive visitSuperGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
-    return irBuilder.buildSuperGetterInvocation(getter, selector,
-        translateDynamicArguments(arguments, selector));
+    return irBuilder.buildSuperGetterInvocation(getter, callStructure,
+        translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive visitSuperMethodInvoke(
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
-    return irBuilder.buildSuperMethodInvocation(method, selector,
-        translateDynamicArguments(arguments, selector));
+    return irBuilder.buildSuperMethodInvocation(method, callStructure,
+        translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive visitThisInvoke(
       ast.Send node,
       ast.NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
-    return translateCallInvoke(irBuilder.buildThis(), arguments, selector);
+    return translateCallInvoke(irBuilder.buildThis(), arguments, callStructure);
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralInvoke(
       ast.Send node,
       TypeVariableElement element,
       ast.NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
     return translateCallInvoke(
         translateTypeVariableTypeLiteral(element),
         arguments,
-        selector);
-  }
-
-  @override
-  ir.Primitive visitTypedefTypeLiteralInvoke(
-      ast.Send node,
-      TypeConstantExpression constant,
-      ast.NodeList arguments,
-      Selector selector, _) {
-    return translateConstantInvoke(constant, arguments, selector);
+        callStructure);
   }
 
   // TODO(johnniwinther): This should be a method on [IrBuilder].
   ir.Primitive buildReifyTypeVariable(ir.Primitive target,
                                       TypeVariableType variable);
 
   @override
   ir.Primitive visitIndexSet(
        ast.SendSet node,
        ast.Node receiver,
@@ skipping 21 matching lines @@
       ast.Node index,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     ir.Primitive target = visit(receiver);
     ir.Primitive indexValue = visit(index);
     return translateCompound(
         getValue: () {
           Selector selector = new Selector.index();
           List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
-          arguments = normalizeDynamicArguments(selector, arguments);
+          arguments =
+              normalizeDynamicArguments(selector.callStructure, arguments);
           return irBuilder.buildDynamicInvocation(target, selector, arguments);
         },
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
           irBuilder.buildDynamicIndexSet(target, indexValue, result);
         });
   }
 
   @override
   ir.Primitive visitSuperCompoundIndexSet(
       ast.SendSet node,
       FunctionElement getter,
       FunctionElement setter,
       ast.Node index,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     ir.Primitive indexValue = visit(index);
     return translateCompound(
         getValue: () {
-          Selector selector = new Selector.index();
-          List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
-          arguments = normalizeDynamicArguments(selector, arguments);
-          return irBuilder.buildSuperMethodInvocation(
-              getter, selector, arguments);
+          return irBuilder.buildSuperIndex(getter, indexValue);
         },
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
           irBuilder.buildSuperIndexSet(setter, indexValue, result);
         });
   }
 
   ir.Primitive translatePrefixPostfix(
       {ir.Primitive getValue(),
        op.IncDecOperator operator,
        void setValue(ir.Primitive value),
        bool isPrefix}) {
     ir.Primitive value = getValue();
     Selector operatorSelector =
         new Selector.binaryOperator(operator.selectorName);
     List<ir.Primitive> arguments =
         <ir.Primitive>[irBuilder.buildIntegerLiteral(1)];
-    arguments = normalizeDynamicArguments(operatorSelector, arguments);
+    arguments = normalizeDynamicArguments(
+        operatorSelector.callStructure, arguments);
     ir.Primitive result =
         irBuilder.buildDynamicInvocation(value, operatorSelector, arguments);
     setValue(result);
     return isPrefix ? result : value;
   }
 
   ir.Primitive translateCompound(
       {ir.Primitive getValue(),
        op.AssignmentOperator operator,
        ast.Node rhs,
        void setValue(ir.Primitive value)}) {
     ir.Primitive value = getValue();
     Selector operatorSelector =
         new Selector.binaryOperator(operator.selectorName);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(rhs)];
-    arguments = normalizeDynamicArguments(operatorSelector, arguments);
+    arguments = normalizeDynamicArguments(
+        operatorSelector.callStructure, arguments);
     ir.Primitive result =
         irBuilder.buildDynamicInvocation(value, operatorSelector, arguments);
     setValue(result);
     return result;
   }
 
   @override
   ir.Primitive handleDynamicCompound(
       ast.Send node,
       ast.Node receiver,
@@ skipping 304 matching lines @@
       ast.Node index,
       op.IncDecOperator operator,
       arg,
       {bool isPrefix}) {
     ir.Primitive target = visit(receiver);
     ir.Primitive indexValue = visit(index);
     return translatePrefixPostfix(
         getValue: () {
           Selector selector = new Selector.index();
           List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
-          arguments = normalizeDynamicArguments(selector, arguments);
+          arguments =
+              normalizeDynamicArguments(selector.callStructure, arguments);
           return irBuilder.buildDynamicInvocation(target, selector, arguments);
         },
         operator: operator,
         setValue: (ir.Primitive result) {
           Selector selector = new Selector.indexSet();
           List<ir.Primitive> arguments = <ir.Primitive>[indexValue, result];
-          arguments = normalizeDynamicArguments(selector, arguments);
+          arguments =
+              normalizeDynamicArguments(selector.callStructure, arguments);
           irBuilder.buildDynamicInvocation(target, selector, arguments);
         },
         isPrefix: isPrefix);
   }
 
   @override
   ir.Primitive handleSuperIndexPostfixPrefix(
       ast.Send node,
       FunctionElement indexFunction,
       FunctionElement indexSetFunction,
       ast.Node index,
       op.IncDecOperator operator,
       arg,
       {bool isPrefix}) {
     ir.Primitive indexValue = visit(index);
     return translatePrefixPostfix(
         getValue: () {
-          Selector selector = new Selector.index();
-          List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
-          arguments = normalizeDynamicArguments(selector, arguments);
-          return irBuilder.buildSuperMethodInvocation(
-              indexFunction, selector, arguments);
+          return irBuilder.buildSuperIndex(indexFunction, indexValue);
         },
         operator: operator,
         setValue: (ir.Primitive result) {
-          Selector selector = new Selector.indexSet();
-          List<ir.Primitive> arguments = <ir.Primitive>[indexValue, result];
-          arguments = normalizeDynamicArguments(selector, arguments);
-          irBuilder.buildSuperMethodInvocation(
-              indexSetFunction, selector, arguments);
+          irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result);
         },
         isPrefix: isPrefix);
   }
 
   @override
   ir.Primitive handleStaticSetterSet(
       ast.SendSet node,
       FunctionElement setter,
       ast.Node rhs,
       _) {
@@ skipping 448 matching lines @@
   }
 
   List<ir.Primitive> normalizeStaticArguments(
       CallStructure callStructure,
       FunctionElement target,
       List<ir.Primitive> arguments) {
     return arguments;
   }
 
   List<ir.Primitive> normalizeDynamicArguments(
-      Selector selector,
+      CallStructure callStructure,
       List<ir.Primitive> arguments) {
     return arguments;
   }
 
   @override
   ir.Primitive buildReifyTypeVariable(ir.Primitive target,
                                       TypeVariableType variable) {
     assert(target == irBuilder.state.enclosingMethodThisParameter);
     ir.Primitive prim = new ir.ReifyTypeVar(variable.element);
     irBuilder.add(new ir.LetPrim(prim));
     return prim;
   }
 
   @override
   ir.Primitive handleConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList arguments,
-      Selector selector, _) {
+      CallStructure callStructure, _) {
     List<ir.Primitive> arguments =
         node.send.arguments.mapToList(visit, growable:false);
     return irBuilder.buildConstructorInvocation(
         constructor,
-        selector,
+        callStructure,
         type,
         arguments);
   }
 }
 
 /// The [IrBuilder]s view on the information about the program that has been
 /// computed in resolution and and type interence.
 class GlobalProgramInformation {
   final Compiler _compiler;
   JavaScriptBackend get _backend => _compiler.backend;
@@ skipping 541 matching lines @@
         } else {
           result.add(translateDefaultValue(element));
         }
       });
     }
     return result;
   }
 
   /// Normalizes order of named arguments.
   List<ir.Primitive> normalizeDynamicArguments(
-      Selector selector,
+      CallStructure callStructure,
       List<ir.Primitive> arguments) {
-    CallStructure callStructure = selector.callStructure;
     assert(arguments.length == callStructure.argumentCount);
     // Optimization: don't copy the argument list for trivial cases.
     if (callStructure.namedArguments.isEmpty) return arguments;
     List<ir.Primitive> result = <ir.Primitive>[];
     for (int i=0; i < callStructure.positionalArgumentCount; i++) {
       result.add(arguments[i]);
     }
     for (String argName in callStructure.getOrderedNamedArguments()) {
       int nameIndex = callStructure.namedArguments.indexOf(argName);
       int translatedIndex = callStructure.positionalArgumentCount + nameIndex;
@@ skipping 12 matching lines @@
     irBuilder.add(new ir.LetPrim(type));
     return type;
   }
 
   @override
   ir.Primitive handleConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList arguments,
-      Selector selector, _) {
+      CallStructure callStructure,
+      _) {
     List<ir.Primitive> arguments =
         node.send.arguments.mapToList(visit, growable:false);
     arguments = normalizeStaticArguments(
-        selector.callStructure, constructor, arguments);
+        callStructure, constructor, arguments);
     return irBuilder.buildConstructorInvocation(
         constructor.effectiveTarget,
-        selector,
+        callStructure,
         constructor.computeEffectiveTargetType(type),
         arguments);
   }
 }
 
 /// Interface for generating [SourceInformation] for the CPS.
 class SourceInformationBuilder {
   const SourceInformationBuilder();
 
   /// Create a [SourceInformationBuilder] for [element].
@@ skipping 25 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }