TypeScript/tests/baselines/reference/privateNameInInExpression.symbols

=== tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts ===
class Foo {
>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0))

    #field = 1;
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))

    static #staticField = 2;
>#staticField : Symbol(Foo.#staticField, Decl(privateNameInInExpression.ts, 1, 15))

    #method() {}
>#method : Symbol(Foo.#method, Decl(privateNameInInExpression.ts, 2, 28))

    static #staticMethod() {}
>#staticMethod : Symbol(Foo.#staticMethod, Decl(privateNameInInExpression.ts, 3, 16))

    goodRhs(v: any) {
>goodRhs : Symbol(Foo.goodRhs, Decl(privateNameInInExpression.ts, 4, 29))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12))

        const a = #field in v;
>a : Symbol(a, Decl(privateNameInInExpression.ts, 7, 13))
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12))

        const b = #field in v.p1.p2;
>b : Symbol(b, Decl(privateNameInInExpression.ts, 9, 13))
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12))

        const c = #field in (v as {});
>c : Symbol(c, Decl(privateNameInInExpression.ts, 11, 13))
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12))

        const d = #field in (v as Foo);
>d : Symbol(d, Decl(privateNameInInExpression.ts, 13, 13))
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12))
>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0))

        const e = #field in (v as never);
>e : Symbol(e, Decl(privateNameInInExpression.ts, 15, 13))
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12))

        for (let f in #field in v as any) { /**/ } // unlikely but valid
>f : Symbol(f, Decl(privateNameInInExpression.ts, 17, 16))
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12))
    }
    badRhs(v: any) {
>badRhs : Symbol(Foo.badRhs, Decl(privateNameInInExpression.ts, 18, 5))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11))

        const a = #field in (v as unknown); // Bad - RHS of in must be object type or any
>a : Symbol(a, Decl(privateNameInInExpression.ts, 20, 13))
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11))

        const b = #fiel in v; // Bad - typo in privateID
>b : Symbol(b, Decl(privateNameInInExpression.ts, 22, 13))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11))

        const c = (#field) in v; // Bad - privateID is not an expression on its own
>c : Symbol(c, Decl(privateNameInInExpression.ts, 24, 13))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11))

        for (#field in v) { /**/ } // Bad - 'in' not allowed
>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11))

        for (let d in #field in v) { /**/ } // Bad - rhs of in should be a object/any
>d : Symbol(d, Decl(privateNameInInExpression.ts, 28, 16))
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11))
    }
    whitespace(v: any) {
>whitespace : Symbol(Foo.whitespace, Decl(privateNameInInExpression.ts, 29, 5))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 30, 15))

        const a = v && /*0*/#field/*1*/
>a : Symbol(a, Decl(privateNameInInExpression.ts, 31, 13))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 30, 15))
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))

            /*2*/in/*3*/
                /*4*/v/*5*/
>v : Symbol(v, Decl(privateNameInInExpression.ts, 30, 15))
    }
    flow(u: unknown, n: never, fb: Foo | Bar, fs: FooSub, b: Bar, fsb: FooSub | Bar, fsfb: Foo | FooSub | Bar) {
>flow : Symbol(Foo.flow, Decl(privateNameInInExpression.ts, 34, 5))
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))
>n : Symbol(n, Decl(privateNameInInExpression.ts, 35, 20))
>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30))
>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0))
>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48))
>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45))
>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1))
>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57))
>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48))
>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65))
>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1))
>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48))
>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84))
>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0))
>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1))
>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48))

        if (typeof u === 'object') {
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))

            if (#field in n) {
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>n : Symbol(n, Decl(privateNameInInExpression.ts, 35, 20))

                n; // good n is never
>n : Symbol(n, Decl(privateNameInInExpression.ts, 35, 20))
            }

            if (#field in u) {
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))

                u; // good u is Foo
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))

            } else {
                u; // good u is object | null
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))
            }

            if (u !== null) {
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))

                if (#field in u) {
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))

                    u; // good u is Foo
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))

                } else {
                    u; // good u is object
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))
                }

                if (#method in u) {
>#method : Symbol(Foo.#method, Decl(privateNameInInExpression.ts, 2, 28))
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))

                    u; // good u is Foo
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))
                }

                if (#staticField in u) {
>#staticField : Symbol(Foo.#staticField, Decl(privateNameInInExpression.ts, 1, 15))
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))

                    u; // good u is typeof Foo
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))
                }

                if (#staticMethod in u) {
>#staticMethod : Symbol(Foo.#staticMethod, Decl(privateNameInInExpression.ts, 3, 16))
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))

                    u; // good u is typeof Foo
>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9))
                }
            }
        }

        if (#field in fb) {
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30))

            fb; // good fb is Foo
>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30))

        } else {
            fb; // good fb is Bar
>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30))
        }

        if (#field in fs) {
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45))

            fs; // good fs is FooSub
>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45))

        } else {
            fs; // good fs is never
>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45))
        }

        if (#field in b) {
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57))

            b; // good b is 'Bar & Foo'
>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57))

        } else {
            b; // good b is Bar
>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57))
        }

        if (#field in fsb) {
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65))

            fsb; // good fsb is FooSub
>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65))

        } else {
            fsb; // good fsb is Bar
>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65))
        }

        if (#field in fsfb) {
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84))

            fsfb; // good fsfb is 'Foo | FooSub'
>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84))

        } else {
            fsfb; // good fsfb is Bar
>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84))
        }

        class Nested {
>Nested : Symbol(Nested, Decl(privateNameInInExpression.ts, 97, 9))

            m(v: any) {
>m : Symbol(Nested.m, Decl(privateNameInInExpression.ts, 99, 22))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 100, 14))

                if (#field in v) {
>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 100, 14))

                    v; // good v is Foo
>v : Symbol(v, Decl(privateNameInInExpression.ts, 100, 14))
                }
            }
        }
    }
}

class FooSub extends Foo { subTypeOfFoo = true }
>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1))
>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0))
>subTypeOfFoo : Symbol(FooSub.subTypeOfFoo, Decl(privateNameInInExpression.ts, 109, 26))

class Bar { notFoo = true }
>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48))
>notFoo : Symbol(Bar.notFoo, Decl(privateNameInInExpression.ts, 110, 11))

function badSyntax(v: Foo) {
>badSyntax : Symbol(badSyntax, Decl(privateNameInInExpression.ts, 110, 27))
>v : Symbol(v, Decl(privateNameInInExpression.ts, 112, 19))
>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0))

    return #field in v; // Bad - outside of class
>v : Symbol(v, Decl(privateNameInInExpression.ts, 112, 19))
}