controlFlowOptionalChain.types

//// [tests/cases/conformance/controlFlow/controlFlowOptionalChain.ts] ////

=== controlFlowOptionalChain.ts ===
// assignments in shortcutting chain
declare const o: undefined | {
>o : { (...args: any[]): any; [key: string]: any; [key: number]: any; } | undefined
>  : ^^^^^^    ^^     ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    [key: string]: any;
>key : string
>    : ^^^^^^

    [key: number]: any;
>key : number
>    : ^^^^^^

    (...args: any[]): any;
>args : any[]
>     : ^^^^^

};

let a: number;
>a : number
>  : ^^^^^^

o?.[a = 1];
>o?.[a = 1] : any
>           : ^^^
>o : { (...args: any[]): any; [key: string]: any; [key: number]: any; } | undefined
>  : ^^^^^^    ^^     ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>a = 1 : 1
>      : ^
>a : number
>  : ^^^^^^
>1 : 1
>  : ^

a.toString();
>a.toString() : string
>             : ^^^^^^
>a.toString : (radix?: number) => string
>           : ^     ^^^      ^^^^^      
>a : number
>  : ^^^^^^
>toString : (radix?: number) => string
>         : ^     ^^^      ^^^^^      

let b: number;
>b : number
>  : ^^^^^^

o?.x[b = 1];
>o?.x[b = 1] : any
>            : ^^^
>o?.x : any
>     : ^^^
>o : { (...args: any[]): any; [key: string]: any; [key: number]: any; } | undefined
>  : ^^^^^^    ^^     ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : any
>  : ^^^
>b = 1 : 1
>      : ^
>b : number
>  : ^^^^^^
>1 : 1
>  : ^

b.toString();
>b.toString() : string
>             : ^^^^^^
>b.toString : (radix?: number) => string
>           : ^     ^^^      ^^^^^      
>b : number
>  : ^^^^^^
>toString : (radix?: number) => string
>         : ^     ^^^      ^^^^^      

let c: number;
>c : number
>  : ^^^^^^

o?.(c = 1)
>o?.(c = 1) : any
>           : ^^^
>o : { (...args: any[]): any; [key: string]: any; [key: number]: any; } | undefined
>  : ^^^^^^    ^^     ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>c = 1 : 1
>      : ^
>c : number
>  : ^^^^^^
>1 : 1
>  : ^

c.toString();
>c.toString() : string
>             : ^^^^^^
>c.toString : (radix?: number) => string
>           : ^     ^^^      ^^^^^      
>c : number
>  : ^^^^^^
>toString : (radix?: number) => string
>         : ^     ^^^      ^^^^^      

let d: number;
>d : number
>  : ^^^^^^

o?.x(d = 1);
>o?.x(d = 1) : any
>            : ^^^
>o?.x : any
>     : ^^^
>o : { (...args: any[]): any; [key: string]: any; [key: number]: any; } | undefined
>  : ^^^^^^    ^^     ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : any
>  : ^^^
>d = 1 : 1
>      : ^
>d : number
>  : ^^^^^^
>1 : 1
>  : ^

d.toString();
>d.toString() : string
>             : ^^^^^^
>d.toString : (radix?: number) => string
>           : ^     ^^^      ^^^^^      
>d : number
>  : ^^^^^^
>toString : (radix?: number) => string
>         : ^     ^^^      ^^^^^      

// type predicates
declare const f: undefined | ((x: any) => x is number);
>f : ((x: any) => x is number) | undefined
>  : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^
>x : any
>  : ^^^

declare const x: string | number;
>x : string | number
>  : ^^^^^^^^^^^^^^^

if (f?.(x)) {
>f?.(x) : boolean | undefined
>       : ^^^^^^^^^^^^^^^^^^^
>f : ((x: any) => x is number) | undefined
>  : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^
>x : string | number
>  : ^^^^^^^^^^^^^^^

    x; // number
>x : number
>  : ^^^^^^

    f; // (x: any) => x is number
>f : (x: any) => x is number
>  : ^ ^^   ^^^^^           

    f(x);
>f(x) : boolean
>     : ^^^^^^^
>f : (x: any) => x is number
>  : ^ ^^   ^^^^^           
>x : number
>  : ^^^^^^
}
else {
    x;
>x : string | number
>  : ^^^^^^^^^^^^^^^

    f;
>f : ((x: any) => x is number) | undefined
>  : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^

    f(x);
>f(x) : boolean
>     : ^^^^^^^
>f : ((x: any) => x is number) | undefined
>  : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^
>x : string | number
>  : ^^^^^^^^^^^^^^^
}
x;
>x : string | number
>  : ^^^^^^^^^^^^^^^

f;
>f : ((x: any) => x is number) | undefined
>  : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^

f(x);
>f(x) : boolean
>     : ^^^^^^^
>f : ((x: any) => x is number) | undefined
>  : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^
>x : string | number
>  : ^^^^^^^^^^^^^^^

declare const o2: { f(x: any): x is number; } | undefined;
>o2 : { f(x: any): x is number; } | undefined
>   : ^^^^ ^^   ^^^           ^^^^^^^^^^^^^^^
>f : (x: any) => x is number
>  : ^ ^^   ^^^^^           
>x : any
>  : ^^^

if (o2?.f(x)) {
>o2?.f(x) : boolean | undefined
>         : ^^^^^^^^^^^^^^^^^^^
>o2?.f : ((x: any) => x is number) | undefined
>      : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^
>o2 : { f(x: any): x is number; } | undefined
>   : ^^^^ ^^   ^^^           ^^^^^^^^^^^^^^^
>f : ((x: any) => x is number) | undefined
>  : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^
>x : string | number
>  : ^^^^^^^^^^^^^^^

    x; // number
>x : number
>  : ^^^^^^

    o2.f; // (x: any) => x is number
>o2.f : (x: any) => x is number
>     : ^ ^^   ^^^^^           
>o2 : { f(x: any): x is number; }
>   : ^^^^ ^^   ^^^           ^^^
>f : (x: any) => x is number
>  : ^ ^^   ^^^^^           

    o2?.f;
>o2?.f : (x: any) => x is number
>      : ^ ^^   ^^^^^           
>o2 : { f(x: any): x is number; }
>   : ^^^^ ^^   ^^^           ^^^
>f : (x: any) => x is number
>  : ^ ^^   ^^^^^           

    o2?.f(x);
>o2?.f(x) : boolean
>         : ^^^^^^^
>o2?.f : (x: any) => x is number
>      : ^ ^^   ^^^^^           
>o2 : { f(x: any): x is number; }
>   : ^^^^ ^^   ^^^           ^^^
>f : (x: any) => x is number
>  : ^ ^^   ^^^^^           
>x : number
>  : ^^^^^^
}
else {
    x;
>x : string | number
>  : ^^^^^^^^^^^^^^^

    o2;
>o2 : { f(x: any): x is number; } | undefined
>   : ^^^^ ^^   ^^^           ^^^^^^^^^^^^^^^

    o2?.f;
>o2?.f : ((x: any) => x is number) | undefined
>      : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^
>o2 : { f(x: any): x is number; } | undefined
>   : ^^^^ ^^   ^^^           ^^^^^^^^^^^^^^^
>f : ((x: any) => x is number) | undefined
>  : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^

    o2.f;
>o2.f : (x: any) => x is number
>     : ^ ^^   ^^^^^           
>o2 : { f(x: any): x is number; } | undefined
>   : ^^^^ ^^   ^^^           ^^^^^^^^^^^^^^^
>f : (x: any) => x is number
>  : ^ ^^   ^^^^^           
}
x;
>x : string | number
>  : ^^^^^^^^^^^^^^^

o2;
>o2 : { f(x: any): x is number; } | undefined
>   : ^^^^ ^^   ^^^           ^^^^^^^^^^^^^^^

