Given generic `W extends { x: A | B | undefined }` should be able to use `keyof W['x']` to index w.x

[studds]

TypeScript Version: 2.4.0 / nightly (2.5.0-dev.201xxxxx)

2.4.1 (playground)

Code

// A *self-contained* demonstration of the problem follows...

interface A { a: string; }

interface B {  b: string; }

interface W {
    x: A | B | undefined;
}

function fn2<W1 extends W>(w: W1, k: keyof W1['x']) {
    // issue 1: incorrect error: Type 'keyof W1["x"]' cannot be used to index type 'Partial<A> | Partial<B>'.
    // also correctly reports error: Object is possibly 'undefined'.
    w.x[k] = 'string';

    // this is fine, with the explicit type
    const x: W1['x'] = w.x;
    // issue 2: Should complain that w.x might be undefined
    x[k] = 'string';
}

// Inside the generic function, W1['x'] is unnecessarily and prematurely resolved to `A | B | undefined`, 
// causing the error to be incorrectly reported.
// The final type of W1['x'] and keyof W1['x'] should only be resolved when the function is called.
// This in fact works correctly already. 

// correctly infers type of param k, errors: Argument of type '"a"' is not assignable to parameter of type '"b"'.
fn2({ x: { b: '' } }, 'a');

// no error
fn2({ x: {  b: '' } }, 'b');

// k is correctly resolved to never: Argument of type '"a"' is not assignable to parameter of type 'never'.
let ambiguous: W = <W>{};
fn2(ambiguous, 'a');
fn2({ x: undefined }, 'a');

Expected behavior:

1. Given a generic W extends { x: A | B | undefined } should be able to use keyof W['x'] to index w.x
2. Should complain that w.x could be undefined after assigning to explicitly typed variable W['x']

Actual behavior:

1. Errors unless you create a local variable with explicit type W['x']: const x: W['x'] = w.x;
2. Does not complain that x could be undefined after assigning to explicitly typed variable W['x']

[RyanCavanaugh]

The root cause here is that k has type never, which leads to some surprising but intended behavior.

undefined has no keys, so keyof W1['x'] is never (the keyof a union type is the intersection of its constituents' keys). Even removing undefined from the equation, A and B have no properties in common -- there's no legal call to fn2!

---

    // this is fine, with the explicit type
    const x: W1['x'] = w.x;
    // issue 2: Should complain that w.x might be undefined
    x[k] = 'string';

This is a bug as far as I can tell.

[studds]

Thanks for the quick response @RyanCavanaugh!

If in the example above I do type K = keyof W['x'] then as you say, K is never. But in the generic example, keyof W1['x'] does not resolve to never (at least, in the playground, it doesn't pop up with never as the type - it simply reports the type as keyof W1['x'] - this seems correct to me).

In the generic example, I don't think it would be correct to attempt to resolve keyof W1['x'] within the generic function. It should be (and currently is) resolved when the function is called.

Instead, I think the problem is the premature resolution of the type of w.x from the generic type W1['x'] to the non-generic type A | B | undefined. I cannot see why it's not consistent to use a generic key keyof W1['x'] as an index of W1['x']. There's no need within the generic function to actually resolve what W1['x'] means as this will be done when you actually call the function.

I've added to my original example some examples of fn2 being called, and the generic type inference works beautifully, correctly inferring keyof A -> 'a' when appropriate and keyof A | B -> never when called ambiguously.

[studds]

Just to clarify a bit further, the error reported is not Type 'never' cannot be used as an index type. which would be correct if you were trying to index W1['x'] with keyof W['x'] (that is, the generic variable with the non-generic key.)

Rather, the error that occurs is Type 'keyof W1["x"]' cannot be used to index type 'Partial<A> | Partial<B>'. This error occurs when attempting to index the generic type with the generic key. However, the message suggests that typescript is not treating w.x as generic, but rather as having the specific type Partial<A> | Partial<B>.

[ahejlsberg]

With the compiler currently in master, for both issue 1 and 2 above we report Type 'keyof W1["x"]' cannot be used to index type 'A | B'. That error is correct. The constraint of keyof W1["x"] is keyof (A | B), which simplifies to keyof A & keyof B, which is never (because there are no common properties).

So, our current behavior looks to be correct here.