From e0ccb0da7633c472b967b5370cad3c889ab51ad1 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Mon, 8 Jan 2024 08:52:52 -0800
Subject: [PATCH] Accept new baselines

---
 tests/baselines/reference/enumIndexer.types   |   2 +-
 .../narrowingPastLastAssignment.errors.txt    |  56 +++++-
 .../narrowingPastLastAssignment.symbols       | 179 +++++++++++++-----
 .../narrowingPastLastAssignment.types         | 136 ++++++++++++-
 ...arrowingPastLastAssignmentInModule.symbols |  70 +++++++
 .../narrowingPastLastAssignmentInModule.types |  89 +++++++++
 6 files changed, 472 insertions(+), 60 deletions(-)
 create mode 100644 tests/baselines/reference/narrowingPastLastAssignmentInModule.symbols
 create mode 100644 tests/baselines/reference/narrowingPastLastAssignmentInModule.types

diff --git a/tests/baselines/reference/enumIndexer.types b/tests/baselines/reference/enumIndexer.types
index 53ddde562b2cd..ef25de3ab05a2 100644
--- a/tests/baselines/reference/enumIndexer.types
+++ b/tests/baselines/reference/enumIndexer.types
@@ -38,5 +38,5 @@ var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same ty
 >o.key : string
 >o : { key: string; }
 >key : string
->enumValue : MyEnumType.foo
+>enumValue : MyEnumType
 
diff --git a/tests/baselines/reference/narrowingPastLastAssignment.errors.txt b/tests/baselines/reference/narrowingPastLastAssignment.errors.txt
index 7590912410bde..0477f4c4877a1 100644
--- a/tests/baselines/reference/narrowingPastLastAssignment.errors.txt
+++ b/tests/baselines/reference/narrowingPastLastAssignment.errors.txt
@@ -1,5 +1,5 @@
-narrowingPastLastAssignment.ts(67,9): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined.
-narrowingPastLastAssignment.ts(69,20): error TS7005: Variable 'x' implicitly has an 'any' type.
+narrowingPastLastAssignment.ts(88,9): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined.
+narrowingPastLastAssignment.ts(90,20): error TS7005: Variable 'x' implicitly has an 'any' type.
 
 
 ==== narrowingPastLastAssignment.ts (2 errors) ====
@@ -66,6 +66,27 @@ narrowingPastLastAssignment.ts(69,20): error TS7005: Variable 'x' implicitly has
         action(() => { x /* number */ });
     }
     
+    function f5a(cond: boolean) {
+        if (cond) {
+            let x: number | undefined;
+            x = 1;
+            action(() => { x /* number */ });
+        }
+        else {
+            let x: number | undefined;
+            x = 2;
+            action(() => { x /* number */ });
+        }
+    }
+    
+    function f5b() {
+        for (let x = 0; x < 10; x++) {
+            if (x === 1 || x === 2) {
+                action(() => { x /* 1 | 2 */ })
+            }
+        }
+    }
+    
     // Implicit any variables have a known type following last assignment
     
     function f6() {
@@ -92,6 +113,23 @@ narrowingPastLastAssignment.ts(69,20): error TS7005: Variable 'x' implicitly has
         }
     }
     
+    // Narrowings are not preserved for global variables
+    
+    let g: string | number;
+    g = "abc";
+    action(() => { g /* string | number */ });
+    
+    // Narrowings are not preserved for exported namespace members
+    
+    namespace Foo {
+        export let x: string | number;
+        x = "abc";
+        action(() => { x /* string | number */ });
+        let y: string | number;
+        y = "abc";
+        action(() => { y /* string */ });
+    }
+    
     // Repros from #35124
     
     function f10() {
@@ -113,11 +151,13 @@ narrowingPastLastAssignment.ts(69,20): error TS7005: Variable 'x' implicitly has
     
     // Repro from #52104
     
-    const fooMap: Map<string,Array<number>> = new Map()
-    const values = [1, 2, 3, 4, 5];
-    let foo = fooMap.get("a");
-    if (foo == null) {
-        foo = [];
+    function f12() {
+        const fooMap: Map<string,Array<number>> = new Map()
+        const values = [1, 2, 3, 4, 5];
+        let foo = fooMap.get("a");
+        if (foo == null) {
+            foo = [];
+        }
+        values.forEach(v => foo.push(v));
     }
-    values.forEach(v => foo.push(v));
     
\ No newline at end of file
diff --git a/tests/baselines/reference/narrowingPastLastAssignment.symbols b/tests/baselines/reference/narrowingPastLastAssignment.symbols
index 006603f0d010d..4ace603d16418 100644
--- a/tests/baselines/reference/narrowingPastLastAssignment.symbols
+++ b/tests/baselines/reference/narrowingPastLastAssignment.symbols
@@ -152,123 +152,214 @@ function f5(x: string | number, cond: () => boolean) {
 >x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 51, 12))
 }
 