o2?.f;
>o2?.f : ((x: any) => x is number) | undefined
>      : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^
>o2 : { f(x: any): x is number; } | undefined
>   : ^^^^ ^^   ^^^           ^^^^^^^^^^^^^^^
>f : ((x: any) => x is number) | undefined
>  : ^^ ^^   ^^^^^           ^^^^^^^^^^^^^

o2.f;
>o2.f : (x: any) => x is number
>     : ^ ^^   ^^^^^           
>o2 : { f(x: any): x is number; } | undefined
>   : ^^^^ ^^   ^^^           ^^^^^^^^^^^^^^^
>f : (x: any) => x is number
>  : ^ ^^   ^^^^^           

declare const o3: { x: 1, y: string } | { x: 2, y: number } | undefined;
>o3 : { x: 1; y: string; } | { x: 2; y: number; } | undefined
>   : ^^^^^ ^^^^^      ^^^^^^^^^^^ ^^^^^      ^^^^^^^^^^^^^^^
>x : 1
>  : ^
>y : string
>  : ^^^^^^
>x : 2
>  : ^
>y : number
>  : ^^^^^^

if (o3?.x === 1) {
>o3?.x === 1 : boolean
>            : ^^^^^^^
>o3?.x : 1 | 2 | undefined
>      : ^^^^^^^^^^^^^^^^^
>o3 : { x: 1; y: string; } | { x: 2; y: number; } | undefined
>   : ^^^^^ ^^^^^      ^^^^^^^^^^^ ^^^^^      ^^^^^^^^^^^^^^^
>x : 1 | 2 | undefined
>  : ^^^^^^^^^^^^^^^^^
>1 : 1
>  : ^

    o3;
>o3 : { x: 1; y: string; }
>   : ^^^^^ ^^^^^      ^^^

    o3.x;
>o3.x : 1
>     : ^
>o3 : { x: 1; y: string; }
>   : ^^^^^ ^^^^^      ^^^
>x : 1
>  : ^

    o3?.x;
>o3?.x : 1
>      : ^
>o3 : { x: 1; y: string; }
>   : ^^^^^ ^^^^^      ^^^
>x : 1
>  : ^
}
else {
    o3;
>o3 : { x: 2; y: number; } | undefined
>   : ^^^^^ ^^^^^      ^^^^^^^^^^^^^^^

    o3?.x;
>o3?.x : 2 | undefined
>      : ^^^^^^^^^^^^^
>o3 : { x: 2; y: number; } | undefined
>   : ^^^^^ ^^^^^      ^^^^^^^^^^^^^^^
>x : 2 | undefined
>  : ^^^^^^^^^^^^^

    o3.x;
>o3.x : 2
>     : ^
>o3 : { x: 2; y: number; } | undefined
>   : ^^^^^ ^^^^^      ^^^^^^^^^^^^^^^
>x : 2
>  : ^
}
o3;
>o3 : { x: 1; y: string; } | { x: 2; y: number; } | undefined
>   : ^^^^^ ^^^^^      ^^^^^^^^^^^ ^^^^^      ^^^^^^^^^^^^^^^

o3?.x;
>o3?.x : 1 | 2 | undefined
>      : ^^^^^^^^^^^^^^^^^
>o3 : { x: 1; y: string; } | { x: 2; y: number; } | undefined
>   : ^^^^^ ^^^^^      ^^^^^^^^^^^ ^^^^^      ^^^^^^^^^^^^^^^
>x : 1 | 2 | undefined
>  : ^^^^^^^^^^^^^^^^^

o3.x;
>o3.x : 1 | 2
>     : ^^^^^
>o3 : { x: 1; y: string; } | { x: 2; y: number; } | undefined
>   : ^^^^^ ^^^^^      ^^^^^^^^^^^ ^^^^^      ^^^^^^^^^^^^^^^
>x : 1 | 2
>  : ^^^^^

