Generics get broken when inferred from a function with an implicitly typed parameter

Bug Report

🔎 Search Terms

generic, function, parameters, unknown, never

🕗 Version & Regression Information

This is the behavior in every version I tried, and I reviewed the FAQ for entries about Generics

⏯ Playground Link

💻 Code

interface Entity {
    id: number;
    name: string;
}

type Fn<T> = (params: Record<string, unknown>) => T[];

declare function test<T, K extends keyof T>(fn: Fn<T>, key: K): T;

// Case #1: params aren't used, generic is `<Entity, 'id'>` ✅
test(() => [] as Entity[], 'id');

// Case #2: params are used with a type being explicitly specified, generic is `<Entity, 'name'>` ✅
test((params: Record<string, unknown>) => [] as Entity[], 'name');

// Case #3: params are used with a different type, generic is `<Entity, 'id'>` ✅
test((params: unknown) => [] as Entity[], 'id');

// Case #4: params are used with an implicit type, generic is <unknown, never> ❌
test((params) => [] as Entity[], 'id');
      ^ but it's inferred properly as Record<string, unknown>

🙁 Actual behavior

In the case 4 a generic gets broken and has a type <unknown, never> instead of <Entity, 'id'> as shown in the previous examples.
There's nothing wrong with an implicit type for params since it's already automatically inferred as Record<string, unknown>.

🙂 Expected behavior

The case 4 should work exactly the same as the previous ones and missing type annotation in parameters should have no impact on the inferred generic type.

Duplicates the part of #47599 that's still unresolved... and might never be resolved, see #48538 (comment):

() => 42 and (n: number) => n are context insensitive because they have no contextually typed parameters, but n => n and function() { return 42 } are context sensitive because they have at least one contextually typed parameter (in the function expression case, the implicit this parameter is contextually typed). The errors in the last two calls occur because inferred type information only flows from left to right between context sensitive arguments. This is a long standing limitation of our inference algorithm, and one that isn't likely to change. [emphasis added]

Joe Calzaretta (@jcalz)

Thanks Joe Calzaretta (@jcalz), I suspected this was related to contextual typing but wasn't confident enough about the cause to jump in. I thought it might just be a circularity (i.e. T infers from function parameter -> arrow function is contextually typed by T -> cycle detected -> default to constraint)

Joe Calzaretta (@jcalz)

Joe Calzaretta (@jcalz) Thank you for clearing this up, it makes sense now. I'm going to close this one as it already has a bunch of duplicates out there.
So, for anyone coming up here the best solution is to explicitly add a type annotation for your parameter like this: (params: YourType) => ... or get rid of your parameter at all.

Navigation Menu

Repository navigation

Generics get broken when inferred from a function with an implicitly typed parameter #54438

Bug Report

🔎 Search Terms

🕗 Version & Regression Information

⏯ Playground Link

💻 Code

🙁 Actual behavior

🙂 Expected behavior

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Generics get broken when inferred from a function with an implicitly typed parameter #54438

Description

Bug Report

🔎 Search Terms

🕗 Version & Regression Information

⏯ Playground Link

💻 Code

🙁 Actual behavior

🙂 Expected behavior

Activity

jcalz commented on May 29, 2023

fatcerberus commented on May 29, 2023

mattersj commented on May 31, 2023

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions