Use CallStructure instead of Selector in SemanticSendVisitor.

pkg/compiler/lib/src/resolution/send_structure.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.send_structure;
 
 import 'access_semantics.dart';
 import 'operators.dart';
 import 'semantic_visitor.dart';
 import '../dart_types.dart';
@@ skipping 131 matching lines @@
 
   String toString() => 'as $type';
 }
 
 /// The structure for a [Send] that is an invocation.
 class InvokeStructure<R, A> implements SendStructure<R, A> {
   /// The target of the invocation.
   final AccessSemantics semantics;
 
   /// The [Selector] for the invocation.
+  // TODO(johnniwinther): Store this only for dynamic invocations.
   final Selector selector;
 
+  /// The [CallStructure] of the invocation.
+  // TODO(johnniwinther): Store this directly for static invocations.
+  CallStructure get callStructure => selector.callStructure;
+
   InvokeStructure(this.semantics, this.selector);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitDynamicPropertyInvoke(
             node,
             node.receiver,
             node.argumentsNode,
             selector,
             arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             // TODO(johnniwinther): Store the call selector instead of the
             // selector using the name of the function.
-            new Selector.callClosureFrom(selector),
+            callStructure,
             arg);
       case AccessKind.LOCAL_VARIABLE:
         return visitor.visitLocalVariableInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             // TODO(johnniwinther): Store the call selector instead of the
             // selector using the name of the variable.
-            new Selector.callClosureFrom(selector),
+            callStructure,
             arg);
       case AccessKind.PARAMETER:
         return visitor.visitParameterInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             // TODO(johnniwinther): Store the call selector instead of the
             // selector using the name of the parameter.
-            new Selector.callClosureFrom(selector),
+            callStructure,
             arg);
       case AccessKind.STATIC_FIELD:
         return visitor.visitStaticFieldInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.STATIC_METHOD:
         return visitor.visitStaticFunctionInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.STATIC_GETTER:
         return visitor.visitStaticGetterInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.STATIC_SETTER:
         return visitor.errorStaticSetterInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.TOPLEVEL_FIELD:
         return visitor.visitTopLevelFieldInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.TOPLEVEL_METHOD:
         return visitor.visitTopLevelFunctionInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.TOPLEVEL_GETTER:
         return visitor.visitTopLevelGetterInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.TOPLEVEL_SETTER:
         return visitor.errorTopLevelSetterInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.CLASS_TYPE_LITERAL:
         return visitor.visitClassTypeLiteralInvoke(
             node,
             semantics.constant,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.TYPEDEF_TYPE_LITERAL:
         return visitor.visitTypedefTypeLiteralInvoke(
             node,
             semantics.constant,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.DYNAMIC_TYPE_LITERAL:
         return visitor.visitDynamicTypeLiteralInvoke(
             node,
             semantics.constant,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.TYPE_PARAMETER_TYPE_LITERAL:
         return visitor.visitTypeVariableTypeLiteralInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.EXPRESSION:
         return visitor.visitExpressionInvoke(
             node,
             node.selector,
             node.argumentsNode,
             selector,
             arg);
       case AccessKind.THIS:
         return visitor.visitThisInvoke(
             node,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.THIS_PROPERTY:
         return visitor.visitThisPropertyInvoke(
             node,
             node.argumentsNode,
             selector,
             arg);
       case AccessKind.SUPER_FIELD:
         return visitor.visitSuperFieldInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperMethodInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.SUPER_GETTER:
         return visitor.visitSuperGetterInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.SUPER_SETTER:
         return visitor.errorSuperSetterInvoke(
             node,
             semantics.element,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.CONSTANT:
         return visitor.visitConstantInvoke(
             node,
             semantics.constant,
             node.argumentsNode,
-            selector,
+            callStructure,
             arg);
       case AccessKind.UNRESOLVED:
         return visitor.errorUnresolvedInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             selector,
             arg);
       case AccessKind.COMPOUND:
         // This is not a valid case.
@@ skipping 1485 matching lines @@
 }
 
 /// The structure for a [NewExpression] of a new invocation. For instance
 /// `new C()`.
 class NewInvokeStructure<R, A> extends NewStructure<R, A> {
   final ConstructorAccessSemantics semantics;
   final Selector selector;
 
   NewInvokeStructure(this.semantics, this.selector);
 
+  CallStructure get callStructure => selector.callStructure;
+
   R dispatch(SemanticSendVisitor<R, A> visitor, NewExpression node, A arg) {
     switch (semantics.kind) {
       case ConstructorAccessKind.GENERATIVE:
         return visitor.visitGenerativeConstructorInvoke(
             node, semantics.element, semantics.type,
-            node.send.argumentsNode, selector, arg);
+            node.send.argumentsNode, callStructure, arg);
       case ConstructorAccessKind.REDIRECTING_GENERATIVE:
         return visitor.visitRedirectingGenerativeConstructorInvoke(
             node, semantics.element, semantics.type,
-            node.send.argumentsNode, selector, arg);
+            node.send.argumentsNode, callStructure, arg);
       case ConstructorAccessKind.FACTORY:
         return visitor.visitFactoryConstructorInvoke(
             node, semantics.element, semantics.type,
-            node.send.argumentsNode, selector, arg);
+            node.send.argumentsNode, callStructure, arg);
       case ConstructorAccessKind.REDIRECTING_FACTORY:
         return visitor.visitRedirectingFactoryConstructorInvoke(
             node, semantics.element, semantics.type,
             semantics.effectiveTargetSemantics.element,
             semantics.effectiveTargetSemantics.type,
-            node.send.argumentsNode, selector, arg);
+            node.send.argumentsNode, callStructure, arg);
       case ConstructorAccessKind.ABSTRACT:
         return visitor.errorAbstractClassConstructorInvoke(
             node, semantics.element, semantics.type,
-            node.send.argumentsNode, selector, arg);
+            node.send.argumentsNode, callStructure, arg);
       case ConstructorAccessKind.ERRONEOUS:
         return visitor.errorUnresolvedConstructorInvoke(
             node, semantics.element, semantics.type,
             node.send.argumentsNode, selector, arg);
       case ConstructorAccessKind.ERRONEOUS_REDIRECTING_FACTORY:
         return visitor.errorUnresolvedRedirectingFactoryConstructorInvoke(
             node, semantics.element, semantics.type,
             node.send.argumentsNode, selector, arg);
     }
     throw new SpannableAssertionFailure(node,
@@ skipping 209 matching lines @@
   final ConstructorElement constructor;
   final Selector selector;
 
   ThisConstructorInvokeStructure(this.constructor, this.selector);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitThisConstructorInvoke(
         node, constructor, node.argumentsNode, selector, arg);
   }
 }