tweak FunctionTypeImpl to support generic methods

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.
 
 library engine.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/src/generated/utilities_general.dart';
@@ skipping 110 matching lines @@
     buffer.write('...');
   }
 
   @override
   TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
 }
 
 /**
  * An element that represents a class.
  */
-abstract class ClassElement implements TypeDefiningElement {
+abstract class ClassElement
+    implements TypeDefiningElement, TypeParameterizedElement {
   /**
    * An empty list of class elements.
    */
   static const List<ClassElement> EMPTY_LIST = const <ClassElement>[];
 
   /**
    * Return a list containing all of the accessors (getters and setters)
    * declared in this class.
    */
   List<PropertyAccessorElement> get accessors;
@@ skipping 120 matching lines @@
    * safe to assume that the inheritance structure of a class does not contain a
    * cycle. Clients that traverse the inheritance structure must explicitly
    * guard against infinite loops.
    */
   InterfaceType get supertype;
 
   @override
   InterfaceType get type;
 
   /**
-   * Return a list containing all of the type parameters declared for this
-   * class.
-   */
-  List<TypeParameterElement> get typeParameters;
-
-  /**
    * Return the unnamed constructor declared in this class, or `null` if this
    * class does not declare an unnamed constructor but does declare named
    * constructors. The returned constructor will be synthetic if this class does
    * not declare any constructors, in which case it will represent the default
    * constructor for the class.
    */
   ConstructorElement get unnamedConstructor;
 
   /**
    * Return the resolved [ClassDeclaration] or [EnumDeclaration] node that
@@ skipping 847 matching lines @@
           implicitParameter.const3 = superParameter.isConst;
           implicitParameter.final2 = superParameter.isFinal;
           implicitParameter.parameterKind = superParameter.parameterKind;
           implicitParameter.synthetic = true;
           implicitParameter.type =
               superParameter.type.substitute2(argumentTypes, parameterTypes);
           implicitParameters[i] = implicitParameter;
         }
         implicitConstructor.parameters = implicitParameters;
       }
-      FunctionTypeImpl constructorType =
-          new FunctionTypeImpl(implicitConstructor);
-      constructorType.typeArguments = type.typeArguments;
-      implicitConstructor.type = constructorType;
       implicitConstructor.enclosingElement = this;
+      implicitConstructor.type = new FunctionTypeImpl(implicitConstructor);
       return implicitConstructor;
     }).toList();
   }
 
   PropertyAccessorElement _internalLookUpConcreteGetter(
       String getterName, LibraryElement library, bool includeThisClass) {
     PropertyAccessorElement getter =
         _internalLookUpGetter(getterName, library, includeThisClass);
     while (getter != null && getter.isAbstract) {
       Element definingClass = getter.enclosingElement;
@@ skipping 2415 matching lines @@
   @override
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChild(_scriptLibrary, visitor);
   }
 }
 
 /**
  * An element representing an executable object, including functions, methods,
  * constructors, getters, and setters.
  */
-abstract class ExecutableElement implements Element {
+abstract class ExecutableElement implements TypeParameterizedElement {
   /**
    * An empty list of executable elements.
    */
   static const List<ExecutableElement> EMPTY_LIST = const <ExecutableElement>[];
 
   /**
    * Return a list containing all of the functions defined within this
    * executable element.
    */
   List<FunctionElement> get functions;
@@ skipping 73 matching lines @@
    * Return the return type defined by this executable element. If the element
    * model is fully populated, then the [returnType] will not be `null`, even
    * if no return type was explicitly specified.
    */
   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 956 matching lines @@
    * Return the type resulting from substituting the given [argumentTypes] for
    * this type's parameters. This is fully equivalent to
    * `substitute(argumentTypes, getTypeArguments())`.
    */
   FunctionType substitute3(List<DartType> argumentTypes);
 }
 
 /**
  * A function type alias (`typedef`).
  */
-abstract class FunctionTypeAliasElement implements TypeDefiningElement {
+abstract class FunctionTypeAliasElement
+    implements TypeDefiningElement, TypeParameterizedElement {
   /**
    * An empty array of type alias elements.
    */
   static List<FunctionTypeAliasElement> EMPTY_LIST =
       new List<FunctionTypeAliasElement>(0);
 
   /**
    * Return the compilation unit in which this type alias is defined.
    */
   @override
   CompilationUnitElement get enclosingElement;
 
   /**
    * Return a list containing all of the parameters defined by this type alias.
    */
   List<ParameterElement> get parameters;
 
   /**
    * Return the return type defined by this type alias.
    */
   DartType get returnType;
 
   @override
   FunctionType get type;
 
   /**
-   * Return a list containing all of the type parameters defined for this type.
-   */
-  List<TypeParameterElement> get typeParameters;
-
-  /**
    * Return the resolved function type alias node that declares this element.
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    */
   @override
   FunctionTypeAlias computeNode();
 }
 
 /**
@@ skipping 158 matching lines @@
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
     safelyVisitChildren(_typeParameters, visitor);
   }
 }
 
 /**
  * The type of a function, method, constructor, getter, or setter.
  */
 class FunctionTypeImpl extends TypeImpl implements FunctionType {
-  /**
-   * A list containing the actual types of the type arguments.
-   */
-  List<DartType> typeArguments = DartType.EMPTY_LIST;
+  List<DartType> _typeArguments = DartType.EMPTY_LIST;

[Brian Wilkerson, 2015/11/13 18:56:16]

Not sure why you removed the comment. If it was wrong, could you add one that's
right? (I like to document everything, including private members.)

[Jennifer Messerly, 2015/11/13 19:04:46]

The comment moved to the public getter. Normally I would keep the getter by the
field, but "sort members" moved it down. Does that work for you? Would you
prefer the comment be only on the field instead of the public getter?

[Brian Wilkerson, 2015/11/13 20:17:14]

I know it's redundant, but I always comment both. Perhaps we should change
server so that if a private field doesn't have a comment we look for a public
getter with the same name (minus the `_`) and return it's comment...

[Jennifer Messerly, 2015/11/13 22:53:14]

yeah that would be good!

In the meantime, done! I wrote a line that also links to the getter (via
[typeArguments]). That way it won't be a full copy+paste. I always worry about
copy+paste as it leads to multiple places to update... which creates a bit of a
perverse incentive for writing long, high quality comments, or improving
existing ones.

 
   /**
    * The set of typedefs which should not be expanded when exploring this type,
    * to avoid creating infinite types in response to self-referential typedefs.
    */
   final List<FunctionTypeAliasElement> prunedTypedefs;
 
   /**
    * Initialize a newly created function type to be declared by the given
-   * [element].
+   * [element], and also initialize [typeArguments] to match the
+   * [typeParameters], which permits later substitution.
    */
-  FunctionTypeImpl(ExecutableElement element, [this.prunedTypedefs])
-      : super(element, null);
+  FunctionTypeImpl(ExecutableElement element,
+      [List<FunctionTypeAliasElement> prunedTypedefs])
+      : this._(element, null, prunedTypedefs, null);
 
   /**
    * Initialize a newly created function type to be declared by the given
    * [element].
    */
   @deprecated // Use new FunctionTypeImpl(element)
   FunctionTypeImpl.con1(ExecutableElement element) : this(element);
 
   /**
    * Initialize a newly created function type to be declared by the given
    * [element].
    */
   @deprecated // Use new FunctionTypeImpl.forTypedef(element)
   FunctionTypeImpl.con2(FunctionTypeAliasElement element)
       : this.forTypedef(element);
 
   /**
    * Initialize a newly created function type to be declared by the given
    * [element].
    */
   FunctionTypeImpl.forTypedef(FunctionTypeAliasElement element,
-      [this.prunedTypedefs])
-      : super(element, element == null ? null : element.name);
+      [List<FunctionTypeAliasElement> prunedTypedefs])
+      : this._(element, element?.name, prunedTypedefs, null);
 
   /**
    * Private constructor.
    */
-  FunctionTypeImpl._(Element element, String name, this.prunedTypedefs)
-      : super(element, name);
+  FunctionTypeImpl._(Element element, String name, this.prunedTypedefs,
+      List<DartType> typeArguments)
+      : super(element, name) {
+    if (typeArguments != null) {
+      _typeArguments = typeArguments;
+    } else {
+      List<TypeParameterElement> typeParameters = this.typeParameters;

[Brian Wilkerson, 2015/11/13 18:56:16]

See TypeParameterTypeImpl.getTypes

[Jennifer Messerly, 2015/11/13 19:04:46]

Yeah, I tried that first. Unfortunately that doesn't work, because it returns
the wrong reified List type (List<TypeParameterType> instead of List<DartType).

The good news: generic methods will help us fix this! We can have getTypes<T>,
where `T extends DartType` ... which will support both use cases. :)

I can add a TODO, if that works for you:

    // TODO(jmesserly): reuse TypeParameterTypeImpl.getTypes once it is generic,
and can return List<DartType>

[Brian Wilkerson, 2015/11/13 20:17:14]

Yes, a comment would be great, thanks!

[Jennifer Messerly, 2015/11/13 22:53:14]

Done.

+      if (typeParameters.isEmpty) {
+        _typeArguments = DartType.EMPTY_LIST;
+      } else {
+        _typeArguments = new List<DartType>.from(
+            typeParameters.map((t) => t.type),
+            growable: false);
+      }
+    }
+  }
 
   /**
    * Return the base parameter elements of this function element.
    */
   List<ParameterElement> get baseParameters {
     Element element = this.element;
     if (element is ExecutableElement) {
       return element.parameters;
     } else {
       return (element as FunctionTypeAliasElement).parameters;
@@ skipping 231 matching lines @@
     // If there are no arguments to substitute, or if the arguments size doesn't
     // match the parameter size, return the base return type.
     if (typeArguments.length == 0 ||
         typeArguments.length != typeParameters.length) {
       return (baseReturnType as TypeImpl).pruned(newPrune);
     }
     return (baseReturnType as TypeImpl).substitute2(typeArguments,
         TypeParameterTypeImpl.getTypes(typeParameters), newPrune);
   }
 
+  /**
+   * A list containing the actual types of the type arguments.
+   */
+  List<DartType> get typeArguments => _typeArguments;
+
   @override
   List<TypeParameterElement> get typeParameters {
-    Element element = this.element;
-    if (element is FunctionTypeAliasElement) {
-      return element.typeParameters;
+    // Combine the generic type arguments from all enclosing contexts.
+    // For example, this could be a generic method in a class, or a local
+    // function within another function.
+    List<TypeParameterElement> typeParams = <TypeParameterElement>[];
+    for (Element e = element; e != null; e = e.enclosingElement) {
+      if (e is TypeParameterizedElement) {
+        typeParams.addAll(e.typeParameters);
+      }
     }
-    ClassElement definingClass =
-        element.getAncestor((element) => element is ClassElement);
-    if (definingClass != null) {
-      return definingClass.typeParameters;
-    }
-    return TypeParameterElement.EMPTY_LIST;
+    return typeParams;
   }
 
   @override
   bool operator ==(Object object) {
     if (object is! FunctionTypeImpl) {
       return false;
     }
     FunctionTypeImpl otherType = object as FunctionTypeImpl;
     return returnType == otherType.returnType &&
         TypeImpl.equalArrays(
@@ skipping 305 matching lines @@
       return this;
     } else if (prune.contains(element)) {
       // Circularity found.  Prune the type declaration.
       return new CircularTypeImpl();
     } else {
       // There should never be a reason to prune a type that has already been
       // pruned, since pruning is only done when expanding a function type
       // alias, and function type aliases are always expanded by starting with
       // base types.
       assert(this.prunedTypedefs == null);
-      FunctionTypeImpl result = new FunctionTypeImpl._(element, name, prune);
-      result.typeArguments =
-          typeArguments.map((TypeImpl t) => t.pruned(prune)).toList();
-      return result;
+      List<DartType> typeArgs = typeArguments
+          .map((TypeImpl t) => t.pruned(prune))
+          .toList(growable: false);
+      return new FunctionTypeImpl._(element, name, prune, typeArgs);
     }
   }
 
   @override
   DartType substitute2(
       List<DartType> argumentTypes, List<DartType> parameterTypes,
       [List<FunctionTypeAliasElement> prune]) {
-    // Pruned types should only ever result from peforming type variable
+    // Pruned types should only ever result from performing type variable
     // substitution, and it doesn't make sense to substitute again after
     // substituting once.
     assert(this.prunedTypedefs == null);
     if (argumentTypes.length != parameterTypes.length) {
       throw new IllegalArgumentException(
           "argumentTypes.length (${argumentTypes.length}) != parameterTypes.length (${parameterTypes.length})");
     }
     Element element = this.element;
     if (prune != null && prune.contains(element)) {
       // Circularity found.  Prune the type declaration.
       return new CircularTypeImpl();
     }
     if (argumentTypes.length == 0) {
       return this.pruned(prune);
     }
-    FunctionTypeImpl newType = (element is ExecutableElement)
-        ? new FunctionTypeImpl(element, prune)
-        : new FunctionTypeImpl.forTypedef(
-            element as FunctionTypeAliasElement, prune);
-    newType.typeArguments =
+    List<DartType> typeArgs =
         TypeImpl.substitute(typeArguments, argumentTypes, parameterTypes);
-    return newType;
+    return new FunctionTypeImpl._(element, name, prune, typeArgs);
   }
 
   @override
   FunctionTypeImpl substitute3(List<DartType> argumentTypes) =>
       substitute2(argumentTypes, typeArguments);
 
   /**
    * Compute the least upper bound of types [f] and [g], both of which are
    * known to be function types.
    *
@@ skipping 2794 matching lines @@
     List<DartType> argumentTypes = _definingType.typeArguments;
     List<DartType> parameterTypes =
         TypeParameterTypeImpl.getTypes(_definingType.typeParameters);
     return type.substitute2(argumentTypes, parameterTypes);
   }
 
   /**
    * Return the list of types that results from replacing the type parameters in
    * the given [types] with the type arguments associated with this member.
    */
+  @deprecated
   List<InterfaceType> substituteFor2(List<InterfaceType> types) {
     int count = types.length;
     List<InterfaceType> substitutedTypes = new List<InterfaceType>(count);
     for (int i = 0; i < count; i++) {
       substitutedTypes[i] = substituteFor(types[i]);
     }
     return substitutedTypes;
   }
 
   @override
@@ skipping 2164 matching lines @@
   void appendTo(StringBuffer buffer) {
     buffer.write(displayName);
     if (bound != null) {
       buffer.write(" extends ");
       buffer.write(bound);
     }
   }
 }
 
 /**
+ * An element that has type parameters.
+ *
+ * For example, a class or a typedef. This also includes functions methods if

[Brian Wilkerson, 2015/11/13 18:56:16]

nit: "functions" --> "function"

[Jennifer Messerly, 2015/11/13 19:04:46]

oops, it should be "functions and methods"

[Jennifer Messerly, 2015/11/13 22:53:14]

Done.

+ * support for generic methods is enabled.
+ */
+abstract class TypeParameterizedElement implements Element {
+  /**
+   * Return a list containing all of the type parameters declared for this
+   * class.
+   */
+  List<TypeParameterElement> get typeParameters;
+}
+
+/**
  * The type introduced by a type parameter.
  */
 abstract class TypeParameterType implements DartType {
   /**
    * An empty list of type parameter types.
    */
   static const List<TypeParameterType> EMPTY_LIST = const <TypeParameterType>[];
 
   @override
   TypeParameterElement get element;
@@ skipping 590 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }