diff --git a/tests/baselines/reference/assertionTypePredicates1.errors.txt b/tests/baselines/reference/assertionTypePredicates1.errors.txt
index 91d2e869bd2..68253ff06b6 100644
--- a/tests/baselines/reference/assertionTypePredicates1.errors.txt
+++ b/tests/baselines/reference/assertionTypePredicates1.errors.txt
@@ -5,9 +5,12 @@ tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(121,15): error T
 tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(122,15): error TS1228: A type predicate is only allowed in return type position for functions and methods.
 tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(123,15): error TS1228: A type predicate is only allowed in return type position for functions and methods.
 tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(124,15): error TS1228: A type predicate is only allowed in return type position for functions and methods.
+tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(129,5): error TS2775: Control flow effects of calls to assertion and never-returning functions are reflected only when every variable or property referenced in the function expression is declared with an explicit type annotation.
+tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(131,5): error TS2776: Control flow effects of calls to assertion and never-returning functions are reflected only when the function expression is an identifier or qualified-name.
+tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(133,5): error TS2775: Control flow effects of calls to assertion and never-returning functions are reflected only when every variable or property referenced in the function expression is declared with an explicit type annotation.
 
 
-==== tests/cases/conformance/controlFlow/assertionTypePredicates1.ts (7 errors) ====
+==== tests/cases/conformance/controlFlow/assertionTypePredicates1.ts (10 errors) ====
     declare function isString(value: unknown): value is string;
     declare function isArrayOfStrings(value: unknown): value is string[];
     
@@ -147,4 +150,21 @@ tests/cases/conformance/controlFlow/assertionTypePredicates1.ts(124,15): error T
                   ~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1228: A type predicate is only allowed in return type position for functions and methods.
     }
+    
+    function f20(x: unknown) {
+        const assert = (value: unknown): asserts value => {}
+        assert(typeof x === "string");  // Error
+        ~~~~~~
+!!! error TS2775: Control flow effects of calls to assertion and never-returning functions are reflected only when every variable or property referenced in the function expression is declared with an explicit type annotation.
+        const a = [assert];
+        a[0](typeof x === "string");  // Error
+        ~~~~
+!!! error TS2776: Control flow effects of calls to assertion and never-returning functions are reflected only when the function expression is an identifier or qualified-name.
+        const t1 = new Test();
+        t1.assert(typeof x === "string");  // Error
+        ~~~~~~~~~
+!!! error TS2775: Control flow effects of calls to assertion and never-returning functions are reflected only when every variable or property referenced in the function expression is declared with an explicit type annotation.
+        const t2: Test = new Test();
+        t2.assert(typeof x === "string");
+    }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/assertionTypePredicates1.js b/tests/baselines/reference/assertionTypePredicates1.js
index ad21d116b73..145bb98bce9 100644
--- a/tests/baselines/reference/assertionTypePredicates1.js
+++ b/tests/baselines/reference/assertionTypePredicates1.js
@@ -124,6 +124,17 @@ declare class Wat {
     get p2(): asserts this is string;
     set p2(x: asserts this is string);
 }
+
+function f20(x: unknown) {
+    const assert = (value: unknown): asserts value => {}
+    assert(typeof x === "string");  // Error
+    const a = [assert];
+    a[0](typeof x === "string");  // Error
+    const t1 = new Test();
+    t1.assert(typeof x === "string");  // Error
+    const t2: Test = new Test();
+    t2.assert(typeof x === "string");
+}
 
 
 //// [assertionTypePredicates1.js]
@@ -250,6 +261,16 @@ var Test2 = /** @class */ (function (_super) {
     }
     return Test2;
 }(Test));
+function f20(x) {
+    var assert = function (value) { };
+    assert(typeof x === "string"); // Error
+    var a = [assert];
+    a[0](typeof x === "string"); // Error
+    var t1 = new Test();
+    t1.assert(typeof x === "string"); // Error
+    var t2 = new Test();
+    t2.assert(typeof x === "string");
+}
 
 
 //// [assertionTypePredicates1.d.ts]
@@ -287,3 +308,4 @@ declare class Wat {
     get p2(): asserts this is string;
     set p2(x: asserts this is string);
 }
