Allow explicitly passing generic function type args

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 1975 matching lines @@
 
 /**
  * A constructor element defined in a parameterized type where the values of the
  * type parameters are known.
  */
 class ConstructorMember extends ExecutableMember implements ConstructorElement {
   /**
    * Initialize a newly created element to represent a constructor, based on the
    * [baseElement], defined by the [definingType].
    */
-  ConstructorMember(ConstructorElement baseElement, InterfaceType definingType)
-      : super(baseElement, definingType);
+  ConstructorMember(ConstructorElement baseElement, InterfaceType definingType,
+      [FunctionType type])

[Leaf, 2015/12/05 00:50:40]

Document what type is in the comment?

[Jennifer Messerly, 2015/12/07 17:46:58]

Done.

+      : super(baseElement, definingType, type);
 
   @override
   ConstructorElement get baseElement => super.baseElement as ConstructorElement;
 
   @override
   InterfaceType get definingType => super.definingType as InterfaceType;
 
   @override
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
@@ skipping 67 matching lines @@
       // TODO(brianwilkerson) We need to understand when this can happen.
       return constructor;
     }
     List<DartType> argumentTypes = definingType.typeArguments;
     List<DartType> parameterTypes = definingType.element.type.typeArguments;
     FunctionType substitutedType =
         baseType.substitute2(argumentTypes, parameterTypes);
     if (baseType == substitutedType) {
       return constructor;
     }
