Merge pull request #18965 from Microsoft/set-symbol-on-union-of-spreads

sandersn · web-flow · commit 461e29bbd8ca · 2017-10-11T13:25:45.000-07:00
Set symbol on union that is returned from `getSpreadType`
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -7878,7 +7878,7 @@ namespace ts {
          * this function should be called in a left folding style, with left = previous result of getSpreadType
          * and right = the new element to be spread.
          */
-        function getSpreadType(left: Type, right: Type): Type {
+        function getSpreadType(left: Type, right: Type, symbol: Symbol, propagatedFlags: TypeFlags): Type {
             if (left.flags & TypeFlags.Any || right.flags & TypeFlags.Any) {
                 return anyType;
             }
@@ -7889,10 +7889,10 @@ namespace ts {
                 return left;
             }
             if (left.flags & TypeFlags.Union) {
-                return mapType(left, t => getSpreadType(t, right));
+                return mapType(left, t => getSpreadType(t, right, symbol, propagatedFlags));
             }
             if (right.flags & TypeFlags.Union) {
-                return mapType(right, t => getSpreadType(left, t));
+                return mapType(right, t => getSpreadType(left, t, symbol, propagatedFlags));
             }
             if (right.flags & TypeFlags.NonPrimitive) {
                 return nonPrimitiveType;
@@ -7950,7 +7950,13 @@ namespace ts {
                     members.set(leftProp.escapedName, getNonReadonlySymbol(leftProp));
                 }
             }
-            return createAnonymousType(undefined, members, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);
+
+            const spread = createAnonymousType(undefined, members, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);
+            spread.flags |= propagatedFlags;
+            spread.flags |= TypeFlags.FreshLiteral;
+            (spread as ObjectType).objectFlags |= ObjectFlags.ObjectLiteral;
+            spread.symbol = symbol;
+            return spread;
         }
 
         function getNonReadonlySymbol(prop: Symbol) {
@@ -13914,7 +13920,7 @@ namespace ts {
                         checkExternalEmitHelpers(memberDecl, ExternalEmitHelpers.Assign);
                     }
                     if (propertiesArray.length > 0) {
-                        spread = getSpreadType(spread, createObjectLiteralType());
+                        spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags);
                         propertiesArray = [];
                         propertiesTable = createSymbolTable();
                         hasComputedStringProperty = false;
@@ -13926,7 +13932,7 @@ namespace ts {
                         error(memberDecl, Diagnostics.Spread_types_may_only_be_created_from_object_types);
                         return unknownType;
                     }
-                    spread = getSpreadType(spread, type);
+                    spread = getSpreadType(spread, type, node.symbol, propagatedFlags);
                     offset = i + 1;
                     continue;
                 }
@@ -13971,14 +13977,7 @@ namespace ts {
 
             if (spread !== emptyObjectType) {
                 if (propertiesArray.length > 0) {
-                    spread = getSpreadType(spread, createObjectLiteralType());
-                }
-                if (spread.flags & TypeFlags.Object) {
-                    // only set the symbol and flags if this is a (fresh) object type
-                    spread.flags |= propagatedFlags;
-                    spread.flags |= TypeFlags.FreshLiteral;
-                    (spread as ObjectType).objectFlags |= ObjectFlags.ObjectLiteral;
-                    spread.symbol = node.symbol;
+                    spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags);
                 }
                 return spread;
             }
@@ -14099,7 +14098,7 @@ namespace ts {
                 else {
                     Debug.assert(attributeDecl.kind === SyntaxKind.JsxSpreadAttribute);
                     if (attributesArray.length > 0) {
-                        spread = getSpreadType(spread, createJsxAttributesType(attributes.symbol, attributesTable));
+                        spread = getSpreadType(spread, createJsxAttributesType(attributes.symbol, attributesTable), openingLikeElement.symbol, /*propagatedFlags*/ 0);
                         attributesArray = [];
                         attributesTable = createSymbolTable();
                     }
@@ -14108,7 +14107,7 @@ namespace ts {
                         hasSpreadAnyType = true;
                     }
                     if (isValidSpreadType(exprType)) {
-                        spread = getSpreadType(spread, exprType);
+                        spread = getSpreadType(spread, exprType, openingLikeElement.symbol, /*propagatedFlags*/ 0);
                     }
                     else {
                         typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType;
@@ -14119,7 +14118,7 @@ namespace ts {
             if (!hasSpreadAnyType) {
                 if (spread !== emptyObjectType) {
                     if (attributesArray.length > 0) {
-                        spread = getSpreadType(spread, createJsxAttributesType(attributes.symbol, attributesTable));
+                        spread = getSpreadType(spread, createJsxAttributesType(attributes.symbol, attributesTable), openingLikeElement.symbol, /*propagatedFlags*/ 0);
                     }
                     attributesArray = getPropertiesOfType(spread);
                 }
diff --git a/tests/baselines/reference/objectSpreadIndexSignature.errors.txt b/tests/baselines/reference/objectSpreadIndexSignature.errors.txt
@@ -0,0 +1,19 @@
+tests/cases/conformance/types/spread/objectSpreadIndexSignature.ts(6,1): error TS7017: Element implicitly has an 'any' type because type '{ b: number; a: number; }' has no index signature.
+
+
+==== tests/cases/conformance/types/spread/objectSpreadIndexSignature.ts (1 errors) ====
+    declare let indexed1: { [n: string]: number; a: number; };
+    declare let indexed2: { [n: string]: boolean; c: boolean; };
+    declare let indexed3: { [n: string]: number };
+    let i = { ...indexed1, b: 11 };
+    // only indexed has indexer, so i[101]: any
+    i[101];
+    ~~~~~~
+!!! error TS7017: Element implicitly has an 'any' type because type '{ b: number; a: number; }' has no index signature.
+    let ii = { ...indexed1, ...indexed2 };
+    // both have indexer, so i[1001]: number | boolean
+    ii[1001];
+    
+    declare const b: boolean;
+    indexed3 = { ...b ? indexed3 : undefined };
+    
diff --git a/tests/baselines/reference/objectSpreadIndexSignature.js b/tests/baselines/reference/objectSpreadIndexSignature.js
@@ -1,23 +1,20 @@
 //// [objectSpreadIndexSignature.ts]
-interface Indexed {
-    [n: string]: number;
-    a: number;
-}
-interface Indexed2 {
-    [n: string]: boolean;
-    c: boolean;
-}
-let indexed: Indexed;
-let indexed2: Indexed2;
-let i = { ...indexed, b: 11 };
+declare let indexed1: { [n: string]: number; a: number; };
+declare let indexed2: { [n: string]: boolean; c: boolean; };
+declare let indexed3: { [n: string]: number };
+let i = { ...indexed1, b: 11 };
 // only indexed has indexer, so i[101]: any
 i[101];
-let ii = { ...indexed, ...indexed2 };
+let ii = { ...indexed1, ...indexed2 };
 // both have indexer, so i[1001]: number | boolean
 ii[1001];
+
+declare const b: boolean;
+indexed3 = { ...b ? indexed3 : undefined };
 
 
 //// [objectSpreadIndexSignature.js]
+"use strict";
 var __assign = (this && this.__assign) || Object.assign || function(t) {
     for (var s, i = 1, n = arguments.length; i < n; i++) {
         s = arguments[i];
@@ -26,11 +23,10 @@ var __assign = (this && this.__assign) || Object.assign || function(t) {
     }
     return t;
 };
-var indexed;
-var indexed2;
-var i = __assign({}, indexed, { b: 11 });
+var i = __assign({}, indexed1, { b: 11 });
 // only indexed has indexer, so i[101]: any
 i[101];
-var ii = __assign({}, indexed, indexed2);
+var ii = __assign({}, indexed1, indexed2);
 // both have indexer, so i[1001]: number | boolean
 ii[1001];
+indexed3 = __assign({}, b ? indexed3 : undefined);
diff --git a/tests/baselines/reference/objectSpreadIndexSignature.symbols b/tests/baselines/reference/objectSpreadIndexSignature.symbols
@@ -1,45 +1,42 @@
 === tests/cases/conformance/types/spread/objectSpreadIndexSignature.ts ===
-interface Indexed {
->Indexed : Symbol(Indexed, Decl(objectSpreadIndexSignature.ts, 0, 0))
+declare let indexed1: { [n: string]: number; a: number; };
+>indexed1 : Symbol(indexed1, Decl(objectSpreadIndexSignature.ts, 0, 11))
+>n : Symbol(n, Decl(objectSpreadIndexSignature.ts, 0, 25))
+>a : Symbol(a, Decl(objectSpreadIndexSignature.ts, 0, 44))
 
-    [n: string]: number;
->n : Symbol(n, Decl(objectSpreadIndexSignature.ts, 1, 5))
+declare let indexed2: { [n: string]: boolean; c: boolean; };
+>indexed2 : Symbol(indexed2, Decl(objectSpreadIndexSignature.ts, 1, 11))
+>n : Symbol(n, Decl(objectSpreadIndexSignature.ts, 1, 25))
+>c : Symbol(c, Decl(objectSpreadIndexSignature.ts, 1, 45))
 
-    a: number;
->a : Symbol(Indexed.a, Decl(objectSpreadIndexSignature.ts, 1, 24))
-}
-interface Indexed2 {
->Indexed2 : Symbol(Indexed2, Decl(objectSpreadIndexSignature.ts, 3, 1))
+declare let indexed3: { [n: string]: number };
+>indexed3 : Symbol(indexed3, Decl(objectSpreadIndexSignature.ts, 2, 11))
+>n : Symbol(n, Decl(objectSpreadIndexSignature.ts, 2, 25))
 
-    [n: string]: boolean;
->n : Symbol(n, Decl(objectSpreadIndexSignature.ts, 5, 5))
-
-    c: boolean;
->c : Symbol(Indexed2.c, Decl(objectSpreadIndexSignature.ts, 5, 25))
-}
-let indexed: Indexed;
->indexed : Symbol(indexed, Decl(objectSpreadIndexSignature.ts, 8, 3))
->Indexed : Symbol(Indexed, Decl(objectSpreadIndexSignature.ts, 0, 0))
-
-let indexed2: Indexed2;
->indexed2 : Symbol(indexed2, Decl(objectSpreadIndexSignature.ts, 9, 3))
->Indexed2 : Symbol(Indexed2, Decl(objectSpreadIndexSignature.ts, 3, 1))
-
-let i = { ...indexed, b: 11 };
->i : Symbol(i, Decl(objectSpreadIndexSignature.ts, 10, 3))
->indexed : Symbol(indexed, Decl(objectSpreadIndexSignature.ts, 8, 3))
->b : Symbol(b, Decl(objectSpreadIndexSignature.ts, 10, 21))
+let i = { ...indexed1, b: 11 };
+>i : Symbol(i, Decl(objectSpreadIndexSignature.ts, 3, 3))
+>indexed1 : Symbol(indexed1, Decl(objectSpreadIndexSignature.ts, 0, 11))
+>b : Symbol(b, Decl(objectSpreadIndexSignature.ts, 3, 22))
 
 // only indexed has indexer, so i[101]: any
 i[101];
->i : Symbol(i, Decl(objectSpreadIndexSignature.ts, 10, 3))
+>i : Symbol(i, Decl(objectSpreadIndexSignature.ts, 3, 3))
 
-let ii = { ...indexed, ...indexed2 };
->ii : Symbol(ii, Decl(objectSpreadIndexSignature.ts, 13, 3))
->indexed : Symbol(indexed, Decl(objectSpreadIndexSignature.ts, 8, 3))
->indexed2 : Symbol(indexed2, Decl(objectSpreadIndexSignature.ts, 9, 3))
+let ii = { ...indexed1, ...indexed2 };
+>ii : Symbol(ii, Decl(objectSpreadIndexSignature.ts, 6, 3))
+>indexed1 : Symbol(indexed1, Decl(objectSpreadIndexSignature.ts, 0, 11))
+>indexed2 : Symbol(indexed2, Decl(objectSpreadIndexSignature.ts, 1, 11))
 
 // both have indexer, so i[1001]: number | boolean
 ii[1001];
->ii : Symbol(ii, Decl(objectSpreadIndexSignature.ts, 13, 3))
+>ii : Symbol(ii, Decl(objectSpreadIndexSignature.ts, 6, 3))
+
+declare const b: boolean;
+>b : Symbol(b, Decl(objectSpreadIndexSignature.ts, 10, 13))
+
+indexed3 = { ...b ? indexed3 : undefined };
+>indexed3 : Symbol(indexed3, Decl(objectSpreadIndexSignature.ts, 2, 11))
+>b : Symbol(b, Decl(objectSpreadIndexSignature.ts, 10, 13))
+>indexed3 : Symbol(indexed3, Decl(objectSpreadIndexSignature.ts, 2, 11))
+>undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/objectSpreadIndexSignature.types b/tests/baselines/reference/objectSpreadIndexSignature.types
@@ -1,34 +1,22 @@
 === tests/cases/conformance/types/spread/objectSpreadIndexSignature.ts ===
-interface Indexed {
->Indexed : Indexed
-
-    [n: string]: number;
+declare let indexed1: { [n: string]: number; a: number; };
+>indexed1 : { [n: string]: number; a: number; }
 >n : string
-
-    a: number;
 >a : number
-}
-interface Indexed2 {
->Indexed2 : Indexed2
 
-    [n: string]: boolean;
+declare let indexed2: { [n: string]: boolean; c: boolean; };
+>indexed2 : { [n: string]: boolean; c: boolean; }
 >n : string
-
-    c: boolean;
 >c : boolean
-}
-let indexed: Indexed;
->indexed : Indexed
->Indexed : Indexed
 
-let indexed2: Indexed2;
->indexed2 : Indexed2
->Indexed2 : Indexed2
+declare let indexed3: { [n: string]: number };
+>indexed3 : { [n: string]: number; }
+>n : string
 
-let i = { ...indexed, b: 11 };
+let i = { ...indexed1, b: 11 };
 >i : { b: number; a: number; }
->{ ...indexed, b: 11 } : { b: number; a: number; }
->indexed : Indexed
+>{ ...indexed1, b: 11 } : { b: number; a: number; }
+>indexed1 : { [n: string]: number; a: number; }
 >b : number
 >11 : 11
 
@@ -38,15 +26,27 @@ i[101];
 >i : { b: number; a: number; }
 >101 : 101
 
-let ii = { ...indexed, ...indexed2 };
+let ii = { ...indexed1, ...indexed2 };
 >ii : { [x: string]: number | boolean; c: boolean; a: number; }
->{ ...indexed, ...indexed2 } : { [x: string]: number | boolean; c: boolean; a: number; }
->indexed : Indexed
->indexed2 : Indexed2
+>{ ...indexed1, ...indexed2 } : { [x: string]: number | boolean; c: boolean; a: number; }
+>indexed1 : { [n: string]: number; a: number; }
+>indexed2 : { [n: string]: boolean; c: boolean; }
 
 // both have indexer, so i[1001]: number | boolean
 ii[1001];
 >ii[1001] : number | boolean
 >ii : { [x: string]: number | boolean; c: boolean; a: number; }
 >1001 : 1001
 
+declare const b: boolean;
+>b : boolean
+
+indexed3 = { ...b ? indexed3 : undefined };
+>indexed3 = { ...b ? indexed3 : undefined } : {} | { [n: string]: number; }
+>indexed3 : { [n: string]: number; }
+>{ ...b ? indexed3 : undefined } : {} | { [n: string]: number; }
+>b ? indexed3 : undefined : { [n: string]: number; } | undefined
+>b : boolean
+>indexed3 : { [n: string]: number; }
+>undefined : undefined
+
diff --git a/tests/cases/conformance/types/spread/objectSpreadIndexSignature.ts b/tests/cases/conformance/types/spread/objectSpreadIndexSignature.ts
@@ -1,16 +1,13 @@
-interface Indexed {
-    [n: string]: number;
-    a: number;
-}
-interface Indexed2 {
-    [n: string]: boolean;
-    c: boolean;
-}
-let indexed: Indexed;
-let indexed2: Indexed2;
-let i = { ...indexed, b: 11 };
+// @strict: true
+declare let indexed1: { [n: string]: number; a: number; };
+declare let indexed2: { [n: string]: boolean; c: boolean; };
+declare let indexed3: { [n: string]: number };
+let i = { ...indexed1, b: 11 };
 // only indexed has indexer, so i[101]: any
 i[101];
-let ii = { ...indexed, ...indexed2 };
+let ii = { ...indexed1, ...indexed2 };
 // both have indexer, so i[1001]: number | boolean
 ii[1001];
+
+declare const b: boolean;
+indexed3 = { ...b ? indexed3 : undefined };

Original file line number	Diff line number	Diff line change
`@@ -7878,7 +7878,7 @@ namespace ts {`
`7878`	`7878`	`* this function should be called in a left folding style, with left = previous result of getSpreadType`
`7879`	`7879`	`* and right = the new element to be spread.`
`7880`	`7880`	`*/`
`7881`		`- function getSpreadType(left: Type, right: Type): Type {`
	`7881`	`+ function getSpreadType(left: Type, right: Type, symbol: Symbol, propagatedFlags: TypeFlags): Type {`
`7882`	`7882`	`if (left.flags & TypeFlags.Any \|\| right.flags & TypeFlags.Any) {`
`7883`	`7883`	`return anyType;`
`7884`	`7884`	`}`
`@@ -7889,10 +7889,10 @@ namespace ts {`
`7889`	`7889`	`return left;`
`7890`	`7890`	`}`
`7891`	`7891`	`if (left.flags & TypeFlags.Union) {`
`7892`		`- return mapType(left, t => getSpreadType(t, right));`
	`7892`	`+ return mapType(left, t => getSpreadType(t, right, symbol, propagatedFlags));`
`7893`	`7893`	`}`
`7894`	`7894`	`if (right.flags & TypeFlags.Union) {`
`7895`		`- return mapType(right, t => getSpreadType(left, t));`
	`7895`	`+ return mapType(right, t => getSpreadType(left, t, symbol, propagatedFlags));`
`7896`	`7896`	`}`
`7897`	`7897`	`if (right.flags & TypeFlags.NonPrimitive) {`
`7898`	`7898`	`return nonPrimitiveType;`
`@@ -7950,7 +7950,13 @@ namespace ts {`
`7950`	`7950`	`members.set(leftProp.escapedName, getNonReadonlySymbol(leftProp));`
`7951`	`7951`	`}`
`7952`	`7952`	`}`
`7953`		`- return createAnonymousType(undefined, members, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);`
	`7953`	`+`
	`7954`	`+ const spread = createAnonymousType(undefined, members, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);`
	`7955`	`+ spread.flags \|= propagatedFlags;`
	`7956`	`+ spread.flags \|= TypeFlags.FreshLiteral;`
	`7957`	`+ (spread as ObjectType).objectFlags \|= ObjectFlags.ObjectLiteral;`
	`7958`	`+ spread.symbol = symbol;`
	`7959`	`+ return spread;`
`7954`	`7960`	`}`
`7955`	`7961`
`7956`	`7962`	`function getNonReadonlySymbol(prop: Symbol) {`
`@@ -13914,7 +13920,7 @@ namespace ts {`
`13914`	`13920`	`checkExternalEmitHelpers(memberDecl, ExternalEmitHelpers.Assign);`
`13915`	`13921`	`}`
`13916`	`13922`	`if (propertiesArray.length > 0) {`
`13917`		`- spread = getSpreadType(spread, createObjectLiteralType());`
	`13923`	`+ spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags);`
`13918`	`13924`	`propertiesArray = [];`
`13919`	`13925`	`propertiesTable = createSymbolTable();`
`13920`	`13926`	`hasComputedStringProperty = false;`
`@@ -13926,7 +13932,7 @@ namespace ts {`
`13926`	`13932`	`error(memberDecl, Diagnostics.Spread_types_may_only_be_created_from_object_types);`
`13927`	`13933`	`return unknownType;`
`13928`	`13934`	`}`
`13929`		`- spread = getSpreadType(spread, type);`
	`13935`	`+ spread = getSpreadType(spread, type, node.symbol, propagatedFlags);`
`13930`	`13936`	`offset = i + 1;`
`13931`	`13937`	`continue;`
`13932`	`13938`	`}`
`@@ -13971,14 +13977,7 @@ namespace ts {`
`13971`	`13977`
`13972`	`13978`	`if (spread !== emptyObjectType) {`
`13973`	`13979`	`if (propertiesArray.length > 0) {`
`13974`		`- spread = getSpreadType(spread, createObjectLiteralType());`
`13975`		`- }`
`13976`		`- if (spread.flags & TypeFlags.Object) {`
`13977`		`- // only set the symbol and flags if this is a (fresh) object type`
`13978`		`- spread.flags \|= propagatedFlags;`
`13979`		`- spread.flags \|= TypeFlags.FreshLiteral;`
`13980`		`- (spread as ObjectType).objectFlags \|= ObjectFlags.ObjectLiteral;`
`13981`		`- spread.symbol = node.symbol;`
	`13980`	`+ spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags);`
`13982`	`13981`	`}`
`13983`	`13982`	`return spread;`
`13984`	`13983`	`}`
`@@ -14099,7 +14098,7 @@ namespace ts {`
`14099`	`14098`	`else {`
`14100`	`14099`	`Debug.assert(attributeDecl.kind === SyntaxKind.JsxSpreadAttribute);`
`14101`	`14100`	`if (attributesArray.length > 0) {`
`14102`		`- spread = getSpreadType(spread, createJsxAttributesType(attributes.symbol, attributesTable));`
	`14101`	`+ spread = getSpreadType(spread, createJsxAttributesType(attributes.symbol, attributesTable), openingLikeElement.symbol, /propagatedFlags/ 0);`
`14103`	`14102`	`attributesArray = [];`
`14104`	`14103`	`attributesTable = createSymbolTable();`
`14105`	`14104`	`}`
`@@ -14108,7 +14107,7 @@ namespace ts {`
`14108`	`14107`	`hasSpreadAnyType = true;`
`14109`	`14108`	`}`
`14110`	`14109`	`if (isValidSpreadType(exprType)) {`
`14111`		`- spread = getSpreadType(spread, exprType);`
	`14110`	`+ spread = getSpreadType(spread, exprType, openingLikeElement.symbol, /propagatedFlags/ 0);`
`14112`	`14111`	`}`
`14113`	`14112`	`else {`
`14114`	`14113`	`typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType;`
`@@ -14119,7 +14118,7 @@ namespace ts {`
`14119`	`14118`	`if (!hasSpreadAnyType) {`
`14120`	`14119`	`if (spread !== emptyObjectType) {`
`14121`	`14120`	`if (attributesArray.length > 0) {`
`14122`		`- spread = getSpreadType(spread, createJsxAttributesType(attributes.symbol, attributesTable));`
	`14121`	`+ spread = getSpreadType(spread, createJsxAttributesType(attributes.symbol, attributesTable), openingLikeElement.symbol, /propagatedFlags/ 0);`
`14123`	`14122`	`}`
`14124`	`14123`	`attributesArray = getPropertiesOfType(spread);`
`14125`	`14124`	`}`