Use CallStructure instead of Selector in SemanticSendVisitor.

pkg/compiler/lib/src/resolution/semantic_visitor.dart

 // Copyright (c) 2015, 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.semantics_visitor;
 
 import '../constants/expressions.dart';
 import '../dart2jslib.dart' show invariant;
 import '../dart_types.dart';
 import '../elements/elements.dart';
@@ skipping 174 matching lines @@
   ///
   /// For instance:
   ///     m(parameter) {
   ///       parameter(null, 42);
   ///     }
   ///
   R visitParameterInvoke(
       Send node,
       ParameterElement parameter,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Read of the local [variable].
   ///
   /// For instance:
   ///     m() {
   ///       var variable;
   ///       return variable;
   ///     }
   ///
@@ skipping 35 matching lines @@
   /// For instance:
   ///     m() {
   ///       var variable;
   ///       variable(null, 42);
   ///     }
   ///
   R visitLocalVariableInvoke(
       Send node,
       LocalVariableElement variable,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Closurization of the local [function].
   ///
   /// For instance:
   ///     m() {
   ///       o(a, b) {}
   ///       return o;
   ///     }
   ///
@@ skipping 21 matching lines @@
   /// For instance:
   ///     m() {
   ///       o(a, b) {}
   ///       return o(null, 42);
   ///     }
   ///
   R visitLocalFunctionInvoke(
       Send node,
       LocalFunctionElement function,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Getter call on [receiver] of the property defined by [selector].
   ///
   /// For instance
   ///     m(receiver) => receiver.foo;
   ///
   R visitDynamicPropertyGet(
       Send node,
       Node receiver,
@@ skipping 101 matching lines @@
   /// Invocation of `this` with [arguments].
   ///
   /// For instance
   ///     class C {
   ///       m() => this(null, 42);
   ///     }
   ///
   R visitThisInvoke(
       Send node,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
 
   /// Read of the super [field].
   ///
   /// For instance
   ///     class B {
   ///       var foo;
   ///     }
   ///     class C extends B {
@@ skipping 44 matching lines @@
   ///       var foo;
   ///     }
   ///     class C extends B {
   ///        m() { super.foo(null, 42); }
   ///     }
   ///
   R visitSuperFieldInvoke(
       Send node,
       FieldElement field,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Closurization of the super [method].
   ///
   /// For instance
   ///     class B {
   ///       foo(a, b) {}
   ///     }
   ///     class C extends B {
   ///        m() => super.foo;
@@ skipping 11 matching lines @@
   ///       foo(a, b) {}
   ///     }
   ///     class C extends B {
   ///        m() { super.foo(null, 42); }
   ///     }
   ///
   R visitSuperMethodInvoke(
       Send node,
       MethodElement method,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Assignment of [rhs] to the super [method].
   ///
   /// For instance
   ///     class B {
   ///       foo(a, b) {}
   ///     }
   ///     class C extends B {
   ///        m() { super.foo = rhs; }
@@ skipping 74 matching lines @@
   ///       get foo => null;
   ///     }
   ///     class C extends B {
   ///        m() { super.foo(null, 42; }
   ///     }
   ///
   R visitSuperGetterInvoke(
       Send node,
       FunctionElement getter,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Invocation of the super [setter] with [arguments].
   ///
   /// For instance
   ///     class B {
   ///       set foo(_) {}
   ///     }
   ///     class C extends B {
   ///        m() { super.foo(null, 42; }
   ///     }
   ///
   R errorSuperSetterInvoke(
       Send node,
       FunctionElement setter,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Invocation of a [expression] with [arguments].
   ///
   /// For instance
   ///     m() => (a, b){}(null, 42);
   ///
   R visitExpressionInvoke(
       Send node,
       Node expression,
@@ skipping 47 matching lines @@
   /// For instance
   ///     class C {
   ///       static var foo;
   ///     }
   ///     m() { C.foo(null, 42); }
   ///
   R visitStaticFieldInvoke(
       Send node,
       FieldElement field,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Closurization of the static [function].
   ///
   /// For instance
   ///     class C {
   ///       static foo(a, b) {}
   ///     }
   ///     m() => C.foo;
   ///
   R visitStaticFunctionGet(
       Send node,
       MethodElement function,
       A arg);
 
   /// Invocation of the static [function] with [arguments].
   ///
   /// For instance
   ///     class C {
   ///       static foo(a, b) {}
   ///     }
   ///     m() { C.foo(null, 42); }
   ///
   R visitStaticFunctionInvoke(
       Send node,
       MethodElement function,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Assignment of [rhs] to the static [function].
   ///
   /// For instance
   ///     class C {
   ///       static foo(a, b) {}
   ///     }
   ///     m() { C.foo = rhs; }
   ///
@@ skipping 62 matching lines @@
   /// For instance
   ///     class C {
   ///       static get foo => null;
   ///     }
   ///     m() { C.foo(null, 42; }
   ///
   R visitStaticGetterInvoke(
       Send node,
       FunctionElement getter,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Invocation of the static [setter] with [arguments].
   ///
   /// For instance
   ///     class C {
   ///       static set foo(_) {}
   ///     }
   ///     m() { C.foo(null, 42; }
   ///
   R errorStaticSetterInvoke(
       Send node,
       FunctionElement setter,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Read of the top level [field].
   ///
   /// For instance
   ///     var foo;
   ///     m() => foo;
   ///
   R visitTopLevelFieldGet(
       Send node,
@@ skipping 27 matching lines @@
   /// Invocation of the top level [field] with [arguments].
   ///
   /// For instance
   ///     var foo;
   ///     m() { foo(null, 42); }
   ///
   R visitTopLevelFieldInvoke(
       Send node,
       FieldElement field,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Closurization of the top level [function].
   ///
   /// For instance
   ///     foo(a, b) {};
   ///     m() => foo;
   ///
   R visitTopLevelFunctionGet(
       Send node,
       MethodElement function,
       A arg);
 
   /// Invocation of the top level [function] with [arguments].
   ///
   /// For instance
   ///     foo(a, b) {};
   ///     m() { foo(null, 42); }
   ///
   R visitTopLevelFunctionInvoke(
       Send node,
       MethodElement function,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Assignment of [rhs] to the top level [function].
   ///
   /// For instance
   ///     foo(a, b) {};
   ///     m() { foo = rhs; }
   ///
   R errorTopLevelFunctionSet(
       Send node,
@@ skipping 50 matching lines @@
   /// Invocation of the top level [getter] with [arguments].
   ///
   /// For instance
   ///     get foo => null;
   ///     m() { foo(null, 42); }
   ///
   R visitTopLevelGetterInvoke(
       Send node,
       FunctionElement getter,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Invocation of the top level [setter] with [arguments].
   ///
   /// For instance
   ///     set foo(_) {};
   ///     m() { foo(null, 42); }
   ///
   R errorTopLevelSetterInvoke(
       Send node,
       FunctionElement setter,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Read of the type literal for class [element].
   ///
   /// For instance
   ///     class C {}
   ///     m() => C;
   ///
   R visitClassTypeLiteralGet(
       Send node,
       ConstantExpression constant,
       A arg);
 
   /// Invocation of the type literal for class [element] with [arguments].
   ///
   /// For instance
   ///     class C {}
   ///     m() => C(null, 42);
   ///
   R visitClassTypeLiteralInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Assignment of [rhs] to the type literal for class [element].
   ///
   /// For instance
   ///     class C {}
   ///     m() { C = rhs; }
   ///
   R errorClassTypeLiteralSet(
       SendSet node,
@@ skipping 15 matching lines @@
   /// Invocation of the type literal for typedef [element] with [arguments].
   ///
   /// For instance
   ///     typedef F();
   ///     m() => F(null, 42);
   ///
   R visitTypedefTypeLiteralInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Assignment of [rhs] to the type literal for typedef [element].
   ///
   /// For instance
   ///     typedef F();
   ///     m() { F = rhs; }
   ///
   R errorTypedefTypeLiteralSet(
       SendSet node,
@@ skipping 18 matching lines @@
   ///
   /// For instance
   ///     class C<T> {
   ///       m() { T(null, 42); }
   ///     }
   ///
   R visitTypeVariableTypeLiteralInvoke(
       Send node,
       TypeVariableElement element,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Assignment of [rhs] to the type literal for type variable [element].
   ///
   /// For instance
   ///     class C<T> {
   ///       m() { T = rhs; }
   ///     }
   ///
   R errorTypeVariableTypeLiteralSet(
@@ skipping 14 matching lines @@
 
   /// Invocation of the type literal for `dynamic` with [arguments].
   ///
   /// For instance
   ///     m() { dynamic(null, 42); }
   ///
   R visitDynamicTypeLiteralInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Assignment of [rhs] to the type literal for `dynamic`.
   ///
   /// For instance
   ///     m() { dynamic = rhs; }
   ///
   R errorDynamicTypeLiteralSet(
       SendSet node,
       ConstantExpression constant,
@@ skipping 1523 matching lines @@
   /// Invocation of the [constant] with [arguments].
   ///
   /// For instance
   ///     const c = null;
   ///     m() => c(null, 42);
   ///
   R visitConstantInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStreucture,
       A arg);
 
   /// Read of the unresolved [element].
   ///
   /// For instance
   ///     class C {}
   ///     m1() => unresolved;
   ///     m2() => prefix.unresolved;
   ///     m3() => Unresolved.foo;
   ///     m4() => unresolved.foo;
@@ skipping 206 matching lines @@
   ///   }
   ///   m() => new C<int>(true, 42);
   ///
   /// where [type] is `C<int>`.
   ///
   R visitGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Invocation of a redirecting generative [constructor] on [type] with
   /// [arguments].
   ///
   /// For instance
   ///   class C<T> {
   ///     C(a, b) : this._(b, a);
   ///     C._(b, a);
   ///   }
   ///   m() => new C<int>(true, 42);
   ///
   /// where [type] is `C<int>`.
   ///
   R visitRedirectingGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Invocation of a factory [constructor] on [type] with [arguments].
   ///
   /// For instance
   ///   class C<T> {
   ///     factory C(a, b) => new C<T>._(b, a);
   ///     C._(b, a);
   ///   }
   ///   m() => new C<int>(true, 42);
   ///
   /// where [type] is `C<int>`.
   ///
   R visitFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Invocation of a factory [constructor] on [type] with [arguments] where
   /// [effectiveTarget] and [effectiveTargetType] are the constructor effective
   /// invoked and its type, respectively.
   ///
   /// For instance
   ///   class C<T> {
   ///     factory C(a, b) = C<int>.a;
   ///     factory C.a(a, b) = C<C<T>>.b;
   ///     C.b(a, b);
   ///   }
   ///   m() => new C<double>(true, 42);
   ///
   /// where [type] is `C<double>`, [effectiveTarget] is `C.b` and
   /// [effectiveTargetType] is `C<C<int>>`.
   ///
   R visitRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
       InterfaceType type,
       ConstructorElement effectiveTarget,
       InterfaceType effectiveTargetType,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Invocation of an unresolved [constructor] on [type] with [arguments].
   ///
   /// For instance
   ///   class C<T> {
   ///     C();
   ///   }
   ///   m() => new C<int>.unresolved(true, 42);
   ///
@@ skipping 29 matching lines @@
   /// For instance
   ///   m() => new Unresolved(true, 42);
   ///
   /// where [type] is the malformed type `Unresolved`.
   ///
   R errorAbstractClassConstructorInvoke(
       NewExpression node,
       ConstructorElement element,
       InterfaceType type,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg);
 
   /// Invocation of a factory [constructor] on [type] with [arguments] where
   /// [effectiveTarget] and [effectiveTargetType] are the constructor effective
   /// invoked and its type, respectively.
   ///
   /// For instance
   ///   class C {
   ///     factory C(a, b) = Unresolved;
   ///     factory C.a(a, b) = C.unresolved;
@@ skipping 551 matching lines @@
   ///       C() : this._(42);
   ///     }
   ///
   R errorUnresolvedThisConstructorInvoke(
       Send node,
       Element element,
       NodeList arguments,
       Selector selector,
       A arg);
 }