Reduce intersections by discriminants

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

@@ -4131,6 +4131,7 @@ 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
         Synthetic = SyntheticProperty | SyntheticMethod,
         Discriminant = HasNonUniformType | HasLiteralType,
         Partial = ReadPartial | WritePartial
@@ -4338,16 +4339,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;
@@ -4459,6 +4460,12 @@ namespace ts {
         IsGenericIndexTypeComputed = 1 << 24, // IsGenericIndexType flag has been computed
         /* @internal */
         IsGenericIndexType = 1 << 25, // Union or intersection contains generic index type
+        /* @internal */
+        ContainsIntersections = 1 << 26, // Union contains intersections
+        /* @internal */
+        IsNeverIntersectionComputed = 1 << 26, // IsNeverLike flag has been computed
+        /* @internal */
+        IsNeverIntersection = 1 << 27, // Intersection reduces to never
         ClassOrInterface = Class | Interface,
         /* @internal */
         RequiresWidening = ContainsWideningType | ContainsObjectOrArrayLiteral,
@@ -4582,6 +4589,8 @@ namespace ts {
     }
 
     export interface UnionType extends UnionOrIntersectionType {
+        /* @internal */
+        resolvedReducedType: Type;
     }
 
     export interface IntersectionType extends UnionOrIntersectionType {

tests/baselines/reference/definiteAssignmentOfDestructuredVariable.types

@@ -18,20 +18,20 @@ class C<T extends Options> {
 >method : () => void
 
         let { a, b } = this.foo;
->a : T["a"]
+>a : T["a"] | undefined
 >b : T["b"]
 >this.foo : { [P in keyof T]: T[P]; }
 >this : this
 >foo : { [P in keyof T]: T[P]; }
 
         !(a && b);
->!(a && b) : false
->(a && b) : T["b"]
->a && b : T["b"]
->a : T["a"]
+>!(a && b) : boolean
+>(a && b) : T["b"] | undefined
+>a && b : T["b"] | undefined
+>a : T["a"] | undefined
 >b : T["b"]
 
         a;
->a : T["a"]
+>a : T["a"] | undefined
     }
 }

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;
@@ -144,8 +143,6 @@ tests/cases/conformance/types/union/discriminatedUnionTypes2.ts(132,11): error T
         }
         else {
             x.value;  // Error, x is never
-              ~~~~~
-!!! error TS2339: Property 'value' does not exist on type 'never'.
         }
     }
 

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,9 +356,9 @@ 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))
@@ -367,7 +367,9 @@ function foo1(x: RuntimeValue & { type: 'number' }) {
     }
     else {
         x.value;  // Error, x is never
+>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"
 
@@ -380,22 +380,22 @@ function foo1(x: RuntimeValue & { type: 'number' }) {
     }
     else {
         x.value;  // Error, x is never
->x.value : any
->x : never
->value : any
+>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/objectSpread.types

@@ -565,7 +565,7 @@ let overwriteId: { id: string, a: number, c: number, d: string } =
 >d : string
 
     f({ a: 1, id: true }, { c: 1, d: 'no' })
->f({ a: 1, id: true }, { c: 1, d: 'no' }) : { a: number; id: boolean; } & { c: number; d: string; } & { id: string; }
+>f({ a: 1, id: true }, { c: 1, d: 'no' }) : never
 >f : <T, U>(t: T, u: U) => T & U & { id: string; }
 >{ a: 1, id: true } : { a: number; id: true; }
 >a : number

tests/baselines/reference/strictNullNotNullIndexTypeNoLib.types

@@ -20,11 +20,11 @@ class Test<T extends A> {
         this.attrs.params!.name;
 >this.attrs.params!.name : any
 >this.attrs.params! : T["params"]
->this.attrs.params : T["params"]
+>this.attrs.params : T["params"] | undefined
 >this.attrs : Readonly<T>
 >this : this
 >attrs : Readonly<T>
->params : T["params"]
+>params : T["params"] | undefined
 >name : any
     }
 }
@@ -66,10 +66,10 @@ class Test2<T extends A> {
 
         return this.attrs.params!; // Return type should maintain relationship with `T` after being not-null-asserted, ideally
 >this.attrs.params! : T["params"]
->this.attrs.params : T["params"]
+>this.attrs.params : T["params"] | undefined
 >this.attrs : Readonly<T>
 >this : this
 >attrs : Readonly<T>
->params : T["params"]
+>params : T["params"] | undefined
     }
 }

tests/baselines/reference/strictNullNotNullIndexTypeShouldWork.types

@@ -17,11 +17,11 @@ class Test<T extends A> {
         this.attrs.params!.name;
 >this.attrs.params!.name : string
 >this.attrs.params! : NonNullable<T["params"]>
->this.attrs.params : T["params"]
+>this.attrs.params : T["params"] | undefined
 >this.attrs : Readonly<T>
 >this : this
 >attrs : Readonly<T>
->params : T["params"]
+>params : T["params"] | undefined
 >name : string
     }
 }
