Cache repeated mapper instantiations only within a single instantiation call

Author: Andarist

src/compiler/checker.ts

@@ -164,7 +164,6 @@ import {
     EmitResolver,
     EmitTextWriter,
     emptyArray,
-    emptyMap,
     EntityName,
     EntityNameExpression,
     EntityNameOrEntityNameExpression,
@@ -2111,14 +2110,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
         return t;
     }, () => "(unmeasurable reporter)");
-    reportUnreliableMapper.instantiations = emptyMap;
     var reportUnmeasurableMapper = makeFunctionTypeMapper(t => {
         if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
             outofbandVarianceMarkerHandler(/*onlyUnreliable*/ false);
         }
         return t;
     }, () => "(unreliable reporter)");
-    reportUnmeasurableMapper.instantiations = emptyMap;
 
     var emptyObjectType = createAnonymousType(/*symbol*/ undefined, emptySymbols, emptyArray, emptyArray, emptyArray);
     var emptyJsxObjectType = createAnonymousType(/*symbol*/ undefined, emptySymbols, emptyArray, emptyArray, emptyArray);
@@ -2319,6 +2316,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     var inferenceContexts: (InferenceContext | undefined)[] = [];
     var inferenceContextCount = 0;
 
+    var activeTypeMappers: TypeMapper[] = [];
+    var activeTypeMappersCaches: Map<string, Type>[] = [];
+    var activeTypeMappersCount = 0;
+
     var emptyStringType = getStringLiteralType("");
     var zeroType = getNumberLiteralType(0);
     var zeroBigIntType = getBigIntLiteralType({ negative: false, base10Value: "0" });
@@ -20374,22 +20375,25 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             error(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
             return errorType;
         }
