Reduce intersections by discriminants

src/compiler/diagnosticMessages.json

@@ -2361,6 +2361,10 @@
         "category": "Error",
         "code": 2614
     },
+    "Type of property '{0}' circularly references itself in mapped type '{1}'.": {
+        "category": "Error",
+        "code": 2615
+    },
 
     "Cannot augment module '{0}' with value exports because it resolves to a non-module entity.": {
         "category": "Error",

src/compiler/factory.ts

@@ -1795,9 +1795,7 @@ namespace ts {
 
         const target = getTargetOfBindingOrAssignmentElement(bindingElement);
         if (target && isPropertyName(target)) {
-            return isComputedPropertyName(target) && isStringOrNumericLiteral(target.expression)
-                ? target.expression
-                : target;
+            return target;
         }
     }
 

src/compiler/transformers/classFields.ts

@@ -976,7 +976,7 @@ namespace ts {
             );
         }
 
-        function visitArrayAssignmentTarget(node: AssignmentPattern) {
+        function visitArrayAssignmentTarget(node: BindingOrAssignmentElement) {
             const target = getTargetOfBindingOrAssignmentElement(node);
             if (target && isPrivateIdentifierPropertyAccessExpression(target)) {
                 const wrapped = wrapPrivateIdentifierForDestructuringTarget(target);

src/compiler/types.ts

@@ -4136,6 +4136,9 @@ namespace ts {
         OptionalParameter = 1 << 14,        // Optional parameter
         RestParameter     = 1 << 15,        // Rest parameter
         DeferredType      = 1 << 16,        // Calculation of the type of this symbol is deferred due to processing costs, should be fetched with `getTypeOfSymbolWithDeferredType`
+        HasNeverType      = 1 << 17,        // Synthetic property with at least one never type in constituents
+        Mapped            = 1 << 18,        // Property of mapped type
+        StripOptional     = 1 << 19,        // Strip optionality in mapped property
         Synthetic = SyntheticProperty | SyntheticMethod,
         Discriminant = HasNonUniformType | HasLiteralType,
         Partial = ReadPartial | WritePartial
@@ -4146,6 +4149,12 @@ namespace ts {
         checkFlags: CheckFlags;
     }
 
+    /* @internal */
+    export interface MappedSymbol extends TransientSymbol {
+        mappedType: MappedType;
+        mapper: TypeMapper;
+    }
+
     /* @internal */
     export interface ReverseMappedSymbol extends TransientSymbol {
         propertyType: Type;
@@ -4343,16 +4352,16 @@ namespace ts {
         NotPrimitiveUnion = Any | Unknown | Enum | Void | Never | StructuredOrInstantiable,
         // The following flags are aggregated during union and intersection type construction
         /* @internal */
-        IncludesMask = Any | Unknown | Primitive | Never | Object | Union | NonPrimitive,
+        IncludesMask = Any | Unknown | Primitive | Never | Object | Union | Intersection | NonPrimitive,
         // The following flags are used for different purposes during union and intersection type construction
         /* @internal */
         IncludesStructuredOrInstantiable = TypeParameter,
         /* @internal */
-        IncludesNonWideningType = Intersection,
+        IncludesNonWideningType = Index,
         /* @internal */
-        IncludesWildcard = Index,
+        IncludesWildcard = IndexedAccess,
         /* @internal */
-        IncludesEmptyObject = IndexedAccess,
+        IncludesEmptyObject = Conditional,
     }
 
     export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
@@ -4468,6 +4477,12 @@ namespace ts {
         CouldContainTypeVariablesComputed = 1 << 26, // CouldContainTypeVariables flag has been computed
         /* @internal */
         CouldContainTypeVariables = 1 << 27, // Type could contain a type variable
+        /* @internal */
+        ContainsIntersections = 1 << 28, // Union contains intersections
+        /* @internal */
+        IsNeverIntersectionComputed = 1 << 28, // IsNeverLike flag has been computed
+        /* @internal */
+        IsNeverIntersection = 1 << 29, // Intersection reduces to never
         ClassOrInterface = Class | Interface,
         /* @internal */
         RequiresWidening = ContainsWideningType | ContainsObjectOrArrayLiteral,
@@ -4589,6 +4604,8 @@ namespace ts {
     }
 
     export interface UnionType extends UnionOrIntersectionType {
+        /* @internal */
+        resolvedReducedType: Type;
     }
 
     export interface IntersectionType extends UnionOrIntersectionType {

tests/baselines/reference/discriminatedUnionTypes2.errors.txt

@@ -2,10 +2,9 @@ tests/cases/conformance/types/union/discriminatedUnionTypes2.ts(27,30): error TS
   Object literal may only specify known properties, and 'c' does not exist in type '{ a: null; b: string; }'.
 tests/cases/conformance/types/union/discriminatedUnionTypes2.ts(32,11): error TS2339: Property 'b' does not exist on type '{ a: 0; b: string; } | { a: T; c: number; }'.
   Property 'b' does not exist on type '{ a: T; c: number; }'.
-tests/cases/conformance/types/union/discriminatedUnionTypes2.ts(132,11): error TS2339: Property 'value' does not exist on type 'never'.
 
 
-==== tests/cases/conformance/types/union/discriminatedUnionTypes2.ts (3 errors) ====
+==== tests/cases/conformance/types/union/discriminatedUnionTypes2.ts (2 errors) ====
     function f10(x : { kind: false, a: string } | { kind: true, b: string } | { kind: string, c: string }) {
         if (x.kind === false) {
             x.a;
@@ -143,9 +142,7 @@ tests/cases/conformance/types/union/discriminatedUnionTypes2.ts(132,11): error T
             x.value;  // number
         }
         else {
-            x.value;  // Error, x is never
-              ~~~~~
-!!! error TS2339: Property 'value' does not exist on type 'never'.
+            x.value;  // number
         }
     }
 

tests/baselines/reference/discriminatedUnionTypes2.js

@@ -130,7 +130,7 @@ function foo1(x: RuntimeValue & { type: 'number' }) {
         x.value;  // number
     }
     else {
-        x.value;  // Error, x is never
+        x.value;  // number
     }
 }
 
@@ -226,7 +226,7 @@ function foo1(x) {
         x.value; // number
     }
     else {
-        x.value; // Error, x is never
+        x.value; // number
     }
 }
 function foo2(x) {

tests/baselines/reference/discriminatedUnionTypes2.symbols

@@ -317,9 +317,9 @@ function f(problem: abc & (b | c)) {
 >c : Symbol(c, Decl(discriminatedUnionTypes2.ts, 104, 1))
 
     if (problem.type === 'b') {
->problem.type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 101, 10), Decl(discriminatedUnionTypes2.ts, 105, 10), Decl(discriminatedUnionTypes2.ts, 97, 10), Decl(discriminatedUnionTypes2.ts, 101, 10), Decl(discriminatedUnionTypes2.ts, 97, 10) ... and 5 more)
+>problem.type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 101, 10), Decl(discriminatedUnionTypes2.ts, 105, 10))
 >problem : Symbol(problem, Decl(discriminatedUnionTypes2.ts, 112, 11))
->type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 101, 10), Decl(discriminatedUnionTypes2.ts, 105, 10), Decl(discriminatedUnionTypes2.ts, 97, 10), Decl(discriminatedUnionTypes2.ts, 101, 10), Decl(discriminatedUnionTypes2.ts, 97, 10) ... and 5 more)
+>type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 101, 10), Decl(discriminatedUnionTypes2.ts, 105, 10))
 
         problem.name;
 >problem.name : Symbol(name, Decl(discriminatedUnionTypes2.ts, 102, 14))
