literal function with structure spread can't be rightly inferred in function's generic type slot

[zheeeng]

TypeScript Version: 3.2.1

Search Terms:

strucutre spread + generic

Code

function id<T>(input: T): T { return input }

function getFoo ({ foo = 42 }) {
  return foo
}

const newGetFoo = id(getFoo)
const newGetFoo2 = id(function getFoo ({ foo = 42 }) {
  return foo
})

Expected behavior:

newGetFoo and newGetFoo2 should have the same signature

Actual behavior:

newGetFoo is:

({ foo }: {
    foo?: number | undefined;
}) => number

but newGetFoo2 is

 ({ foo }: any) => number

Playground Link:
http://www.typescriptlang.org/play/index.html#src=function%20id%3CT%3E(input%3A%20T)%3A%20T%20%7B%20return%20input%20%7D%0A%0Afunction%20getFoo%20(%7B%20foo%20%3D%2042%20%7D)%20%7B%0A%20%20return%20foo%0A%7D%0A%0Aconst%20newGetFoo%20%3D%20id(getFoo)%0Aconst%20newGetFoo2%20%3D%20id(function%20getFoo%20(%7B%20foo%20%3D%2042%20%7D)%20%7B%0A%20%20return%20foo%0A%7D)%0A

Related Issues:

[ahejlsberg]

Our intended design is to determine the type of a parameter from one of the following, in order of preference:

1. Explicit type annotation
2. Contextual parameter type
3. Initializer type
4. Type implied by binding pattern

See original discussion and rationale here.

For the getFoo function we end up using the type implied by the binding pattern (i.e. ({ foo }: { foo?: number }) => number) because there is no type annotation, contextual type, or initializer type. This is working as intended.

However, for the function expression passed as an argument to id we do have a contextual type, namely T. Since T has no constraint we should end up inferring an implicit any type for the parameter, but this isn't quite working correctly.

So, the bug here is that newGetFoo2 should have type ({ foo }: any) => any and in -noImplicitAny mode we should report an implicit any error on foo.

EDIT: In retrospect, I now agree newGetFoo2 should have the same type as getFoo and newGetFoo. #36476 has the fix.