-        let key: string;
-        if (mapper.instantiations !== emptyMap) {
-            key = type.id + getAliasId(aliasSymbol, aliasTypeArguments);
-            const cached = (mapper.instantiations ??= new Map()).get(key);
-            if (cached) {
-                return cached;
-            }
+        const index = findActiveMapper(mapper);
+        if (index === -1) {
+            pushActiveMapper(mapper);
+        }
+        const key = type.id + getAliasId(aliasSymbol, aliasTypeArguments);
+        const mapperCache = activeTypeMappersCaches[index !== -1 ? index : activeTypeMappersCount - 1];
+        const cached = mapperCache.get(key);
+        if (cached) {
+            return cached;
         }
         totalInstantiationCount++;
         instantiationCount++;
         instantiationDepth++;
         const result = instantiateTypeWorker(type, mapper, aliasSymbol, aliasTypeArguments);
-        if (mapper.instantiations !== emptyMap) {
-            // volatile caches (like on `nonFixingMapper`) could have been cleared by the above `instantiateTypeWorker`
-            // if so, we don't want to cache the result as it likely won't be valid anymore anyway
-            mapper.instantiations?.set(key!, result);
+        if (index === -1) {
+            popActiveMapper();
+        }
+        else {
+            mapperCache.set(key, result);
         }
         instantiationDepth--;
         return result;
@@ -25594,7 +25598,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
 
     function clearCachedInferences(context: InferenceContext | undefined, inferences: InferenceInfo[]) {
         if (context) {
-            context.nonFixingMapper.instantiations = undefined;
+            clearActiveMapperCache(context.nonFixingMapper);
         }
         for (const inference of inferences) {
             if (!inference.isFixed) {
@@ -26967,7 +26971,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     // instantiating the constraint could reenter this function if the type parameter's constraint depends on that parameter
                     // in such a case the reentering call just returns the preemptively set `.inferredType`
                     // but given the `.inferredType` gets changed changed above, the cached instantiations have to be cleared because they were cached for the wrong type
-                    context.nonFixingMapper.instantiations = undefined;
+                    clearActiveMapperCache(context.nonFixingMapper);
                 }
             }
         }
@@ -32186,6 +32190,32 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
     }
 
+    function pushActiveMapper(mapper: TypeMapper) {
+        activeTypeMappers[activeTypeMappersCount] = mapper;
+        activeTypeMappersCaches[activeTypeMappersCount] = new Map();
+        activeTypeMappersCount++;
+    }
+
+    function popActiveMapper() {
+        activeTypeMappersCount--;
+    }
+
+    function findActiveMapper(mapper: TypeMapper) {
+        for (let i = activeTypeMappersCount - 1; i >= 0; i--) {
+            if (mapper === activeTypeMappers[i]) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    function clearActiveMapperCache(mapper: TypeMapper) {
+        const index = findActiveMapper(mapper);
+        if (index !== -1) {
+            activeTypeMappersCaches[index] = new Map();
+        }
+    }
+
     function getContextualImportAttributeType(node: ImportAttribute) {
         return getTypeOfPropertyOfContextualType(getGlobalImportAttributesType(/*reportErrors*/ false), getNameFromImportAttribute(node));
     }

src/compiler/core.ts

@@ -16,7 +16,7 @@ import {
 /** @internal */
 export const emptyArray: never[] = [] as never[];
 /** @internal */
-export const emptyMap: Map<never, never> = new Map<never, never>();
+export const emptyMap: ReadonlyMap<never, never> = new Map<never, never>();
 
 /** @internal */
 export function length(array: readonly any[] | undefined): number {

src/compiler/types.ts

@@ -7029,11 +7029,11 @@ export const enum TypeMapKind {
 
 /** @internal */
 export type TypeMapper =
-    | { kind: TypeMapKind.Simple; source: Type; target: Type; instantiations?: Map<string, Type>; }
-    | { kind: TypeMapKind.Array; sources: readonly Type[]; targets: readonly Type[] | undefined; instantiations?: Map<string, Type>; }
-    | { kind: TypeMapKind.Deferred; sources: readonly Type[]; targets: (() => Type)[]; instantiations?: Map<string, Type>; }
-    | { kind: TypeMapKind.Function; func: (t: Type) => Type; debugInfo?: () => string; instantiations?: Map<string, Type>; }
-    | { kind: TypeMapKind.Composite | TypeMapKind.Merged; mapper1: TypeMapper; mapper2: TypeMapper; instantiations?: Map<string, Type>; };
+    | { kind: TypeMapKind.Simple; source: Type; target: Type; }
+    | { kind: TypeMapKind.Array; sources: readonly Type[]; targets: readonly Type[] | undefined; }
+    | { kind: TypeMapKind.Deferred; sources: readonly Type[]; targets: (() => Type)[]; }
+    | { kind: TypeMapKind.Function; func: (t: Type) => Type; debugInfo?: () => string; }
+    | { kind: TypeMapKind.Composite | TypeMapKind.Merged; mapper1: TypeMapper; mapper2: TypeMapper; };
 
 // dprint-ignore
 export const enum InferencePriority {

tests/baselines/reference/callsOnComplexSignatures.types

@@ -3,7 +3,7 @@
 === Performance Stats ===
 Assignability cache: 2,500
 Type Count: 10,000
-Instantiation count: 10,000
+Instantiation count: 50,000
 Symbol count: 50,000
 
 === callsOnComplexSignatures.tsx ===

tests/baselines/reference/checkJsxChildrenCanBeTupleType.types

@@ -3,7 +3,7 @@
 === Performance Stats ===
 Assignability cache: 2,500
 Type Count: 10,000
-Instantiation count: 10,000
+Instantiation count: 50,000
 Symbol count: 50,000
 
 === checkJsxChildrenCanBeTupleType.tsx ===

tests/baselines/reference/checkJsxChildrenProperty16.types

@@ -3,7 +3,7 @@
 === Performance Stats ===
 Assignability cache: 2,500
 Type Count: 10,000
-Instantiation count: 10,000
+Instantiation count: 50,000
 Symbol count: 50,000
 
 === checkJsxChildrenProperty16.tsx ===

tests/baselines/reference/checkJsxUnionSFXContextualTypeInferredCorrectly.types

@@ -3,7 +3,7 @@
 === Performance Stats ===
 Assignability cache: 2,500
 Type Count: 10,000
-Instantiation count: 10,000
+Instantiation count: 50,000
 Symbol count: 50,000
 
 === checkJsxUnionSFXContextualTypeInferredCorrectly.tsx ===

tests/baselines/reference/conditionalTypeDiscriminatingLargeUnionRegularTypeFetchingSpeedReasonable.types

@@ -4,7 +4,7 @@
 Strict subtype cache: 2,500
 Assignability cache: 10,000
 Type Count: 10,000
-Instantiation count: 25,000
+Instantiation count: 50,000
 
 === conditionalTypeDiscriminatingLargeUnionRegularTypeFetchingSpeedReasonable.ts ===
 type BigUnion =

tests/baselines/reference/conditionalTypeVarianceBigArrayConstraintsPerformance.types

@@ -3,7 +3,7 @@
 === Performance Stats ===
 Assignability cache: 1,000
 Type Count: 5,000
-Instantiation count: 5,000
+Instantiation count: 50,000
 Symbol count: 50,000
 
 === conditionalTypeVarianceBigArrayConstraintsPerformance.ts ===

tests/baselines/reference/contextuallyTypedJsxAttribute2.types

@@ -3,7 +3,7 @@
 === Performance Stats ===
 Assignability cache: 5,000
 Type Count: 10,000
-Instantiation count: 100,000
+Instantiation count: 250,000
 Symbol count: 100,000
 
 === contextuallyTypedJsxAttribute2.tsx ===