fix #27454, prune FunctionTypeImpl.parameters

pkg/analyzer/lib/src/dart/element/type.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 analyzer.src.dart.element.type;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 497 matching lines @@
   }
 
   @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 =
-        new List<ParameterElement>(parameterCount);
+    var specializedParams = new List<ParameterElement>(parameterCount);
+
+    var parameterTypes = TypeParameterTypeImpl.getTypes(typeParameters);
     for (int i = 0; i < parameterCount; i++) {
-      specializedParameters[i] = ParameterMember.from(baseParameters[i], this);
+      var parameter = baseParameters[i];
+      if (parameter?.type == null) {
+        specializedParams[i] = parameter;
+        continue;
+      }
+
+      // Check if parameter type depends on defining type type arguments, or
+      // if it needs to be pruned.
+
+      if (parameter is FieldFormalParameterElement) {
+        // TODO(jmesserly): this seems like it won't handle pruning correctly.
+        specializedParams[i] = new FieldFormalParameterMember(parameter, this);
+        continue;
+      }
+
+      var baseType = parameter.type as TypeImpl;
+      TypeImpl type;
+      if (typeArguments.isEmpty ||
+          typeArguments.length != typeParameters.length) {
+        type = baseType.pruned(newPrune);
+      } else {
+        type = baseType.substitute2(typeArguments, parameterTypes, newPrune);
+      }
+
+      specializedParams[i] = identical(type, baseType)
+          ? parameter
+          : new ParameterMember(parameter, this, type);
     }
-    return specializedParameters;
+    return specializedParams;
   }
 
   @override
   DartType get returnType {
     DartType baseReturnType = this.baseReturnType;
     if (baseReturnType == null) {
       // TODO(brianwilkerson) This is a patch. The return type should never be
       // null and we need to understand why it is and fix it.
       return DynamicTypeImpl.instance;
     }
@@ skipping 92 matching lines @@
       // variables, and see if the result is equal.
       if (typeFormals.isNotEmpty) {
         List<DartType> freshVariables =
             relateTypeFormals(this, object, (t, s) => t == s);
         if (freshVariables == null) {
           return false;
         }
         return instantiate(freshVariables) ==
             object.instantiate(freshVariables);
       }
+
       return returnType == object.returnType &&
           TypeImpl.equalArrays(
               normalParameterTypes, object.normalParameterTypes) &&
           TypeImpl.equalArrays(
               optionalParameterTypes, object.optionalParameterTypes) &&
           _equals(namedParameterTypes, object.namedParameterTypes);
     }
     return false;
   }
 
@@ skipping 2101 matching lines @@
 
   @override
   TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
 
   @override
   VoidTypeImpl substitute2(
           List<DartType> argumentTypes, List<DartType> parameterTypes,
           [List<FunctionTypeAliasElement> prune]) =>
       this;
 }