tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/checker-inference.js

@@ -1,32 +1,31 @@
 // Type inference: inference contexts, inferring from source to target types, and the inferred
 // types of type parameters.
 import { sideOf, signatureSideOf } from './side-state.js';
+import { isInJSFile } from './ast-utilities.js';
 import { hasSyntacticModifier } from './binder-utilities.js';
-import { ArrayToSingleTypeMapper, MergedTypeMapper, TupleElementInfo, TypeMapper, newTypeMapper, SimpleTypeMapper, emptyTypes, } from './checker-types.js';
-import { createAnonymousType, createArrayType, createArrayTypeEx, createTupleType, createTupleTypeEx, filterType, getBaseTypeOfLiteralType, getBigIntLiteralType, getElementTypes, getEndElementCount, getIntersectionType, getNumberLiteralType, getRegularTypeOfLiteralType, getStringLiteralType, getTemplateLiteralType, getTypeArguments, getTypeReferenceArity, getUnionType, getUnionTypeEx, getWidenedLiteralType, isArrayOrTupleType, isErrorType, isArrayType, isGenericTupleType, isLiteralType, isMutableArrayOrTuple, isReadonlyArrayType, isTupleType, mapType, newIndexInfo, newObjectType, setStructuredTypeMembers, someType, tupleTargetOf, typesOf, } from './checker-type-factory.js';
+import { ArrayToSingleTypeMapper, MergedTypeMapper, TupleElementInfo, TypeMapper, newTypeMapper, SimpleTypeMapper, emptyTypes, getNonDistributedTypeParameter, } from './checker-types.js';
+import { createAnonymousType, createArrayType, createArrayTypeEx, createTupleType, createTupleTypeEx, filterType, getBaseTypeOfLiteralType, getBigIntLiteralType, getElementTypes, getEndElementCount, getIntersectionType, getNumberLiteralType, getRegularTypeOfLiteralType, getStringLiteralType, getTemplateLiteralType, getTypeArguments, getTypeReferenceArity, getUnionType, getUnionTypeEx, getWidenedLiteralType, isArrayOrTupleType, isErrorType, isArrayType, isGenericTupleType, isLiteralType, isMutableArrayOrTuple, isReadonlyArrayType, isTupleType, mapType, newIndexInfo, newObjectType, setStructuredTypeMembers, someType, tupleTargetOf, typesOf, compareTypes, } from './checker-type-factory.js';
 import { getDeclaredTypeOfClassOrInterface, getDeclaredTypeOfSymbol, fillMissingTypeArguments, getConstraintOfTypeParameter, getDefaultFromTypeParameter, getMinTypeArgumentCount, getDeclaredTypeOfTypeParameter, } from './checker-declared-types.js';
 import { applyStringMapping, getActualTypeVariable, getBranchTypesFromConditionalType, getConstraintFromConditionalType, getConstraintOfConditionalType, getConstraintTypeFromMappedType, getElementTypeOfSliceOfTupleType, getFalseTypeFromConditionalType, getHomomorphicTypeVariable, getIndexType, getIndexTypeEx, getIndexedAccessType, getLiteralTypeFromProperty, getMappedTypeModifiers, getNameTypeFromMappedType, getSimplifiedType, getSubstitutionIntersection, getTemplateTypeFromMappedType, getTrueTypeFromConditionalType, getTypeParameterFromMappedType, isGenericMappedType, isNoInferType, isTypeMatchedByTemplateLiteralType, shouldDeferIndexType, } from './checker-type-operators.js';
 import { getApparentType, getApplicableIndexInfo, getBaseConstraintOfType, getBaseConstraintOrType, getConstraintOfType, getIndexInfoOfType, getIndexInfosOfType, getPropertiesOfObjectType, getPropertiesOfType, getPropertyOfType, getPropertyOfUnionOrIntersectionType, getReducedApparentType, getReducedType, getSignaturesOfType, getTypeWithThisArgument, isApplicableIndexType, isObjectLiteralType, } from './checker-members.js';
 import { getEffectiveRestType, getErasedSignature, getParameterCount, getRestTypeAtPosition, getReturnTypeOfSignature, getSignatureInstantiation, getThisTypeOfSignature, getTypeAtPosition, getTypePredicateOfSignature, sliceTupleType, } from './checker-signatures.js';
 import { getNullableType, getTypeOfSymbol, getWidenedType, isReadonlySymbol, removeMissingOrUndefinedType, removeMissingType, } from './checker-symbol-types.js';
 import { combineTypeMappers, couldContainTypeVariables, instantiateSignature, instantiateSignatureEx, instantiateType, instantiateTypes, } from './instantiation.js';
-import { getAliasVariances, getComparer, getUnmatchedProperty, getVariances, isUnmatchedProperty, isDeeplyNestedType, setStackEntry, isObjectTypeWithInferableIndex, isTypeAssignableTo, isTypeIdenticalTo, isTypeStrictSubtypeOf, isTypeSubtypeOf, } from './relations.js';
+import { getAliasVariances, getComparer, getUnmatchedProperty, getVariances, isUnmatchedProperty, isDeeplyNestedStackEntry, isDeeplyNestedType, setStackEntry, isObjectTypeWithInferableIndex, isTypeAssignableTo, isTypeIdenticalTo, isTypeStrictSubtypeOf, isTypeSubtypeOf, } from './relations.js';
 import { maybeTypeOfKind } from './checker-utilities.js';
 import { getTypeFromTypeNode } from './checker-type-nodes.js';
