Index key accessed nullable index type is not narrowed from nullable

[tinganho]

interface S {
    hello: any;
}

interface R {
    [i: string]: S | undefined;
}

function f<K extends keyof R>(p: K) {
    let r: R = {};
    if (r[p]) {
        r[p].hello // Error: hello does not exists on type R[K]
    }
}

Removing the type undefined from S | undefined fixes the error and also the if check is no longer required.

[DanielRosenwasser]

I think this might be a duplicate of #10530. Could you post your example on #10565 just so we can add a test case?

[DanielRosenwasser]

This is actually a little iffy - despite how we'd like to think about it, there's not anything that really ties keyof R to R. In the end, keyof R is really just equivalent to string.

[tinganho]

@DanielRosenwasser though it does ties to R if you remove undefined?

interface S {
    hello: any;
}

interface R {
    [i: string]: S;
}

function f<K extends keyof R>(p: K) {
    let r: R = {};
    if (r[p]) {
        r[p].hello // No error
    }
}

[ahejlsberg]

Aside from not supporting narrowing with element access expressions (which is tracked by #10530), we would have to introduce a new type operator that records the fact that a truthy check has been performed on some generic type. For example, given a T! operator that represents a truthy check on T, within the if block, r[p] would have type R[K]!. Then, when we obtain the apparent type of R[K]! in the property access r[p].hello we would know to remove undefined from the type.

However, introducing new type operators is not a trivial matter, and I'm not sure it is worth the effort in this particular scenario.

[mhegazy]

Closing in favor of #14366 and #10530.