Propagate both TypeFlags and ObjectFlags in getSpreadType

ahejlsberg · ahejlsberg · commit bb23bb2a9248 · 2018-01-03T11:29:21.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -8442,7 +8442,7 @@ namespace ts {
         function getExtendsType(checkType: Type, extendsType: Type): Type {
             // sys.write(`getExtendsType(${typeToString(checkType)}, ${typeToString(extendsType)})\n`);
             if (checkType.flags & TypeFlags.Union) {
-                return getUnionType(map((<UnionType>checkType).types, t => getExtendsType(t, extendsType)), /*subtypeReduction*/ false);
+                return getUnionType(map((<UnionType>checkType).types, t => getExtendsType(t, extendsType)));
             }
             if (checkType.flags & TypeFlags.Any) {
                 return booleanType;
@@ -8501,7 +8501,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, symbol: Symbol, propagatedFlags: TypeFlags): Type {
+        function getSpreadType(left: Type, right: Type, symbol: Symbol, typeFlags: TypeFlags, objectFlags: ObjectFlags): Type {
             if (left.flags & TypeFlags.Any || right.flags & TypeFlags.Any) {
                 return anyType;
             }
@@ -8512,10 +8512,10 @@ namespace ts {
                 return left;
             }
             if (left.flags & TypeFlags.Union) {
-                return mapType(left, t => getSpreadType(t, right, symbol, propagatedFlags));
+                return mapType(left, t => getSpreadType(t, right, symbol, typeFlags, objectFlags));
             }
             if (right.flags & TypeFlags.Union) {
-                return mapType(right, t => getSpreadType(left, t, symbol, propagatedFlags));
+                return mapType(right, t => getSpreadType(left, t, symbol, typeFlags, objectFlags));
             }
             if (right.flags & (TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.StringLike | TypeFlags.EnumLike | TypeFlags.NonPrimitive)) {
                 return left;
@@ -8578,8 +8578,8 @@ namespace ts {
                 emptyArray,
                 getNonReadonlyIndexSignature(stringIndexInfo),
                 getNonReadonlyIndexSignature(numberIndexInfo));
-            spread.flags |= propagatedFlags | TypeFlags.ContainsObjectLiteral;
-            (spread as ObjectType).objectFlags |= (ObjectFlags.ObjectLiteral | ObjectFlags.ContainsSpread);
+            spread.flags |= typeFlags | TypeFlags.ContainsObjectLiteral;
+            (spread as ObjectType).objectFlags |= objectFlags | (ObjectFlags.ObjectLiteral | ObjectFlags.ContainsSpread);
             return spread;
         }
 
@@ -9552,7 +9552,7 @@ namespace ts {
         }
 
         function isIgnoredJsxProperty(source: Type, sourceProp: Symbol, targetMemberType: Type | undefined) {
-            return source.flags & TypeFlags.JsxAttributes && !(isUnhyphenatedJsxName(sourceProp.escapedName) || targetMemberType);
+            return getObjectFlags(source) & ObjectFlags.JsxAttributes && !(isUnhyphenatedJsxName(sourceProp.escapedName) || targetMemberType);
         }
 
         /**
@@ -14905,7 +14905,7 @@ namespace ts {
                         checkExternalEmitHelpers(memberDecl, ExternalEmitHelpers.Assign);
                     }
                     if (propertiesArray.length > 0) {
-                        spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags);
+                        spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags, 0);
                         propertiesArray = [];
                         propertiesTable = createSymbolTable();
                         hasComputedStringProperty = false;
@@ -14917,7 +14917,7 @@ namespace ts {
                         error(memberDecl, Diagnostics.Spread_types_may_only_be_created_from_object_types);
                         return unknownType;
                     }
-                    spread = getSpreadType(spread, type, node.symbol, propagatedFlags);
+                    spread = getSpreadType(spread, type, node.symbol, propagatedFlags, 0);
                     offset = i + 1;
                     continue;
                 }
@@ -14962,7 +14962,7 @@ namespace ts {
 
             if (spread !== emptyObjectType) {
                 if (propertiesArray.length > 0) {
-                    spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags);
+                    spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags, 0);
                 }
                 return spread;
             }
@@ -15095,15 +15095,15 @@ namespace ts {
                 else {
                     Debug.assert(attributeDecl.kind === SyntaxKind.JsxSpreadAttribute);
                     if (attributesTable.size > 0) {
-                        spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, TypeFlags.JsxAttributes);
+                        spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, 0, ObjectFlags.JsxAttributes);
                         attributesTable = createSymbolTable();
                     }
                     const exprType = checkExpressionCached(attributeDecl.expression, checkMode);
                     if (isTypeAny(exprType)) {
                         hasSpreadAnyType = true;
                     }
                     if (isValidSpreadType(exprType)) {
-                        spread = getSpreadType(spread, exprType, openingLikeElement.symbol, TypeFlags.JsxAttributes);
+                        spread = getSpreadType(spread, exprType, openingLikeElement.symbol, 0, ObjectFlags.JsxAttributes);
                     }
                     else {
                         typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType;
@@ -15113,7 +15113,7 @@ namespace ts {
 
             if (!hasSpreadAnyType) {
                 if (attributesTable.size > 0) {
-                    spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, TypeFlags.JsxAttributes);
+                    spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, 0, ObjectFlags.JsxAttributes);
                 }
             }
 
@@ -15138,7 +15138,8 @@ namespace ts {
                         createArrayType(getUnionType(childrenTypes));
                     const childPropMap = createSymbolTable();
                     childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol);
-                    spread = getSpreadType(spread, createAnonymousType(attributes.symbol, childPropMap, emptyArray, emptyArray, /*stringIndexInfo*/ undefined, /*numberIndexInfo*/ undefined), attributes.symbol, TypeFlags.JsxAttributes);
+                    spread = getSpreadType(spread, createAnonymousType(attributes.symbol, childPropMap, emptyArray, emptyArray, /*stringIndexInfo*/ undefined, /*numberIndexInfo*/ undefined),
+                        attributes.symbol, 0, ObjectFlags.JsxAttributes);
 
                 }
             }

Original file line number	Diff line number	Diff line change
`@@ -8442,7 +8442,7 @@ namespace ts {`
`8442`	`8442`	`function getExtendsType(checkType: Type, extendsType: Type): Type {`
`8443`	`8443`	// sys.write(`getExtendsType(${typeToString(checkType)}, ${typeToString(extendsType)})\n`);
`8444`	`8444`	`if (checkType.flags & TypeFlags.Union) {`
`8445`		`- return getUnionType(map((<UnionType>checkType).types, t => getExtendsType(t, extendsType)), /subtypeReduction/ false);`
	`8445`	`+ return getUnionType(map((<UnionType>checkType).types, t => getExtendsType(t, extendsType)));`
`8446`	`8446`	`}`
`8447`	`8447`	`if (checkType.flags & TypeFlags.Any) {`
`8448`	`8448`	`return booleanType;`
`@@ -8501,7 +8501,7 @@ namespace ts {`
`8501`	`8501`	`* this function should be called in a left folding style, with left = previous result of getSpreadType`
`8502`	`8502`	`* and right = the new element to be spread.`
`8503`	`8503`	`*/`
`8504`		`- function getSpreadType(left: Type, right: Type, symbol: Symbol, propagatedFlags: TypeFlags): Type {`
	`8504`	`+ function getSpreadType(left: Type, right: Type, symbol: Symbol, typeFlags: TypeFlags, objectFlags: ObjectFlags): Type {`
`8505`	`8505`	`if (left.flags & TypeFlags.Any \|\| right.flags & TypeFlags.Any) {`
`8506`	`8506`	`return anyType;`
`8507`	`8507`	`}`
`@@ -8512,10 +8512,10 @@ namespace ts {`
`8512`	`8512`	`return left;`
`8513`	`8513`	`}`
`8514`	`8514`	`if (left.flags & TypeFlags.Union) {`
`8515`		`- return mapType(left, t => getSpreadType(t, right, symbol, propagatedFlags));`
	`8515`	`+ return mapType(left, t => getSpreadType(t, right, symbol, typeFlags, objectFlags));`
`8516`	`8516`	`}`
`8517`	`8517`	`if (right.flags & TypeFlags.Union) {`
`8518`		`- return mapType(right, t => getSpreadType(left, t, symbol, propagatedFlags));`
	`8518`	`+ return mapType(right, t => getSpreadType(left, t, symbol, typeFlags, objectFlags));`
`8519`	`8519`	`}`
`8520`	`8520`	`if (right.flags & (TypeFlags.BooleanLike \| TypeFlags.NumberLike \| TypeFlags.StringLike \| TypeFlags.EnumLike \| TypeFlags.NonPrimitive)) {`
`8521`	`8521`	`return left;`
`@@ -8578,8 +8578,8 @@ namespace ts {`
`8578`	`8578`	`emptyArray,`
`8579`	`8579`	`getNonReadonlyIndexSignature(stringIndexInfo),`
`8580`	`8580`	`getNonReadonlyIndexSignature(numberIndexInfo));`
`8581`		`- spread.flags \|= propagatedFlags \| TypeFlags.ContainsObjectLiteral;`
`8582`		`- (spread as ObjectType).objectFlags \|= (ObjectFlags.ObjectLiteral \| ObjectFlags.ContainsSpread);`
	`8581`	`+ spread.flags \|= typeFlags \| TypeFlags.ContainsObjectLiteral;`
	`8582`	`+ (spread as ObjectType).objectFlags \|= objectFlags \| (ObjectFlags.ObjectLiteral \| ObjectFlags.ContainsSpread);`
`8583`	`8583`	`return spread;`
`8584`	`8584`	`}`
`8585`	`8585`
`@@ -9552,7 +9552,7 @@ namespace ts {`
`9552`	`9552`	`}`
`9553`	`9553`
`9554`	`9554`	`function isIgnoredJsxProperty(source: Type, sourceProp: Symbol, targetMemberType: Type \| undefined) {`
`9555`		`- return source.flags & TypeFlags.JsxAttributes && !(isUnhyphenatedJsxName(sourceProp.escapedName) \|\| targetMemberType);`
	`9555`	`+ return getObjectFlags(source) & ObjectFlags.JsxAttributes && !(isUnhyphenatedJsxName(sourceProp.escapedName) \|\| targetMemberType);`
`9556`	`9556`	`}`
`9557`	`9557`
`9558`	`9558`	`/**`
`@@ -14905,7 +14905,7 @@ namespace ts {`
`14905`	`14905`	`checkExternalEmitHelpers(memberDecl, ExternalEmitHelpers.Assign);`
`14906`	`14906`	`}`
`14907`	`14907`	`if (propertiesArray.length > 0) {`
`14908`		`- spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags);`
	`14908`	`+ spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags, 0);`
`14909`	`14909`	`propertiesArray = [];`
`14910`	`14910`	`propertiesTable = createSymbolTable();`
`14911`	`14911`	`hasComputedStringProperty = false;`
`@@ -14917,7 +14917,7 @@ namespace ts {`
`14917`	`14917`	`error(memberDecl, Diagnostics.Spread_types_may_only_be_created_from_object_types);`
`14918`	`14918`	`return unknownType;`
`14919`	`14919`	`}`
`14920`		`- spread = getSpreadType(spread, type, node.symbol, propagatedFlags);`
	`14920`	`+ spread = getSpreadType(spread, type, node.symbol, propagatedFlags, 0);`
`14921`	`14921`	`offset = i + 1;`
`14922`	`14922`	`continue;`
`14923`	`14923`	`}`
`@@ -14962,7 +14962,7 @@ namespace ts {`
`14962`	`14962`
`14963`	`14963`	`if (spread !== emptyObjectType) {`
`14964`	`14964`	`if (propertiesArray.length > 0) {`
`14965`		`- spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags);`
	`14965`	`+ spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags, 0);`
`14966`	`14966`	`}`
`14967`	`14967`	`return spread;`
`14968`	`14968`	`}`
`@@ -15095,15 +15095,15 @@ namespace ts {`
`15095`	`15095`	`else {`
`15096`	`15096`	`Debug.assert(attributeDecl.kind === SyntaxKind.JsxSpreadAttribute);`
`15097`	`15097`	`if (attributesTable.size > 0) {`
`15098`		`- spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, TypeFlags.JsxAttributes);`
	`15098`	`+ spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, 0, ObjectFlags.JsxAttributes);`
`15099`	`15099`	`attributesTable = createSymbolTable();`
`15100`	`15100`	`}`
`15101`	`15101`	`const exprType = checkExpressionCached(attributeDecl.expression, checkMode);`
`15102`	`15102`	`if (isTypeAny(exprType)) {`
`15103`	`15103`	`hasSpreadAnyType = true;`
`15104`	`15104`	`}`
`15105`	`15105`	`if (isValidSpreadType(exprType)) {`
`15106`		`- spread = getSpreadType(spread, exprType, openingLikeElement.symbol, TypeFlags.JsxAttributes);`
	`15106`	`+ spread = getSpreadType(spread, exprType, openingLikeElement.symbol, 0, ObjectFlags.JsxAttributes);`
`15107`	`15107`	`}`
`15108`	`15108`	`else {`
`15109`	`15109`	`typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType;`
`@@ -15113,7 +15113,7 @@ namespace ts {`
`15113`	`15113`
`15114`	`15114`	`if (!hasSpreadAnyType) {`
`15115`	`15115`	`if (attributesTable.size > 0) {`
`15116`		`- spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, TypeFlags.JsxAttributes);`
	`15116`	`+ spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, 0, ObjectFlags.JsxAttributes);`
`15117`	`15117`	`}`
`15118`	`15118`	`}`
`15119`	`15119`
`@@ -15138,7 +15138,8 @@ namespace ts {`
`15138`	`15138`	`createArrayType(getUnionType(childrenTypes));`
`15139`	`15139`	`const childPropMap = createSymbolTable();`
`15140`	`15140`	`childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol);`
`15141`		`- spread = getSpreadType(spread, createAnonymousType(attributes.symbol, childPropMap, emptyArray, emptyArray, /stringIndexInfo/ undefined, /numberIndexInfo/ undefined), attributes.symbol, TypeFlags.JsxAttributes);`
	`15141`	`+ spread = getSpreadType(spread, createAnonymousType(attributes.symbol, childPropMap, emptyArray, emptyArray, /stringIndexInfo/ undefined, /numberIndexInfo/ undefined),`
	`15142`	`+ attributes.symbol, 0, ObjectFlags.JsxAttributes);`
`15142`	`15143`
`15143`	`15144`	`}`
`15144`	`15145`	`}`