Generic type is not expanded when typechecking equality check

[fictitious]

TypeScript Version: 3.1.0-dev.20180829

Search Terms: generics expansion union equality typecheck

Code

type A = {type :"a"}
type B = {type :"b"}

type P<T extends A | B> = T["type"];

class C<T extends A | B> {

    p: P<T> = 'x'; //error: Type '"x"' is not assignable to type '"a" | "b"'
    // so when typechecking this assignment, it's known that 
    // P<T> actually is "a" | "b"

    f(p: P<T>) {
        if (p === 'x') { // why no error here
        // when typechecking this equality check, P<T> is not expanded ?   
        }
    }

    // expected error, for illustration
    f0(p: 'a' | 'b') {
        if (p === 'x') { // error: This condition will always return 'false' 
                         // since the types '"a" | "b"' and '"x"' have no overlap.

        }
    }

}

Expected behavior:

"This condition will always return 'false'" is reported when doing equality check between a variable declared with P<T> type and "x" literal

Actual behavior:

No error is reported for that particular equality check

Playground Link: link

Related Issues: did not find anything

[mattmccutchen]

Analysis (originally posted here): The rule for a === b is normally that either the type of a has to be comparable to the type of b or vice versa, but there is a special case: if one type is a union of literals and the other type is not, then the type that is a union of literals is changed to the underlying primitive type (here string) for the purpose of the check. This special case is firing undesirably on the first p === 'x' where one side is a union of literals and the other side is a type parameter that is not itself a union of literals but is constrained by a union of literals.

Additional search terms: comparable constrained constraint union literal

[mattmccutchen]

Fix is in #27588.