+function f5a(cond: boolean) {
+>f5a : Symbol(f5a, Decl(narrowingPastLastAssignment.ts, 61, 1))
+>cond : Symbol(cond, Decl(narrowingPastLastAssignment.ts, 63, 13))
+
+    if (cond) {
+>cond : Symbol(cond, Decl(narrowingPastLastAssignment.ts, 63, 13))
+
+        let x: number | undefined;
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 65, 11))
+
+        x = 1;
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 65, 11))
+
+        action(() => { x /* number */ });
+>action : Symbol(action, Decl(narrowingPastLastAssignment.ts, 0, 0))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 65, 11))
+    }
+    else {
+        let x: number | undefined;
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 70, 11))
+
+        x = 2;
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 70, 11))
+
+        action(() => { x /* number */ });
+>action : Symbol(action, Decl(narrowingPastLastAssignment.ts, 0, 0))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 70, 11))
+    }
+}
+
+function f5b() {
+>f5b : Symbol(f5b, Decl(narrowingPastLastAssignment.ts, 74, 1))
+
+    for (let x = 0; x < 10; x++) {
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 77, 12))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 77, 12))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 77, 12))
+
+        if (x === 1 || x === 2) {
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 77, 12))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 77, 12))
+
+            action(() => { x /* 1 | 2 */ })
+>action : Symbol(action, Decl(narrowingPastLastAssignment.ts, 0, 0))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 77, 12))
+        }
+    }
+}
+
 // Implicit any variables have a known type following last assignment
 
 function f6() {
->f6 : Symbol(f6, Decl(narrowingPastLastAssignment.ts, 61, 1))
+>f6 : Symbol(f6, Decl(narrowingPastLastAssignment.ts, 82, 1))
 
     let x;
->x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 66, 7))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 87, 7))
 
     x = "abc";
->x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 66, 7))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 87, 7))
 
     action(() => { x });  // Error
 >action : Symbol(action, Decl(narrowingPastLastAssignment.ts, 0, 0))
->x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 66, 7))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 87, 7))
 
     x = 42;
->x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 66, 7))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 87, 7))
 
     action(() => { x /* number */ });
 >action : Symbol(action, Decl(narrowingPastLastAssignment.ts, 0, 0))
->x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 66, 7))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 87, 7))
 }
 
 // Narrowings on catch variables are preserved past last assignment
 
 function f7() {
->f7 : Symbol(f7, Decl(narrowingPastLastAssignment.ts, 71, 1))
+>f7 : Symbol(f7, Decl(narrowingPastLastAssignment.ts, 92, 1))
 
     try {
     }
     catch (e) {
->e : Symbol(e, Decl(narrowingPastLastAssignment.ts, 78, 11))
+>e : Symbol(e, Decl(narrowingPastLastAssignment.ts, 99, 11))
 
         if (e instanceof Error) {
->e : Symbol(e, Decl(narrowingPastLastAssignment.ts, 78, 11))
+>e : Symbol(e, Decl(narrowingPastLastAssignment.ts, 99, 11))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --))
 
             let f = () => { e /* Error */ }
->f : Symbol(f, Decl(narrowingPastLastAssignment.ts, 80, 15))
->e : Symbol(e, Decl(narrowingPastLastAssignment.ts, 78, 11))
+>f : Symbol(f, Decl(narrowingPastLastAssignment.ts, 101, 15))
+>e : Symbol(e, Decl(narrowingPastLastAssignment.ts, 99, 11))
         }
     }
 }
 