+declare function f20(x: unknown): void;
diff --git a/tests/baselines/reference/assertionTypePredicates1.symbols b/tests/baselines/reference/assertionTypePredicates1.symbols
index c68a1926aff..af43ab29864 100644
--- a/tests/baselines/reference/assertionTypePredicates1.symbols
+++ b/tests/baselines/reference/assertionTypePredicates1.symbols
@@ -357,3 +357,46 @@ declare class Wat {
 >x : Symbol(x, Decl(assertionTypePredicates1.ts, 123, 11))
 }
 
+function f20(x: unknown) {
+>f20 : Symbol(f20, Decl(assertionTypePredicates1.ts, 124, 1))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 126, 13))
+
+    const assert = (value: unknown): asserts value => {}
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 127, 9))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 127, 20))
+>value : Symbol(value, Decl(assertionTypePredicates1.ts, 127, 20))
+
+    assert(typeof x === "string");  // Error
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 127, 9))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 126, 13))
+
+    const a = [assert];
+>a : Symbol(a, Decl(assertionTypePredicates1.ts, 129, 9))
+>assert : Symbol(assert, Decl(assertionTypePredicates1.ts, 127, 9))
+
+    a[0](typeof x === "string");  // Error
+>a : Symbol(a, Decl(assertionTypePredicates1.ts, 129, 9))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 126, 13))
+
+    const t1 = new Test();
+>t1 : Symbol(t1, Decl(assertionTypePredicates1.ts, 131, 9))
+>Test : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+
+    t1.assert(typeof x === "string");  // Error
+>t1.assert : Symbol(Test.assert, Decl(assertionTypePredicates1.ts, 78, 12))
+>t1 : Symbol(t1, Decl(assertionTypePredicates1.ts, 131, 9))
+>assert : Symbol(Test.assert, Decl(assertionTypePredicates1.ts, 78, 12))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 126, 13))
+
+    const t2: Test = new Test();
+>t2 : Symbol(t2, Decl(assertionTypePredicates1.ts, 133, 9))
+>Test : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+>Test : Symbol(Test, Decl(assertionTypePredicates1.ts, 76, 1))
+
+    t2.assert(typeof x === "string");
+>t2.assert : Symbol(Test.assert, Decl(assertionTypePredicates1.ts, 78, 12))
+>t2 : Symbol(t2, Decl(assertionTypePredicates1.ts, 133, 9))
+>assert : Symbol(Test.assert, Decl(assertionTypePredicates1.ts, 78, 12))
+>x : Symbol(x, Decl(assertionTypePredicates1.ts, 126, 13))
+}
+
diff --git a/tests/baselines/reference/assertionTypePredicates1.types b/tests/baselines/reference/assertionTypePredicates1.types
index f72ec641013..470478b3fe4 100644
--- a/tests/baselines/reference/assertionTypePredicates1.types
+++ b/tests/baselines/reference/assertionTypePredicates1.types
@@ -436,3 +436,66 @@ declare class Wat {
 >x : void
 }
 