-    // TODO(brianwilkerson) Consider caching the substituted type in the
-    // instance. It would use more memory but speed up some operations.
-    // We need to see how often the type is being re-computed.
-    return new ConstructorMember(constructor, definingType);
+    return new ConstructorMember(constructor, definingType, substitutedType);
   }
 }
 
 /**
  * A [TopLevelVariableElement] for a top-level 'const' variable that has an
  * initializer.
  */
 class ConstTopLevelVariableElementImpl extends TopLevelVariableElementImpl
     with ConstVariableElement {
   /**
@@ skipping 1468 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 TypeParameterizedElement {
+abstract class ExecutableElement implements FunctionTypedElement {
   /**
    * 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 55 matching lines @@
    * Return a list containing all of the labels defined within this executable
    * element.
    */
   List<LabelElement> get labels;
 
   /**
    * Return a list containing all of the local variables defined within this
    * executable element.
    */
   List<LocalVariableElement> get localVariables;
-
-  /**
-   * Return a list containing all of the parameters defined by this executable
-   * element.
-   */
-  List<ParameterElement> get parameters;
-
-  /**
-   * 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;
 }
 
 /**
  * A base class for concrete implementations of an [ExecutableElement].
  */
 abstract class ExecutableElementImpl extends ElementImpl
     implements ExecutableElement {
   /**
    * An empty list of executable elements.
    */
@@ skipping 254 matching lines @@
     safelyVisitChildren(_localVariables, visitor);
     safelyVisitChildren(_parameters, visitor);
   }
 }
 
 /**
  * An executable element defined in a parameterized type where the values of the
  * type parameters are known.
  */
 abstract class ExecutableMember extends Member implements ExecutableElement {
+  @override
+  final FunctionType type;
+
   /**
    * Initialize a newly created element to represent a constructor, based on the
    * [baseElement], defined by the [definingType].
    */
-  ExecutableMember(ExecutableElement baseElement, InterfaceType definingType)
-      : super(baseElement, definingType);
+  ExecutableMember(ExecutableElement baseElement, InterfaceType definingType,
+      [FunctionType type])

[Leaf, 2015/12/05 00:50:40]

ditto?

[Jennifer Messerly, 2015/12/07 17:46:58]

Done.

+      : type = type ??
+            baseElement.type.substitute2(definingType.typeArguments,
+                TypeParameterTypeImpl.getTypes(definingType.typeParameters)),
+        super(baseElement, definingType);
 
   @override
   ExecutableElement get baseElement => super.baseElement as ExecutableElement;
 
   @override
   List<FunctionElement> get functions {
     //
     // Elements within this element should have type parameters substituted,
     // just like this element.
     //
@@ skipping 32 matching lines @@
   List<LocalVariableElement> get localVariables {
     //
     // Elements within this element should have type parameters substituted,
     // just like this element.
     //
     throw new UnsupportedOperationException();
 //    return getBaseElement().getLocalVariables();
   }
 
   @override
-  List<ParameterElement> get parameters {
-    List<ParameterElement> baseParameters = baseElement.parameters;
-    int parameterCount = baseParameters.length;
-    if (parameterCount == 0) {
-      return baseParameters;
-    }
-    List<ParameterElement> parameterizedParameters =
-        new List<ParameterElement>(parameterCount);
-    for (int i = 0; i < parameterCount; i++) {
-      parameterizedParameters[i] =
-          ParameterMember.from(baseParameters[i], definingType);
-    }
-    return parameterizedParameters;
-  }
+  List<ParameterElement> get parameters => type.parameters;
 
   @override
-  DartType get returnType => substituteFor(baseElement.returnType);
-
-  @override
-  FunctionType get type => substituteFor(baseElement.type);
+  DartType get returnType => type.returnType;
 
   @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);
@@ skipping 223 matching lines @@
  * A parameter element defined in a parameterized type where the values of the
  * type parameters are known.
  */
 class FieldFormalParameterMember extends ParameterMember
     implements FieldFormalParameterElement {
   /**
    * Initialize a newly created element to represent a constructor, based on the
    * [baseElement], defined by the [definingType].
    */
   FieldFormalParameterMember(
-      FieldFormalParameterElement baseElement, ParameterizedType definingType)
-      : super(baseElement, definingType);
+      FieldFormalParameterElement baseElement, ParameterizedType definingType,
+      [DartType type])

[Leaf, 2015/12/05 00:50:41]

also.

+      : super(baseElement, definingType, type);
 
   @override
   FieldElement get field {
     FieldElement field = (baseElement as FieldFormalParameterElement).field;
     if (field is FieldElement) {
-      return FieldMember.from(field, definingType);
+      return FieldMember.from(
+          field, substituteFor(field.enclosingElement.type));
     }
     return field;
   }
 
   @override
   accept(ElementVisitor visitor) =>
       visitor.visitFieldFormalParameterElement(this);
 }
 
 /**
  * A field element defined in a parameterized type where the values of the type
  * parameters are known.
  */
 class FieldMember extends VariableMember implements FieldElement {
   /**
    * Initialize a newly created element to represent a constructor, based on the
    * [baseElement], defined by the [definingType].
    */
   FieldMember(FieldElement baseElement, InterfaceType definingType)
       : super(baseElement, definingType);
 
   @override
   FieldElement get baseElement => super.baseElement as FieldElement;
 
   @override
-  InterfaceType get definingType => super.definingType as InterfaceType;
-
-  @override
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
   @override
   PropertyAccessorElement get getter =>
       PropertyAccessorMember.from(baseElement.getter, definingType);
 
   @override
   bool get isEnumConstant => baseElement.isEnumConstant;
 
   @override
@@ skipping 12 matching lines @@
   @override
   String toString() => '$type $displayName';
 
   /**
    * If the given [field]'s type is different when any type parameters from the
    * defining type's declaration are replaced with the actual type arguments
    * from the [definingType], create a field member representing the given
    * field. Return the member that was created, or the base field if no member
    * was created.
    */
-  static FieldElement from(FieldElement field, InterfaceType definingType) {
+  static FieldElement from(FieldElement field, ParameterizedType definingType) {
     if (!_isChangedByTypeSubstitution(field, definingType)) {
       return field;
     }
     // TODO(brianwilkerson) Consider caching the substituted type in the
     // instance. It would use more memory but speed up some operations.
     // We need to see how often the type is being re-computed.
     return new FieldMember(field, definingType);
   }
 
   /**
    * Determine whether the given [field]'s type is changed when type parameters
    * from the [definingType]'s declaration are replaced with the actual type
    * arguments from the defining type.
    */
   static bool _isChangedByTypeSubstitution(
-      FieldElement field, InterfaceType definingType) {
+      FieldElement field, ParameterizedType definingType) {
     List<DartType> argumentTypes = definingType.typeArguments;
     if (field != null && argumentTypes.length != 0) {
       DartType baseType = field.type;
-      List<DartType> parameterTypes = definingType.element.type.typeArguments;
+      List<DartType> parameterTypes =
+          (definingType.element as dynamic).type.typeArguments;

[Leaf, 2015/12/05 00:50:40]

Lack of a common superclass? Maybe at least a comment or assertion to document
the intended types that reach here?

[Jennifer Messerly, 2015/12/07 17:46:58]

yup, exactly. I actually have an idea for how to fix this. Let me give it a
shot.

       if (baseType != null) {
         DartType substitutedType =
             baseType.substitute2(argumentTypes, parameterTypes);
         if (baseType != substitutedType) {
           return true;
         }
       }
       // If the field has a propagated type, then we need to check whether the
       // propagated type needs substitution.
       DartType basePropagatedType = field.propagatedType;
@@ skipping 154 matching lines @@
    * Set the parameters defined by this type alias to the given [parameters]
    * without becoming the parent of the parameters. This should only be used by
    * the [TypeResolverVisitor] when creating a synthetic type alias.
    */
   void shareParameters(List<ParameterElement> parameters) {
     this._parameters = parameters;
   }
 }
 
 /**
+ * An element of a generic function, where the type parameters are known.
+ */
+// TODO(jmesserly): the term "function member" is a bit weird, but it allows
+// a certain consistency.
+class FunctionMember extends ExecutableMember implements FunctionElement {
+  /**
+   * Initialize a newly created element to represent a constructor, based on the
+   * [baseElement], defined by the [definingType].

[Leaf, 2015/12/05 00:50:40]

Comment cut & pasted?

[Jennifer Messerly, 2015/12/07 17:46:58]

Done.

[Jennifer Messerly, 2015/12/07 17:46:58]

Done.

+   */
+  FunctionMember(FunctionElement baseElement, [DartType type])
+      : super(baseElement, null, type);
+
+  @override
+  FunctionElement get baseElement => super.baseElement as FunctionElement;
+
+  @override
+  Element get enclosingElement => baseElement.enclosingElement;
+
+  @override
+  bool get isEntryPoint => baseElement.isEntryPoint;
+
+  @override
+  SourceRange get visibleRange => baseElement.visibleRange;
+
+  @override
+  accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
+
+  @override
+  FunctionDeclaration computeNode() => baseElement.computeNode();
+
+  @override
+  String toString() {
+    StringBuffer buffer = new StringBuffer();
+    buffer.write(baseElement.displayName);
+    (type as FunctionTypeImpl).appendTo(buffer);
+    return buffer.toString();
+  }
+
+  /**
+   * If the given [method]'s type is different when any type parameters from the
+   * defining type's declaration are replaced with the actual type arguments
+   * from the [definingType], create a method member representing the given
+   * method. Return the member that was created, or the base method if no member
+   * was created.
+   */
+  static MethodElement from(
+      MethodElement method, ParameterizedType definingType) {
+    if (method == null || definingType.typeArguments.length == 0) {
+      return method;
+    }
+    FunctionType baseType = method.type;
+    List<DartType> argumentTypes = definingType.typeArguments;
+    List<DartType> parameterTypes =
+        TypeParameterTypeImpl.getTypes(definingType.typeParameters);
+    FunctionType substitutedType =
+        baseType.substitute2(argumentTypes, parameterTypes);
+    if (baseType == substitutedType) {
+      return method;
+    }
+    return new MethodMember(method, definingType, substitutedType);
+  }
+}
+
+/**
  * The type of a function, method, constructor, getter, or setter. Function
  * types come in three variations:
  *
  * * The types of functions that only have required parameters. These have the
  *   general form <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T</i>.
  * * The types of functions with optional positional parameters. These have the
  *   general form <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, [T<sub>n+1</sub>
  *   &hellip;, T<sub>n+k</sub>]) &rarr; T</i>.
  * * The types of functions with named parameters. These have the general form
  *   <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, {T<sub>x1</sub> x1, &hellip;,
@@ skipping 124 matching lines @@
    * `substitute(argumentTypes, getTypeArguments())`.
    */
   @deprecated // use instantiate
   FunctionType substitute3(List<DartType> argumentTypes);
 }
 
 /**
  * A function type alias (`typedef`).
  */
 abstract class FunctionTypeAliasElement
-    implements TypeDefiningElement, TypeParameterizedElement {
+    implements TypeDefiningElement, FunctionTypedElement {
   /**
    * 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 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 137 matching lines @@
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
     safelyVisitChildren(_typeParameters, visitor);
   }
 }
 
 /**
+ * An element that has a [FunctionType] as its [type].
+ *
+ * This also provides convenient access to the parameters and return type.
+ */
+abstract class FunctionTypedElement implements TypeParameterizedElement {
+  /**
+   * Return a list containing all of the parameters defined by this executable
+   * element.
+   */
+  List<ParameterElement> get parameters;
+
+  /**
+   * Return the return type defined by this 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 element.
+   */
+  FunctionType get type;
+}
+
+/**
  * The type of a function, method, constructor, getter, or setter.
  */
 class FunctionTypeImpl extends TypeImpl implements FunctionType {
   /**
    * The list of [typeArguments].
    */
   List<DartType> _typeArguments;
 
   /**
    * The list of [typeParameters].
@@ skipping 84 matching lines @@
             typeParameters.map((t) => t.type),
             growable: false);
       }
     }
     _typeArguments = typeArguments;
   }
 
   /**
    * 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;
-    }
-  }
+  List<ParameterElement> get baseParameters => element.parameters;
 
   /**
    * Return the return type defined by this function's element.
    */
-  DartType get baseReturnType {
-    Element element = this.element;
-    if (element is ExecutableElement) {
-      return element.returnType;
-    } else {
-      return (element as FunctionTypeAliasElement).returnType;
-    }
-  }
+  DartType get baseReturnType => element.returnType;
 
   @override
   List<TypeParameterElement> get boundTypeParameters => _boundTypeParameters;
 
   @override
   String get displayName {
     String name = this.name;
     if (name == null || name.length == 0) {
       // Function types have an empty name when they are defined implicitly by
       // either a closure or as part of a parameter declaration.
@@ skipping 56 matching lines @@
         buffer.write("null");
       } else {
         buffer.write(returnType.displayName);
       }
       name = buffer.toString();
     }
     return name;
   }
 
   @override
+  FunctionTypedElement get element => super.element;
+
+  @override
   int get hashCode {
     if (element == null) {
       return 0;
     }
     // Reference the arrays of parameters
     List<DartType> normalParameterTypes = this.normalParameterTypes;
     List<DartType> optionalParameterTypes = this.optionalParameterTypes;
     Iterable<DartType> namedParameterTypes = this.namedParameterTypes.values;
     // Generate the hashCode
     int code = (returnType as TypeImpl).hashCode;
     for (int i = 0; i < normalParameterTypes.length; i++) {
       code = (code << 1) + (normalParameterTypes[i] as TypeImpl).hashCode;
     }
     for (int i = 0; i < optionalParameterTypes.length; i++) {
       code = (code << 1) + (optionalParameterTypes[i] as TypeImpl).hashCode;
     }
     for (DartType type in namedParameterTypes) {
       code = (code << 1) + (type as TypeImpl).hashCode;
     }
     return code;
   }
 
+  /**
+   * The type arguments that were used to instantiate this function type, if
+   * any, otherwise this will return an empty list.
+   *
+   * Given a function type `f`:
+   *
+   *     f == f.originalFunction.instantiate(f.instantiatedTypeArguments)
+   *
+   * Will always hold.
+   */
+  List<DartType> get instantiatedTypeArguments {
+    int typeParameterCount = element.type.boundTypeParameters.length;
+    if (typeParameterCount == 0) {
+      return DartType.EMPTY_LIST;
+    }
+    // The substituted types at the end should be our bound type parameters.
+    int skipCount = typeArguments.length - typeParameterCount;
+    return new List<DartType>.from(typeArguments.skip(skipCount));
+  }
+
   @override
   Map<String, DartType> get namedParameterTypes {
     LinkedHashMap<String, DartType> namedParameterTypes =
         new LinkedHashMap<String, DartType>();
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return namedParameterTypes;
     }
     List<DartType> typeParameters =
         TypeParameterTypeImpl.getTypes(this.typeParameters);
@@ skipping 77 matching lines @@
               .substitute2(typeArguments, typeParameters, newPrune);
         } else {
           type = (type as TypeImpl).pruned(newPrune);
         }
         types.add(type);
       }
     }
     return types;
   }
 
