Infer type in conditional cannot unify generics

TypeScript Version: 2.8.0-dev.20180315

Search Terms: infer conditional unify generic function

Code

type Apply1<T, V> = T extends (item: V) => infer R ? R : never;
type A1 = Apply1< (item: string) => string[] , string>;
type B1 = Apply1< <U>(item: U) => U[], string>;

type Apply2<T, V> = T extends (item: V, obj: infer R) => any ? R : never;
type A2 = Apply2< (item: string, obj: string[]) => any , string>;
type B2 = Apply2< <U>(item: U, obj: U[]) => any , string>;

type Apply3<T, V> = T extends (item: V, obj: infer R) => infer R ? R : never;
type A3 = Apply3< (item: string, obj: string[]) => string[] , string>;
type B3 = Apply3< <U>(item: U, obj: U[]) => U[] , string>;

{
	"compilerOptions": {
		"allowJs": true,
		"target": "es6",
		"module": "commonjs",
		"outDir": "dest",
		"strictNullChecks": true,
		"jsx": "preserve",
		"strictFunctionTypes": true
	}
}

Expected behavior: All A and B types are inferred to string[]. For types B, the type parameter U should be unified with string.

Actual behavior: All B types are inferred to {}[].

Related Issues: #22615 (different problem, but similar input)

[fazouane-marouane]

Hi,

I’ll add a simple example related to this:

type GenericReturnType<T, TInput> = T extends (_: TInput) => infer TResult? TResult: never;

// Gives { x: {}; }
type Box = <T>(_: T)=> { value: T };
type _test1 = GenericReturnType<Box, number>;

// Gives {x: number; }
type AltBox<T> = (_: T)=> { value: T };
type _test2 = GenericReturnType<AltBox<number> | AltBox<string>, number>;

[ahejlsberg]

Repeating my comments from #22615 as they apply equally here:

It is effectively a design limitation. We have the concept of instantiating a generic function type in the context of a non-generic function type (a form of unification), but we currently don’t do that in conditional types. Instead, function type parameters are erased to their constraints and we infer from those. In the example above, that causes us to infer {} for the infer R type parameter.

The proper fix for this would be have type inference perform instantiation of a source type in the context of a target type when the source type is a generic function type.