clean up generic methods in resolution

Introduces MethodInvocation.staticInvokeType to track the type of this invocation. This provides a natural place to store the instantiated generic function type. We then use this type when we are computing corresponding parameters or return types. As a result we do not need FunctionMember, and some of the code around generics becomes simpler/more uniform.

This approach should be a straightforward way to add support for generics in FunctionExpressionInvocation, in a follow up (see issue #25175).

Also renames "boundTypeParameters" to "typeFormals". "formals" and "actuals" is a pretty common way to describe these, I'm not sure why I didn't think of that better name originally. :)

Also removes broken ParameterMember.== that I had added in a previous CL. And the broken FunctionTypeImpl.originalFunction/instantiatedTypeArguments getters.

Finally, this fixes #23252 in the process of adding this. The return type of a "call" method was not being statically analyzed if the target was a VariableElement.

[email protected], [email protected]

Review URL: https://codereview.chromium.org/1568643002 .

Author: John Messerly

pkg/analyzer/lib/dart/element/type.dart

@@ -131,13 +131,20 @@ abstract class DartType {
  */
 abstract class FunctionType implements ParameterizedType {
   /**
-   * The type parameters of this generic function. For example `<T> T -> T`.
+   * Deprecated: use [typeFormals].
+   */
+  @deprecated
+  List<TypeParameterElement> get boundTypeParameters;
+
+  /**
+   * The formal type parameters of this generic function.
+   * For example `<T> T -> T`.
    *
    * These are distinct from the [typeParameters] list, which contains type
    * parameters from surrounding contexts, and thus are free type variables from
    * the perspective of this function type.
    */
-  List<TypeParameterElement> get boundTypeParameters;
+  List<TypeParameterElement> get typeFormals;
 
   /**
    * Return a map from the names of named parameters to the types of the named
@@ -569,7 +576,7 @@ abstract class InterfaceType implements ParameterizedType {
    */
   // TODO(jmesserly): introduce a new "instantiate" and deprecate this.
   // The new "instantiate" should work similar to FunctionType.instantiate,
-  // which uses [boundTypeParameters] to model type parameters that haven't been
+  // which uses [typeFormals] to model type parameters that haven't been
   // filled in yet. Those are kept separate from already-substituted type
   // parameters or free variables from the enclosing scopes, which allows nested
   // generics to work, such as a generic method in a generic class.
@@ -590,7 +597,16 @@ abstract class InterfaceType implements ParameterizedType {
 }
 
 /**
- * A type with type parameters, such as a class or function type alias.
+ * A type that can track substituted type parameters, either for itself after
+ * instantiation, or from a surrounding context.
+ *
+ * For example, given a class `Foo<T>`, after instantiation with S for T, it
+ * will track the substitution `{S/T}`.
+ *
+ * This substitution will be propagated to its members. For example, say our
+ * `Foo<T>` class has a field `T bar;`. When we look up this field, we will get
+ * back a [FieldElement] that tracks the substituted type as `{S/T}T`, so when
+ * we ask for the field type we will get`S`.
  *
  * Clients may not extend, implement or mix-in this class.
  */

pkg/analyzer/lib/src/dart/element/member.dart

@@ -339,15 +339,21 @@ class FieldMember extends VariableMember implements FieldElement {
 }
 
 /**
+ * Deprecated: this type is no longer used. Use
+ * [MethodInvocation.staticInvokeType] to get the instantiated type of a generic
+ * method invocation.
+ *
  * 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.
+@deprecated
 class FunctionMember extends ExecutableMember implements FunctionElement {
   /**
    * Initialize a newly created element to represent a function, based on the
    * [baseElement], with the corresponding function [type].
    */
+  @deprecated
   FunctionMember(FunctionElement baseElement, [DartType type])
       : super(baseElement, null, type);
 
@@ -674,12 +680,6 @@ class ParameterMember extends VariableMember
   @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);
 

pkg/analyzer/lib/src/dart/element/type.dart

@@ -177,7 +177,7 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
   /**
    * True if this type is the result of instantiating type parameters (and thus
    * any type parameters bound by the typedef should be considered part of
-   * [typeParameters] rather than [boundTypeParameters]).
+   * [typeParameters] rather than [typeFormals]).
    */
   final bool _isInstantiated;
 
@@ -243,8 +243,12 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
    */
   DartType get baseReturnType => element.returnType;
 
+  @deprecated
   @override
-  List<TypeParameterElement> get boundTypeParameters {
+  List<TypeParameterElement> get boundTypeParameters => typeFormals;
+
+  @override
+  List<TypeParameterElement> get typeFormals {
     if (_isInstantiated) {
       return TypeParameterElement.EMPTY_LIST;
     } else {
@@ -349,26 +353,6 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
     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));
-  }
-
   /**
    * Return `true` if this type is the result of instantiating type parameters.
    */
@@ -471,20 +455,6 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
     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;
@@ -558,19 +528,19 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
       return false;
     }
     FunctionTypeImpl otherType = object as FunctionTypeImpl;