declare const o4: { x?: { y: boolean } };
>o4 : { x?: { y: boolean; }; }
>   : ^^^^^^               ^^^
>x : { y: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>y : boolean
>  : ^^^^^^^

if (o4.x?.y) {
>o4.x?.y : boolean | undefined
>        : ^^^^^^^^^^^^^^^^^^^
>o4.x : { y: boolean; } | undefined
>     : ^^^^^       ^^^^^^^^^^^^^^^
>o4 : { x?: { y: boolean; }; }
>   : ^^^^^^               ^^^
>x : { y: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>y : boolean | undefined
>  : ^^^^^^^^^^^^^^^^^^^

    o4.x; // { y: boolean }
>o4.x : { y: boolean; }
>     : ^^^^^       ^^^
>o4 : { x?: { y: boolean; }; }
>   : ^^^^^^               ^^^
>x : { y: boolean; }
>  : ^^^^^       ^^^

    o4.x.y; // true
>o4.x.y : true
>       : ^^^^
>o4.x : { y: boolean; }
>     : ^^^^^       ^^^
>o4 : { x?: { y: boolean; }; }
>   : ^^^^^^               ^^^
>x : { y: boolean; }
>  : ^^^^^       ^^^
>y : true
>  : ^^^^

    o4.x?.y; // true
>o4.x?.y : true
>        : ^^^^
>o4.x : { y: boolean; }
>     : ^^^^^       ^^^
>o4 : { x?: { y: boolean; }; }
>   : ^^^^^^               ^^^
>x : { y: boolean; }
>  : ^^^^^       ^^^
>y : true
>  : ^^^^
}
else {
    o4.x;
>o4.x : { y: boolean; } | undefined
>     : ^^^^^       ^^^^^^^^^^^^^^^
>o4 : { x?: { y: boolean; }; }
>   : ^^^^^^               ^^^
>x : { y: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^

    o4.x?.y;
>o4.x?.y : boolean | undefined
>        : ^^^^^^^^^^^^^^^^^^^
>o4.x : { y: boolean; } | undefined
>     : ^^^^^       ^^^^^^^^^^^^^^^
>o4 : { x?: { y: boolean; }; }
>   : ^^^^^^               ^^^
>x : { y: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>y : boolean | undefined
>  : ^^^^^^^^^^^^^^^^^^^

    o4.x.y;
>o4.x.y : boolean
>       : ^^^^^^^
>o4.x : { y: boolean; } | undefined
>     : ^^^^^       ^^^^^^^^^^^^^^^
>o4 : { x?: { y: boolean; }; }
>   : ^^^^^^               ^^^
>x : { y: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>y : boolean
>  : ^^^^^^^
}
o4.x;
>o4.x : { y: boolean; } | undefined
>     : ^^^^^       ^^^^^^^^^^^^^^^
>o4 : { x?: { y: boolean; }; }
>   : ^^^^^^               ^^^
>x : { y: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^

o4.x?.y;
>o4.x?.y : boolean | undefined
>        : ^^^^^^^^^^^^^^^^^^^
>o4.x : { y: boolean; } | undefined
>     : ^^^^^       ^^^^^^^^^^^^^^^
>o4 : { x?: { y: boolean; }; }
>   : ^^^^^^               ^^^
>x : { y: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>y : boolean | undefined
>  : ^^^^^^^^^^^^^^^^^^^

o4.x.y;
>o4.x.y : boolean
>       : ^^^^^^^
>o4.x : { y: boolean; } | undefined
>     : ^^^^^       ^^^^^^^^^^^^^^^
>o4 : { x?: { y: boolean; }; }
>   : ^^^^^^               ^^^
>x : { y: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>y : boolean
>  : ^^^^^^^

declare const o5: { x?: { y: { z?: { w: boolean } } } };
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; }
>  : ^^^^^^               ^^^
>z : { w: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>w : boolean
>  : ^^^^^^^

if (o5.x?.y.z?.w) {
>o5.x?.y.z?.w : boolean | undefined
>             : ^^^^^^^^^^^^^^^^^^^
>o5.x?.y.z : { w: boolean; } | undefined
>          : ^^^^^       ^^^^^^^^^^^^^^^
>o5.x?.y : { z?: { w: boolean; }; } | undefined
>        : ^^^^^^               ^^^^^^^^^^^^^^^
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; } | undefined
>  : ^^^^^^               ^^^^^^^^^^^^^^^
>z : { w: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>w : boolean | undefined
>  : ^^^^^^^^^^^^^^^^^^^

    o5.x;
>o5.x : { y: { z?: { w: boolean; }; }; }
>     : ^^^^^                        ^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; }
>  : ^^^^^                        ^^^

    o5.x.y;
>o5.x.y : { z?: { w: boolean; }; }
>       : ^^^^^^               ^^^
>o5.x : { y: { z?: { w: boolean; }; }; }
>     : ^^^^^                        ^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; }
>  : ^^^^^                        ^^^
>y : { z?: { w: boolean; }; }
>  : ^^^^^^               ^^^

    o5.x.y.z;
>o5.x.y.z : { w: boolean; }
>         : ^^^^^       ^^^
>o5.x.y : { z?: { w: boolean; }; }
>       : ^^^^^^               ^^^
>o5.x : { y: { z?: { w: boolean; }; }; }
>     : ^^^^^                        ^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; }
>  : ^^^^^                        ^^^
>y : { z?: { w: boolean; }; }
>  : ^^^^^^               ^^^
>z : { w: boolean; }
>  : ^^^^^       ^^^

    o5.x.y.z.w; // true
>o5.x.y.z.w : true
>           : ^^^^
>o5.x.y.z : { w: boolean; }
>         : ^^^^^       ^^^
>o5.x.y : { z?: { w: boolean; }; }
>       : ^^^^^^               ^^^
>o5.x : { y: { z?: { w: boolean; }; }; }
>     : ^^^^^                        ^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; }
>  : ^^^^^                        ^^^
>y : { z?: { w: boolean; }; }
>  : ^^^^^^               ^^^
>z : { w: boolean; }
>  : ^^^^^       ^^^
>w : true
>  : ^^^^

    o5.x.y.z?.w; // true
>o5.x.y.z?.w : true
>            : ^^^^
>o5.x.y.z : { w: boolean; }
>         : ^^^^^       ^^^
>o5.x.y : { z?: { w: boolean; }; }
>       : ^^^^^^               ^^^
>o5.x : { y: { z?: { w: boolean; }; }; }
>     : ^^^^^                        ^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; }
>  : ^^^^^                        ^^^
>y : { z?: { w: boolean; }; }
>  : ^^^^^^               ^^^
>z : { w: boolean; }
>  : ^^^^^       ^^^
>w : true
>  : ^^^^

    o5.x?.y.z.w; // true
>o5.x?.y.z.w : true
>            : ^^^^
>o5.x?.y.z : { w: boolean; }
>          : ^^^^^       ^^^
>o5.x?.y : { z?: { w: boolean; }; }
>        : ^^^^^^               ^^^
>o5.x : { y: { z?: { w: boolean; }; }; }
>     : ^^^^^                        ^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; }
>  : ^^^^^                        ^^^
>y : { z?: { w: boolean; }; }
>  : ^^^^^^               ^^^
>z : { w: boolean; }
>  : ^^^^^       ^^^
>w : true
>  : ^^^^

    o5.x?.y.z?.w; // true
>o5.x?.y.z?.w : true
>             : ^^^^
>o5.x?.y.z : { w: boolean; }
>          : ^^^^^       ^^^
>o5.x?.y : { z?: { w: boolean; }; }
>        : ^^^^^^               ^^^
>o5.x : { y: { z?: { w: boolean; }; }; }
>     : ^^^^^                        ^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; }
>  : ^^^^^                        ^^^
>y : { z?: { w: boolean; }; }
>  : ^^^^^^               ^^^
>z : { w: boolean; }
>  : ^^^^^       ^^^
>w : true
>  : ^^^^
}
else {
    o5.x;
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^

    o5.x?.y;
>o5.x?.y : { z?: { w: boolean; }; } | undefined
>        : ^^^^^^               ^^^^^^^^^^^^^^^
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; } | undefined
>  : ^^^^^^               ^^^^^^^^^^^^^^^

    o5.x?.y.z;
>o5.x?.y.z : { w: boolean; } | undefined
>          : ^^^^^       ^^^^^^^^^^^^^^^
>o5.x?.y : { z?: { w: boolean; }; } | undefined
>        : ^^^^^^               ^^^^^^^^^^^^^^^
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; } | undefined
>  : ^^^^^^               ^^^^^^^^^^^^^^^
>z : { w: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^

    o5.x?.y.z?.w;
>o5.x?.y.z?.w : boolean | undefined
>             : ^^^^^^^^^^^^^^^^^^^
>o5.x?.y.z : { w: boolean; } | undefined
>          : ^^^^^       ^^^^^^^^^^^^^^^
>o5.x?.y : { z?: { w: boolean; }; } | undefined
>        : ^^^^^^               ^^^^^^^^^^^^^^^
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; } | undefined
>  : ^^^^^^               ^^^^^^^^^^^^^^^
>z : { w: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>w : boolean | undefined
>  : ^^^^^^^^^^^^^^^^^^^

    o5.x.y;
>o5.x.y : { z?: { w: boolean; }; }
>       : ^^^^^^               ^^^
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; }
>  : ^^^^^^               ^^^

    o5.x.y.z.w;
>o5.x.y.z.w : boolean
>           : ^^^^^^^
>o5.x.y.z : { w: boolean; } | undefined
>         : ^^^^^       ^^^^^^^^^^^^^^^
>o5.x.y : { z?: { w: boolean; }; }
>       : ^^^^^^               ^^^
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; }
>  : ^^^^^^               ^^^
>z : { w: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>w : boolean
>  : ^^^^^^^
}
o5.x;
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^

o5.x?.y;
>o5.x?.y : { z?: { w: boolean; }; } | undefined
>        : ^^^^^^               ^^^^^^^^^^^^^^^
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; } | undefined
>  : ^^^^^^               ^^^^^^^^^^^^^^^

o5.x?.y.z;
>o5.x?.y.z : { w: boolean; } | undefined
>          : ^^^^^       ^^^^^^^^^^^^^^^
>o5.x?.y : { z?: { w: boolean; }; } | undefined
>        : ^^^^^^               ^^^^^^^^^^^^^^^
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; } | undefined
>  : ^^^^^^               ^^^^^^^^^^^^^^^
>z : { w: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^

o5.x?.y.z?.w;
>o5.x?.y.z?.w : boolean | undefined
>             : ^^^^^^^^^^^^^^^^^^^
>o5.x?.y.z : { w: boolean; } | undefined
>          : ^^^^^       ^^^^^^^^^^^^^^^
>o5.x?.y : { z?: { w: boolean; }; } | undefined
>        : ^^^^^^               ^^^^^^^^^^^^^^^
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; } | undefined
>  : ^^^^^^               ^^^^^^^^^^^^^^^
>z : { w: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>w : boolean | undefined
>  : ^^^^^^^^^^^^^^^^^^^

o5.x.y;
>o5.x.y : { z?: { w: boolean; }; }
>       : ^^^^^^               ^^^
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; }
>  : ^^^^^^               ^^^

