Merge pull request #40778 from weswigham/spread-compact-literals

Always create optional properties when spreading objects conditionally
microsoft · Oct 12, 2020 · 4bf8ac2 · 4bf8ac2
2 parents a09a714 + e46a038
commit 4bf8ac2
Show file tree

Hide file tree

Showing 4 changed files with 6 additions and 182 deletions.
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -14436,23 +14436,17 @@ namespace ts {
             return isEmptyObjectType(type) || !!(type.flags & (TypeFlags.Null | TypeFlags.Undefined | TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.BigIntLike | TypeFlags.StringLike | TypeFlags.EnumLike | TypeFlags.NonPrimitive | TypeFlags.Index));
         }
 
-        function isSinglePropertyAnonymousObjectType(type: Type) {
-            return !!(type.flags & TypeFlags.Object) &&
-                !!(getObjectFlags(type) & ObjectFlags.Anonymous) &&
-                (length(getPropertiesOfType(type)) === 1 || every(getPropertiesOfType(type), p => !!(p.flags & SymbolFlags.Optional)));
-        }
-
         function tryMergeUnionOfObjectTypeAndEmptyObject(type: UnionType, readonly: boolean): Type | undefined {
             if (type.types.length === 2) {
                 const firstType = type.types[0];
                 const secondType = type.types[1];
                 if (every(type.types, isEmptyObjectTypeOrSpreadsIntoEmptyObject)) {
                     return isEmptyObjectType(firstType) ? firstType : isEmptyObjectType(secondType) ? secondType : emptyObjectType;
                 }
-                if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(firstType) && isSinglePropertyAnonymousObjectType(secondType)) {
+                if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(firstType)) {
                     return getAnonymousPartialType(secondType);
                 }
-                if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(secondType) && isSinglePropertyAnonymousObjectType(firstType)) {
+                if (isEmptyObjectTypeOrSpreadsIntoEmptyObject(secondType)) {
                     return getAnonymousPartialType(firstType);
                 }
             }

diff --git a/tests/baselines/reference/objectSpreadRepeatedComplexity.errors.txt b/tests/baselines/reference/objectSpreadRepeatedComplexity.errors.txt
diff --git a/tests/baselines/reference/objectSpreadRepeatedComplexity.types b/tests/baselines/reference/objectSpreadRepeatedComplexity.types
@@ -1,11 +1,11 @@
 === tests/cases/conformance/types/spread/objectSpreadRepeatedComplexity.ts ===
 function f(cnd: Record<number, boolean>){
->f : (cnd: Record<number, boolean>) => any
+>f : (cnd: Record<number, boolean>) => { prop20a?: number; prop20b?: number; prop19a?: number; prop19b?: number; prop18a?: number; prop18b?: number; prop17a?: number; prop17b?: number; prop16a?: number; prop16b?: number; prop15a?: number; prop15b?: number; prop14a?: number; prop14b?: number; prop13a?: number; prop13b?: number; prop12a?: number; prop12b?: number; prop11a?: number; prop11b?: number; prop10a?: number; prop10b?: number; prop9a?: number; prop9b?: number; prop8a?: number; prop8b?: number; prop7a?: number; prop7b?: number; prop6a?: number; prop6b?: number; prop5a?: number; prop5b?: number; prop4a?: number; prop4b?: number; prop3a?: number; prop3b?: number; prop0?: number; }
 >cnd : Record<number, boolean>
 
     // Type is a union of 2^(n-1) members, where n is the number of spread objects
     return {
->{        // Without this one, it collapses to {} ?        ...(cnd[1] &&            cnd[2] && {            prop0: 0,        }),        // With one prop each, it collapses to a single object (#34853?)        ...(cnd[3] && {            prop3a: 1,            prop3b: 1,        }),        ...(cnd[4] && {            prop4a: 1,            prop4b: 1,        }),        ...(cnd[5] && {            prop5a: 1,            prop5b: 1,        }),        ...(cnd[6] && {            prop6a: 1,            prop6b: 1,        }),        ...(cnd[7] && {            prop7a: 1,            prop7b: 1,        }),        ...(cnd[8] && {            prop8a: 1,            prop8b: 1,        }),        ...(cnd[9] && {            prop9a: 1,            prop9b: 1,        }),        ...(cnd[10] && {            prop10a: 1,            prop10b: 1,        }),        ...(cnd[11] && {            prop11a: 1,            prop11b: 1,        }),        ...(cnd[12] && {            prop12a: 1,            prop12b: 1,        }),        ...(cnd[13] && {            prop13a: 1,            prop13b: 1,        }),        ...(cnd[14] && {            prop14a: 1,            prop14b: 1,        }),        ...(cnd[15] && {            prop15a: 1,            prop15b: 1,        }),        ...(cnd[16] && {            prop16a: 1,            prop16b: 1,        }),        ...(cnd[17] && {            prop17a: 1,            prop17b: 1,        }),        ...(cnd[18] && {            prop18a: 1,            prop18b: 1,        }),        ...(cnd[19] && {            prop19a: 1,            prop19b: 1,        }),        ...(cnd[20] && {            prop20a: 1,            prop20b: 1,        }),    } : any
+>{        // Without this one, it collapses to {} ?        ...(cnd[1] &&            cnd[2] && {            prop0: 0,        }),        // With one prop each, it collapses to a single object (#34853?)        ...(cnd[3] && {            prop3a: 1,            prop3b: 1,        }),        ...(cnd[4] && {            prop4a: 1,            prop4b: 1,        }),        ...(cnd[5] && {            prop5a: 1,            prop5b: 1,        }),        ...(cnd[6] && {            prop6a: 1,            prop6b: 1,        }),        ...(cnd[7] && {            prop7a: 1,            prop7b: 1,        }),        ...(cnd[8] && {            prop8a: 1,            prop8b: 1,        }),        ...(cnd[9] && {            prop9a: 1,            prop9b: 1,        }),        ...(cnd[10] && {            prop10a: 1,            prop10b: 1,        }),        ...(cnd[11] && {            prop11a: 1,            prop11b: 1,        }),        ...(cnd[12] && {            prop12a: 1,            prop12b: 1,        }),        ...(cnd[13] && {            prop13a: 1,            prop13b: 1,        }),        ...(cnd[14] && {            prop14a: 1,            prop14b: 1,        }),        ...(cnd[15] && {            prop15a: 1,            prop15b: 1,        }),        ...(cnd[16] && {            prop16a: 1,            prop16b: 1,        }),        ...(cnd[17] && {            prop17a: 1,            prop17b: 1,        }),        ...(cnd[18] && {            prop18a: 1,            prop18b: 1,        }),        ...(cnd[19] && {            prop19a: 1,            prop19b: 1,        }),        ...(cnd[20] && {            prop20a: 1,            prop20b: 1,        }),    } : { prop20a?: number; prop20b?: number; prop19a?: number; prop19b?: number; prop18a?: number; prop18b?: number; prop17a?: number; prop17b?: number; prop16a?: number; prop16b?: number; prop15a?: number; prop15b?: number; prop14a?: number; prop14b?: number; prop13a?: number; prop13b?: number; prop12a?: number; prop12b?: number; prop11a?: number; prop11b?: number; prop10a?: number; prop10b?: number; prop9a?: number; prop9b?: number; prop8a?: number; prop8b?: number; prop7a?: number; prop7b?: number; prop6a?: number; prop6b?: number; prop5a?: number; prop5b?: number; prop4a?: number; prop4b?: number; prop3a?: number; prop3b?: number; prop0?: number; }
 
         // Without this one, it collapses to {} ?
         ...(cnd[1] &&

diff --git a/tests/baselines/reference/spreadOverwritesPropertyStrict.types b/tests/baselines/reference/spreadOverwritesPropertyStrict.types
@@ -78,14 +78,14 @@ function h(obj: { x: number } | { x: string }) {
 >obj : { x: number; } | { x: string; }
 }
 function i(b: boolean, t: { command: string, ok: string }) {
->i : (b: boolean, t: {    command: string;    ok: string;}) => { command: string; ok: string; } | { command: string; }
+>i : (b: boolean, t: {    command: string;    ok: string;}) => { command: string; ok?: string; }
 >b : boolean
 >t : { command: string; ok: string; }
 >command : string
 >ok : string
 
     return { command: "hi", ...(b ? t : {}) } // ok
->{ command: "hi", ...(b ? t : {}) } : { command: string; ok: string; } | { command: string; }
+>{ command: "hi", ...(b ? t : {}) } : { command: string; ok?: string; }
 >command : string
 >"hi" : "hi"
 >(b ? t : {}) : { command: string; ok: string; } | {}