+  /**
+   * If this is an instantiation of a generic function type, this will get
+   * the original function from which it was instantiated.
+   *
+   * Otherwise, this will return `this`.
+   */
+  FunctionTypeImpl get originalFunction {
+    if (element.type.boundTypeParameters.isEmpty) {
+      return this;
+    }
+    return (element.type as FunctionTypeImpl).substitute2(typeArguments,
+        TypeParameterTypeImpl.getTypes(typeParameters), prunedTypedefs);
+  }
+
   @override
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = this.baseParameters;
     // no parameters, quick return
     int parameterCount = baseParameters.length;
     if (parameterCount == 0) {
       return baseParameters;
     }
     // create specialized parameters
     List<ParameterElement> specializedParameters =
@@ skipping 3305 matching lines @@
       for (Element child in children) {
         child.accept(visitor);
       }
     }
   }
 
   /**
    * Return the type that results from replacing the type parameters in the
    * given [type] with the type arguments associated with this member.
    */
+  @deprecated
   DartType substituteFor(DartType type) {
     if (type == null) {
       return null;
     }
     List<DartType> argumentTypes = _definingType.typeArguments;
     List<DartType> parameterTypes =
         TypeParameterTypeImpl.getTypes(_definingType.typeParameters);
     return type.substitute2(argumentTypes, parameterTypes);
   }
 
