controlFlowGenericTypes.types

=== tests/cases/conformance/controlFlow/controlFlowGenericTypes.ts ===
function f1<T extends string | undefined>(x: T, y: { a: T }, z: [T]): string {
>f1 : <T extends string | undefined>(x: T, y: {    a: T;}, z: [T]) => string
>x : T
>y : { a: T; }
>a : T
>z : [T]

    if (x) {
>x : T

        x;
>x : T

        x.length;
>x.length : number
>x : string
>length : number

        return x;
>x : string
    }
    if (y.a) {
>y.a : T
>y : { a: T; }
>a : T

        y.a.length;
>y.a.length : number
>y.a : string
>y : { a: T; }
>a : string
>length : number

        return y.a;
>y.a : string
>y : { a: T; }
>a : string
    }
    if (z[0]) {
>z[0] : T
>z : [T]
>0 : 0

        z[0].length;
>z[0].length : number
>z[0] : string
>z : [T]
>0 : 0
>length : number

        return z[0];
>z[0] : string
>z : [T]
>0 : 0
    }
    return "hello";
>"hello" : "hello"
}

function f2<T>(x: Extract<T, string | undefined> | null): string {
>f2 : <T>(x: Extract<T, string | undefined> | null) => string
>x : Extract<T, string | undefined> | null
>null : null

    if (x) {
>x : Extract<T, string | undefined> | null

        x;
>x : Extract<T, string | undefined>

        x.length;
>x.length : number
>x : string
>length : number

        return x;
>x : string
    }
    return "hello";
>"hello" : "hello"
}

interface Box<T> {
    item: T;
>item : T
}

declare function isBox(x: any): x is Box<unknown>;
>isBox : (x: any) => x is Box<unknown>
>x : any

declare function isUndefined(x: unknown): x is undefined;
>isUndefined : (x: unknown) => x is undefined
>x : unknown

declare function unbox<T>(x: Box<T>): T;
>unbox : <T>(x: Box<T>) => T
>x : Box<T>

function g1<T extends Box<T> | undefined>(x: T) {
>g1 : <T extends Box<T> | undefined>(x: T) => void
>x : T

    if (isBox(x)) {
>isBox(x) : boolean
>isBox : (x: any) => x is Box<unknown>
>x : Box<T> | undefined

        unbox(x);
>unbox(x) : T
>unbox : <T>(x: Box<T>) => T
>x : Box<T>
    }
}

function g2<T extends Box<T> | undefined>(x: T) {
>g2 : <T extends Box<T> | undefined>(x: T) => void
>x : T

    if (!isUndefined(x)) {
>!isUndefined(x) : boolean
>isUndefined(x) : boolean
>isUndefined : (x: unknown) => x is undefined
>x : Box<T> | undefined

        unbox(x);
>unbox(x) : T
>unbox : <T>(x: Box<T>) => T
>x : Box<T>
    }
}

function g3<T extends Box<T> | undefined>(x: T) {
>g3 : <T extends Box<T> | undefined>(x: T) => void
>x : T

    if (!isBox(x)) {
>!isBox(x) : boolean
>isBox(x) : boolean
>isBox : (x: any) => x is Box<unknown>
>x : Box<T> | undefined

        unbox(x);  // Error
>unbox(x) : T
>unbox : <T>(x: Box<T>) => T
>x : undefined
    }
}

function g4<T extends Box<T> | undefined>(x: T) {
>g4 : <T extends Box<T> | undefined>(x: T) => void
>x : T

    if (isUndefined(x)) {
>isUndefined(x) : boolean
>isUndefined : (x: unknown) => x is undefined
>x : Box<T> | undefined

        unbox(x);  // Error
>unbox(x) : unknown
>unbox : <T>(x: Box<T>) => T
>x : undefined
    }
}

// Repro from #13995

declare function takeA(val: 'A'): void;
>takeA : (val: 'A') => void
>val : "A"

export function bounceAndTakeIfA<AB extends 'A' | 'B'>(value: AB): AB {
>bounceAndTakeIfA : <AB extends "A" | "B">(value: AB) => AB
>value : AB

    if (value === 'A') {
>value === 'A' : boolean
>value : AB
>'A' : "A"

        takeA(value);
>takeA(value) : void
>takeA : (val: "A") => void
>value : "A"

        return value;
>value : AB
    }
    else {
        return value;
>value : AB
    }
}

// Repro from #13995

type Common = { id: number };
>Common : Common
>id : number

type AA = { tag: 'A', id: number };
>AA : AA
>tag : "A"
>id : number

type BB = { tag: 'B', id: number, foo: number };
>BB : BB
>tag : "B"
>id : number
>foo : number

type MyUnion = AA | BB;
>MyUnion : MyUnion

