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

package/lib/typescript.js

@@ -9111,8 +9111,7 @@ ${lanes.join("\n")}
         _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.")
       };
     }
   });
@@ -56837,27 +56836,15 @@ ${lanes.join("\n")}
         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;
@@ -59382,9 +59369,9 @@ ${lanes.join("\n")}
             }
           }
           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;
@@ -60071,8 +60058,11 @@ ${lanes.join("\n")}
         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) {
@@ -62886,9 +62876,10 @@ ${lanes.join("\n")}
                 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)) {
@@ -64726,7 +64717,12 @@ ${lanes.join("\n")}
       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 = {
@@ -64743,20 +64739,29 @@ ${lanes.join("\n")}
       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) {
@@ -64773,7 +64778,7 @@ ${lanes.join("\n")}
         for (const { node, type } of context.intraExpressionInferenceSites) {
           const contextualType = node.kind === 171 /* MethodDeclaration */ ? getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) : getContextualType2(node, 2 /* NoConstraints */);
           if (contextualType) {
-            inferTypes(context.inferences, type, contextualType);
+            inferTypes(context, type, contextualType);
           }
         }
         context.intraExpressionInferenceSites = void 0;
@@ -64808,7 +64813,8 @@ ${lanes.join("\n")}
       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);
@@ -64908,8 +64914,15 @@ ${lanes.join("\n")}
       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);
@@ -65086,7 +65099,15 @@ ${lanes.join("\n")}
         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 */;
@@ -65095,7 +65116,21 @@ ${lanes.join("\n")}
       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;
@@ -65156,6 +65191,9 @@ ${lanes.join("\n")}
             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;
@@ -65168,16 +65206,16 @@ ${lanes.join("\n")}
                 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);
@@ -65345,7 +65383,12 @@ ${lanes.join("\n")}
       }
       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;
             }
@@ -65626,17 +65669,88 @@ ${lanes.join("\n")}
           }
         }
       }
+      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 */;
@@ -65711,8 +65825,7 @@ ${lanes.join("\n")}
       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;
@@ -65728,7 +65841,7 @@ ${lanes.join("\n")}
           } 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 {
@@ -65748,12 +65861,24 @@ ${lanes.join("\n")}
     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) {
@@ -69131,8 +69256,11 @@ ${lanes.join("\n")}
     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);
@@ -71491,23 +71619,23 @@ ${lanes.join("\n")}
     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) {
@@ -71516,9 +71644,9 @@ ${lanes.join("\n")}
       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));
@@ -71533,11 +71661,11 @@ ${lanes.join("\n")}
               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;
           }
         }
@@ -71553,7 +71681,7 @@ ${lanes.join("\n")}
       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];
@@ -71561,15 +71689,15 @@ ${lanes.join("\n")}
           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(
@@ -72336,6 +72464,26 @@ ${lanes.join("\n")}
           }
           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)) {
@@ -72356,7 +72504,7 @@ ${lanes.join("\n")}
                 /*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);
@@ -72384,7 +72532,7 @@ ${lanes.join("\n")}
           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;
@@ -72494,7 +72642,7 @@ ${lanes.join("\n")}
         /*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) {
@@ -73762,7 +73910,7 @@ ${lanes.join("\n")}
         if (declaration.type) {
           const typeNode = getEffectiveTypeAnnotationNode(declaration);
           if (typeNode) {
-            inferTypes(inferenceContext.inferences, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i));
+            inferTypes(inferenceContext, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i));
           }
         }
       }
@@ -74474,7 +74622,7 @@ ${lanes.join("\n")}
                   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);
@@ -75855,7 +76003,7 @@ ${lanes.join("\n")}
       return isAssertionExpression(parent2) && isConstTypeReference(parent2.type) || isJSDocTypeAssertion(parent2) && isConstTypeReference(getJSDocTypeAssertionType(parent2)) || isValidConstAssertionArgument(node) && isConstTypeParameterContext(node) || (isParenthesizedExpression(parent2) || isArrayLiteralExpression(parent2) || isSpreadElement(parent2)) && isConstContext(parent2) || (isPropertyAssignment(parent2) || isShorthandPropertyAssignment(parent2) || isTemplateSpan(parent2)) && isConstContext(parent2.parent);
     }
     function isConstTypeParameterContext(node) {
-      const contextualType = getContextualType2(node, 0 /* None */);
+      const contextualType = getContextualType2(node, 1 /* Signature */);
       return !!contextualType && someType(contextualType, isConstTypeVariable);
     }
     function checkExpressionForMutableLocation(node, checkMode, forceTuple) {
@@ -75920,10 +76068,11 @@ ${lanes.join("\n")}
               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*/
@@ -75932,12 +76081,12 @@ ${lanes.join("\n")}
                     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);
                   }
@@ -75970,13 +76119,22 @@ ${lanes.join("\n")}
       }
       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;
