Use CallStructure instead of Selector in SemanticSendVisitor.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../tree/tree.dart' as ast;
 import '../closure.dart' hide ClosureScope;
+import '../universe/universe.dart' show SelectorKind;
 import 'cps_ir_nodes.dart' as ir;
 import 'cps_ir_builder_task.dart' show DartCapturedVariables,
     GlobalProgramInformation;
 
 /// A mapping from variable elements to their compile-time values.
 ///
 /// Map elements denoted by parameters and local variables to the
 /// [ir.Primitive] that is their value.  Parameters and locals are
 /// assigned indexes which can be used to refer to them.
 class Environment {
@@ skipping 615 matching lines @@
                                    Selector selector,
                                    List<ir.Primitive> arguments,
                                    {SourceInformation sourceInformation}) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeMethod(receiver, selector, k, arguments,
             sourceInformation: sourceInformation));
   }
 
   ir.Primitive _buildInvokeCall(ir.Primitive target,
-                                Selector selector,
+                                CallStructure callStructure,
                                 List<ir.Definition> arguments,
                                 {SourceInformation sourceInformation}) {
-    Selector callSelector = new Selector.callClosureFrom(selector);
-    return _buildInvokeDynamic(target, callSelector, arguments,
+    Selector selector = callStructure.callSelector;
+    return _buildInvokeDynamic(target, selector, arguments,
         sourceInformation: sourceInformation);
   }
 
 
   /// Create a constant literal from [constant].
   ir.Constant buildConstantLiteral(ConstantExpression constant) {
     assert(isOpen);
     return addPrimitive(new ir.Constant(constant));
   }
 
@@ skipping 196 matching lines @@
   ir.ConstructorDefinition makeConstructorDefinition(
       List<ConstantExpression> defaults, List<ir.Initializer> initializers) {
     FunctionElement element = state.currentElement;
     ir.Body body = makeBody();
     return new ir.ConstructorDefinition(
         element, state.thisParameter, state.functionParameters, body, initializers,
         state.localConstants, defaults);
   }
 
   /// Create a invocation of the [method] on the super class where the call
-  /// structure is defined [selector] and the argument values are defined by
-  /// [arguments].
+  /// structure is defined [callStructure] and the argument values are defined
+  /// by [arguments].
   ir.Primitive buildSuperMethodInvocation(MethodElement method,
-                                          Selector selector,
+                                          CallStructure callStructure,
                                           List<ir.Primitive> arguments) {
+    // TODO(johnniwinther): This shouldn't be necessary.
+    SelectorKind kind = Elements.isOperatorName(method.name)
+        ? SelectorKind.OPERATOR : SelectorKind.CALL;
+    Selector selector =
+        new Selector(kind, method.memberName, callStructure);
     return _buildInvokeSuper(method, selector, arguments);
   }
 
   /// Create a call invocation on the value of [field] on the super class where
-  /// the call structure is defined [selector] and the argument values are
+  /// the call structure is defined [callStructure] and the argument values are
   /// defined by [arguments].
   ir.Primitive buildSuperFieldInvocation(FieldElement field,
-                                         Selector selector,
+                                         CallStructure callStructure,
                                          List<ir.Primitive> arguments) {
     // TODO(johnniwinther): Maybe this should have its own ir node.
     return buildCallInvocation(
         buildSuperFieldGet(field),
-        selector,
+        callStructure,
         arguments);
   }
 
   /// Create a call invocation on the value returned from the [getter] on the
   /// super class where the call structure is defined [selector] and the
   /// argument values are defined by [arguments].
   ir.Primitive buildSuperGetterInvocation(MethodElement getter,
-                                          Selector selector,
+                                          CallStructure callStructure,
                                           List<ir.Primitive> arguments) {
     // TODO(johnniwinther): Maybe this should have its own ir node.
     return buildCallInvocation(
         buildSuperGetterGet(getter),
-        selector,
+        callStructure,
         arguments);
   }
 
   /// Create a read access of the [field] on the super class.
   ir.Primitive buildSuperFieldGet(FieldElement field) {
     // TODO(johnniwinther): This should have its own ir node.
     return _buildInvokeSuper(
         field,
         new Selector.getter(field.name, field.library),
         const <ir.Primitive>[]);
@@ skipping 33 matching lines @@
   ir.Primitive buildSuperSetterSet(MethodElement setter,
                                           ir.Primitive value) {
     // TODO(johnniwinther): This should have its own ir node.
     _buildInvokeSuper(
         setter,
         new Selector.setter(setter.name, setter.library),
         <ir.Primitive>[value]);
     return value;
   }
 
+  /// Create an invocation of the index [method] on the super class with
+  /// the provided [index].
+  ir.Primitive buildSuperIndex(MethodElement method,
+                               ir.Primitive index) {
+    return _buildInvokeSuper(
+        method, new Selector.index(), <ir.Primitive>[index]);
+  }
+
   /// Create an invocation of the index set [method] on the super class with
   /// the provided [index] and [value].
   ir.Primitive buildSuperIndexSet(MethodElement method,
                                   ir.Primitive index,
                                   ir.Primitive value) {
     _buildInvokeSuper(method, new Selector.indexSet(),
         <ir.Primitive>[index, value]);
     return value;
   }
 
@@ skipping 46 matching lines @@
   ir.Primitive buildLocalFunctionGet(LocalFunctionElement function) {
     // TODO(johnniwinther): Separate function access from variable access.
     return _buildLocalGet(function);
   }
 
   /// Create a write access to the [local] variable or parameter with the
   /// provided [value].
   ir.Primitive buildLocalVariableSet(LocalElement local, ir.Primitive value);
 
   /// Create an invocation of the the [local] variable or parameter where
-  /// argument structure is defined by [selector] and the argument values are
-  /// defined by [arguments].
+  /// argument structure is defined by [callStructure] and the argument values
+  /// are defined by [arguments].
   ir.Primitive buildLocalVariableInvocation(LocalVariableElement local,
-                                            Selector selector,
+                                            CallStructure callStructure,
                                             List<ir.Primitive> arguments) {
     return buildCallInvocation(
-        buildLocalVariableGet(local), selector, arguments);
+        buildLocalVariableGet(local), callStructure, arguments);
   }
 
   /// Create an invocation of the local [function] where argument structure is
-  /// defined by [selector] and the argument values are defined by [arguments].
+  /// defined by [callStructure] and the argument values are defined by
+  /// [arguments].
   ir.Primitive buildLocalFunctionInvocation(
       LocalFunctionElement function,
-      Selector selector,
+      CallStructure callStructure,
       List<ir.Primitive> arguments) {
     // TODO(johnniwinther): Maybe this should have its own ir node.
     return buildCallInvocation(
-        buildLocalFunctionGet(function), selector, arguments);
+        buildLocalFunctionGet(function), callStructure, arguments);
   }
 
   /// Create a static invocation of [function] where argument structure is
