Accept new baselines

2026-05-30 01:04:49 -05:00 · 2016-08-01 07:04:54 -07:00
parent b3b4c34b60
commit 0a90a4b27c
3 changed files with 336 additions and 73 deletions
--- a/tests/baselines/reference/narrowingByDiscriminantInLoop.js
+++ b/tests/baselines/reference/narrowingByDiscriminantInLoop.js
@@ -1,4 +1,5 @@
 //// [narrowingByDiscriminantInLoop.ts]
+
 // Repro from #9977

 type IDLMemberTypes = OperationMemberType | ConstantMemberType;
@@ -13,7 +14,7 @@ interface InterfaceType {

 interface OperationMemberType {
    type: "operation";
-    idlType: IDLTypeDescription | null;
+    idlType: IDLTypeDescription;
 }

 interface ConstantMemberType {
@@ -48,6 +49,41 @@ function foo(memberType: IDLMemberTypes) {
    else if (memberType.type === "operation") {
        memberType.idlType.origin;  // string
    }
+}
+
+// Repro for issue similar to #8383
+
+interface A {
+    kind: true;
+    prop: { a: string; };
+}
+
+interface B {
+    kind: false;
+    prop: { b: string; }
+}
+
+function f1(x: A | B) {
+    while (true) {
+        x.prop;
+        if (x.kind === true) {
+            x.prop.a;
+        }
+        if (x.kind === false) {
+            x.prop.b;
+        }
+    }
+}
+
+function f2(x: A | B) {
+    while (true) {
+        if (x.kind) {
+            x.prop.a;
+        }
+        if (!x.kind) {
+            x.prop.b;
+        }
+    }
 }

 //// [narrowingByDiscriminantInLoop.js]
@@ -80,3 +116,24 @@ function foo(memberType) {
        memberType.idlType.origin; // string
    }
 }
+function f1(x) {
+    while (true) {
+        x.prop;
+        if (x.kind === true) {
+            x.prop.a;
+        }
+        if (x.kind === false) {
+            x.prop.b;
+        }
+    }
+}
+function f2(x) {
+    while (true) {
+        if (x.kind) {
+            x.prop.a;
+        }
+        if (!x.kind) {
+            x.prop.b;
+        }
+    }
+}
--- a/tests/baselines/reference/narrowingByDiscriminantInLoop.symbols
+++ b/tests/baselines/reference/narrowingByDiscriminantInLoop.symbols
@@ -1,140 +1,238 @@
 === tests/cases/compiler/narrowingByDiscriminantInLoop.ts ===
+
 // Repro from #9977

 type IDLMemberTypes = OperationMemberType | ConstantMemberType;
 >IDLMemberTypes : Symbol(IDLMemberTypes, Decl(narrowingByDiscriminantInLoop.ts, 0, 0))
->OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 10, 1))
->ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 15, 1))
+>OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 11, 1))
+>ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 16, 1))

 interface IDLTypeDescription {
->IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 2, 63))
+>IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 3, 63))

    origin: string;
->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30))
+>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30))
 }

 interface InterfaceType {
->InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 6, 1))
+>InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 7, 1))

    members: IDLMemberTypes[];
->members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25))
+>members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25))
 >IDLMemberTypes : Symbol(IDLMemberTypes, Decl(narrowingByDiscriminantInLoop.ts, 0, 0))
 }

 interface OperationMemberType {
->OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 10, 1))
+>OperationMemberType : Symbol(OperationMemberType, Decl(narrowingByDiscriminantInLoop.ts, 11, 1))

    type: "operation";
->type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31))
+>type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31))

-    idlType: IDLTypeDescription | null;
->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22))
->IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 2, 63))
+    idlType: IDLTypeDescription;
+>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22))
+>IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 3, 63))
 }

 interface ConstantMemberType {
->ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 15, 1))
+>ConstantMemberType : Symbol(ConstantMemberType, Decl(narrowingByDiscriminantInLoop.ts, 16, 1))

    type: "const";
->type : Symbol(ConstantMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 17, 30))
+>type : Symbol(ConstantMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 18, 30))

    idlType: string;
->idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18))
+>idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18))
 }

 function insertInterface(callbackType: InterfaceType) {
->insertInterface : Symbol(insertInterface, Decl(narrowingByDiscriminantInLoop.ts, 20, 1))
->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 22, 25))
->InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 6, 1))
+>insertInterface : Symbol(insertInterface, Decl(narrowingByDiscriminantInLoop.ts, 21, 1))
+>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 23, 25))
+>InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 7, 1))

    for (const memberType of callbackType.members) {
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14))
->callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25))
->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 22, 25))
->members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14))
+>callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25))
+>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 23, 25))
+>members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25))

        if (memberType.type === "const") {
->memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14))
->type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30))
+>memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14))
+>type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30))

            memberType.idlType;  // string
->memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14))
->idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18))
+>memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14))
+>idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18))
        }
        else if (memberType.type === "operation") {
->memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14))
->type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31))
+>memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14))
+>type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31))

            memberType.idlType.origin;  // string
->memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30))
->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14))
->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22))
->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30))
+>memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30))
+>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14))
+>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22))
+>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30))

            (memberType.idlType as IDLTypeDescription);
->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 23, 14))
->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22))
->IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 2, 63))
+>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 24, 14))
+>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22))
+>IDLTypeDescription : Symbol(IDLTypeDescription, Decl(narrowingByDiscriminantInLoop.ts, 3, 63))
        }
    }
 }

 function insertInterface2(callbackType: InterfaceType) {
->insertInterface2 : Symbol(insertInterface2, Decl(narrowingByDiscriminantInLoop.ts, 32, 1))
->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 34, 26))
->InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 6, 1))
+>insertInterface2 : Symbol(insertInterface2, Decl(narrowingByDiscriminantInLoop.ts, 33, 1))
+>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 35, 26))
+>InterfaceType : Symbol(InterfaceType, Decl(narrowingByDiscriminantInLoop.ts, 7, 1))

    for (const memberType of callbackType.members) {
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 35, 14))
->callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25))
->callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 34, 26))
->members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 8, 25))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 36, 14))
+>callbackType.members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25))
+>callbackType : Symbol(callbackType, Decl(narrowingByDiscriminantInLoop.ts, 35, 26))
+>members : Symbol(InterfaceType.members, Decl(narrowingByDiscriminantInLoop.ts, 9, 25))

        if (memberType.type === "operation") {
->memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 35, 14))
->type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30))
+>memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 36, 14))
+>type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30))

            memberType.idlType.origin;  // string
->memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30))
->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 35, 14))
->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22))
->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30))
+>memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30))
+>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 36, 14))
+>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22))
+>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30))
        }
    }
 }

 function foo(memberType: IDLMemberTypes) {
->foo : Symbol(foo, Decl(narrowingByDiscriminantInLoop.ts, 40, 1))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13))
+>foo : Symbol(foo, Decl(narrowingByDiscriminantInLoop.ts, 41, 1))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13))
 >IDLMemberTypes : Symbol(IDLMemberTypes, Decl(narrowingByDiscriminantInLoop.ts, 0, 0))

    if (memberType.type === "const") {
->memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13))
->type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31), Decl(narrowingByDiscriminantInLoop.ts, 17, 30))
+>memberType.type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13))
+>type : Symbol(type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31), Decl(narrowingByDiscriminantInLoop.ts, 18, 30))

        memberType.idlType;  // string
->memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13))
->idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 18, 18))
+>memberType.idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13))
+>idlType : Symbol(ConstantMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 19, 18))
    }
    else if (memberType.type === "operation") {
->memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13))
->type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 12, 31))
+>memberType.type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13))
+>type : Symbol(OperationMemberType.type, Decl(narrowingByDiscriminantInLoop.ts, 13, 31))

        memberType.idlType.origin;  // string
->memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30))
->memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22))
->memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 42, 13))
->idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 13, 22))
->origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 4, 30))
+>memberType.idlType.origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30))
+>memberType.idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22))
+>memberType : Symbol(memberType, Decl(narrowingByDiscriminantInLoop.ts, 43, 13))
+>idlType : Symbol(OperationMemberType.idlType, Decl(narrowingByDiscriminantInLoop.ts, 14, 22))
+>origin : Symbol(IDLTypeDescription.origin, Decl(narrowingByDiscriminantInLoop.ts, 5, 30))
+    }
+}
+
+// Repro for issue similar to #8383
+
+interface A {
+>A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 50, 1))
+
+    kind: true;
+>kind : Symbol(A.kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13))
+
+    prop: { a: string; };
+>prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15))
+>a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11))
+}
+
+interface B {
+>B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 57, 1))
+
+    kind: false;
+>kind : Symbol(B.kind, Decl(narrowingByDiscriminantInLoop.ts, 59, 13))
+
+    prop: { b: string; }
+>prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16))
+>b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11))
+}
+
+function f1(x: A | B) {
+>f1 : Symbol(f1, Decl(narrowingByDiscriminantInLoop.ts, 62, 1))
+>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12))
+>A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 50, 1))
+>B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 57, 1))
+
+    while (true) {
+        x.prop;
+>x.prop : Symbol(prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15), Decl(narrowingByDiscriminantInLoop.ts, 60, 16))
+>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12))
+>prop : Symbol(prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15), Decl(narrowingByDiscriminantInLoop.ts, 60, 16))
+
+        if (x.kind === true) {
+>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13))
+>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12))
+>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13))
+
+            x.prop.a;
+>x.prop.a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11))
+>x.prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15))
+>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12))
+>prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15))
+>a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11))
+        }
+        if (x.kind === false) {
+>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13))
+>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12))
+>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13))
+
+            x.prop.b;
+>x.prop.b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11))
+>x.prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16))
+>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 64, 12))
+>prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16))
+>b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11))
+        }
+    }
+}
+
+function f2(x: A | B) {
+>f2 : Symbol(f2, Decl(narrowingByDiscriminantInLoop.ts, 74, 1))
+>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12))
+>A : Symbol(A, Decl(narrowingByDiscriminantInLoop.ts, 50, 1))
+>B : Symbol(B, Decl(narrowingByDiscriminantInLoop.ts, 57, 1))
+
+    while (true) {
+        if (x.kind) {
+>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13))
+>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12))
+>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13))
+
+            x.prop.a;
+>x.prop.a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11))
+>x.prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15))
+>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12))
+>prop : Symbol(A.prop, Decl(narrowingByDiscriminantInLoop.ts, 55, 15))
+>a : Symbol(a, Decl(narrowingByDiscriminantInLoop.ts, 56, 11))
+        }
+        if (!x.kind) {
+>x.kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13))
+>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12))
+>kind : Symbol(kind, Decl(narrowingByDiscriminantInLoop.ts, 54, 13), Decl(narrowingByDiscriminantInLoop.ts, 59, 13))
+
+            x.prop.b;
+>x.prop.b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11))
+>x.prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16))
+>x : Symbol(x, Decl(narrowingByDiscriminantInLoop.ts, 76, 12))
+>prop : Symbol(B.prop, Decl(narrowingByDiscriminantInLoop.ts, 60, 16))
+>b : Symbol(b, Decl(narrowingByDiscriminantInLoop.ts, 61, 11))
+        }
    }
 }
--- a/tests/baselines/reference/narrowingByDiscriminantInLoop.types
+++ b/tests/baselines/reference/narrowingByDiscriminantInLoop.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/narrowingByDiscriminantInLoop.ts ===
+
 // Repro from #9977

 type IDLMemberTypes = OperationMemberType | ConstantMemberType;
@@ -27,10 +28,9 @@ interface OperationMemberType {
    type: "operation";
 >type : "operation"

-    idlType: IDLTypeDescription | null;
+    idlType: IDLTypeDescription;
 >idlType : IDLTypeDescription
 >IDLTypeDescription : IDLTypeDescription
->null : null
 }

 interface ConstantMemberType {
@@ -151,3 +151,111 @@ function foo(memberType: IDLMemberTypes) {
 >origin : string
    }
 }
+
+// Repro for issue similar to #8383
+
+interface A {
+>A : A
+
+    kind: true;
+>kind : true
+>true : true
+
+    prop: { a: string; };
+>prop : { a: string; }
+>a : string
+}
+
+interface B {
+>B : B
+
+    kind: false;
+>kind : false
+>false : false
+
+    prop: { b: string; }
+>prop : { b: string; }
+>b : string
+}
+
+function f1(x: A | B) {
+>f1 : (x: A | B) => void
+>x : A | B
+>A : A
+>B : B
+
+    while (true) {
+>true : boolean
+
+        x.prop;
+>x.prop : { a: string; } | { b: string; }
+>x : A | B
+>prop : { a: string; } | { b: string; }
+
+        if (x.kind === true) {
+>x.kind === true : boolean
+>x.kind : boolean
+>x : A | B
+>kind : boolean
+>true : true
+
+            x.prop.a;
+>x.prop.a : string
+>x.prop : { a: string; }
+>x : A
+>prop : { a: string; }
+>a : string
+        }
+        if (x.kind === false) {
+>x.kind === false : boolean
+>x.kind : boolean
+>x : A | B
+>kind : boolean
+>false : false
+
+            x.prop.b;
+>x.prop.b : string
+>x.prop : { b: string; }
+>x : B
+>prop : { b: string; }
+>b : string
+        }
+    }
+}
+
+function f2(x: A | B) {
+>f2 : (x: A | B) => void
+>x : A | B
+>A : A
+>B : B
+
+    while (true) {
+>true : boolean
+
+        if (x.kind) {
+>x.kind : boolean
+>x : A | B
+>kind : boolean
+
+            x.prop.a;
+>x.prop.a : string
+>x.prop : { a: string; }
+>x : A
+>prop : { a: string; }
+>a : string
+        }
+        if (!x.kind) {
+>!x.kind : boolean
+>x.kind : boolean
+>x : A | B
+>kind : boolean
+
+            x.prop.b;
+>x.prop.b : string
+>x.prop : { b: string; }
+>x : B
+>prop : { b: string; }
+>b : string
+        }
+    }
+}