Resolve type arguments to generic methods.

pkg/compiler/lib/src/tree/nodes.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.
 
 import 'dart:collection' show IterableMixin;
 
 import '../common.dart';
 import '../elements/elements.dart' show MetadataAnnotation;
 import '../resolution/secret_tree_element.dart'
     show NullTreeElementMixin, StoredTreeElementMixin;
@@ skipping 575 matching lines @@
  * A message send aka method invocation. In Dart, most operations can
  * (and should) be considered as message sends. Getters and setters
  * are just methods with a special syntax. Consequently, we model
  * property access, assignment, operators, and method calls with this
  * one node.
  */
 class Send extends Expression with StoredTreeElementMixin {
   final Node receiver;
   final Node selector;
   final NodeList argumentsNode;
+  final NodeList typeArgumentsNode;
 
   /// Whether this is a conditional send of the form `a?.b`.
   final bool isConditional;
 
   Link<Node> get arguments => argumentsNode.nodes;
 
   Send(
       [this.receiver,
       this.selector,
       this.argumentsNode,
+      this.typeArgumentsNode,
       this.isConditional = false]);
   Send.postfix(this.receiver, this.selector,
       [Node argument = null, this.isConditional = false])
       : argumentsNode = (argument == null)
             ? new Postfix()
-            : new Postfix.singleton(argument);
+            : new Postfix.singleton(argument),
+        typeArgumentsNode = null;
   Send.prefix(this.receiver, this.selector,
       [Node argument = null, this.isConditional = false])
       : argumentsNode =
-            (argument == null) ? new Prefix() : new Prefix.singleton(argument);
+            (argument == null) ? new Prefix() : new Prefix.singleton(argument),
+        typeArgumentsNode = null;
 
   Send asSend() => this;
 
   accept(Visitor visitor) => visitor.visitSend(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitSend(this, arg);
 
   visitChildren(Visitor visitor) {
     if (receiver != null) receiver.accept(visitor);
     if (selector != null) selector.accept(visitor);
@@ skipping 62 matching lines @@
     if (!isPostfix && argumentsNode != null) {
       Token token = argumentsNode.getEndToken();
       if (token != null) return token;
     }
     if (selector != null) return selector.getEndToken();
     return getBeginToken();
   }
 
   Send copyWithReceiver(Node newReceiver, bool isConditional) {
     assert(receiver == null);
-    return new Send(newReceiver, selector, argumentsNode, isConditional);
+    return new Send(
+        newReceiver, selector, argumentsNode, typeArgumentsNode, isConditional);
   }
 }
 
 class Postfix extends NodeList {
   Postfix() : super(null, const Link<Node>());
   Postfix.singleton(Node argument) : super.singleton(argument);
 }
 
 class Prefix extends NodeList {
   Prefix() : super(null, const Link<Node>());
   Prefix.singleton(Node argument) : super.singleton(argument);
 }
 
 class SendSet extends Send {
   final Operator assignmentOperator;
   SendSet(receiver, selector, this.assignmentOperator, argumentsNode,
       [bool isConditional = false])
-      : super(receiver, selector, argumentsNode, isConditional);
+      : super(receiver, selector, argumentsNode, null, isConditional);
   SendSet.postfix(receiver, selector, this.assignmentOperator,
       [Node argument = null, bool isConditional = false])
       : super.postfix(receiver, selector, argument, isConditional);
   SendSet.prefix(receiver, selector, this.assignmentOperator,
       [Node argument = null, bool isConditional = false])
       : super.prefix(receiver, selector, argument, isConditional);
 
   SendSet asSendSet() => this;
 
   accept(Visitor visitor) => visitor.visitSendSet(this);
@@ skipping 2399 matching lines @@
 
   // VariableDefinitions.
   get metadata => null;
   get type => null;
 
   // Typedef.
   get typeParameters => null;
   get formals => null;
   get typedefKeyword => null;
 }