@@ skipping 128 matching lines @@
       getNodeMatching((node) => node is MethodDeclaration);
 }
 
 /**
  * A method element defined in a parameterized type where the values of the type
  * parameters are known.
  */
 class MethodMember extends ExecutableMember implements MethodElement {
   /**
    * Initialize a newly created element to represent a constructor, based on the
    * [baseElement], defined by the [definingType].

[Leaf, 2015/12/05 00:50:40]

update comment.

[Jennifer Messerly, 2015/12/07 17:46:58]

Done.

    */
-  MethodMember(MethodElement baseElement, InterfaceType definingType)
-      : super(baseElement, definingType);
+  MethodMember(MethodElement baseElement, InterfaceType definingType,
+      [DartType type])
+      : super(baseElement, definingType, type);
 
   @override
   MethodElement get baseElement => super.baseElement as MethodElement;
 
   @override
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
   @override
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
 
@@ skipping 37 matching lines @@
       return method;
     }
     FunctionType baseType = method.type;
     List<DartType> argumentTypes = definingType.typeArguments;
     List<DartType> parameterTypes = definingType.element.type.typeArguments;
     FunctionType substitutedType =
         baseType.substitute2(argumentTypes, parameterTypes);
     if (baseType == substitutedType) {
       return method;
     }