-    if (boundTypeParameters.length != otherType.boundTypeParameters.length) {
+    if (typeFormals.length != otherType.typeFormals.length) {
       return false;
     }
     // `<T>T -> T` should be equal to `<U>U -> U`
     // To test this, we instantiate both types with the same (unique) type
     // variables, and see if the result is equal.
-    if (boundTypeParameters.isNotEmpty) {
+    if (typeFormals.isNotEmpty) {
       List<DartType> instantiateTypeArgs = new List<DartType>();
       List<DartType> variablesThis = new List<DartType>();
       List<DartType> variablesOther = new List<DartType>();
-      for (int i = 0; i < boundTypeParameters.length; i++) {
-        TypeParameterElement pThis = boundTypeParameters[i];
-        TypeParameterElement pOther = otherType.boundTypeParameters[i];
+      for (int i = 0; i < typeFormals.length; i++) {
+        TypeParameterElement pThis = typeFormals[i];
+        TypeParameterElement pOther = otherType.typeFormals[i];
         TypeParameterTypeImpl pFresh = new TypeParameterTypeImpl(
             new TypeParameterElementImpl(pThis.name, -1));
         instantiateTypeArgs.add(pFresh);
@@ -583,7 +553,7 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
           return false;
         }
       }
-      // After instantiation, they will no longer have boundTypeParameters,
+      // After instantiation, they will no longer have typeFormals,
       // so we will continue below.
       return this.instantiate(instantiateTypeArgs) ==
           otherType.instantiate(instantiateTypeArgs);
@@ -599,7 +569,7 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
 
   @override
   void appendTo(StringBuffer buffer) {
-    if (boundTypeParameters.isNotEmpty) {
+    if (typeFormals.isNotEmpty) {
       // To print a type with type variables, first make sure we have unique
       // variable names to print.
       Set<TypeParameterType> freeVariables = new HashSet<TypeParameterType>();
@@ -615,8 +585,8 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
       List<DartType> instantiateTypeArgs = new List<DartType>();
       List<DartType> variables = new List<DartType>();
       buffer.write("<");
-      for (TypeParameterElement e in boundTypeParameters) {
-        if (e != boundTypeParameters[0]) {
+      for (TypeParameterElement e in typeFormals) {
+        if (e != typeFormals[0]) {
           buffer.write(",");
         }
         String name = e.name;
@@ -645,7 +615,7 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
       buffer.write(">");
 
       // Instantiate it and print the resulting type. After instantiation, it
-      // will no longer have boundTypeParameters, so we will continue below.
+      // will no longer have typeFormals, so we will continue below.
       this.instantiate(instantiateTypeArgs).appendTo(buffer);
       return;
     }
@@ -713,10 +683,10 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
 
   @override
   FunctionTypeImpl instantiate(List<DartType> argumentTypes) {
-    if (argumentTypes.length != boundTypeParameters.length) {
+    if (argumentTypes.length != typeFormals.length) {
       throw new IllegalArgumentException(
           "argumentTypes.length (${argumentTypes.length}) != "
-          "boundTypeParameters.length (${boundTypeParameters.length})");
+          "typeFormals.length (${typeFormals.length})");
     }
     if (argumentTypes.isEmpty) {
       return this;
@@ -725,7 +695,7 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
     // Given:
     //     {U/T} <S> T -> S
     // Where {U/T} represents the typeArguments (U) and typeParameters (T) list,
-    // and <S> represents the boundTypeParameters.
+    // and <S> represents the typeFormals.
     //
     // Now instantiate([V]), and the result should be:
     //     {U/T, V/S} T -> S.
@@ -1024,8 +994,8 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
       FunctionType type, Set<TypeParameterType> free) {
     // Make some fresh variables to avoid capture.
     List<DartType> typeArgs = DartType.EMPTY_LIST;
-    if (type.boundTypeParameters.isNotEmpty) {
-      typeArgs = new List<DartType>.from(type.boundTypeParameters.map((e) =>
+    if (type.typeFormals.isNotEmpty) {
+      typeArgs = new List<DartType>.from(type.typeFormals.map((e) =>
           new TypeParameterTypeImpl(new TypeParameterElementImpl(e.name, -1))));
 
       type = type.instantiate(typeArgs);

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

@@ -8087,6 +8087,21 @@ class MethodInvocation extends Expression {
    */
   ArgumentList _argumentList;
 
+  /**
+   * The function type of the method invocation, or `null` if the AST
+   * structure has not been resolved, or if the invoke could not be resolved.
+   *
+   * This will usually be a [FunctionType], but it can also be an
+   * [InterfaceType] with a `call` method, `dynamic`, `Function`, or a `@proxy`
+   * interface type that implements `Function`.
+   */
+  DartType staticInvokeType;
+
+  /**
+   * Like [staticInvokeType], but reflects propagated type information.
+   */
+  DartType propagatedInvokeType;
+
   /**
    * Initialize a newly created method invocation. The [target] and [operator]
    * can be `null` if there is no target.