tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,2105 @@
+// 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 { hasSyntacticModifier } from './binder-utilities.js';
+import { getSymbolId } from './symbol.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 { 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 { maybeTypeOfKind } from './checker-utilities.js';
+import { getTypeFromTypeNode } from './checker-type-nodes.js';
+import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
+import { parsePseudoBigInt } from './pseudo-bigint.js';
+import { getContextualTypeForInference } from './checker-contextual.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. */
+    candidates = noCandidates;
+    candidateDepths = noCandidateDepths;
+    contraCandidates = noCandidates;
+    inferredType = undefined;
+    priority = 2048 /* InferencePriority.MaxValue */;
+    /** Whether all inferences are to top-level occurrences. */
+    topLevel = true;
+    isFixed = false;
+    impliedArity = -1;
+    constructor(typeParameter) {
+        this.typeParameter = typeParameter;
+    }
+    clone() {
+        const info = new InferenceInfo(this.typeParameter);
+        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;
+        info.priority = this.priority;
+        info.topLevel = this.topLevel;
+        info.isFixed = this.isFixed;
+        info.impliedArity = this.impliedArity;
+        return info;
+    }
+}
+export class IntraExpressionInferenceSite {
+    node;
+    type;
+    constructor(node, type) {
+        this.node = node;
+        this.type = type;
+    }
+}
+export class InferenceContext {
+    inferences;
+    /** The generic signature inferences are made for, if any. */
+    signature;
+    flags;
+    compareTypes;
+    /** Fixes inferences. */
+    mapper;
+    nonFixingMapper;
+    /** Maps to inferences from the return type, if any. */
+    returnMapper = undefined;
+    outerReturnMapper = undefined;
+    inferredTypeParameters = undefined;
+    intraExpressionInferenceSites = [];
+    constructor(c, inferences, signature, flags, compareTypes) {
+        this.inferences = inferences;
+        this.signature = signature;
+        this.flags = flags;
+        this.compareTypes = compareTypes;
+        this.mapper = new InferenceTypeMapper(c, this, true);
+        this.nonFixingMapper = new InferenceTypeMapper(c, this, false);
+    }
+}
+/** Maps a context's type parameters to their inferred types, optionally fixing them. */
+export class InferenceTypeMapper extends TypeMapper {
+    c;
+    context;
+    fixing;
+    constructor(c, context, fixing) {
+        super();
+        this.c = c;
+        this.context = context;
+        this.fixing = fixing;
+    }
+    map(type) {
+        const inferences = this.context.inferences;
+        for (let i = 0; i < inferences.length; i++) {
+            const inference = inferences[i];
+            if (type !== inference.typeParameter)
+                continue;
+            if (this.fixing && !inference.isFixed) {
+                // Infer from intra-expression sites before committing to an inference.
+                inferFromIntraExpressionSites(this.c, this.context);
+                clearCachedInferences(inferences);
+                inference.isFixed = true;
+            }
+            return getInferredType(this.c, this.context, i);
+        }
+        return type;
+    }
+}
+export function createInferenceContext(c, typeParameters, signature, flags, compareTypes) {
+    const inferences = [];
+    for (const tp of typeParameters)
+        inferences.push(new InferenceInfo(tp));
+    return new InferenceContext(c, inferences, signature, flags, compareTypes ?? getComparer(c, 2 /* ComparerKind.Assignable */));
+}
+export function cloneInferenceContext(c, context, extraFlags) {
+    return new InferenceContext(c, context.inferences.map((i) => i.clone()), context.signature, context.flags | extraFlags, context.compareTypes);
+}
+export function cloneInferredPartOfContext(c, context) {
+    const inferences = [];
+    for (const i of context.inferences)
+        if (hasInferenceCandidates(i))
+            inferences.push(i.clone());
+    if (inferences.length === 0)
+        return undefined;
+    return new InferenceContext(c, inferences, context.signature, context.flags, context.compareTypes);
+}
+export function getMapperFromContext(context) {
+    return context !== undefined ? context.mapper : undefined;
+}
+/** The context's return mapper combined with a mapper erasing its other type parameters to their current inferences. */
+export function createOuterReturnMapper(c, context) {
+    if (context.outerReturnMapper === undefined) {
+        let mapper = cloneInferenceContext(c, context, 0 /* InferenceFlags.None */).mapper;
+        if (context.returnMapper !== undefined)
+            mapper = new MergedTypeMapper(context.returnMapper, mapper);
+        context.outerReturnMapper = mapper;
+    }
+    return context.outerReturnMapper;
+}
+export function addIntraExpressionInferenceSite(context, node, type) {
+    context.intraExpressionInferenceSites.push(new IntraExpressionInferenceSite(node, type));
+}
+export function clearCachedInferences(inferences) {
+    for (const inference of inferences)
+        if (!inference.isFixed)
+            inference.inferredType = undefined;
+}
+export function hasInferenceCandidates(info) {
+    return info.candidates.length !== 0 || info.contraCandidates.length !== 0;
+}
+export function hasInferenceCandidatesOrDefault(info) {
+    return hasInferenceCandidates(info) || hasTypeParameterDefault(info.typeParameter);
+}
+export function someInferenceHasCandidates(inferences) {
+    for (const info of inferences)
+        if (hasInferenceCandidates(info))
+            return true;
+    return false;
+}
+export function everyInferenceHasCandidates(inferences) {
+    for (const info of inferences)
+        if (!hasInferenceCandidates(info))
+            return false;
+    return true;
+}
+export function someInferenceHasCandidatesOrDefault(inferences) {
+    for (const info of inferences)
+        if (hasInferenceCandidatesOrDefault(info))
+            return true;
+    return false;
+}
+function hasTypeParameterDefault(tp) {
+    const symbol = tp.symbol;
+    if (symbol === undefined)
+        return false;
+    for (const d of symbol.declarations)
+        if (d.kind === 169 /* SyntaxKind.TypeParameter */ && d.defaultType !== undefined)
+            return true;
+    return false;
+}
+export function hasOverlappingInferences(a, b) {
+    for (let i = 0; i < a.length; i++)
+        if (hasInferenceCandidates(a[i]) && hasInferenceCandidates(b[i]))
+            return true;
+    return false;
+}
+export function mergeInferences(target, source) {
+    for (let i = 0; i < target.length; i++)
+        if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i]))
+            target[i] = source[i];
+}
+// ---- Inferring from types
+/** Infers from `source` to `target` for the type parameters of `inferences`. */
+export function inferTypes(c, inferences, source, target, priority, contravariant) {
+    const state = new InferenceState(c, inferences, target, priority, contravariant);
+    state.inferFromTypes(source, target);
+}
+class MatchedTypes {
+    sources;
+    targets;
+    constructor(sources, targets) {
+        this.sources = sources;
+        this.targets = targets;
+    }
+}
+function typesMatch(c, s, t, kind) {
+    switch (kind) {
+        case 0 /* MatchKind.TypeOrBaseIdentical */:
+            return isTypeOrBaseIdenticalTo(c, s, t);
+        case 1 /* MatchKind.CloselyMatched */:
+            return isTypeCloselyMatchedBy(s, t);
+        case 2 /* MatchKind.Identical */:
+            return isTypeIdenticalTo(c, s, t);
+    }
+}
+/** The state of one `inferTypes` walk. */
+class InferenceState {
+    c;
+    inferences;
+    originalTarget;
+    priority;
+    inferencePriority = 2048 /* InferencePriority.MaxValue */;
+    contravariant;
+    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. */
+    visited = undefined;
+    visitedSpelled = undefined;
+    /** invokeOnce's recursion stacks; the first `stackDepth` entries of each are live. */
+    sourceStack = [];
+    targetStack = [];
+    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;
+    }
+    infoFor(t) {
+        return getInferenceInfoForType(this.inferences, t);
+    }
+    inferFromTypes(source, target) {
+        const c = this.c;
+        if (!couldContainTypeVariables(c, target) || isNoInferType(c, target))
+            return;
+        if (source === c.wildcardType || source === c.blockedStringType) {
+            // Infer the `any`-like source for every type parameter referenced in the target.
+            const savePropagationType = this.propagationType;
+            this.propagationType = source;
+            this.inferFromTypes(target, target);
+            this.propagationType = savePropagationType;
+            return;
+        }
+        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);
+            }
+            return;
+        }
+        if (source === target && (source.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
+            for (const t of typesOf(source))
+                this.inferFromTypes(t, t);
+            return;
+        }
+        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 matched = this.inferFromMatchingTypes(temp.sources, temp.targets, 1 /* MatchKind.CloselyMatched */);
+            if (matched.targets.length === 0)
+                return;
+            target = getUnionType(c, matched.targets);
+            if (matched.sources.length === 0) {
+                // Everything matched; infer from the full source at lower priority so that `string` to
+                // `string | T` still infers `string` for T.
+                this.inferWithPriority(source, target, 1 /* InferencePriority.NakedTypeVariable */);
+                return;
+            }
+            source = getUnionType(c, matched.sources);
+        }
+        else if ((target.flags & 268435456 /* TypeFlags.Intersection */) !== 0 && !everyNonGenericObjectType(c, typesOf(target))) {
+            // Reduce intersections unless they're simple combinations of object types.
+            if ((source.flags & 134217728 /* TypeFlags.Union */) === 0) {
+                const sourceTypes = (source.flags & 268435456 /* TypeFlags.Intersection */) !== 0 ? typesOf(source) : [source];
+                const matched = this.inferFromMatchingTypes(sourceTypes, typesOf(target), 2 /* MatchKind.Identical */);
+                if (matched.sources.length === 0 || matched.targets.length === 0)
+                    return;
+                source = getIntersectionType(c, matched.sources);
+                target = getIntersectionType(c, matched.targets);
+            }
+        }
+        if ((target.flags & (33554432 /* TypeFlags.IndexedAccess */ | 16777216 /* TypeFlags.Substitution */)) !== 0) {
+            if (isNoInferType(c, target))
+                return;
+            target = getActualTypeVariable(c, target);
+        }
+        if ((target.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0) {
+            const inference = this.infoFor(target);
+            if (inference !== undefined) {
+                this.inferToTypeVariable(inference, source, target);
+                return;
+            }
+            // Infer to the simplified indexed access to expose more bare type parameters.
+            const simplified = getSimplifiedType(c, target, false);
+            if (simplified !== target)
+                this.inferFromTypes(source, simplified);
+            else if ((target.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0) {
+                const access = target;
+                const indexType = getSimplifiedType(c, access.indexType, false);
+                if ((indexType.flags & 132644864 /* TypeFlags.Instantiable */) !== 0) {
+                    const distributed = distributeIndexOverObjectType(c, getSimplifiedType(c, access.objectType, false), indexType);
+                    if (distributed !== undefined && distributed !== target)
+                        this.inferFromTypes(source, distributed);
+                }
+            }
+        }
+        if ((source.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 &&
+            (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);
+        }
+        else if ((source.flags & 2097152 /* TypeFlags.Index */) !== 0 && (target.flags & 2097152 /* TypeFlags.Index */) !== 0) {
+            this.inferFromContravariantTypes(source.target, target.target);
+        }
+        else if ((isLiteralType(source) || (source.flags & 32 /* TypeFlags.String */) !== 0) &&
+            (target.flags & 2097152 /* TypeFlags.Index */) !== 0) {
+            const empty = createEmptyObjectTypeFromStringLiteral(c, source);
+            this.inferFromContravariantTypesWithPriority(empty, target.target, 256 /* InferencePriority.LiteralKeyof */);
+        }
+        else if ((source.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0 && (target.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0) {
+            this.inferFromTypes(source.objectType, target.objectType);
+            this.inferFromTypes(source.indexType, target.indexType);
+        }
+        else if ((source.flags & 8388608 /* TypeFlags.StringMapping */) !== 0 && (target.flags & 8388608 /* TypeFlags.StringMapping */) !== 0) {
+            if (source.symbol === target.symbol)
+                this.inferFromTypes(source.target, target.target);
+        }
+        else if ((source.flags & 16777216 /* TypeFlags.Substitution */) !== 0) {
+            this.inferFromTypes(source.baseType, target);
+            // Substitutes infer at a lower priority.
+            this.inferWithPriority(getSubstitutionIntersection(c, source), target, 4 /* InferencePriority.SubstituteSource */);
+        }
+        else if ((target.flags & 67108864 /* TypeFlags.Conditional */) !== 0) {
+            this.invokeOnce(source, target, 0 /* InferenceAction.ConditionalType */);
+        }
+        else if ((target.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
+            this.inferToMultipleTypes(source, typesOf(target), target.flags);
+        }
+        else if ((source.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+            for (const sourceType of typesOf(source))
+                this.inferFromTypes(sourceType, target);
+        }
+        else if ((target.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
+            this.inferToTemplateLiteralType(source, target);
+        }
+        else {
+            source = getReducedType(c, source);
+            if (isGenericMappedType(c, source) && isGenericMappedType(c, target))
+                this.invokeOnce(source, target, 1 /* InferenceAction.GenericMappedTypes */);
+            if (!((this.priority & 512 /* InferencePriority.NoConstraints */) !== 0 &&
+                (source.flags & (268435456 /* TypeFlags.Intersection */ | 132644864 /* TypeFlags.Instantiable */)) !== 0)) {
+                const apparentSource = getApparentType(c, source);
+                // The apparent type of an indexed access or conditional may be any type; restart with it.
+                if (apparentSource !== source && (apparentSource.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */)) === 0) {
+                    this.inferFromTypes(apparentSource, target);
+                    return;
+                }
+                source = apparentSource;
+            }
+            if ((source.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */)) !== 0)
+                this.invokeOnce(source, target, 2 /* InferenceAction.ObjectTypes */);
+        }
+    }
+    inferToTypeVariable(inference, source, target) {
+        const c = this.c;
+        // Non-inferrable sources are markers that must not become candidates.
+        if ((source.objectFlags & 262144 /* ObjectFlags.NonInferrableType */) !== 0 || source === c.nonInferrableAnyType)
+            return;
+        if (!inference.isFixed) {
+            const candidate = this.propagationType ?? source;
+            if (candidate === c.blockedStringType)
+                return;
+            if (this.priority < inference.priority) {
+                inference.candidates = noCandidates;
+                inference.candidateDepths = noCandidateDepths;
+                inference.contraCandidates = noCandidates;
+                inference.topLevel = true;
+                inference.priority = this.priority;
+            }
+            if (this.priority === inference.priority) {
+                // Contravariant inferences only in purely contravariant positions.
+                if (this.contravariant && !this.bivariant) {
+                    if (!inference.contraCandidates.includes(candidate)) {
+                        if (inference.contraCandidates === noCandidates)
+                            inference.contraCandidates = [];
+                        inference.contraCandidates.push(candidate);
+                        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++;
+                        inference.candidates.splice(index, 0, candidate);
+                        inference.candidateDepths.splice(index, 0, this.depth);
+                        clearCachedInferences(this.inferences);
+                    }
+                }
+            }
+            if ((this.priority & 128 /* InferencePriority.ReturnType */) === 0 &&
+                (target.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 &&
+                inference.topLevel &&
+                !isTypeParameterAtTopLevel(c, this.originalTarget, target, 0)) {
+                inference.topLevel = false;
+                clearCachedInferences(this.inferences);
+            }
+        }
+        this.inferencePriority = Math.min(this.inferencePriority, this.priority);
+    }
+    /**
+     * Infers between the type arguments of two references to one generic type. The variances only pick
+     * the direction of each inference, so they are measured only when a target type argument could hold
+     * one: measuring them relates marker instantiations of the whole type.
+     */
+    inferFromReferenceTypeArguments(source, target) {
+        const c = this.c;
+        const sourceTypes = getTypeArguments(c, source);
+        const targetTypes = getTypeArguments(c, target);
+        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 */)
+                this.inferFromContravariantTypes(sourceTypes[i], targetTypes[i]);
+            else
+                this.inferFromTypes(sourceTypes[i], targetTypes[i]);
+        }
+        this.depth--;
+    }
+    inferWithPriority(source, target, newPriority) {
+        const savePriority = this.priority;
+        this.priority |= newPriority;
+        this.inferFromTypes(source, target);
+        this.priority = savePriority;
+    }
+    inferFromContravariantTypesWithPriority(source, target, newPriority) {
+        const savePriority = this.priority;
+        this.priority |= newPriority;
+        this.inferFromContravariantTypes(source, target);
+        this.priority = savePriority;
+    }
+    inferFromContravariantTypes(source, target) {
+        this.contravariant = !this.contravariant;
+        this.inferFromTypes(source, target);
+        this.contravariant = !this.contravariant;
+    }
+    inferFromContravariantTypesIfStrictFunctionTypes(source, target) {
+        if (this.c.strictFunctionTypes || (this.priority & 1024 /* InferencePriority.AlwaysStrict */) !== 0)
+            this.inferFromContravariantTypes(source, target);
+        else
+            this.inferFromTypes(source, target);
+    }
+    /** Runs `action` once per source and target pair, stopping at circularities. */
+    invokeOnce(source, target, action) {
+        const key = visitKey(source, target);
+        const status = key >= 0 ? this.visited?.get(key) : this.visitedSpelled?.get(source.id + ',' + target.id);
+        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 stackDepth = this.stackDepth;
+        setStackEntry(this.sourceStack, stackDepth, source);
+        setStackEntry(this.targetStack, stackDepth, target);
+        this.stackDepth = stackDepth + 1;
+        if (isDeeplyNestedType(this.c, source, this.sourceStack, stackDepth + 1, 2))
+            this.expandingFlags |= 1 /* ExpandingFlags.Source */;
+        if (isDeeplyNestedType(this.c, target, this.targetStack, stackDepth + 1, 2))
+            this.expandingFlags |= 2 /* ExpandingFlags.Target */;
+        if (this.expandingFlags !== 3 /* ExpandingFlags.Both */) {
+            switch (action) {
+                case 0 /* InferenceAction.ConditionalType */:
+                    this.inferToConditionalType(source, target);
+                    break;
+                case 1 /* InferenceAction.GenericMappedTypes */:
+                    this.inferFromGenericMappedTypes(source, target);
+                    break;
+                case 2 /* InferenceAction.ObjectTypes */:
+                    this.inferFromObjectTypes(source, target);
+                    break;
+            }
+        }
+        else
+            this.inferencePriority = -1 /* InferencePriority.Circularity */;
+        this.stackDepth = stackDepth;
+        this.expandingFlags = saveExpandingFlags;
+        this.setVisited(source, target, key, this.inferencePriority);
+        this.inferencePriority = Math.min(this.inferencePriority, saveInferencePriority);
+    }
+    setVisited(source, target, key, status) {
+        if (key >= 0) {
+            let visited = this.visited;
+            if (visited === undefined) {
+                visited = new Map();
+                this.visited = visited;
+            }
+            visited.set(key, status);
+        }
+        else {
+            let visited = this.visitedSpelled;
+            if (visited === undefined) {
+                visited = new Map();
+                this.visitedSpelled = visited;
+            }
+            visited.set(source.id + ',' + target.id, status);
+        }
+    }
+    inferFromMatchingTypes(sources, targets, kind) {
+        const c = this.c;
+        const matchedSources = [];
+        const matchedTargets = [];
+        for (const t of targets)
+            for (const s of sources)
+                if (typesMatch(c, s, t, kind)) {
+                    this.inferFromTypes(s, t);
+                    if (!matchedSources.includes(s))
+                        matchedSources.push(s);
+                    if (!matchedTargets.includes(t))
+                        matchedTargets.push(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) {
+        let typeVariableCount = 0;
+        if ((targetFlags & 134217728 /* TypeFlags.Union */) !== 0) {
+            let nakedTypeVariable = undefined;
+            const sources = (source.flags & 134217728 /* TypeFlags.Union */) !== 0 ? typesOf(source) : [source];
+            const matched = [];
+            for (let i = 0; i < sources.length; i++)
+                matched.push(false);
+            let inferenceCircularity = false;
+            // Infer to targets that aren't naked type variables first, tracking which sources produced
+            // inferences of the same quality as a naked type variable would get.
+            for (const t of targets) {
+                if (this.infoFor(t) !== undefined) {
+                    nakedTypeVariable = t;
+                    typeVariableCount++;
+                }
+                else
+                    for (let i = 0; i < sources.length; i++) {
+                        const saveInferencePriority = this.inferencePriority;
+                        this.inferencePriority = 2048 /* InferencePriority.MaxValue */;
+                        this.inferFromTypes(sources[i], t);
+                        if (this.inferencePriority === this.priority)
+                            matched[i] = true;
+                        inferenceCircularity = inferenceCircularity || this.inferencePriority === -1 /* InferencePriority.Circularity */;
+                        this.inferencePriority = Math.min(this.inferencePriority, saveInferencePriority);
+                    }
+            }
+            if (typeVariableCount === 0) {
+                // Infer `A | B` for T from `A | B` to `T & (X | Y)`.
+                const intersectionTypeVariable = this.getSingleTypeVariableFromIntersectionTypes(targets);
+                if (intersectionTypeVariable !== undefined)
+                    this.inferWithPriority(source, intersectionTypeVariable, 1 /* InferencePriority.NakedTypeVariable */);
+                return;
+            }
+            // With a single naked type variable and no circularities, infer the unmatched sources to it.
+            if (typeVariableCount === 1 && !inferenceCircularity) {
+                const unmatched = [];
+                for (let i = 0; i < sources.length; i++)
+                    if (!matched[i])
+                        unmatched.push(sources[i]);
+                if (unmatched.length !== 0) {
+                    this.inferFromTypes(getUnionType(this.c, unmatched), nakedTypeVariable);
+                    return;
+                }
+            }
+        }
+        else {
+            // Inferences from nested naked type variables come first among the candidates.
+            for (const t of targets) {
+                if (this.infoFor(t) !== undefined)
+                    typeVariableCount++;
+                else
+                    this.inferFromTypes(source, t);
+            }
+        }
+        // Inferences directly to naked type variables get lower priority.
+        if (((targetFlags & 268435456 /* TypeFlags.Intersection */) !== 0 && typeVariableCount === 1) ||
+            ((targetFlags & 268435456 /* TypeFlags.Intersection */) === 0 && typeVariableCount > 0))
+            for (const t of targets)
+                if (this.infoFor(t) !== undefined)
+                    this.inferWithPriority(source, t, 1 /* InferencePriority.NakedTypeVariable */);
+    }
+    getSingleTypeVariableFromIntersectionTypes(types) {
+        let typeVariable = undefined;
+        for (const t of types) {
+            if ((t.flags & 268435456 /* TypeFlags.Intersection */) === 0)
+                return undefined;
+            let v;
+            for (const u of typesOf(t)) {
+                if (this.infoFor(u) !== undefined) {
+                    v = u;
+                    break;
+                }
+            }
+            if (v === undefined || (typeVariable !== undefined && v !== typeVariable))
+                return undefined;
+            typeVariable = v;
+        }
+        return typeVariable;
+    }
+    inferToConditionalType(source, target) {
+        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));
+        }
+        else {
+            const savePriority = this.priority;
+            this.priority |= this.contravariant ? 64 /* InferencePriority.ContravariantConditional */ : 0;
+            this.inferToMultipleTypes(source, getBranchTypesFromConditionalType(c, target), target.flags);
+            this.priority = savePriority;
+        }
+    }
+    inferToTemplateLiteralType(source, target) {
+        const c = this.c;
+        const matches = inferTypesFromTemplateLiteralType(c, source, target);
+        const types = target.types;
+        // When the target has only placeholders and nothing matches, infer `never` for each so that
+        // instantiation produces `never` rather than collapsing to the constraint.
+        if (matches === undefined && !target.texts.every((s) => s === ''))
+            return;
+        for (let i = 0; i < types.length; i++) {
+            const placeholder = types[i];
+            const matchSource = matches !== undefined ? matches[i] : c.neverType;
+            if ((matchSource.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 && (placeholder.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0) {
+                const info = this.infoFor(placeholder);
+                if (info !== undefined) {
+                    const constraint = getBaseConstraintOfType(c, info.typeParameter);
+                    if (constraint !== undefined && (constraint.flags & 1 /* TypeFlags.Any */) === 0) {
+                        const matching = getTemplatePlaceholderInference(c, matchSource, constraint);
+                        if (matching !== undefined) {
+                            this.inferFromTypes(matching, placeholder);
+                            continue;
+                        }
+                    }
+                }
+            }
+            this.inferFromTypes(matchSource, placeholder);
+        }
+    }
+    inferFromGenericMappedTypes(source, target) {
+        // From `{ [P in S]: X }` to `{ [P in T]: Y }`, infer from S to T and from X to Y.
+        const c = this.c;
+        this.inferFromTypes(getConstraintTypeFromMappedType(c, source), getConstraintTypeFromMappedType(c, target));
+        this.inferFromTypes(getTemplateTypeFromMappedType(c, source), getTemplateTypeFromMappedType(c, target));
+        const sourceNameType = getNameTypeFromMappedType(c, source);
+        const targetNameType = getNameTypeFromMappedType(c, target);
+        if (sourceNameType !== undefined && targetNameType !== undefined)
+            this.inferFromTypes(sourceNameType, targetNameType);
+    }
+    inferFromObjectTypes(source, target) {
+        const c = this.c;
+        if ((source.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 &&
+            (target.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 &&
+            (referenceTarget(source) === referenceTarget(target) || (isArrayType(c, source) && isArrayType(c, target)))) {
+            this.inferFromReferenceTypeArguments(source, target);
+            return;
+        }
+        if (isGenericMappedType(c, source) && isGenericMappedType(c, target))
+            this.inferFromGenericMappedTypes(source, target);
+        if ((target.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0 && !hasMappedNameType(target)) {
+            const constraintType = getConstraintTypeFromMappedType(c, target);
+            if (this.inferToMappedType(source, target, constraintType))
+                return;
+        }
+        // Infer from members only when the types are possibly related.
+        if (typesDefinitelyUnrelated(c, source, target))
+            return;
+        if (isArrayOrTupleType(c, source)) {
+            if (isTupleType(target)) {
+                this.inferFromTupleTypes(source, target);
+                return;
+            }
+            if (isArrayType(c, target)) {
+                this.inferFromIndexTypes(source, target);
+                return;
+            }
+        }
+        this.inferFromProperties(source, target);
+        this.inferFromSignatures(source, target, 0 /* SignatureKind.Call */);
+        this.inferFromSignatures(source, target, 1 /* SignatureKind.Construct */);
+        this.inferFromIndexTypes(source, target);
+    }
+    inferFromTupleTypes(source, target) {
+        const c = this.c;
+        const sourceArity = getTypeReferenceArity(source);
+        const targetArity = getTypeReferenceArity(target);
+        const elementTypes = getTypeArguments(c, target);
+        const targetTuple = tupleTargetOf(target);
+        const elementInfos = targetTuple.elementInfos;
+        const sourceTypes = getTypeArguments(c, source);
+        // Tuples of the same structure: infer between the element types.
+        if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) {
+            for (let i = 0; i < targetArity; i++)
+                this.inferFromTypes(sourceTypes[i], elementTypes[i]);
+            return;
+        }
+        let startLength = 0;
+        let endLength = 0;
+        if (isTupleType(source)) {
+            const sourceTuple = tupleTargetOf(source);
+            startLength = Math.min(sourceTuple.fixedLength, targetTuple.fixedLength);
+            if ((targetTuple.combinedFlags & 12 /* ElementFlags.Variable */) !== 0)
+                endLength = Math.min(getEndElementCount(sourceTuple, 3 /* ElementFlags.Fixed */), getEndElementCount(targetTuple, 3 /* ElementFlags.Fixed */));
+        }
+        for (let i = 0; i < startLength; i++)
+            this.inferFromTypes(sourceTypes[i], elementTypes[i]);
+        if (!isTupleType(source) ||
+            (sourceArity - startLength - endLength === 1 &&
+                (tupleTargetOf(source).elementInfos[startLength].flags & 4 /* ElementFlags.Rest */) !== 0)) {
+            // A single rest element remains in the source; infer from it to every middle target element.
+            const restType = sourceTypes[startLength];
+            for (let i = startLength; i < targetArity - endLength; i++)
+                this.inferFromTypes((elementInfos[i].flags & 8 /* ElementFlags.Variadic */) !== 0 ? createArrayType(c, restType) : restType, elementTypes[i]);
+        }
+        else {
+            const middleLength = targetArity - startLength - endLength;
+            if (middleLength === 2) {
+                const first = elementInfos[startLength].flags;
+                const second = elementInfos[startLength + 1].flags;
+                if ((first & second & 8 /* ElementFlags.Variadic */) !== 0) {
+                    // [...T, ...U]: slice the source by the implied arity of T.
+                    const targetInfo = this.infoFor(elementTypes[startLength]);
+                    if (targetInfo !== undefined && targetInfo.impliedArity >= 0) {
+                        this.inferFromTypes(sliceTupleType(c, source, startLength, endLength + sourceArity - targetInfo.impliedArity), elementTypes[startLength]);
+                        this.inferFromTypes(sliceTupleType(c, source, startLength + targetInfo.impliedArity, endLength), elementTypes[startLength + 1]);
+                    }
+                }
+                else if ((first & 8 /* ElementFlags.Variadic */) !== 0 && (second & 4 /* ElementFlags.Rest */) !== 0) {
+                    // [...T, ...rest]: use the arity of a fixed-size tuple constraint of T.
+                    const info = this.infoFor(elementTypes[startLength]);
+                    if (info !== undefined) {
+                        const constraint = getBaseConstraintOfType(c, info.typeParameter);
+                        if (constraint !== undefined &&
+                            isTupleType(constraint) &&
+                            (tupleTargetOf(constraint).combinedFlags & 12 /* ElementFlags.Variable */) === 0) {
+                            const impliedArity = tupleTargetOf(constraint).fixedLength;
+                            this.inferFromTypes(sliceTupleType(c, source, startLength, sourceArity - (startLength + impliedArity)), elementTypes[startLength]);
+                            const restType = getElementTypeOfSliceOfTupleType(c, source, startLength + impliedArity, endLength, false, false);
+                            if (restType !== undefined)
+                                this.inferFromTypes(restType, elementTypes[startLength + 1]);
+                        }
+                    }
+                }
+                else if ((first & 4 /* ElementFlags.Rest */) !== 0 && (second & 8 /* ElementFlags.Variadic */) !== 0) {
+                    // [...rest, ...T]: use the arity of a fixed-size tuple constraint of T.
+                    const info = this.infoFor(elementTypes[startLength + 1]);
+                    if (info !== undefined) {
+                        const constraint = getBaseConstraintOfType(c, info.typeParameter);
+                        if (constraint !== undefined &&
+                            isTupleType(constraint) &&
+                            (tupleTargetOf(constraint).combinedFlags & 12 /* ElementFlags.Variable */) === 0) {
+                            const impliedArity = tupleTargetOf(constraint).fixedLength;
+                            const endIndex = sourceArity - getEndElementCount(targetTuple, 3 /* ElementFlags.Fixed */);
+                            const startIndex = endIndex - impliedArity;
+                            if (startIndex >= startLength) {
+                                const trailingSlice = createTupleTypeEx(c, sourceTypes.slice(startIndex, endIndex), tupleTargetOf(source).elementInfos.slice(startIndex, endIndex), false);
+                                const restType = getElementTypeOfSliceOfTupleType(c, source, startLength, endLength + impliedArity, false, false);
+                                if (restType !== undefined)
+                                    this.inferFromTypes(restType, elementTypes[startLength]);
+                                this.inferFromTypes(trailingSlice, elementTypes[startLength + 1]);
+                            }
+                        }
+                    }
+                }
+            }
+            else if (middleLength === 1 && (elementInfos[startLength].flags & 8 /* ElementFlags.Variadic */) !== 0) {
+                // One variadic middle element: infer the source slice between the fixed parts, speculatively
+                // when the target ends in optional elements.
+                const priority = (elementInfos[targetArity - 1].flags & 2 /* ElementFlags.Optional */) !== 0
+                    ? 2 /* InferencePriority.SpeculativeTuple */
+                    : 0 /* InferencePriority.None */;
+                this.inferWithPriority(sliceTupleType(c, source, startLength, endLength), elementTypes[startLength], priority);
+            }
+            else if (middleLength === 1 && (elementInfos[startLength].flags & 4 /* ElementFlags.Rest */) !== 0) {
+                // One rest middle element: infer the union of the middle source elements.
+                const restType = getElementTypeOfSliceOfTupleType(c, source, startLength, endLength, false, false);
+                if (restType !== undefined)
+                    this.inferFromTypes(restType, elementTypes[startLength]);
+            }
+        }
+        for (let i = 0; i < endLength; i++)
+            this.inferFromTypes(sourceTypes[sourceArity - i - 1], elementTypes[targetArity - i - 1]);
+    }
+    inferFromProperties(source, target) {
+        const c = this.c;
+        for (const targetProp of getPropertiesOfObjectType(c, target)) {
+            const sourceProp = getPropertyOfType(c, source, targetProp.name);
+            if (sourceProp !== undefined)
+                this.inferFromTypes(removeMissingType(c, getTypeOfSymbol(c, sourceProp), (sourceProp.flags & 16777216 /* SymbolFlags.Optional */) !== 0), removeMissingType(c, getTypeOfSymbol(c, targetProp), (targetProp.flags & 16777216 /* SymbolFlags.Optional */) !== 0));
+        }
+    }
+    inferFromSignatures(source, target, kind) {
+        const c = this.c;
+        const sourceSignatures = getSignaturesOfType(c, source, kind);
+        const sourceLen = sourceSignatures.length;
+        if (sourceLen === 0)
+            return;
+        // Match signatures from the bottom up; excess targets infer from the first source signature.
+        const targetSignatures = getSignaturesOfType(c, target, kind);
+        const targetLen = targetSignatures.length;
+        for (let i = 0; i < targetLen; i++) {
+            const sourceIndex = Math.max(sourceLen - targetLen + i, 0);
+            this.inferFromSignature(getBaseSignature(c, sourceSignatures[sourceIndex]), getErasedSignature(c, targetSignatures[i]));
+        }
+    }
+    inferFromSignature(source, target) {
+        const c = this.c;
+        if ((source.flags & 128 /* SignatureFlags.IsNonInferrable */) === 0) {
+            const saveBivariant = this.bivariant;
+            const kind = target.declaration !== undefined ? target.declaration.kind : 0 /* SyntaxKind.Unknown */;
+            // 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 */;
+            applyToParameterTypes(c, source, target, (s, t) => this.inferFromContravariantTypesIfStrictFunctionTypes(s, t));
+            this.bivariant = saveBivariant;
+        }
+        applyToReturnTypes(c, source, target, (s, t) => this.inferFromTypes(s, t));
+    }
+    inferFromIndexTypes(source, target) {
+        const c = this.c;
+        // Inferences across mapped type index signatures are like inferences to homomorphic variables.
+        const priority = (source.objectFlags & target.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0
+            ? 8 /* InferencePriority.HomomorphicMappedType */
+            : 0 /* InferencePriority.None */;
+        const indexInfos = getIndexInfosOfType(c, target);
+        if (isObjectTypeWithInferableIndex(c, source))
+            for (const targetInfo of indexInfos) {
+                const propTypes = [];
+                for (const prop of getPropertiesOfType(c, source))
+                    if (isApplicableIndexType(c, getLiteralTypeFromProperty(c, prop, 19456 /* TypeFlags.StringOrNumberLiteralOrUnique */, false), targetInfo.keyType)) {
+                        const propType = getTypeOfSymbol(c, prop);
+                        propTypes.push((prop.flags & 16777216 /* SymbolFlags.Optional */) !== 0 ? removeMissingOrUndefinedType(c, propType) : propType);
+                    }
+                for (const info of getIndexInfosOfType(c, source))
+                    if (isApplicableIndexType(c, info.keyType, targetInfo.keyType))
+                        propTypes.push(info.valueType);
+                if (propTypes.length !== 0)
+                    this.inferWithPriority(getUnionType(c, propTypes), targetInfo.valueType, priority);
+            }
+        for (const targetInfo of indexInfos) {
+            const sourceInfo = getApplicableIndexInfo(c, source, targetInfo.keyType);
+            if (sourceInfo !== undefined)
+                this.inferWithPriority(sourceInfo.valueType, targetInfo.valueType, priority);
+        }
+    }
+    inferToMappedType(source, target, constraintType) {
+        const c = this.c;
+        if ((constraintType.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
+            let result = false;
+            for (const t of typesOf(constraintType))
+                result = this.inferToMappedType(source, target, t) || result;
+            return result;
+        }
+        if ((constraintType.flags & 2097152 /* TypeFlags.Index */) !== 0) {
+            // From S to a homomorphic `{ [P in keyof T]: X }`: reverse-map S and make a secondary
+            // inference to T, so direct inferences to T win over ones to `Partial<T>`.
+            const inference = this.infoFor(constraintType.target);
+            if (inference !== undefined && !inference.isFixed) {
+                const inferredType = inferTypeForHomomorphicMappedType(c, source, target, constraintType);
+                if (inferredType !== undefined)
+                    this.inferWithPriority(inferredType, inference.typeParameter, (source.objectFlags & 262144 /* ObjectFlags.NonInferrableType */) !== 0
+                        ? 16 /* InferencePriority.PartialHomomorphicMappedType */
+                        : 8 /* InferencePriority.HomomorphicMappedType */);
+            }
+            return true;
+        }
+        if ((constraintType.flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
+            // From S to `{ [P in K]: X }`: infer `keyof S` to K, then to K's constraint like a homomorphic
+            // mapped type (for `Pick<T, K>`).
+            this.inferWithPriority(getIndexTypeEx(c, source, c.patternForType.has(source) ? 2 /* IndexFlags.NoIndexSignatures */ : 0 /* IndexFlags.None */), constraintType, 32 /* InferencePriority.MappedTypeConstraint */);
+            const extendedConstraint = getConstraintOfType(c, constraintType);
+            if (extendedConstraint !== undefined && this.inferToMappedType(source, target, extendedConstraint))
+                return true;
+            // Otherwise infer the union of the source's property types to X.
+            const types = [];
+            for (const p of getPropertiesOfType(c, source))
+                types.push(getTypeOfSymbol(c, p));
+            for (const info of getIndexInfosOfType(c, source))
+                types.push(info !== c.enumNumberIndexInfo ? info.valueType : c.neverType);
+            this.inferFromTypes(getUnionType(c, types), getTemplateTypeFromMappedType(c, target));
+            return true;
+        }
+        return false;
+    }
+}
+// ---- Helpers
+function getInferenceInfoForType(inferences, t) {
+    if ((t.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0)
+        for (const inference of inferences)
+            if (t === inference.typeParameter)
+                return inference;
+    return undefined;
+}
+function distributedTypes(t) {
+    return (t.flags & 134217728 /* TypeFlags.Union */) !== 0 ? typesOf(t) : [t];
+}
+function referenceTarget(t) {
+    return t.target;
+}
+function referenceNode(t) {
+    return t.node;
+}
+const noVariances = [];
+/** Whether inferring to one of `targets` could record a candidate. */
+function someTypeCouldHoldInference(c, targets) {
+    for (const t of targets)
+        if (couldHoldInference(c, t, 0))
+            return true;
+    return false;
+}
+/**
+ * `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.
+ */
+function couldHoldInference(c, t, depth) {
+    if (!couldContainTypeVariables(c, t))
+        return false;
+    if (t.alias !== undefined || depth === 4)
+        return true;
+    if ((t.objectFlags & 4 /* ObjectFlags.Reference */) !== 0) {
+        const resolved = t.resolvedTypeArguments ?? sideOf(c, t).resolvedTypeArguments;
+        if (resolved === undefined)
+            return true;
+        for (const a of resolved)
+            if (couldHoldInference(c, a, depth + 1))
+                return true;
+        return false;
+    }
+    return !isTopLevelClassStaticSide(t);
+}
+function isTopLevelClassStaticSide(t) {
+    const symbol = t.symbol;
+    if ((t.objectFlags & 16 /* ObjectFlags.Anonymous */) === 0 ||
+        symbol === undefined ||
+        (symbol.flags & 32 /* SymbolFlags.Class */) === 0 ||
+        (symbol.flags &
+            (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 2048 /* SymbolFlags.TypeLiteral */ | 4096 /* SymbolFlags.ObjectLiteral */)) !==
+            0 ||
+        symbol.declarations.length === 0)
+        return false;
+    for (const d of symbol.declarations) {
+        if (d.kind !== 264 /* SyntaxKind.ClassDeclaration */ &&
+            d.kind !== 265 /* SyntaxKind.InterfaceDeclaration */ &&
+            d.kind !== 268 /* 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 */)
+                return false;
+    }
+    return true;
+}
+function isNonGenericObjectType(c, t) {
+    return (t.flags & 1048576 /* TypeFlags.Object */) !== 0 && !isGenericMappedType(c, t);
+}
+function hasMappedNameType(t) {
+    return t.declaration !== undefined && t.declaration.nameType !== undefined;
+}
+/** `(T | U)[K]` as `T[K] | U[K]` and `(T & U)[K]` as `T[K] & U[K]`. */
+function distributeIndexOverObjectType(c, objectType, indexType) {
+    if ((objectType.flags & 134217728 /* TypeFlags.Union */) !== 0 ||
+        ((objectType.flags & 268435456 /* TypeFlags.Intersection */) !== 0 && !shouldDeferIndexType(c, objectType, 0 /* IndexFlags.None */))) {
+        const types = [];
+        for (const t of typesOf(objectType))
+            types.push(getSimplifiedType(c, getIndexedAccessType(c, t, indexType), false));
+        return (objectType.flags & 268435456 /* TypeFlags.Intersection */) !== 0 ? getIntersectionType(c, types) : getUnionType(c, types);
+    }
+    return undefined;
+}
+/** An object with a property of type `any` for each string literal in `t`. */
+function createEmptyObjectTypeFromStringLiteral(c, t) {
+    const members = new Map();
+    for (const u of distributedTypes(t)) {
+        if ((u.flags & 1024 /* TypeFlags.StringLiteral */) === 0)
+            continue;
+        const name = u.stringValue;
+        const literalProp = c.newSymbol(4 /* SymbolFlags.Property */, name);
+        c.symbolTypes.set(getSymbolId(literalProp), c.anyType);
+        if (u.symbol !== undefined) {
+            literalProp.declarations = u.symbol.declarations;
+            literalProp.valueDeclaration = u.symbol.valueDeclaration;
+        }
+        members.set(name, literalProp);
+    }
+    const indexInfos = (t.flags & 32 /* TypeFlags.String */) !== 0 ? [newIndexInfo(c.stringType, c.emptyObjectType, false, undefined)] : [];
+    return createAnonymousType(c, undefined, members, [], [], indexInfos);
+}
+export function isTypeParameterAtTopLevel(c, t, tp, depth) {
+    if (t === tp)
+        return true;
+    if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (isTypeParameterAtTopLevel(c, u, tp, depth))
+                return true;
+        return false;
+    }
+    return (depth < 3 &&
+        (t.flags & 67108864 /* TypeFlags.Conditional */) !== 0 &&
+        (isTypeParameterAtTopLevel(c, getTrueTypeFromConditionalType(c, t), tp, depth + 1) ||
+            isTypeParameterAtTopLevel(c, getFalseTypeFromConditionalType(c, t), tp, depth + 1)));
+}
+function isTypeParameterAtTopLevelInReturnType(c, signature, typeParameter) {
+    const typePredicate = getTypePredicateOfSignature(c, signature);
+    if (typePredicate !== undefined)
+        return typePredicate.type !== undefined && isTypeParameterAtTopLevel(c, typePredicate.type, typeParameter, 0);
+    return isTypeParameterAtTopLevel(c, getReturnTypeOfSignature(c, signature), typeParameter, 0);
+}
+function isTypeOrBaseIdenticalTo(c, s, t) {
+    if (t === c.missingType)
+        return s === t;
+    return (isTypeIdenticalTo(c, s, t) ||
+        ((t.flags & 32 /* TypeFlags.String */) !== 0 && (s.flags & 1024 /* TypeFlags.StringLiteral */) !== 0) ||
+        ((t.flags & 64 /* TypeFlags.Number */) !== 0 && (s.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0));
+}
+function isTypeCloselyMatchedBy(s, t) {
+    if ((s.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
+        (t.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
+        s.symbol !== undefined &&
+        s.symbol === t.symbol)
+        return true;
+    const sa = s.alias;
+    const ta = t.alias;
+    return sa !== undefined && ta !== undefined && sa.typeArguments.length !== 0 && sa.symbol === ta.symbol;
+}
+function typesDefinitelyUnrelated(c, source, target) {
+    // Tuples of incompatible arities, or objects that each have a property missing in the other.
+    if (isTupleType(source) && isTupleType(target)) {
+        const s = tupleTargetOf(source);
+        const t = tupleTargetOf(target);
+        return (((t.combinedFlags & 8 /* ElementFlags.Variadic */) === 0 && t.minLength > s.minLength) ||
+            ((t.combinedFlags & 12 /* ElementFlags.Variable */) === 0 &&
+                ((s.combinedFlags & 12 /* ElementFlags.Variable */) !== 0 || t.fixedLength < s.fixedLength)));
+    }
+    return hasUnmatchedProperty(c, source, target, true) && hasUnmatchedProperty(c, target, source, false);
+}
+/**
+ * Whether `getUnmatchedProperty(c, source, target, false, matchDiscriminantProperties)` finds a
+ * property, without creating every property of a union or intersection target whose properties
+ * aren't resolved yet. That test reports only required properties: a union property is optional
+ * when it is optional in any constituent, an intersection property when it is optional in every
+ * constituent that has it. So only names required in a constituent (of those
+ * `getPropertiesOfUnionOrIntersectionType` reads) are candidates, and the search stops at the first
+ * unmatched one. A union property is created only when the result can depend on it: when the source
+ * lacks the name, or for the discriminant test when the first constituent's property type is a unit
+ * type or never (otherwise the union of the constituents' types is not a unit type).
+ */
+function hasUnmatchedProperty(c, source, target, matchDiscriminantProperties) {
+    const t = getReducedApparentType(c, target);
+    if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) === 0 ||
+        sideOf(c, t).resolvedProperties !== undefined)
+        return getUnmatchedProperty(c, source, target, false, matchDiscriminantProperties) !== undefined;
+    const containingType = t;
+    const isUnion = (t.flags & 134217728 /* TypeFlags.Union */) !== 0;
+    const checked = new Set();
+    for (const current of containingType.types) {
+        for (const prop of getPropertiesOfType(c, current)) {
+            const name = prop.name;
+            if ((prop.flags & 16777216 /* SymbolFlags.Optional */) !== 0) {
+                if (isUnion)
+                    checked.add(name);
+                continue;
+            }
+            if (checked.has(name))
+                continue;
+            checked.add(name);
+            if (isUnion &&
+                getPropertyOfType(c, source, name) !== undefined &&
+                (!matchDiscriminantProperties || (getTypeOfSymbol(c, prop).flags & (97292 /* TypeFlags.Unit */ | 262144 /* TypeFlags.Never */)) === 0))
+                continue;
+            const combined = getPropertyOfUnionOrIntersectionType(c, containingType, name, !isUnion);
+            if (combined !== undefined && isUnmatchedProperty(c, source, combined, false, matchDiscriminantProperties))
+                return true;
+        }
+        if (isUnion && getIndexInfosOfType(c, current).length === 0)
+            break;
+    }
+    return false;
+}
+function isTupleTypeStructureMatching(t1, t2) {
+    if (getTypeReferenceArity(t1) !== getTypeReferenceArity(t2))
+        return false;
+    const infos1 = tupleTargetOf(t1).elementInfos;
+    const infos2 = tupleTargetOf(t2).elementInfos;
+    for (let i = 0; i < infos1.length; i++)
+        if ((infos1[i].flags & 12 /* ElementFlags.Variable */) !== (infos2[i].flags & 12 /* ElementFlags.Variable */))
+            return false;
+    return true;
+}
+export function isConstTypeVariable(c, t, depth) {
+    if (depth >= 5 || t === undefined)
+        return false;
+    if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
+        if (t.symbol === undefined)
+            return false;
+        for (const d of t.symbol.declarations)
+            if (hasSyntacticModifier(d, 4096 /* ModifierFlags.Const */))
+                return true;
+        return false;
+    }
+    if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
+        for (const s of typesOf(t))
+            if (isConstTypeVariable(c, s, depth))
+                return true;
+        return false;
+    }
+    if ((t.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0)
+        return isConstTypeVariable(c, t.objectType, depth + 1);
+    if ((t.flags & 67108864 /* TypeFlags.Conditional */) !== 0)
+        return isConstTypeVariable(c, getConstraintOfConditionalType(c, t), depth + 1);
+    if ((t.flags & 16777216 /* TypeFlags.Substitution */) !== 0)
+        return isConstTypeVariable(c, t.baseType, depth);
+    if ((t.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0) {
+        const typeVariable = getHomomorphicTypeVariable(c, t);
+        return typeVariable !== undefined && isConstTypeVariable(c, typeVariable, depth);
+    }
+    if (isGenericTupleType(t)) {
+        const elements = getElementTypes(c, t);
+        const infos = tupleTargetOf(t).elementInfos;
+        for (let i = 0; i < elements.length; i++)
+            if ((infos[i].flags & 8 /* ElementFlags.Variadic */) !== 0 && isConstTypeVariable(c, elements[i], depth))
+                return true;
+    }
+    return false;
+}
+export function isMutableArrayLikeType(c, t) {
+    return (isMutableArrayOrTuple(c, t) ||
+        ((t.flags & (1 /* TypeFlags.Any */ | 12 /* TypeFlags.Nullable */)) === 0 && isTypeAssignableTo(c, t, c.anyArrayType)));
+}
+function typePredicateKindsMatch(a, b) {
+    return a.kind === b.kind && a.parameterIndex === b.parameterIndex;
+}
+/** Calls `callback` with each pair of corresponding parameter types of `source` and `target`. */
+export function applyToParameterTypes(c, source, target, callback) {
+    const sourceCount = getParameterCount(c, source);
+    const targetCount = getParameterCount(c, target);
+    const sourceRestType = getEffectiveRestType(c, source);
+    const targetRestType = getEffectiveRestType(c, target);
+    const targetNonRestCount = targetRestType !== undefined ? targetCount - 1 : targetCount;
+    const paramCount = sourceRestType !== undefined ? targetNonRestCount : Math.min(sourceCount, targetNonRestCount);
+    const sourceThisType = getThisTypeOfSignature(c, source);
+    if (sourceThisType !== undefined) {
+        const targetThisType = getThisTypeOfSignature(c, target);
+        if (targetThisType !== undefined)
+            callback(sourceThisType, targetThisType);
+    }
+    for (let i = 0; i < paramCount; i++)
+        callback(getTypeAtPosition(c, source, i), getTypeAtPosition(c, target, i));
+    if (targetRestType !== undefined)
+        callback(getRestTypeAtPosition(c, source, paramCount, isConstTypeVariable(c, targetRestType, 0) && !someType(targetRestType, (t) => isMutableArrayLikeType(c, t))), targetRestType);
+}
+export function applyToReturnTypes(c, source, target, callback) {
+    const targetTypePredicate = getTypePredicateOfSignature(c, target);
+    if (targetTypePredicate !== undefined) {
+        const sourceTypePredicate = getTypePredicateOfSignature(c, source);
+        if (sourceTypePredicate !== undefined &&
+            typePredicateKindsMatch(sourceTypePredicate, targetTypePredicate) &&
+            sourceTypePredicate.type !== undefined &&
+            targetTypePredicate.type !== undefined) {
+            callback(sourceTypePredicate.type, targetTypePredicate.type);
+            return;
+        }
+    }
+    const targetReturnType = getReturnTypeOfSignature(c, target);
+    if (couldContainTypeVariables(c, targetReturnType))
+        callback(getReturnTypeOfSignature(c, source), targetReturnType);
+}
+/** `signature` with its type parameters replaced by their base constraints. */
+export function getBaseSignature(c, signature) {
+    const typeParameters = signature.typeParameters;
+    if (typeParameters.length === 0)
+        return signature;
+    const side = signatureSideOf(c, signature);
+    if (side.baseSignatureCache !== undefined)
+        return side.baseSignatureCache;
+    const constraints = [];
+    for (const tp of typeParameters)
+        constraints.push(getConstraintOfTypeParameter(c, tp) ?? c.unknownType);
+    const baseConstraintMapper = newTypeMapper(typeParameters, constraints);
+    let baseConstraints = [];
+    for (const tp of typeParameters)
+        baseConstraints.push(instantiateType(c, tp, baseConstraintMapper));
+    // Resolve non-circular interdependent constraints, then erase what remains circular.
+    for (let i = 0; i < typeParameters.length - 1; i++)
+        baseConstraints = instantiateTypes(c, baseConstraints, baseConstraintMapper);
+    baseConstraints = instantiateTypes(c, baseConstraints, new ArrayToSingleTypeMapper(typeParameters, c.anyType));
+    const result = instantiateSignatureEx(c, signature, newTypeMapper(typeParameters, baseConstraints), true);
+    side.baseSignatureCache = result;
+    return result;
+}
+export function getTypeParametersForMapper(c, signature) {
+    const result = [];
+    for (const tp of signature.typeParameters)
+        result.push(instantiateType(c, tp, tp.mapper));
+    return result;
+}
+/** The generic `signature` instantiated in the context of the non-generic `contextualSignature`. */
+export function instantiateSignatureInContextOf(c, signature, contextualSignature, inferenceContext, compareTypes) {
+    const context = createInferenceContext(c, getTypeParametersForMapper(c, signature), signature, 0 /* InferenceFlags.None */, compareTypes);
+    // Clone so that inferring through a rest type parameter doesn't fix it.
+    const restType = getEffectiveRestType(c, contextualSignature);
+    const mapper = inferenceContext !== undefined
+        ? restType !== undefined && (restType.flags & 524288 /* TypeFlags.TypeParameter */) !== 0
+            ? inferenceContext.nonFixingMapper
+            : inferenceContext.mapper
+        : undefined;
+    const sourceSignature = mapper !== undefined ? instantiateSignature(c, contextualSignature, mapper) : contextualSignature;
+    applyToParameterTypes(c, sourceSignature, signature, (source, target) => inferTypes(c, context.inferences, source, target, 0 /* InferencePriority.None */, false));
+    if (inferenceContext === undefined)
+        applyToReturnTypes(c, contextualSignature, signature, (source, target) => inferTypes(c, context.inferences, source, target, 128 /* InferencePriority.ReturnType */, false));
+    return getSignatureInstantiation(c, signature, getInferredTypes(c, context), contextualSignature.declaration !== undefined &&
+        (contextualSignature.declaration.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0);
+}
+// ---- Template literal inference
+/**
+ * Whether `source`, a string literal or a template literal type, fails the start and end text test of
+ * `inferFromLiteralPartsToTemplateLiteral` against `target`: its first text does not start with the
+ * target's first text, its last text does not end with the target's last text, or a string literal
+ * is shorter than both. `inferTypesFromTemplateLiteralType` returns undefined then.
+ */
+export function failsTemplateLiteralTextTest(source, target) {
+    const targetTexts = target.texts;
+    const targetStartText = targetTexts[0];
+    const targetEndText = targetTexts[targetTexts.length - 1];
+    if ((source.flags & 1024 /* TypeFlags.StringLiteral */) !== 0) {
+        const text = source.stringValue;
+        return (text.length < targetStartText.length + targetEndText.length ||
+            !text.startsWith(targetStartText) ||
+            !text.endsWith(targetEndText));
+    }
+    const sourceTexts = source.texts;
+    return !sourceTexts[0].startsWith(targetStartText) || !sourceTexts[sourceTexts.length - 1].endsWith(targetEndText);
+}
+/**
+ * Whether `source` is a string literal, or a template literal type whose placeholders are `string`,
+ * `number` or `bigint`, that fails the start and end text test against `target`. It is then not
+ * assignable to `target`, and relating the two has no other effect: such a template has no type
+ * variables for a variance marker mapper to find.
+ */
+export function isUnmatchedTemplateLiteralKey(source, target) {
+    if ((source.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
+        for (const t of source.types)
+            if ((t.flags & (32 /* TypeFlags.String */ | 64 /* TypeFlags.Number */ | 128 /* TypeFlags.BigInt */)) === 0)
+                return false;
+    }
+    else if ((source.flags & 1024 /* TypeFlags.StringLiteral */) === 0)
+        return false;
+    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) {
+    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.
+        if (failsTemplateLiteralTextTest(source, target))
+            return undefined;
+        return inferFromLiteralPartsToTemplateLiteral(c, [source.stringValue], emptyTypes, target);
+    }
+    if ((source.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
+        const s = source;
+        if (arraysEqual(s.texts, target.texts)) {
+            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));
+            }
+            return result;
+        }
+        return inferFromLiteralPartsToTemplateLiteral(c, s.texts, s.types, target);
+    }
+    return undefined;
+}
+function arraysEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+function getStringLikeTypeForType(c, t) {
+    return (t.flags & (1 /* TypeFlags.Any */ | 12583968 /* TypeFlags.StringLike */)) !== 0 ? t : getTemplateLiteralType(c, ['', ''], [t]);
+}
+/** Matches the text and type parts of a source literal against a target template literal. */
+class TemplateMatcher {
+    c;
+    sourceTexts;
+    sourceTypes;
+    lastSourceIndex;
+    remainingEndText;
+    seg = 0;
+    pos;
+    matches = [];
+    constructor(c, sourceTexts, sourceTypes, remainingEndText, pos) {
+        this.c = c;
+        this.sourceTexts = sourceTexts;
+        this.sourceTypes = sourceTypes;
+        this.lastSourceIndex = sourceTexts.length - 1;
+        this.remainingEndText = remainingEndText;
+        this.pos = pos;
+    }
+    sourceText(index) {
+        return index < this.lastSourceIndex ? this.sourceTexts[index] : this.remainingEndText;
+    }
+    addMatch(s, p) {
+        let matchType;
+        if (s === this.seg)
+            matchType = getStringLiteralType(this.c, this.sourceText(s).substring(this.pos, p));
+        else {
+            const texts = [this.sourceTexts[this.seg].substring(this.pos)];
+            for (let i = this.seg + 1; i < s; i++)
+                texts.push(this.sourceTexts[i]);
+            texts.push(this.sourceText(s).substring(0, p));
+            matchType = getTemplateLiteralType(this.c, texts, this.sourceTypes.slice(this.seg, s));
+        }
+        this.matches.push(matchType);
+        this.seg = s;
+        this.pos = p;
+    }
+}
+function inferFromLiteralPartsToTemplateLiteral(c, sourceTexts, sourceTypes, target) {
+    const lastSourceIndex = sourceTexts.length - 1;
+    const sourceStartText = sourceTexts[0];
+    const sourceEndText = sourceTexts[lastSourceIndex];
+    const targetTexts = target.texts;
+    const lastTargetIndex = targetTexts.length - 1;
+    const targetStartText = targetTexts[0];
+    const targetEndText = targetTexts[lastTargetIndex];
+    if ((lastSourceIndex === 0 && sourceStartText.length < targetStartText.length + targetEndText.length) ||
+        !sourceStartText.startsWith(targetStartText) ||
+        !sourceEndText.endsWith(targetEndText))
+        return undefined;
+    const m = new TemplateMatcher(c, sourceTexts, sourceTypes, sourceEndText.substring(0, sourceEndText.length - targetEndText.length), targetStartText.length);
+    for (let i = 1; i < lastTargetIndex; i++) {
+        const delim = targetTexts[i];
+        if (delim.length > 0) {
+            let s = m.seg;
+            let p = m.pos;
+            for (;;) {
+                const d = m.sourceText(s).indexOf(delim, p);
+                if (d >= 0) {
+                    p = d;
+                    break;
+                }
+                s++;
+                if (s === sourceTexts.length)
+                    return undefined;
+                p = 0;
+            }
+            m.addMatch(s, p);
+            m.pos += delim.length;
+        }
+        else if (m.pos < m.sourceText(m.seg).length) {
+            // Consume one code point.
+            const code = m.sourceText(m.seg).codePointAt(m.pos);
+            m.addMatch(m.seg, m.pos + (code > 0xffff ? 2 : 1));
+        }
+        else if (m.seg < lastSourceIndex)
+            m.addMatch(m.seg + 1, 0);
+        else
+            return undefined;
+    }
+    m.addMatch(lastSourceIndex, m.sourceText(lastSourceIndex).length);
+    return m.matches;
+}
+/** For a string literal inferred to a placeholder constrained to primitives, the literal type the constraint prefers. */
+function getTemplatePlaceholderInference(c, source, constraint) {
+    let allTypeFlags = 0 /* TypeFlags.None */;
+    for (const t of distributedTypes(constraint))
+        allTypeFlags |= t.flags;
+    // A constraint including `string` needs no more specific type.
+    if ((allTypeFlags & 32 /* TypeFlags.String */) !== 0)
+        return undefined;
+    const str = source.stringValue;
+    if ((allTypeFlags & 67648 /* TypeFlags.NumberLike */) !== 0 && !isValidNumberString(str, true))
+        allTypeFlags &= ~67648 /* TypeFlags.NumberLike */;
+    if ((allTypeFlags & 4224 /* TypeFlags.BigIntLike */) !== 0 && !isValidBigIntString(str, true))
+        allTypeFlags &= ~4224 /* TypeFlags.BigIntLike */;
+    let matching = c.neverType;
+    for (const t of distributedTypes(constraint))
+        matching = choosePlaceholderType(c, matching, t, source, str, allTypeFlags);
+    return (matching.flags & 262144 /* TypeFlags.Never */) === 0 ? matching : undefined;
+}
+function choosePlaceholderType(c, left, right, source, str, allTypeFlags) {
+    if ((right.flags & allTypeFlags) === 0)
+        return left;
+    if ((left.flags & 32 /* TypeFlags.String */) !== 0)
+        return left;
+    if ((right.flags & 32 /* TypeFlags.String */) !== 0)
+        return source;
+    if ((left.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0)
+        return left;
+    if ((right.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0 &&
+        isTypeMatchedByTemplateLiteralType(c, source, right))
+        return source;
+    if ((left.flags & 8388608 /* TypeFlags.StringMapping */) !== 0)
+        return left;
+    if ((right.flags & 8388608 /* TypeFlags.StringMapping */) !== 0 && str === applyStringMapping(right.symbol, str))
+        return source;
+    if ((left.flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
+        return left;
+    if ((right.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 && right.stringValue === str)
+        return right;
+    if ((left.flags & 64 /* TypeFlags.Number */) !== 0)
+        return left;
+    if ((right.flags & 64 /* TypeFlags.Number */) !== 0)
+        return getNumberLiteralType(c, Number(str));
+    if ((left.flags & 65536 /* TypeFlags.Enum */) !== 0)
+        return left;
+    if ((right.flags & 65536 /* TypeFlags.Enum */) !== 0)
+        return getNumberLiteralType(c, Number(str));
+    if ((left.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0)
+        return left;
+    if ((right.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0 && right.numberValue === Number(str))
+        return right;
+    if ((left.flags & 128 /* TypeFlags.BigInt */) !== 0)
+        return left;
+    if ((right.flags & 128 /* TypeFlags.BigInt */) !== 0)
+        return getBigIntLiteralType(c, parsePseudoBigInt(str));
+    if ((left.flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0)
+        return left;
+    if ((right.flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0 && right.stringValue === str)
+        return right;
+    if ((left.flags & 256 /* TypeFlags.Boolean */) !== 0)
+        return left;
+    if ((right.flags & 256 /* TypeFlags.Boolean */) !== 0)
+        return str === 'true' ? c.trueType : str === 'false' ? c.falseType : c.booleanType;
+    if ((left.flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0)
+        return left;
+    if ((right.flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0 && right.stringValue === str)
+        return right;
+    if ((left.flags & 4 /* TypeFlags.Undefined */) !== 0)
+        return left;
+    if ((right.flags & 4 /* TypeFlags.Undefined */) !== 0 && right.intrinsicName === str)
+        return right;
+    if ((left.flags & 8 /* TypeFlags.Null */) !== 0)
+        return left;
+    if ((right.flags & 8 /* TypeFlags.Null */) !== 0 && right.intrinsicName === str)
+        return right;
+    return left;
+}
+export function isValidNumberString(s, roundTripOnly) {
+    if (s === '')
+        return false;
+    const n = Number(s);
+    return isFinite(n) && (!roundTripOnly || String(n) === s);
+}
+/** Whether `s` scans as a bigint literal without separators; round-trippable ones print as written. */
+export function isValidBigIntString(s, roundTripOnly) {
+    if (roundTripOnly)
+        return /^-?(0|[1-9][0-9]*)$/.test(s) && s !== '-0';
+    return /^-?(0|[1-9][0-9]*|0[xX][0-9a-fA-F]+|0[bB][01]+|0[oO][0-7]+)$/.test(s);
+}
+// ---- Reverse mapped types
+/** Infers a source type for the homomorphic mapped type `{ [P in keyof T]: X }`, cached. */
+export function inferTypeForHomomorphicMappedType(c, source, target, constraint) {
+    const key = source.id + ',' + target.id + ',' + constraint.id;
+    const caches = c.inferenceCaches;
+    if (caches.reverseHomomorphicMapped.has(key))
+        return caches.reverseHomomorphicMapped.get(key);
+    const t = createReverseMappedType(c, source, target, constraint);
+    caches.reverseHomomorphicMapped.set(key, t);
+    return t;
+}
+function createReverseMappedType(c, source, target, constraint) {
+    // Reverse mappable: a string index signature, or properties of a partially inferable type.
+    if (!(getIndexInfoOfType(c, source, c.stringType) !== undefined ||
+        (getPropertiesOfType(c, source).length !== 0 && isPartiallyInferableType(c, source))))
+        return undefined;
+    // Arrays and tuples map to arrays and tuples of reverse-mapped elements.
+    if (isArrayType(c, source)) {
+        const elementType = inferReverseMappedType(c, getTypeArguments(c, source)[0], target, constraint);
+        if (elementType === undefined)
+            return undefined;
+        return createArrayTypeEx(c, elementType, isReadonlyArrayType(c, source));
+    }
+    if (isTupleType(source)) {
+        const elementTypes = [];
+        for (const t of getElementTypes(c, source)) {
+            const e = inferReverseMappedType(c, t, target, constraint);
+            if (e === undefined)
+                return undefined;
+            elementTypes.push(e);
+        }
+        let elementInfos = tupleTargetOf(source).elementInfos;
+        if ((getMappedTypeModifiers(target) & 4 /* MappedTypeModifiers.IncludeOptional */) !== 0)
+            elementInfos = elementInfos.map((info) => (info.flags & 2 /* ElementFlags.Optional */) !== 0
+                ? new TupleElementInfo(1 /* ElementFlags.Required */, info.labeledDeclaration)
+                : info);
+        return createTupleTypeEx(c, elementTypes, elementInfos, tupleTargetOf(source).readonly);
+    }
+    // Other object types map to an object whose properties are reverse-mapped lazily.
+    const reversed = newObjectType(c, 1024 /* ObjectFlags.ReverseMapped */ | 16 /* ObjectFlags.Anonymous */, undefined);
+    reversed.source = source;
+    reversed.mappedType = target;
+    reversed.constraintType = constraint;
+    return reversed;
+}
+/** Not marked non-inferable, or an object literal or tuple with some inferable part. */
+function isPartiallyInferableType(c, t) {
+    if ((t.objectFlags & 262144 /* ObjectFlags.NonInferrableType */) === 0)
+        return true;
+    if (isObjectLiteralType(t))
+        for (const p of getPropertiesOfType(c, t))
+            if (isPartiallyInferableType(c, getTypeOfSymbol(c, p)))
+                return true;
+    if (isTupleType(t))
+        for (const e of getElementTypes(c, t))
+            if (isPartiallyInferableType(c, e))
+                return true;
+    return false;
+}
+export function inferReverseMappedType(c, source, target, constraint) {
+    const key = source.id + ',' + target.id + ',' + constraint.id;
+    const caches = c.inferenceCaches;
+    if (caches.reverseMapped.has(key))
+        return caches.reverseMapped.get(key) ?? c.unknownType;
+    const stackDepth = caches.reverseStackDepth;
+    setStackEntry(caches.reverseSourceStack, stackDepth, source);
+    setStackEntry(caches.reverseTargetStack, stackDepth, target);
+    caches.reverseStackDepth = stackDepth + 1;
+    const saveExpandingFlags = caches.reverseExpandingFlags;
+    if (isDeeplyNestedType(c, source, caches.reverseSourceStack, stackDepth + 1, 2))
+        caches.reverseExpandingFlags |= 1 /* ExpandingFlags.Source */;
+    if (isDeeplyNestedType(c, target, caches.reverseTargetStack, stackDepth + 1, 2))
+        caches.reverseExpandingFlags |= 2 /* ExpandingFlags.Target */;
+    let t = undefined;
+    if (caches.reverseExpandingFlags !== 3 /* ExpandingFlags.Both */) {
+        const typeParameter = getIndexedAccessType(c, constraint.target, getTypeParameterFromMappedType(c, target));
+        const templateType = getTemplateTypeFromMappedType(c, target);
+        const inference = new InferenceInfo(typeParameter);
+        inferTypes(c, [inference], source, templateType, 0 /* InferencePriority.None */, false);
+        t = getWidenedType(c, getTypeFromInference(c, inference) ?? c.unknownType);
+    }
+    caches.reverseStackDepth = stackDepth;
+    caches.reverseExpandingFlags = saveExpandingFlags;
+    caches.reverseMapped.set(key, t);
+    return t;
+}
+export function resolveReverseMappedTypeMembers(c, t) {
+    const source = t.source;
+    const mappedType = t.mappedType;
+    const constraintType = t.constraintType;
+    const indexInfo = getIndexInfoOfType(c, source, c.stringType);
+    const modifiers = getMappedTypeModifiers(mappedType);
+    const readonlyMask = (modifiers & 1 /* MappedTypeModifiers.IncludeReadonly */) === 0;
+    const optionalMask = (modifiers & 4 /* MappedTypeModifiers.IncludeOptional */) !== 0 ? 0 : 16777216 /* SymbolFlags.Optional */;
+    const indexInfos = indexInfo !== undefined
+        ? [
+            newIndexInfo(c.stringType, inferReverseMappedType(c, indexInfo.valueType, mappedType, constraintType) ?? c.unknownType, readonlyMask && indexInfo.isReadonly, undefined),
+        ]
+        : [];
+    const members = new Map();
+    const limitedConstraint = getLimitedConstraint(c, t);
+    for (const prop of getPropertiesOfType(c, source)) {
+        // With an intersection constraint, skip properties the filtering literals exclude.
+        if (limitedConstraint !== undefined) {
+            const propertyNameType = getLiteralTypeFromProperty(c, prop, 19456 /* TypeFlags.StringOrNumberLiteralOrUnique */, false);
+            if (!isTypeAssignableTo(c, propertyNameType, limitedConstraint))
+                continue;
+        }
+        const checkFlags = 8192 /* CheckFlags.ReverseMapped */ | (readonlyMask && isReadonlySymbol(c, prop) ? 8 /* CheckFlags.Readonly */ : 0);
+        const inferredProp = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | (prop.flags & optionalMask), prop.name, checkFlags);
+        inferredProp.declarations = prop.declarations;
+        const links = c.symbolLinks(inferredProp);
+        const id = inferredProp.id;
+        c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(prop)));
+        links.reverseMappedPropertyType = getTypeOfSymbol(c, prop);
+        const constraintTarget = constraintType.target;
+        if ((constraintTarget.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0 &&
+            (constraintTarget.objectType.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 &&
+            (constraintTarget.indexType.flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
+            // `{[K in keyof T[K_1]]: T[K_1]}` reverse-maps like `{[K in keyof T]: T}`.
+            const newTypeParam = constraintTarget.objectType;
+            links.reverseMappedMappedType = replaceIndexedAccess(c, mappedType, constraintTarget, newTypeParam);
+            links.reverseMappedConstraintType = getIndexType(c, newTypeParam);
+        }
+        else {
+            links.reverseMappedMappedType = mappedType;
+            links.reverseMappedConstraintType = constraintType;
+        }
+        members.set(prop.name, inferredProp);
+    }
+    setStructuredTypeMembers(c, t, members, [], [], indexInfos);
+}
+export function getTypeOfReverseMappedSymbol(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    const id = symbol.id;
+    let type = c.symbolTypes.get(id);
+    if (type === undefined) {
+        type =
+            inferReverseMappedType(c, links.reverseMappedPropertyType, links.reverseMappedMappedType, links.reverseMappedConstraintType) ?? c.unknownType;
+        c.symbolTypes.set(id, type);
+    }
+    return type;
+}
+/** The filtering literals of an intersection constraint, e.g. `"a" | "b"` in `keyof U & ("a" | "b")`. */
+function getLimitedConstraint(c, t) {
+    const constraint = getConstraintTypeFromMappedType(c, t.mappedType);
+    if ((constraint.flags & 402653184 /* TypeFlags.UnionOrIntersection */) === 0)
+        return undefined;
+    const origin = (constraint.flags & 134217728 /* TypeFlags.Union */) !== 0 ? constraint.origin : constraint;
+    if (origin === undefined || (origin.flags & 268435456 /* TypeFlags.Intersection */) === 0)
+        return undefined;
+    const limited = getIntersectionType(c, typesOf(origin).filter((u) => u !== t.constraintType));
+    return limited !== c.neverType ? limited : undefined;
+}
+function replaceIndexedAccess(c, instantiable, t, replacement) {
+    // Map the index to 0 and the object to `[replacement]`, making the access `replacement`.
+    return instantiateType(c, instantiable, newTypeMapper([t.indexType, t.objectType], [getNumberLiteralType(c, 0), createTupleType(c, [replacement])]));
+}
+export function instantiateReverseMappedType(c, t, mapper) {
+    const innerMappedType = instantiateType(c, t.mappedType, mapper);
+    if ((innerMappedType.objectFlags & 32 /* ObjectFlags.Mapped */) === 0)
+        return t;
+    const innerIndexType = instantiateType(c, t.constraintType, mapper);
+    if ((innerIndexType.flags & 2097152 /* TypeFlags.Index */) === 0)
+        return t;
+    const inferred = inferTypeForHomomorphicMappedType(c, instantiateType(c, t.source, mapper), innerMappedType, innerIndexType);
+    return inferred === undefined ? t : inferred;
+}
+// ---- Inferred types
+/** Infers early from intra-expression sites (context-sensitive elements of object and array literals). */
+export function inferFromIntraExpressionSites(c, context) {
+    const sites = context.intraExpressionInferenceSites;
+    context.intraExpressionInferenceSites = [];
+    for (const site of sites) {
+        const contextualType = getContextualTypeForInference(c, site.node);
+        if (contextualType !== undefined)
+            inferTypes(c, context.inferences, site.type, contextualType, 0 /* InferencePriority.None */, false);
+    }
+}
+export function getInferredType(c, context, index) {
+    const inference = context.inferences[index];
+    if (inference.inferredType !== undefined)
+        return inference.inferredType;
+    if (inference.typeParameter === c.errorType)
+        return inference.typeParameter;
+    let inferredType = undefined;
+    let fallbackType = undefined;
+    const signature = context.signature;
+    if (signature !== undefined) {
+        const covariant = inference.candidates.length !== 0 ? getCovariantInference(c, inference, signature) : undefined;
+        const contravariant = inference.contraCandidates.length !== 0 ? getContravariantInference(c, inference) : undefined;
+        if (covariant !== undefined || contravariant !== undefined) {
+            // Prefer the covariant inference when it isn't never or any, is assignable to some
+            // contravariant candidate, and no type parameter constrained to this one conflicts.
+            const preferCovariantType = covariant !== undefined &&
+                (contravariant === undefined ||
+                    ((covariant.flags & (262144 /* TypeFlags.Never */ | 1 /* TypeFlags.Any */)) === 0 &&
+                        someTypeAssignableFrom(c, covariant, inference.contraCandidates) &&
+                        noConflictingConstrainedInference(c, context, inference, covariant)));
+            if (preferCovariantType) {
+                inferredType = covariant;
+                fallbackType = contravariant;
+            }
+            else {
+                inferredType = contravariant;
+                fallbackType = covariant;
+            }
+        }
+        else if ((context.flags & 1 /* InferenceFlags.NoDefault */) !== 0) {
+            // silentNeverType signals no inferences.
+            inferredType = c.silentNeverType;
+        }
+        else {
+            // No inferences: the default, with forward references to later type parameters erased.
+            const defaultType = getDefaultFromTypeParameter(c, inference.typeParameter);
+            if (defaultType !== undefined)
+                inferredType = instantiateType(c, defaultType, new MergedTypeMapper(newBackreferenceMapper(c, context, index), context.nonFixingMapper));
+        }
+    }
+    else
+        inferredType = getTypeFromInference(c, inference);
+    inference.inferredType =
+        inferredType ?? ((context.flags & 2 /* InferenceFlags.AnyDefault */) !== 0 ? c.anyType : c.unknownType);
+    const constraint = getConstraintOfTypeParameter(c, inference.typeParameter);
+    if (constraint !== undefined) {
+        const instantiatedConstraint = instantiateType(c, constraint, context.nonFixingMapper);
+        if (inferredType !== undefined) {
+            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.
+                let filtered = undefined;
+                if (inference.priority === 128 /* InferencePriority.ReturnType */)
+                    filtered = mapType(c, inferredType, (t) => context.compareTypes.compare(t, constraintWithThis, false) !== 0 /* Ternary.False */ ? t : c.neverType);
+                inferredType = filtered !== undefined && (filtered.flags & 262144 /* TypeFlags.Never */) === 0 ? filtered : undefined;
+            }
+        }
+        if (inferredType === undefined)
+            inferredType =
+                fallbackType !== undefined &&
+                    context.compareTypes.compare(fallbackType, getTypeWithThisArgument(c, instantiatedConstraint, fallbackType, false), false) !== 0 /* Ternary.False */
+                    ? fallbackType
+                    : instantiatedConstraint;
+        inference.inferredType = inferredType;
+    }
+    clearActiveMapperCaches(c);
+    return inference.inferredType;
+}
+function clearActiveMapperCaches(c) {
+    for (const cache of c.activeMapperCaches)
+        if (cache !== undefined)
+            cache.clear();
+    for (const cache of c.activeMapperAliasCaches)
+        if (cache !== undefined)
+            cache.clear();
+}
+/** Type ids below this bound pack in pairs into one exact number. */
+const VisitKeyIdLimit = 1 << 26;
+/** 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;
+    const t = target.id;
+    return s < VisitKeyIdLimit && t < VisitKeyIdLimit ? s * VisitKeyIdLimit + t : -1;
+}
+/** Maps forward references to later type parameters to `unknown`, for instantiating defaults. */
+function newBackreferenceMapper(c, context, index) {
+    return new ArrayToSingleTypeMapper(context.inferences.slice(index).map((i) => i.typeParameter), c.unknownType);
+}
+export function getInferredTypes(c, context) {
+    const result = [];
+    for (let i = 0; i < context.inferences.length; i++)
+        result.push(getInferredType(c, context, i));
+    return result;
+}
+function getCovariantInference(c, inference, signature) {
+    // Object and array literal candidates become one widened, normalized type.
+    const candidates = unionObjectAndArrayLiteralCandidates(c, inference.candidates);
+    // Widen literals when all inferences were to top-level occurrences, the type parameter has no
+    // primitive constraint, and it was fixed or doesn't occur at top level in the return type.
+    const primitiveConstraint = hasPrimitiveConstraint(c, inference.typeParameter) || isConstTypeVariable(c, inference.typeParameter, 0);
+    const widenLiteralTypes = !primitiveConstraint &&
+        inference.topLevel &&
+        (inference.isFixed || !isTypeParameterAtTopLevelInReturnType(c, signature, inference.typeParameter));
+    let baseCandidates = candidates;
+    if (primitiveConstraint || widenLiteralTypes) {
+        baseCandidates = [];
+        for (const t of candidates)
+            baseCandidates.push(primitiveConstraint ? getRegularTypeOfLiteralType(c, t) : getWidenedLiteralType(c, t));
+    }
+    // Positions implying a combined result infer a union, others a common supertype.
+    const unwidenedType = (inference.priority & 416 /* InferencePriority.PriorityImpliesCombination */) !== 0
+        ? getUnionTypeEx(c, baseCandidates, 2 /* UnionReduction.Subtype */, undefined, undefined)
+        : getCommonSupertype(c, baseCandidates);
+    return getWidenedType(c, unwidenedType);
+}
+function getContravariantInference(c, inference) {
+    return (inference.priority & 416 /* InferencePriority.PriorityImpliesCombination */) !== 0
+        ? getIntersectionType(c, inference.contraCandidates)
+        : getCommonSubtype(c, inference.contraCandidates);
+}
+function someTypeAssignableFrom(c, source, targets) {
+    for (const t of targets)
+        if (isTypeAssignableTo(c, source, t))
+            return true;
+    return false;
+}
+/** No other inference constrained to `inference`'s type parameter has a candidate not assignable to `covariant`. */
+function noConflictingConstrainedInference(c, context, inference, covariant) {
+    for (const other of context.inferences) {
+        if (other !== inference && getConstraintOfTypeParameter(c, other.typeParameter) !== inference.typeParameter)
+            continue;
+        for (const t of other.candidates)
+            if (!isTypeAssignableTo(c, t, covariant))
+                return false;
+    }
+    return true;
+}
+function everyNonGenericObjectType(c, types) {
+    for (const t of types)
+        if (!isNonGenericObjectType(c, t))
+            return false;
+    return true;
+}
+function isObjectOrArrayLiteralType(t) {
+    return (t.objectFlags & (128 /* ObjectFlags.ObjectLiteral */ | 16384 /* ObjectFlags.ArrayLiteral */)) !== 0;
+}
+function unionObjectAndArrayLiteralCandidates(c, candidates) {
+    if (candidates.length > 1) {
+        const objectLiterals = [];
+        const result = [];
+        for (const t of candidates) {
+            if (isObjectOrArrayLiteralType(t))
+                objectLiterals.push(t);
+            else
+                result.push(t);
+        }
+        if (objectLiterals.length !== 0) {
+            result.push(getUnionTypeEx(c, objectLiterals, 2 /* UnionReduction.Subtype */, undefined, undefined));
+            return result;
+        }
+    }
+    return candidates;
+}
+function hasPrimitiveConstraint(c, t) {
+    let constraint = getConstraintOfTypeParameter(c, t);
+    if (constraint === undefined)
+        return false;
+    if ((constraint.flags & 67108864 /* TypeFlags.Conditional */) !== 0)
+        constraint = getConstraintFromConditionalType(c, constraint);
+    return maybeTypeOfKind(constraint, 12713980 /* TypeFlags.Primitive */ | 2097152 /* TypeFlags.Index */ | 4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */);
+}
+export function getTypeFromInference(c, inference) {
+    if (inference.candidates.length !== 0)
+        return getUnionTypeEx(c, inference.candidates, 2 /* UnionReduction.Subtype */, undefined, undefined);
+    if (inference.contraCandidates.length !== 0)
+        return getIntersectionType(c, inference.contraCandidates);
+    return undefined;
+}
+export function getCommonSupertype(c, types) {
+    if (types.length === 1)
+        return types[0];
+    // Remove nullable types, find the supertype, and add them back.
+    let primaryTypes = types;
+    if (c.strictNullChecks) {
+        primaryTypes = [];
+        for (const t of types)
+            primaryTypes.push(filterType(c, t, (u) => (u.flags & 12 /* TypeFlags.Nullable */) === 0));
+    }
+    const supertype = literalTypesWithSameBaseType(c, primaryTypes)
+        ? getUnionType(c, primaryTypes)
+        : getSingleCommonSupertype(c, primaryTypes);
+    let same = true;
+    for (let i = 0; i < types.length; i++)
+        if (primaryTypes[i] !== types[i])
+            same = false;
+    if (same)
+        return supertype;
+    return getNullableType(c, supertype, getCombinedTypeFlags(types) & 12 /* TypeFlags.Nullable */);
+}
+function getSingleCommonSupertype(c, types) {
+    // The leftmost type no type to its right is a strict supertype of, if it's a strict supertype of
+    // all others; otherwise the same with regular supertypes.
+    let candidate = undefined;
+    for (const t of types)
+        if (candidate === undefined || isTypeStrictSubtypeOf(c, candidate, t))
+            candidate = t;
+    let strictSupertype = true;
+    for (const t of types) {
+        if (t !== candidate && !isTypeStrictSubtypeOf(c, t, candidate)) {
+            strictSupertype = false;
+            break;
+        }
+    }
+    if (strictSupertype)
+        return candidate;
+    candidate = undefined;
+    for (const t of types)
+        if (candidate === undefined || isTypeSubtypeOf(c, candidate, t))
+            candidate = t;
+    return candidate;
+}
+/** The leftmost type no type to its right is a subtype of. */
+export function getCommonSubtype(c, types) {
+    let subtype = undefined;
+    for (const t of types)
+        if (subtype === undefined || isTypeSubtypeOf(c, t, subtype))
+            subtype = t;
+    return subtype;
+}
+function getCombinedTypeFlags(types) {
+    let flags = 0 /* TypeFlags.None */;
+    for (const t of types)
+        flags |= (t.flags & 134217728 /* TypeFlags.Union */) !== 0 ? getCombinedTypeFlags(typesOf(t)) : t.flags;
+    return flags;
+}
+function literalTypesWithSameBaseType(c, types) {
+    let commonBaseType = undefined;
+    for (const t of types) {
+        if ((t.flags & 262144 /* TypeFlags.Never */) !== 0)
+            continue;
+        const baseType = getBaseTypeOfLiteralType(c, t);
+        if (commonBaseType === undefined)
+            commonBaseType = baseType;
+        if (baseType === t || baseType !== commonBaseType)
+            return false;
+    }
+    return true;
+}
+// ---- Conditional types
+/** A mapper from a conditional type's `infer` type parameters to their inferences. */
+export function inferTypesForConditional(c, root, checkType, extendsType, mapper, checkTypeDeferred) {
+    // The constraints of `infer` type parameters may refer to other roots or to what `mapper` maps,
+    // so the non-fixing mapper combines with `mapper`.
+    const context = createInferenceContext(c, root.inferTypeParameters, undefined, 0 /* InferenceFlags.None */, undefined);
+    if (mapper !== undefined)
+        context.nonFixingMapper = combineTypeMappers(c, context.nonFixingMapper, mapper);
+    // Inferences from constraints could eagerly resolve what should defer; contravariance is always strict.
+    if (!checkTypeDeferred)
+        inferTypes(c, context.inferences, checkType, extendsType, 512 /* InferencePriority.NoConstraints */ | 1024 /* InferencePriority.AlwaysStrict */, false);
+    return context.mapper;
+}
+/** Caches and stacks for inference, contextual typing and call resolution. */
+export class InferenceCaches {
+    /**
+     * Contextual types pushed for nodes being checked, innermost last. The first `contextualDepth`
+     * entries are live; popping keeps the slots after them for reuse.
+     */
+    contextualNodes = [];
+    contextualTypes = [];
+    contextualIsCache = [];
+    contextualDepth = 0;
+    /** Inference contexts pushed for arguments being checked, innermost last; `inferenceDepth` are live. */
+    inferenceNodes = [];
+    inferenceContexts = [];
+    inferenceDepth = 0;
+    optionalCallSignatures = new Map();
+    discriminatedContextualTypes = new Map();
+    /** `discriminatedContextualTypes` by node and type id packed into one number, when they fit. */
+    discriminatedContextualTypesById = new Map();
+    /** For union contextual types, what each constituent has for a missing optional property (discriminateTypeByObjectLiteral). */
+    missingPropertyStates = new Map();
+    contextFreeTypes = new Map();
+    reverseMapped = new Map();
+    reverseHomomorphicMapped = new Map();
+    /** inferReverseMappedType's recursion stacks; the first `reverseStackDepth` entries of each are live. */
+    reverseSourceStack = [];
+    reverseTargetStack = [];
+    reverseStackDepth = 0;
+    reverseExpandingFlags = 0 /* ExpandingFlags.None */;
+}
+// ---- Constraints of `infer` type parameters
+/**
+ * Maps the type parameters of a type reference to its type arguments, resolving them (and filling
+ * in defaults) only when a type parameter is mapped.
+ */
+class TypeArgumentMapper extends TypeMapper {
+    c;
+    typeArgumentNodes;
+    typeParameters;
+    filled = undefined;
+    constructor(c, typeArgumentNodes, typeParameters) {
+        super();
+        this.c = c;
+        this.typeArgumentNodes = typeArgumentNodes;
+        this.typeParameters = typeParameters;
+    }
+    map(t) {
+        const index = this.typeParameters.indexOf(t);
+        if (index < 0)
+            return t;
+        if (index < this.typeArgumentNodes.length)
+            return getTypeFromTypeNode(this.c, this.typeArgumentNodes[index]);
+        if (this.filled === undefined) {
+            const typeArguments = [];
+            for (const n of this.typeArgumentNodes)
+                typeArguments.push(getTypeFromTypeNode(this.c, n));
+            this.filled = fillMissingTypeArguments(this.c, typeArguments, this.typeParameters, getMinTypeArgumentCount(this.c, this.typeParameters), false);
+        }
+        return this.filled[index];
+    }
+}
+/**
+ * The constraint an `infer T` position implies, e.g. `unknown[]` in a rest position; with
+ * `omitTypeReferences`, `Foo<infer T>` implies none.
+ */
+export function getInferredTypeParameterConstraint(c, t, omitTypeReferences = false) {
+    const inferences = [];
+    const symbol = t.symbol;
+    if (symbol !== undefined)
+        for (const declaration of symbol.declarations) {
+            if (declaration.parent === undefined || declaration.parent.kind !== 196 /* SyntaxKind.InferType */)
+                continue;
+            let child = declaration.parent;
+            let parent = child.parent;
+            while (parent !== undefined && parent.kind === 197 /* SyntaxKind.ParenthesizedType */) {
+                child = parent;
+                parent = child.parent;
+            }
+            if (parent === undefined)
+                continue;
+            switch (parent.kind) {
+                case 184 /* SyntaxKind.TypeReference */: {
+                    if (omitTypeReferences)
+                        break;
+                    // `Foo<infer T>` takes the constraint of Foo's corresponding type parameter.
+                    const typeArgumentNodes = parent.typeArguments;
+                    const typeParameters = getTypeParametersForTypeReference(c, parent);
+                    if (typeArgumentNodes === undefined || typeParameters === undefined)
+                        break;
+                    const index = typeArgumentNodes.nodes.indexOf(child);
+                    if (index < 0 || index >= typeParameters.length)
+                        break;
+                    const declaredConstraint = getConstraintOfTypeParameter(c, typeParameters[index]);
+                    if (declaredConstraint === undefined)
+                        break;
+                    // Constraints referencing the type parameter itself are discarded.
+                    const constraint = instantiateType(c, declaredConstraint, new TypeArgumentMapper(c, typeArgumentNodes.nodes, typeParameters));
+                    if (constraint !== t)
+                        inferences.push(constraint);
+                    break;
+                }
+                case 170 /* SyntaxKind.Parameter */:
+                    if (parent.dotDotDotToken !== undefined)
+                        inferences.push(createArrayType(c, c.unknownType));
+                    break;
+                case 192 /* SyntaxKind.RestType */:
+                    inferences.push(createArrayType(c, c.unknownType));
+                    break;
+                case 203 /* SyntaxKind.NamedTupleMember */:
+                    if (parent.dotDotDotToken !== undefined)
+                        inferences.push(createArrayType(c, c.unknownType));
+                    break;
+                case 205 /* SyntaxKind.TemplateLiteralTypeSpan */:
+                    inferences.push(c.stringType);
+                    break;
+                case 169 /* SyntaxKind.TypeParameter */:
+                    if (parent.parent !== undefined && parent.parent.kind === 201 /* SyntaxKind.MappedType */)
+                        inferences.push(c.stringNumberSymbolType);
+                    break;
+                case 201 /* 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.extendsType === parent &&
+                        conditional.checkType.kind === 201 /* SyntaxKind.MappedType */ &&
+                        conditional.checkType.type !== undefined) {
+                        const checkMappedType = conditional.checkType;
+                        const nodeType = getTypeFromTypeNode(c, checkMappedType.type);
+                        const checkMappedTypeParameter = checkMappedType.typeParameter;
+                        const mapper = new SimpleTypeMapper(getDeclaredTypeOfTypeParameter(c, getSymbolOfDeclaration(c, checkMappedTypeParameter)), checkMappedTypeParameter.constraint !== undefined
+                            ? getTypeFromTypeNode(c, checkMappedTypeParameter.constraint)
+                            : c.stringNumberSymbolType);
+                        inferences.push(instantiateType(c, nodeType, mapper));
+                    }
+                    break;
+                }
+            }
+        }
+    return inferences.length !== 0 ? getIntersectionType(c, inferences) : undefined;
+}
+function getTypeParametersForTypeReference(c, node) {
+    if (isErrorType(c, getTypeFromTypeNode(c, node)))
+        return undefined;
+    const symbol = c.resolvedSymbols.get(node.id);
+    if (symbol === undefined || symbol === c.unknownSymbol)
+        return undefined;
+    if ((symbol.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */)) !== 0)
+        return getDeclaredTypeOfClassOrInterface(c, getMergedSymbol(c, symbol)).localTypeParameters();
+    if ((symbol.flags & 524288 /* SymbolFlags.TypeAlias */) !== 0) {
+        getDeclaredTypeOfSymbol(c, symbol);
+        return c.symbolLinks(symbol).typeParameters;
+    }
+    return undefined;
+}