@@ -356,18 +356,20 @@ function foo1(x: RuntimeValue & { type: 'number' }) {
 >type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 126, 33))
 
     if (x.type === 'number') {
->x.type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 122, 7), Decl(discriminatedUnionTypes2.ts, 126, 33), Decl(discriminatedUnionTypes2.ts, 123, 7), Decl(discriminatedUnionTypes2.ts, 126, 33), Decl(discriminatedUnionTypes2.ts, 124, 7) ... and 1 more)
+>x.type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 122, 7), Decl(discriminatedUnionTypes2.ts, 126, 33))
 >x : Symbol(x, Decl(discriminatedUnionTypes2.ts, 126, 14))
->type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 122, 7), Decl(discriminatedUnionTypes2.ts, 126, 33), Decl(discriminatedUnionTypes2.ts, 123, 7), Decl(discriminatedUnionTypes2.ts, 126, 33), Decl(discriminatedUnionTypes2.ts, 124, 7) ... and 1 more)
+>type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 122, 7), Decl(discriminatedUnionTypes2.ts, 126, 33))
 
         x.value;  // number
 >x.value : Symbol(value, Decl(discriminatedUnionTypes2.ts, 122, 23))
 >x : Symbol(x, Decl(discriminatedUnionTypes2.ts, 126, 14))
 >value : Symbol(value, Decl(discriminatedUnionTypes2.ts, 122, 23))
     }
     else {
-        x.value;  // Error, x is never
+        x.value;  // number
+>x.value : Symbol(value, Decl(discriminatedUnionTypes2.ts, 122, 23))
 >x : Symbol(x, Decl(discriminatedUnionTypes2.ts, 126, 14))
+>value : Symbol(value, Decl(discriminatedUnionTypes2.ts, 122, 23))
     }
 }
 
@@ -379,9 +381,9 @@ function foo2(x: RuntimeValue & ({ type: 'number' } | { type: 'string' })) {
 >type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 135, 55))
 
     if (x.type === 'number') {
->x.type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 122, 7), Decl(discriminatedUnionTypes2.ts, 135, 34), Decl(discriminatedUnionTypes2.ts, 122, 7), Decl(discriminatedUnionTypes2.ts, 135, 55), Decl(discriminatedUnionTypes2.ts, 123, 7) ... and 7 more)
+>x.type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 122, 7), Decl(discriminatedUnionTypes2.ts, 135, 34), Decl(discriminatedUnionTypes2.ts, 123, 7), Decl(discriminatedUnionTypes2.ts, 135, 55))
 >x : Symbol(x, Decl(discriminatedUnionTypes2.ts, 135, 14))
->type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 122, 7), Decl(discriminatedUnionTypes2.ts, 135, 34), Decl(discriminatedUnionTypes2.ts, 122, 7), Decl(discriminatedUnionTypes2.ts, 135, 55), Decl(discriminatedUnionTypes2.ts, 123, 7) ... and 7 more)
+>type : Symbol(type, Decl(discriminatedUnionTypes2.ts, 122, 7), Decl(discriminatedUnionTypes2.ts, 135, 34), Decl(discriminatedUnionTypes2.ts, 123, 7), Decl(discriminatedUnionTypes2.ts, 135, 55))
 
         x.value;  // number
 >x.value : Symbol(value, Decl(discriminatedUnionTypes2.ts, 122, 23))

tests/baselines/reference/discriminatedUnionTypes2.types

