AST changes necessary for generic method support

pkg/analyzer/lib/src/generated/ast.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.ast;
 
 import 'dart:collection';
@@ skipping 1227 matching lines @@
       new FieldDeclaration(cloneNode(node.documentationComment),
           cloneNodeList(node.metadata), cloneToken(node.staticKeyword),
           cloneNode(node.fields), cloneToken(node.semicolon));
 
   @override
   FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) =>
       new FieldFormalParameter(cloneNode(node.documentationComment),
           cloneNodeList(node.metadata), cloneToken(node.keyword),
           cloneNode(node.type), cloneToken(node.thisKeyword),
           cloneToken(node.period), cloneNode(node.identifier),
-          cloneNode(node.parameters));
+          cloneNode(node.typeParameters), cloneNode(node.parameters));
 
   @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
       return new ForEachStatement.withReference(cloneToken(node.awaitKeyword),
           cloneToken(node.forKeyword), cloneToken(node.leftParenthesis),
           cloneNode(node.identifier), cloneToken(node.inKeyword),
           cloneNode(node.iterable), cloneToken(node.rightParenthesis),
           cloneNode(node.body));
@@ skipping 26 matching lines @@
           cloneNode(node.returnType), cloneToken(node.propertyKeyword),
           cloneNode(node.name), cloneNode(node.functionExpression));
 
   @override
   FunctionDeclarationStatement visitFunctionDeclarationStatement(
           FunctionDeclarationStatement node) =>
       new FunctionDeclarationStatement(cloneNode(node.functionDeclaration));
 
   @override
   FunctionExpression visitFunctionExpression(FunctionExpression node) =>
-      new FunctionExpression(cloneNode(node.parameters), cloneNode(node.body));
+      new FunctionExpression(cloneNode(node.typeParameters),
+          cloneNode(node.parameters), cloneNode(node.body));
 
   @override
   FunctionExpressionInvocation visitFunctionExpressionInvocation(
       FunctionExpressionInvocation node) => new FunctionExpressionInvocation(
-      cloneNode(node.function), cloneNode(node.argumentList));
+      cloneNode(node.function), cloneNode(node.typeArguments),
+      cloneNode(node.argumentList));
 
   @override
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) =>
       new FunctionTypeAlias(cloneNode(node.documentationComment),
           cloneNodeList(node.metadata), cloneToken(node.typedefKeyword),
           cloneNode(node.returnType), cloneNode(node.name),
           cloneNode(node.typeParameters), cloneNode(node.parameters),
           cloneToken(node.semicolon));
 
   @override
   FunctionTypedFormalParameter visitFunctionTypedFormalParameter(
       FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter(
       cloneNode(node.documentationComment), cloneNodeList(node.metadata),
       cloneNode(node.returnType), cloneNode(node.identifier),
-      cloneNode(node.parameters));
+      cloneNode(node.typeParameters), cloneNode(node.parameters));
 
   @override
   HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator(
       cloneToken(node.keyword), cloneNodeList(node.hiddenNames));
 
   @override
   IfStatement visitIfStatement(IfStatement node) => new IfStatement(
       cloneToken(node.ifKeyword), cloneToken(node.leftParenthesis),
       cloneNode(node.condition), cloneToken(node.rightParenthesis),
       cloneNode(node.thenStatement), cloneToken(node.elseKeyword),
@@ skipping 91 matching lines @@
   MapLiteralEntry visitMapLiteralEntry(
       MapLiteralEntry node) => new MapLiteralEntry(
       cloneNode(node.key), cloneToken(node.separator), cloneNode(node.value));
 
   @override
   MethodDeclaration visitMethodDeclaration(MethodDeclaration node) =>
       new MethodDeclaration(cloneNode(node.documentationComment),
           cloneNodeList(node.metadata), cloneToken(node.externalKeyword),
           cloneToken(node.modifierKeyword), cloneNode(node.returnType),
           cloneToken(node.propertyKeyword), cloneToken(node.operatorKeyword),
-          cloneNode(node.name), cloneNode(node.parameters),
-          cloneNode(node.body));
+          cloneNode(node.name), cloneNode(node.typeParameters),
+          cloneNode(node.parameters), cloneNode(node.body));
 
   @override
   MethodInvocation visitMethodInvocation(MethodInvocation node) =>
       new MethodInvocation(cloneNode(node.target), cloneToken(node.operator),
-          cloneNode(node.methodName), cloneNode(node.argumentList));
+          cloneNode(node.methodName), cloneNode(node.typeArguments),
+          cloneNode(node.argumentList));
 
   @override
   NamedExpression visitNamedExpression(NamedExpression node) =>
       new NamedExpression(cloneNode(node.name), cloneNode(node.expression));
 
   @override
   AstNode visitNativeClause(NativeClause node) =>
       new NativeClause(cloneToken(node.nativeKeyword), cloneNode(node.name));
 
   @override
