re-land Use FunctionElementImpl for inline function type parameters

pkg/analyzer/lib/src/generated/resolver.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;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'constant.dart';
@@ skipping 14921 matching lines @@
    * Given a parameter element, create a function type based on the given return type and parameter
    * list and associate the created type with the element.
    *
    * @param element the parameter element whose type is to be set
    * @param returnType the (possibly `null`) return type of the function
    * @param parameterList the list of parameters to the function
    */
   void _setFunctionTypedParameterType(ParameterElementImpl element,
       TypeName returnType, FormalParameterList parameterList) {
     List<ParameterElement> parameters = _getElements(parameterList);
-    FunctionTypeAliasElementImpl aliasElement =
-        new FunctionTypeAliasElementImpl.forNode(null);
-    aliasElement.synthetic = true;
-    aliasElement.shareParameters(parameters);
-    aliasElement.returnType = _computeReturnType(returnType);
-    // FunctionTypeAliasElementImpl assumes the enclosing element is a
-    // CompilationUnitElement (because non-synthetic function types can only be
-    // declared at top level), so to avoid breaking things, go find the
-    // compilation unit element.
-    aliasElement.enclosingElement =
-        element.getAncestor((element) => element is CompilationUnitElement);
-    ClassElement definingClass =
-        element.getAncestor((element) => element is ClassElement);
-    if (definingClass != null) {
-      aliasElement.shareTypeParameters(definingClass.typeParameters);
-    } else {
-      FunctionTypeAliasElement alias =
-          element.getAncestor((element) => element is FunctionTypeAliasElement);
-      while (alias != null && alias.isSynthetic) {
-        alias =
-            alias.getAncestor((element) => element is FunctionTypeAliasElement);
-      }
-      if (alias != null) {
-        aliasElement.typeParameters = alias.typeParameters;
-      }
-    }
-    element.type = new FunctionTypeImpl.forTypedef(aliasElement);
+    FunctionElementImpl functionElement = new FunctionElementImpl.forNode(null);
+    functionElement.synthetic = true;
+    functionElement.shareParameters(parameters);
+    functionElement.returnType = _computeReturnType(returnType);
+    functionElement.enclosingElement = element;
+    element.type = new FunctionTypeImpl(functionElement);
   }
 
   /**
    * @return `true` if the name of the given [TypeName] is an built-in identifier.
    */
   static bool _isBuiltInIdentifier(TypeName node) {
     sc.Token token = node.name.beginToken;
     return token.type == sc.TokenType.KEYWORD;
   }
 
@@ skipping 591 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }