@typescript-deploys/pr-build 5.0.0-pr-52899-2 → 5.0.0-pr-52944-9

package/lib/tsc.js

@@ -7825,8 +7825,7 @@ var Diagnostics = {
   _0_is_possibly_undefined: diag(18048, 1 /* Error */, "_0_is_possibly_undefined_18048", "'{0}' is possibly 'undefined'."),
   _0_is_possibly_null_or_undefined: diag(18049, 1 /* Error */, "_0_is_possibly_null_or_undefined_18049", "'{0}' is possibly 'null' or 'undefined'."),
   The_value_0_cannot_be_used_here: diag(18050, 1 /* Error */, "The_value_0_cannot_be_used_here_18050", "The value '{0}' cannot be used here."),
-  Compiler_option_0_cannot_be_given_an_empty_string: diag(18051, 1 /* Error */, "Compiler_option_0_cannot_be_given_an_empty_string_18051", "Compiler option '{0}' cannot be given an empty string."),
-  Add_missing_comma_for_an_object_member_completion_0: diag(18052, 3 /* Message */, "Add_missing_comma_for_an_object_member_completion_0_18052", "Add missing comma for an object member completion '{0}'.")
+  Compiler_option_0_cannot_be_given_an_empty_string: diag(18051, 1 /* Error */, "Compiler_option_0_cannot_be_given_an_empty_string_18051", "Compiler option '{0}' cannot be given an empty string.")
 };
 
 // src/compiler/scanner.ts
@@ -54422,27 +54421,15 @@ function createTypeChecker(host) {
       isInJSFile(signature.declaration)
     );
   }
-  function getBaseSignature(signature) {
-    const typeParameters = signature.typeParameters;
-    if (typeParameters) {
-      if (signature.baseSignatureCache) {
-        return signature.baseSignatureCache;
-      }
-      const typeEraser = createTypeEraser(typeParameters);
-      const baseConstraintMapper = createTypeMapper(typeParameters, map(typeParameters, (tp) => getConstraintOfTypeParameter(tp) || unknownType));
-      let baseConstraints = map(typeParameters, (tp) => instantiateType(tp, baseConstraintMapper) || unknownType);
-      for (let i = 0; i < typeParameters.length - 1; i++) {
-        baseConstraints = instantiateTypes(baseConstraints, baseConstraintMapper);
-      }
-      baseConstraints = instantiateTypes(baseConstraints, typeEraser);
-      return signature.baseSignatureCache = instantiateSignature(
-        signature,
-        createTypeMapper(typeParameters, baseConstraints),
-        /*eraseTypeParameters*/
-        true
-      );
+  function getTypeParameterConstraintMapper(typeParameters) {
+    const typeEraser = createTypeEraser(typeParameters);
+    const baseConstraintMapper = createTypeMapper(typeParameters, map(typeParameters, (tp) => getConstraintOfTypeParameter(tp) || unknownType));
+    let baseConstraints = map(typeParameters, (tp) => instantiateType(tp, baseConstraintMapper) || unknownType);
+    for (let i = 0; i < typeParameters.length - 1; i++) {
+      baseConstraints = instantiateTypes(baseConstraints, baseConstraintMapper);
     }
-    return signature;
+    baseConstraints = instantiateTypes(baseConstraints, typeEraser);
+    return createTypeMapper(typeParameters, baseConstraints);
   }
   function getOrCreateTypeFromSignature(signature) {
     var _a2;
@@ -56967,9 +56954,9 @@ function createTypeChecker(host) {
           }
         }
         if (!checkTypeDeferred) {
-          inferTypes(context.inferences, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+          inferTypes(context, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
         }
-        const innerMapper = combineTypeMappers(freshMapper, context.mapper);
+        const innerMapper = combineTypeMappers(freshMapper, getMapperFromContext(context));
         combinedMapper = mapper ? combineTypeMappers(innerMapper, mapper) : innerMapper;
       }
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
@@ -57656,8 +57643,11 @@ function createTypeChecker(host) {
       void 0
     );
   }
-  function createBackreferenceMapper(context, index) {
-    const forwardInferences = context.inferences.slice(index);
+  function createBackreferenceMapper(context, inference) {
+    const inferences = context.inferences.indexOf(inference) >= 0 ? context.inferences : context.freeTypeVariables;
+    Debug.assert(inferences, "Inference for backreference mapper must exist within provided context");
+    const index = inferences.indexOf(inference);
+    const forwardInferences = inferences.slice(index);
     return createTypeMapper(map(forwardInferences, (i) => i.typeParameter), map(forwardInferences, () => unknownType));
   }
   function combineTypeMappers(mapper1, mapper2) {
@@ -60471,9 +60461,10 @@ function createTypeChecker(host) {
               0 /* None */,
               isRelatedToWorker
             );
-            inferTypes(ctx.inferences, target2.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
-            sourceExtends = instantiateType(sourceExtends, ctx.mapper);
-            mapper = ctx.mapper;
+            inferTypes(ctx, target2.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+            const newMapper = getMapperFromContext(ctx);
+            sourceExtends = instantiateType(sourceExtends, newMapper);
+            mapper = newMapper;
           }
           if (isTypeIdenticalTo(sourceExtends, target2.extendsType) && (isRelatedTo(source2.checkType, target2.checkType, 3 /* Both */) || isRelatedTo(target2.checkType, source2.checkType, 3 /* Both */))) {
             if (result2 = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source2), mapper), getTrueTypeFromConditionalType(target2), 3 /* Both */, reportErrors2)) {
@@ -62311,7 +62302,12 @@ function createTypeChecker(host) {
     return createInferenceContextWorker(typeParameters.map(createInferenceInfo), signature, flags, compareTypes || compareTypesAssignable);
   }
   function cloneInferenceContext(context, extraFlags = 0) {
-    return context && createInferenceContextWorker(map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes);
+    const newContext = context && createInferenceContextWorker(map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes);
+    if (context && context.freeTypeVariables) {
+      newContext.freeTypeVariables = map(context.freeTypeVariables, cloneInferenceInfo);
+      newContext.freeTypeVariableSourceSignatures = new Map(mapIterator(context.freeTypeVariableSourceSignatures.entries(), ([k, v]) => [k, new Map(v.entries())]));
+    }
+    return newContext;
   }
   function createInferenceContextWorker(inferences, signature, flags, compareTypes) {
     const context = {
@@ -62328,20 +62324,29 @@ function createTypeChecker(host) {
     return context;
   }
   function makeFixingMapperForContext(context) {
-    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (inference, i) => () => {
+    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (inference) => () => {
       if (!inference.isFixed) {
         inferFromIntraExpressionSites(context);
         clearCachedInferences(context.inferences);
         inference.isFixed = true;
       }
-      return getInferredType(context, i);
+      return getInferredType(context, inference);
     }));
   }
   function makeNonFixingMapperForContext(context) {
-    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (_, i) => () => {
-      return getInferredType(context, i);
+    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (inference) => () => {
+      return getInferredType(context, inference);
     }));
   }
+  function makeFreeTypeVariableMapperForContext(context) {
+    if (!context.freeTypeVariables)
+      return void 0;
+    const baseMapper = getTypeParameterConstraintMapper(map(context.freeTypeVariables, (i) => i.typeParameter));
+    return context.freeTypeVariables.reduceRight(
+      (previous, i) => combineTypeMappers(makeDeferredTypeMapper([i.typeParameter], [() => hasInferenceCandidatesOrDefault(i) ? getInferredType(context, i) : instantiateType(i.typeParameter, baseMapper)]), previous),
+      baseMapper
+    );
+  }
   function clearCachedInferences(inferences) {
     for (const inference of inferences) {
       if (!inference.isFixed) {
@@ -62358,7 +62363,7 @@ function createTypeChecker(host) {
       for (const { node, type } of context.intraExpressionInferenceSites) {
         const contextualType = node.kind === 171 /* MethodDeclaration */ ? getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) : getContextualType(node, 2 /* NoConstraints */);
         if (contextualType) {
-          inferTypes(context.inferences, type, contextualType);
+          inferTypes(context, type, contextualType);
         }
       }
       context.intraExpressionInferenceSites = void 0;
@@ -62393,7 +62398,8 @@ function createTypeChecker(host) {
     return inferences.length ? createInferenceContextWorker(map(inferences, cloneInferenceInfo), context.signature, context.flags, context.compareTypes) : void 0;
   }
   function getMapperFromContext(context) {
-    return context && context.mapper;
+    const innerContext = context && last(flattenInferenceContextAlternatives(context));
+    return innerContext && innerContext.mapper && (innerContext.freeTypeVariables ? combineTypeMappers(innerContext.mapper, makeFreeTypeVariableMapperForContext(innerContext)) : innerContext.mapper);
   }
   function couldContainTypeVariables(type) {
     const objectFlags = getObjectFlags(type);
@@ -62493,8 +62499,15 @@ function createTypeChecker(host) {
     const typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target));
     const templateType = getTemplateTypeFromMappedType(target);
     const inference = createInferenceInfo(typeParameter);
-    inferTypes([inference], sourceType, templateType);
-    return getTypeFromInference(inference) || unknownType;
+    const context = createInferenceContextWorker(
+      [inference],
+      /*signature*/
+      void 0,
+      0 /* None */,
+      compareTypesAssignable
+    );
+    inferTypes(context, sourceType, templateType);
+    return getInferredTypes(context, returnFalse)[0] || unknownType;
   }
   function* getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {
     const properties = getPropertiesOfType(target);
@@ -62671,7 +62684,15 @@ function createTypeChecker(host) {
       pos = p;
     }
   }
-  function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
+  function flattenInferenceContextAlternatives(context) {
+    return context.alternatives ? (context.alternatives.forEach((a) => mergeInferenceContexts(
+      a,
+      context,
+      /*clone*/
+      true
+    )), context.alternatives) : [context];
+  }
+  function inferTypes(context, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
     let bivariant = false;
     let propagationType;
     let inferencePriority = 2048 /* MaxValue */;
@@ -62680,7 +62701,21 @@ function createTypeChecker(host) {
     let sourceStack;
     let targetStack;
     let expandingFlags = 0 /* None */;
+    let useOnlyCachedAlternativeRoutes = false;
     inferFromTypes(originalSource, originalTarget);
+    useOnlyCachedAlternativeRoutes = true;
+    const group2 = forkInferenceContext();
+    spawnAlternativeInferenceContext(
+      group2,
+      () => {
+        if (length(context.freeTypeVariables)) {
+          inferFromTypes(originalSource, instantiateType(originalTarget, context.nonFixingMapper));
+        }
+      },
+      /*fork*/
+      false
+    );
+    joinInferenceContext(group2);
     function inferFromTypes(source, target) {
       if (!couldContainTypeVariables(target)) {
         return;
@@ -62741,6 +62776,9 @@ function createTypeChecker(host) {
           if (getObjectFlags(source) & 262144 /* NonInferrableType */ || source === nonInferrableAnyType) {
             return;
           }
+          if (useOnlyCachedAlternativeRoutes && source === target) {
+            return;
+          }
           if (!inference.isFixed) {
             if (inference.priority === void 0 || priority < inference.priority) {
               inference.candidates = void 0;
@@ -62753,16 +62791,16 @@ function createTypeChecker(host) {
               if (contravariant && !bivariant) {
                 if (!contains(inference.contraCandidates, candidate)) {
                   inference.contraCandidates = append(inference.contraCandidates, candidate);
-                  clearCachedInferences(inferences);
+                  clearCachedInferences(context.inferences);
                 }
               } else if (!contains(inference.candidates, candidate)) {
                 inference.candidates = append(inference.candidates, candidate);
-                clearCachedInferences(inferences);
+                clearCachedInferences(context.inferences);
               }
             }
             if (!(priority & 128 /* ReturnType */) && target.flags & 262144 /* TypeParameter */ && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, target)) {
               inference.topLevel = false;
-              clearCachedInferences(inferences);
+              clearCachedInferences(context.inferences);
             }
           }
           inferencePriority = Math.min(inferencePriority, priority);
@@ -62930,7 +62968,12 @@ function createTypeChecker(host) {
     }
     function getInferenceInfoForType(type) {
       if (type.flags & 8650752 /* TypeVariable */) {
-        for (const inference of inferences) {
+        for (const inference of context.inferences) {
+          if (type === inference.typeParameter) {
+            return inference;
+          }
+        }
+        for (const inference of context.freeTypeVariables || []) {
           if (type === inference.typeParameter) {
             return inference;
           }
@@ -63211,17 +63254,88 @@ function createTypeChecker(host) {
         }
       }
     }
+    function forkInferenceContext() {
+      return [];
+    }
+    function spawnAlternativeInferenceContext(group3, action, fork = true) {
+      const oldContext = context;
+      flattenInferenceContextAlternatives(context).forEach((alternative) => {
+        const newContext = fork ? cloneInferenceContext(alternative) : alternative;
+        context = newContext;
+        action();
+        context = oldContext;
+        group3.push(...flattenInferenceContextAlternatives(newContext));
+      });
+    }
+    function joinInferenceContext(group3) {
+      group3 = group3.length < 10 ? deduplicate(group3, compareInferenceContext) : group3;
+      if (group3.length === 1) {
+        mergeInferenceContexts(context, group3[0]);
+        context.freeTypeVariables = group3[0].freeTypeVariables;
+        context.freeTypeVariableSourceSignatures = group3[0].freeTypeVariableSourceSignatures;
+        context.inferredTypeParameters = group3[0].inferredTypeParameters;
+        context.flags = group3[0].flags;
+        context.alternatives = void 0;
+        return;
+      }
+      context.alternatives = group3;
+    }
+    function compareInferenceContext(a, b) {
+      return a.compareTypes === b.compareTypes && a.flags === b.flags && a.inferredTypeParameters === b.inferredTypeParameters && a.intraExpressionInferenceSites === b.intraExpressionInferenceSites && a.signature === b.signature && compareInferencesIdentical(a, a.inferences, b, b.inferences) && compareInferencesIdentical(a, a.freeTypeVariables, b, b.freeTypeVariables);
+    }
+    function compareInferencesIdentical(ctxA, a, ctxB, b) {
+      if (length(a) !== length(b))
+        return false;
+      if (length(a) === 0)
+        return true;
+      for (let i = 0; i < length(a); i++) {
+        if (a[i].typeParameter !== b[i].typeParameter || a[i].impliedArity !== b[i].impliedArity || a[i].isFixed !== b[i].isFixed || a[i].priority !== b[i].priority || a[i].topLevel !== b[i].topLevel || forEach(a, (_, i2) => getInferredType(ctxA, a[i2]) !== getInferredType(ctxB, b[i2])))
+          return false;
+      }
+      return true;
+    }
     function inferFromSignatures(source, target, kind) {
+      var _a2, _b;
       const sourceSignatures = getSignaturesOfType(source, kind);
       const targetSignatures = getSignaturesOfType(target, kind);
       const sourceLen = sourceSignatures.length;
       const targetLen = targetSignatures.length;
-      const len = sourceLen < targetLen ? sourceLen : targetLen;
-      for (let i = 0; i < len; i++) {
-        inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
+      if (targetLen === 1 && sourceLen > 1) {
+        const group3 = forkInferenceContext();
+        for (let i = 0; i < sourceLen; i++) {
+          if (useOnlyCachedAlternativeRoutes && !((_b = (_a2 = context.freeTypeVariableSourceSignatures) == null ? void 0 : _a2.get(last(sourceStack))) == null ? void 0 : _b.get(sourceSignatures[i]))) {
+            continue;
+          }
+          spawnAlternativeInferenceContext(
+            group3,
+            () => inferFromSignature(sourceSignatures[i], targetSignatures[0])
+          );
+        }
+        joinInferenceContext(group3);
+      } else {
+        const len = sourceLen < targetLen ? sourceLen : targetLen;
+        for (let i = 0; i < len; i++) {
+          inferFromSignature(sourceSignatures[sourceLen - len + i], targetSignatures[targetLen - len + i]);
+        }
       }
     }
     function inferFromSignature(source, target) {
+      target = getErasedSignature(target);
+      if (source.typeParameters) {
+        let cache = (context.freeTypeVariableSourceSignatures || (context.freeTypeVariableSourceSignatures = /* @__PURE__ */ new Map())).get(last(sourceStack));
+        if (!cache) {
+          context.freeTypeVariableSourceSignatures.set(last(sourceStack), cache = /* @__PURE__ */ new Map());
+        }
+        const cached = cache.get(source);
+        if (cached) {
+          source = cached;
+        } else {
+          const originalSignature = source;
+          source = instantiateSignature(source, makeUnaryTypeMapper(unknownType, unknownType));
+          cache.set(originalSignature, source);
+          (context.freeTypeVariables || (context.freeTypeVariables = [])).push(...map(source.typeParameters, createInferenceInfo));
+        }
+      }
       const saveBivariant = bivariant;
       const kind = target.declaration ? target.declaration.kind : 0 /* Unknown */;
       bivariant = bivariant || kind === 171 /* MethodDeclaration */ || kind === 170 /* MethodSignature */ || kind === 173 /* Constructor */;
@@ -63296,8 +63410,7 @@ function createTypeChecker(host) {
     const unwidenedType = inference.priority & 416 /* PriorityImpliesCombination */ ? getUnionType(baseCandidates, 2 /* Subtype */) : getCommonSupertype(baseCandidates);
     return getWidenedType(unwidenedType);
   }
-  function getInferredType(context, index) {
-    const inference = context.inferences[index];
+  function getInferredType(context, inference) {
     if (!inference.inferredType) {
       let inferredType;
       const signature = context.signature;
@@ -63313,7 +63426,7 @@ function createTypeChecker(host) {
         } else {
           const defaultType = getDefaultFromTypeParameter(inference.typeParameter);
           if (defaultType) {
-            inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
+            inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, inference), context.nonFixingMapper));
           }
         }
       } else {
@@ -63333,12 +63446,24 @@ function createTypeChecker(host) {
   function getDefaultTypeArgumentType(isInJavaScriptFile) {
     return isInJavaScriptFile ? anyType : unknownType;
   }
-  function getInferredTypes(context) {
-    const result = [];
-    for (let i = 0; i < context.inferences.length; i++) {
-      result.push(getInferredType(context, i));
+  function getInferredTypes(context, accept) {
+    const alternatives = flattenInferenceContextAlternatives(context);
+    let finalAlternative;
+    for (let a = alternatives.length - 1; a >= 0; a--) {
+      const context2 = alternatives[a];
+      const freeTypeVariableMapper = makeFreeTypeVariableMapperForContext(context2);
+      const result = [];
+      for (const inference of context2.inferences) {
+        result.push(instantiateType(getInferredType(context2, inference), freeTypeVariableMapper));
+      }
+      if (alternatives.length === 1 || accept(result)) {
+        return result;
+      }
+      if (!finalAlternative) {
+        finalAlternative = result;
+      }
     }
-    return result;
+    return finalAlternative;
   }
   function getCannotFindNameDiagnosticForName(node) {
     switch (node.escapedText) {
@@ -66716,8 +66841,11 @@ function createTypeChecker(host) {
   function instantiateContextualType(contextualType, node, contextFlags) {
     if (contextualType && maybeTypeOfKind(contextualType, 465829888 /* Instantiable */)) {
       const inferenceContext = getInferenceContext(node);
-      if (inferenceContext && contextFlags & 1 /* Signature */ && some(inferenceContext.inferences, hasInferenceCandidatesOrDefault)) {
-        return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+      if (inferenceContext && contextFlags & 1 /* Signature */ && some(flatMap(flattenInferenceContextAlternatives(inferenceContext), (c) => c.inferences), hasInferenceCandidatesOrDefault)) {
+        return getUnionType(map(
+          flattenInferenceContextAlternatives(inferenceContext),
+          (c) => instantiateInstantiableTypes(contextualType, c.nonFixingMapper)
+        ));
       }
       if (inferenceContext == null ? void 0 : inferenceContext.returnMapper) {
         const type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
@@ -69076,23 +69204,23 @@ function createTypeChecker(host) {
   function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) {
     const context = createInferenceContext(signature.typeParameters, signature, 0 /* None */, compareTypes);
     const restType = getEffectiveRestType(contextualSignature);
-    const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
+    const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : getMapperFromContext(inferenceContext));
     const sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
     applyToParameterTypes(sourceSignature, signature, (source, target) => {
-      inferTypes(context.inferences, source, target);
+      inferTypes(context, source, target);
     });
     if (!inferenceContext) {
       applyToReturnTypes(contextualSignature, signature, (source, target) => {
-        inferTypes(context.inferences, source, target, 128 /* ReturnType */);
+        inferTypes(context, source, target, 128 /* ReturnType */);
       });
     }
-    return getSignatureInstantiation(signature, getInferredTypes(context), isInJSFile(contextualSignature.declaration));
+    return getSignatureInstantiation(signature, getInferredTypes(context, returnFalse), isInJSFile(contextualSignature.declaration));
   }
-  function inferJsxTypeArguments(node, signature, checkMode, context) {
+  function inferJsxTypeArguments(node, signature, checkMode, context, accept) {
     const paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
     const checkAttrType = checkExpressionWithContextualType(node.attributes, paramType, context, checkMode);
-    inferTypes(context.inferences, checkAttrType, paramType);
-    return getInferredTypes(context);
+    inferTypes(context, checkAttrType, paramType);
+    return getInferredTypes(context, accept);
   }
   function getThisArgumentType(thisArgumentNode) {
     if (!thisArgumentNode) {
@@ -69101,9 +69229,9 @@ function createTypeChecker(host) {
     const thisArgumentType = checkExpression(thisArgumentNode);
     return isOptionalChainRoot(thisArgumentNode.parent) ? getNonNullableType(thisArgumentType) : isOptionalChain(thisArgumentNode.parent) ? removeOptionalTypeMarker(thisArgumentType) : thisArgumentType;
   }
-  function inferTypeArguments(node, signature, args, checkMode, context) {
+  function inferTypeArguments(node, signature, args, checkMode, context, accept) {
     if (isJsxOpeningLikeElement(node)) {
-      return inferJsxTypeArguments(node, signature, checkMode, context);
+      return inferJsxTypeArguments(node, signature, checkMode, context, accept);
     }
     if (node.kind !== 167 /* Decorator */) {
       const skipBindingPatterns = every(signature.typeParameters, (p) => !!getDefaultFromTypeParameter(p));
@@ -69118,11 +69246,11 @@ function createTypeChecker(host) {
             const instantiatedType = instantiateType(contextualType, outerMapper);
             const contextualSignature = getSingleCallSignature(instantiatedType);
             const inferenceSourceType = contextualSignature && contextualSignature.typeParameters ? getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) : instantiatedType;
-            inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+            inferTypes(context, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
           }
           const returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
           const returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
-          inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
+          inferTypes(returnContext, returnSourceType, inferenceTargetType);
           context.returnMapper = some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : void 0;
         }
       }
@@ -69138,7 +69266,7 @@ function createTypeChecker(host) {
     const thisType = getThisTypeOfSignature(signature);
     if (thisType && couldContainTypeVariables(thisType)) {
       const thisArgumentNode = getThisArgumentOfCall(node);
-      inferTypes(context.inferences, getThisArgumentType(thisArgumentNode), thisType);
+      inferTypes(context, getThisArgumentType(thisArgumentNode), thisType);
     }
     for (let i = 0; i < argCount; i++) {
       const arg = args[i];
@@ -69146,15 +69274,15 @@ function createTypeChecker(host) {
         const paramType = getTypeAtPosition(signature, i);
         if (couldContainTypeVariables(paramType)) {
           const argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
-          inferTypes(context.inferences, argType, paramType);
+          inferTypes(context, argType, paramType);
         }
       }
     }
     if (restType && couldContainTypeVariables(restType)) {
       const spreadType = getSpreadArgumentType(args, argCount, args.length, restType, context, checkMode);
-      inferTypes(context.inferences, spreadType, restType);
+      inferTypes(context, spreadType, restType);
     }
-    return getInferredTypes(context);
+    return getInferredTypes(context, accept);
   }
   function getMutableArrayOrTupleType(type) {
     return type.flags & 1048576 /* Union */ ? mapType(type, getMutableArrayOrTupleType) : type.flags & 1 /* Any */ || isMutableArrayOrTuple(getBaseConstraintOfType(type) || type) ? type : isTupleType(type) ? createTupleType(
@@ -69921,6 +70049,26 @@ function createTypeChecker(host) {
         }
         let checkCandidate;
         let inferenceContext;
+        const acceptor = (types) => {
+          const checkCandidate2 = getSignatureInstantiation(candidate, types, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
+          if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate2, signatureHelpTrailingComma2)) {
+            return false;
+          }
+          if (getSignatureApplicabilityError(
+            node,
+            args,
+            checkCandidate2,
+            relation,
+            argCheckMode,
+            /*reportErrors*/
+            false,
+            /*containingMessageChain*/
+            void 0
+          )) {
+            return false;
+          }
+          return true;
+        };
         if (candidate.typeParameters) {
           let typeArgumentTypes;
           if (some(typeArguments)) {
@@ -69941,7 +70089,7 @@ function createTypeChecker(host) {
               /*flags*/
               isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
             );
-            typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
+            typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext, acceptor);
             argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
           }
           checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
@@ -69969,7 +70117,7 @@ function createTypeChecker(host) {
         if (argCheckMode) {
           argCheckMode = checkMode & 32 /* IsForStringLiteralArgumentCompletions */;
           if (inferenceContext) {
-            const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
+            const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext, acceptor);
             checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
             if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
               candidateForArgumentArityError = checkCandidate;
@@ -70079,7 +70227,7 @@ function createTypeChecker(host) {
       /*flags*/
       isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
     );
-    const typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext);
+    const typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext, returnFalse);
     return createSignatureInstantiation(candidate, typeArgumentTypes);
   }
   function getLongestCandidateIndex(candidates, argsCount) {
@@ -71347,7 +71495,7 @@ function createTypeChecker(host) {
       if (declaration.type) {
         const typeNode = getEffectiveTypeAnnotationNode(declaration);
         if (typeNode) {
-          inferTypes(inferenceContext.inferences, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i));
+          inferTypes(inferenceContext, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i));
         }
       }
     }
@@ -72059,7 +72207,7 @@ function createTypeChecker(host) {
                 instantiatedContextualSignature = instantiateSignature(contextualSignature, inferenceContext.nonFixingMapper);
               }
             }
-            instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ? instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature);
+            instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ? instantiateSignature(contextualSignature, getMapperFromContext(inferenceContext)) : contextualSignature);
             assignContextualParameterTypes(signature, instantiatedContextualSignature);
           } else {
             assignNonContextualParameterTypes(signature);
@@ -73440,7 +73588,7 @@ function createTypeChecker(host) {
     return isAssertionExpression(parent) && isConstTypeReference(parent.type) || isJSDocTypeAssertion(parent) && isConstTypeReference(getJSDocTypeAssertionType(parent)) || isValidConstAssertionArgument(node) && isConstTypeParameterContext(node) || (isParenthesizedExpression(parent) || isArrayLiteralExpression(parent) || isSpreadElement(parent)) && isConstContext(parent) || (isPropertyAssignment(parent) || isShorthandPropertyAssignment(parent) || isTemplateSpan(parent)) && isConstContext(parent.parent);
   }
   function isConstTypeParameterContext(node) {
-    const contextualType = getContextualType(node, 0 /* None */);
+    const contextualType = getContextualType(node, 1 /* Signature */);
     return !!contextualType && someType(contextualType, isConstTypeVariable);
   }
   function checkExpressionForMutableLocation(node, checkMode, forceTuple) {
@@ -73505,10 +73653,11 @@ function createTypeChecker(host) {
             if (returnSignature && !returnSignature.typeParameters && !every(context.inferences, hasInferenceCandidates)) {
               const uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters);
               const instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters);
-              const inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
+              const subcontext = cloneInferenceContext(context);
+              subcontext.inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
               applyToParameterTypes(instantiatedSignature, contextualSignature, (source, target) => {
                 inferTypes(
-                  inferences,
+                  subcontext,
                   source,
                   target,
                   /*priority*/
@@ -73517,12 +73666,12 @@ function createTypeChecker(host) {
                   true
                 );
               });
-              if (some(inferences, hasInferenceCandidates)) {
+              if (some(subcontext.inferences, hasInferenceCandidates)) {
                 applyToReturnTypes(instantiatedSignature, contextualSignature, (source, target) => {
-                  inferTypes(inferences, source, target);
+                  inferTypes(subcontext, source, target);
                 });
-                if (!hasOverlappingInferences(context.inferences, inferences)) {
-                  mergeInferences(context.inferences, inferences);
+                if (!hasOverlappingInferences(context.inferences, subcontext.inferences)) {
+                  mergeInferenceContexts(context, subcontext);
                   context.inferredTypeParameters = concatenate(context.inferredTypeParameters, uniqueTypeParameters);
                   return getOrCreateTypeFromSignature(instantiatedSignature);
                 }
@@ -73555,13 +73704,22 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function mergeInferences(target, source) {
+  function mergeInferences(target, source, clone2 = false) {
     for (let i = 0; i < target.length; i++) {
       if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) {
-        target[i] = source[i];
+        target[i] = clone2 ? {
+          ...source[i],
+          candidates: source[i].candidates && [...source[i].candidates],
+          contraCandidates: source[i].contraCandidates && [...source[i].contraCandidates]
+        } : source[i];
       }
     }
   }
+  function mergeInferenceContexts(target, source, cloneInferences = false) {
+    mergeInferences(target.inferences, source.inferences, cloneInferences);
+    target.mapper = makeFixingMapperForContext(target);
+    target.nonFixingMapper = makeNonFixingMapperForContext(target);
+  }
   function getUniqueTypeParameters(context, typeParameters) {
     const result = [];
     let oldTypeParameters;