Revert "Use FunctionElementImpl for inline function type parameters"

pkg/analyzer/test/generated/resolver_test.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.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/context.dart' as newContext;
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 189 matching lines @@
     futureConstructor.parameters = <ParameterElement>[
       ElementFactory.positionalParameter2("value", provider.dynamicType)
     ];
     futureConstructor.factory = true;
     futureElement.constructors = <ConstructorElement>[futureConstructor];
     //   Future then(onValue(T value), { Function onError });
     List<ParameterElement> parameters = <ParameterElement>[
       ElementFactory.requiredParameter2(
           "value", futureElement.typeParameters[0].type)
     ];
-    FunctionElementImpl onValueFunction = new FunctionElementImpl.forNode(null);
-    onValueFunction.synthetic = true;
-    onValueFunction.parameters = parameters;
-    onValueFunction.returnType = provider.dynamicType;
-    onValueFunction.enclosingElement = futureElement;
-    onValueFunction.type = new FunctionTypeImpl(onValueFunction);
+    FunctionTypeAliasElementImpl aliasElement =
+        new FunctionTypeAliasElementImpl.forNode(null);
+    aliasElement.synthetic = true;
+    aliasElement.parameters = parameters;
+    aliasElement.returnType = provider.dynamicType;
+    aliasElement.enclosingElement = asyncUnit;
+    aliasElement.shareTypeParameters(futureElement.typeParameters);
+    FunctionTypeImpl aliasType = new FunctionTypeImpl.forTypedef(aliasElement);
+    aliasElement.type = aliasType;
     DartType futureDynamicType =
         futureElement.type.substitute4([provider.dynamicType]);
     MethodElement thenMethod = ElementFactory.methodElementWithParameters(
         futureElement, "then", futureDynamicType, [
-      ElementFactory.requiredParameter2("onValue", onValueFunction.type),
+      ElementFactory.requiredParameter2("onValue", aliasType),
       ElementFactory.namedParameter2("onError", provider.functionType)
     ]);
     futureElement.methods = <MethodElement>[thenMethod];
     // Completer
     ClassElementImpl completerElement =
         ElementFactory.classElement2("Completer", ["T"]);
     ConstructorElementImpl completerConstructor =
         ElementFactory.constructorElement2(completerElement, null);
     completerElement.constructors = <ConstructorElement>[completerConstructor];
     // StreamSubscription
@@ skipping 11974 matching lines @@
     expect(e.type.toString(), '(E) → List<T>');
 
     SimpleIdentifier c = _findIdentifier('cOfString');
     FunctionType ft = (c.staticType as InterfaceType).getMethod('f').type;
     expect(ft.toString(), '(String) → List<T>');
     DartType t = e.typeParameters[0].type;
     ft = ft.substitute2([typeProvider.intType], [t]);
     expect(ft.toString(), '(String) → List<int>');
   }
 
-  void test_genericMethod_functionTypedParameter() {
-    _resolveTestUnit(r'''
-class C<E> {
-  List/*<T>*/ f/*<T>*/(/*=T*/ f(E e)) => null;
-}
-main() {
-  C<String> cOfString;
-}
-''');
-    SimpleIdentifier f = _findIdentifier('f');
-    MethodElementImpl e = f.staticElement;
-    expect(e.typeParameters.toString(), '[T]');
-    expect(e.type.typeParameters.toString(), '[T, E]');
-    expect(e.type.typeArguments.toString(), '[T, E]');
-    expect(e.type.toString(), '((E) → T) → List<T>');
-
-    SimpleIdentifier c = _findIdentifier('cOfString');
-    FunctionType ft = (c.staticType as InterfaceType).getMethod('f').type;
-    expect(ft.toString(), '((String) → T) → List<T>');
-    DartType t = e.typeParameters[0].type;
-    ft = ft.substitute2([typeProvider.intType], [t]);
-    expect(ft.toString(), '((String) → int) → List<int>');
-  }
-
   void test_pseudoGeneric_max_doubleDouble() {
     String code = r'''
 import 'dart:math';
 main() {
   var foo = max(1.0, 2.0);
 }
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
@@ skipping 2935 matching lines @@
 
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }