Analyzer: it is an error if a type argument is a generic function type

[leafpetersen]

The analyzer is missing the following errors from https://github.com/dart-lang/sdk/blob/master/docs/language/informal/generic-function-type-alias.md :

 It is a compile-time error if a generic function type is used as a bound for a formal type parameter of a class or a function. It is a compile-time error if a generic function type is used as an actual type argument.

[MichaelRFairhurst]

@eernstg @bwilkerson

I firmly believe that good advice is a huge part of good error messages. I'd like help brainstorming a simple "correction" message to use in the implementation.

Part of that principle is that bad suggestions are bad. So maybe here I should not try to offer any suggestions at all. Regardless, here's what I have so far.

For using a generic function as a bound, here's what I have: "Try making the free variable in the function type part of the larger declaration signature"

If that's not clear don't let my explanation convince you otherwise. However, I'll describe what I mean by that in case anyone has further suggestions etc.

List<T> map<T extends S Function<S>(S)>(T f);
// should be?
List<T> map<T extends Function(T), S>(T f);

This is obviously not a catch-all suggestion.

For disabling parameterization with a generic function type, I have (yikes) "Try resorting to dynamic programming if you need to have generic function types in your consuming code."

Trying to think through some circumstance which is maybe a guideline for what else to suggest, I imagine:

class Container<T> {
  T val;
  Container<S> map<S>(S Function(T));
}
final List<T Function<T>(T)> identities = ...;
List<Container<List<int>> x = new List<Container<int>>(...).expand((c) => identities.map((i) => c.map(i)));
List<Container<List<String>> x = new List<Container<String>>(...).expand((c) => identities.map((i) => c.map(i)));

In this case it seems like the only solution will involve casting. Reification is prone to go wrong in any workarounds. Therefore suggesting "dynamic programming" seems like essentially the only option, especially given that "dynamic programming" is on a sort of scale that potentially includes:

final List<Object Function(Object)> identities ...;
List<Container<List<int>> x = new List<Container<int>>(...).expand((c) => identities.map((i) => c.map(i).map((r) => r as int)));

Anyways, feedback welcome. Either in terms of user-facing advice being adequate, lacking, convoluted, or wrong, etc.

[MichaelRFairhurst]

I didn't read the paper on why generic function types as bounds or parameters create problems. So forgive me for asking rather than researching...

What do those problems mean for this case:

class C<T extends void Function(S Function<S>(S))> { ... }

the generic function type is being used as a bound indirectly, but the bound is not a generic function type. Should this be illegal, and should the informal spec be updated to account for this?

[MichaelRFairhurst]

I'm also assuming that this the second part of this (if a type argument is a generic function type that's a compile time error) should be part of the inference engine?

[MichaelRFairhurst]

Just saw this test case:

  // Type inference must also give an error.                                     
  var inferredList = [foo];  //# 02: compile-time error   

well that's good to have my answer regarding inference!

[MichaelRFairhurst]

Aside from the inference case, this is fixed in https://dart-review.googlesource.com/c/sdk/+/61109 and https://dart-review.googlesource.com/c/sdk/+/61103.

I'll open a new bug for the inference side and put it in 2.1.