o5.x.y.z.w;
>o5.x.y.z.w : boolean
>           : ^^^^^^^
>o5.x.y.z : { w: boolean; } | undefined
>         : ^^^^^       ^^^^^^^^^^^^^^^
>o5.x.y : { z?: { w: boolean; }; }
>       : ^^^^^^               ^^^
>o5.x : { y: { z?: { w: boolean; }; }; } | undefined
>     : ^^^^^                        ^^^^^^^^^^^^^^^
>o5 : { x?: { y: { z?: { w: boolean; }; }; }; }
>   : ^^^^^^                                ^^^
>x : { y: { z?: { w: boolean; }; }; } | undefined
>  : ^^^^^                        ^^^^^^^^^^^^^^^
>y : { z?: { w: boolean; }; }
>  : ^^^^^^               ^^^
>z : { w: boolean; } | undefined
>  : ^^^^^       ^^^^^^^^^^^^^^^
>w : boolean
>  : ^^^^^^^

interface Base {
    f(): this is Derived;
>f : () => this is Derived
>  : ^^^^^^               
}

interface Derived extends Base {
    x: number;
>x : number
>  : ^^^^^^
}

declare const o6: Base | undefined;
>o6 : Base | undefined
>   : ^^^^^^^^^^^^^^^^

if (o6?.f()) {
>o6?.f() : boolean | undefined
>        : ^^^^^^^^^^^^^^^^^^^
>o6?.f : (() => this is Derived) | undefined
>      : ^^^^^^^               ^^^^^^^^^^^^^
>o6 : Base | undefined
>   : ^^^^^^^^^^^^^^^^
>f : (() => this is Derived) | undefined
>  : ^^^^^^^               ^^^^^^^^^^^^^

    o6; // Derived
>o6 : Derived
>   : ^^^^^^^

    o6.f;
>o6.f : () => this is Derived
>     : ^^^^^^               
>o6 : Derived
>   : ^^^^^^^
>f : () => this is Derived
>  : ^^^^^^               
}
else {
    o6;
>o6 : Base | undefined
>   : ^^^^^^^^^^^^^^^^

    o6?.f;
>o6?.f : (() => this is Derived) | undefined
>      : ^^^^^^^               ^^^^^^^^^^^^^
>o6 : Base | undefined
>   : ^^^^^^^^^^^^^^^^
>f : (() => this is Derived) | undefined
>  : ^^^^^^^               ^^^^^^^^^^^^^

    o6.f;
>o6.f : () => this is Derived
>     : ^^^^^^               
>o6 : Base | undefined
>   : ^^^^^^^^^^^^^^^^
>f : () => this is Derived
>  : ^^^^^^               
}
o6;
>o6 : Base | undefined
>   : ^^^^^^^^^^^^^^^^

o6?.f;
>o6?.f : (() => this is Derived) | undefined
>      : ^^^^^^^               ^^^^^^^^^^^^^
>o6 : Base | undefined
>   : ^^^^^^^^^^^^^^^^
>f : (() => this is Derived) | undefined
>  : ^^^^^^^               ^^^^^^^^^^^^^

o6.f;
>o6.f : () => this is Derived
>     : ^^^^^^               
>o6 : Base | undefined
>   : ^^^^^^^^^^^^^^^^
>f : () => this is Derived
>  : ^^^^^^               

// asserts
declare const isDefined: <T>(value: T) => asserts value is NonNullable<T>;
>isDefined : <T>(value: T) => asserts value is NonNullable<T>
>          : ^ ^^     ^^ ^^^^^                               
>value : T
>      : ^

declare const isString: (value: unknown) => asserts value is string;
>isString : (value: unknown) => asserts value is string
>         : ^     ^^       ^^^^^                       
>value : unknown
>      : ^^^^^^^

declare const maybeIsString: undefined | ((value: unknown) => asserts value is string);
>maybeIsString : ((value: unknown) => asserts value is string) | undefined
>              : ^^     ^^       ^^^^^                       ^^^^^^^^^^^^^
>value : unknown
>      : ^^^^^^^

declare const maybeNever: undefined | (() => never);
>maybeNever : (() => never) | undefined
>           : ^^^^^^^     ^^^^^^^^^^^^^

function f01(x: unknown) {
>f01 : (x: unknown) => void
>    : ^ ^^       ^^^^^^^^^
>x : unknown
>  : ^^^^^^^

    if (!!true) {
>!!true : true
>       : ^^^^
>!true : false
>      : ^^^^^
>true : true
>     : ^^^^

        isString?.(x);
>isString?.(x) : void
>              : ^^^^
>isString : (value: unknown) => asserts value is string
>         : ^     ^^       ^^^^^                       
>x : unknown
>  : ^^^^^^^

        x;
>x : string
>  : ^^^^^^
    }
    if (!!true) {
>!!true : true
>       : ^^^^
>!true : false
>      : ^^^^^
>true : true
>     : ^^^^

        maybeIsString?.(x);
>maybeIsString?.(x) : void | undefined
>                   : ^^^^^^^^^^^^^^^^
>maybeIsString : ((value: unknown) => asserts value is string) | undefined
>              : ^^     ^^       ^^^^^                       ^^^^^^^^^^^^^
>x : unknown
>  : ^^^^^^^

        x;
>x : unknown
>  : ^^^^^^^
    }
    if (!!true) {
>!!true : true
>       : ^^^^
>!true : false
>      : ^^^^^
>true : true
>     : ^^^^

        isDefined(maybeIsString);
>isDefined(maybeIsString) : void
>                         : ^^^^
>isDefined : <T>(value: T) => asserts value is NonNullable<T>
>          : ^ ^^     ^^ ^^^^^                               
>maybeIsString : ((value: unknown) => asserts value is string) | undefined
>              : ^^     ^^       ^^^^^                       ^^^^^^^^^^^^^

        maybeIsString?.(x);
>maybeIsString?.(x) : void
>                   : ^^^^
>maybeIsString : (value: unknown) => asserts value is string
>              : ^     ^^       ^^^^^                       
>x : unknown
>  : ^^^^^^^

        x;
>x : unknown
>  : ^^^^^^^
    }
    if (!!true) {
>!!true : true
>       : ^^^^
>!true : false
>      : ^^^^^
>true : true
>     : ^^^^

        maybeNever?.();
>maybeNever?.() : undefined
>               : ^^^^^^^^^
>maybeNever : (() => never) | undefined
>           : ^^^^^^^     ^^^^^^^^^^^^^

        x;
>x : unknown
>  : ^^^^^^^
    }
}

type Thing = { foo: string | number, bar(): number, baz: object };
>Thing : Thing
>      : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
>bar : () => number
>    : ^^^^^^      
>baz : object
>    : ^^^^^^

