fix #27971, implement generic function RTTI

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 734 matching lines @@
   }
 
   String _jsTypeofName(DartType t) {
     if (_isNumberInJS(t)) return 'number';
     if (t == types.stringType) return 'string';
     if (t == types.boolType) return 'boolean';
     return null;
   }
 
   @override
-  visitFunctionTypeAlias(FunctionTypeAlias node) {
-    FunctionTypeAliasElement element = node.element;
+  visitFunctionTypeAlias(FunctionTypeAlias node) => _emitTypedef(node);
+
+  @override
+  visitGenericTypeAlias(GenericTypeAlias node) => _emitTypedef(node);
+
+  JS.Statement _emitTypedef(TypeAlias node) {
+    var element = node.element as FunctionTypeAliasElement;
+    FunctionType type;
+    var typeFormals = element.typeParameters;
+    if (element is GenericTypeAliasElement) {
+      type = element.function.type;
+    } else {
+      type = element.type;
+      if (typeFormals.isNotEmpty) {

[vsm, 2017/04/21 22:19:54]

Is this if not needed in the GenericTypeAliasElement case?

[Jennifer Messerly, 2017/04/21 22:39:59]

no it is not needed. GenericTypeAliasElement representation and how it tracks
type is different. I'm not sure which is better, and I would also like to see it
reconciled, but this is where we're at right now in Analyzer's element model.

+        // Skip past the type formals, we'll add them back below, so these
+        // type parameter names will end up in scope in the generated JS.
+        type = type.instantiate(typeFormals.map((f) => f.type).toList());
+      }
+    }
 
     JS.Expression body = annotate(
         _callHelper('typedef(#, () => #)', [
           js.string(element.name, "'"),
-          _emitType(element.type, nameType: false, lowerTypedef: true)
+          _emitType(type, nameType: false, lowerTypedef: true)
         ]),
         node,
         element);
 
-    var typeFormals = element.typeParameters;
     if (typeFormals.isNotEmpty) {
       return _defineClassTypeArguments(element, typeFormals,
           js.statement('const # = #;', [element.name, body]));
     } else {
       return js.statement('# = #;', [_emitTopLevelName(element), body]);
     }
   }
 
   @override
-  visitGenericTypeAlias(GenericTypeAlias node) {
-    throw new UnimplementedError('Generic type aliases are not implemented. '
-        'See https://github.com/dart-lang/sdk/issues/27971');
-  }
-
-  @override
   JS.Expression visitTypeName(TypeName node) {
     if (node.type == null) {
       // TODO(jmesserly): if the type fails to resolve, should we generate code
       // that throws instead?
       assert(options.unsafeForceCompile || options.replCompile);
       return _callHelper('dynamic');
     }
     return _emitType(node.type);
   }
 
@@ skipping 2240 matching lines @@
       assert(namedTypes.isEmpty);
       var oa = _emitTypeNames(
           optionalTypes, parameters?.sublist(parameterTypes.length),
           nameType: nameType, hoistType: hoistType);
       typeParts = [rt, ra, oa];
     } else {
       typeParts = [rt, ra];
     }
 
     var typeFormals = type.typeFormals;
-    if (typeFormals.isNotEmpty && !lowerTypedef) {
+    if (typeFormals.isNotEmpty) {
       // TODO(jmesserly): this is a suboptimal representation for universal
       // function types (as callable functions). See discussion at
       // https://github.com/dart-lang/sdk/issues/27333
       var tf = _emitTypeFormals(typeFormals);
       var names = _typeTable.discharge(typeFormals);
       var parts = new JS.ArrayInitializer(typeParts);
       if (names.isEmpty) {
         typeParts = [
           js.call('(#) => #', [tf, parts])
         ];
@@ skipping 3067 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }