Generic method support in element model

pkg/analyzer/lib/src/generated/element.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.element;
 
 import 'dart:collection';
@@ skipping 3575 matching lines @@
 
   /**
    * Return the return type defined by this executable element.
    */
   DartType get returnType;
 
   /**
    * Return the type of function defined by this executable element.
    */
   FunctionType get type;
+
+  /**
+   * Return a list containing all of the type parameters defined for this
+   * executable element.
+   */
+  List<TypeParameterElement> get typeParameters;
 }
 
 /**
  * A base class for concrete implementations of an [ExecutableElement].
  */
 abstract class ExecutableElementImpl extends ElementImpl
     implements ExecutableElement {
   /**
    * An empty list of executable elements.
    */
@@ skipping 17 matching lines @@
    * element.
    */
   List<LocalVariableElement> _localVariables = LocalVariableElement.EMPTY_LIST;
 
   /**
    * A list containing all of the parameters defined by this executable element.
    */
   List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
 
   /**
+   * A list containing all of the type parameters defined for this function.

[scheglov, 2015/07/06 15:03:21]

"for this executable element"?

[Brian Wilkerson, 2015/07/09 22:02:27]

Done

+   */
+  List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
+
+  /**
    * The return type defined by this executable element.
    */
   DartType returnType;
 
   /**
    * The type of function defined by this executable element.
    */
   FunctionType type;
 
   /**
@@ skipping 96 matching lines @@
    * [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
   @override
+  List<TypeParameterElement> get typeParameters => _typeParameters;
+
+  /**
+   * Set the type parameters defined by this executable element to the given
+   * [typeParameters].
+   */
+  void set typeParameters(List<TypeParameterElement> typeParameters) {
+    for (TypeParameterElement parameter in typeParameters) {
+      (parameter as TypeParameterElementImpl).enclosingElement = this;
+    }
+    this._typeParameters = typeParameters;
+  }
+
+  @override
   void appendTo(StringBuffer buffer) {
     if (this.kind != ElementKind.GETTER) {
+      int typeParameterCount = _typeParameters.length;
+      if (typeParameterCount > 0) {
+        buffer.write('<');
+        for (int i = 0; i < typeParameterCount; i++) {
+          if (i > 0) {
+            buffer.write(", ");
+          }
+          (_typeParameters[i] as TypeParameterElementImpl).appendTo(buffer);
+        }
+        buffer.write('>');
+      }
       buffer.write("(");
       String closing = null;
       ParameterKind kind = ParameterKind.REQUIRED;
       int parameterCount = _parameters.length;
       for (int i = 0; i < parameterCount; i++) {
         if (i > 0) {
           buffer.write(", ");
         }
         ParameterElementImpl parameter = _parameters[i] as ParameterElementImpl;
         ParameterKind parameterKind = parameter.parameterKind;
@@ skipping 135 matching lines @@
     return parameterizedParameters;
   }
 
   @override
   DartType get returnType => substituteFor(baseElement.returnType);
 
   @override
   FunctionType get type => substituteFor(baseElement.type);
 
   @override
+  List<TypeParameterElement> get typeParameters => baseElement.typeParameters;
+
+  @override
   void visitChildren(ElementVisitor visitor) {
     // TODO(brianwilkerson) We need to finish implementing the accessors used
     // below so that we can safely invoke them.
     super.visitChildren(visitor);
     safelyVisitChildren(baseElement.functions, visitor);
     safelyVisitChildren(labels, visitor);
     safelyVisitChildren(baseElement.localVariables, visitor);
     safelyVisitChildren(parameters, visitor);
   }
 }
@@ skipping 4681 matching lines @@
    */
   ParameterKind get parameterKind;
 
   /**
    * Return a list containing all of the parameters defined by this parameter.
    * A parameter will only define other parameters if it is a function typed
    * parameter.
    */
   List<ParameterElement> get parameters;
 
+  /**
+   * Return a list containing all of the type parameters defined by this
+   * parameter. A parameter will only define other parameters if it is a
+   * function typed parameter.
+   */
+  List<TypeParameterElement> get typeParameters;
+
   @override
   FormalParameter computeNode();
 }
 
 /**
  * A concrete implementation of a [ParameterElement].
  */
 class ParameterElementImpl extends VariableElementImpl
     with PotentiallyConstVariableElement implements ParameterElement {
   /**
    * An empty list of parameter elements.
    */
   @deprecated // Use ParameterElement.EMPTY_LIST
   static const List<ParameterElement> EMPTY_ARRAY = const <ParameterElement>[];
 
   /**
    * A list containing all of the parameters defined by this parameter element.
    * There will only be parameters if this parameter is a function typed
    * parameter.
    */
   List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
 
   /**
+   * A list containing all of the type parameters defined for this parameter
+   * element. There will only be parameters if this parameter is a function
+   * typed parameter.
+   */
+  List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
+
+  /**
    * The kind of this parameter.
    */
   ParameterKind parameterKind;
 
   /**
    * The Dart code of the default value.
    */
   String _defaultValueCode;
 
   /**
@@ skipping 50 matching lines @@
    * [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
   @override
+  List<TypeParameterElement> get typeParameters => _typeParameters;
+
+  /**
+   * Set the type parameters defined by this executable element to the given

[scheglov, 2015/07/06 15:03:21]

"defined by this parameter element"?

[Brian Wilkerson, 2015/07/09 22:02:28]

Done

+   * [typeParameters].
+   */
+  void set typeParameters(List<TypeParameterElement> typeParameters) {
+    for (TypeParameterElement parameter in typeParameters) {
+      (parameter as TypeParameterElementImpl).enclosingElement = this;
+    }
+    this._typeParameters = typeParameters;
+  }
+
+  @override
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
 
@@ skipping 135 matching lines @@
     List<ParameterElement> parameterizedParameters =
         new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       parameterizedParameters[i] =
           ParameterMember.from(baseParameters[i], definingType);
     }
     return parameterizedParameters;
   }
 
   @override
+  List<TypeParameterElement> get typeParameters => baseElement.typeParameters;
+
+  @override
   SourceRange get visibleRange => baseElement.visibleRange;
 
   @override
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
 
   @override
   FormalParameter computeNode() => baseElement.computeNode();
 
   @override
   Element getAncestor(Predicate<Element> predicate) {
@@ skipping 1773 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }