synthetic function types are not substituted correctly

[leafpetersen]

EDIT by @jmesserly: see comment here #29778 (comment) for description of the problem.

This bug has been recurring rather often and showed up in several other bugs, #30822 and #30207

original bug description by Leaf follows:

---

The following program:

void main() {
  Null Function<R>(R Function(int)) f = <S>(g) {};
}

produces the following incorrect error when run against bleeding edge analyzer:

  error • A value of type '<S₀>((int) → S) → Null' can't be assigned to a variable of type '<R>((int) → R) → Null' at /Users/leafp/tmp/test.dart:2:41 • invalid_assignment

The inferred type for the lambda is <S₀>((int) → S) → Null, instead of the presumably correct <S₀>((int) → S₀) → Null .

It looks like downwards inference is correctly choosing a new canonical type variable S₀ to use to match up R and S, but is then constructing the final inferred type using a mix of S and
S₀ to produce an invalid type.

[jmesserly]

possibly related substitution problem: #30207

[jmesserly]

so, this happens any time we construct a (synthetic) function type, such as in TypeSystem. The resulting object cannot be substituted correctly because its free variable list (FunctionTypeImpl.typeParameters) is empty (because it did not have an enclosingElement scope chain available to populate the free variables).

This is going to be tricky to fix, but I'm working on it.

Other interesting finds:

• function types are not considered equal unless their typeArguments arrays are. So int -> int is not the same as {int/T} T -> T ... I thought we'd fixed this, but it's back (edit: and test_instanceField_functionTypeAlias_doesNotUseItsTypeParameter depends on this behavior somehow)
• GLB/LUB seems to ignore(!!) typeFormals of a generic function (filed as GLB/LUB do not handle generic functions #30237)

EDIT: also we need to fix TypeParameterElement.==/hashCode so they work correctly for synthetic type parameters.

[jmesserly]

Here are two more repros from #30822

main() {
  T Function() Function<T>() g =
      <S>() {
    S Function() f;
    if (f != null) return f;
    return () => f();
  };
}

and

// Wants a function that takes a function and returns a same-typed function.
void foo(T Function() Function<T>(T Function() f) parameterName) {}

// Using a function literal. -> the return type needs to be inferred.
foo(<T>(T Function() f) {
  if (true) return f;
  return () => f();
});

[jmesserly]

another example from #30207 is tests/language_2/generic_methods_generic_function_result_test.dart