push/popTypeResolution for circular base constraints

sandersn · sandersn · commit 16a80030117e · 2018-01-11T10:07:59.000-08:00
Instead of a custom cache `typeStack`.
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -530,6 +530,7 @@ namespace ts {
             ResolvedBaseConstructorType,
             DeclaredType,
             ResolvedReturnType,
+            ResolvedBaseConstraint,
         }
 
         const enum CheckMode {
@@ -4254,7 +4255,7 @@ namespace ts {
             return -1;
         }
 
-        function hasType(target: TypeSystemEntity, propertyName: TypeSystemPropertyName): Type {
+        function hasType(target: TypeSystemEntity, propertyName: TypeSystemPropertyName): Type | boolean {
             if (propertyName === TypeSystemPropertyName.Type) {
                 return getSymbolLinks(<Symbol>target).type;
             }
@@ -4267,6 +4268,10 @@ namespace ts {
             if (propertyName === TypeSystemPropertyName.ResolvedReturnType) {
                 return (<Signature>target).resolvedReturnType;
             }
+            if (propertyName === TypeSystemPropertyName.ResolvedBaseConstraint) {
+                const bc = (<TypeParameter | UnionOrIntersectionType>target).resolvedBaseConstraint;
+                return bc && bc !== circularConstraintType;
+            }
 
             Debug.fail("Unhandled TypeSystemPropertyName " + propertyName);
         }
@@ -6301,9 +6306,9 @@ namespace ts {
                 (type.typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(type.declaration.typeParameter)));
         }
 
-        function getConstraintTypeFromMappedType(type: MappedType, typeStack?: Type[]) {
+        function getConstraintTypeFromMappedType(type: MappedType) {
             return type.constraintType ||
-                (type.constraintType = instantiateType(getConstraintOfTypeParameter(getTypeParameterFromMappedType(type), typeStack), type.mapper || identityMapper) || unknownType);
+                (type.constraintType = instantiateType(getConstraintOfTypeParameter(getTypeParameterFromMappedType(type)), type.mapper || identityMapper) || unknownType);
         }
 
         function getTemplateTypeFromMappedType(type: MappedType) {
@@ -6351,8 +6356,8 @@ namespace ts {
             return getObjectFlags(type) & ObjectFlags.Mapped && !!(<MappedType>type).declaration.questionToken;
         }
 
-        function isGenericMappedType(type: Type, typeStack?: Type[]): type is MappedType {
-            return getObjectFlags(type) & ObjectFlags.Mapped && isGenericIndexType(getConstraintTypeFromMappedType(<MappedType>type, typeStack));
+        function isGenericMappedType(type: Type): type is MappedType {
+            return getObjectFlags(type) & ObjectFlags.Mapped && isGenericIndexType(getConstraintTypeFromMappedType(<MappedType>type));
         }
 
         function resolveStructuredTypeMembers(type: StructuredType): ResolvedType {
@@ -6458,10 +6463,7 @@ namespace ts {
                     getBaseConstraintOfType(type);
         }
 
-        function getConstraintOfTypeParameter(typeParameter: TypeParameter, typeStack?: Type[]): Type {
-            if (typeStack) {
-                return !contains(typeStack, typeParameter) && getConstraintFromTypeParameter(typeParameter);
-            }
+        function getConstraintOfTypeParameter(typeParameter: TypeParameter): Type {
             return hasNonCircularBaseConstraint(typeParameter) ? getConstraintFromTypeParameter(typeParameter) : undefined;
         }
 
@@ -6503,23 +6505,23 @@ namespace ts {
          * circularly references the type variable.
          */
         function getResolvedBaseConstraint(type: TypeVariable | UnionOrIntersectionType): Type {
-            let typeStack: Type[];
             let circular: boolean;
             if (!type.resolvedBaseConstraint) {
-                typeStack = [];
                 const constraint = getBaseConstraint(type);
                 type.resolvedBaseConstraint = circular ? circularConstraintType : getTypeWithThisArgument(constraint || noConstraintType, type);
             }
             return type.resolvedBaseConstraint;
 
             function getBaseConstraint(t: Type): Type {
-                if (contains(typeStack, t)) {
+                if (!pushTypeResolution(t, TypeSystemPropertyName.ResolvedBaseConstraint)) {
                     circular = true;
                     return undefined;
                 }
-                typeStack.push(t);
                 const result = computeBaseConstraint(t);
-                typeStack.pop();
+                if (!popTypeResolution()) {
+                    circular = true;
+                    return undefined;
+                }
                 return result;
             }
 
@@ -6556,7 +6558,7 @@ namespace ts {
                     const baseIndexedAccess = baseObjectType && baseIndexType ? getIndexedAccessType(baseObjectType, baseIndexType) : undefined;
                     return baseIndexedAccess && baseIndexedAccess !== unknownType ? getBaseConstraint(baseIndexedAccess) : undefined;
                 }
-                if (isGenericMappedType(t, typeStack)) {
+                if (isGenericMappedType(t)) {
                     return emptyObjectType;
                 }
                 return t;

Original file line number	Diff line number	Diff line change
`@@ -530,6 +530,7 @@ namespace ts {`
`530`	`530`	`ResolvedBaseConstructorType,`
`531`	`531`	`DeclaredType,`
`532`	`532`	`ResolvedReturnType,`
	`533`	`+ ResolvedBaseConstraint,`
`533`	`534`	`}`
`534`	`535`
`535`	`536`	`const enum CheckMode {`
`@@ -4254,7 +4255,7 @@ namespace ts {`
`4254`	`4255`	`return -1;`
`4255`	`4256`	`}`
`4256`	`4257`
`4257`		`- function hasType(target: TypeSystemEntity, propertyName: TypeSystemPropertyName): Type {`
	`4258`	`+ function hasType(target: TypeSystemEntity, propertyName: TypeSystemPropertyName): Type \| boolean {`
`4258`	`4259`	`if (propertyName === TypeSystemPropertyName.Type) {`
`4259`	`4260`	`return getSymbolLinks(<Symbol>target).type;`
`4260`	`4261`	`}`
`@@ -4267,6 +4268,10 @@ namespace ts {`
`4267`	`4268`	`if (propertyName === TypeSystemPropertyName.ResolvedReturnType) {`
`4268`	`4269`	`return (<Signature>target).resolvedReturnType;`
`4269`	`4270`	`}`
	`4271`	`+ if (propertyName === TypeSystemPropertyName.ResolvedBaseConstraint) {`
	`4272`	`+ const bc = (<TypeParameter \| UnionOrIntersectionType>target).resolvedBaseConstraint;`
	`4273`	`+ return bc && bc !== circularConstraintType;`
	`4274`	`+ }`
`4270`	`4275`
`4271`	`4276`	`Debug.fail("Unhandled TypeSystemPropertyName " + propertyName);`
`4272`	`4277`	`}`
`@@ -6301,9 +6306,9 @@ namespace ts {`
`6301`	`6306`	`(type.typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(type.declaration.typeParameter)));`
`6302`	`6307`	`}`
`6303`	`6308`
`6304`		`- function getConstraintTypeFromMappedType(type: MappedType, typeStack?: Type[]) {`
	`6309`	`+ function getConstraintTypeFromMappedType(type: MappedType) {`
`6305`	`6310`	`return type.constraintType \|\|`
`6306`		`- (type.constraintType = instantiateType(getConstraintOfTypeParameter(getTypeParameterFromMappedType(type), typeStack), type.mapper \|\| identityMapper) \|\| unknownType);`
	`6311`	`+ (type.constraintType = instantiateType(getConstraintOfTypeParameter(getTypeParameterFromMappedType(type)), type.mapper \|\| identityMapper) \|\| unknownType);`
`6307`	`6312`	`}`
`6308`	`6313`
`6309`	`6314`	`function getTemplateTypeFromMappedType(type: MappedType) {`
`@@ -6351,8 +6356,8 @@ namespace ts {`
`6351`	`6356`	`return getObjectFlags(type) & ObjectFlags.Mapped && !!(<MappedType>type).declaration.questionToken;`
`6352`	`6357`	`}`
`6353`	`6358`
`6354`		`- function isGenericMappedType(type: Type, typeStack?: Type[]): type is MappedType {`
`6355`		`- return getObjectFlags(type) & ObjectFlags.Mapped && isGenericIndexType(getConstraintTypeFromMappedType(<MappedType>type, typeStack));`
	`6359`	`+ function isGenericMappedType(type: Type): type is MappedType {`
	`6360`	`+ return getObjectFlags(type) & ObjectFlags.Mapped && isGenericIndexType(getConstraintTypeFromMappedType(<MappedType>type));`
`6356`	`6361`	`}`
`6357`	`6362`
`6358`	`6363`	`function resolveStructuredTypeMembers(type: StructuredType): ResolvedType {`
`@@ -6458,10 +6463,7 @@ namespace ts {`
`6458`	`6463`	`getBaseConstraintOfType(type);`
`6459`	`6464`	`}`
`6460`	`6465`
`6461`		`- function getConstraintOfTypeParameter(typeParameter: TypeParameter, typeStack?: Type[]): Type {`
`6462`		`- if (typeStack) {`
`6463`		`- return !contains(typeStack, typeParameter) && getConstraintFromTypeParameter(typeParameter);`
`6464`		`- }`
	`6466`	`+ function getConstraintOfTypeParameter(typeParameter: TypeParameter): Type {`
`6465`	`6467`	`return hasNonCircularBaseConstraint(typeParameter) ? getConstraintFromTypeParameter(typeParameter) : undefined;`
`6466`	`6468`	`}`
`6467`	`6469`
`@@ -6503,23 +6505,23 @@ namespace ts {`
`6503`	`6505`	`* circularly references the type variable.`
`6504`	`6506`	`*/`
`6505`	`6507`	`function getResolvedBaseConstraint(type: TypeVariable \| UnionOrIntersectionType): Type {`
`6506`		`- let typeStack: Type[];`
`6507`	`6508`	`let circular: boolean;`
`6508`	`6509`	`if (!type.resolvedBaseConstraint) {`
`6509`		`- typeStack = [];`
`6510`	`6510`	`const constraint = getBaseConstraint(type);`
`6511`	`6511`	`type.resolvedBaseConstraint = circular ? circularConstraintType : getTypeWithThisArgument(constraint \|\| noConstraintType, type);`
`6512`	`6512`	`}`
`6513`	`6513`	`return type.resolvedBaseConstraint;`
`6514`	`6514`
`6515`	`6515`	`function getBaseConstraint(t: Type): Type {`
`6516`		`- if (contains(typeStack, t)) {`
	`6516`	`+ if (!pushTypeResolution(t, TypeSystemPropertyName.ResolvedBaseConstraint)) {`
`6517`	`6517`	`circular = true;`
`6518`	`6518`	`return undefined;`
`6519`	`6519`	`}`
`6520`		`- typeStack.push(t);`
`6521`	`6520`	`const result = computeBaseConstraint(t);`
`6522`		`- typeStack.pop();`
	`6521`	`+ if (!popTypeResolution()) {`
	`6522`	`+ circular = true;`
	`6523`	`+ return undefined;`
	`6524`	`+ }`
`6523`	`6525`	`return result;`
`6524`	`6526`	`}`
`6525`	`6527`
`@@ -6556,7 +6558,7 @@ namespace ts {`
`6556`	`6558`	`const baseIndexedAccess = baseObjectType && baseIndexType ? getIndexedAccessType(baseObjectType, baseIndexType) : undefined;`
`6557`	`6559`	`return baseIndexedAccess && baseIndexedAccess !== unknownType ? getBaseConstraint(baseIndexedAccess) : undefined;`
`6558`	`6560`	`}`
`6559`		`- if (isGenericMappedType(t, typeStack)) {`
	`6561`	`+ if (isGenericMappedType(t)) {`
`6560`	`6562`	`return emptyObjectType;`
`6561`	`6563`	`}`
`6562`	`6564`	`return t;`