Revert "Revert "fix #27256, track type bounds for generic functions""

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 2974 matching lines @@
   }
 
   /// Emit the pieces of a function type, as an array of return type,
   /// regular args, and optional/named args.
   JS.Expression _emitFunctionType(FunctionType type,
       {List<FormalParameter> parameters,
       bool lowerTypedef: false,
       bool nameType: true,
       bool hoistType: true,
       definite: false}) {
-    var parts = _emitFunctionTypeParts(type,
-        parameters: parameters,
-        lowerTypedef: lowerTypedef,
-        nameType: nameType,
-        hoistType: hoistType);
-    var helper = definite ? 'definiteFunctionType' : 'functionType';
-    var fullType = _callHelper('${helper}(#)', [parts]);
-    if (!nameType) return fullType;
-    return _typeTable.nameType(type, fullType,
-        hoistType: hoistType, definite: definite);
-  }
-
-  JS.Expression _emitAnnotatedFunctionType(
-      FunctionType type, List<Annotation> metadata,
-      {List<FormalParameter> parameters,
-      bool lowerTypedef: false,
-      bool nameType: true,
-      bool hoistType: true,
-      bool definite: false}) {
-    var result = _emitFunctionType(type,
-        parameters: parameters,
-        lowerTypedef: lowerTypedef,
-        nameType: nameType,
-        hoistType: hoistType,
-        definite: definite);
-    return _emitAnnotatedResult(result, metadata);
-  }
-
-  /// Emit the pieces of a function type, as an array of return type,
-  /// regular args, and optional/named args.
-  List<JS.Expression> _emitFunctionTypeParts(FunctionType type,
-      {List<FormalParameter> parameters,
-      bool lowerTypedef: false,
-      bool nameType: true,
-      bool hoistType: true}) {
     var parameterTypes = type.normalParameterTypes;
     var optionalTypes = type.optionalParameterTypes;
     var namedTypes = type.namedParameterTypes;
     var rt =
         _emitType(type.returnType, nameType: nameType, hoistType: hoistType);
 
     var ra = _emitTypeNames(parameterTypes, parameters,
         nameType: nameType, hoistType: hoistType);
 
     List<JS.Expression> typeParts;
     if (namedTypes.isNotEmpty) {
       assert(optionalTypes.isEmpty);
       // TODO(vsm): Pass in annotations here as well.
       var na = _emitTypeProperties(namedTypes);
       typeParts = [rt, ra, na];
     } else if (optionalTypes.isNotEmpty) {
       assert(namedTypes.isEmpty);
       var oa = _emitTypeNames(
           optionalTypes, parameters?.sublist(parameterTypes.length),
           nameType: nameType, hoistType: hoistType);
       typeParts = [rt, ra, oa];
     } else {
       typeParts = [rt, ra];
     }
 
+    JS.Expression fullType;
     var typeFormals = type.typeFormals;
+    String helperCall;
     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])
-        ];
-      } else {
-        typeParts = [
-          js.call('(#) => {#; return #;}', [tf, names, parts])
-        ];
+
+      addTypeFormalsAsParameters(List<JS.Expression> elements) {
+        var names = _typeTable.discharge(typeFormals);
+        var array = new JS.ArrayInitializer(elements);
+        return names.isEmpty
+            ? js.call('(#) => #', [tf, array])
+            : js.call('(#) => {#; return #;}', [tf, names, array]);
       }
+
+      typeParts = [addTypeFormalsAsParameters(typeParts)];
+
+      helperCall = definite ? 'gFnType(#)' : 'gFnTypeFuzzy(#)';
+      // If any explicit bounds were passed, emit them.
+      if (typeFormals.any((t) => t.bound != null)) {
+        var bounds = typeFormals.map((t) => _emitType(t.type.bound)).toList();
+        typeParts.add(addTypeFormalsAsParameters(bounds));
+      }
+    } else {
+      helperCall = definite ? 'fnType(#)' : 'fnTypeFuzzy(#)';
     }
-    return typeParts;
+    fullType = _callHelper(helperCall, [typeParts]);
+    if (!nameType) return fullType;
+    return _typeTable.nameType(type, fullType,
+        hoistType: hoistType, definite: definite);
+  }
+
+  JS.Expression _emitAnnotatedFunctionType(
+      FunctionType type, List<Annotation> metadata,
+      {List<FormalParameter> parameters,
+      bool lowerTypedef: false,
+      bool nameType: true,
+      bool hoistType: true,
+      bool definite: false}) {
+    var result = _emitFunctionType(type,
+        parameters: parameters,
+        lowerTypedef: lowerTypedef,
+        nameType: nameType,
+        hoistType: hoistType,
+        definite: definite);
+    return _emitAnnotatedResult(result, metadata);
   }
 
   /// Emits an expression that lets you access statics on a [type] from code.
   ///
   /// If [nameType] is true, then the type will be named.  In addition,
   /// if [hoistType] is true, then the named type will be hoisted.
   JS.Expression _emitConstructorAccess(DartType type,
       {bool nameType: true, bool hoistType: true}) {
     return _emitJSInterop(type.element) ??
         _emitType(type, nameType: nameType, hoistType: hoistType);
@@ skipping 3053 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;
 }