Type info of arrow function arguments get lost when you parametrize that function

Bug Report

🔎 Search Terms

arrow function type inference type parameters

see also issue: https://github.com/microsoft/TypeScript/issues/50417

🕗 Version & Regression Information

the furthest back the playground allows is 3.3.3; in that version this was already an issue

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about bugs that are not bugs

⏯ Playground Link

Playground link with relevant code

💻 Code

type MyFuncType = (a: string) => void;

const myFuncImp: MyFuncType = (a) => { // <-- the fact that this argument is of type string does not have to be respecified, just the argument name is enough
    a.endsWith("foo")
}

//now trying the same with type parameters:

type MyFuncTypeWithTypeParameter = <T>(a: string) => void;


const myFuncImpWithTypeParameter: MyFuncType = <T, >(a) => { // <-- now suddenly the type of a is unknown
    a.endsWith("foo")
}

🙁 Actual behavior

the type of a is not known

🙂 Expected behavior

the type of ‘a’ is known by the compiler

[corno]

@RyanCavanaugh I’ve tried to come up with a minimal example of when this might occur. I’m using ‘map’ as an example. I have lots of occurences of these kind of things. Can you explain what you feel is the issue with this code, why it should never been written in the first place?

playground

[corno]

On line 13, you’ve declared a generic function. But you’re actually declaring new type parameters which might come in with a different order, different count, different meaning, different anything, from the type parameter list in the contextual type. You happen to have declared a type argument list with the same names and cardinality, but this isn’t a requirement, and there’s no way to tell the difference between a type argument list that intends to correlate with the contextual type’s and one that doesn’t

This seems to be the crux of the issue. It’s a catch-22: TS won’t contextually infer a type parameter list (case 1), but explicitly specifying the type parameters (case 2) makes new, unrelated bindings.

If I understand you correctly, this is indeed the problem I’m facing.

Here is an example that is closer to my actual code base. playground

I’m writing an inner function because there is a recursive structure that needs to be visited. I want the inner function to use the outer function’s parameter ‘report’ and I don’t want to copy that parameter to the inner function. This means that I have to be able to refer to the generic type ‘T’. If there is something intrinsically wrong with this approach, I would really like to hear that.