Intersection with 'never' is always 'never'

src/compiler/checker.ts

@@ -7168,6 +7168,7 @@ namespace ts {
             containsAny?: boolean;
             containsUndefined?: boolean;
             containsNull?: boolean;
+            containsNever?: boolean;
             containsNonWideningType?: boolean;
             containsString?: boolean;
             containsNumber?: boolean;
@@ -7369,10 +7370,13 @@ namespace ts {
             else if (type.flags & TypeFlags.Any) {
                 typeSet.containsAny = true;
             }
+            else if (type.flags & TypeFlags.Never) {
+                typeSet.containsNever = true;
+            }
             else if (getObjectFlags(type) & ObjectFlags.Anonymous && isEmptyObjectType(type)) {
                 typeSet.containsEmptyObject = true;
             }
-            else if (!(type.flags & TypeFlags.Never) && (strictNullChecks || !(type.flags & TypeFlags.Nullable)) && !contains(typeSet, type)) {
+            else if ((strictNullChecks || !(type.flags & TypeFlags.Nullable)) && !contains(typeSet, type)) {
                 if (type.flags & TypeFlags.Object) {
                     typeSet.containsObjectType = true;
                 }
@@ -7410,6 +7414,9 @@ namespace ts {
             }
             const typeSet = [] as TypeSet;
             addTypesToIntersection(typeSet, types);
+            if (typeSet.containsNever) {
+                return neverType;
+            }
             if (typeSet.containsAny) {
                 return anyType;
             }

tests/baselines/reference/neverUnionIntersection.js

@@ -0,0 +1,17 @@
+//// [neverUnionIntersection.ts]
+type T01 = string | never;
+type T02 = string & never;
+type T03 = string | number | never;
+type T04 = string & number & never;
+type T05 = any | never;
+type T06 = any & never;
+type T07 = undefined | never;
+type T08 = undefined & never;
+type T09 = null | never;
+type T10 = null & never;
+type T11 = { a: string } | never;
+type T12 = { a: string } & never;
+
+
+//// [neverUnionIntersection.js]
+"use strict";

tests/baselines/reference/neverUnionIntersection.symbols

@@ -0,0 +1,39 @@
+=== tests/cases/conformance/types/never/neverUnionIntersection.ts ===
+type T01 = string | never;
+>T01 : Symbol(T01, Decl(neverUnionIntersection.ts, 0, 0))
+
+type T02 = string & never;
+>T02 : Symbol(T02, Decl(neverUnionIntersection.ts, 0, 26))
+
+type T03 = string | number | never;
+>T03 : Symbol(T03, Decl(neverUnionIntersection.ts, 1, 26))
+
+type T04 = string & number & never;
+>T04 : Symbol(T04, Decl(neverUnionIntersection.ts, 2, 35))
+
+type T05 = any | never;
+>T05 : Symbol(T05, Decl(neverUnionIntersection.ts, 3, 35))
+
+type T06 = any & never;
+>T06 : Symbol(T06, Decl(neverUnionIntersection.ts, 4, 23))
+
+type T07 = undefined | never;
+>T07 : Symbol(T07, Decl(neverUnionIntersection.ts, 5, 23))
+
+type T08 = undefined & never;
+>T08 : Symbol(T08, Decl(neverUnionIntersection.ts, 6, 29))
+
+type T09 = null | never;
+>T09 : Symbol(T09, Decl(neverUnionIntersection.ts, 7, 29))
+
+type T10 = null & never;
+>T10 : Symbol(T10, Decl(neverUnionIntersection.ts, 8, 24))
+
+type T11 = { a: string } | never;
+>T11 : Symbol(T11, Decl(neverUnionIntersection.ts, 9, 24))
+>a : Symbol(a, Decl(neverUnionIntersection.ts, 10, 12))
+
+type T12 = { a: string } & never;
+>T12 : Symbol(T12, Decl(neverUnionIntersection.ts, 10, 33))
+>a : Symbol(a, Decl(neverUnionIntersection.ts, 11, 12))
+

tests/baselines/reference/neverUnionIntersection.types

@@ -0,0 +1,41 @@
+=== tests/cases/conformance/types/never/neverUnionIntersection.ts ===
+type T01 = string | never;
+>T01 : string
+
+type T02 = string & never;
+>T02 : never
+
+type T03 = string | number | never;
+>T03 : T03
+
+type T04 = string & number & never;
+>T04 : never
+
+type T05 = any | never;
+>T05 : any
+
+type T06 = any & never;
+>T06 : never
+
+type T07 = undefined | never;
+>T07 : undefined
+
+type T08 = undefined & never;
+>T08 : never
+
+type T09 = null | never;
+>T09 : null
+>null : null
+
+type T10 = null & never;
+>T10 : never
+>null : null
+
+type T11 = { a: string } | never;
+>T11 : { a: string; }
+>a : string
+
+type T12 = { a: string } & never;
+>T12 : never
+>a : string
+

tests/cases/conformance/types/never/neverUnionIntersection.ts

@@ -0,0 +1,14 @@
+// @strict: true
+
+type T01 = string | never;
+type T02 = string & never;
+type T03 = string | number | never;
+type T04 = string & number & never;
+type T05 = any | never;
+type T06 = any & never;
+type T07 = undefined | never;
+type T08 = undefined & never;
+type T09 = null | never;
+type T10 = null & never;
+type T11 = { a: string } | never;
+type T12 = { a: string } & never;