+function f20(x: unknown) {
+>f20 : (x: unknown) => void
+>x : unknown
+
+    const assert = (value: unknown): asserts value => {}
+>assert : (value: unknown) => asserts value
+>(value: unknown): asserts value => {} : (value: unknown) => asserts value
+>value : unknown
+
+    assert(typeof x === "string");  // Error
+>assert(typeof x === "string") : void
+>assert : (value: unknown) => asserts value
+>typeof x === "string" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : unknown
+>"string" : "string"
+
+    const a = [assert];
+>a : ((value: unknown) => asserts value)[]
+>[assert] : ((value: unknown) => asserts value)[]
+>assert : (value: unknown) => asserts value
+
+    a[0](typeof x === "string");  // Error
+>a[0](typeof x === "string") : void
+>a[0] : (value: unknown) => asserts value
+>a : ((value: unknown) => asserts value)[]
+>0 : 0
+>typeof x === "string" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : unknown
+>"string" : "string"
+
+    const t1 = new Test();
+>t1 : Test
+>new Test() : Test
+>Test : typeof Test
+
+    t1.assert(typeof x === "string");  // Error
+>t1.assert(typeof x === "string") : void
+>t1.assert : (value: unknown) => asserts value
+>t1 : Test
+>assert : (value: unknown) => asserts value
+>typeof x === "string" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : unknown
+>"string" : "string"
+
+    const t2: Test = new Test();
+>t2 : Test
+>new Test() : Test
+>Test : typeof Test
+
+    t2.assert(typeof x === "string");
+>t2.assert(typeof x === "string") : void
+>t2.assert : (value: unknown) => asserts value
+>t2 : Test
+>assert : (value: unknown) => asserts value
+>typeof x === "string" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : unknown
+>"string" : "string"
+}
+
diff --git a/tests/baselines/reference/neverReturningFunctions1.errors.txt b/tests/baselines/reference/neverReturningFunctions1.errors.txt
index 5eb6659427c..5c6ba45ea4a 100644
--- a/tests/baselines/reference/neverReturningFunctions1.errors.txt
+++ b/tests/baselines/reference/neverReturningFunctions1.errors.txt
@@ -21,9 +21,11 @@ tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(139,9): error TS
 tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(141,5): error TS7027: Unreachable code detected.
 tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(148,9): error TS7027: Unreachable code detected.
 tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(153,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(159,5): error TS2775: Control flow effects of calls to assertion and never-returning functions are reflected only when every variable or property referenced in the function expression is declared with an explicit type annotation.
+tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(160,5): error TS2776: Control flow effects of calls to assertion and never-returning functions are reflected only when the function expression is an identifier or qualified-name.
 
 
-==== tests/cases/conformance/controlFlow/neverReturningFunctions1.ts (23 errors) ====
+==== tests/cases/conformance/controlFlow/neverReturningFunctions1.ts (25 errors) ====
     function fail(message?: string): never {
         throw new Error(message);
     }
@@ -225,6 +227,17 @@ tests/cases/conformance/controlFlow/neverReturningFunctions1.ts(153,5): error TS
 !!! error TS7027: Unreachable code detected.
     }
     
+    function f43() {
+        const fail = (): never => { throw new Error(); };
+        const f = [fail];
+        fail();  // Error
+        ~~~~
+!!! error TS2775: Control flow effects of calls to assertion and never-returning functions are reflected only when every variable or property referenced in the function expression is declared with an explicit type annotation.
+        f[0]();  // Error
+        ~~~~
+!!! error TS2776: Control flow effects of calls to assertion and never-returning functions are reflected only when the function expression is an identifier or qualified-name.
+    }
+    
     // Repro from #33582
     
     export interface Component<T extends object = any> {
diff --git a/tests/baselines/reference/neverReturningFunctions1.js b/tests/baselines/reference/neverReturningFunctions1.js
index a99cc51e06d..dc79d7733df 100644
--- a/tests/baselines/reference/neverReturningFunctions1.js
+++ b/tests/baselines/reference/neverReturningFunctions1.js
@@ -154,6 +154,13 @@ function f42(x: number) {
     x;  // Unreachable
 }
 
+function f43() {
+    const fail = (): never => { throw new Error(); };
+    const f = [fail];
+    fail();  // Error
+    f[0]();  // Error
+}
+
 // Repro from #33582
 
 export interface Component<T extends object = any> {
@@ -375,6 +382,12 @@ function f42(x) {
     }
     x; // Unreachable
 }
+function f43() {
+    var fail = function () { throw new Error(); };
+    var f = [fail];
+    fail(); // Error
+    f[0](); // Error
+}
 var Component = registerComponent('test-component', {
     schema: {
         myProperty: {
diff --git a/tests/baselines/reference/neverReturningFunctions1.symbols b/tests/baselines/reference/neverReturningFunctions1.symbols
index 2ec4c5f93d3..3dff8bef7e3 100644
--- a/tests/baselines/reference/neverReturningFunctions1.symbols
+++ b/tests/baselines/reference/neverReturningFunctions1.symbols
@@ -385,196 +385,214 @@ function f42(x: number) {
 >x : Symbol(x, Decl(neverReturningFunctions1.ts, 143, 13))
 }
 
+function f43() {
+>f43 : Symbol(f43, Decl(neverReturningFunctions1.ts, 153, 1))
+
+    const fail = (): never => { throw new Error(); };
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 156, 9))
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+
+    const f = [fail];
+>f : Symbol(f, Decl(neverReturningFunctions1.ts, 157, 9))
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 156, 9))
+
+    fail();  // Error
+>fail : Symbol(fail, Decl(neverReturningFunctions1.ts, 156, 9))
+
+    f[0]();  // Error
+>f : Symbol(f, Decl(neverReturningFunctions1.ts, 157, 9))
+}
+
 // Repro from #33582
 
 export interface Component<T extends object = any> {
->Component : Symbol(Component, Decl(neverReturningFunctions1.ts, 153, 1))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 157, 27))
+>Component : Symbol(Component, Decl(neverReturningFunctions1.ts, 160, 1))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 164, 27))
 
 	attrName?: string;