-  /// defined by [selector] and the argument values are defined by [arguments].
+  /// defined by [callStructure] and the argument values are defined by
+  /// [arguments].
   ir.Primitive buildStaticFunctionInvocation(
       MethodElement function,
-      Selector selector,
+      CallStructure callStructure,
       List<ir.Primitive> arguments,
       {SourceInformation sourceInformation}) {
-    return _buildInvokeStatic(function, selector, arguments, sourceInformation);
+    Selector selector =
+        new Selector(SelectorKind.CALL, function.memberName, callStructure);
+    return _buildInvokeStatic(
+        function, selector, arguments, sourceInformation);
   }
 
   /// Create a call invocation of the value of the static [field] where argument
-  /// structure is defined by [selector] and the argument values are defined by
-  /// [arguments].
+  /// structure is defined by [callStructure] and the argument values are
+  /// defined by [arguments].
   ir.Primitive buildStaticFieldInvocation(
       FieldElement field,
-      Selector selector,
+      CallStructure callStructure,
       List<ir.Primitive> arguments,
       {SourceInformation sourceInformation}) {
     // TODO(johnniwinther): Maybe this should have its own node.
     return buildCallInvocation(
         buildStaticFieldGet(field),
-        selector,
+        callStructure,
         arguments,
         sourceInformation: sourceInformation);
   }
 
   /// Create a call invocation of the result of calling the static [getter]
