Support type guards on property access expression

[tinganho]

I just found out that property access expressions doesn't work on type predicate functions and instanceof type guards.

class A {
    propA: number;
}

class B {
    propB: number;
}
class C {
    propC: A;
}

declare function isA(p1: any): p1 is D;

interface D {
    a: A | B
    b: A | C;
}

let d: D;
if (isA(d.b)) {
    d.b.propA; //error
}

function foo(d: D) {
    if (d.b instanceof A) {
        d.b.propA // error
    }
}

I'm not sure if there is an easy fix on this problem. We are provided just a symbol when narrowing. That symbol represent the left most expression and then we walk up the if statement. There is no easy way of controlling symbol by symbol on each namespace in a property access expression in the if-statement-body. Because there is no info about the property access expression provided in getTypeOfSymbolAtLocation(symbol: Symbol, node: Node).

I also found that type assertion expressions are also not working in type predicate functions. But I will land a fix on that.

if (isA(<A>union)) {
    a = union;
}
if (isA(union as A)) {
    a = union;
}

[danquirk]

I believe I ran into similar cases when first playing with #1260. This is by design (4.20):
Note that type guards affect types of variables and parameters only and have no effect on members of objects such as properties
so I will edit the title to reflect the suggestion a little more clearly.

[mhegazy]

is not this a duplicate of #1260?

[danquirk]

Upon reflection probably yes unless there's something unique about the more recent changes to type guards supporting basic property access but not instanceof/user defined type guards

[mhegazy]

instance of and use type guards are just two checks, if we allow narrowing by property access, we will need to add it every where, typeof, instanceof, type guards ..etc..

[danquirk]

Yeah, that's what I figured, will just close this then.

[RyanCavanaugh]

I don't think #1260 and this are really the same thing

[Joncom]

The following example demonstrates the problem, which still exists in 1.8.2:

interface Foo {
    myProperty: (boolean | string)
}

var foo: Foo = {
    myProperty: "Hello World"
};

var p = foo.myProperty;
if (typeof p === "string") {
    // This works fine!
    console.log(p.length); // Prints `11`
}

if (typeof foo.myProperty === "string") {
    // This line produces the following compilation error:
    // "Property 'length' does not exist on type 'boolean | string'."
    console.log(foo.myProperty.length);
}

[RyanCavanaugh]

This will be going in as part of the non-nullable type work

[ahejlsberg]

Closed in #7140.