->attrName : Symbol(Component.attrName, Decl(neverReturningFunctions1.ts, 157, 52))
+>attrName : Symbol(Component.attrName, Decl(neverReturningFunctions1.ts, 164, 52))
 
 	data: T;
->data : Symbol(Component.data, Decl(neverReturningFunctions1.ts, 158, 19))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 157, 27))
+>data : Symbol(Component.data, Decl(neverReturningFunctions1.ts, 165, 19))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 164, 27))
 
 	dependencies?: string[];
->dependencies : Symbol(Component.dependencies, Decl(neverReturningFunctions1.ts, 159, 9))
+>dependencies : Symbol(Component.dependencies, Decl(neverReturningFunctions1.ts, 166, 9))
 
 	el: any;
->el : Symbol(Component.el, Decl(neverReturningFunctions1.ts, 160, 25))
+>el : Symbol(Component.el, Decl(neverReturningFunctions1.ts, 167, 25))
 
 	id: string;
->id : Symbol(Component.id, Decl(neverReturningFunctions1.ts, 161, 9))
+>id : Symbol(Component.id, Decl(neverReturningFunctions1.ts, 168, 9))
 
 	multiple?: boolean;
->multiple : Symbol(Component.multiple, Decl(neverReturningFunctions1.ts, 162, 12))
+>multiple : Symbol(Component.multiple, Decl(neverReturningFunctions1.ts, 169, 12))
 
 	name: string;
->name : Symbol(Component.name, Decl(neverReturningFunctions1.ts, 163, 20))
+>name : Symbol(Component.name, Decl(neverReturningFunctions1.ts, 170, 20))
 
 	schema: unknown;
->schema : Symbol(Component.schema, Decl(neverReturningFunctions1.ts, 164, 14))
+>schema : Symbol(Component.schema, Decl(neverReturningFunctions1.ts, 171, 14))
 
 	system: any;
->system : Symbol(Component.system, Decl(neverReturningFunctions1.ts, 165, 17))
+>system : Symbol(Component.system, Decl(neverReturningFunctions1.ts, 172, 17))
 
 	init(data?: T): void;
->init : Symbol(Component.init, Decl(neverReturningFunctions1.ts, 166, 13))
->data : Symbol(data, Decl(neverReturningFunctions1.ts, 168, 6))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 157, 27))
+>init : Symbol(Component.init, Decl(neverReturningFunctions1.ts, 173, 13))
+>data : Symbol(data, Decl(neverReturningFunctions1.ts, 175, 6))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 164, 27))
 
 	pause(): void;
->pause : Symbol(Component.pause, Decl(neverReturningFunctions1.ts, 168, 22))
+>pause : Symbol(Component.pause, Decl(neverReturningFunctions1.ts, 175, 22))
 
 	play(): void;
->play : Symbol(Component.play, Decl(neverReturningFunctions1.ts, 169, 15))
+>play : Symbol(Component.play, Decl(neverReturningFunctions1.ts, 176, 15))
 
 	remove(): void;
->remove : Symbol(Component.remove, Decl(neverReturningFunctions1.ts, 170, 14))
+>remove : Symbol(Component.remove, Decl(neverReturningFunctions1.ts, 177, 14))
 
 	tick?(time: number, timeDelta: number): void;
->tick : Symbol(Component.tick, Decl(neverReturningFunctions1.ts, 171, 16))
->time : Symbol(time, Decl(neverReturningFunctions1.ts, 172, 7))
->timeDelta : Symbol(timeDelta, Decl(neverReturningFunctions1.ts, 172, 20))
+>tick : Symbol(Component.tick, Decl(neverReturningFunctions1.ts, 178, 16))
+>time : Symbol(time, Decl(neverReturningFunctions1.ts, 179, 7))
+>timeDelta : Symbol(timeDelta, Decl(neverReturningFunctions1.ts, 179, 20))
 
 	update(oldData: T): void;