+// Narrowings are not preserved for global variables
+
+let g: string | number;
+>g : Symbol(g, Decl(narrowingPastLastAssignment.ts, 108, 3))
+
+g = "abc";
+>g : Symbol(g, Decl(narrowingPastLastAssignment.ts, 108, 3))
+
+action(() => { g /* string | number */ });
+>action : Symbol(action, Decl(narrowingPastLastAssignment.ts, 0, 0))
+>g : Symbol(g, Decl(narrowingPastLastAssignment.ts, 108, 3))
+
+// Narrowings are not preserved for exported namespace members
+
+namespace Foo {
+>Foo : Symbol(Foo, Decl(narrowingPastLastAssignment.ts, 110, 42))
+
+    export let x: string | number;
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 115, 14))
+
+    x = "abc";
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 115, 14))
+
+    action(() => { x /* string | number */ });
+>action : Symbol(action, Decl(narrowingPastLastAssignment.ts, 0, 0))
+>x : Symbol(x, Decl(narrowingPastLastAssignment.ts, 115, 14))
+
+    let y: string | number;
+>y : Symbol(y, Decl(narrowingPastLastAssignment.ts, 118, 7))
+
+    y = "abc";
+>y : Symbol(y, Decl(narrowingPastLastAssignment.ts, 118, 7))
+
+    action(() => { y /* string */ });
+>action : Symbol(action, Decl(narrowingPastLastAssignment.ts, 0, 0))
+>y : Symbol(y, Decl(narrowingPastLastAssignment.ts, 118, 7))
+}
+
 // Repros from #35124
 
 function f10() {
->f10 : Symbol(f10, Decl(narrowingPastLastAssignment.ts, 83, 1))
+>f10 : Symbol(f10, Decl(narrowingPastLastAssignment.ts, 121, 1))
 
     let i: number | undefined;
->i : Symbol(i, Decl(narrowingPastLastAssignment.ts, 88, 7))
+>i : Symbol(i, Decl(narrowingPastLastAssignment.ts, 126, 7))
 
     i = 0;
->i : Symbol(i, Decl(narrowingPastLastAssignment.ts, 88, 7))
+>i : Symbol(i, Decl(narrowingPastLastAssignment.ts, 126, 7))
 
     return (k: number) => k === i + 1;
->k : Symbol(k, Decl(narrowingPastLastAssignment.ts, 90, 12))
->k : Symbol(k, Decl(narrowingPastLastAssignment.ts, 90, 12))
->i : Symbol(i, Decl(narrowingPastLastAssignment.ts, 88, 7))
+>k : Symbol(k, Decl(narrowingPastLastAssignment.ts, 128, 12))
+>k : Symbol(k, Decl(narrowingPastLastAssignment.ts, 128, 12))
+>i : Symbol(i, Decl(narrowingPastLastAssignment.ts, 126, 7))
 }
 
 function makeAdder(n?: number) {
->makeAdder : Symbol(makeAdder, Decl(narrowingPastLastAssignment.ts, 91, 1))
->n : Symbol(n, Decl(narrowingPastLastAssignment.ts, 93, 19))
+>makeAdder : Symbol(makeAdder, Decl(narrowingPastLastAssignment.ts, 129, 1))
+>n : Symbol(n, Decl(narrowingPastLastAssignment.ts, 131, 19))
 
     n ??= 0;
->n : Symbol(n, Decl(narrowingPastLastAssignment.ts, 93, 19))
+>n : Symbol(n, Decl(narrowingPastLastAssignment.ts, 131, 19))
 
     return (m: number) => n + m;
->m : Symbol(m, Decl(narrowingPastLastAssignment.ts, 95, 12))
->n : Symbol(n, Decl(narrowingPastLastAssignment.ts, 93, 19))
->m : Symbol(m, Decl(narrowingPastLastAssignment.ts, 95, 12))
+>m : Symbol(m, Decl(narrowingPastLastAssignment.ts, 133, 12))
+>n : Symbol(n, Decl(narrowingPastLastAssignment.ts, 131, 19))
+>m : Symbol(m, Decl(narrowingPastLastAssignment.ts, 133, 12))
 }
 
 function f11() {
->f11 : Symbol(f11, Decl(narrowingPastLastAssignment.ts, 96, 1))
+>f11 : Symbol(f11, Decl(narrowingPastLastAssignment.ts, 134, 1))
 
     let r;
->r : Symbol(r, Decl(narrowingPastLastAssignment.ts, 99, 7))
+>r : Symbol(r, Decl(narrowingPastLastAssignment.ts, 137, 7))
 
     r = "b";
->r : Symbol(r, Decl(narrowingPastLastAssignment.ts, 99, 7))
+>r : Symbol(r, Decl(narrowingPastLastAssignment.ts, 137, 7))
 
     () => r;
->r : Symbol(r, Decl(narrowingPastLastAssignment.ts, 99, 7))
+>r : Symbol(r, Decl(narrowingPastLastAssignment.ts, 137, 7))
 }
 
 // Repro from #52104
 
