Generic type doesn't infer correctly without number type in function

[wbolduc]

Bug Report

number annotation is required despite typescript correctly identifying that same type

🕗 Version & Regression Information

• This is the behavior in every version I tried

⏯ Playground Link

Playground link with relevant code

💻 Code

interface QueryLoading {
	isSuccess: false;
	data: undefined;
}
interface QueryLoaded<T> {
	isSuccess: true;
	data: T;
}
type UseQueryResult<T> = QueryLoaded<T> | QueryLoading;

interface Thing {
	id: number;
	name: string;
	description: string;
}
const useGetThing = (id: number | null | undefined): UseQueryResult<Thing> =>
	id
		? {
				isSuccess: true,
				data: { id, name: "fake name", description: "fake description" },
		  }
		: { isSuccess: false, data: undefined };

/// pretend to be reactquery ^^

interface NameId {
	id: number;
	name: string;
}
interface WeirdRendererProps<T extends NameId, FieldName extends keyof T> {
	id: number;
	useGetter: (id: number) => UseQueryResult<T>;
	field_name: FieldName;
	render: (value: T[FieldName]) => string;
}

const weirdRenderer = <T extends NameId, FieldName extends keyof T>({
	id,
	useGetter,
	field_name,
	render,
}: WeirdRendererProps<T, FieldName>) => {
	const { data, isSuccess } = useGetter(id);
	return isSuccess ? render(data[field_name]) : null;
};

export const A = () =>
	weirdRenderer({
		id: 1,
		useGetter: (i_am_a_number: number) => useGetThing(i_am_a_number),
		//                            ^ Why does it seem like 'number' is required here to get the types to work
		field_name: "description",
		render: (value) => value.toString(),
	});

export const B = () =>
	weirdRenderer({
		id: 1,
		useGetter: (i_am_a_number) => useGetThing(i_am_a_number),
		//               ^?
		field_name: "description",
		render: (value) => value.toString(),
	});

export const C = () =>
	weirdRenderer({
		id: 1,
		useGetter: useGetThing,
		field_name: "description",
		render: (value) => value.toString(),
	});

🙁 Actual behavior

typescript is throwing an error off of the generic

🙂 Expected behavior

If typescript can correctly identify the type of the function arguments it should make no difference if I manually add or remove that annotation

[RyanCavanaugh]

The order of inference that would be needed here -- first check the return type of useGetThing, then check field_name, then figure out render's parameter type -- is pretty far off from a supported ordering of inference steps. See #30134

[wbolduc]

What I don't understand here though is that in the playground it looks like ts is correctly identifying it as a number. If it can give me the intelisense on what that value should be why does it matter if I do or do not specify it explictily

[RyanCavanaugh]

Intellisense doesn't compute the entire type flow of the program -- instead, it tries to compute the minimum amount possible so that results can come back faster. In some cases like this, these shortcuts can produce slightly inaccurate results compared to what would be produced from a proper inference.