->update : Symbol(Component.update, Decl(neverReturningFunctions1.ts, 172, 46))
->oldData : Symbol(oldData, Decl(neverReturningFunctions1.ts, 173, 8))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 157, 27))
+>update : Symbol(Component.update, Decl(neverReturningFunctions1.ts, 179, 46))
+>oldData : Symbol(oldData, Decl(neverReturningFunctions1.ts, 180, 8))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 164, 27))
 
 	updateSchema?(): void;
->updateSchema : Symbol(Component.updateSchema, Decl(neverReturningFunctions1.ts, 173, 26))
+>updateSchema : Symbol(Component.updateSchema, Decl(neverReturningFunctions1.ts, 180, 26))
 
 	extendSchema(update: unknown): void;
->extendSchema : Symbol(Component.extendSchema, Decl(neverReturningFunctions1.ts, 174, 23))
->update : Symbol(update, Decl(neverReturningFunctions1.ts, 176, 14))
+>extendSchema : Symbol(Component.extendSchema, Decl(neverReturningFunctions1.ts, 181, 23))
+>update : Symbol(update, Decl(neverReturningFunctions1.ts, 183, 14))
 
 	flushToDOM(): void;
->flushToDOM : Symbol(Component.flushToDOM, Decl(neverReturningFunctions1.ts, 176, 37))
+>flushToDOM : Symbol(Component.flushToDOM, Decl(neverReturningFunctions1.ts, 183, 37))
 }
 
 export interface ComponentConstructor<T extends object> {
->ComponentConstructor : Symbol(ComponentConstructor, Decl(neverReturningFunctions1.ts, 178, 1))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 180, 38))
+>ComponentConstructor : Symbol(ComponentConstructor, Decl(neverReturningFunctions1.ts, 185, 1))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 187, 38))
 
 	new (el: unknown, attrValue: string, id: string): T & Component;
->el : Symbol(el, Decl(neverReturningFunctions1.ts, 181, 6))
->attrValue : Symbol(attrValue, Decl(neverReturningFunctions1.ts, 181, 18))
->id : Symbol(id, Decl(neverReturningFunctions1.ts, 181, 37))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 180, 38))
->Component : Symbol(Component, Decl(neverReturningFunctions1.ts, 153, 1))
+>el : Symbol(el, Decl(neverReturningFunctions1.ts, 188, 6))
+>attrValue : Symbol(attrValue, Decl(neverReturningFunctions1.ts, 188, 18))
+>id : Symbol(id, Decl(neverReturningFunctions1.ts, 188, 37))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 187, 38))
+>Component : Symbol(Component, Decl(neverReturningFunctions1.ts, 160, 1))
 
 	prototype: T & {
->prototype : Symbol(ComponentConstructor.prototype, Decl(neverReturningFunctions1.ts, 181, 65))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 180, 38))
+>prototype : Symbol(ComponentConstructor.prototype, Decl(neverReturningFunctions1.ts, 188, 65))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 187, 38))
 
 		name: string;
->name : Symbol(name, Decl(neverReturningFunctions1.ts, 182, 17))
+>name : Symbol(name, Decl(neverReturningFunctions1.ts, 189, 17))
 
 		system: unknown;
->system : Symbol(system, Decl(neverReturningFunctions1.ts, 183, 15))
+>system : Symbol(system, Decl(neverReturningFunctions1.ts, 190, 15))
 
 		play(): void;
->play : Symbol(play, Decl(neverReturningFunctions1.ts, 184, 18))
+>play : Symbol(play, Decl(neverReturningFunctions1.ts, 191, 18))
 
 		pause(): void;
->pause : Symbol(pause, Decl(neverReturningFunctions1.ts, 185, 15))
+>pause : Symbol(pause, Decl(neverReturningFunctions1.ts, 192, 15))
 
 	};
 }
 
 declare function registerComponent<T extends object>(
->registerComponent : Symbol(registerComponent, Decl(neverReturningFunctions1.ts, 188, 1))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 190, 35))
+>registerComponent : Symbol(registerComponent, Decl(neverReturningFunctions1.ts, 195, 1))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 197, 35))
 
     name: string,
->name : Symbol(name, Decl(neverReturningFunctions1.ts, 190, 53))
+>name : Symbol(name, Decl(neverReturningFunctions1.ts, 197, 53))
 
     component: ComponentDefinition<T>
