Unable to infer generic for a Pick / indexed-access type from a union of compatible types

[fongandrew]

TypeScript Version: 2.3.4
Code

interface Test {
  cat: number;
  dog: number;
}

declare function doTest<T extends keyof Test>(x: Pick<Test, T>): void;

declare var cat: { cat: number };
doTest(cat);

declare var dog: { dog: number };
doTest(dog);

declare var catOrDog: { cat: number } | { dog: number };
doTest(catOrDog); // Error

Expected behavior: Last line should not error

Actual behavior: Property 'dog' is missing in type '{ cat: number; }'.

I understand this might be working as intended insofar that, in the last invocation of doTest, it's unclear what generic T to infer for the function. If T is 'cat'|'dog', then Pick<Test, 'cat'|'dog'> would require both cat and dog, which the union type for catOrDog does not match.

On the other hand, it seems very odd for a function to accept both an argument of type { cat: number } and type { dog: number } but not type { cat: number }|{ dog: number }.

As a work-around, it is possible to type doTest with additional generics, like so:

declare function doTest<T extends keyof CatAndDog, V extends keyof CatAndDog>(
  x: Pick<CatAndDog, T>|Pick<CatAndDog, V>
): void;
doTest<"cat", "dog">(catOrDog); // No eror

But this feels like a less than ideal solution.

[jcalz]

I feel like I've seen this sort of thing crop up for different people and I wonder if there's a known issue that tracks the general case of reduction of unions/intersections of overloaded/generic functions.

You want TypeScript to notice that doTest is the intersection of a function from Pick<Test,'cat'> to void and a function from Pick<Test,'dog'> to void, and treat it as a function from Pick<Test,'cat'> | Pick<Test,'dog'> to void. You can kind of force TypeScript to notice this without touching your declaration of doTest declaration, in the following ugly way:

function intersectFunction<A1, R1, A2, R2>(f: ((a: A1) => R1) & ((a: A2) => R2)): (a: A1|A2) => R1|R2 {
  return f;
}
var doTestCatOrDog = intersectFunction<Pick<Test, 'cat'>, void, Pick<Test, 'dog'>, void>(doTest); 
doTestCatOrDog(catOrDog); // success!

Similarly, there's the flip side where one wants TypeScript to notice that you have a function which is the union of a function from A1 to R1 and a function from A2 to R2, and you want to be able to give it a parameter of type A1 & A2 and get a value of type R1 | R2:

var g = Math.random() < 0.5 ? ((x:string) => 1) : ((x:'dog') => 'dog')
g('dog'); //error

function uniteFunction<A1, R1, A2, R2>(f: ((a: A1) => R1) | ((a: A2) => R2)): (a: A1&A2) => R1|R2 {
  return f;
}

var gDog = uniteFunction<string, number, 'dog', string>(g);
gDog('dog'); // success!

It's probably a difficult problem to solve properly and lots of creeping unsoundness happens. But I wonder if it's tracked anywhere. See #16644 and #16716 for recent similar examples.

[fongandrew]

Closing. I think this is a duplicate of #14107.