Resynthesize typedefs from Kernel.

pkg/analyzer/lib/src/kernel/resynthesize.dart

 // Copyright (c) 2017, 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.
 
 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';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 465 matching lines @@
     }
     return new _ExprBuilder(this).buildInitializer(k);
   }
 
   @override
   Expression getExpression(kernel.Expression expression) {
     return new _ExprBuilder(this).build(expression);
   }
 
   @override
+  List<List<kernel.VariableDeclaration>> getFunctionTypeParameters(
+      kernel.FunctionType type) {
+    int positionalCount = type.positionalParameters.length;
+    var positionalParameters =
+        new List<kernel.VariableDeclaration>(positionalCount);
+    for (int i = 0; i < positionalCount; i++) {
+      String name = i < type.positionalParameterNames.length
+          ? type.positionalParameterNames[i]
+          : 'arg_$i';
+      positionalParameters[i] = new kernel.VariableDeclaration(name,
+          type: type.positionalParameters[i]);
+    }
+
+    var namedParameters = type.namedParameters
+        .map((k) => new kernel.VariableDeclaration(k.name, type: k.type))
+        .toList(growable: false);
+
+    return [positionalParameters, namedParameters];
+  }
+
+  @override
   InterfaceType getInterfaceType(
       ElementImpl context, kernel.Supertype kernelType) {
     return _getInterfaceType(
         context, kernelType.className.canonicalName, kernelType.typeArguments);
   }
 
   @override
   LibraryElement getLibrary(String uriStr) {
     return _resynthesizer.getLibrary(uriStr);
   }
@@ skipping 37 matching lines @@
     }
 
     if (kernelType is kernel.FunctionType) {
       var functionElement = new FunctionElementImpl.synthetic([], null);
       functionElement.enclosingElement = context;
 
       functionElement.typeParameters = kernelType.typeParameters.map((k) {
         return new TypeParameterElementImpl.forKernel(functionElement, k);
       }).toList(growable: false);
 
+      var parameters = getFunctionTypeParameters(kernelType);
       functionElement.parameters = ParameterElementImpl.forKernelParameters(
           functionElement,
           kernelType.requiredParameterCount,
-          kernelType.positionalParameters
-              .map((t) => new kernel.VariableDeclaration(null, type: t))
-              .toList(),
-          kernelType.namedParameters
-              .map((t) => new kernel.VariableDeclaration(t.name, type: t.type))
-              .toList());
+          parameters[0],
+          parameters[1]);
 
       functionElement.returnType =
           getType(functionElement, kernelType.returnType);
       return functionElement.type;
     }
 
     // TODO(scheglov) Support other kernel types.
     throw new UnimplementedError('For ${kernelType.runtimeType}');
   }
 
@@ skipping 125 matching lines @@
         for (var typeParameter in ctx.typeParameters) {
           if (typeParameter.name == name) {
             return typeParameter;
           }
         }
       }
     }
     throw new StateError('Not found $kernelTypeParameter in $context');
   }
 }