->component : Symbol(component, Decl(neverReturningFunctions1.ts, 191, 17))
->ComponentDefinition : Symbol(ComponentDefinition, Decl(neverReturningFunctions1.ts, 193, 27))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 190, 35))
+>component : Symbol(component, Decl(neverReturningFunctions1.ts, 198, 17))
+>ComponentDefinition : Symbol(ComponentDefinition, Decl(neverReturningFunctions1.ts, 200, 27))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 197, 35))
 
 ): ComponentConstructor<T>;
->ComponentConstructor : Symbol(ComponentConstructor, Decl(neverReturningFunctions1.ts, 178, 1))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 190, 35))
+>ComponentConstructor : Symbol(ComponentConstructor, Decl(neverReturningFunctions1.ts, 185, 1))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 197, 35))
 
 export type ComponentDefinition<T extends object = object> = T & Partial<Component> & ThisType<T & Component>;
->ComponentDefinition : Symbol(ComponentDefinition, Decl(neverReturningFunctions1.ts, 193, 27))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 195, 32))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 195, 32))
+>ComponentDefinition : Symbol(ComponentDefinition, Decl(neverReturningFunctions1.ts, 200, 27))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 202, 32))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 202, 32))
 >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
->Component : Symbol(Component, Decl(neverReturningFunctions1.ts, 153, 1))
+>Component : Symbol(Component, Decl(neverReturningFunctions1.ts, 160, 1))
 >ThisType : Symbol(ThisType, Decl(lib.es5.d.ts, --, --))