@@ -63,10 +63,10 @@ class Test2<T extends A> {
 
         return this.attrs.params!; // Return type should maintain relationship with `T` after being not-null-asserted, ideally
 >this.attrs.params! : NonNullable<T["params"]>
->this.attrs.params : T["params"]
+>this.attrs.params : T["params"] | undefined
 >this.attrs : Readonly<T>
 >this : this
 >attrs : Readonly<T>
->params : T["params"]
+>params : T["params"] | undefined
     }
 }

tests/baselines/reference/stringLiteralTypesAsTags01.types

@@ -93,6 +93,6 @@ if (!hasKind(x, "B")) {
 }
 else {
     let d = x;
->d : A & B
->x : A & B
+>d : never
+>x : never
 }

tests/baselines/reference/stringLiteralTypesAsTags02.types

@@ -88,6 +88,6 @@ if (!hasKind(x, "B")) {
 }
 else {
     let d = x;
->d : A & B
->x : A & B
+>d : never
+>x : never
 }

tests/baselines/reference/stringLiteralTypesAsTags03.types

@@ -92,6 +92,6 @@ if (!hasKind(x, "B")) {
 }
 else {
     let d = x;
->d : A & B
->x : A & B
+>d : never
+>x : never
 }

tests/baselines/reference/tsxUnionElementType1.errors.txt

@@ -15,5 +15,4 @@ tests/cases/conformance/jsx/file.tsx(12,10): error TS2322: Type 'true' is not as
     var SFCComp = SFC1 || SFC2;
     <SFCComp x />
              ~
-!!! error TS2322: Type 'true' is not assignable to type 'never'.
-!!! related TS6500 tests/cases/conformance/jsx/file.tsx:3:23: The expected type comes from property 'x' which is declared here on type 'IntrinsicAttributes & { x: number; } & { x: boolean; }'
+!!! error TS2322: Type 'true' is not assignable to type 'never'.

tests/baselines/reference/tsxUnionElementType2.errors.txt

@@ -15,5 +15,4 @@ tests/cases/conformance/jsx/file.tsx(12,10): error TS2322: Type 'string' is not
     var SFCComp = SFC1 || SFC2;
     <SFCComp x={"hi"}/>
              ~
-!!! error TS2322: Type 'string' is not assignable to type 'never'.
-!!! related TS6500 tests/cases/conformance/jsx/file.tsx:3:23: The expected type comes from property 'x' which is declared here on type 'IntrinsicAttributes & { x: number; } & { x: boolean; }'
+!!! error TS2322: Type 'string' is not assignable to type 'never'.

tests/baselines/reference/typeGuardsWithInstanceOf.errors.txt

@@ -0,0 +1,14 @@
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOf.ts(7,20): error TS2339: Property 'global' does not exist on type 'never'.
+
+
+==== tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOf.ts (1 errors) ====
+    interface I { global: string; }
+    var result: I;
+    var result2: I;
+
+    if (!(result instanceof RegExp)) {
+        result = result2;
+    } else if (!result.global) {
+                       ~~~~~~
+!!! error TS2339: Property 'global' does not exist on type 'never'.
+    }

tests/baselines/reference/typeGuardsWithInstanceOf.symbols

@@ -20,7 +20,5 @@ if (!(result instanceof RegExp)) {
 >result2 : Symbol(result2, Decl(typeGuardsWithInstanceOf.ts, 2, 3))
 
 } else if (!result.global) {
->result.global : Symbol(global, Decl(typeGuardsWithInstanceOf.ts, 0, 13), Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(typeGuardsWithInstanceOf.ts, 1, 3))
->global : Symbol(global, Decl(typeGuardsWithInstanceOf.ts, 0, 13), Decl(lib.es5.d.ts, --, --))
 }

tests/baselines/reference/typeGuardsWithInstanceOf.types

@@ -22,7 +22,7 @@ if (!(result instanceof RegExp)) {
 
 } else if (!result.global) {
 >!result.global : boolean
->result.global : never
->result : I & RegExp
->global : never
+>result.global : any
+>result : never
+>global : any
 }

tests/baselines/reference/typeVariableTypeGuards.types

@@ -16,12 +16,12 @@ class A<P extends Partial<Foo>> {
 >doSomething : () => void
 
         this.props.foo && this.props.foo()
->this.props.foo && this.props.foo() : void
->this.props.foo : P["foo"]
+>this.props.foo && this.props.foo() : void | undefined
+>this.props.foo : P["foo"] | undefined
 >this.props : Readonly<P>
 >this : this
 >props : Readonly<P>
->foo : P["foo"]
+>foo : P["foo"] | undefined
 >this.props.foo() : void
 >this.props.foo : () => void
 >this.props : Readonly<P>