-  /// where argument structure is defined by [selector] and the argument values
-  /// are defined by [arguments].
+  /// where argument structure is defined by [callStructure] and the argument
+  /// values are defined by [arguments].
   ir.Primitive buildStaticGetterInvocation(
       MethodElement getter,
-      Selector selector,
+      CallStructure callStructure,
       List<ir.Primitive> arguments,
       {SourceInformation sourceInformation}) {
     // TODO(johnniwinther): Maybe this should have its own node.
     return buildCallInvocation(
         buildStaticGetterGet(getter),
-        selector,
+        callStructure,
         arguments,
         sourceInformation: sourceInformation);
   }
 
   /// Create a read access of the static [field].
   ir.Primitive buildStaticFieldGet(FieldElement field,
                                    {SourceInformation sourceInformation}) {
     Selector selector = new Selector.getter(field.name, field.library);
     // TODO(karlklose,sigurdm): build different nodes for getters.
     return _buildInvokeStatic(
@@ skipping 43 matching lines @@
   }
 
   /// Create an erroneous invocation where argument structure is defined by
   /// [selector] and the argument values are defined by [arguments].
   // TODO(johnniwinther): Make this more fine-grained.
   ir.Primitive buildErroneousInvocation(
       Element element,
       Selector selector,
       List<ir.Primitive> arguments) {
     // TODO(johnniwinther): This should have its own ir node.
-    return _buildInvokeStatic( element, selector, arguments, null);
+    return _buildInvokeStatic(element, selector, arguments, null);
   }
 
   /// Create a constructor invocation of [element] on [type] where the
-  /// constructor name and argument structure are defined by [selector] and the
-  /// argument values are defined by [arguments].
+  /// constructor name and argument structure are defined by [callStructure] and
+  /// the argument values are defined by [arguments].
   ir.Primitive buildConstructorInvocation(FunctionElement element,
-                                          Selector selector,
+                                          CallStructure callStructure,
                                           DartType type,
                                           List<ir.Primitive> arguments);
 
   /// Create a string concatenation of the [arguments].
   ir.Primitive buildStringConcatenation(List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.ConcatenateStrings(k, arguments));
   }
 
   /// Create an invocation of the `call` method of [functionExpression], where
-  /// the named arguments are given by [selector].
+  /// the structure of arguments are given by [callStructure].
   ir.Primitive buildCallInvocation(
       ir.Primitive functionExpression,
-      Selector selector,
+      CallStructure callStructure,
       List<ir.Definition> arguments,
       {SourceInformation sourceInformation}) {
-    return _buildInvokeCall(functionExpression, selector, arguments,
+    return _buildInvokeCall(functionExpression, callStructure, arguments,
         sourceInformation: sourceInformation);
   }
 
   /// Creates an if-then-else statement with the provided [condition] where the
   /// then and else branches are created through the [buildThenPart] and
   /// [buildElsePart] functions, respectively.
   ///
   /// An if-then statement is created if [buildElsePart] is a no-op.
   // TODO(johnniwinther): Unify implementation with [buildConditional] and
   // [_buildLogicalOperator].
@@ skipping 1080 matching lines @@
       environment.update(local, value);
     }
     return value;
   }
 
   ir.Primitive buildThis() {
     return state.enclosingMethodThisParameter;
   }
 
   @override
-  ir.Primitive buildConstructorInvocation(FunctionElement element,
-                                          Selector selector,
+  ir.Primitive buildConstructorInvocation(ConstructorElement element,
+                                          CallStructure callStructure,
                                           DartType type,
                                           List<ir.Primitive> arguments) {
     assert(isOpen);
+    Selector selector =
+        new Selector(SelectorKind.CALL, element.memberName, callStructure);
     return _continueWithExpression(
         (k) => new ir.InvokeConstructor(type, element, selector, k,
             arguments));
   }
 }
 
 /// State shared between JsIrBuilders within the same function.
 ///
 /// Note that this is not shared between builders of nested functions.
 class JsIrBuilderSharedState {
@@ skipping 258 matching lines @@
       ir.Parameter parameter = createLocalParameter(param);
       state.functionParameters.add(parameter);
     }
     if (closureScope != null) {
       jsState.boxedVariables.addAll(closureScope.capturedVariables);
     }
   }
 
   @override
   ir.Primitive buildConstructorInvocation(ConstructorElement element,
-                                          Selector selector,
+                                          CallStructure callStructure,
                                           DartType type,
                                           List<ir.Primitive> arguments) {
     assert(isOpen);
-
+    Selector selector =
+        new Selector(SelectorKind.CALL, element.memberName, callStructure);
     ClassElement cls = element.enclosingClass;
     if (program.requiresRuntimeTypesFor(cls)) {
       InterfaceType interface = type;
       Iterable<ir.Primitive> typeArguments =
           interface.typeArguments.map((DartType argument) {
         return type.treatAsRaw
             ? buildNullLiteral()
             : buildTypeExpression(argument);
       });
       arguments = new List<ir.Primitive>.from(arguments)
@@ skipping 110 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }