Improve printing of generic function types and add tests

pkg/analyzer/lib/src/generated/testing/ast_test_factory.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.generated.testing.ast_test_factory;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 594 matching lines @@
           function, typeArguments, argumentList(arguments));
 
   static FunctionTypedFormalParameter functionTypedFormalParameter(
           TypeAnnotation returnType, String identifier,
           [List<FormalParameter> parameters]) =>
       astFactory.functionTypedFormalParameter2(
           returnType: returnType,
           identifier: identifier3(identifier),
           parameters: formalParameterList(parameters));
 
+  static GenericFunctionType genericFunctionType(TypeAnnotation returnType,
+          TypeParameterList typeParameters, FormalParameterList parameters) =>
+      astFactory.genericFunctionType(returnType,
+          TokenFactory.tokenFromString("Function"), typeParameters, parameters);
+
+  static GenericTypeAlias genericTypeAlias(String name,
+          TypeParameterList typeParameters, GenericFunctionType functionType) =>
+      astFactory.genericTypeAlias(
+          null,
+          null,
+          TokenFactory.tokenFromKeyword(Keyword.TYPEDEF),
+          identifier3(name),
+          typeParameters,
+          TokenFactory.tokenFromType(TokenType.EQ),
+          functionType,
+          TokenFactory.tokenFromType(TokenType.SEMICOLON));
+
   static HideCombinator hideCombinator(List<SimpleIdentifier> identifiers) =>
       astFactory.hideCombinator(
           TokenFactory.tokenFromString("hide"), identifiers);
 
   static HideCombinator hideCombinator2(List<String> identifiers) =>
       astFactory.hideCombinator(
           TokenFactory.tokenFromString("hide"), identifierList(identifiers));
 
   static PrefixedIdentifier identifier(
           SimpleIdentifier prefix, SimpleIdentifier identifier) =>
@@ skipping 437 matching lines @@
   static SimpleFormalParameter simpleFormalParameter(
           Keyword keyword, String parameterName) =>
       simpleFormalParameter2(keyword, null, parameterName);
 
   static SimpleFormalParameter simpleFormalParameter2(
           Keyword keyword, TypeAnnotation type, String parameterName) =>
       astFactory.simpleFormalParameter2(
           keyword:
               keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           type: type,
-          identifier: identifier3(parameterName));
+          identifier:
+              parameterName == null ? null : identifier3(parameterName));
 
   static SimpleFormalParameter simpleFormalParameter3(String parameterName) =>
       simpleFormalParameter2(null, null, parameterName);
 
   static SimpleFormalParameter simpleFormalParameter4(
           TypeAnnotation type, String parameterName) =>
       simpleFormalParameter2(null, type, parameterName);
 
   static StringInterpolation string([List<InterpolationElement> elements]) =>
       astFactory.stringInterpolation(elements);
@@ skipping 231 matching lines @@
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static YieldStatement yieldStatement(Expression expression) =>
       astFactory.yieldStatement(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "yield"),
           null,
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 }