-const fooMap: Map<string,Array<number>> = new Map()
->fooMap : Symbol(fooMap, Decl(narrowingPastLastAssignment.ts, 106, 5))
+function f12() {
+>f12 : Symbol(f12, Decl(narrowingPastLastAssignment.ts, 140, 1))
+
+    const fooMap: Map<string,Array<number>> = new Map()
+>fooMap : Symbol(fooMap, Decl(narrowingPastLastAssignment.ts, 145, 9))
 >Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more)
 >Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 
-const values = [1, 2, 3, 4, 5];
->values : Symbol(values, Decl(narrowingPastLastAssignment.ts, 107, 5))
+    const values = [1, 2, 3, 4, 5];
+>values : Symbol(values, Decl(narrowingPastLastAssignment.ts, 146, 9))
 
-let foo = fooMap.get("a");
->foo : Symbol(foo, Decl(narrowingPastLastAssignment.ts, 108, 3))
+    let foo = fooMap.get("a");
+>foo : Symbol(foo, Decl(narrowingPastLastAssignment.ts, 147, 7))
 >fooMap.get : Symbol(Map.get, Decl(lib.es2015.collection.d.ts, --, --))
->fooMap : Symbol(fooMap, Decl(narrowingPastLastAssignment.ts, 106, 5))
+>fooMap : Symbol(fooMap, Decl(narrowingPastLastAssignment.ts, 145, 9))
 >get : Symbol(Map.get, Decl(lib.es2015.collection.d.ts, --, --))
 
-if (foo == null) {
->foo : Symbol(foo, Decl(narrowingPastLastAssignment.ts, 108, 3))
+    if (foo == null) {
+>foo : Symbol(foo, Decl(narrowingPastLastAssignment.ts, 147, 7))
 
-    foo = [];
->foo : Symbol(foo, Decl(narrowingPastLastAssignment.ts, 108, 3))
-}
-values.forEach(v => foo.push(v));
+        foo = [];
+>foo : Symbol(foo, Decl(narrowingPastLastAssignment.ts, 147, 7))
+    }
+    values.forEach(v => foo.push(v));
 >values.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
->values : Symbol(values, Decl(narrowingPastLastAssignment.ts, 107, 5))
+>values : Symbol(values, Decl(narrowingPastLastAssignment.ts, 146, 9))
 >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
->v : Symbol(v, Decl(narrowingPastLastAssignment.ts, 112, 15))
+>v : Symbol(v, Decl(narrowingPastLastAssignment.ts, 151, 19))
 >foo.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
->foo : Symbol(foo, Decl(narrowingPastLastAssignment.ts, 108, 3))
+>foo : Symbol(foo, Decl(narrowingPastLastAssignment.ts, 147, 7))
 >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
->v : Symbol(v, Decl(narrowingPastLastAssignment.ts, 112, 15))
+>v : Symbol(v, Decl(narrowingPastLastAssignment.ts, 151, 19))
+}
 