->T : Symbol(T, Decl(neverReturningFunctions1.ts, 195, 32))
->Component : Symbol(Component, Decl(neverReturningFunctions1.ts, 153, 1))
+>T : Symbol(T, Decl(neverReturningFunctions1.ts, 202, 32))
+>Component : Symbol(Component, Decl(neverReturningFunctions1.ts, 160, 1))
 
 const Component = registerComponent('test-component', {
->Component : Symbol(Component, Decl(neverReturningFunctions1.ts, 153, 1), Decl(neverReturningFunctions1.ts, 197, 5))
->registerComponent : Symbol(registerComponent, Decl(neverReturningFunctions1.ts, 188, 1))
+>Component : Symbol(Component, Decl(neverReturningFunctions1.ts, 160, 1), Decl(neverReturningFunctions1.ts, 204, 5))
+>registerComponent : Symbol(registerComponent, Decl(neverReturningFunctions1.ts, 195, 1))
 
 	schema: {
->schema : Symbol(schema, Decl(neverReturningFunctions1.ts, 197, 55))
+>schema : Symbol(schema, Decl(neverReturningFunctions1.ts, 204, 55))
 
 		myProperty: {
->myProperty : Symbol(myProperty, Decl(neverReturningFunctions1.ts, 198, 10))
+>myProperty : Symbol(myProperty, Decl(neverReturningFunctions1.ts, 205, 10))
 
 			default: [],
->default : Symbol(default, Decl(neverReturningFunctions1.ts, 199, 15))
+>default : Symbol(default, Decl(neverReturningFunctions1.ts, 206, 15))
 
 			parse() {
->parse : Symbol(parse, Decl(neverReturningFunctions1.ts, 200, 15))
+>parse : Symbol(parse, Decl(neverReturningFunctions1.ts, 207, 15))
 
 				return [true];
 			}
 		},
 		string: { type: 'string' },
->string : Symbol(string, Decl(neverReturningFunctions1.ts, 204, 4))
->type : Symbol(type, Decl(neverReturningFunctions1.ts, 205, 11))
+>string : Symbol(string, Decl(neverReturningFunctions1.ts, 211, 4))
+>type : Symbol(type, Decl(neverReturningFunctions1.ts, 212, 11))
 
 		num: 0
->num : Symbol(num, Decl(neverReturningFunctions1.ts, 205, 29))
+>num : Symbol(num, Decl(neverReturningFunctions1.ts, 212, 29))
 
 	},
 	init() {
->init : Symbol(init, Decl(neverReturningFunctions1.ts, 207, 3))
+>init : Symbol(init, Decl(neverReturningFunctions1.ts, 214, 3))
 
 		this.data.num = 0;
->this.data : Symbol(Component.data, Decl(neverReturningFunctions1.ts, 158, 19))
->data : Symbol(Component.data, Decl(neverReturningFunctions1.ts, 158, 19))
+>this.data : Symbol(Component.data, Decl(neverReturningFunctions1.ts, 165, 19))
+>data : Symbol(Component.data, Decl(neverReturningFunctions1.ts, 165, 19))
 
 		this.el.setAttribute('custom-attribute', 'custom-value');
->this.el : Symbol(Component.el, Decl(neverReturningFunctions1.ts, 160, 25))
->el : Symbol(Component.el, Decl(neverReturningFunctions1.ts, 160, 25))
+>this.el : Symbol(Component.el, Decl(neverReturningFunctions1.ts, 167, 25))
+>el : Symbol(Component.el, Decl(neverReturningFunctions1.ts, 167, 25))
 
 	},
 	update() {},
->update : Symbol(update, Decl(neverReturningFunctions1.ts, 211, 3))
+>update : Symbol(update, Decl(neverReturningFunctions1.ts, 218, 3))
 
 	tick() {},
->tick : Symbol(tick, Decl(neverReturningFunctions1.ts, 212, 13))
+>tick : Symbol(tick, Decl(neverReturningFunctions1.ts, 219, 13))
 
 	remove() {},
->remove : Symbol(remove, Decl(neverReturningFunctions1.ts, 213, 11))
+>remove : Symbol(remove, Decl(neverReturningFunctions1.ts, 220, 11))
 
 	pause() {},
->pause : Symbol(pause, Decl(neverReturningFunctions1.ts, 214, 13))
+>pause : Symbol(pause, Decl(neverReturningFunctions1.ts, 221, 13))
 
 	play() {},
->play : Symbol(play, Decl(neverReturningFunctions1.ts, 215, 12))
+>play : Symbol(play, Decl(neverReturningFunctions1.ts, 222, 12))
 
 	multiply(f: number) {
->multiply : Symbol(multiply, Decl(neverReturningFunctions1.ts, 216, 11))
->f : Symbol(f, Decl(neverReturningFunctions1.ts, 218, 10))
+>multiply : Symbol(multiply, Decl(neverReturningFunctions1.ts, 223, 11))
+>f : Symbol(f, Decl(neverReturningFunctions1.ts, 225, 10))
 
 		// Reference to system because both were registered with the same name.
 		return f * this.data.num * this.system!.data.counter;
->f : Symbol(f, Decl(neverReturningFunctions1.ts, 218, 10))
->this.data : Symbol(Component.data, Decl(neverReturningFunctions1.ts, 158, 19))
->data : Symbol(Component.data, Decl(neverReturningFunctions1.ts, 158, 19))
->this.system : Symbol(Component.system, Decl(neverReturningFunctions1.ts, 165, 17))
->system : Symbol(Component.system, Decl(neverReturningFunctions1.ts, 165, 17))
+>f : Symbol(f, Decl(neverReturningFunctions1.ts, 225, 10))
+>this.data : Symbol(Component.data, Decl(neverReturningFunctions1.ts, 165, 19))
+>data : Symbol(Component.data, Decl(neverReturningFunctions1.ts, 165, 19))
+>this.system : Symbol(Component.system, Decl(neverReturningFunctions1.ts, 172, 17))
+>system : Symbol(Component.system, Decl(neverReturningFunctions1.ts, 172, 17))
 	}
 });
 
diff --git a/tests/baselines/reference/neverReturningFunctions1.types b/tests/baselines/reference/neverReturningFunctions1.types
index ed49d1841b8..9089630ab9a 100644
--- a/tests/baselines/reference/neverReturningFunctions1.types
+++ b/tests/baselines/reference/neverReturningFunctions1.types
@@ -437,6 +437,31 @@ function f42(x: number) {
 >x : number
 }
 
+function f43() {
+>f43 : () => void
+
+    const fail = (): never => { throw new Error(); };
+>fail : () => never
+>(): never => { throw new Error(); } : () => never
+>new Error() : Error
+>Error : ErrorConstructor
+
+    const f = [fail];
+>f : (() => never)[]
+>[fail] : (() => never)[]
+>fail : () => never
+
+    fail();  // Error
+>fail() : never
+>fail : () => never
+
+    f[0]();  // Error
+>f[0]() : never
+>f[0] : () => never
+>f : (() => never)[]
+>0 : 0
+}
+
 // Repro from #33582
 
 export interface Component<T extends object = any> {