const fn = (value: MyUnion) => {
>fn : (value: MyUnion) => void
>(value: MyUnion) => {    value.foo;  // Error    if ('foo' in value) {        value.foo;    }    if (value.tag === 'B') {        value.foo;    }} : (value: MyUnion) => void
>value : MyUnion

    value.foo;  // Error
>value.foo : any
>value : MyUnion
>foo : any

    if ('foo' in value) {
>'foo' in value : boolean
>'foo' : "foo"
>value : MyUnion

        value.foo;
>value.foo : number
>value : BB
>foo : number
    }
    if (value.tag === 'B') {
>value.tag === 'B' : boolean
>value.tag : "A" | "B"
>value : MyUnion
>tag : "A" | "B"
>'B' : "B"

        value.foo;
>value.foo : number
>value : BB
>foo : number
    }
};

const fn2 = <T extends MyUnion>(value: T): MyUnion => {
>fn2 : <T extends MyUnion>(value: T) => MyUnion
><T extends MyUnion>(value: T): MyUnion => {    value.foo;  // Error    if ('foo' in value) {        value.foo;    }    if (value.tag === 'B') {        value.foo;    }} : <T extends MyUnion>(value: T) => MyUnion
>value : T

    value.foo;  // Error
>value.foo : any
>value : MyUnion
>foo : any

    if ('foo' in value) {
>'foo' in value : boolean
>'foo' : "foo"
>value : T

        value.foo;
>value.foo : number
>value : BB
>foo : number
    }
    if (value.tag === 'B') {
>value.tag === 'B' : boolean
>value.tag : "A" | "B"
>value : MyUnion
>tag : "A" | "B"
>'B' : "B"

        value.foo;
>value.foo : number
>value : BB
>foo : number
    }
};

// Repro from #13995

type A1 = {
>A1 : A1

    testable: true
>testable : true
>true : true

    doTest: () => void
>doTest : () => void
}
type B1 = {
>B1 : B1

    testable: false
>testable : false
>false : false

};

type Union = A1 | B1
>Union : Union

function notWorking<T extends Union>(object: T) {
>notWorking : <T extends Union>(object: T) => void
>object : T

    if (!object.testable) return;
>!object.testable : boolean
>object.testable : boolean
>object : Union
>testable : boolean

    object.doTest();
>object.doTest() : void
>object.doTest : () => void
>object : A1
>doTest : () => void
}

// Repro from #42939

interface A {
    a: number | null;
>a : number | null
>null : null

};

function get<K extends keyof A>(key: K, obj: A): number {
>get : <K extends "a">(key: K, obj: A) => number
>key : K
>obj : A

    const value = obj[key];
>value : A[K]
>obj[key] : A[K]
>obj : A
>key : K

    if (value !== null) {
>value !== null : boolean
>value : A[K]
>null : null

        return value;
>value : number
    }
    return 0;
>0 : 0

};

// Repro from #44093

class EventEmitter<ET> {
>EventEmitter : EventEmitter<ET>

    off<K extends keyof ET>(...args: [K, number] | [unknown, string]):void {}
>off : <K extends keyof ET>(...args: [K, number] | [unknown, string]) => void
>args : [K, number] | [unknown, string]
}
function once<ET, T extends EventEmitter<ET>>(emittingObject: T, eventName: keyof ET): void {
>once : <ET, T extends EventEmitter<ET>>(emittingObject: T, eventName: keyof ET) => void
>emittingObject : T
>eventName : keyof ET

    emittingObject.off(eventName, 0);
>emittingObject.off(eventName, 0) : void
>emittingObject.off : <K extends keyof ET>(...args: [unknown, string] | [K, number]) => void
>emittingObject : T
>off : <K extends keyof ET>(...args: [unknown, string] | [K, number]) => void
>eventName : keyof ET
>0 : 0

    emittingObject.off(eventName as typeof eventName, 0);
>emittingObject.off(eventName as typeof eventName, 0) : void
>emittingObject.off : <K extends keyof ET>(...args: [unknown, string] | [K, number]) => void
>emittingObject : T
>off : <K extends keyof ET>(...args: [unknown, string] | [K, number]) => void
>eventName as typeof eventName : keyof ET
>eventName : keyof ET
>eventName : keyof ET
>0 : 0
}

// In an element access obj[x], we consider obj to be in a constraint position, except when obj is of
// a generic type without a nullable constraint and x is a generic type. This is because when both obj
// and x are of generic types T and K, we want the resulting type to be T[K].

function fx1<T, K extends keyof T>(obj: T, key: K) {
>fx1 : <T, K extends keyof T>(obj: T, key: K) => void
>obj : T
>key : K

    const x1 = obj[key];
>x1 : T[K]
>obj[key] : T[K]
>obj : T
>key : K

    const x2 = obj && obj[key];
>x2 : T[K]
>obj && obj[key] : T[K]
>obj : T
>obj[key] : T[K]
>obj : T
>key : K
}

function fx2<T extends Record<keyof T, string>, K extends keyof T>(obj: T, key: K) {
>fx2 : <T extends Record<keyof T, string>, K extends keyof T>(obj: T, key: K) => void
>obj : T
>key : K

    const x1 = obj[key];
>x1 : T[K]
>obj[key] : T[K]
>obj : T
>key : K

    const x2 = obj && obj[key];
>x2 : T[K]
>obj && obj[key] : T[K]
>obj : T
>obj[key] : T[K]
>obj : T
>key : K
}

function fx3<T extends Record<keyof T, string> | undefined, K extends keyof T>(obj: T, key: K) {
>fx3 : <T extends Record<keyof T, string> | undefined, K extends keyof T>(obj: T, key: K) => void
>obj : T
>key : K

    const x1 = obj[key];  // Error
>x1 : NonNullable<Record<keyof T, string>>[K]
>obj[key] : NonNullable<Record<keyof T, string>>[K]
>obj : Record<keyof T, string> | undefined
>key : K

    const x2 = obj && obj[key];
>x2 : Record<keyof T, string>[K]
>obj && obj[key] : Record<keyof T, string>[K]
>obj : T
>obj[key] : Record<keyof T, string>[K]
>obj : Record<keyof T, string>
>key : K
}

// Repro from #44166

class TableBaseEnum<
>TableBaseEnum : TableBaseEnum<PublicSpec, InternalSpec>

    PublicSpec extends Record<keyof InternalSpec, any>,
    InternalSpec extends Record<keyof PublicSpec, any>  | undefined = undefined> {
    m() {
>m : () => void

        let iSpec = null! as InternalSpec;
>iSpec : InternalSpec
>null! as InternalSpec : InternalSpec
>null! : never
>null : null

        iSpec[null! as keyof InternalSpec];  // Error, object possibly undefined
>iSpec[null! as keyof InternalSpec] : NonNullable<Record<keyof PublicSpec, any>>[keyof InternalSpec]
>iSpec : Record<keyof PublicSpec, any> | undefined
>null! as keyof InternalSpec : keyof InternalSpec
>null! : never
>null : null

        iSpec[null! as keyof PublicSpec];    // Error, object possibly undefined
>iSpec[null! as keyof PublicSpec] : NonNullable<Record<keyof PublicSpec, any>>[keyof PublicSpec]
>iSpec : Record<keyof PublicSpec, any> | undefined
>null! as keyof PublicSpec : keyof PublicSpec
>null! : never
>null : null

        if (iSpec === undefined) {
>iSpec === undefined : boolean
>iSpec : InternalSpec
>undefined : undefined

            return;
        }
        iSpec[null! as keyof InternalSpec];
>iSpec[null! as keyof InternalSpec] : Record<keyof PublicSpec, any>[keyof InternalSpec]
>iSpec : Record<keyof PublicSpec, any>
>null! as keyof InternalSpec : keyof InternalSpec
>null! : never
>null : null

        iSpec[null! as keyof PublicSpec];
>iSpec[null! as keyof PublicSpec] : Record<keyof PublicSpec, any>[keyof PublicSpec]
>iSpec : Record<keyof PublicSpec, any>
>null! as keyof PublicSpec : keyof PublicSpec
>null! : never
>null : null
    }
}

// Repros from #45145

function f10<T extends { a: string } | undefined>(x: T, y: Partial<T>) {
>f10 : <T extends { a: string; } | undefined>(x: T, y: Partial<T>) => void
>a : string
>x : T
>y : Partial<T>

    y = x;
>y = x : T
>y : Partial<T>
>x : T
}

type SqlInsertSet<T> = T extends undefined ? object : { [P in keyof T]: unknown };
>SqlInsertSet : SqlInsertSet<T>

class SqlTable<T> {
>SqlTable : SqlTable<T>

    protected validateRow(_row: Partial<SqlInsertSet<T>>): void {
>validateRow : (_row: Partial<SqlInsertSet<T>>) => void
>_row : Partial<SqlInsertSet<T>>
    }
    public insertRow(row: SqlInsertSet<T>) {
>insertRow : (row: SqlInsertSet<T>) => void
>row : SqlInsertSet<T>

        this.validateRow(row);
>this.validateRow(row) : void
>this.validateRow : (_row: Partial<SqlInsertSet<T>>) => void
>this : this
>validateRow : (_row: Partial<SqlInsertSet<T>>) => void
>row : SqlInsertSet<T>
    }
}

// Repro from #46495

interface Button {
    type: "button";
>type : "button"

    text: string;
>text : string
}

interface Checkbox {
    type: "checkbox";
>type : "checkbox"

    isChecked: boolean;
>isChecked : boolean
}

type Control = Button | Checkbox;
>Control : Control

function update<T extends Control, K extends keyof T>(control : T | undefined, key: K, value: T[K]): void {
>update : <T extends Control, K extends keyof T>(control: T | undefined, key: K, value: T[K]) => void
>control : T | undefined
>key : K
>value : T[K]

    if (control !== undefined) {
>control !== undefined : boolean
>control : T | undefined
>undefined : undefined

        control[key] = value;
>control[key] = value : T[K]
>control[key] : T[K]
>control : T
>key : K
>value : T[K]
    }
}