function f10(o: Thing | undefined, value: number) {
>f10 : (o: Thing | undefined, value: number) => void
>    : ^ ^^                 ^^     ^^      ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

    if (o?.foo === value) {
>o?.foo === value : boolean
>                 : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
    if (o?.["foo"] === value) {
>o?.["foo"] === value : boolean
>                     : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>value : number
>      : ^^^^^^

        o["foo"];
>o["foo"] : number
>         : ^^^^^^
>o : Thing
>  : ^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() === value) {
>o?.bar() === value : boolean
>                   : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.bar;
>o.bar : () => number
>      : ^^^^^^      
>o : Thing
>  : ^^^^^
>bar : () => number
>    : ^^^^^^      
    }
    if (o?.foo == value) {
>o?.foo == value : boolean
>                : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.["foo"] == value) {
>o?.["foo"] == value : boolean
>                    : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>value : number
>      : ^^^^^^

        o["foo"];
>o["foo"] : string | number
>         : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() == value) {
>o?.bar() == value : boolean
>                  : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.bar;
>o.bar : () => number
>      : ^^^^^^      
>o : Thing
>  : ^^^^^
>bar : () => number
>    : ^^^^^^      
    }
}

function f11(o: Thing | null, value: number) {
>f11 : (o: Thing | null, value: number) => void
>    : ^ ^^            ^^     ^^      ^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>value : number
>      : ^^^^^^

    if (o?.foo === value) {
>o?.foo === value : boolean
>                 : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
    if (o?.["foo"] === value) {
>o?.["foo"] === value : boolean
>                     : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>value : number
>      : ^^^^^^

        o["foo"];
>o["foo"] : number
>         : ^^^^^^
>o : Thing
>  : ^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() === value) {
>o?.bar() === value : boolean
>                   : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.bar;
>o.bar : () => number
>      : ^^^^^^      
>o : Thing
>  : ^^^^^
>bar : () => number
>    : ^^^^^^      
    }
    if (o?.foo == value) {
>o?.foo == value : boolean
>                : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.["foo"] == value) {
>o?.["foo"] == value : boolean
>                    : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>value : number
>      : ^^^^^^

        o["foo"];
>o["foo"] : string | number
>         : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() == value) {
>o?.bar() == value : boolean
>                  : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.bar;
>o.bar : () => number
>      : ^^^^^^      
>o : Thing
>  : ^^^^^
>bar : () => number
>    : ^^^^^^      
    }
}

function f12(o: Thing | undefined, value: number | undefined) {
>f12 : (o: Thing | undefined, value: number | undefined) => void
>    : ^ ^^                 ^^     ^^                  ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>value : number | undefined
>      : ^^^^^^^^^^^^^^^^^^

    if (o?.foo === value) {
>o?.foo === value : boolean
>                 : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number | undefined
>      : ^^^^^^^^^^^^^^^^^^

        o.foo;  // Error
>o.foo : number
>      : ^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : number
>    : ^^^^^^
    }
    if (o?.["foo"] === value) {
>o?.["foo"] === value : boolean
>                     : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>value : number | undefined
>      : ^^^^^^^^^^^^^^^^^^

        o["foo"];  // Error
>o["foo"] : number
>         : ^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() === value) {
>o?.bar() === value : boolean
>                   : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>value : number | undefined
>      : ^^^^^^^^^^^^^^^^^^

        o.bar;  // Error
>o.bar : () => number
>      : ^^^^^^      
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : () => number
>    : ^^^^^^      
    }
    if (o?.foo == value) {
>o?.foo == value : boolean
>                : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number | undefined
>      : ^^^^^^^^^^^^^^^^^^

        o.foo;  // Error
>o.foo : number
>      : ^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : number
>    : ^^^^^^
    }
    if (o?.["foo"] == value) {
>o?.["foo"] == value : boolean
>                    : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>value : number | undefined
>      : ^^^^^^^^^^^^^^^^^^

        o["foo"];  // Error
>o["foo"] : number
>         : ^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() == value) {
>o?.bar() == value : boolean
>                  : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>value : number | undefined
>      : ^^^^^^^^^^^^^^^^^^

        o.bar;  // Error
>o.bar : () => number
>      : ^^^^^^      
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : () => number
>    : ^^^^^^      
    }
}

function f12a(o: Thing | undefined, value: number | null) {
>f12a : (o: Thing | undefined, value: number | null) => void
>     : ^ ^^                 ^^     ^^             ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>value : number | null
>      : ^^^^^^^^^^^^^

    if (o?.foo === value) {
>o?.foo === value : boolean
>                 : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number | null
>      : ^^^^^^^^^^^^^

        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
    if (o?.["foo"] === value) {
>o?.["foo"] === value : boolean
>                     : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>value : number | null
>      : ^^^^^^^^^^^^^

        o["foo"];
>o["foo"] : number
>         : ^^^^^^
>o : Thing
>  : ^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() === value) {
>o?.bar() === value : boolean
>                   : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>value : number | null
>      : ^^^^^^^^^^^^^

        o.bar;
>o.bar : () => number
>      : ^^^^^^      
>o : Thing
>  : ^^^^^
>bar : () => number
>    : ^^^^^^      
    }
    if (o?.foo == value) {
>o?.foo == value : boolean
>                : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number | null
>      : ^^^^^^^^^^^^^

        o.foo;  // Error
>o.foo : number
>      : ^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : number
>    : ^^^^^^
    }
    if (o?.["foo"] == value) {
>o?.["foo"] == value : boolean
>                    : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>value : number | null
>      : ^^^^^^^^^^^^^

        o["foo"];  // Error
>o["foo"] : number
>         : ^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() == value) {
>o?.bar() == value : boolean
>                  : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>value : number | null
>      : ^^^^^^^^^^^^^

        o.bar;  // Error
>o.bar : () => number
>      : ^^^^^^      
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : () => number
>    : ^^^^^^      
    }
}

function f13(o: Thing | undefined) {
>f13 : (o: Thing | undefined) => void
>    : ^ ^^                 ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^

    if (o?.foo !== undefined) {
>o?.foo !== undefined : boolean
>                     : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.["foo"] !== undefined) {
>o?.["foo"] !== undefined : boolean
>                         : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o["foo"];
>o["foo"] : string | number
>         : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() !== undefined) {
>o?.bar() !== undefined : boolean
>                       : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o.bar;
>o.bar : () => number
>      : ^^^^^^      
>o : Thing
>  : ^^^^^
>bar : () => number
>    : ^^^^^^      
    }
    if (o?.foo != undefined) {
>o?.foo != undefined : boolean
>                    : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.["foo"] != undefined) {
>o?.["foo"] != undefined : boolean
>                        : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o["foo"];
>o["foo"] : string | number
>         : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() != undefined) {
>o?.bar() != undefined : boolean
>                      : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o.bar;
>o.bar : () => number
>      : ^^^^^^      
>o : Thing
>  : ^^^^^
>bar : () => number
>    : ^^^^^^      
    }
}

function f13a(o: Thing | undefined) {
>f13a : (o: Thing | undefined) => void
>     : ^ ^^                 ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^

    if (o?.foo !== null) {
>o?.foo !== null : boolean
>                : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^

        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.["foo"] !== null) {
>o?.["foo"] !== null : boolean
>                    : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^

        o["foo"];  // Error
>o["foo"] : string | number
>         : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() !== null) {
>o?.bar() !== null : boolean
>                  : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^

        o.bar;  // Error
>o.bar : () => number
>      : ^^^^^^      
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : () => number
>    : ^^^^^^      
    }
    if (o?.foo != null) {
>o?.foo != null : boolean
>               : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.["foo"] != null) {
>o?.["foo"] != null : boolean
>                   : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^

        o["foo"];
>o["foo"] : string | number
>         : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() != null) {
>o?.bar() != null : boolean
>                 : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^

        o.bar;
>o.bar : () => number
>      : ^^^^^^      
>o : Thing
>  : ^^^^^
>bar : () => number
>    : ^^^^^^      
    }
}

function f14(o: Thing | null) {
>f14 : (o: Thing | null) => void
>    : ^ ^^            ^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^

    if (o?.foo !== undefined) {
>o?.foo !== undefined : boolean
>                     : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.["foo"] !== undefined) {
>o?.["foo"] !== undefined : boolean
>                         : ^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o["foo"];
>o["foo"] : string | number
>         : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (o?.bar() !== undefined) {
>o?.bar() !== undefined : boolean
>                       : ^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o.bar;
>o.bar : () => number
>      : ^^^^^^      
>o : Thing
>  : ^^^^^
>bar : () => number
>    : ^^^^^^      
    }
}

function f15(o: Thing | undefined, value: number) {
>f15 : (o: Thing | undefined, value: number) => void
>    : ^ ^^                 ^^     ^^      ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

    if (o?.foo === value) {
>o?.foo === value : boolean
>                 : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.foo !== value) {
>o?.foo !== value : boolean
>                 : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    else {
        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
    if (o?.foo == value) {
>o?.foo == value : boolean
>                : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.foo != value) {
>o?.foo != value : boolean
>                : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : number
>      : ^^^^^^

        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    else {
        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
}

function f15a(o: Thing | undefined, value: unknown) {
>f15a : (o: Thing | undefined, value: unknown) => void
>     : ^ ^^                 ^^     ^^       ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>value : unknown
>      : ^^^^^^^

    if (o?.foo === value) {
>o?.foo === value : boolean
>                 : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : unknown
>      : ^^^^^^^

        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.foo !== value) {
>o?.foo !== value : boolean
>                 : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : unknown
>      : ^^^^^^^

        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.foo == value) {
>o?.foo == value : boolean
>                : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : unknown
>      : ^^^^^^^

        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.foo != value) {
>o?.foo != value : boolean
>                : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>value : unknown
>      : ^^^^^^^

        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
}

function f16(o: Thing | undefined) {
>f16 : (o: Thing | undefined) => void
>    : ^ ^^                 ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^

    if (o?.foo === undefined) {
>o?.foo === undefined : boolean
>                     : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o.foo;  // Error
>o.foo : never
>      : ^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : never
>    : ^^^^^
    }
    else {
        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.foo !== undefined) {
>o?.foo !== undefined : boolean
>                     : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : never
>      : ^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : never
>    : ^^^^^
    }
    if (o?.foo == undefined) {
>o?.foo == undefined : boolean
>                    : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o.foo;  // Error
>o.foo : never
>      : ^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : never
>    : ^^^^^
    }
    else {
        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (o?.foo != undefined) {
>o?.foo != undefined : boolean
>                    : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>undefined : undefined
>          : ^^^^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : never
>      : ^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : never
>    : ^^^^^
    }
}

function f20(o: Thing | undefined) {
>f20 : (o: Thing | undefined) => void
>    : ^ ^^                 ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^

    if (typeof o?.foo === "number") {
>typeof o?.foo === "number" : boolean
>                           : ^^^^^^^
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"number" : "number"
>         : ^^^^^^^^

        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
    if (typeof o?.["foo"] === "number") {
>typeof o?.["foo"] === "number" : boolean
>                               : ^^^^^^^
>typeof o?.["foo"] : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>"number" : "number"
>         : ^^^^^^^^

        o["foo"];
>o["foo"] : number
>         : ^^^^^^
>o : Thing
>  : ^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (typeof o?.bar() === "number") {
>typeof o?.bar() === "number" : boolean
>                             : ^^^^^^^
>typeof o?.bar() : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>"number" : "number"
>         : ^^^^^^^^

        o.bar;
>o.bar : () => number
>      : ^^^^^^      
>o : Thing
>  : ^^^^^
>bar : () => number
>    : ^^^^^^      
    }
    if (o?.baz instanceof Error) {
>o?.baz instanceof Error : boolean
>                        : ^^^^^^^
>o?.baz : object | undefined
>       : ^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>baz : object | undefined
>    : ^^^^^^^^^^^^^^^^^^
>Error : ErrorConstructor
>      : ^^^^^^^^^^^^^^^^

        o.baz;
>o.baz : Error
>      : ^^^^^
>o : Thing
>  : ^^^^^
>baz : Error
>    : ^^^^^
    }
}

function f21(o: Thing | null) {
>f21 : (o: Thing | null) => void
>    : ^ ^^            ^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^

    if (typeof o?.foo === "number") {
>typeof o?.foo === "number" : boolean
>                           : ^^^^^^^
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"number" : "number"
>         : ^^^^^^^^

        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
    if (typeof o?.["foo"] === "number") {
>typeof o?.["foo"] === "number" : boolean
>                               : ^^^^^^^
>typeof o?.["foo"] : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.["foo"] : string | number | undefined
>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>"foo" : "foo"
>      : ^^^^^
>"number" : "number"
>         : ^^^^^^^^

        o["foo"];
>o["foo"] : number
>         : ^^^^^^
>o : Thing
>  : ^^^^^
>"foo" : "foo"
>      : ^^^^^
    }
    if (typeof o?.bar() === "number") {
>typeof o?.bar() === "number" : boolean
>                             : ^^^^^^^
>typeof o?.bar() : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.bar() : number | undefined
>         : ^^^^^^^^^^^^^^^^^^
>o?.bar : (() => number) | undefined
>       : ^^^^^^^      ^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>bar : (() => number) | undefined
>    : ^^^^^^^      ^^^^^^^^^^^^^
>"number" : "number"
>         : ^^^^^^^^

        o.bar;
>o.bar : () => number
>      : ^^^^^^      
>o : Thing
>  : ^^^^^
>bar : () => number
>    : ^^^^^^      
    }
    if (o?.baz instanceof Error) {
>o?.baz instanceof Error : boolean
>                        : ^^^^^^^
>o?.baz : object | undefined
>       : ^^^^^^^^^^^^^^^^^^
>o : Thing | null
>  : ^^^^^^^^^^^^
>baz : object | undefined
>    : ^^^^^^^^^^^^^^^^^^
>Error : ErrorConstructor
>      : ^^^^^^^^^^^^^^^^

        o.baz;
>o.baz : Error
>      : ^^^^^
>o : Thing
>  : ^^^^^
>baz : Error
>    : ^^^^^
    }
}

function f22(o: Thing | undefined) {
>f22 : (o: Thing | undefined) => void
>    : ^ ^^                 ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^

    if (typeof o?.foo === "number") {
>typeof o?.foo === "number" : boolean
>                           : ^^^^^^^
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"number" : "number"
>         : ^^^^^^^^

        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : string
>      : ^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string
>    : ^^^^^^
    }
    if (typeof o?.foo !== "number") {
>typeof o?.foo !== "number" : boolean
>                           : ^^^^^^^
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"number" : "number"
>         : ^^^^^^^^

        o.foo;  // Error
>o.foo : string
>      : ^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string
>    : ^^^^^^
    }
    else {
        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
    if (typeof o?.foo == "number") {
>typeof o?.foo == "number" : boolean
>                          : ^^^^^^^
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"number" : "number"
>         : ^^^^^^^^

        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : string
>      : ^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string
>    : ^^^^^^
    }
    if (typeof o?.foo != "number") {
>typeof o?.foo != "number" : boolean
>                          : ^^^^^^^
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"number" : "number"
>         : ^^^^^^^^

        o.foo;  // Error
>o.foo : string
>      : ^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string
>    : ^^^^^^
    }
    else {
        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
}

function f23(o: Thing | undefined) {
>f23 : (o: Thing | undefined) => void
>    : ^ ^^                 ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^

    if (typeof o?.foo === "undefined") {
>typeof o?.foo === "undefined" : boolean
>                              : ^^^^^^^
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"undefined" : "undefined"
>            : ^^^^^^^^^^^

        o.foo;  // Error
>o.foo : never
>      : ^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : never
>    : ^^^^^
    }
    else {
        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (typeof o?.foo !== "undefined") {
>typeof o?.foo !== "undefined" : boolean
>                              : ^^^^^^^
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"undefined" : "undefined"
>            : ^^^^^^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : never
>      : ^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : never
>    : ^^^^^
    }
    if (typeof o?.foo == "undefined") {
>typeof o?.foo == "undefined" : boolean
>                             : ^^^^^^^
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"undefined" : "undefined"
>            : ^^^^^^^^^^^

        o.foo;  // Error
>o.foo : never
>      : ^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : never
>    : ^^^^^
    }
    else {
        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (typeof o?.foo != "undefined") {
>typeof o?.foo != "undefined" : boolean
>                             : ^^^^^^^
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"undefined" : "undefined"
>            : ^^^^^^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    else {
        o.foo;  // Error
>o.foo : never
>      : ^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : never
>    : ^^^^^
    }
}

declare function assert(x: unknown): asserts x;
>assert : (x: unknown) => asserts x
>       : ^ ^^       ^^^^^         
>x : unknown
>  : ^^^^^^^

declare function assertNonNull<T>(x: T): asserts x is NonNullable<T>;
>assertNonNull : <T>(x: T) => asserts x is NonNullable<T>
>              : ^ ^^ ^^ ^^^^^                           
>x : T
>  : ^

function f30(o: Thing | undefined) {
>f30 : (o: Thing | undefined) => void
>    : ^ ^^                 ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^

    if (!!true) {
>!!true : true
>       : ^^^^
>!true : false
>      : ^^^^^
>true : true
>     : ^^^^

        assert(o?.foo);
>assert(o?.foo) : void
>               : ^^^^
>assert : (x: unknown) => asserts x
>       : ^ ^^       ^^^^^         
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
    if (!!true) {
>!!true : true
>       : ^^^^
>!true : false
>      : ^^^^^
>true : true
>     : ^^^^

        assert(o?.foo === 42);
>assert(o?.foo === 42) : void
>                      : ^^^^
>assert : (x: unknown) => asserts x
>       : ^ ^^       ^^^^^         
>o?.foo === 42 : boolean
>              : ^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>42 : 42
>   : ^^

        o.foo;
>o.foo : 42
>      : ^^
>o : Thing
>  : ^^^^^
>foo : 42
>    : ^^
    }
    if (!!true) {
>!!true : true
>       : ^^^^
>!true : false
>      : ^^^^^
>true : true
>     : ^^^^

        assert(typeof o?.foo === "number");
>assert(typeof o?.foo === "number") : void
>                                   : ^^^^
>assert : (x: unknown) => asserts x
>       : ^ ^^       ^^^^^         
>typeof o?.foo === "number" : boolean
>                           : ^^^^^^^
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"number" : "number"
>         : ^^^^^^^^

        o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^
    }
    if (!!true) {
>!!true : true
>       : ^^^^
>!true : false
>      : ^^^^^
>true : true
>     : ^^^^

        assertNonNull(o?.foo);
>assertNonNull(o?.foo) : void
>                      : ^^^^
>assertNonNull : <T>(x: T) => asserts x is NonNullable<T>
>              : ^ ^^ ^^ ^^^^^                           
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^

        o.foo;
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing
>  : ^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^
    }
}

function f40(o: Thing | undefined) {
>f40 : (o: Thing | undefined) => void
>    : ^ ^^                 ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^

    switch (o?.foo) {
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^

        case "abc":
>"abc" : "abc"
>      : ^^^^^

            o.foo;
>o.foo : "abc"
>      : ^^^^^
>o : Thing
>  : ^^^^^
>foo : "abc"
>    : ^^^^^

            break;
        case 42:
>42 : 42
>   : ^^

            o.foo;
>o.foo : 42
>      : ^^
>o : Thing
>  : ^^^^^
>foo : 42
>    : ^^

            break;
        case undefined:
>undefined : undefined
>          : ^^^^^^^^^

            o.foo;  // Error
>o.foo : never
>      : ^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : never
>    : ^^^^^

            break;
        default:
            o.foo;  // Error
>o.foo : string | number
>      : ^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number
>    : ^^^^^^^^^^^^^^^

            break;
    }
}

function f41(o: Thing | undefined) {
>f41 : (o: Thing | undefined) => void
>    : ^ ^^                 ^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^

    switch (typeof o?.foo) {
>typeof o?.foo : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o?.foo : string | number | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : string | number | undefined
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^

        case "string":
>"string" : "string"
>         : ^^^^^^^^

            o.foo;
>o.foo : string
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : string
>    : ^^^^^^

            break;
        case "number":
>"number" : "number"
>         : ^^^^^^^^

            o.foo;
>o.foo : number
>      : ^^^^^^
>o : Thing
>  : ^^^^^
>foo : number
>    : ^^^^^^

            break;
        case "undefined":
>"undefined" : "undefined"
>            : ^^^^^^^^^^^

            o.foo;  // Error
>o.foo : never
>      : ^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : never
>    : ^^^^^

            break;
        default:
            o.foo;  // Error
>o.foo : never
>      : ^^^^^
>o : Thing | undefined
>  : ^^^^^^^^^^^^^^^^^
>foo : never
>    : ^^^^^

            break;
    }
}

// Repros from #34570

type Shape =
>Shape : Shape
>      : ^^^^^

    | { type: 'rectangle', width: number, height: number }
>type : "rectangle"
>     : ^^^^^^^^^^^
>width : number
>      : ^^^^^^
>height : number
>       : ^^^^^^

    | { type: 'circle', radius: number }
>type : "circle"
>     : ^^^^^^^^
>radius : number
>       : ^^^^^^

function getArea(shape?: Shape) {
>getArea : (shape?: Shape) => number
>        : ^     ^^^     ^^^^^^^^^^^
>shape : Shape | undefined
>      : ^^^^^^^^^^^^^^^^^

    switch (shape?.type) {
>shape?.type : "rectangle" | "circle" | undefined
>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>shape : Shape | undefined
>      : ^^^^^^^^^^^^^^^^^
>type : "rectangle" | "circle" | undefined
>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

        case 'circle':
>'circle' : "circle"
>         : ^^^^^^^^

            return Math.PI * shape.radius ** 2
>Math.PI * shape.radius ** 2 : number
>                            : ^^^^^^
>Math.PI : number
>        : ^^^^^^
>Math : Math
>     : ^^^^
>PI : number
>   : ^^^^^^
>shape.radius ** 2 : number
>                  : ^^^^^^
>shape.radius : number
>             : ^^^^^^
>shape : { type: "circle"; radius: number; }
>      : ^^^^^^^^        ^^^^^^^^^^      ^^^
>radius : number
>       : ^^^^^^
>2 : 2
>  : ^

        case 'rectangle':
>'rectangle' : "rectangle"
>            : ^^^^^^^^^^^

            return shape.width * shape.height
>shape.width * shape.height : number
>                           : ^^^^^^
>shape.width : number
>            : ^^^^^^
>shape : { type: "rectangle"; width: number; height: number; }
>      : ^^^^^^^^           ^^^^^^^^^      ^^^^^^^^^^      ^^^
>width : number
>      : ^^^^^^
>shape.height : number
>             : ^^^^^^
>shape : { type: "rectangle"; width: number; height: number; }
>      : ^^^^^^^^           ^^^^^^^^^      ^^^^^^^^^^      ^^^
>height : number
>       : ^^^^^^

        default:
            return 0
>0 : 0
>  : ^
    }
}

type Feature = {
>Feature : Feature
>        : ^^^^^^^

  id: string;
>id : string
>   : ^^^^^^

  geometry?: {
>geometry : { type: string; coordinates: number[]; } | undefined
>         : ^^^^^^^^      ^^^^^^^^^^^^^^^        ^^^^^^^^^^^^^^^

    type: string;
>type : string
>     : ^^^^^^

    coordinates: number[];
>coordinates : number[]
>            : ^^^^^^^^

  };
};


function extractCoordinates(f: Feature): number[] {
>extractCoordinates : (f: Feature) => number[]
>                   : ^ ^^       ^^^^^        
>f : Feature
>  : ^^^^^^^

    if (f.geometry?.type !== 'test') {
>f.geometry?.type !== 'test' : boolean
>                            : ^^^^^^^
>f.geometry?.type : string | undefined
>                 : ^^^^^^^^^^^^^^^^^^
>f.geometry : { type: string; coordinates: number[]; } | undefined
>           : ^^^^^^^^      ^^^^^^^^^^^^^^^        ^^^^^^^^^^^^^^^
>f : Feature
>  : ^^^^^^^
>geometry : { type: string; coordinates: number[]; } | undefined
>         : ^^^^^^^^      ^^^^^^^^^^^^^^^        ^^^^^^^^^^^^^^^
>type : string | undefined
>     : ^^^^^^^^^^^^^^^^^^
>'test' : "test"
>       : ^^^^^^

        return [];
>[] : never[]
>   : ^^^^^^^
    }
    return f.geometry.coordinates;
>f.geometry.coordinates : number[]
>                       : ^^^^^^^^
>f.geometry : { type: string; coordinates: number[]; }
>           : ^^^^^^^^      ^^^^^^^^^^^^^^^        ^^^
>f : Feature
>  : ^^^^^^^
>geometry : { type: string; coordinates: number[]; }
>         : ^^^^^^^^      ^^^^^^^^^^^^^^^        ^^^
>coordinates : number[]
>            : ^^^^^^^^
}

// Repro from #35842

interface SomeObject {
    someProperty: unknown;
>someProperty : unknown
>             : ^^^^^^^
}

let lastSomeProperty: unknown | undefined;
>lastSomeProperty : unknown
>                 : ^^^^^^^

function someFunction(someOptionalObject: SomeObject | undefined): void {
>someFunction : (someOptionalObject: SomeObject | undefined) => void
>             : ^                  ^^                      ^^^^^    
>someOptionalObject : SomeObject | undefined
>                   : ^^^^^^^^^^^^^^^^^^^^^^

    if (someOptionalObject?.someProperty !== lastSomeProperty) {
>someOptionalObject?.someProperty !== lastSomeProperty : boolean
>                                                      : ^^^^^^^
>someOptionalObject?.someProperty : unknown
>                                 : ^^^^^^^
>someOptionalObject : SomeObject | undefined
>                   : ^^^^^^^^^^^^^^^^^^^^^^
>someProperty : unknown
>             : ^^^^^^^
>lastSomeProperty : unknown
>                 : ^^^^^^^

        console.log(someOptionalObject);
>console.log(someOptionalObject) : void
>                                : ^^^^
>console.log : (...data: any[]) => void
>            : ^^^^    ^^     ^^^^^    
>console : Console
>        : ^^^^^^^
>log : (...data: any[]) => void
>    : ^^^^    ^^     ^^^^^    
>someOptionalObject : SomeObject | undefined
>                   : ^^^^^^^^^^^^^^^^^^^^^^

        console.log(someOptionalObject.someProperty);  // Error
>console.log(someOptionalObject.someProperty) : void
>                                             : ^^^^
>console.log : (...data: any[]) => void
>            : ^^^^    ^^     ^^^^^    
>console : Console
>        : ^^^^^^^
>log : (...data: any[]) => void
>    : ^^^^    ^^     ^^^^^    
>someOptionalObject.someProperty : unknown
>                                : ^^^^^^^
>someOptionalObject : SomeObject | undefined
>                   : ^^^^^^^^^^^^^^^^^^^^^^
>someProperty : unknown
>             : ^^^^^^^

        lastSomeProperty = someOptionalObject?.someProperty;
>lastSomeProperty = someOptionalObject?.someProperty : unknown
>                                                    : ^^^^^^^
>lastSomeProperty : unknown
>                 : ^^^^^^^
>someOptionalObject?.someProperty : unknown
>                                 : ^^^^^^^
>someOptionalObject : SomeObject | undefined
>                   : ^^^^^^^^^^^^^^^^^^^^^^
>someProperty : unknown
>             : ^^^^^^^
    }
}

const someObject: SomeObject = {
>someObject : SomeObject
>           : ^^^^^^^^^^
>{    someProperty: 42} : { someProperty: number; }
>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^

    someProperty: 42
>someProperty : number
>             : ^^^^^^
>42 : 42
>   : ^^

};

someFunction(someObject);
>someFunction(someObject) : void
>                         : ^^^^
>someFunction : (someOptionalObject: SomeObject | undefined) => void
>             : ^                  ^^                      ^^^^^    
>someObject : SomeObject
>           : ^^^^^^^^^^

someFunction(undefined);
>someFunction(undefined) : void
>                        : ^^^^
>someFunction : (someOptionalObject: SomeObject | undefined) => void
>             : ^                  ^^                      ^^^^^    
>undefined : undefined
>          : ^^^^^^^^^

// Repro from #35970

let i = 0;
>i : number
>  : ^^^^^^
>0 : 0
>  : ^

declare const arr: { tag: ("left" | "right") }[];
>arr : { tag: ("left" | "right"); }[]
>    : ^^^^^^^                  ^^^^^
>tag : "left" | "right"
>    : ^^^^^^^^^^^^^^^^

while (arr[i]?.tag === "left") {
>arr[i]?.tag === "left" : boolean
>                       : ^^^^^^^
>arr[i]?.tag : "left" | "right"
>            : ^^^^^^^^^^^^^^^^
>arr[i] : { tag: ("left" | "right"); }
>       : ^^^^^^^                  ^^^
>arr : { tag: ("left" | "right"); }[]
>    : ^^^^^^^                  ^^^^^
>i : number
>  : ^^^^^^
>tag : "left" | "right"
>    : ^^^^^^^^^^^^^^^^
>"left" : "left"
>       : ^^^^^^

    i += 1;
>i += 1 : number
>       : ^^^^^^
>i : number
>  : ^^^^^^
>1 : 1
>  : ^

    if (arr[i]?.tag === "right") {
>arr[i]?.tag === "right" : boolean
>                        : ^^^^^^^
>arr[i]?.tag : "left" | "right"
>            : ^^^^^^^^^^^^^^^^
>arr[i] : { tag: ("left" | "right"); }
>       : ^^^^^^^                  ^^^
>arr : { tag: ("left" | "right"); }[]
>    : ^^^^^^^                  ^^^^^
>i : number
>  : ^^^^^^
>tag : "left" | "right"
>    : ^^^^^^^^^^^^^^^^
>"right" : "right"
>        : ^^^^^^^

        console.log("I should ALSO be reachable");
>console.log("I should ALSO be reachable") : void
>                                          : ^^^^
>console.log : (...data: any[]) => void
>            : ^^^^    ^^     ^^^^^    
>console : Console
>        : ^^^^^^^
>log : (...data: any[]) => void
>    : ^^^^    ^^     ^^^^^    
>"I should ALSO be reachable" : "I should ALSO be reachable"
>                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    }
}


// Repro from #51941

type Test5 = {
>Test5 : Test5
>      : ^^^^^

  main?: {
>main : { childs: Record<string, Test5>; } | undefined
>     : ^^^^^^^^^^                     ^^^^^^^^^^^^^^^

    childs: Record<string, Test5>;
>childs : Record<string, Test5>
>       : ^^^^^^^^^^^^^^^^^^^^^

  };
};

function f50(obj: Test5) {
>f50 : (obj: Test5) => Test5 | null
>    : ^   ^^     ^^^^^^^^^^^^^^^^^
>obj : Test5
>    : ^^^^^

   for (const key in obj.main?.childs) {
>key : string
>    : ^^^^^^
>obj.main?.childs : Record<string, Test5> | undefined
>                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>obj.main : { childs: Record<string, Test5>; } | undefined
>         : ^^^^^^^^^^                     ^^^^^^^^^^^^^^^
>obj : Test5
>    : ^^^^^
>main : { childs: Record<string, Test5>; } | undefined
>     : ^^^^^^^^^^                     ^^^^^^^^^^^^^^^
>childs : Record<string, Test5> | undefined
>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

      if (obj.main.childs[key] === obj) {
>obj.main.childs[key] === obj : boolean
>                             : ^^^^^^^
>obj.main.childs[key] : Test5
>                     : ^^^^^
>obj.main.childs : Record<string, Test5>
>                : ^^^^^^^^^^^^^^^^^^^^^
>obj.main : { childs: Record<string, Test5>; }
>         : ^^^^^^^^^^                     ^^^
>obj : Test5
>    : ^^^^^
>main : { childs: Record<string, Test5>; }
>     : ^^^^^^^^^^                     ^^^
>childs : Record<string, Test5>
>       : ^^^^^^^^^^^^^^^^^^^^^
>key : string
>    : ^^^^^^
>obj : Test5
>    : ^^^^^

        return obj;
>obj : Test5
>    : ^^^^^
      }
   }
   return null;
}