Store Typedef(s) in kernel when parsing with Fasta, deserilize in DillLibraryBuilder.

pkg/analyzer/lib/src/fasta/element_store.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.analyzer.element_store;
 
 import 'package:analyzer/src/kernel/loader.dart' show ReferenceLevelLoader;
 
 import 'package:kernel/ast.dart';
 
@@ skipping 61 matching lines @@
     libraries.forEach((Uri uri, LibraryBuilder library) {
       KernelCompilationUnitElement unit =
           new KernelCompilationUnitElement(library);
       KernelLibraryElement element = new KernelLibraryElement(unit);
       elements[library] = element;
       unit.library = element;
       library.forEach((String name, Builder builder) {
         do {
           if (builder is ClassBuilder) {
             elements[builder] = new KernelClassElement(builder);
+          } else if (builder is KernelFunctionTypeAliasBuilder) {
+            elements[builder] = new KernelFunctionTypeAliasElement(builder);
           } else if (builder is DillMemberBuilder) {
             Member member = builder.member;
             if (member is Field) {} else if (member is Procedure) {
               buildDillFunctionElement(builder, unit, elements);
             } else {
               internalError("Unhandled $name ${member.runtimeType} in $uri");
             }
           } else if (builder is KernelProcedureBuilder) {
             buildKernelFunctionElement(builder, unit, elements);
           } else if (builder is BuiltinTypeBuilder) {
@@ skipping 190 matching lines @@
 class KernelClassElement extends MockClassElement {
   final KernelClassBuilder builder;
 
   KernelInterfaceType rawType;
 
   KernelClassElement(this.builder) {
     rawType = new KernelInterfaceType(this);
   }
 }
 
+class KernelFunctionTypeAliasElement extends MockFunctionTypeAliasElement {
+  final KernelFunctionTypeAliasBuilder builder;
+
+  KernelFunctionTypeAliasElement(this.builder);
+
+  @override
+  analyzer.DartType get returnType {
+    return internalError("not supported.");
+  }
+
+  @override
+  analyzer.FunctionType get type {
+    return internalError("not supported.");
+  }
+
+  @override
+  List<TypeParameterElement> get typeParameters {
+    return internalError("not supported.");
+  }
+}
+
 class KernelInterfaceType extends MockInterfaceType {
   final KernelClassElement element;
 
   KernelInterfaceType(this.element);
 
   List<analyzer.DartType> get typeArguments => const <analyzer.DartType>[];
 }