-    // TODO(brianwilkerson) Consider caching the substituted type in the
-    // instance. It would use more memory but speed up some operations.
-    // We need to see how often the type is being re-computed.
-    return new MethodMember(method, definingType);
+    return new MethodMember(method, definingType, substitutedType);
   }
 }
 
 /**
  * The enumeration `Modifier` defines constants for all of the modifiers defined
  * by the Dart language and for a few additional flags that are useful.
  */
 class Modifier extends Enum<Modifier> {
   /**
    * Indicates that the modifier 'abstract' was applied to the element.
@@ skipping 707 matching lines @@
 
 /**
  * A parameter element defined in a parameterized type where the values of the
  * type parameters are known.
  */
 class ParameterMember extends VariableMember
     with ParameterElementMixin
     implements ParameterElement {
   /**
    * Initialize a newly created element to represent a constructor, based on the
    * [baseElement], defined by the [definingType].

[Leaf, 2015/12/05 00:50:40]

update comment.  I think here and elsewhere there is a pre-existing cut&paste
error - they all refer to "constructor".  :)

[Jennifer Messerly, 2015/12/07 17:46:58]

Done.

    */
-  ParameterMember(ParameterElement baseElement, ParameterizedType definingType)
-      : super(baseElement, definingType);
+  ParameterMember(ParameterElement baseElement, ParameterizedType definingType,
+      [DartType type])
+      : super._(baseElement, definingType, type);
 
   @override
   ParameterElement get baseElement => super.baseElement as ParameterElement;
 
   @override
   String get defaultValueCode => baseElement.defaultValueCode;
 
   @override
   Element get enclosingElement => baseElement.enclosingElement;
 
   @override
   int get hashCode => baseElement.hashCode;
 
   @override
   bool get isInitializingFormal => baseElement.isInitializingFormal;
 
   @override
   ParameterKind get parameterKind => baseElement.parameterKind;
 
   @override
   List<ParameterElement> get parameters {
-    List<ParameterElement> baseParameters = baseElement.parameters;
-    int parameterCount = baseParameters.length;
-    if (parameterCount == 0) {
-      return baseParameters;
+    DartType type = this.type;
+    if (type is FunctionType) {
+      return type.parameters;
     }
-    List<ParameterElement> parameterizedParameters =
-        new List<ParameterElement>(parameterCount);
-    for (int i = 0; i < parameterCount; i++) {
-      parameterizedParameters[i] =
-          ParameterMember.from(baseParameters[i], definingType);
-    }
-    return parameterizedParameters;
+    return ParameterElement.EMPTY_LIST;
   }
 
   @override
   List<TypeParameterElement> get typeParameters => baseElement.typeParameters;
 
   @override
   SourceRange get visibleRange => baseElement.visibleRange;
 
+  // TODO(jmesserly): this equality is broken. It should consider the defining
+  // type as well, otherwise we're dropping the substitution.
   @override
   bool operator ==(Object object) =>
       object is ParameterMember && baseElement == object.baseElement;
 
   @override
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
 
   @override
   FormalParameter computeNode() => baseElement.computeNode();
 
@@ skipping 46 matching lines @@
    * parameter if no member was created.
    */
   static ParameterElement from(
       ParameterElement parameter, ParameterizedType definingType) {
     if (parameter == null || definingType.typeArguments.length == 0) {
       return parameter;
     }
     // Check if parameter type depends on defining type type arguments.
     // It is possible that we did not resolve field formal parameter yet,
     // so skip this check for it.
-    bool isFieldFormal = parameter is FieldFormalParameterElement;
-    if (!isFieldFormal) {
+    if (parameter is FieldFormalParameterElement) {
+      return new FieldFormalParameterMember(parameter, definingType);
+    } else {
       DartType baseType = parameter.type;
       List<DartType> argumentTypes = definingType.typeArguments;
       List<DartType> parameterTypes =
           TypeParameterTypeImpl.getTypes(definingType.typeParameters);
       DartType substitutedType =
           baseType.substitute2(argumentTypes, parameterTypes);
       if (baseType == substitutedType) {
         return parameter;
       }
+      return new ParameterMember(parameter, definingType, substitutedType);
     }
-    // TODO(brianwilkerson) Consider caching the substituted type in the
-    // instance. It would use more memory but speed up some operations.
-    // We need to see how often the type is being re-computed.
-    if (isFieldFormal) {
-      return new FieldFormalParameterMember(
-          parameter as FieldFormalParameterElement, definingType);
-    }
-    return new ParameterMember(parameter, definingType);
   }
 }
 
 /**
  * A prefix used to import one or more libraries into another library.
  */
 abstract class PrefixElement implements Element {
   /**
    * An empty list of prefix elements.
    */
@@ skipping 1606 matching lines @@
     super.visitChildren(visitor);
     safelyVisitChild(_initializer, visitor);
   }
 }
 
 /**
  * A variable element defined in a parameterized type where the values of the
  * type parameters are known.
  */
 abstract class VariableMember extends Member implements VariableElement {
+  @override
+  final DartType type;
+
   /**
    * Initialize a newly created element to represent a constructor, based on the
    * [baseElement], defined by the [definingType].

[Leaf, 2015/12/05 00:50:40]

comment.

[Jennifer Messerly, 2015/12/07 17:46:58]

Done.

    */
-  VariableMember(VariableElement baseElement, ParameterizedType definingType)
-      : super(baseElement, definingType);
+  VariableMember(VariableElement baseElement, ParameterizedType definingType,
+      [DartType type])
+      : type = type ??
+            baseElement.type.substitute2(definingType.typeArguments,
+                TypeParameterTypeImpl.getTypes(definingType.typeParameters)),
+        super(baseElement, definingType);
+
+  // TODO(jmesserly): this is temporary to allow the ParameterMember subclass.
+  // Apparently mixins don't work with optional params.
+  VariableMember._(VariableElement baseElement, ParameterizedType definingType,
+      DartType type)
+      : this(baseElement, definingType, type);
 
   @override
   VariableElement get baseElement => super.baseElement as VariableElement;
 
   @override
   DartObject get constantValue => baseElement.constantValue;
 
   @override
   bool get hasImplicitType => baseElement.hasImplicitType;
 
@@ skipping 18 matching lines @@
       baseElement.isPotentiallyMutatedInClosure;
 
   @override
   bool get isPotentiallyMutatedInScope =>
       baseElement.isPotentiallyMutatedInScope;
 
   @override
   bool get isStatic => baseElement.isStatic;
 
   @override
-  DartType get type => substituteFor(baseElement.type);
-
-  @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);
     safelyVisitChild(baseElement.initializer, visitor);
   }
 }
 
 /**
  * The type `void`.
@@ skipping 66 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }