NoInfer and overloaded function argument inference

[kevinresol]

🔎 Search Terms

NoInfer, overload

🕗 Version & Regression Information

Version 5.4.3

• I was unable to test this on prior versions because this is a new feature

⏯ Playground Link

https://www.typescriptlang.org/play?#code/CYUwxgNghgTiAEAzArgOzAFwJYHtXwAcYdhkwQAKRALngDkcBJVREGAHgoEp4BeAPngA3HFmD8utbn0EixAbgBQoSLAQp02PIWKly7AIL8qtBs1YcKsAOa0DPAcNHjJ8KzFvx7MpwsWKwPABnDHgADykHWWc+HRIySmlHAEYuJUDUEPgATykbWhCYLFRrKN9gWKJ48goKITLUpSA

💻 Code

declare function produce(f: NoInfer<() => void>): () => void;
declare function produce<A>(f: NoInfer<(arg: A) => void>): (arg: A) => void;

const x: () => void = produce(() => 1); // works
const y: (arg: string) => void = produce((v) => 1); // Parameter 'v' implicitly has an 'any' type.

🙁 Actual behavior

Because const y is explicitly typed and thanks to the new utility NoInfer type, the compiler is able to figure out (from the return type) it is calling the produce<string>() overload. (Without NoInfer it would just be produce<any>()).

However, apparently it does not apply this knowledge to the function parameter f and thus the non type-hinted argument v is inferred as any

🙂 Expected behavior

Since the compiler already knows f is of type NoInfer<(arg:string)=>void> it should be able to infer the lambda argument v to be of string type.

Additional information about the issue

No response

[Andarist]

This isn't related to NoInfer as this doesn't assign the correct contextual parameter here either:

declare function produce(f: () => void): () => void;
declare function produce<A>(f: (arg: A) => void): (arg: A) => void;
const y: (arg: string) => void = produce((v) => 1);

There is a good chance that this PR might solve your issue: #57421

[Andarist]

Since Ryan Cavanaugh (@RyanCavanaugh) has prepared a playground for that mentioned PR (thanks!) we can now quickly confirm that it fixes this issue: TS playground

[typescript-bot]

This issue has been marked as "Duplicate" and has seen no recent activity. It has been automatically closed for house-keeping purposes.