-import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
+import { findResolutionCycleStartIndex, getMergedSymbol, getSymbolOfDeclaration, } from './checker-symbols.js';
 import { parsePseudoBigInt } from './pseudo-bigint.js';
 import { getContextualTypeForInference } from './checker-contextual.js';
 import { copyDeclarations, declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
 // Shared empty candidate lists: an InferenceInfo gets its own on its first candidate, as tsgo's nil
 // slices do. Never changed.
 const noCandidates = [];
-const noCandidateDepths = [];
 /** Inferences for one type parameter. */
 export class InferenceInfo {
     typeParameter;
-    /** Covariant candidates, in decreasing depth order. */
+    /** Covariant candidates. */
     candidates = noCandidates;
-    candidateDepths = noCandidateDepths;
     contraCandidates = noCandidates;
     inferredType = undefined;
     priority = 2048 /* InferencePriority.MaxValue */;
@@ -39,10 +38,8 @@ export class InferenceInfo {
     }
     clone() {
         const info = new InferenceInfo(this.typeParameter);
-        if (this.candidates.length !== 0) {
+        if (this.candidates.length !== 0)
             info.candidates = this.candidates.slice();
-            info.candidateDepths = this.candidateDepths.slice();
-        }
         if (this.contraCandidates.length !== 0)
             info.contraCandidates = this.contraCandidates.slice();
         info.inferredType = this.inferredType;
@@ -201,7 +198,7 @@ function hasTypeParameterDefault(tp) {
     if (symbol === undefined)
         return false;
     for (const d of getDeclarations(symbol))
-        if (d.kind === 169 /* SyntaxKind.TypeParameter */ && d.defaultType !== undefined)
+        if (d.kind === 170 /* SyntaxKind.TypeParameter */ && d.defaultType !== undefined)
             return true;
     return false;
 }
@@ -222,6 +219,224 @@ export function inferTypes(c, inferences, source, target, priority, contravarian
     const state = new InferenceState(c, inferences, target, priority, contravariant);
     state.inferFromTypes(source, target);
 }
+/** Whether no inference has a candidate or an inferred type, or is fixed, as in a new context. */
+function isUnstarted(inferences) {
+    for (const i of inferences)
+        if (i.candidates.length !== 0 || i.contraCandidates.length !== 0 || i.inferredType !== undefined || i.isFixed)
+            return false;
+    return true;
+}
+/** A memoized `inferTypesFromUnstarted` walk. */
+export class UnstartedInference {
+    state;
+    inferences;
+    /** The instantiations the walk does, which a skipped walk adds to the counts. */
+    instantiations;
+    /** The instantiation depth the confirming walk started at: a walk starting deeper might reach the limit. */
+    depth;
+    /** The variance reliability flags the walk reports. */
+    reliabilityFlags;
+    /** The unions and intersections the walk searched before their properties were resolved. */
+    searched;
+    constructor(state, inferences, instantiations, depth, reliabilityFlags, searched) {
+        this.state = state;
+        this.inferences = inferences;
+        this.instantiations = instantiations;
+        this.depth = depth;
+        this.reliabilityFlags = reliabilityFlags;
+        this.searched = searched;
+    }
+}
+const verifyUnstartedInferences = process.env['TSC_TS_VERIFY_INFERENCE_MEMO'] === '1';
+/**
+ * `inferTypes` into the inferences for `signature`'s type parameters, to `target`, which is
+ * determined by `signature` (its return type). When no inference has started, the walk depends only
+ * on `signature`, `source` and `priority`, so it is memoized per checker. Contextual return type
+ * inference repeats the same walk for calls of a generic function with the same contextual type at
+ * different call sites.
+ *
+ * A walk is skipped only when it would add nothing but the inferences:
+ * - Once a second and a third walk have both created no types or signatures and done the same. The
+ *   first walk resolves the types it reaches; only walks that repeat keep their inferences.
+ * - With the instantiation count and depth replayed. The walk is skipped only where it could not
+ *   reach the instantiation limits.
+ * - With the variance reliability flags replayed.
+ * - Never when a walk reported a diagnostic or met a circularity. Never during a variance
+ *   computation, where relations are not cached and circularities are found differently.
+ * - Only while the unions and intersections whose unresolved properties the walk searched
+ *   (hasUnmatchedProperty) are still unresolved. Once they are resolved, the same walk creates the
+ *   property types, so it is learned again.
+ */
+export function inferTypesFromUnstarted(c, signature, inferences, source, target, priority) {
+    if (c.varianceStack.length !== 0 || !isUnstarted(inferences)) {
+        inferTypes(c, inferences, source, target, priority, false);
+        return;
+    }
+    const caches = c.inferenceCaches;
+    const memo = caches.unstartedInferences;
+    let bySource = memo.get(signature.id);
+    if (bySource === undefined) {
+        bySource = new Map();
+        memo.set(signature.id, bySource);
+    }
+    const key = source.id * 4096 + priority;
+    let known = bySource.get(key);
+    if (known !== undefined && known.state === 2 /* UnstartedInferenceState.Confirmed */) {
+        if (havePropertiesResolved(c, known.searched)) {
+            // Learn the walk again for the resolved properties; each union's properties are resolved once.
+            bySource.delete(key);
+            known = undefined;
+        }
+        else if (c.instantiationDepth <= known.depth && c.instantiationCount + known.instantiations < 5000000) {
+            if (verifyUnstartedInferences)
+                verifyUnstartedInference(c, signature, known, source, target, priority);
+            copyInferences(inferences, known.inferences);
+            const outer = c.unresolvedPropertySearches;
+            if (outer !== undefined)
+                for (const t of known.searched)
+                    outer.push(t);
+            c.instantiationCount += known.instantiations;
+            c.totalInstantiations += known.instantiations;
+            c.reliabilityFlags |= known.reliabilityFlags;
+            return;
+        }
+    }
+    const reports = c.reports;
+    const cycles = c.resolutionCycleCount;
+    const outerSearches = c.unresolvedPropertySearches;
+    const searches = [];
+    c.unresolvedPropertySearches = searches;
+    const types = c.typeCount;
+    const signatures = c.signatureCount;
+    const count = c.instantiationCount;
+    const total = c.totalInstantiations;
+    const depth = c.instantiationDepth;
+    const reliabilityFlags = c.reliabilityFlags;
+    // Nothing reads the flags before setting them, so the walk's own are those it leaves from zero.
+    c.reliabilityFlags = 0;
+    inferTypes(c, inferences, source, target, priority, false);
+    const walkFlags = c.reliabilityFlags;
+    c.reliabilityFlags = reliabilityFlags | walkFlags;
+    c.unresolvedPropertySearches = outerSearches;
+    // An enclosing walk depends on the searches of the walks within it.
+    if (outerSearches !== undefined)
+        for (const t of searches)
+            outerSearches.push(t);
+    const state = known === undefined ? undefined : known.state;
+    if (state === 2 /* UnstartedInferenceState.Confirmed */ || state === 3 /* UnstartedInferenceState.Unusable */)
+        return;
+    const instantiations = c.totalInstantiations - total;
+    if (c.reports !== reports || c.resolutionCycleCount !== cycles || c.instantiationCount - count !== instantiations) {
+        bySource.set(key, caches.alwaysWalked);
+        return;
+    }
+    if (state === undefined) {
+        bySource.set(key, caches.seenOnce);
+        return;
+    }
+    if (c.typeCount !== types || c.signatureCount !== signatures) {
+        bySource.set(key, caches.alwaysWalked);
+        return;
+    }
+    const searched = searches.length === 0 ? searches : [...new Set(searches)];
+    if (state === 0 /* UnstartedInferenceState.Seen */) {
+        const snapshot = [];
+        for (const i of inferences)
+            snapshot.push(i.clone());
+        bySource.set(key, new UnstartedInference(1 /* UnstartedInferenceState.Walked */, snapshot, instantiations, depth, walkFlags, searched));
+        return;
+    }
+    bySource.set(key, sameInferences(inferences, known.inferences) &&
+        instantiations === known.instantiations &&
+        walkFlags === known.reliabilityFlags
+        ? new UnstartedInference(2 /* UnstartedInferenceState.Confirmed */, known.inferences, instantiations, depth, walkFlags, searched)
+        : caches.alwaysWalked);
+}
+/** Whether the properties of any of `types` have been resolved. */
+function havePropertiesResolved(c, types) {
+    for (const t of types)
+        if (sideOf(c, t).membersOf?.resolvedProperties !== undefined)
+            return true;
+    return false;
+}
+function copyInferences(inferences, from) {
+    for (let k = 0; k < inferences.length; k++) {
+        const info = inferences[k];
+        const known = from[k];
+        if (known.candidates.length !== 0)
+            info.candidates = known.candidates.slice();
+        if (known.contraCandidates.length !== 0)
+            info.contraCandidates = known.contraCandidates.slice();
+        info.inferredType = known.inferredType;
+        info.priority = known.priority;
+        info.topLevel = known.topLevel;
+        info.isFixed = known.isFixed;
+        info.impliedArity = known.impliedArity;
+    }
+}
+function sameTypes(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let k = 0; k < a.length; k++)
+        if (a[k] !== b[k])
+            return false;
+    return true;
+}
+function sameInferences(a, b) {
+    for (let k = 0; k < a.length; k++) {
+        const x = a[k];
+        const y = b[k];
+        if (!sameTypes(x.candidates, y.candidates) ||
+            !sameTypes(x.contraCandidates, y.contraCandidates) ||
+            x.inferredType !== y.inferredType ||
+            x.priority !== y.priority ||
+            x.topLevel !== y.topLevel ||
+            x.isFixed !== y.isFixed ||
+            x.impliedArity !== y.impliedArity)
+            return false;
+    }
+    return true;
+}
+/** With TSC_TS_VERIFY_INFERENCE_MEMO=1: walks anyway and reports how the skipped walk would have differed. */
+function verifyUnstartedInference(c, signature, known, source, target, priority) {
+    const inferences = [];
+    for (const i of known.inferences)
+        inferences.push(new InferenceInfo(i.typeParameter));
+    const types = c.typeCount;
+    const signatures = c.signatureCount;
+    const total = c.totalInstantiations;
+    const reports = c.reports;
+    const cycles = c.resolutionCycleCount;
+    const reliabilityFlags = c.reliabilityFlags;
+    const outerSearches = c.unresolvedPropertySearches;
+    c.reliabilityFlags = 0;
+    c.unresolvedPropertySearches = undefined;
+    inferTypes(c, inferences, source, target, priority, false);
+    const walkFlags = c.reliabilityFlags;
+    c.reliabilityFlags = reliabilityFlags;
+    c.unresolvedPropertySearches = outerSearches;
+    const instantiations = c.totalInstantiations - total;
+    // Undo the check walk's count so the run continues as without verification.
+    c.instantiationCount -= instantiations;
+    c.totalInstantiations -= instantiations;
+    const differences = [];
+    if (!sameInferences(inferences, known.inferences))
+        differences.push('inferences');
+    if (c.typeCount !== types)
+        differences.push(`${c.typeCount - types} types`);
+    if (c.signatureCount !== signatures)
+        differences.push(`${c.signatureCount - signatures} signatures`);
+    if (instantiations !== known.instantiations)
+        differences.push(`${instantiations} instantiations, not ${known.instantiations}`);
+    if (c.reports !== reports)
+        differences.push(`${c.reports - reports} diagnostics`);
+    if (c.resolutionCycleCount !== cycles)
+        differences.push('a circularity');
+    if (walkFlags !== known.reliabilityFlags)
+        differences.push('reliability flags');
+    if (differences.length !== 0)
+        process.stderr.write(`inference memo: signature ${signature.id} source ${source.id} priority ${priority}: ${differences.join(', ')}\n`);
+}
 class MatchedTypes {
     sources;
     targets;
@@ -251,20 +466,34 @@ class InferenceState {
     bivariant = false;
     expandingFlags = 0 /* ExpandingFlags.None */;
     propagationType = undefined;
-    /** invokeOnce's pairs by packed type ids (`visitKey`), or spelled when an id is too large to pack. */
+    /**
+     * The statuses of the pairs invokeOnce finished, for each priority and variance of the walk (`visitMode`), by
+     * packed type ids (`visitKey`), or spelled when an id is too large to pack. The first pair with packed ids is in
+     * `firstVisitKey` instead: most walks finish at most one.
+     */
     visited = undefined;
     visitedSpelled = undefined;
-    /** invokeOnce's recursion stacks; the first `stackDepth` entries of each are live. */
-    sourceStack = [];
-    targetStack = [];
+    /** The mode `visitedPairs` belongs to, or -1 before the first `visitedPairsOf`. */
+    visitedMode = -1;
+    /** `visited`'s map for `visitedMode`; a walk mostly stays in one mode. */
+    visitedPairs = undefined;
+    /** The first finished pair with packed ids (-1 before it), its mode and its status. */
+    firstVisitKey = -1;
+    firstVisitMode = 0;
+    firstVisitStatus = 2048 /* InferencePriority.MaxValue */;
+    /**
+     * Where this walk's entries start on the checker's invokeOnce stacks (`InferenceCaches.invokeSourceStack`). The
+     * `stackDepth` entries from there are live: the pairs being visited.
+     */
+    stackBase;
     stackDepth = 0;
-    depth = 0;
     constructor(c, inferences, originalTarget, priority, contravariant) {
         this.c = c;
         this.inferences = inferences;
         this.originalTarget = originalTarget;
         this.priority = priority;
         this.contravariant = contravariant;
+        this.stackBase = c.inferenceCaches.invokeStackDepth;
     }
     infoFor(t) {
         return getInferenceInfoForType(this.inferences, t);
@@ -284,14 +513,9 @@ class InferenceState {
         const sourceAlias = source.alias;
         const targetAlias = target.alias;
         if (sourceAlias !== undefined && targetAlias !== undefined && sourceAlias.symbol === targetAlias.symbol) {
-            if (sourceAlias.typeArguments.length !== 0 || targetAlias.typeArguments.length !== 0) {
-                // Instantiations of the same alias: infer between the type arguments, with defaults applied.
-                const params = c.symbolLinks(sourceAlias.symbol).typeParameters ?? [];
-                const minParams = getMinTypeArgumentCount(c, params);
-                const sourceTypes = fillMissingTypeArguments(c, sourceAlias.typeArguments, params, minParams, false);
-                const targetTypes = fillMissingTypeArguments(c, targetAlias.typeArguments, params, minParams, false);
-                this.inferFromTypeArguments(sourceTypes, targetTypes, someTypeCouldHoldInference(c, targetTypes) ? getAliasVariances(c, sourceAlias.symbol) : noVariances);
-            }
+            // Instantiations of the same alias infer between their type arguments, once for each pair of types, as tsc does.
+            if (sourceAlias.typeArguments.length !== 0 || targetAlias.typeArguments.length !== 0)
+                this.invokeOnce(source, target, 0 /* InferenceAction.AliasTypeArguments */);
             return;
         }
         if (source === target && (source.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
@@ -302,7 +526,7 @@ class InferenceState {
         if ((target.flags & 134217728 /* TypeFlags.Union */) !== 0) {
             const sourceTypes = (source.flags & 134217728 /* TypeFlags.Union */) !== 0 ? typesOf(source) : [source];
             // Infer between identically matching constituents, then closely matching ones, removing them.
-            const temp = this.inferFromMatchingTypes(sourceTypes, distributedTypes(target), 0 /* MatchKind.TypeOrBaseIdentical */);
+            const temp = this.inferFromMatchingTypes(sourceTypes, typesOf(target), 0 /* MatchKind.TypeOrBaseIdentical */);
             const matched = this.inferFromMatchingTypes(temp.sources, temp.targets, 1 /* MatchKind.CloselyMatched */);
             if (matched.targets.length === 0)
                 return;
@@ -355,7 +579,7 @@ class InferenceState {
             (target.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 &&
             (referenceTarget(source) === referenceTarget(target) || (isArrayType(c, source) && isArrayType(c, target))) &&
             !(referenceNode(source) !== undefined && referenceNode(target) !== undefined)) {
-            this.inferFromReferenceTypeArguments(source, target);
+            this.invokeOnce(source, target, 4 /* InferenceAction.ReferenceTypeArguments */);
         }
         else if ((source.flags & 2097152 /* TypeFlags.Index */) !== 0 && (target.flags & 2097152 /* TypeFlags.Index */) !== 0) {
             this.inferFromContravariantTypes(source.target, target.target);
@@ -379,7 +603,7 @@ class InferenceState {
             this.inferWithPriority(getSubstitutionIntersection(c, source), target, 4 /* InferencePriority.SubstituteSource */);
         }
         else if ((target.flags & 67108864 /* TypeFlags.Conditional */) !== 0) {
-            this.invokeOnce(source, target, 0 /* InferenceAction.ConditionalType */);
+            this.invokeOnce(source, target, 1 /* InferenceAction.ConditionalType */);
         }
         else if ((target.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
             this.inferToMultipleTypes(source, typesOf(target), target.flags);
@@ -394,7 +618,7 @@ class InferenceState {
         else {
             source = getReducedType(c, source);
             if (isGenericMappedType(c, source) && isGenericMappedType(c, target))
-                this.invokeOnce(source, target, 1 /* InferenceAction.GenericMappedTypes */);
+                this.invokeOnce(source, target, 2 /* InferenceAction.GenericMappedTypes */);
             if (!((this.priority & 512 /* InferencePriority.NoConstraints */) !== 0 &&
                 (source.flags & (268435456 /* TypeFlags.Intersection */ | 132644864 /* TypeFlags.Instantiable */)) !== 0)) {
                 const apparentSource = getApparentType(c, source);
@@ -406,7 +630,7 @@ class InferenceState {
                 source = apparentSource;
             }
             if ((source.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */)) !== 0)
-                this.invokeOnce(source, target, 2 /* InferenceAction.ObjectTypes */);
+                this.invokeOnce(source, target, 3 /* InferenceAction.ObjectTypes */);
         }
     }
     inferToTypeVariable(inference, source, target) {
@@ -420,7 +644,6 @@ class InferenceState {
                 return;
             if (this.priority < inference.priority) {
                 inference.candidates = noCandidates;
-                inference.candidateDepths = noCandidateDepths;
                 inference.contraCandidates = noCandidates;
                 inference.topLevel = true;
                 inference.priority = this.priority;
@@ -435,31 +658,11 @@ class InferenceState {
                         clearCachedInferences(this.inferences);
                     }
                 }
-                else {
-                    let index = inference.candidates.indexOf(candidate);
-                    if (index < 0 || inference.candidateDepths[index] < this.depth) {
-                        if (index >= 0) {
-                            inference.candidates.splice(index, 1);
-                            inference.candidateDepths.splice(index, 1);
-                        }
-                        if (inference.candidates === noCandidates) {
-                            inference.candidates = [];
-                            inference.candidateDepths = [];
-                        }
-                        // Keep candidates with the highest depth first.
-                        index = 0;
-                        while (index < inference.candidateDepths.length && inference.candidateDepths[index] >= this.depth)
-                            index++;
-                        if (index === inference.candidates.length) {
-                            inference.candidates.push(candidate);
-                            inference.candidateDepths.push(this.depth);
-                        }
-                        else {
-                            inference.candidates.splice(index, 0, candidate);
-                            inference.candidateDepths.splice(index, 0, this.depth);
-                        }
-                        clearCachedInferences(this.inferences);
-                    }
+                else if (!inference.candidates.includes(candidate)) {
+                    if (inference.candidates === noCandidates)
+                        inference.candidates = [];
+                    inference.candidates.push(candidate);
+                    clearCachedInferences(this.inferences);
                 }
             }
             if ((this.priority & 128 /* InferencePriority.ReturnType */) === 0 &&
@@ -484,7 +687,6 @@ class InferenceState {
         this.inferFromTypeArguments(sourceTypes, targetTypes, someTypeCouldHoldInference(c, targetTypes) ? getVariances(c, referenceTarget(source)) : noVariances);
     }
     inferFromTypeArguments(sourceTypes, targetTypes, variances) {
-        this.depth++;
         const count = Math.min(sourceTypes.length, targetTypes.length);
         for (let i = 0; i < count; i++) {
             if (i < variances.length && (variances[i] & 7 /* VarianceFlags.VarianceMask */) === 2 /* VarianceFlags.Contravariant */)
@@ -492,7 +694,6 @@ class InferenceState {
             else
                 this.inferFromTypes(sourceTypes[i], targetTypes[i]);
         }
-        this.depth--;
     }
     inferWithPriority(source, target, newPriority) {
         const savePriority = this.priority;
@@ -519,62 +720,138 @@ class InferenceState {
     }
     /** Runs `action` once per source and target pair, stopping at circularities. */
     invokeOnce(source, target, action) {
+        // As in tsc, a pair is visited once for each priority and variance it is inferred with.
+        const mode = visitMode(this.priority, this.contravariant, this.bivariant);
         const key = visitKey(source, target);
-        const status = key >= 0 ? this.visited?.get(key) : this.visitedSpelled?.get(source.id + ',' + target.id);
+        const status = this.getVisited(source, target, key, mode);
         if (status !== undefined) {
             this.inferencePriority = Math.min(this.inferencePriority, status);
             return;
         }
-        this.setVisited(source, target, key, -1 /* InferencePriority.Circularity */);
         const saveInferencePriority = this.inferencePriority;
         this.inferencePriority = 2048 /* InferencePriority.MaxValue */;
         // Duplicate recursion identities on both sides mean a circularity.
         const saveExpandingFlags = this.expandingFlags;
+        const caches = this.c.inferenceCaches;
         const stackDepth = this.stackDepth;
-        setStackEntry(this.sourceStack, stackDepth, source);
-        setStackEntry(this.targetStack, stackDepth, target);
+        const start = this.stackBase;
+        const end = start + stackDepth + 1;
+        setStackEntry(caches.invokeSourceStack, end - 1, source);
+        setStackEntry(caches.invokeTargetStack, end - 1, target);
+        setNumberEntry(caches.invokeModeStack, end - 1, mode);
+        setNumberEntry(caches.invokeSourceIdentities, end - 1, 0);
+        setNumberEntry(caches.invokeTargetIdentities, end - 1, 0);
         this.stackDepth = stackDepth + 1;
-        if (isDeeplyNestedType(this.c, source, this.sourceStack, stackDepth + 1, 2))
+        caches.invokeStackDepth = end;
+        if (isDeeplyNestedStackEntry(this.c, caches.invokeSourceStack, caches.invokeSourceIdentities, start, end, 2))
             this.expandingFlags |= 1 /* ExpandingFlags.Source */;
-        if (isDeeplyNestedType(this.c, target, this.targetStack, stackDepth + 1, 2))
+        if (isDeeplyNestedStackEntry(this.c, caches.invokeTargetStack, caches.invokeTargetIdentities, start, end, 2))
             this.expandingFlags |= 2 /* ExpandingFlags.Target */;
         if (this.expandingFlags !== 3 /* ExpandingFlags.Both */) {
             switch (action) {
-                case 0 /* InferenceAction.ConditionalType */:
+                case 0 /* InferenceAction.AliasTypeArguments */:
+                    this.inferFromAliasTypeArguments(source, target);
+                    break;
+                case 1 /* InferenceAction.ConditionalType */:
                     this.inferToConditionalType(source, target);
                     break;
-                case 1 /* InferenceAction.GenericMappedTypes */:
+                case 2 /* InferenceAction.GenericMappedTypes */:
                     this.inferFromGenericMappedTypes(source, target);
                     break;
-                case 2 /* InferenceAction.ObjectTypes */:
+                case 3 /* InferenceAction.ObjectTypes */:
                     this.inferFromObjectTypes(source, target);
                     break;
+                case 4 /* InferenceAction.ReferenceTypeArguments */:
+                    this.inferFromReferenceTypeArguments(source, target);
+                    break;
             }
         }
         else
             this.inferencePriority = -1 /* InferencePriority.Circularity */;
         this.stackDepth = stackDepth;
+        caches.invokeStackDepth = end - 1;
         this.expandingFlags = saveExpandingFlags;
-        this.setVisited(source, target, key, this.inferencePriority);
+        this.setVisited(source, target, key, mode, this.inferencePriority);
         this.inferencePriority = Math.min(this.inferencePriority, saveInferencePriority);
     }
-    setVisited(source, target, key, status) {
+    /**
+     * The status of the pair in `mode`: its status once it is finished, Circularity while it is being visited, and
+     * undefined before its first visit.
+     */
+    getVisited(source, target, key, mode) {
         if (key >= 0) {
-            let visited = this.visited;
-            if (visited === undefined) {
-                visited = new Map();
-                this.visited = visited;
-            }
-            visited.set(key, status);
+            if (key === this.firstVisitKey && mode === this.firstVisitMode)
+                return this.firstVisitStatus;
+            const status = this.visited !== undefined ? this.visitedPairsOf(mode)?.get(key) : undefined;
+            if (status !== undefined)
+                return status;
         }
         else {
+            const status = this.visitedSpelled?.get(source.id + ',' + target.id + ',' + mode);
+            if (status !== undefined)
+                return status;
+        }
+        const caches = this.c.inferenceCaches;
+        const targetStack = caches.invokeTargetStack;
+        const end = this.stackBase + this.stackDepth;
+        for (let i = this.stackBase; i < end; i++)
+            if (targetStack[i] === target && caches.invokeSourceStack[i] === source && caches.invokeModeStack[i] === mode)
+                return -1 /* InferencePriority.Circularity */;
+        return undefined;
+    }
+    /** Records the status of a finished pair. */
+    setVisited(source, target, key, mode, status) {
+        if (key < 0) {
             let visited = this.visitedSpelled;
             if (visited === undefined) {
                 visited = new Map();
                 this.visitedSpelled = visited;
             }
-            visited.set(source.id + ',' + target.id, status);
+            visited.set(source.id + ',' + target.id + ',' + mode, status);
+        }
+        else if (this.firstVisitKey < 0) {
+            this.firstVisitKey = key;
+            this.firstVisitMode = mode;
+            this.firstVisitStatus = status;
         }
+        else {
+            let modes = this.visited;
+            if (modes === undefined) {
+                modes = new Map();
+                this.visited = modes;
+            }
+            let pairs = this.visitedPairsOf(mode);
+            if (pairs === undefined) {
+                pairs = new Map();
+                modes.set(mode, pairs);
+                this.visitedMode = mode;
+                this.visitedPairs = pairs;
+            }
+            pairs.set(key, status);
+        }
+    }
+    // Source and target are instantiations of the same type alias: infers between the type arguments, with defaults
+    // applied.
+    inferFromAliasTypeArguments(source, target) {
+        const c = this.c;
+        const sourceAlias = source.alias;
+        const params = c.symbolLinks(sourceAlias.symbol).typeParameters ?? [];
+        const minParams = getMinTypeArgumentCount(c, params);
+        const isJavaScript = isInJSFile(sourceAlias.symbol.valueDeclaration);
+        const sourceTypes = fillMissingTypeArguments(c, sourceAlias.typeArguments, params, minParams, isJavaScript);
+        const targetTypes = fillMissingTypeArguments(c, target.alias.typeArguments, params, minParams, isJavaScript);
+        this.inferFromTypeArguments(sourceTypes, targetTypes, someTypeCouldHoldInference(c, targetTypes) ? getAliasVariances(c, sourceAlias.symbol) : noVariances);
+    }
+    /** `visited`'s map of the pairs finished in `mode`, if there is one. */
+    visitedPairsOf(mode) {
+        if (mode === this.visitedMode)
+            return this.visitedPairs;
+        const pairs = this.visited?.get(mode);
+        if (pairs !== undefined) {
+            this.visitedMode = mode;
+            this.visitedPairs = pairs;
+        }
+        return pairs;
     }
     inferFromMatchingTypes(sources, targets, kind) {
         const c = this.c;
@@ -583,12 +860,24 @@ class InferenceState {
         for (const t of targets)
             for (const s of sources)
                 if (typesMatch(c, s, t, kind)) {
-                    this.inferFromTypes(s, t);
+                    if (kind !== 1 /* MatchKind.CloselyMatched */)
+                        this.inferFromTypes(s, t);
                     if (!matchedSources.includes(s))
                         matchedSources.push(s);
                     if (!matchedTargets.includes(t))
                         matchedTargets.push(t);
                 }
+        if (kind === 1 /* MatchKind.CloselyMatched */) {
+            // Infer to closely matched targets in decreasing depth of generic instantiations: an inference
+            // from a more deeply nested type argument has had more layers of instantiation stripped away. For
+            // example, from `string[] | string[][]` to `T[] | T[][]`, relating `string[][]` to `T[][]` infers
+            // `string`, a better inference than the `string[]` that relating `string[][]` to `T[]` infers.
+            matchedTargets.sort((t1, t2) => compareTypesAndDepth(c, t1, t2));
+            for (const t of matchedTargets)
+                for (const s of matchedSources)
+                    if (typesMatch(c, s, t, kind))
+                        this.inferFromTypes(s, t);
+        }
         return new MatchedTypes(matchedSources.length !== 0 ? sources.filter((t) => !matchedSources.includes(t)) : sources, matchedTargets.length !== 0 ? targets.filter((t) => !matchedTargets.includes(t)) : targets);
     }
     inferToMultipleTypes(source, targets, targetFlags) {
@@ -675,10 +964,11 @@ class InferenceState {
         const c = this.c;
         if ((source.flags & 67108864 /* TypeFlags.Conditional */) !== 0) {
             const s = source;
-            this.inferFromTypes(s.checkType, target.checkType);
-            this.inferFromTypes(s.extendsType, target.extendsType);
-            this.inferFromTypes(getTrueTypeFromConditionalType(c, s), getTrueTypeFromConditionalType(c, target));
-            this.inferFromTypes(getFalseTypeFromConditionalType(c, s), getFalseTypeFromConditionalType(c, target));
+            // A source's distributed type parameters infer as the type parameters they were made from.
+            this.inferFromTypes(getNonDistributedTypeParameter(s.checkType), target.checkType);
+            this.inferFromTypes(getNonDistributedTypeParameter(s.extendsType), target.extendsType);
+            this.inferFromTypes(getNonDistributedTypeParameter(getTrueTypeFromConditionalType(c, s)), getTrueTypeFromConditionalType(c, target));
+            this.inferFromTypes(getNonDistributedTypeParameter(getFalseTypeFromConditionalType(c, s)), getFalseTypeFromConditionalType(c, target));
         }
         else {
             const savePriority = this.priority;
@@ -888,9 +1178,9 @@ class InferenceState {
             // Once in a bivariant signature, nested inferences stay bivariant.
             this.bivariant =
                 this.bivariant ||
-                    kind === 175 /* SyntaxKind.MethodDeclaration */ ||
-                    kind === 174 /* SyntaxKind.MethodSignature */ ||
-                    kind === 177 /* SyntaxKind.Constructor */;
+                    kind === 176 /* SyntaxKind.MethodDeclaration */ ||
+                    kind === 175 /* SyntaxKind.MethodSignature */ ||
+                    kind === 178 /* SyntaxKind.Constructor */;
             applyToParameterTypes(c, source, target, (s, t) => this.inferFromContravariantTypesIfStrictFunctionTypes(s, t));
             this.bivariant = saveBivariant;
         }
@@ -965,12 +1255,47 @@ class InferenceState {
 }
 // ---- Helpers
 function getInferenceInfoForType(inferences, t) {
-    if ((t.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0)
+    if ((t.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0) {
+        const typeVariable = getNonDistributedTypeParameter(t);
         for (const inference of inferences)
-            if (t === inference.typeParameter)
+            if (typeVariable === inference.typeParameter)
                 return inference;
+    }
     return undefined;
 }
+/** Orders types by decreasing depth, then by the regular type ordering. */
+function compareTypesAndDepth(c, t1, t2) {
+    const d1 = getTypeDepth(c, t1, 3);
+    const d2 = getTypeDepth(c, t2, 3);
+    if (d1 !== d2)
+        return d2 - d1;
+    return compareTypes(c, t1, t2);
+}
+/**
+ * The depth of a type, up to `maxDepth`: one plus the largest type argument depth for generic aliased
+ * types and type references, the largest constituent depth for unions and intersections, and zero
+ * otherwise. The maximum keeps circular types from recursing forever.
+ */
+function getTypeDepth(c, t, maxDepth) {
+    if (maxDepth !== 0) {
+        if (t.alias !== undefined && t.alias.typeArguments.length !== 0)
+            return getTypeListDepth(c, t.alias.typeArguments, maxDepth - 1) + 1;
+        if ((t.objectFlags & 4 /* ObjectFlags.Reference */) !== 0) {
+            const typeArguments = getTypeArguments(c, t);
+            if (typeArguments.length !== 0)
+                return getTypeListDepth(c, typeArguments, maxDepth - 1) + 1;
+        }
+        if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0)
+            return getTypeListDepth(c, typesOf(t), maxDepth);
+    }
+    return 0;
+}
+function getTypeListDepth(c, types, maxDepth) {
+    let depth = 0;
+    for (const t of types)
+        depth = Math.max(depth, getTypeDepth(c, t, maxDepth));
+    return depth;
+}
 function distributedTypes(t) {
     return (t.flags & 134217728 /* TypeFlags.Union */) !== 0 ? typesOf(t) : [t];
 }
@@ -990,9 +1315,10 @@ function someTypeCouldHoldInference(c, targets) {
 }
 /**
  * `couldContainTypeVariables` without two of its conservative answers: a deferred reference without an
- * alias, once its type arguments are resolved, holds type variables only through them, like any other
- * reference; and the static side of a class declared at the top level of a file or module holds none
- * outside its generic signatures, which inference erases.
+ * alias holds type variables only through its type arguments, like any other reference; and the static
+ * side of a class declared at the top level of a file or module holds none outside its generic
+ * signatures, which inference erases. A deferred reference's type arguments are resolved here unless
+ * they are being resolved already, where resolving them would report a circularity.
  */
 function couldHoldInference(c, t, depth) {
     if (!couldContainTypeVariables(c, t))
@@ -1000,7 +1326,11 @@ function couldHoldInference(c, t, depth) {
     if (t.alias !== undefined || depth === 4)
         return true;
     if ((t.objectFlags & 4 /* ObjectFlags.Reference */) !== 0) {
-        const resolved = t.resolvedTypeArguments ?? sideOf(c, t).resolvedTypeArguments;
+        const resolved = t.resolvedTypeArguments ??
+            sideOf(c, t).resolvedTypeArguments ??
+            (findResolutionCycleStartIndex(c, t, 5 /* TypeSystemPropertyName.ResolvedTypeArguments */) < 0
+                ? getTypeArguments(c, t)
+                : undefined);
         if (resolved === undefined)
             return true;
         for (const a of resolved)
@@ -1021,12 +1351,12 @@ function isTopLevelClassStaticSide(t) {
         declarationCount(symbol) === 0)
         return false;
     for (const d of getDeclarations(symbol)) {
-        if (d.kind !== 264 /* SyntaxKind.ClassDeclaration */ &&
-            d.kind !== 265 /* SyntaxKind.InterfaceDeclaration */ &&
-            d.kind !== 268 /* SyntaxKind.ModuleDeclaration */)
+        if (d.kind !== 265 /* SyntaxKind.ClassDeclaration */ &&
+            d.kind !== 266 /* SyntaxKind.InterfaceDeclaration */ &&
+            d.kind !== 269 /* SyntaxKind.ModuleDeclaration */)
             return false;
-        for (let n = d.parent; n.kind !== 307 /* SyntaxKind.SourceFile */; n = n.parent)
-            if (n.kind !== 269 /* SyntaxKind.ModuleBlock */ && n.kind !== 268 /* SyntaxKind.ModuleDeclaration */)
+        for (let n = d.parent; n.kind !== 308 /* SyntaxKind.SourceFile */; n = n.parent)
+            if (n.kind !== 270 /* SyntaxKind.ModuleBlock */ && n.kind !== 269 /* SyntaxKind.ModuleDeclaration */)
                 return false;
     }
     return true;
@@ -1130,6 +1460,8 @@ function hasUnmatchedProperty(c, source, target, matchDiscriminantProperties) {
     if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) === 0 ||
         sideOf(c, t).membersOf?.resolvedProperties !== undefined)
         return getUnmatchedProperty(c, source, target, false, matchDiscriminantProperties) !== undefined;
+    if (c.unresolvedPropertySearches !== undefined)
+        c.unresolvedPropertySearches.push(t);
     const containingType = t;
     const isUnion = (t.flags & 134217728 /* TypeFlags.Union */) !== 0;
     const checked = new Set();
@@ -1205,7 +1537,8 @@ export function isConstTypeVariable(c, t, depth) {
 }
 export function isMutableArrayLikeType(c, t) {
     return (isMutableArrayOrTuple(c, t) ||
-        ((t.flags & (1 /* TypeFlags.Any */ | 12 /* TypeFlags.Nullable */)) === 0 && isTypeAssignableTo(c, t, c.anyArrayType)));
+        ((t.flags & (1 /* TypeFlags.Any */ | 12 /* TypeFlags.Nullable */ | 262144 /* TypeFlags.Never */)) === 0 &&
+            isTypeAssignableTo(c, t, c.anyArrayType)));
 }
 function typePredicateKindsMatch(a, b) {
     return a.kind === b.kind && a.parameterIndex === b.parameterIndex;
@@ -1328,7 +1661,11 @@ export function isUnmatchedTemplateLiteralKey(source, target) {
     return failsTemplateLiteralTextTest(source, target);
 }
 /** The types matched by `target`'s placeholders in `source`, or undefined if it doesn't match. */
-export function inferTypesFromTemplateLiteralType(c, source, target) {
+/**
+ * The types that `source` gives the placeholders of `target`. A placeholder of a source template with the same
+ * texts keeps its type where `compareTypes` (assignability by default) relates their base constraints.
+ */
+export function inferTypesFromTemplateLiteralType(c, source, target, compareTypes) {
     if ((source.flags & 1024 /* TypeFlags.StringLiteral */) !== 0) {
         // Most string literals fail the start and end text test; apply it before building the
         // one-element source texts.
@@ -1342,9 +1679,12 @@ export function inferTypesFromTemplateLiteralType(c, source, target) {
             const result = [];
             for (let i = 0; i < s.types.length; i++) {
                 const t = s.types[i];
-                result.push(isTypeAssignableTo(c, getBaseConstraintOrType(c, t), getBaseConstraintOrType(c, target.types[i]))
-                    ? t
-                    : getStringLikeTypeForType(c, t));
+                const sourceConstraint = getBaseConstraintOrType(c, t);
+                const targetConstraint = getBaseConstraintOrType(c, target.types[i]);
+                const related = compareTypes !== undefined
+                    ? compareTypes(sourceConstraint, targetConstraint)
+                    : isTypeAssignableTo(c, sourceConstraint, targetConstraint);
+                result.push(related ? t : getStringLikeTypeForType(c, t));
             }
             return result;
         }
@@ -1641,7 +1981,7 @@ export function resolveReverseMappedTypeMembers(c, t) {
             if (!isTypeAssignableTo(c, propertyNameType, limitedConstraint))
                 continue;
         }
-        const checkFlags = 8192 /* CheckFlags.ReverseMapped */ | (readonlyMask && isReadonlySymbol(c, prop) ? 8 /* CheckFlags.Readonly */ : 0);
+        const checkFlags = 65536 /* CheckFlags.ReverseMapped */ | (readonlyMask && isReadonlySymbol(c, prop) ? 8 /* CheckFlags.Readonly */ : 0);
         const inferredProp = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | (prop.flags & optionalMask), prop.name, checkFlags);
         copyDeclarations(inferredProp, prop);
         const links = c.symbolLinks(inferredProp);
@@ -1761,7 +2101,10 @@ export function getInferredType(c, context, index) {
     const constraint = getConstraintOfTypeParameter(c, inference.typeParameter);
     if (constraint !== undefined) {
         const instantiatedConstraint = instantiateType(c, constraint, context.nonFixingMapper);
-        if (inferredType !== undefined) {
+        // A pure return type inference is still filtered in a recursive call resolution: its result can become
+        // the type of the enclosing declaration.
+        if (inferredType !== undefined &&
+            ((context.flags & 8 /* InferenceFlags.NoConstraintChecks */) === 0 || inference.priority === 128 /* InferencePriority.ReturnType */)) {
             const constraintWithThis = getTypeWithThisArgument(c, instantiatedConstraint, inferredType, false);
             if (context.compareTypes.compare(inferredType, constraintWithThis, false) === 0 /* Ternary.False */) {
                 // A pure return type inference may still succeed without the constituents the constraint rejects.
@@ -1790,8 +2133,18 @@ function clearActiveMapperCaches(c) {
         if (cache !== undefined)
             cache.clear();
 }
+function setNumberEntry(stack, depth, value) {
+    if (depth < stack.length)
+        stack[depth] = value;
+    else
+        stack.push(value);
+}
 /** Type ids below this bound pack in pairs into one exact number. */
 const VisitKeyIdLimit = 1 << 26;
+/** The priority and variance of an inference walk, packed. */
+function visitMode(priority, contravariant, bivariant) {
+    return priority * 4 + (contravariant ? 2 : 0) + (bivariant ? 1 : 0);
+}
 /** invokeOnce's key for a pair of types: both ids in one number, or -1 when an id is too large. */
 function visitKey(source, target) {
     const s = source.id;
@@ -1998,11 +2351,32 @@ export class InferenceCaches {
     contextFreeTypes = new Map();
     reverseMapped = new Map();
     reverseHomomorphicMapped = new Map();
+    /**
+     * invokeOnce's recursion stacks, shared by the checker's inference walks, with the mode of each visit and the
+     * recursion identities isDeeplyNestedStackEntry keeps for each entry. The first `invokeStackDepth` entries are live.
+     * A walk's entries start where the live entries end when it starts (`InferenceState.stackBase`), so a walk started
+     * during another one keeps the other's entries.
+     */
+    invokeSourceStack = [];
+    invokeTargetStack = [];
+    invokeModeStack = [];
+    invokeSourceIdentities = [];
+    invokeTargetIdentities = [];
+    invokeStackDepth = 0;
     /** inferReverseMappedType's recursion stacks; the first `reverseStackDepth` entries of each are live. */
     reverseSourceStack = [];
     reverseTargetStack = [];
     reverseStackDepth = 0;
     reverseExpandingFlags = 0 /* ExpandingFlags.None */;
+    /**
+     * What `inferTypesFromUnstarted` left in each inference, by signature id, then by source type id
+     * times 4096 plus the priority.
+     */
+    unstartedInferences = new Map();
+    /** The `unstartedInferences` entry of a walk seen once. */
+    seenOnce = new UnstartedInference(0 /* UnstartedInferenceState.Seen */, [], 0, 0, 0, []);
+    /** The `unstartedInferences` entry of a walk that is never skipped. */
+    alwaysWalked = new UnstartedInference(3 /* UnstartedInferenceState.Unusable */, [], 0, 0, 0, []);
 }
 // ---- Constraints of `infer` type parameters
 /**
@@ -2044,18 +2418,18 @@ export function getInferredTypeParameterConstraint(c, t, omitTypeReferences = fa
     const symbol = t.symbol;
     if (symbol !== undefined)
         for (const declaration of getDeclarations(symbol)) {
-            if (declaration.parent === undefined || declaration.parent.kind !== 196 /* SyntaxKind.InferType */)
+            if (declaration.parent === undefined || declaration.parent.kind !== 197 /* SyntaxKind.InferType */)
                 continue;
             let child = declaration.parent;
             let parent = child.parent;
-            while (parent !== undefined && parent.kind === 197 /* SyntaxKind.ParenthesizedType */) {
+            while (parent !== undefined && parent.kind === 198 /* SyntaxKind.ParenthesizedType */) {
                 child = parent;
                 parent = child.parent;
             }
             if (parent === undefined)
                 continue;
             switch (parent.kind) {
-                case 184 /* SyntaxKind.TypeReference */: {
+                case 185 /* SyntaxKind.TypeReference */: {
                     if (omitTypeReferences)
                         break;
                     // `Foo<infer T>` takes the constraint of Foo's corresponding type parameter.
@@ -2075,34 +2449,34 @@ export function getInferredTypeParameterConstraint(c, t, omitTypeReferences = fa
                         inferences.push(constraint);
                     break;
                 }
-                case 170 /* SyntaxKind.Parameter */:
+                case 171 /* SyntaxKind.Parameter */:
                     if (parent.dotDotDotToken !== undefined)
                         inferences.push(createArrayType(c, c.unknownType));
                     break;
-                case 192 /* SyntaxKind.RestType */:
+                case 193 /* SyntaxKind.RestType */:
                     inferences.push(createArrayType(c, c.unknownType));
                     break;
-                case 203 /* SyntaxKind.NamedTupleMember */:
+                case 204 /* SyntaxKind.NamedTupleMember */:
                     if (parent.dotDotDotToken !== undefined)
                         inferences.push(createArrayType(c, c.unknownType));
                     break;
-                case 205 /* SyntaxKind.TemplateLiteralTypeSpan */:
+                case 206 /* SyntaxKind.TemplateLiteralTypeSpan */:
                     inferences.push(c.stringType);
                     break;
-                case 169 /* SyntaxKind.TypeParameter */:
-                    if (parent.parent !== undefined && parent.parent.kind === 201 /* SyntaxKind.MappedType */)
+                case 170 /* SyntaxKind.TypeParameter */:
+                    if (parent.parent !== undefined && parent.parent.kind === 202 /* SyntaxKind.MappedType */)
                         inferences.push(c.stringNumberSymbolType);
                     break;
-                case 201 /* SyntaxKind.MappedType */: {
+                case 202 /* SyntaxKind.MappedType */: {
                     // `{ [P in K]: X } extends { [Q in L]: infer U }` constrains U to X with P replaced by K.
                     const mapped = parent;
                     const conditional = parent.parent;
                     if (mapped.type !== undefined &&
                         mapped.type === declaration.parent &&
                         conditional !== undefined &&
-                        conditional.kind === 195 /* SyntaxKind.ConditionalType */ &&
+                        conditional.kind === 196 /* SyntaxKind.ConditionalType */ &&
                         conditional.extendsType === parent &&
-                        conditional.checkType.kind === 201 /* SyntaxKind.MappedType */ &&
+                        conditional.checkType.kind === 202 /* SyntaxKind.MappedType */ &&
                         conditional.checkType.type !== undefined) {
                         const checkMappedType = conditional.checkType;
                         const nodeType = getTypeFromTypeNode(c, checkMappedType.type);