@@ -323,13 +323,13 @@ type abc = a | b | c;
 >abc : abc
 
 function f(problem: abc & (b | c)) {
->f : (problem: b | c | (a & b) | (a & c) | (b & c) | (c & b)) => void
->problem : b | c | (a & b) | (a & c) | (b & c) | (c & b)
+>f : (problem: b | c) => void
+>problem : b | c
 
     if (problem.type === 'b') {
 >problem.type === 'b' : boolean
 >problem.type : "b" | "c"
->problem : b | c | (a & b) | (a & c) | (b & c) | (c & b)
+>problem : b | c
 >type : "b" | "c"
 >'b' : "b"
 
@@ -362,14 +362,14 @@ type RuntimeValue =
 >value : boolean
 
 function foo1(x: RuntimeValue & { type: 'number' }) {
->foo1 : (x: ({ type: "number"; value: number; } & { type: "number"; }) | ({ type: "string"; value: string; } & { type: "number"; }) | ({ type: "boolean"; value: boolean; } & { type: "number"; })) => void
->x : ({ type: "number"; value: number; } & { type: "number"; }) | ({ type: "string"; value: string; } & { type: "number"; }) | ({ type: "boolean"; value: boolean; } & { type: "number"; })
+>foo1 : (x: { type: "number"; value: number; } & { type: "number"; }) => void
+>x : { type: "number"; value: number; } & { type: "number"; }
 >type : "number"
 
     if (x.type === 'number') {
 >x.type === 'number' : boolean
 >x.type : "number"
->x : ({ type: "number"; value: number; } & { type: "number"; }) | ({ type: "string"; value: string; } & { type: "number"; }) | ({ type: "boolean"; value: boolean; } & { type: "number"; })
+>x : { type: "number"; value: number; } & { type: "number"; }
 >type : "number"
 >'number' : "number"
 
@@ -379,23 +379,23 @@ function foo1(x: RuntimeValue & { type: 'number' }) {
 >value : number
     }
     else {
-        x.value;  // Error, x is never
->x.value : any
->x : never
->value : any
+        x.value;  // number
+>x.value : number
+>x : { type: "number"; value: number; } & { type: "number"; }
+>value : number
     }
 }
 
 function foo2(x: RuntimeValue & ({ type: 'number' } | { type: 'string' })) {
->foo2 : (x: ({ type: "number"; value: number; } & { type: "number"; }) | ({ type: "number"; value: number; } & { type: "string"; }) | ({ type: "string"; value: string; } & { type: "number"; }) | ({ type: "string"; value: string; } & { type: "string"; }) | ({ type: "boolean"; value: boolean; } & { type: "number"; }) | ({ type: "boolean"; value: boolean; } & { type: "string"; })) => void
->x : ({ type: "number"; value: number; } & { type: "number"; }) | ({ type: "number"; value: number; } & { type: "string"; }) | ({ type: "string"; value: string; } & { type: "number"; }) | ({ type: "string"; value: string; } & { type: "string"; }) | ({ type: "boolean"; value: boolean; } & { type: "number"; }) | ({ type: "boolean"; value: boolean; } & { type: "string"; })
+>foo2 : (x: ({ type: "number"; value: number; } & { type: "number"; }) | ({ type: "string"; value: string; } & { type: "string"; })) => void
+>x : ({ type: "number"; value: number; } & { type: "number"; }) | ({ type: "string"; value: string; } & { type: "string"; })
 >type : "number"
 >type : "string"
 
     if (x.type === 'number') {
 >x.type === 'number' : boolean
 >x.type : "string" | "number"
->x : ({ type: "number"; value: number; } & { type: "number"; }) | ({ type: "number"; value: number; } & { type: "string"; }) | ({ type: "string"; value: string; } & { type: "number"; }) | ({ type: "string"; value: string; } & { type: "string"; }) | ({ type: "boolean"; value: boolean; } & { type: "number"; }) | ({ type: "boolean"; value: boolean; } & { type: "string"; })
+>x : ({ type: "number"; value: number; } & { type: "number"; }) | ({ type: "string"; value: string; } & { type: "string"; })
 >type : "string" | "number"
 >'number' : "number"
 

tests/baselines/reference/intersectionReduction.errors.txt

@@ -1,8 +1,9 @@
-tests/cases/conformance/types/intersection/intersectionReduction.ts(40,1): error TS2322: Type 'any' is not assignable to type 'never'.
-tests/cases/conformance/types/intersection/intersectionReduction.ts(41,1): error TS2322: Type 'any' is not assignable to type 'never'.
+tests/cases/conformance/types/intersection/intersectionReduction.ts(38,4): error TS2339: Property 'kind' does not exist on type 'never'.
+tests/cases/conformance/types/intersection/intersectionReduction.ts(80,1): error TS2322: Type 'any' is not assignable to type 'never'.
+tests/cases/conformance/types/intersection/intersectionReduction.ts(81,1): error TS2322: Type 'any' is not assignable to type 'never'.
 
 
-==== tests/cases/conformance/types/intersection/intersectionReduction.ts (2 errors) ====
+==== tests/cases/conformance/types/intersection/intersectionReduction.ts (3 errors) ====
     declare const sym1: unique symbol;
     declare const sym2: unique symbol;
 
@@ -35,6 +36,48 @@ tests/cases/conformance/types/intersection/intersectionReduction.ts(41,1): error
     type X6 = X | symbol & string;
     type X7 = X | void & string;
 
+    type A = { kind: 'a', foo: string };
+    type B = { kind: 'b', foo: number };
+    type C = { kind: 'c', foo: number };
+
+    declare let ab: A & B;
+    ab.kind;  // Error
+       ~~~~
+!!! error TS2339: Property 'kind' does not exist on type 'never'.
+
+    declare let x: A | (B & C);  // A
+    let a: A = x;
+
+    type AB = A & B;  // never
+    type BC = B & C;  // never
+
+    type U1 = Partial<A & B>;  // never
+    type U2 = Readonly<A & B>;  // never
+    type U3 = (A & B)['kind'];  // never
+    type U4 = A & B | B & C;  // never
+    type U5 = A | B & C;  // A
+
+    type K1 = keyof (A & B);  // string | number | symbol
+    type K2 = keyof A | keyof B;  // 'kind' | 'foo'
+
+    type Merge1<T, U> = { [P in keyof (T & U)]: P extends keyof T ? T[P] : U[P & keyof U] }
+    type Merge2<T, U> = { [P in keyof T | keyof U]: P extends keyof T ? T[P] : U[P & keyof U] }
+
+    type M1 = { a: 1, b: 2 } & { a: 2, c: 3 };  // never
+    type M2 = Merge1<{ a: 1, b: 2 }, { a: 2, c: 3 }>;  // {}
+    type M3 = Merge2<{ a: 1, b: 2 }, { a: 2, c: 3 }>;  // { a: 1, b: 2, c: 3 }
+
+    type D = { kind: 'd', foo: unknown };
+    type E = { kind: 'e', foo: unknown };
+
+    declare function f10<T>(x: { foo: T }): T;
+
+    declare let a1: A | D;
+    declare let a2: A | D & E;
+
+    let r1 = f10(a1);  // unknown
+    let r2 = f10(a2);  // string
+
     // Repro from #31663
 
     const x1 = { a: 'foo', b: 42 };
@@ -63,4 +106,16 @@ tests/cases/conformance/types/intersection/intersectionReduction.ts(41,1): error
 
     t1 = t2;
     t2 = t1;
+
+    // Repro from #36736
+
+    const f1 = (t: "a" | ("b" & "c")): "a" => t;
+
+    type Container<Type extends string> = {
+        type: Type;
+    }
+
+    const f2 = (t: Container<"a"> | (Container<"b"> & Container<"c">)): Container<"a"> => t;
+    const f3 = (t: Container<"a"> | (Container<"b"> & { dataB: boolean } & Container<"a">)): Container<"a"> => t;
+    const f4 = (t: number | (Container<"b"> & { dataB: boolean } & Container<"a">)): number => t;