Discrepancy inferring function parameter from context

[benjaminjkraft]

As of today's nightly:

declare function compact<T>(array: T[]): T[];
declare function makeFooer(): Fooer;
interface Fooer {
  foo: (v: string) => string;
}
function f() {
  const _ = compact([makeFooer(), { foo: (v) => v }]);
}

This passes in TS, but fails in Go with:

src/compact.ts:7:43 - error TS7006: Parameter 'v' implicitly has an 'any' type.

7   const _ = compact([makeFooer(), { foo: (v) => v }]);

(Without the compact both TS and Go refuse to infer. With an explicit type on the const, they both infer successfully.)

This is simplified from a real issue with _.compact in our codebase.

[Andarist]

It's a regression caused by #850

A similar example doesn't work in Strada (TS playground):

declare function compact<T>(array: T[]): T[];
declare function makeFooerFn(): FooerFn;
interface FooerFn {
  (v: string): string;
}
function f2() {
  const _ = compact([makeFooerFn(), (v) => v]); // Parameter 'v' implicitly has an 'any' type.(7006)
  const _2 = compact([makeFooerFn(), (v: string) => v]); // ok
}

[ahejlsberg]

The change in #850 doesn't seem right in retrospect. The purpose of anyFunctionType is to be a wildcard that is ignored during the first phase of type inference where contextually sensitive function expressions are excluded. But #850 makes anyFunctionType a supertype of other function types, meaning that all inferences will be discarded when a contextually sensitive function expression is present. It really should be the opposite, i.e. anyFunctionType should be a subtype of all other function types (kind of like a never function type). That would remove the error in this issue. However, it would also cause #849 to again become an error. I think that's the better outcome--in #849, the inference made from return () => true will then win over the weaker inference made from the (input: string) => boolean type annotation. That's the intended behavior, even if it then subsequently means we can't assign a contextual type in return input => input.length > 0.