diff --git a/tests/baselines/reference/narrowingPastLastAssignment.types b/tests/baselines/reference/narrowingPastLastAssignment.types
index 99cde6a0fd2e2..18dce42399162 100644
--- a/tests/baselines/reference/narrowingPastLastAssignment.types
+++ b/tests/baselines/reference/narrowingPastLastAssignment.types
@@ -196,6 +196,74 @@ function f5(x: string | number, cond: () => boolean) {
 >x : number
 }
 
+function f5a(cond: boolean) {
+>f5a : (cond: boolean) => void
+>cond : boolean
+
+    if (cond) {
+>cond : boolean
+
+        let x: number | undefined;
+>x : number | undefined
+
+        x = 1;
+>x = 1 : 1
+>x : number | undefined
+>1 : 1
+
+        action(() => { x /* number */ });
+>action(() => { x /* number */ }) : void
+>action : (f: Function) => void
+>() => { x /* number */ } : () => void
+>x : number
+    }
+    else {
+        let x: number | undefined;
+>x : number | undefined
+
+        x = 2;
+>x = 2 : 2
+>x : number | undefined
+>2 : 2
+
+        action(() => { x /* number */ });
+>action(() => { x /* number */ }) : void
+>action : (f: Function) => void
+>() => { x /* number */ } : () => void
+>x : number
+    }
+}
+
+function f5b() {
+>f5b : () => void
+
+    for (let x = 0; x < 10; x++) {
+>x : number
+>0 : 0
+>x < 10 : boolean
+>x : number
+>10 : 10
+>x++ : number
+>x : number
+
+        if (x === 1 || x === 2) {
+>x === 1 || x === 2 : boolean
+>x === 1 : boolean
+>x : number
+>1 : 1
+>x === 2 : boolean
+>x : number
+>2 : 2
+
+            action(() => { x /* 1 | 2 */ })
+>action(() => { x /* 1 | 2 */ }) : void
+>action : (f: Function) => void
+>() => { x /* 1 | 2 */ } : () => void
+>x : 1 | 2
+        }
+    }
+}
+
 // Implicit any variables have a known type following last assignment
 
 function f6() {
@@ -250,6 +318,56 @@ function f7() {
     }
 }
 