@@ skipping 5678 matching lines @@
     super.visitChildren(visitor);
     _safelyVisitChild(_fieldList, visitor);
   }
 }
 
 /**
  * A field formal parameter.
  *
  * > fieldFormalParameter ::=
  * >     ('final' [TypeName] | 'const' [TypeName] | 'var' | [TypeName])?
- * >     'this' '.' [SimpleIdentifier] [FormalParameterList]?
+ * >     'this' '.' [SimpleIdentifier] ([TypeParameterList]? [FormalParameterList])?
  */
 class FieldFormalParameter extends NormalFormalParameter {
   /**
    * The token representing either the 'final', 'const' or 'var' keyword, or
    * `null` if no keyword was used.
    */
   Token keyword;
 
   /**
    * The name of the declared type of the parameter, or `null` if the parameter
    * does not have a declared type.
    */
   TypeName _type;
 
   /**
    * The token representing the 'this' keyword.
    */
   Token thisKeyword;
 
   /**
    * The token representing the period.
    */
   Token period;
 
   /**
+   * The type parameters associated with the method, or `null` if the method is
+   * not a generic method.
+   */
+  TypeParameterList _typeParameters;
+
+  /**
    * The parameters of the function-typed parameter, or `null` if this is not a
    * function-typed field formal parameter.
    */
   FormalParameterList _parameters;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [keyword] can be `null` if there is a type.
    * The [type] must be `null` if the keyword is 'var'. The [thisKeyword] and
    * [period] can be `null` if the keyword 'this' was not provided.  The
    * [parameters] can be `null` if this is not a function-typed field formal
    * parameter.
    */
   FieldFormalParameter(Comment comment, List<Annotation> metadata, this.keyword,
       TypeName type, this.thisKeyword, this.period, SimpleIdentifier identifier,
-      FormalParameterList parameters)
+      TypeParameterList typeParameters, FormalParameterList parameters)
       : super(comment, metadata, identifier) {
     _type = _becomeParentOf(type);
+    _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
@@ skipping 61 matching lines @@
    */
   TypeName get type => _type;
 
   /**
    * Set the name of the declared type of the parameter to the given [typeName].
    */
   void set type(TypeName typeName) {
     _type = _becomeParentOf(typeName);
   }
 
+  /**
+   * Return the type parameters associated with this method, or `null` if this
+   * method is not a generic method.
+   */
+  TypeParameterList get typeParameters => _typeParameters;
+
+  /**
+   * Set the type parameters associated with this method to the given
+   * [typeParameters].
+   */
+  void set typeParameters(TypeParameterList typeParameters) {
+    _typeParameters = _becomeParentOf(typeParameters);
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitFieldFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_type, visitor);
     _safelyVisitChild(identifier, visitor);
+    _safelyVisitChild(_typeParameters, visitor);
     _safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * A for-each statement.
  *
  * > forEachStatement ::=
  * >     'await'? 'for' '(' [DeclaredIdentifier] 'in' [Expression] ')' [Block]
  * >   | 'await'? 'for' '(' [SimpleIdentifier] 'in' [Expression] ')' [Block]
@@ skipping 727 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_functionDeclaration, visitor);
   }
 }
 
 /**
  * A function expression.
  *
  * > functionExpression ::=
- * >     [FormalParameterList] [FunctionBody]
+ * >     [TypeParameterList]? [FormalParameterList] [FunctionBody]
  */
 class FunctionExpression extends Expression {
   /**
+   * The type parameters associated with the method, or `null` if the method is
+   * not a generic method.
+   */
+  TypeParameterList _typeParameters;
+
+  /**
    * The parameters associated with the function.
    */
   FormalParameterList _parameters;
 
   /**
    * The body of the function, or `null` if this is an external function.
    */
   FunctionBody _body;
 
   /**
    * The element associated with the function, or `null` if the AST structure
    * has not been resolved.
    */
   ExecutableElement element;
 
   /**
    * Initialize a newly created function declaration.
    */
-  FunctionExpression(FormalParameterList parameters, FunctionBody body) {
+  FunctionExpression(TypeParameterList typeParameters,
+      FormalParameterList parameters, FunctionBody body) {
+    _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
     _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken {
-    if (_parameters != null) {
+    if (_typeParameters != null) {
+      return _typeParameters.beginToken;
+    } else if (_parameters != null) {
       return _parameters.beginToken;
     } else if (_body != null) {
       return _body.beginToken;
     }
     // This should never be reached because external functions must be named,
     // hence either the body or the name should be non-null.
     throw new IllegalStateException("Non-external functions must have a body");
   }
 
   /**
@@ skipping 33 matching lines @@
    * Set the parameters associated with the function to the given list of
    * [parameters].
    */
   void set parameters(FormalParameterList parameters) {
     _parameters = _becomeParentOf(parameters);
   }
 
   @override
   int get precedence => 16;
 
+  /**
+   * Return the type parameters associated with this method, or `null` if this
+   * method is not a generic method.
+   */
+  TypeParameterList get typeParameters => _typeParameters;
+
+  /**
+   * Set the type parameters associated with this method to the given
+   * [typeParameters].
+   */
+  void set typeParameters(TypeParameterList typeParameters) {
+    _typeParameters = _becomeParentOf(typeParameters);
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
+    _safelyVisitChild(_typeParameters, visitor);
     _safelyVisitChild(_parameters, visitor);
     _safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * The invocation of a function resulting from evaluating an expression.
  * Invocations of methods and other forms of functions are represented by
  * [MethodInvocation] nodes. Invocations of getters and setters are represented
  * by either [PrefixedIdentifier] or [PropertyAccess] nodes.
  *
  * > functionExpressionInvoction ::=
- * >     [Expression] [ArgumentList]
+ * >     [Expression] [TypeArgumentList]? [ArgumentList]
  */
 class FunctionExpressionInvocation extends Expression {
   /**
    * The expression producing the function being invoked.
    */
   Expression _function;
 
   /**
+   * The type arguments to be applied to the method being invoked, or `null` if
+   * no type arguments were provided.
+   */
+  TypeArgumentList _typeArguments;
+
+  /**
    * The list of arguments to the function.
    */
   ArgumentList _argumentList;
 
   /**
    * The element associated with the function being invoked based on static type
    * information, or `null` if the AST structure has not been resolved or the
    * function could not be resolved.
    */
   ExecutableElement staticElement;
 
   /**
    * The element associated with the function being invoked based on propagated
    * type information, or `null` if the AST structure has not been resolved or
    * the function could not be resolved.
    */
   ExecutableElement propagatedElement;
 
   /**
    * Initialize a newly created function expression invocation.
    */
-  FunctionExpressionInvocation(Expression function, ArgumentList argumentList) {
+  FunctionExpressionInvocation(Expression function,
+      TypeArgumentList typeArguments, ArgumentList argumentList) {
     _function = _becomeParentOf(function);
+    _typeArguments = _becomeParentOf(typeArguments);
     _argumentList = _becomeParentOf(argumentList);
   }
 
   /**
    * Return the list of arguments to the method.
    */
   ArgumentList get argumentList => _argumentList;
 
   /**
    * Set the list of arguments to the method to the given [argumentList].
@@ skipping 36 matching lines @@
    * Set the expression producing the function being invoked to the given
    * [expression].
    */
   void set function(Expression expression) {
     _function = _becomeParentOf(expression);
   }
 
   @override
   int get precedence => 15;
 
+  /**
+   * Return the type arguments to be applied to the method being invoked, or
+   * `null` if no type arguments were provided.
+   */
+  TypeArgumentList get typeArguments => _typeArguments;
+
+  /**
+   * Set the type arguments to be applied to the method being invoked to the
+   * given [typeArguments].
+   */
+  void set typeArguments(TypeArgumentList typeArguments) {
+    _typeArguments = _becomeParentOf(typeArguments);
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionExpressionInvocation(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_function, visitor);
+    _safelyVisitChild(_typeArguments, visitor);
     _safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * A function type alias.
  *
  * > functionTypeAlias ::=
  * >     functionPrefix [TypeParameterList]? [FormalParameterList] ';'
  * >
@@ skipping 99 matching lines @@
     _safelyVisitChild(_name, visitor);
     _safelyVisitChild(_typeParameters, visitor);
     _safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * A function-typed formal parameter.
  *
  * > functionSignature ::=
- * >     [TypeName]? [SimpleIdentifier] [FormalParameterList]
+ * >     [TypeName]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
  */
 class FunctionTypedFormalParameter extends NormalFormalParameter {
   /**
    * The return type of the function, or `null` if the function does not have a
    * return type.
    */
   TypeName _returnType;
 
   /**
+   * The type parameters associated with the method, or `null` if the method is

[scheglov, 2015/06/26 01:33:50]

method -> function

[Brian Wilkerson, 2015/06/26 19:07:34]

Done

+   * not a generic method.
+   */
+  TypeParameterList _typeParameters;
+
+  /**
    * The parameters of the function-typed parameter.
    */
   FormalParameterList _parameters;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified.
    */
   FunctionTypedFormalParameter(Comment comment, List<Annotation> metadata,
       TypeName returnType, SimpleIdentifier identifier,
-      FormalParameterList parameters)
+      TypeParameterList typeParameters, FormalParameterList parameters)
       : super(comment, metadata, identifier) {
     _returnType = _becomeParentOf(returnType);
+    _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Token get beginToken {
     if (_returnType != null) {
       return _returnType.beginToken;
     }
     return identifier.beginToken;
   }
@@ skipping 30 matching lines @@
    */
   TypeName get returnType => _returnType;
 
   /**
    * Set the return type of the function to the given [type].
    */
   void set returnType(TypeName type) {
     _returnType = _becomeParentOf(type);
   }
 
+  /**
+   * Return the type parameters associated with this method, or `null` if this
+   * method is not a generic method.
+   */
+  TypeParameterList get typeParameters => _typeParameters;

[scheglov, 2015/06/26 01:33:49]

method -> function

[Brian Wilkerson, 2015/06/26 19:07:34]

Done

+
+  /**
+   * Set the type parameters associated with this method to the given
+   * [typeParameters].
+   */
+  void set typeParameters(TypeParameterList typeParameters) {
+    _typeParameters = _becomeParentOf(typeParameters);
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionTypedFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_returnType, visitor);
     _safelyVisitChild(identifier, visitor);
+    _safelyVisitChild(_typeParameters, visitor);
     _safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * An AST visitor that will recursively visit all of the nodes in an AST
  * structure (like instances of the class [RecursiveAstVisitor]). In addition,
  * when a node of a specific type is visited not only will the visit method for
  * that specific type of node be invoked, but additional methods for the
  * superclasses of that node will also be invoked. For example, using an
@@ skipping 1225 matching lines @@
       new FieldDeclaration(_cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata), _mapToken(node.staticKeyword),
           _cloneNode(node.fields), _mapToken(node.semicolon));
 
   @override
   FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) =>
       new FieldFormalParameter(_cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata), _mapToken(node.keyword),
           _cloneNode(node.type), _mapToken(node.thisKeyword),
           _mapToken(node.period), _cloneNode(node.identifier),
-          _cloneNode(node.parameters));
+          _cloneNode(node.typeParameters), _cloneNode(node.parameters));
 
   @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
       return new ForEachStatement.withReference(_mapToken(node.awaitKeyword),
           _mapToken(node.forKeyword), _mapToken(node.leftParenthesis),
           _cloneNode(node.identifier), _mapToken(node.inKeyword),
           _cloneNode(node.iterable), _mapToken(node.rightParenthesis),
           _cloneNode(node.body));
@@ skipping 27 matching lines @@
           _cloneNode(node.name), _cloneNode(node.functionExpression));
 
   @override
   FunctionDeclarationStatement visitFunctionDeclarationStatement(
           FunctionDeclarationStatement node) =>
       new FunctionDeclarationStatement(_cloneNode(node.functionDeclaration));
 
   @override
   FunctionExpression visitFunctionExpression(FunctionExpression node) {
     FunctionExpression copy = new FunctionExpression(
-        _cloneNode(node.parameters), _cloneNode(node.body));
+        _cloneNode(node.typeParameters), _cloneNode(node.parameters),
+        _cloneNode(node.body));
     copy.element = node.element;
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   FunctionExpressionInvocation visitFunctionExpressionInvocation(
       FunctionExpressionInvocation node) {
     FunctionExpressionInvocation copy = new FunctionExpressionInvocation(
-        _cloneNode(node.function), _cloneNode(node.argumentList));
+        _cloneNode(node.function), _cloneNode(node.typeArguments),
+        _cloneNode(node.argumentList));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) =>
       new FunctionTypeAlias(_cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata), _mapToken(node.typedefKeyword),
           _cloneNode(node.returnType), _cloneNode(node.name),
           _cloneNode(node.typeParameters), _cloneNode(node.parameters),
           _mapToken(node.semicolon));
 
   @override
   FunctionTypedFormalParameter visitFunctionTypedFormalParameter(
       FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter(
       _cloneNode(node.documentationComment), _cloneNodeList(node.metadata),
       _cloneNode(node.returnType), _cloneNode(node.identifier),
-      _cloneNode(node.parameters));
+      _cloneNode(node.typeParameters), _cloneNode(node.parameters));
 
   @override
   HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator(
       _mapToken(node.keyword), _cloneNodeList(node.hiddenNames));
 
   @override
   IfStatement visitIfStatement(IfStatement node) => new IfStatement(
       _mapToken(node.ifKeyword), _mapToken(node.leftParenthesis),
       _cloneNode(node.condition), _mapToken(node.rightParenthesis),
       _cloneNode(node.thenStatement), _mapToken(node.elseKeyword),
@@ skipping 121 matching lines @@
   MapLiteralEntry visitMapLiteralEntry(
       MapLiteralEntry node) => new MapLiteralEntry(
       _cloneNode(node.key), _mapToken(node.separator), _cloneNode(node.value));
 
   @override
   MethodDeclaration visitMethodDeclaration(MethodDeclaration node) =>
       new MethodDeclaration(_cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata), _mapToken(node.externalKeyword),
           _mapToken(node.modifierKeyword), _cloneNode(node.returnType),
           _mapToken(node.propertyKeyword), _mapToken(node.operatorKeyword),
-          _cloneNode(node.name), _cloneNode(node.parameters),
-          _cloneNode(node.body));
+          _cloneNode(node.name), _cloneNode(node._typeParameters),
+          _cloneNode(node.parameters), _cloneNode(node.body));
 
   @override
   MethodInvocation visitMethodInvocation(MethodInvocation node) {
     MethodInvocation copy = new MethodInvocation(_cloneNode(node.target),
         _mapToken(node.operator), _cloneNode(node.methodName),
-        _cloneNode(node.argumentList));
+        _cloneNode(node.typeArguments), _cloneNode(node.argumentList));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   NamedExpression visitNamedExpression(NamedExpression node) {
     NamedExpression copy =
         new NamedExpression(_cloneNode(node.name), _cloneNode(node.expression));
     copy.propagatedType = node.propagatedType;
@@ skipping 1515 matching lines @@
 }
 
 /**
  * A method declaration.
  *
  * > methodDeclaration ::=
  * >     methodSignature [FunctionBody]
  * >
  * > methodSignature ::=
  * >     'external'? ('abstract' | 'static')? [Type]? ('get' | 'set')?
- * >     methodName [FormalParameterList]
+ * >     methodName [TypeParameterList] [FormalParameterList]
  * >
  * > methodName ::=
  * >     [SimpleIdentifier]
  * >   | 'operator' [SimpleIdentifier]
  */
 class MethodDeclaration extends ClassMember {
   /**
    * The token for the 'external' keyword, or `null` if the constructor is not
    * external.
    */
@@ skipping 21 matching lines @@
    * does not declare an operator.
    */
   Token operatorKeyword;
 
   /**
    * The name of the method.
    */
   SimpleIdentifier _name;
 
   /**
+   * The type parameters associated with the method, or `null` if the method is
+   * not a generic method.
+   */
+  TypeParameterList _typeParameters;
+
+  /**
    * The parameters associated with the method, or `null` if this method
    * declares a getter.
    */
   FormalParameterList _parameters;
 
   /**
    * The body of the method.
    */
   FunctionBody _body;
 
   /**
    * Initialize a newly created method declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [externalKeyword] can be `null` if the method
    * is not external. The [modifierKeyword] can be `null` if the method is
    * neither abstract nor static. The [returnType] can be `null` if no return
    * type was specified. The [propertyKeyword] can be `null` if the method is
    * neither a getter or a setter. The [operatorKeyword] can be `null` if the
    * method does not implement an operator. The [parameters] must be `null` if
    * this method declares a getter.
    */
   MethodDeclaration(Comment comment, List<Annotation> metadata,
       this.externalKeyword, this.modifierKeyword, TypeName returnType,
       this.propertyKeyword, this.operatorKeyword, SimpleIdentifier name,
-      FormalParameterList parameters, FunctionBody body)
+      TypeParameterList typeParameters, FormalParameterList parameters,
+      FunctionBody body)
       : super(comment, metadata) {
     _returnType = _becomeParentOf(returnType);
     _name = _becomeParentOf(name);
+    _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
     _body = _becomeParentOf(body);
   }
 
   /**
    * Return the body of the method.
    */
   FunctionBody get body => _body;
 
   /**
@@ skipping 106 matching lines @@
    */
   TypeName get returnType => _returnType;
 
   /**
    * Set the return type of the method to the given [typeName].
    */
   void set returnType(TypeName typeName) {
     _returnType = _becomeParentOf(typeName);
   }
 
+  /**
+   * Return the type parameters associated with this method, or `null` if this
+   * method is not a generic method.
+   */
+  TypeParameterList get typeParameters => _typeParameters;
+
+  /**
+   * Set the type parameters associated with this method to the given
+   * [typeParameters].
+   */
+  void set typeParameters(TypeParameterList typeParameters) {
+    _typeParameters = _becomeParentOf(typeParameters);
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitMethodDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _safelyVisitChild(_returnType, visitor);
     _safelyVisitChild(_name, visitor);
+    _safelyVisitChild(_typeParameters, visitor);
     _safelyVisitChild(_parameters, visitor);
     _safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * The invocation of either a function or a method. Invocations of functions
  * resulting from evaluating an expression are represented by
  * [FunctionExpressionInvocation] nodes. Invocations of getters and setters are
  * represented by either [PrefixedIdentifier] or [PropertyAccess] nodes.
  *
  * > methodInvoction ::=
- * >     ([Expression] '.')? [SimpleIdentifier] [ArgumentList]
+ * >     ([Expression] '.')? [SimpleIdentifier] [TypeArgumentList]? [ArgumentList]
  */
 class MethodInvocation extends Expression {
   /**
    * The expression producing the object on which the method is defined, or
    * `null` if there is no target (that is, the target is implicitly `this`).
    */
   Expression _target;
 
   /**
    * The operator that separates the target from the method name, or `null`
    * if there is no target. In an ordinary method invocation this will be a
    * period ('.'). In a cascade section this will be the cascade operator
    * ('..').
    */
   Token operator;
 
   /**
    * The name of the method being invoked.
    */
   SimpleIdentifier _methodName;
 
   /**
+   * The type arguments to be applied to the method being invoked, or `null` if
+   * no type arguments were provided.
+   */
+  TypeArgumentList _typeArguments;
+
+  /**
    * The list of arguments to the method.
    */
   ArgumentList _argumentList;
 
   /**
    * Initialize a newly created method invocation. The [target] and [operator]
    * can be `null` if there is no target.
    */
   MethodInvocation(Expression target, this.operator,
-      SimpleIdentifier methodName, ArgumentList argumentList) {
+      SimpleIdentifier methodName, TypeArgumentList typeArguments,
+      ArgumentList argumentList) {
     _target = _becomeParentOf(target);
     _methodName = _becomeParentOf(methodName);
+    _typeArguments = _becomeParentOf(typeArguments);
     _argumentList = _becomeParentOf(argumentList);
   }
 
   /**
    * Return the list of arguments to the method.
    */
   ArgumentList get argumentList => _argumentList;
 
   /**
    * Set the list of arguments to the method to the given [argumentList].
@@ skipping 96 matching lines @@
   Expression get target => _target;
 
   /**
    * Set the expression producing the object on which the method is defined to
    * the given [expression].
    */
   void set target(Expression expression) {
     _target = _becomeParentOf(expression);
   }
 
+  /**
+   * Return the type arguments to be applied to the method being invoked, or
+   * `null` if no type arguments were provided.
+   */
+  TypeArgumentList get typeArguments => _typeArguments;
+
+  /**
+   * Set the type arguments to be applied to the method being invoked to the
+   * given [typeArguments].
+   */
+  void set typeArguments(TypeArgumentList typeArguments) {
+    _typeArguments = _becomeParentOf(typeArguments);
+  }
+
   @override
   accept(AstVisitor visitor) => visitor.visitMethodInvocation(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_target, visitor);
     _safelyVisitChild(_methodName, visitor);
+    _safelyVisitChild(_typeArguments, visitor);
     _safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * A node that declares a single name within the scope of a compilation unit.
  */
 abstract class NamedCompilationUnitMember extends CompilationUnitMember {
   /**
    * The name of the member being declared.
@@ skipping 5956 matching lines @@
     _writer.print(";");
     return null;
   }
 
   @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     _visitTokenWithSuffix(node.keyword, " ");
     _visitNodeWithSuffix(node.type, " ");
     _writer.print("this.");
     _visitNode(node.identifier);
+    _visitNode(node.typeParameters);
     _visitNode(node.parameters);
     return null;
   }
 
   @override
   Object visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (node.awaitKeyword != null) {
       _writer.print("await ");
     }
@@ skipping 68 matching lines @@
   }
 
   @override
   Object visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     _visitNode(node.functionDeclaration);
     return null;
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
+    _visitNode(node.typeParameters);
     _visitNode(node.parameters);
     _writer.print(' ');
     _visitNode(node.body);
     return null;
   }
 
   @override
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     _visitNode(node.function);
+    _visitNode(node.typeArguments);
     _visitNode(node.argumentList);
     return null;
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _writer.print("typedef ");
     _visitNodeWithSuffix(node.returnType, " ");
     _visitNode(node.name);
     _visitNode(node.typeParameters);
     _visitNode(node.parameters);
     _writer.print(";");
     return null;
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     _visitNodeWithSuffix(node.returnType, " ");
     _visitNode(node.identifier);
+    _visitNode(node.typeParameters);
     _visitNode(node.parameters);
     return null;
   }
 
   @override
   Object visitHideCombinator(HideCombinator node) {
     _writer.print("hide ");
     _visitNodeListWithSeparator(node.hiddenNames, ", ");
     return null;
   }
@@ skipping 153 matching lines @@
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitTokenWithSuffix(node.externalKeyword, " ");
     _visitTokenWithSuffix(node.modifierKeyword, " ");
     _visitNodeWithSuffix(node.returnType, " ");
     _visitTokenWithSuffix(node.propertyKeyword, " ");
     _visitTokenWithSuffix(node.operatorKeyword, " ");
     _visitNode(node.name);
     if (!node.isGetter) {
+      _visitNode(node.typeParameters);
       _visitNode(node.parameters);
     }
     _visitFunctionWithPrefix(" ", node.body);
     return null;
   }
 
   @override
   Object visitMethodInvocation(MethodInvocation node) {
     if (node.isCascaded) {
       _writer.print("..");
     } else {
       if (node.target != null) {
         node.target.accept(this);
         _writer.print(node.operator.lexeme);
       }
     }
     _visitNode(node.methodName);
+    _visitNode(node.typeArguments);
     _visitNode(node.argumentList);
     return null;
   }
 
   @override
   Object visitNamedExpression(NamedExpression node) {
     _visitNode(node.name);
     _visitNodeWithPrefix(" ", node.expression);
     return null;
   }
@@ skipping 1971 matching lines @@
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }