Optimize substitution types (#50397)

ahejlsberg · web-flow · commit 6e8337ef70e4 · 2022-08-26T12:06:06.000-07:00
* Optimize substitution type infrastructure

* Accept new baselines

* Preserve instantiated substitution types for type variables

* Restrictive type parameters should have no constraint

* Fix issues from top100 test run

* Accept new baselines
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -12366,7 +12366,7 @@ namespace ts {
                     return constraint && getBaseConstraint(constraint);
                 }
                 if (t.flags & TypeFlags.Substitution) {
-                    return getBaseConstraint((t as SubstitutionType).substitute);
+                    return getBaseConstraint(getSubstitutionIntersection(t as SubstitutionType));
                 }
                 return t;
             }
@@ -13903,22 +13903,27 @@ namespace ts {
             return links.resolvedJSDocType;
         }
 
-        function getSubstitutionType(baseType: Type, substitute: Type) {
-            if (substitute.flags & TypeFlags.AnyOrUnknown || substitute === baseType) {
+        function getSubstitutionType(baseType: Type, constraint: Type) {
+            if (constraint.flags & TypeFlags.AnyOrUnknown || constraint === baseType ||
+                !isGenericType(baseType) && !isGenericType(constraint)) {
                 return baseType;
             }
-            const id = `${getTypeId(baseType)}>${getTypeId(substitute)}`;
+            const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
             const cached = substitutionTypes.get(id);
             if (cached) {
                 return cached;
             }
             const result = createType(TypeFlags.Substitution) as SubstitutionType;
             result.baseType = baseType;
-            result.substitute = substitute;
+            result.constraint = constraint;
             substitutionTypes.set(id, result);
             return result;
         }
 
+        function getSubstitutionIntersection(substitutionType: SubstitutionType) {
+            return getIntersectionType([substitutionType.constraint, substitutionType.baseType]);
+        }
+
         function isUnaryTupleTypeNode(node: TypeNode) {
             return node.kind === SyntaxKind.TupleType && (node as TupleTypeNode).elements.length === 1;
         }
@@ -13963,7 +13968,7 @@ namespace ts {
                 }
                 node = parent;
             }
-            return constraints ? getSubstitutionType(type, getIntersectionType(append(constraints, type))) : type;
+            return constraints ? getSubstitutionType(type, getIntersectionType(constraints)) : type;
         }
 
         function isJSDocTypeReference(node: Node): node is TypeReferenceNode {
@@ -15363,7 +15368,7 @@ namespace ts {
                     type.flags & TypeFlags.Conditional ? (type as ConditionalType).root.isDistributive && (type as ConditionalType).checkType === typeVariable :
                     type.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral) ? every((type as UnionOrIntersectionType | TemplateLiteralType).types, isDistributive) :
                     type.flags & TypeFlags.IndexedAccess ? isDistributive((type as IndexedAccessType).objectType) && isDistributive((type as IndexedAccessType).indexType) :
-                    type.flags & TypeFlags.Substitution ? isDistributive((type as SubstitutionType).substitute) :
+                    type.flags & TypeFlags.Substitution ? isDistributive((type as SubstitutionType).baseType) && isDistributive((type as SubstitutionType).constraint):
                     type.flags & TypeFlags.StringMapping ? isDistributive((type as StringMappingType).type) :
                     false;
             }
@@ -15883,7 +15888,7 @@ namespace ts {
             if (type.flags & TypeFlags.Substitution) {
                 if (!((type as SubstitutionType).objectFlags & ObjectFlags.IsGenericTypeComputed)) {
                     (type as SubstitutionType).objectFlags |= ObjectFlags.IsGenericTypeComputed |
-                        getGenericObjectFlags((type as SubstitutionType).substitute) | getGenericObjectFlags((type as SubstitutionType).baseType);
+                        getGenericObjectFlags((type as SubstitutionType).baseType) | getGenericObjectFlags((type as SubstitutionType).constraint);
                 }
                 return (type as SubstitutionType).objectFlags & ObjectFlags.IsGenericType;
             }
@@ -16095,11 +16100,7 @@ namespace ts {
                 const objectType = getTypeFromTypeNode(node.objectType);
                 const indexType = getTypeFromTypeNode(node.indexType);
                 const potentialAlias = getAliasSymbolForTypeNode(node);
-                const resolved = getIndexedAccessType(objectType, indexType, AccessFlags.None, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias));
-                links.resolvedType = resolved.flags & TypeFlags.IndexedAccess &&
-                    (resolved as IndexedAccessType).objectType === objectType &&
-                    (resolved as IndexedAccessType).indexType === indexType ?
-                    getConditionalFlowTypeOfType(resolved, node) : resolved;
+                links.resolvedType = getIndexedAccessType(objectType, indexType, AccessFlags.None, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias));
             }
             return links.resolvedType;
         }
@@ -17040,9 +17041,9 @@ namespace ts {
         }
 
         function getRestrictiveTypeParameter(tp: TypeParameter) {
-            return tp.constraint === unknownType ? tp : tp.restrictiveInstantiation || (
+            return !tp.constraint && !getConstraintDeclaration(tp) || tp.constraint === noConstraintType ? tp : tp.restrictiveInstantiation || (
                 tp.restrictiveInstantiation = createTypeParameter(tp.symbol),
-                (tp.restrictiveInstantiation as TypeParameter).constraint = unknownType,
+                (tp.restrictiveInstantiation as TypeParameter).constraint = noConstraintType,
                 tp.restrictiveInstantiation
             );
         }
@@ -17429,17 +17430,18 @@ namespace ts {
                 return getConditionalTypeInstantiation(type as ConditionalType, combineTypeMappers((type as ConditionalType).mapper, mapper), aliasSymbol, aliasTypeArguments);
             }
             if (flags & TypeFlags.Substitution) {
-                const maybeVariable = instantiateType((type as SubstitutionType).baseType, mapper);
-                if (maybeVariable.flags & TypeFlags.TypeVariable) {
-                    return getSubstitutionType(maybeVariable as TypeVariable, instantiateType((type as SubstitutionType).substitute, mapper));
+                const newBaseType = instantiateType((type as SubstitutionType).baseType, mapper);
+                const newConstraint = instantiateType((type as SubstitutionType).constraint, mapper);
+                // A substitution type originates in the true branch of a conditional type and can be resolved
+                // to just the base type in the same cases as the conditional type resolves to its true branch
+                // (because the base type is then known to satisfy the constraint).
+                if (newBaseType.flags & TypeFlags.TypeVariable && isGenericType(newConstraint)) {
+                    return getSubstitutionType(newBaseType, newConstraint);
                 }
-                else {
-                    const sub = instantiateType((type as SubstitutionType).substitute, mapper);
-                    if (sub.flags & TypeFlags.AnyOrUnknown || isTypeAssignableTo(getRestrictiveInstantiation(maybeVariable), getRestrictiveInstantiation(sub))) {
-                        return maybeVariable;
-                    }
-                    return sub;
+                if (newConstraint.flags & TypeFlags.AnyOrUnknown || isTypeAssignableTo(getRestrictiveInstantiation(newBaseType), getRestrictiveInstantiation(newConstraint))) {
+                    return newBaseType;
                 }
+                return newBaseType.flags & TypeFlags.TypeVariable ? getSubstitutionType(newBaseType, newConstraint) : getIntersectionType([newConstraint, newBaseType]);
             }
             return type;
         }
@@ -18478,7 +18480,7 @@ namespace ts {
                 const t = isFreshLiteralType(type) ? (type as FreshableType).regularType :
                     getObjectFlags(type) & ObjectFlags.Reference ? (type as TypeReference).node ? createTypeReference((type as TypeReference).target, getTypeArguments(type as TypeReference)) : getSingleBaseForNonAugmentingSubtype(type) || type :
                     type.flags & TypeFlags.UnionOrIntersection ? getNormalizedUnionOrIntersectionType(type as UnionOrIntersectionType, writing) :
-                    type.flags & TypeFlags.Substitution ? writing ? (type as SubstitutionType).baseType : (type as SubstitutionType).substitute :
+                    type.flags & TypeFlags.Substitution ? writing ? (type as SubstitutionType).baseType : getSubstitutionIntersection(type as SubstitutionType) :
                     type.flags & TypeFlags.Simplifiable ? getSimplifiedType(type, writing) :
                     type;
                 if (t === type) return t;
@@ -19561,7 +19563,11 @@ namespace ts {
                         }
                     }
                     if (sourceFlags & TypeFlags.Substitution) {
-                        return isRelatedTo((source as SubstitutionType).substitute, (target as SubstitutionType).substitute, RecursionFlags.Both, /*reportErrors*/ false);
+                        if (result = isRelatedTo((source as SubstitutionType).baseType, (target as SubstitutionType).baseType, RecursionFlags.Both, /*reportErrors*/ false)) {
+                            if (result &= isRelatedTo((source as SubstitutionType).constraint, (target as SubstitutionType).constraint, RecursionFlags.Both, /*reportErrors*/ false)) {
+                                return result;
+                            }
+                        }
                     }
                     if (!(sourceFlags & TypeFlags.Object)) {
                         return Ternary.False;
@@ -22699,7 +22705,7 @@ namespace ts {
                 }
                 else if (source.flags & TypeFlags.Substitution) {
                     inferFromTypes((source as SubstitutionType).baseType, target);
-                    inferWithPriority((source as SubstitutionType).substitute, target, InferencePriority.SubstituteSource); // Make substitute inference at a lower priority
+                    inferWithPriority(getSubstitutionIntersection(source as SubstitutionType), target, InferencePriority.SubstituteSource); // Make substitute inference at a lower priority
                 }
                 else if (target.flags & TypeFlags.Conditional) {
                     invokeOnce(source, target, inferToConditionalType);
diff --git a/src/compiler/tracing.ts b/src/compiler/tracing.ts
@@ -253,7 +253,7 @@ namespace ts { // eslint-disable-line local/one-namespace-per-file
                     const substitutionType = type as SubstitutionType;
                     substitutionProperties = {
                         substitutionBaseType: substitutionType.baseType?.id,
-                        substituteType: substitutionType.substitute?.id,
+                        constraintType: substitutionType.constraint?.id,
                     };
                 }
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -6145,8 +6145,8 @@ namespace ts {
     // types disappear upon instantiation (just like type parameters).
     export interface SubstitutionType extends InstantiableType {
         objectFlags: ObjectFlags;
-        baseType: Type;     // Target type
-        substitute: Type;   // Type to substitute for type parameter
+        baseType: Type;    // Target type
+        constraint: Type;  // Constraint that target type is known to satisfy
     }
 
     /* @internal */
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -2840,7 +2840,7 @@ declare namespace ts {
     export interface SubstitutionType extends InstantiableType {
         objectFlags: ObjectFlags;
         baseType: Type;
-        substitute: Type;
+        constraint: Type;
     }
     export enum SignatureKind {
         Call = 0,
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
@@ -2840,7 +2840,7 @@ declare namespace ts {
     export interface SubstitutionType extends InstantiableType {
         objectFlags: ObjectFlags;
         baseType: Type;
-        substitute: Type;
+        constraint: Type;
     }
     export enum SignatureKind {
         Call = 0,

Original file line number	Diff line number	Diff line change
`@@ -12366,7 +12366,7 @@ namespace ts {`
`12366`	`12366`	`return constraint && getBaseConstraint(constraint);`
`12367`	`12367`	`}`
`12368`	`12368`	`if (t.flags & TypeFlags.Substitution) {`
`12369`		`- return getBaseConstraint((t as SubstitutionType).substitute);`
	`12369`	`+ return getBaseConstraint(getSubstitutionIntersection(t as SubstitutionType));`
`12370`	`12370`	`}`
`12371`	`12371`	`return t;`
`12372`	`12372`	`}`
`@@ -13903,22 +13903,27 @@ namespace ts {`
`13903`	`13903`	`return links.resolvedJSDocType;`
`13904`	`13904`	`}`
`13905`	`13905`
`13906`		`- function getSubstitutionType(baseType: Type, substitute: Type) {`
`13907`		`- if (substitute.flags & TypeFlags.AnyOrUnknown \|\| substitute === baseType) {`
	`13906`	`+ function getSubstitutionType(baseType: Type, constraint: Type) {`
	`13907`	`+ if (constraint.flags & TypeFlags.AnyOrUnknown \|\| constraint === baseType \|\|`
	`13908`	`+ !isGenericType(baseType) && !isGenericType(constraint)) {`
`13908`	`13909`	`return baseType;`
`13909`	`13910`	`}`
`13910`		- const id = `${getTypeId(baseType)}>${getTypeId(substitute)}`;
	`13911`	+ const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
`13911`	`13912`	`const cached = substitutionTypes.get(id);`
`13912`	`13913`	`if (cached) {`
`13913`	`13914`	`return cached;`
`13914`	`13915`	`}`
`13915`	`13916`	`const result = createType(TypeFlags.Substitution) as SubstitutionType;`
`13916`	`13917`	`result.baseType = baseType;`
`13917`		`- result.substitute = substitute;`
	`13918`	`+ result.constraint = constraint;`
`13918`	`13919`	`substitutionTypes.set(id, result);`
`13919`	`13920`	`return result;`
`13920`	`13921`	`}`
`13921`	`13922`
	`13923`	`+ function getSubstitutionIntersection(substitutionType: SubstitutionType) {`
	`13924`	`+ return getIntersectionType([substitutionType.constraint, substitutionType.baseType]);`
	`13925`	`+ }`
	`13926`	`+`
`13922`	`13927`	`function isUnaryTupleTypeNode(node: TypeNode) {`
`13923`	`13928`	`return node.kind === SyntaxKind.TupleType && (node as TupleTypeNode).elements.length === 1;`
`13924`	`13929`	`}`
`@@ -13963,7 +13968,7 @@ namespace ts {`
`13963`	`13968`	`}`
`13964`	`13969`	`node = parent;`
`13965`	`13970`	`}`
`13966`		`- return constraints ? getSubstitutionType(type, getIntersectionType(append(constraints, type))) : type;`
	`13971`	`+ return constraints ? getSubstitutionType(type, getIntersectionType(constraints)) : type;`
`13967`	`13972`	`}`
`13968`	`13973`
`13969`	`13974`	`function isJSDocTypeReference(node: Node): node is TypeReferenceNode {`
`@@ -15363,7 +15368,7 @@ namespace ts {`
`15363`	`15368`	`type.flags & TypeFlags.Conditional ? (type as ConditionalType).root.isDistributive && (type as ConditionalType).checkType === typeVariable :`
`15364`	`15369`	`type.flags & (TypeFlags.UnionOrIntersection \| TypeFlags.TemplateLiteral) ? every((type as UnionOrIntersectionType \| TemplateLiteralType).types, isDistributive) :`
`15365`	`15370`	`type.flags & TypeFlags.IndexedAccess ? isDistributive((type as IndexedAccessType).objectType) && isDistributive((type as IndexedAccessType).indexType) :`
`15366`		`- type.flags & TypeFlags.Substitution ? isDistributive((type as SubstitutionType).substitute) :`
	`15371`	`+ type.flags & TypeFlags.Substitution ? isDistributive((type as SubstitutionType).baseType) && isDistributive((type as SubstitutionType).constraint):`
`15367`	`15372`	`type.flags & TypeFlags.StringMapping ? isDistributive((type as StringMappingType).type) :`
`15368`	`15373`	`false;`
`15369`	`15374`	`}`
`@@ -15883,7 +15888,7 @@ namespace ts {`
`15883`	`15888`	`if (type.flags & TypeFlags.Substitution) {`
`15884`	`15889`	`if (!((type as SubstitutionType).objectFlags & ObjectFlags.IsGenericTypeComputed)) {`
`15885`	`15890`	`(type as SubstitutionType).objectFlags \|= ObjectFlags.IsGenericTypeComputed \|`
`15886`		`- getGenericObjectFlags((type as SubstitutionType).substitute) \| getGenericObjectFlags((type as SubstitutionType).baseType);`
	`15891`	`+ getGenericObjectFlags((type as SubstitutionType).baseType) \| getGenericObjectFlags((type as SubstitutionType).constraint);`
`15887`	`15892`	`}`
`15888`	`15893`	`return (type as SubstitutionType).objectFlags & ObjectFlags.IsGenericType;`
`15889`	`15894`	`}`
`@@ -16095,11 +16100,7 @@ namespace ts {`
`16095`	`16100`	`const objectType = getTypeFromTypeNode(node.objectType);`
`16096`	`16101`	`const indexType = getTypeFromTypeNode(node.indexType);`
`16097`	`16102`	`const potentialAlias = getAliasSymbolForTypeNode(node);`
`16098`		`- const resolved = getIndexedAccessType(objectType, indexType, AccessFlags.None, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias));`
`16099`		`- links.resolvedType = resolved.flags & TypeFlags.IndexedAccess &&`
`16100`		`- (resolved as IndexedAccessType).objectType === objectType &&`
`16101`		`- (resolved as IndexedAccessType).indexType === indexType ?`
`16102`		`- getConditionalFlowTypeOfType(resolved, node) : resolved;`
	`16103`	`+ links.resolvedType = getIndexedAccessType(objectType, indexType, AccessFlags.None, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias));`
`16103`	`16104`	`}`
`16104`	`16105`	`return links.resolvedType;`
`16105`	`16106`	`}`
`@@ -17040,9 +17041,9 @@ namespace ts {`
`17040`	`17041`	`}`
`17041`	`17042`
`17042`	`17043`	`function getRestrictiveTypeParameter(tp: TypeParameter) {`
`17043`		`- return tp.constraint === unknownType ? tp : tp.restrictiveInstantiation \|\| (`
	`17044`	`+ return !tp.constraint && !getConstraintDeclaration(tp) \|\| tp.constraint === noConstraintType ? tp : tp.restrictiveInstantiation \|\| (`
`17044`	`17045`	`tp.restrictiveInstantiation = createTypeParameter(tp.symbol),`
`17045`		`- (tp.restrictiveInstantiation as TypeParameter).constraint = unknownType,`
	`17046`	`+ (tp.restrictiveInstantiation as TypeParameter).constraint = noConstraintType,`
`17046`	`17047`	`tp.restrictiveInstantiation`
`17047`	`17048`	`);`
`17048`	`17049`	`}`
`@@ -17429,17 +17430,18 @@ namespace ts {`
`17429`	`17430`	`return getConditionalTypeInstantiation(type as ConditionalType, combineTypeMappers((type as ConditionalType).mapper, mapper), aliasSymbol, aliasTypeArguments);`
`17430`	`17431`	`}`
`17431`	`17432`	`if (flags & TypeFlags.Substitution) {`
`17432`		`- const maybeVariable = instantiateType((type as SubstitutionType).baseType, mapper);`
`17433`		`- if (maybeVariable.flags & TypeFlags.TypeVariable) {`
`17434`		`- return getSubstitutionType(maybeVariable as TypeVariable, instantiateType((type as SubstitutionType).substitute, mapper));`
	`17433`	`+ const newBaseType = instantiateType((type as SubstitutionType).baseType, mapper);`
	`17434`	`+ const newConstraint = instantiateType((type as SubstitutionType).constraint, mapper);`
	`17435`	`+ // A substitution type originates in the true branch of a conditional type and can be resolved`
	`17436`	`+ // to just the base type in the same cases as the conditional type resolves to its true branch`
	`17437`	`+ // (because the base type is then known to satisfy the constraint).`
	`17438`	`+ if (newBaseType.flags & TypeFlags.TypeVariable && isGenericType(newConstraint)) {`
	`17439`	`+ return getSubstitutionType(newBaseType, newConstraint);`
`17435`	`17440`	`}`
`17436`		`- else {`
`17437`		`- const sub = instantiateType((type as SubstitutionType).substitute, mapper);`
`17438`		`- if (sub.flags & TypeFlags.AnyOrUnknown \|\| isTypeAssignableTo(getRestrictiveInstantiation(maybeVariable), getRestrictiveInstantiation(sub))) {`
`17439`		`- return maybeVariable;`
`17440`		`- }`
`17441`		`- return sub;`
	`17441`	`+ if (newConstraint.flags & TypeFlags.AnyOrUnknown \|\| isTypeAssignableTo(getRestrictiveInstantiation(newBaseType), getRestrictiveInstantiation(newConstraint))) {`
	`17442`	`+ return newBaseType;`
`17442`	`17443`	`}`
	`17444`	`+ return newBaseType.flags & TypeFlags.TypeVariable ? getSubstitutionType(newBaseType, newConstraint) : getIntersectionType([newConstraint, newBaseType]);`
`17443`	`17445`	`}`
`17444`	`17446`	`return type;`
`17445`	`17447`	`}`
`@@ -18478,7 +18480,7 @@ namespace ts {`
`18478`	`18480`	`const t = isFreshLiteralType(type) ? (type as FreshableType).regularType :`
`18479`	`18481`	`getObjectFlags(type) & ObjectFlags.Reference ? (type as TypeReference).node ? createTypeReference((type as TypeReference).target, getTypeArguments(type as TypeReference)) : getSingleBaseForNonAugmentingSubtype(type) \|\| type :`
`18480`	`18482`	`type.flags & TypeFlags.UnionOrIntersection ? getNormalizedUnionOrIntersectionType(type as UnionOrIntersectionType, writing) :`
`18481`		`- type.flags & TypeFlags.Substitution ? writing ? (type as SubstitutionType).baseType : (type as SubstitutionType).substitute :`
	`18483`	`+ type.flags & TypeFlags.Substitution ? writing ? (type as SubstitutionType).baseType : getSubstitutionIntersection(type as SubstitutionType) :`
`18482`	`18484`	`type.flags & TypeFlags.Simplifiable ? getSimplifiedType(type, writing) :`
`18483`	`18485`	`type;`
`18484`	`18486`	`if (t === type) return t;`
`@@ -19561,7 +19563,11 @@ namespace ts {`
`19561`	`19563`	`}`
`19562`	`19564`	`}`
`19563`	`19565`	`if (sourceFlags & TypeFlags.Substitution) {`
`19564`		`- return isRelatedTo((source as SubstitutionType).substitute, (target as SubstitutionType).substitute, RecursionFlags.Both, /reportErrors/ false);`
	`19566`	`+ if (result = isRelatedTo((source as SubstitutionType).baseType, (target as SubstitutionType).baseType, RecursionFlags.Both, /reportErrors/ false)) {`
	`19567`	`+ if (result &= isRelatedTo((source as SubstitutionType).constraint, (target as SubstitutionType).constraint, RecursionFlags.Both, /reportErrors/ false)) {`
	`19568`	`+ return result;`
	`19569`	`+ }`
	`19570`	`+ }`
`19565`	`19571`	`}`
`19566`	`19572`	`if (!(sourceFlags & TypeFlags.Object)) {`
`19567`	`19573`	`return Ternary.False;`
`@@ -22699,7 +22705,7 @@ namespace ts {`
`22699`	`22705`	`}`
`22700`	`22706`	`else if (source.flags & TypeFlags.Substitution) {`
`22701`	`22707`	`inferFromTypes((source as SubstitutionType).baseType, target);`
`22702`		`- inferWithPriority((source as SubstitutionType).substitute, target, InferencePriority.SubstituteSource); // Make substitute inference at a lower priority`
	`22708`	`+ inferWithPriority(getSubstitutionIntersection(source as SubstitutionType), target, InferencePriority.SubstituteSource); // Make substitute inference at a lower priority`
`22703`	`22709`	`}`
`22704`	`22710`	`else if (target.flags & TypeFlags.Conditional) {`
`22705`	`22711`	`invokeOnce(source, target, inferToConditionalType);`
Original file line number	Diff line number	Diff line change
`@@ -253,7 +253,7 @@ namespace ts { // eslint-disable-line local/one-namespace-per-file`
`253`	`253`	`const substitutionType = type as SubstitutionType;`
`254`	`254`	`substitutionProperties = {`
`255`	`255`	`substitutionBaseType: substitutionType.baseType?.id,`
`256`		`- substituteType: substitutionType.substitute?.id,`
	`256`	`+ constraintType: substitutionType.constraint?.id,`
`257`	`257`	`};`
`258`	`258`	`}`
`259`	`259`
Original file line number	Diff line number	Diff line change
`@@ -2840,7 +2840,7 @@ declare namespace ts {`
`2840`	`2840`	`export interface SubstitutionType extends InstantiableType {`
`2841`	`2841`	`objectFlags: ObjectFlags;`
`2842`	`2842`	`baseType: Type;`
`2843`		`- substitute: Type;`
	`2843`	`+ constraint: Type;`
`2844`	`2844`	`}`
`2845`	`2845`	`export enum SignatureKind {`
`2846`	`2846`	`Call = 0,`