@@ -147958,7 +148116,6 @@ ${lanes.join("\n")}
     return { name: completionNameForLiteral(sourceFile, preferences, literal), kind: "string" /* string */, kindModifiers: "" /* none */, sortText: SortText.LocationPriority };
   }
   function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, position, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importStatementCompletion, useSemicolons, options, preferences, completionKind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag, includeSymbol) {
-    var _a2;
     let insertText;
     let replacementSpan = getReplacementSpanForContextToken(replacementToken);
     let data;
@@ -148016,10 +148173,6 @@ ${lanes.join("\n")}
     if ((origin == null ? void 0 : origin.kind) === 64 /* TypeOnlyAlias */) {
       hasAction = true;
     }
-    if (contextToken && isPropertyAssignment(contextToken.parent) && ((_a2 = findNextToken(contextToken, contextToken == null ? void 0 : contextToken.parent, sourceFile)) == null ? void 0 : _a2.kind) !== 27 /* CommaToken */ && completionKind === 0 /* ObjectPropertyDeclaration */) {
-      source = "ObjectLiteralExpression/" /* ObjectLiteralExpression */;
-      hasAction = true;
-    }
     if (preferences.includeCompletionsWithClassMemberSnippets && preferences.includeCompletionsWithInsertText && completionKind === 3 /* MemberLike */ && isClassLikeMemberCompletion(symbol, location, sourceFile)) {
       let importAdder;
       ({ insertText, isSnippet, importAdder, replacementSpan } = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, position, contextToken, formatContext));
@@ -148708,7 +148861,7 @@ ${lanes.join("\n")}
     return firstDefined(symbols, (symbol, index) => {
       const origin = symbolToOriginInfoMap[index];
       const info = getCompletionEntryDisplayNameForSymbol(symbol, getEmitScriptTarget(compilerOptions), origin, completionKind, completionData.isJsxIdentifierExpected);
-      return info && info.name === entryId.name && (entryId.source === "ClassMemberSnippet/" /* ClassMemberSnippet */ && symbol.flags & 106500 /* ClassMember */ || entryId.source === "ObjectLiteralMethodSnippet/" /* ObjectLiteralMethodSnippet */ && symbol.flags & (4 /* Property */ | 8192 /* Method */) || getSourceFromOrigin(origin) === entryId.source || entryId.source === "ObjectLiteralExpression/" /* ObjectLiteralExpression */) ? { type: "symbol", symbol, location, origin, contextToken, previousToken, isJsxInitializer, isTypeOnlyLocation } : void 0;
+      return info && info.name === entryId.name && (entryId.source === "ClassMemberSnippet/" /* ClassMemberSnippet */ && symbol.flags & 106500 /* ClassMember */ || entryId.source === "ObjectLiteralMethodSnippet/" /* ObjectLiteralMethodSnippet */ && symbol.flags & (4 /* Property */ | 8192 /* Method */) || getSourceFromOrigin(origin) === entryId.source) ? { type: "symbol", symbol, location, origin, contextToken, previousToken, isJsxInitializer, isTypeOnlyLocation } : void 0;
     }) || { type: "none" };
   }
   function getCompletionEntryDetails(program, log, sourceFile, position, entryId, host, formatContext, preferences, cancellationToken) {
@@ -148846,21 +148999,6 @@ ${lanes.join("\n")}
       Debug.assertIsDefined(codeAction2, "Expected to have a code action for promoting type-only alias");
       return { codeActions: [codeAction2], sourceDisplay: void 0 };
     }
-    if (source === "ObjectLiteralExpression/" /* ObjectLiteralExpression */ && contextToken) {
-      const changes = ts_textChanges_exports.ChangeTracker.with(
-        { host, formatContext, preferences },
-        (tracker) => tracker.insertText(sourceFile, contextToken.end, ",")
-      );
-      if (changes) {
-        return {
-          sourceDisplay: void 0,
-          codeActions: [{
-            changes,
-            description: diagnosticToString([Diagnostics.Add_missing_comma_for_an_object_member_completion_0, name])
-          }]
-        };
-      }
-    }
     if (!origin || !(originIsExport(origin) || originIsResolvedExport(origin))) {
       return { codeActions: void 0, sourceDisplay: void 0 };
     }
@@ -150259,10 +150397,6 @@ ${lanes.join("\n")}
           return isMethodDeclaration(parent2) ? tryCast(parent2.parent, isObjectLiteralExpression) : void 0;
         case 79 /* Identifier */:
           return contextToken.text === "async" && isShorthandPropertyAssignment(contextToken.parent) ? contextToken.parent.parent : void 0;
-        default:
-          if (parent2.parent && isObjectLiteralExpression(parent2.parent) && contextToken.kind !== 58 /* ColonToken */) {
-            return parent2.parent;
-          }
       }
     }
     return void 0;
@@ -150803,7 +150937,6 @@ ${lanes.join("\n")}
         CompletionSource2["TypeOnlyAlias"] = "TypeOnlyAlias/";
         CompletionSource2["ObjectLiteralMethodSnippet"] = "ObjectLiteralMethodSnippet/";
         CompletionSource2["SwitchCases"] = "SwitchCases/";
-        CompletionSource2["ObjectLiteralExpression"] = "ObjectLiteralExpression/";
         return CompletionSource2;
       })(CompletionSource || {});
       SymbolOriginInfoKind = /* @__PURE__ */ ((SymbolOriginInfoKind2) => {
@@ -163797,10 +163930,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           const suffix = this.nextCommaToken(sourceFile, oldNode) ? "" : "," + this.newLineCharacter;
           this.replaceNode(sourceFile, oldNode, newNode, { suffix });
         }
-        replacePropertyAssignmentOnSameLine(sourceFile, oldNode, newNode) {
-          const suffix = this.nextCommaToken(sourceFile, oldNode) ? "" : ",";
-          this.replaceNode(sourceFile, oldNode, newNode, { suffix });
-        }
         insertNodeAt(sourceFile, pos, newNode, options = {}) {
           this.replaceRange(sourceFile, createRange(pos), newNode, options);
         }