Serialize typedef parameters (including function typed ones) to Kernel and use it to resynthesize t…

pkg/front_end/lib/src/fasta/kernel/kernel_function_type_alias_builder.dart

 // Copyright (c) 2016, 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 fasta.kernel_function_type_alias_builder;
 
+import 'package:front_end/src/fasta/kernel/kernel_function_type_builder.dart';
+import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 import 'package:kernel/ast.dart'
     show
         DartType,
         DynamicType,
         FunctionType,
         InvalidType,
         TypeParameter,
-        Typedef;
-
+        Typedef,
+        VariableDeclaration;
 import 'package:kernel/type_algebra.dart' show substitute;
 
 import '../fasta_codes.dart' show templateCyclicTypedef;
-
 import 'kernel_builder.dart'
     show
         FunctionTypeAliasBuilder,
+        KernelFormalParameterBuilder,
         KernelFunctionTypeBuilder,
         KernelTypeBuilder,
         KernelTypeVariableBuilder,
         LibraryBuilder,
         MetadataBuilder,
         TypeVariableBuilder,
         computeDefaultTypeArguments;
 
 class KernelFunctionTypeAliasBuilder
     extends FunctionTypeAliasBuilder<KernelFunctionTypeBuilder, DartType> {
@@ skipping 21 matching lines @@
   DartType buildThisType(LibraryBuilder library) {
     if (thisType != null) {
       if (const InvalidType() == thisType) {
         library.addCompileTimeError(
             templateCyclicTypedef.withArguments(name), charOffset, fileUri);
         return const DynamicType();
       }
       return thisType;
     }
     thisType = const InvalidType();
+
     DartType builtType = type?.build(library) ?? const DynamicType();
     if (typeVariables != null) {
       for (KernelTypeVariableBuilder tv in typeVariables) {
         tv.parameter.bound = tv?.bound?.build(library);
         target.typeParameters.add(tv.parameter..parent = target);
       }
     }
+
+    _buildParameters(library);
+
     return thisType = builtType;
   }
 
   /// [arguments] have already been built.
   DartType buildTypesWithBuiltArguments(
       LibraryBuilder library, List<DartType> arguments) {
     var thisType = buildThisType(library);
     if (const DynamicType() == thisType) return thisType;
     FunctionType result = thisType;
     if (target.typeParameters.isEmpty && arguments == null) return result;
@@ skipping 15 matching lines @@
     if (target.typeParameters.isEmpty && arguments == null) return result;
     // Otherwise, substitute.
     List<DartType> builtArguments = <DartType>[];
     if (arguments != null) {
       for (int i = 0; i < arguments.length; i++) {
         builtArguments.add(arguments[i].build(library));
       }
     }
     return buildTypesWithBuiltArguments(library, builtArguments);
   }
+
+  /// Build and set formal parameters of this typedef.
+  void _buildParameters(LibraryBuilder library) {
+    int requiredCount = 0;
+    final positional = <VariableDeclaration>[];
+    final named = <VariableDeclaration>[];
+    if (type.formals != null) {
+      for (KernelFormalParameterBuilder formal in type.formals) {
+        KernelVariableDeclaration parameter = formal.build(library);
+        if (formal.isPositional) {
+          positional.add(parameter);
+          if (formal.isRequired) requiredCount++;
+        } else if (formal.isNamed) {
+          named.add(parameter);
+        }
+      }
+      target.setParameters(requiredCount, positional, named);
+    }
+  }
 }