+// Narrowings are not preserved for global variables
+
+let g: string | number;
+>g : string | number
+
+g = "abc";
+>g = "abc" : "abc"
+>g : string | number
+>"abc" : "abc"
+
+action(() => { g /* string | number */ });
+>action(() => { g /* string | number */ }) : void
+>action : (f: Function) => void
+>() => { g /* string | number */ } : () => void
+>g : string | number
+
+// Narrowings are not preserved for exported namespace members
+
+namespace Foo {
+>Foo : typeof Foo
+
+    export let x: string | number;
+>x : string | number
+
+    x = "abc";
+>x = "abc" : "abc"
+>x : string | number
+>"abc" : "abc"
+
+    action(() => { x /* string | number */ });
+>action(() => { x /* string | number */ }) : void
+>action : (f: Function) => void
+>() => { x /* string | number */ } : () => void
+>x : string | number
+
+    let y: string | number;
+>y : string | number
+
+    y = "abc";
+>y = "abc" : "abc"
+>y : string | number
+>"abc" : "abc"
+
+    action(() => { y /* string */ });
+>action(() => { y /* string */ }) : void
+>action : (f: Function) => void
+>() => { y /* string */ } : () => void
+>y : string
+}
+
 // Repros from #35124
 
 function f10() {
@@ -308,12 +426,15 @@ function f11() {
 
 // Repro from #52104
 
-const fooMap: Map<string,Array<number>> = new Map()
+function f12() {
+>f12 : () => void
+
+    const fooMap: Map<string,Array<number>> = new Map()
 >fooMap : Map<string, number[]>
 >new Map() : Map<any, any>
 >Map : MapConstructor
 
-const values = [1, 2, 3, 4, 5];
+    const values = [1, 2, 3, 4, 5];
 >values : number[]
 >[1, 2, 3, 4, 5] : number[]
 >1 : 1
@@ -322,7 +443,7 @@ const values = [1, 2, 3, 4, 5];
 >4 : 4
 >5 : 5
 
-let foo = fooMap.get("a");
+    let foo = fooMap.get("a");
 >foo : number[] | undefined
 >fooMap.get("a") : number[] | undefined
 >fooMap.get : (key: string) => number[] | undefined
@@ -330,16 +451,16 @@ let foo = fooMap.get("a");
 >get : (key: string) => number[] | undefined
 >"a" : "a"
 
-if (foo == null) {
+    if (foo == null) {
 >foo == null : boolean
 >foo : number[] | undefined
 
-    foo = [];
+        foo = [];
 >foo = [] : never[]
 >foo : number[] | undefined
 >[] : never[]
-}
-values.forEach(v => foo.push(v));
+    }
+    values.forEach(v => foo.push(v));
 >values.forEach(v => foo.push(v)) : void
 >values.forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
 >values : number[]
@@ -351,4 +472,5 @@ values.forEach(v => foo.push(v));
 >foo : number[]
 >push : (...items: number[]) => number
 >v : number
+}
 
diff --git a/tests/baselines/reference/narrowingPastLastAssignmentInModule.symbols b/tests/baselines/reference/narrowingPastLastAssignmentInModule.symbols
new file mode 100644
index 0000000000000..c4b5b29a98b81
--- /dev/null
+++ b/tests/baselines/reference/narrowingPastLastAssignmentInModule.symbols
@@ -0,0 +1,70 @@
+//// [tests/cases/compiler/narrowingPastLastAssignmentInModule.ts] ////
+
+=== narrowingPastLastAssignmentInModule.ts ===
+function action(f: Function) {}
+>action : Symbol(action, Decl(narrowingPastLastAssignmentInModule.ts, 0, 0))
+>f : Symbol(f, Decl(narrowingPastLastAssignmentInModule.ts, 0, 16))
+>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --))
+
+// Narrowings are not preserved for exported mutable variables
+
+export let x1: string | number;
+>x1 : Symbol(x1, Decl(narrowingPastLastAssignmentInModule.ts, 4, 10))
+
+x1 = "abc";
+>x1 : Symbol(x1, Decl(narrowingPastLastAssignmentInModule.ts, 4, 10))
+
+action(() => { x1 /* string | number */ });
+>action : Symbol(action, Decl(narrowingPastLastAssignmentInModule.ts, 0, 0))
+>x1 : Symbol(x1, Decl(narrowingPastLastAssignmentInModule.ts, 4, 10))
+
+export { x2 };
+>x2 : Symbol(x2, Decl(narrowingPastLastAssignmentInModule.ts, 8, 8))
+
+let x2: string | number;
+>x2 : Symbol(x2, Decl(narrowingPastLastAssignmentInModule.ts, 9, 3))
+
+x2 = "abc";
+>x2 : Symbol(x2, Decl(narrowingPastLastAssignmentInModule.ts, 9, 3))
+
+action(() => { x2 /* string | number */ });
+>action : Symbol(action, Decl(narrowingPastLastAssignmentInModule.ts, 0, 0))
+>x2 : Symbol(x2, Decl(narrowingPastLastAssignmentInModule.ts, 9, 3))
+
+export { x3 as foo };
+>x3 : Symbol(x3, Decl(narrowingPastLastAssignmentInModule.ts, 14, 3))
+>foo : Symbol(foo, Decl(narrowingPastLastAssignmentInModule.ts, 13, 8))
+
+let x3: string | number;
+>x3 : Symbol(x3, Decl(narrowingPastLastAssignmentInModule.ts, 14, 3))
+
+x3 = "abc";
+>x3 : Symbol(x3, Decl(narrowingPastLastAssignmentInModule.ts, 14, 3))
+
+action(() => { x3 /* string | number */ });
+>action : Symbol(action, Decl(narrowingPastLastAssignmentInModule.ts, 0, 0))
+>x3 : Symbol(x3, Decl(narrowingPastLastAssignmentInModule.ts, 14, 3))
+
+let x4: string | number;
+>x4 : Symbol(x4, Decl(narrowingPastLastAssignmentInModule.ts, 18, 3))
+
+x4 = "abc";
+>x4 : Symbol(x4, Decl(narrowingPastLastAssignmentInModule.ts, 18, 3))
+
+action(() => { x4 /* string */ });
+>action : Symbol(action, Decl(narrowingPastLastAssignmentInModule.ts, 0, 0))
+>x4 : Symbol(x4, Decl(narrowingPastLastAssignmentInModule.ts, 18, 3))
+
+export default x4;
+>x4 : Symbol(x4, Decl(narrowingPastLastAssignmentInModule.ts, 18, 3))
+
+let x5: string | number;
+>x5 : Symbol(x5, Decl(narrowingPastLastAssignmentInModule.ts, 23, 3))
+
+x5 = "abc";
+>x5 : Symbol(x5, Decl(narrowingPastLastAssignmentInModule.ts, 23, 3))
+
+action(() => { x5 /* string */ });
+>action : Symbol(action, Decl(narrowingPastLastAssignmentInModule.ts, 0, 0))
+>x5 : Symbol(x5, Decl(narrowingPastLastAssignmentInModule.ts, 23, 3))
+
diff --git a/tests/baselines/reference/narrowingPastLastAssignmentInModule.types b/tests/baselines/reference/narrowingPastLastAssignmentInModule.types
new file mode 100644
index 0000000000000..ccb173341e07a
--- /dev/null
+++ b/tests/baselines/reference/narrowingPastLastAssignmentInModule.types
@@ -0,0 +1,89 @@
+//// [tests/cases/compiler/narrowingPastLastAssignmentInModule.ts] ////
+
+=== narrowingPastLastAssignmentInModule.ts ===
+function action(f: Function) {}
+>action : (f: Function) => void
+>f : Function
+
+// Narrowings are not preserved for exported mutable variables
+
+export let x1: string | number;
+>x1 : string | number
+
+x1 = "abc";
+>x1 = "abc" : "abc"
+>x1 : string | number
+>"abc" : "abc"
+
+action(() => { x1 /* string | number */ });
+>action(() => { x1 /* string | number */ }) : void
+>action : (f: Function) => void
+>() => { x1 /* string | number */ } : () => void
+>x1 : string | number
+
+export { x2 };
+>x2 : string | number
+
+let x2: string | number;
+>x2 : string | number
+
+x2 = "abc";
+>x2 = "abc" : "abc"
+>x2 : string | number
+>"abc" : "abc"
+
+action(() => { x2 /* string | number */ });
+>action(() => { x2 /* string | number */ }) : void
+>action : (f: Function) => void
+>() => { x2 /* string | number */ } : () => void
+>x2 : string | number
+
+export { x3 as foo };
+>x3 : string | number
+>foo : string | number
+
+let x3: string | number;
+>x3 : string | number
+
+x3 = "abc";
+>x3 = "abc" : "abc"
+>x3 : string | number
+>"abc" : "abc"
+
+action(() => { x3 /* string | number */ });
+>action(() => { x3 /* string | number */ }) : void
+>action : (f: Function) => void
+>() => { x3 /* string | number */ } : () => void
+>x3 : string | number
+
+let x4: string | number;
+>x4 : string | number
+
+x4 = "abc";
+>x4 = "abc" : "abc"
+>x4 : string | number
+>"abc" : "abc"
+
+action(() => { x4 /* string */ });
+>action(() => { x4 /* string */ }) : void
+>action : (f: Function) => void
+>() => { x4 /* string */ } : () => void
+>x4 : string
+
+export default x4;
+>x4 : string | number
+
+let x5: string | number;
+>x5 : string | number
+
+x5 = "abc";
+>x5 = "abc" : "abc"
+>x5 : string | number
+>"abc" : "abc"
+
+action(() => { x5 /* string */ });
+>action(() => { x5 /* string */ }) : void
+>action : (f: Function) => void
+>() => { x5 /* string */ } : () => void
+>x5 : string
+