typescript 4.7.0-dev.20220327 → 4.7.0-dev.20220330

package/lib/tsserverlibrary.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220327";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220330";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -13606,7 +13606,9 @@ var ts;
             || kind === 174 /* CallSignature */
             || kind === 166 /* PropertySignature */
             || kind === 168 /* MethodSignature */
-            || kind === 176 /* IndexSignature */;
+            || kind === 176 /* IndexSignature */
+            || kind === 172 /* GetAccessor */
+            || kind === 173 /* SetAccessor */;
     }
     ts.isTypeElement = isTypeElement;
     function isClassOrTypeElement(node) {
@@ -47588,6 +47590,7 @@ var ts;
         TypeSystemPropertyName[TypeSystemPropertyName["EnumTagType"] = 5] = "EnumTagType";
         TypeSystemPropertyName[TypeSystemPropertyName["ResolvedTypeArguments"] = 6] = "ResolvedTypeArguments";
         TypeSystemPropertyName[TypeSystemPropertyName["ResolvedBaseTypes"] = 7] = "ResolvedBaseTypes";
+        TypeSystemPropertyName[TypeSystemPropertyName["WriteType"] = 8] = "WriteType";
     })(TypeSystemPropertyName || (TypeSystemPropertyName = {}));
     var CheckMode;
     (function (CheckMode) {
@@ -47597,7 +47600,8 @@ var ts;
         CheckMode[CheckMode["SkipContextSensitive"] = 4] = "SkipContextSensitive";
         CheckMode[CheckMode["SkipGenericFunctions"] = 8] = "SkipGenericFunctions";
         CheckMode[CheckMode["IsForSignatureHelp"] = 16] = "IsForSignatureHelp";
-        CheckMode[CheckMode["RestBindingElement"] = 32] = "RestBindingElement";
+        CheckMode[CheckMode["IsForStringLiteralArgumentCompletions"] = 32] = "IsForStringLiteralArgumentCompletions";
+        CheckMode[CheckMode["RestBindingElement"] = 64] = "RestBindingElement";
         //   e.g. in `const { a, ...rest } = foo`, when checking the type of `foo` to determine the type of `rest`,
         //   we need to preserve generic types instead of substituting them for constraints
     })(CheckMode || (CheckMode = {}));
@@ -47935,26 +47939,10 @@ var ts;
                 if (!node) {
                     return undefined;
                 }
-                var containingCall = ts.findAncestor(node, ts.isCallLikeExpression);
-                var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature;
-                if (contextFlags & 4 /* Completions */ && containingCall) {
-                    var toMarkSkip = node;
-                    do {
-                        getNodeLinks(toMarkSkip).skipDirectInference = true;
-                        toMarkSkip = toMarkSkip.parent;
-                    } while (toMarkSkip && toMarkSkip !== containingCall);
-                    getNodeLinks(containingCall).resolvedSignature = undefined;
-                }
-                var result = getContextualType(node, contextFlags);
-                if (contextFlags & 4 /* Completions */ && containingCall) {
-                    var toMarkSkip = node;
-                    do {
-                        getNodeLinks(toMarkSkip).skipDirectInference = undefined;
-                        toMarkSkip = toMarkSkip.parent;
-                    } while (toMarkSkip && toMarkSkip !== containingCall);
-                    getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
+                if (contextFlags & 4 /* Completions */) {
+                    return runWithInferenceBlockedFromSourceNode(node, function () { return getContextualType(node, contextFlags); });
                 }
-                return result;
+                return getContextualType(node, contextFlags);
             },
             getContextualTypeForObjectLiteralElement: function (nodeIn) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isObjectLiteralElementLike);
@@ -47974,6 +47962,9 @@ var ts;
             getResolvedSignature: function (node, candidatesOutArray, argumentCount) {
                 return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0 /* Normal */);
             },
+            getResolvedSignatureForStringLiteralCompletions: function (call, editingArgument, candidatesOutArray) {
+                return getResolvedSignatureWorker(call, candidatesOutArray, /*argumentCount*/ undefined, 32 /* IsForStringLiteralArgumentCompletions */, editingArgument);
+            },
             getResolvedSignatureForSignatureHelp: function (node, candidatesOutArray, argumentCount) {
                 return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16 /* IsForSignatureHelp */);
             },
@@ -48126,10 +48117,34 @@ var ts;
             getTypeOnlyAliasDeclaration: getTypeOnlyAliasDeclaration,
             getMemberOverrideModifierStatus: getMemberOverrideModifierStatus,
         };
-        function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
+        function runWithInferenceBlockedFromSourceNode(node, fn) {
+            var containingCall = ts.findAncestor(node, ts.isCallLikeExpression);
+            var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature;
+            if (containingCall) {
+                var toMarkSkip = node;
+                do {
+                    getNodeLinks(toMarkSkip).skipDirectInference = true;
+                    toMarkSkip = toMarkSkip.parent;
+                } while (toMarkSkip && toMarkSkip !== containingCall);
+                getNodeLinks(containingCall).resolvedSignature = undefined;
+            }
+            var result = fn();
+            if (containingCall) {
+                var toMarkSkip = node;
+                do {
+                    getNodeLinks(toMarkSkip).skipDirectInference = undefined;
+                    toMarkSkip = toMarkSkip.parent;
+                } while (toMarkSkip && toMarkSkip !== containingCall);
+                getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
+            }
+            return result;
+        }
+        function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode, editingArgument) {
             var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
             apparentArgumentCount = argumentCount;
-            var res = node ? getResolvedSignature(node, candidatesOutArray, checkMode) : undefined;
+            var res = !node ? undefined :
+                editingArgument ? runWithInferenceBlockedFromSourceNode(editingArgument, function () { return getResolvedSignature(node, candidatesOutArray, checkMode); }) :
+                    getResolvedSignature(node, candidatesOutArray, checkMode);
             apparentArgumentCount = undefined;
             return res;
         }
@@ -49102,6 +49117,10 @@ var ts;
                 }
             }
         }
+        function isConstAssertion(location) {
+            return (ts.isAssertionExpression(location) && ts.isConstTypeReference(location.type))
+                || (ts.isJSDocTypeTag(location) && ts.isConstTypeReference(location.typeExpression));
+        }
         /**
          * Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and
          * the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with
@@ -49127,6 +49146,11 @@ var ts;
             var grandparent;
             var isInExternalModule = false;
             loop: while (location) {
+                if (name === "const" && isConstAssertion(location)) {
+                    // `const` in an `as const` has no symbol, but issues no error because there is no *actual* lookup of the type
+                    // (it refers to the constant type of the expression instead)
+                    return undefined;
+                }
                 // Locals of a source file are not in scope (because they get merged into the global symbol table)
                 if (location.locals && !isGlobalSourceFile(location)) {
                     if (result = lookup(location.locals, name, meaning)) {
@@ -55075,6 +55099,8 @@ var ts;
                     return !!target.resolvedTypeArguments;
                 case 7 /* ResolvedBaseTypes */:
                     return !!target.baseTypesResolved;
+                case 8 /* WriteType */:
+                    return !!getSymbolLinks(target).writeType;
             }
             return ts.Debug.assertNever(propertyName);
         }
@@ -55252,7 +55278,7 @@ var ts;
         }
         /** Return the inferred type for a binding element */
         function getTypeForBindingElement(declaration) {
-            var checkMode = declaration.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */;
+            var checkMode = declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
             var parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode);
             return parentType && getBindingElementTypeFromParentType(declaration, parentType);
         }
@@ -55992,6 +56018,11 @@ var ts;
                 }
                 return getWidenedType(getWidenedLiteralType(checkExpression(declaration.statements[0].expression)));
             }
+            if (ts.isAccessor(declaration)) {
+                // Binding of certain patterns in JS code will occasionally mark symbols as both properties
+                // and accessors. Here we dispatch to accessor resolution if needed.
+                return getTypeOfAccessors(symbol);
+            }
             // Handle variable, parameter or property
             if (!pushTypeResolution(symbol, 0 /* Type */)) {
                 // Symbol is property of some kind that is merged with something - should use `getTypeOfFuncClassEnumModule` and not `getTypeOfVariableOrParameterOrProperty`
@@ -56055,9 +56086,6 @@ var ts;
             else if (ts.isEnumMember(declaration)) {
                 type = getTypeOfEnumMember(symbol);
             }
-            else if (ts.isAccessor(declaration)) {
-                type = resolveTypeOfAccessors(symbol) || ts.Debug.fail("Non-write accessor resolution must always produce a type");
-            }
             else {
                 return ts.Debug.fail("Unhandled declaration kind! " + ts.Debug.formatSyntaxKind(declaration.kind) + " for " + ts.Debug.formatSymbol(symbol));
             }
@@ -56096,87 +56124,61 @@ var ts;
         }
         function getTypeOfAccessors(symbol) {
             var links = getSymbolLinks(symbol);
-            return links.type || (links.type = getTypeOfAccessorsWorker(symbol) || ts.Debug.fail("Read type of accessor must always produce a type"));
-        }
-        function getTypeOfSetAccessor(symbol) {
-            var links = getSymbolLinks(symbol);
-            return links.writeType || (links.writeType = getTypeOfAccessorsWorker(symbol, /*writing*/ true));
-        }
-        function getTypeOfAccessorsWorker(symbol, writing) {
-            if (writing === void 0) { writing = false; }
-            if (!pushTypeResolution(symbol, 0 /* Type */)) {
-                return errorType;
-            }
-            var type = resolveTypeOfAccessors(symbol, writing);
-            if (!popTypeResolution()) {
+            if (!links.type) {
+                if (!pushTypeResolution(symbol, 0 /* Type */)) {
+                    return errorType;
+                }
                 var getter = ts.getDeclarationOfKind(symbol, 172 /* GetAccessor */);
-                if (getter) {
-                    if (ts.getEffectiveTypeAnnotationNode(getter)) {
-                        error(getter.name, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
+                var setter = ts.getDeclarationOfKind(symbol, 173 /* SetAccessor */);
+                // We try to resolve a getter type annotation, a setter type annotation, or a getter function
+                // body return type inference, in that order.
+                var type = getter && ts.isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) ||
+                    getAnnotatedAccessorType(getter) ||
+                    getAnnotatedAccessorType(setter) ||
+                    getter && getter.body && getReturnTypeFromBody(getter);
+                if (!type) {
+                    if (setter && !isPrivateWithinAmbient(setter)) {
+                        errorOrSuggestion(noImplicitAny, setter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol));
+                    }
+                    else if (getter && !isPrivateWithinAmbient(getter)) {
+                        errorOrSuggestion(noImplicitAny, getter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol));
+                    }
+                    type = anyType;
+                }
+                if (!popTypeResolution()) {
+                    if (getAnnotatedAccessorTypeNode(getter)) {
+                        error(getter, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
                     }
-                    else if (noImplicitAny) {
+                    else if (getAnnotatedAccessorTypeNode(setter)) {
+                        error(setter, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
+                    }
+                    else if (getter && noImplicitAny) {
                         error(getter, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
                     }
+                    type = anyType;
                 }
-                type = anyType;
+                links.type = type;
             }
-            return type;
+            return links.type;
         }
-        function resolveTypeOfAccessors(symbol, writing) {
-            if (writing === void 0) { writing = false; }
-            var getter = ts.getDeclarationOfKind(symbol, 172 /* GetAccessor */);
-            var setter = ts.getDeclarationOfKind(symbol, 173 /* SetAccessor */);
-            // For write operations, prioritize type annotations on the setter
-            if (writing) {
-                var setterType_1 = getAnnotatedAccessorType(setter);
-                if (setterType_1) {
-                    return instantiateTypeIfNeeded(setterType_1, symbol);
-                }
-            }
-            // Else defer to the getter type
-            if (getter && ts.isInJSFile(getter)) {
-                var jsDocType = getTypeForDeclarationFromJSDocComment(getter);
-                if (jsDocType) {
-                    return instantiateTypeIfNeeded(jsDocType, symbol);
-                }
-            }
-            // Try to see if the user specified a return type on the get-accessor.
-            var getterType = getAnnotatedAccessorType(getter);
-            if (getterType) {
-                return instantiateTypeIfNeeded(getterType, symbol);
-            }
-            // If the user didn't specify a return type, try to use the set-accessor's parameter type.
-            var setterType = getAnnotatedAccessorType(setter);
-            if (setterType) {
-                return setterType;
-            }
-            // If there are no specified types, try to infer it from the body of the get accessor if it exists.
-            if (getter && getter.body) {
-                var returnTypeFromBody = getReturnTypeFromBody(getter);
-                return instantiateTypeIfNeeded(returnTypeFromBody, symbol);
-            }
-            // Otherwise, fall back to 'any'.
-            if (setter) {
-                if (!isPrivateWithinAmbient(setter)) {
-                    errorOrSuggestion(noImplicitAny, setter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol));
-                }
-                return anyType;
-            }
-            else if (getter) {
-                ts.Debug.assert(!!getter, "there must exist a getter as we are current checking either setter or getter in this function");
-                if (!isPrivateWithinAmbient(getter)) {
-                    errorOrSuggestion(noImplicitAny, getter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol));
+        function getWriteTypeOfAccessors(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.writeType) {
+                if (!pushTypeResolution(symbol, 8 /* WriteType */)) {
+                    return errorType;
                 }
-                return anyType;
-            }
-            return undefined;
-            function instantiateTypeIfNeeded(type, symbol) {
-                if (ts.getCheckFlags(symbol) & 1 /* Instantiated */) {
-                    var links = getSymbolLinks(symbol);
-                    return instantiateType(type, links.mapper);
+                var setter = ts.getDeclarationOfKind(symbol, 173 /* SetAccessor */);
+                var writeType = getAnnotatedAccessorType(setter);
+                if (!popTypeResolution()) {
+                    if (getAnnotatedAccessorTypeNode(setter)) {
+                        error(setter, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
+                    }
+                    writeType = anyType;
                 }
-                return type;
+                // Absent an explicit setter type annotation we use the read type of the accessor.
+                links.writeType = writeType || getTypeOfAccessors(symbol);
             }
+            return links.writeType;
         }
         function getBaseTypeVariableOfClass(symbol) {
             var baseConstructorType = getBaseConstructorTypeOfClass(getDeclaredTypeOfClassOrInterface(symbol));
@@ -56258,17 +56260,11 @@ var ts;
         }
         function getTypeOfInstantiatedSymbol(symbol) {
             var links = getSymbolLinks(symbol);
-            if (!links.type) {
-                if (!pushTypeResolution(symbol, 0 /* Type */)) {
-                    return links.type = errorType;
-                }
-                var type = instantiateType(getTypeOfSymbol(links.target), links.mapper);
-                if (!popTypeResolution()) {
-                    type = reportCircularityError(symbol);
-                }
-                links.type = type;
-            }
-            return links.type;
+            return links.type || (links.type = instantiateType(getTypeOfSymbol(links.target), links.mapper));
+        }
+        function getWriteTypeOfInstantiatedSymbol(symbol) {
+            var links = getSymbolLinks(symbol);
+            return links.writeType || (links.writeType = instantiateType(getWriteTypeOfSymbol(links.target), links.mapper));
         }
         function reportCircularityError(symbol) {
             var declaration = symbol.valueDeclaration;
@@ -56305,35 +56301,23 @@ var ts;
             return links.writeType;
         }
         /**
-         * Distinct write types come only from set accessors, but union and intersection
-         * properties deriving from set accessors will either pre-compute or defer the
-         * union or intersection of the writeTypes of their constituents. To account for
-         * this, we will assume that any deferred type or transient symbol may have a
-         * `writeType` (or a deferred write type ready to be computed) that should be
-         * used before looking for set accessor declarations.
+         * Distinct write types come only from set accessors, but synthetic union and intersection
+         * properties deriving from set accessors will either pre-compute or defer the union or
+         * intersection of the writeTypes of their constituents.
          */
         function getWriteTypeOfSymbol(symbol) {
             var checkFlags = ts.getCheckFlags(symbol);
-            if (checkFlags & 65536 /* DeferredType */) {
-                var writeType = getWriteTypeOfSymbolWithDeferredType(symbol);
-                if (writeType) {
-                    return writeType;
-                }
+            if (symbol.flags & 4 /* Property */) {
+                return checkFlags & 2 /* SyntheticProperty */ ?
+                    checkFlags & 65536 /* DeferredType */ ?
+                        getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) :
+                        symbol.writeType || symbol.type :
+                    getTypeOfSymbol(symbol);
             }
-            if (symbol.flags & 33554432 /* Transient */) {
-                var writeType = symbol.writeType;
-                if (writeType) {
-                    return writeType;
-                }
-            }
-            return getSetAccessorTypeOfSymbol(symbol);
-        }
-        function getSetAccessorTypeOfSymbol(symbol) {
             if (symbol.flags & 98304 /* Accessor */) {
-                var type = getTypeOfSetAccessor(symbol);
-                if (type) {
-                    return type;
-                }
+                return checkFlags & 1 /* Instantiated */ ?
+                    getWriteTypeOfInstantiatedSymbol(symbol) :
+                    getWriteTypeOfAccessors(symbol);
             }
             return getTypeOfSymbol(symbol);
         }
@@ -68422,7 +68406,7 @@ var ts;
                 for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) {
                     var targetProp = properties_3[_i];
                     var sourceProp = getPropertyOfType(source, targetProp.escapedName);
-                    if (sourceProp) {
+                    if (sourceProp && !ts.some(sourceProp.declarations, hasSkipDirectInferenceFlag)) {
                         inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
                     }
                 }
@@ -70804,7 +70788,7 @@ var ts;
                 }
             }
             if (ts.isDeclarationName(location) && ts.isSetAccessor(location.parent) && getAnnotatedAccessorTypeNode(location.parent)) {
-                return resolveTypeOfAccessors(location.parent.symbol, /*writing*/ true);
+                return getWriteTypeOfAccessors(location.parent.symbol);
             }
             // The location isn't a reference to the given symbol, meaning we're being asked
             // a hypothetical question of what type the symbol would have if there was a reference
@@ -70896,7 +70880,7 @@ var ts;
             // as we want the type of a rest element to be generic when possible.
             var contextualType = (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
                 !((ts.isJsxOpeningElement(node.parent) || ts.isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) &&
-                (checkMode && checkMode & 32 /* RestBindingElement */ ?
+                (checkMode && checkMode & 64 /* RestBindingElement */ ?
                     getContextualType(node, 8 /* SkipBindingPatterns */)
                     : getContextualType(node));
             return contextualType && !isGenericType(contextualType);
@@ -71835,7 +71819,7 @@ var ts;
             var parent = declaration.parent.parent;
             var name = declaration.propertyName || declaration.name;
             var parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
-                parent.kind !== 203 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */);
+                parent.kind !== 203 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */);
             if (!parentType || ts.isBindingPattern(name) || ts.isComputedNonLiteralName(name))
                 return undefined;
             if (parent.name.kind === 202 /* ArrayBindingPattern */) {
@@ -74889,7 +74873,7 @@ var ts;
             }
             for (var i = 0; i < argCount; i++) {
                 var arg = args[i];
-                if (arg.kind !== 227 /* OmittedExpression */) {
+                if (arg.kind !== 227 /* OmittedExpression */ && !(checkMode & 32 /* IsForStringLiteralArgumentCompletions */ && hasSkipDirectInferenceFlag(arg))) {
                     var paramType = getTypeAtPosition(signature, i);
                     var argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
                     inferTypes(context.inferences, argType, paramType);
@@ -75574,7 +75558,7 @@ var ts;
                     }
                 }
             }
-            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray);
+            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
             function addImplementationSuccessElaboration(failed, diagnostic) {
                 var _a, _b;
                 var oldCandidatesForArgumentError = candidatesForArgumentError;
@@ -75675,14 +75659,14 @@ var ts;
             }
         }
         // No signature was applicable. We have already reported the errors for the invalid signature.
-        function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray) {
+        function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray, checkMode) {
             ts.Debug.assert(candidates.length > 0); // Else should not have called this.
             checkNodeDeferred(node);
             // Normally we will combine overloads. Skip this if they have type parameters since that's hard to combine.
             // Don't do this if there is a `candidatesOutArray`,
             // because then we want the chosen best candidate to be one of the overloads, not a combination.
             return hasCandidatesOutArray || candidates.length === 1 || candidates.some(function (c) { return !!c.typeParameters; })
-                ? pickLongestCandidateSignature(node, candidates, args)
+                ? pickLongestCandidateSignature(node, candidates, args, checkMode)
                 : createUnionOfSignaturesForOverloadFailure(candidates);
         }
         function createUnionOfSignaturesForOverloadFailure(candidates) {
@@ -75730,7 +75714,7 @@ var ts;
             // This function is currently only used for erroneous overloads, so it's good enough to just use the first source.
             return createSymbolWithType(ts.first(sources), type);
         }
-        function pickLongestCandidateSignature(node, candidates, args) {
+        function pickLongestCandidateSignature(node, candidates, args, checkMode) {
             // Pick the longest signature. This way we can get a contextual type for cases like:
             //     declare function f(a: { xa: number; xb: number; }, b: number);
             //     f({ |
@@ -75746,7 +75730,7 @@ var ts;
             var typeArgumentNodes = callLikeExpressionMayHaveTypeArguments(node) ? node.typeArguments : undefined;
             var instantiated = typeArgumentNodes
                 ? createSignatureInstantiation(candidate, getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, ts.isInJSFile(node)))
-                : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args);
+                : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode);
             candidates[bestIndex] = instantiated;
             return instantiated;
         }
@@ -75760,9 +75744,9 @@ var ts;
             }
             return typeArguments;
         }
-        function inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args) {
+        function inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode) {
             var inferenceContext = createInferenceContext(typeParameters, candidate, /*flags*/ ts.isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */);
-            var typeArgumentTypes = inferTypeArguments(node, candidate, args, 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext);
+            var typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext);
             return createSignatureInstantiation(candidate, typeArgumentTypes);
         }
         function getLongestCandidateIndex(candidates, argsCount) {
@@ -81828,7 +81812,7 @@ var ts;
                 }
                 // check private/protected variable access
                 var parent = node.parent.parent;
-                var parentCheckMode = node.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */;
+                var parentCheckMode = node.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
                 var parentType = getTypeForBindingElementParent(parent, parentCheckMode);
                 var name = node.propertyName || node.name;
                 if (parentType && !ts.isBindingPattern(name)) {
@@ -82007,6 +81991,8 @@ var ts;
                     (condExpr.operatorToken.kind === 56 /* BarBarToken */ || condExpr.operatorToken.kind === 55 /* AmpersandAmpersandToken */)
                     ? condExpr.right
                     : condExpr;
+                if (ts.isModuleExportsAccessExpression(location))
+                    return;
                 var type = checkTruthinessExpression(location);
                 var isPropertyExpressionCast = ts.isPropertyAccessExpression(location) && isTypeAssertion(location.expression);
                 if (getFalsyFlags(type) || isPropertyExpressionCast)
@@ -116924,6 +116910,13 @@ var ts;
                                 return "skip";
                             }
                             break;
+                        case 270 /* ImportSpecifier */:
+                        case 275 /* ExportSpecifier */:
+                            if (node.isTypeOnly) {
+                                diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, ts.isImportSpecifier(node) ? "import...type" : "export...type"));
+                                return "skip";
+                            }
+                            break;
                         case 265 /* ImportEqualsDeclaration */:
                             diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.import_can_only_be_used_in_TypeScript_files));
                             return "skip";
@@ -126684,12 +126677,8 @@ var ts;
         }
     }
     ts.findNextToken = findNextToken;
-    /**
-     * Finds the rightmost token satisfying `token.end <= position`,
-     * excluding `JsxText` tokens containing only whitespace.
-     */
     function findPrecedingToken(position, sourceFile, startNode, excludeJsdoc) {
-        var result = find(startNode || sourceFile);
+        var result = find((startNode || sourceFile));
         ts.Debug.assert(!(result && isWhiteSpaceOnlyJsxText(result)));
         return result;
         function find(n) {
@@ -127789,6 +127778,14 @@ var ts;
         });
     }
     ts.signatureToDisplayParts = signatureToDisplayParts;
+    function nodeToDisplayParts(node, enclosingDeclaration) {
+        var file = enclosingDeclaration.getSourceFile();
+        return mapToDisplayParts(function (writer) {
+            var printer = ts.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
+            printer.writeNode(4 /* Unspecified */, node, file, writer);
+        });
+    }
+    ts.nodeToDisplayParts = nodeToDisplayParts;
     function isImportOrExportSpecifierName(location) {
         return !!location.parent && ts.isImportOrExportSpecifier(location.parent) && location.parent.propertyName === location;
     }
@@ -130485,12 +130482,13 @@ var ts;
                     }
                     case 208 /* CallExpression */:
                     case 209 /* NewExpression */:
+                    case 285 /* JsxAttribute */:
                         if (!isRequireCallArgument(node) && !ts.isImportCall(parent)) {
-                            var argumentInfo = ts.SignatureHelp.getArgumentInfoForCompletions(node, position, sourceFile);
+                            var argumentInfo = ts.SignatureHelp.getArgumentInfoForCompletions(parent.kind === 285 /* JsxAttribute */ ? parent.parent : node, position, sourceFile);
                             // Get string literal completions from specialized signatures of the target
                             // i.e. declare function f(a: 'A');
                             // f("/*completion position*/")
-                            return argumentInfo ? getStringLiteralCompletionsFromSignature(argumentInfo, typeChecker) : fromContextualType();
+                            return argumentInfo ? getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker) : fromContextualType();
                         }
                     // falls through (is `require("")` or `require(""` or `import("")`)
                     case 266 /* ImportDeclaration */:
@@ -130527,15 +130525,22 @@ var ts;
                     return type !== current && ts.isLiteralTypeNode(type) && ts.isStringLiteral(type.literal) ? type.literal.text : undefined;
                 });
             }
-            function getStringLiteralCompletionsFromSignature(argumentInfo, checker) {
+            function getStringLiteralCompletionsFromSignature(call, arg, argumentInfo, checker) {
                 var isNewIdentifier = false;
                 var uniques = new ts.Map();
                 var candidates = [];
-                checker.getResolvedSignature(argumentInfo.invocation, candidates, argumentInfo.argumentCount);
+                var editingArgument = ts.isJsxOpeningLikeElement(call) ? ts.Debug.checkDefined(ts.findAncestor(arg.parent, ts.isJsxAttribute)) : arg;
+                checker.getResolvedSignatureForStringLiteralCompletions(call, editingArgument, candidates);
                 var types = ts.flatMap(candidates, function (candidate) {
                     if (!ts.signatureHasRestParameter(candidate) && argumentInfo.argumentCount > candidate.parameters.length)
                         return;
                     var type = candidate.getTypeParameterAtPosition(argumentInfo.argumentIndex);
+                    if (ts.isJsxOpeningLikeElement(call)) {
+                        var propType = checker.getTypeOfPropertyOfType(type, editingArgument.name.text);
+                        if (propType) {
+                            type = propType;
+                        }
+                    }
                     isNewIdentifier = isNewIdentifier || !!(type.flags & 4 /* String */);
                     return getStringLiteralTypes(type, uniques);
                 });
@@ -131078,43 +131083,28 @@ var ts;
         // Exported only for tests
         Completions.moduleSpecifierResolutionLimit = 100;
         Completions.moduleSpecifierResolutionCacheAttemptLimit = 1000;
-        // NOTE: Make sure that each entry has the exact same number of digits
-        //       since many implementations will sort by string contents,
-        //       where "10" is considered less than "2".
-        var SortText;
-        (function (SortText) {
-            SortText["LocalDeclarationPriority"] = "10";
-            SortText["LocationPriority"] = "11";
-            SortText["OptionalMember"] = "12";
-            SortText["MemberDeclaredBySpreadAssignment"] = "13";
-            SortText["SuggestedClassMembers"] = "14";
-            SortText["GlobalsOrKeywords"] = "15";
-            SortText["AutoImportSuggestions"] = "16";
-            SortText["ClassMemberSnippets"] = "17";
-            SortText["JavascriptIdentifiers"] = "18";
-            SortText["DeprecatedLocalDeclarationPriority"] = "19";
-            SortText["DeprecatedLocationPriority"] = "20";
-            SortText["DeprecatedOptionalMember"] = "21";
-            SortText["DeprecatedMemberDeclaredBySpreadAssignment"] = "22";
-            SortText["DeprecatedSuggestedClassMembers"] = "23";
-            SortText["DeprecatedGlobalsOrKeywords"] = "24";
-            SortText["DeprecatedAutoImportSuggestions"] = "25";
-        })(SortText = Completions.SortText || (Completions.SortText = {}));
-        var SortTextId;
-        (function (SortTextId) {
-            SortTextId[SortTextId["LocalDeclarationPriority"] = 10] = "LocalDeclarationPriority";
-            SortTextId[SortTextId["LocationPriority"] = 11] = "LocationPriority";
-            SortTextId[SortTextId["OptionalMember"] = 12] = "OptionalMember";
-            SortTextId[SortTextId["MemberDeclaredBySpreadAssignment"] = 13] = "MemberDeclaredBySpreadAssignment";
-            SortTextId[SortTextId["SuggestedClassMembers"] = 14] = "SuggestedClassMembers";
-            SortTextId[SortTextId["GlobalsOrKeywords"] = 15] = "GlobalsOrKeywords";
-            SortTextId[SortTextId["AutoImportSuggestions"] = 16] = "AutoImportSuggestions";
-            // Don't use these directly.
-            SortTextId[SortTextId["_JavaScriptIdentifiers"] = 18] = "_JavaScriptIdentifiers";
-            SortTextId[SortTextId["_DeprecatedStart"] = 19] = "_DeprecatedStart";
-            SortTextId[SortTextId["_First"] = 10] = "_First";
-            SortTextId[SortTextId["DeprecatedOffset"] = 9] = "DeprecatedOffset";
-        })(SortTextId || (SortTextId = {}));
+        Completions.SortText = {
+            // Presets
+            LocalDeclarationPriority: "10",
+            LocationPriority: "11",
+            OptionalMember: "12",
+            MemberDeclaredBySpreadAssignment: "13",
+            SuggestedClassMembers: "14",
+            GlobalsOrKeywords: "15",
+            AutoImportSuggestions: "16",
+            ClassMemberSnippets: "17",
+            JavascriptIdentifiers: "18",
+            // Transformations
+            Deprecated: function (sortText) {
+                return "z" + sortText;
+            },
+            ObjectLiteralProperty: function (presetSortText, symbolDisplayName) {
+                return presetSortText + "\0" + symbolDisplayName + "\0";
+            },
+            SortBelow: function (sortText) {
+                return sortText + "1";
+            },
+        };
         /**
          * Special values for `CompletionInfo['source']` used to disambiguate
          * completion items with the same `name`. (Each completion item must
@@ -131134,6 +131124,8 @@ var ts;
             CompletionSource["ClassMemberSnippet"] = "ClassMemberSnippet/";
             /** A type-only import that needs to be promoted in order to be used at the completion location */
             CompletionSource["TypeOnlyAlias"] = "TypeOnlyAlias/";
+            /** Auto-import that comes attached to an object literal method snippet */
+            CompletionSource["ObjectLiteralMethodSnippet"] = "ObjectLiteralMethodSnippet/";
         })(CompletionSource = Completions.CompletionSource || (Completions.CompletionSource = {}));
         var SymbolOriginInfoKind;
         (function (SymbolOriginInfoKind) {
@@ -131144,6 +131136,7 @@ var ts;
             SymbolOriginInfoKind[SymbolOriginInfoKind["Nullable"] = 16] = "Nullable";
             SymbolOriginInfoKind[SymbolOriginInfoKind["ResolvedExport"] = 32] = "ResolvedExport";
             SymbolOriginInfoKind[SymbolOriginInfoKind["TypeOnlyAlias"] = 64] = "TypeOnlyAlias";
+            SymbolOriginInfoKind[SymbolOriginInfoKind["ObjectLiteralMethod"] = 128] = "ObjectLiteralMethod";
             SymbolOriginInfoKind[SymbolOriginInfoKind["SymbolMemberNoExport"] = 2] = "SymbolMemberNoExport";
             SymbolOriginInfoKind[SymbolOriginInfoKind["SymbolMemberExport"] = 6] = "SymbolMemberExport";
         })(SymbolOriginInfoKind || (SymbolOriginInfoKind = {}));
@@ -131174,6 +131167,9 @@ var ts;
         function originIsTypeOnlyAlias(origin) {
             return !!(origin && origin.kind & 64 /* TypeOnlyAlias */);
         }
+        function originIsObjectLiteralMethod(origin) {
+            return !!(origin && origin.kind & 128 /* ObjectLiteralMethod */);
+        }
         var KeywordCompletionFilters;
         (function (KeywordCompletionFilters) {
             KeywordCompletionFilters[KeywordCompletionFilters["None"] = 0] = "None";
@@ -131266,7 +131262,7 @@ var ts;
                 && (previousToken.kind === 81 /* BreakKeyword */ || previousToken.kind === 86 /* ContinueKeyword */ || previousToken.kind === 79 /* Identifier */)) {
                 return getLabelCompletionAtPosition(previousToken.parent);
             }
-            var completionData = getCompletionData(program, log, sourceFile, isUncheckedFile(sourceFile, compilerOptions), position, preferences, /*detailsEntryId*/ undefined, host, cancellationToken);
+            var completionData = getCompletionData(program, log, sourceFile, compilerOptions, position, preferences, /*detailsEntryId*/ undefined, host, formatContext, cancellationToken);
             if (!completionData) {
                 return undefined;
             }
@@ -131364,7 +131360,7 @@ var ts;
                 name: ts.tokenToString(keyword),
                 kind: "keyword" /* keyword */,
                 kindModifiers: "" /* none */,
-                sortText: SortText.GlobalsOrKeywords,
+                sortText: Completions.SortText.GlobalsOrKeywords,
             };
         }
         function specificKeywordCompletionInfo(entries, isNewIdentifierLocation) {
@@ -131393,7 +131389,7 @@ var ts;
             return (location === null || location === void 0 ? void 0 : location.kind) === 79 /* Identifier */ ? ts.createTextSpanFromNode(location) : undefined;
         }
         function completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences, formatContext, position) {
-            var symbols = completionData.symbols, contextToken = completionData.contextToken, completionKind = completionData.completionKind, isInSnippetScope = completionData.isInSnippetScope, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, propertyAccessToConvert = completionData.propertyAccessToConvert, keywordFilters = completionData.keywordFilters, literals = completionData.literals, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, recommendedCompletion = completionData.recommendedCompletion, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation, isJsxIdentifierExpected = completionData.isJsxIdentifierExpected, isRightOfOpenTag = completionData.isRightOfOpenTag, importCompletionNode = completionData.importCompletionNode, insideJsDocTagTypeExpression = completionData.insideJsDocTagTypeExpression, symbolToSortTextIdMap = completionData.symbolToSortTextIdMap, hasUnresolvedAutoImports = completionData.hasUnresolvedAutoImports;
+            var symbols = completionData.symbols, contextToken = completionData.contextToken, completionKind = completionData.completionKind, isInSnippetScope = completionData.isInSnippetScope, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, propertyAccessToConvert = completionData.propertyAccessToConvert, keywordFilters = completionData.keywordFilters, literals = completionData.literals, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, recommendedCompletion = completionData.recommendedCompletion, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation, isJsxIdentifierExpected = completionData.isJsxIdentifierExpected, isRightOfOpenTag = completionData.isRightOfOpenTag, importCompletionNode = completionData.importCompletionNode, insideJsDocTagTypeExpression = completionData.insideJsDocTagTypeExpression, symbolToSortTextMap = completionData.symbolToSortTextMap, hasUnresolvedAutoImports = completionData.hasUnresolvedAutoImports;
             // Verify if the file is JSX language variant
             if (ts.getLanguageVariant(sourceFile.scriptKind) === 1 /* JSX */) {
                 var completionInfo = getJsxClosingTagCompletion(location, sourceFile);
@@ -131404,7 +131400,7 @@ var ts;
             var entries = ts.createSortedArray();
             if (isUncheckedFile(sourceFile, compilerOptions)) {
                 var uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, 
-                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap, isJsxIdentifierExpected, isRightOfOpenTag);
+                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag);
                 getJSCompletionEntries(sourceFile, location.pos, uniqueNames, ts.getEmitScriptTarget(compilerOptions), entries);
             }
             else {
@@ -131412,7 +131408,7 @@ var ts;
                     return undefined;
                 }
                 getCompletionEntriesFromSymbols(symbols, entries, 
-                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap, isJsxIdentifierExpected, isRightOfOpenTag);
+                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag);
             }
             if (keywordFilters !== 0 /* None */) {
                 var entryNames_1 = new ts.Set(entries.map(function (e) { return e.name; }));
@@ -131493,7 +131489,7 @@ var ts;
                     name: fullClosingTag,
                     kind: "class" /* classElement */,
                     kindModifiers: undefined,
-                    sortText: SortText.LocationPriority,
+                    sortText: Completions.SortText.LocationPriority,
                 };
                 return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: false, optionalReplacementSpan: replacementSpan, entries: [entry] };
             }
@@ -131512,7 +131508,7 @@ var ts;
                         name: realName,
                         kind: "warning" /* warning */,
                         kindModifiers: "",
-                        sortText: SortText.JavascriptIdentifiers,
+                        sortText: Completions.SortText.JavascriptIdentifiers,
                         isFromUncheckedFile: true
                     }, compareCompletionEntries);
                 }
@@ -131523,7 +131519,7 @@ var ts;
                 ts.isString(literal) ? ts.quote(sourceFile, preferences, literal) : JSON.stringify(literal);
         }
         function createCompletionEntryForLiteral(sourceFile, preferences, literal) {
-            return { name: completionNameForLiteral(sourceFile, preferences, literal), kind: "string" /* string */, kindModifiers: "" /* none */, sortText: SortText.LocationPriority };
+            return { name: completionNameForLiteral(sourceFile, preferences, literal), kind: "string" /* string */, kindModifiers: "" /* none */, sortText: Completions.SortText.LocationPriority };
         }
         function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences, completionKind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag) {
             var _a, _b;
@@ -131594,12 +131590,21 @@ var ts;
                 isClassLikeMemberCompletion(symbol, location)) {
                 var importAdder = void 0;
                 (_b = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken, formatContext), insertText = _b.insertText, isSnippet = _b.isSnippet, importAdder = _b.importAdder, replacementSpan = _b.replacementSpan);
-                sortText = SortText.ClassMemberSnippets; // sortText has to be lower priority than the sortText for keywords. See #47852.
+                sortText = Completions.SortText.ClassMemberSnippets; // sortText has to be lower priority than the sortText for keywords. See #47852.
                 if (importAdder === null || importAdder === void 0 ? void 0 : importAdder.hasFixes()) {
                     hasAction = true;
                     source = CompletionSource.ClassMemberSnippet;
                 }
             }
+            if (origin && originIsObjectLiteralMethod(origin)) {
+                var importAdder = void 0;
+                (insertText = origin.insertText, isSnippet = origin.isSnippet, importAdder = origin.importAdder, sourceDisplay = origin.sourceDisplay);
+                source = CompletionSource.ObjectLiteralMethodSnippet;
+                sortText = Completions.SortText.SortBelow(sortText);
+                if (importAdder.hasFixes()) {
+                    hasAction = true;
+                }
+            }
             if (isJsxIdentifierExpected && !isRightOfOpenTag && preferences.includeCompletionsWithSnippetText && preferences.jsxAttributeCompletionStyle && preferences.jsxAttributeCompletionStyle !== "none") {
                 var useBraces_1 = preferences.jsxAttributeCompletionStyle === "braces";
                 var type = typeChecker.getTypeOfSymbolAtLocation(symbol, location);
@@ -131758,27 +131763,15 @@ var ts;
                 completionNodes.push(node);
             }, body, 2 /* Property */, isAbstract);
             if (completionNodes.length) {
+                var format = 1 /* MultiLine */ | 131072 /* NoTrailingNewLine */;
                 replacementSpan = modifiersSpan;
                 // If we have access to formatting settings, we print the nodes using the emitter,
                 // and then format the printed text.
                 if (formatContext) {
-                    var syntheticFile_1 = {
-                        text: printer.printSnippetList(1 /* MultiLine */ | 131072 /* NoTrailingNewLine */, ts.factory.createNodeArray(completionNodes), sourceFile),
-                        getLineAndCharacterOfPosition: function (pos) {
-                            return ts.getLineAndCharacterOfPosition(this, pos);
-                        },
-                    };
-                    var formatOptions_1 = ts.getFormatCodeSettingsForWriting(formatContext, sourceFile);
-                    var changes = ts.flatMap(completionNodes, function (node) {
-                        var nodeWithPos = ts.textChanges.assignPositionsToNode(node);
-                        return ts.formatting.formatNodeGivenIndentation(nodeWithPos, syntheticFile_1, sourceFile.languageVariant, 
-                        /* indentation */ 0, 
-                        /* delta */ 0, __assign(__assign({}, formatContext), { options: formatOptions_1 }));
-                    });
-                    insertText = ts.textChanges.applyChanges(syntheticFile_1.text, changes);
+                    insertText = printer.printAndFormatSnippetList(format, ts.factory.createNodeArray(completionNodes), sourceFile, formatContext);
                 }
                 else { // Otherwise, just use emitter to print the new nodes.
-                    insertText = printer.printSnippetList(1 /* MultiLine */ | 131072 /* NoTrailingNewLine */, ts.factory.createNodeArray(completionNodes), sourceFile);
+                    insertText = printer.printSnippetList(format, ts.factory.createNodeArray(completionNodes), sourceFile);
                 }
             }
             return { insertText: insertText, isSnippet: isSnippet, importAdder: importAdder, replacementSpan: replacementSpan };
@@ -131828,12 +131821,103 @@ var ts;
             }
             return undefined;
         }
+        function getEntryForObjectLiteralMethodCompletion(symbol, name, enclosingDeclaration, program, host, options, preferences, formatContext) {
+            var isSnippet = preferences.includeCompletionsWithSnippetText || undefined;
+            var insertText = name;
+            var sourceFile = enclosingDeclaration.getSourceFile();
+            var importAdder = ts.codefix.createImportAdder(sourceFile, program, preferences, host);
+            var method = createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, program, host, preferences, importAdder);
+            if (!method) {
+                return undefined;
+            }
+            var printer = createSnippetPrinter({
+                removeComments: true,
+                module: options.module,
+                target: options.target,
+                omitTrailingSemicolon: false,
+                newLine: ts.getNewLineKind(ts.getNewLineCharacter(options, ts.maybeBind(host, host.getNewLine))),
+            });
+            if (formatContext) {
+                insertText = printer.printAndFormatSnippetList(16 /* CommaDelimited */ | 64 /* AllowTrailingComma */, ts.factory.createNodeArray([method], /*hasTrailingComma*/ true), sourceFile, formatContext);
+            }
+            else {
+                insertText = printer.printSnippetList(16 /* CommaDelimited */ | 64 /* AllowTrailingComma */, ts.factory.createNodeArray([method], /*hasTrailingComma*/ true), sourceFile);
+            }
+            var methodSignature = ts.factory.createMethodSignature(method.modifiers, method.name, method.questionToken, method.typeParameters, method.parameters, method.type);
+            var sourceDisplay = ts.nodeToDisplayParts(methodSignature, enclosingDeclaration);
+            return { isSnippet: isSnippet, insertText: insertText, importAdder: importAdder, sourceDisplay: sourceDisplay };
+        }
+        ;
+        function createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, program, host, preferences, importAdder) {
+            var declarations = symbol.getDeclarations();
+            if (!(declarations && declarations.length)) {
+                return undefined;
+            }
+            var checker = program.getTypeChecker();
+            var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions());
+            var declaration = declarations[0];
+            var name = ts.getSynthesizedDeepClone(ts.getNameOfDeclaration(declaration), /*includeTrivia*/ false);
+            var type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
+            var quotePreference = ts.getQuotePreference(sourceFile, preferences);
+            var builderFlags = quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : undefined;
+            switch (declaration.kind) {
+                case 166 /* PropertySignature */:
+                case 167 /* PropertyDeclaration */:
+                case 168 /* MethodSignature */:
+                case 169 /* MethodDeclaration */: {
+                    var effectiveType = type.flags & 1048576 /* Union */ && type.types.length < 10
+                        ? checker.getUnionType(type.types, 2 /* Subtype */)
+                        : type;
+                    if (effectiveType.flags & 1048576 /* Union */) {
+                        // Only offer the completion if there's a single function type component.
+                        var functionTypes = ts.filter(effectiveType.types, function (type) { return checker.getSignaturesOfType(type, 0 /* Call */).length > 0; });
+                        if (functionTypes.length === 1) {
+                            effectiveType = functionTypes[0];
+                        }
+                        else {
+                            return undefined;
+                        }
+                    }
+                    var signatures = checker.getSignaturesOfType(effectiveType, 0 /* Call */);
+                    if (signatures.length !== 1) {
+                        // We don't support overloads in object literals.
+                        return undefined;
+                    }
+                    var typeNode = checker.typeToTypeNode(effectiveType, enclosingDeclaration, builderFlags, ts.codefix.getNoopSymbolTrackerWithResolver({ program: program, host: host }));
+                    if (!typeNode || !ts.isFunctionTypeNode(typeNode)) {
+                        return undefined;
+                    }
+                    var importableReference = ts.codefix.tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
+                    if (importableReference) {
+                        typeNode = importableReference.typeNode;
+                        ts.codefix.importSymbols(importAdder, importableReference.symbols);
+                    }
+                    var body = void 0;
+                    if (preferences.includeCompletionsWithSnippetText) {
+                        var emptyStmt = ts.factory.createEmptyStatement();
+                        body = ts.factory.createBlock([emptyStmt], /* multiline */ true);
+                        ts.setSnippetElement(emptyStmt, { kind: 0 /* TabStop */, order: 0 });
+                    }
+                    else {
+                        body = ts.factory.createBlock([], /* multiline */ true);
+                    }
+                    return ts.factory.createMethodDeclaration(
+                    /*decorators*/ undefined, 
+                    /*modifiers*/ undefined, 
+                    /*asteriskToken*/ undefined, name, 
+                    /*questionToken*/ undefined, typeNode.typeParameters, typeNode.parameters, typeNode.type, body);
+                }
+                default:
+                    return undefined;
+            }
+        }
         function createSnippetPrinter(printerOptions) {
             var baseWriter = ts.textChanges.createWriter(ts.getNewLineCharacter(printerOptions));
             var printer = ts.createPrinter(printerOptions, baseWriter);
             var writer = __assign(__assign({}, baseWriter), { write: function (s) { return baseWriter.write(ts.escapeSnippetText(s)); }, nonEscapingWrite: baseWriter.write, writeLiteral: function (s) { return baseWriter.writeLiteral(ts.escapeSnippetText(s)); }, writeStringLiteral: function (s) { return baseWriter.writeStringLiteral(ts.escapeSnippetText(s)); }, writeSymbol: function (s, symbol) { return baseWriter.writeSymbol(ts.escapeSnippetText(s), symbol); }, writeParameter: function (s) { return baseWriter.writeParameter(ts.escapeSnippetText(s)); }, writeComment: function (s) { return baseWriter.writeComment(ts.escapeSnippetText(s)); }, writeProperty: function (s) { return baseWriter.writeProperty(ts.escapeSnippetText(s)); } });
             return {
                 printSnippetList: printSnippetList,
+                printAndFormatSnippetList: printAndFormatSnippetList,
             };
             /* Snippet-escaping version of `printer.printList`. */
             function printSnippetList(format, list, sourceFile) {
@@ -131841,6 +131925,22 @@ var ts;
                 printer.writeList(format, list, sourceFile, writer);
                 return writer.getText();
             }
+            function printAndFormatSnippetList(format, list, sourceFile, formatContext) {
+                var syntheticFile = {
+                    text: printSnippetList(format, list, sourceFile),
+                    getLineAndCharacterOfPosition: function (pos) {
+                        return ts.getLineAndCharacterOfPosition(this, pos);
+                    },
+                };
+                var formatOptions = ts.getFormatCodeSettingsForWriting(formatContext, sourceFile);
+                var changes = ts.flatMap(list, function (node) {
+                    var nodeWithPos = ts.textChanges.assignPositionsToNode(node);
+                    return ts.formatting.formatNodeGivenIndentation(nodeWithPos, syntheticFile, sourceFile.languageVariant, 
+                    /* indentation */ 0, 
+                    /* delta */ 0, __assign(__assign({}, formatContext), { options: formatOptions }));
+                });
+                return ts.textChanges.applyChanges(syntheticFile.text, changes);
+            }
         }
         function originToCompletionEntryData(origin) {
             var ambientModuleName = origin.fileName ? undefined : ts.stripQuotes(origin.moduleSymbol.name);
@@ -131938,7 +132038,7 @@ var ts;
                 return CompletionSource.TypeOnlyAlias;
             }
         }
-        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap, isJsxIdentifierExpected, isRightOfOpenTag) {
+        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag) {
             var _a;
             var start = ts.timestamp();
             var variableDeclaration = getVariableDeclaration(location);
@@ -131953,12 +132053,12 @@ var ts;
                 var symbol = symbols[i];
                 var origin = symbolToOriginInfoMap === null || symbolToOriginInfoMap === void 0 ? void 0 : symbolToOriginInfoMap[i];
                 var info = getCompletionEntryDisplayNameForSymbol(symbol, target, origin, kind, !!jsxIdentifierExpected);
-                if (!info || uniques.get(info.name) || kind === 1 /* Global */ && symbolToSortTextIdMap && !shouldIncludeSymbol(symbol, symbolToSortTextIdMap)) {
+                if (!info || (uniques.get(info.name) && (!origin || !originIsObjectLiteralMethod(origin))) || kind === 1 /* Global */ && symbolToSortTextMap && !shouldIncludeSymbol(symbol, symbolToSortTextMap)) {
                     continue;
                 }
                 var name = info.name, needsConvertPropertyAccess = info.needsConvertPropertyAccess;
-                var sortTextId = (_a = symbolToSortTextIdMap === null || symbolToSortTextIdMap === void 0 ? void 0 : symbolToSortTextIdMap[ts.getSymbolId(symbol)]) !== null && _a !== void 0 ? _a : 11 /* LocationPriority */;
-                var sortText = (isDeprecated(symbol, typeChecker) ? 9 /* DeprecatedOffset */ + sortTextId : sortTextId).toString();
+                var originalSortText = (_a = symbolToSortTextMap === null || symbolToSortTextMap === void 0 ? void 0 : symbolToSortTextMap[ts.getSymbolId(symbol)]) !== null && _a !== void 0 ? _a : Completions.SortText.LocationPriority;
+                var sortText = (isDeprecated(symbol, typeChecker) ? Completions.SortText.Deprecated(originalSortText) : originalSortText);
                 var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences, kind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag);
                 if (!entry) {
                     continue;
@@ -131976,7 +132076,7 @@ var ts;
                 has: function (name) { return uniques.has(name); },
                 add: function (name) { return uniques.set(name, true); },
             };
-            function shouldIncludeSymbol(symbol, symbolToSortTextIdMap) {
+            function shouldIncludeSymbol(symbol, symbolToSortTextMap) {
                 var allFlags = symbol.flags;
                 if (!ts.isSourceFile(location)) {
                     // export = /**/ here we want to get all meanings, so any symbol is ok
@@ -131998,9 +132098,9 @@ var ts;
                     // Auto Imports are not available for scripts so this conditional is always false
                     if (!!sourceFile.externalModuleIndicator
                         && !compilerOptions.allowUmdGlobalAccess
-                        && symbolToSortTextIdMap[ts.getSymbolId(symbol)] === 15 /* GlobalsOrKeywords */
-                        && (symbolToSortTextIdMap[ts.getSymbolId(symbolOrigin)] === 16 /* AutoImportSuggestions */
-                            || symbolToSortTextIdMap[ts.getSymbolId(symbolOrigin)] === 11 /* LocationPriority */)) {
+                        && symbolToSortTextMap[ts.getSymbolId(symbol)] === Completions.SortText.GlobalsOrKeywords
+                        && (symbolToSortTextMap[ts.getSymbolId(symbolOrigin)] === Completions.SortText.AutoImportSuggestions
+                            || symbolToSortTextMap[ts.getSymbolId(symbolOrigin)] === Completions.SortText.LocationPriority)) {
                         return false;
                     }
                     allFlags |= ts.getCombinedLocalAndExportSymbolFlags(symbolOrigin);
@@ -132040,7 +132140,7 @@ var ts;
                             name: name,
                             kindModifiers: "" /* none */,
                             kind: "label" /* label */,
-                            sortText: SortText.LocationPriority
+                            sortText: Completions.SortText.LocationPriority
                         });
                     }
                 }
@@ -132066,7 +132166,7 @@ var ts;
                 }
             }
             var compilerOptions = program.getCompilerOptions();
-            var completionData = getCompletionData(program, log, sourceFile, isUncheckedFile(sourceFile, compilerOptions), position, { includeCompletionsForModuleExports: true, includeCompletionsWithInsertText: true }, entryId, host);
+            var completionData = getCompletionData(program, log, sourceFile, compilerOptions, position, { includeCompletionsForModuleExports: true, includeCompletionsWithInsertText: true }, entryId, host, /*formatContext*/ undefined);
             if (!completionData) {
                 return { type: "none" };
             }
@@ -132084,7 +132184,9 @@ var ts;
             return ts.firstDefined(symbols, function (symbol, index) {
                 var origin = symbolToOriginInfoMap[index];
                 var info = getCompletionEntryDisplayNameForSymbol(symbol, ts.getEmitScriptTarget(compilerOptions), origin, completionKind, completionData.isJsxIdentifierExpected);
-                return info && info.name === entryId.name && (entryId.source === CompletionSource.ClassMemberSnippet && symbol.flags & 106500 /* ClassMember */ || getSourceFromOrigin(origin) === entryId.source)
+                return info && info.name === entryId.name && (entryId.source === CompletionSource.ClassMemberSnippet && symbol.flags & 106500 /* ClassMember */
+                    || entryId.source === CompletionSource.ObjectLiteralMethodSnippet && symbol.flags & (4 /* Property */ | 8192 /* Method */)
+                    || getSourceFromOrigin(origin) === entryId.source)
                     ? { type: "symbol", symbol: symbol, location: location, origin: origin, contextToken: contextToken, previousToken: previousToken, isJsxInitializer: isJsxInitializer, isTypeOnlyLocation: isTypeOnlyLocation }
                     : undefined;
             }) || { type: "none" };
@@ -132166,6 +132268,20 @@ var ts;
                     };
                 }
             }
+            if (source === CompletionSource.ObjectLiteralMethodSnippet) {
+                var enclosingDeclaration = tryGetObjectLikeCompletionContainer(contextToken);
+                var importAdder = getEntryForObjectLiteralMethodCompletion(symbol, name, enclosingDeclaration, program, host, compilerOptions, preferences, formatContext).importAdder;
+                if (importAdder.hasFixes()) {
+                    var changes = ts.textChanges.ChangeTracker.with({ host: host, formatContext: formatContext, preferences: preferences }, importAdder.writeFixes);
+                    return {
+                        sourceDisplay: undefined,
+                        codeActions: [{
+                                changes: changes,
+                                description: ts.diagnosticToString([ts.Diagnostics.Includes_imports_of_types_referenced_by_0, name]),
+                            }],
+                    };
+                }
+            }
             if (originIsTypeOnlyAlias(origin)) {
                 var codeAction_1 = ts.codefix.getPromoteTypeOnlyCompletionAction(sourceFile, origin.declaration.name, program, host, formatContext, preferences);
                 ts.Debug.assertIsDefined(codeAction_1, "Expected to have a code action for promoting type-only alias");
@@ -132258,8 +132374,9 @@ var ts;
             var _a;
             return !!((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d.kind === 305 /* SourceFile */; }));
         }
-        function getCompletionData(program, log, sourceFile, isUncheckedFile, position, preferences, detailsEntryId, host, cancellationToken) {
+        function getCompletionData(program, log, sourceFile, compilerOptions, position, preferences, detailsEntryId, host, formatContext, cancellationToken) {
             var typeChecker = program.getTypeChecker();
+            var inUncheckedFile = isUncheckedFile(sourceFile, compilerOptions);
             var start = ts.timestamp();
             var currentToken = ts.getTokenAtPosition(sourceFile, position); // TODO: GH#15853
             // We will check for jsdoc comments with insideComment and getJsDocTagAtPosition. (TODO: that seems rather inefficient to check the same thing so many times.)
@@ -132502,7 +132619,7 @@ var ts;
             // This also gets mutated in nested-functions after the return
             var symbols = [];
             var symbolToOriginInfoMap = [];
-            var symbolToSortTextIdMap = [];
+            var symbolToSortTextMap = [];
             var seenPropertySymbols = new ts.Map();
             var isTypeOnlyLocation = isTypeOnlyCompletion();
             var getModuleSpecifierResolutionHost = ts.memoizeOne(function (isFromPackageJson) {
@@ -132557,7 +132674,7 @@ var ts;
                 contextToken: contextToken,
                 isJsxInitializer: isJsxInitializer,
                 insideJsDocTagTypeExpression: insideJsDocTagTypeExpression,
-                symbolToSortTextIdMap: symbolToSortTextIdMap,
+                symbolToSortTextMap: symbolToSortTextMap,
                 isTypeOnlyLocation: isTypeOnlyLocation,
                 isJsxIdentifierExpected: isJsxIdentifierExpected,
                 isRightOfOpenTag: isRightOfOpenTag,
@@ -132671,7 +132788,7 @@ var ts;
                     isNewIdentifierLocation = true;
                 }
                 var propertyAccess = node.kind === 200 /* ImportType */ ? node : node.parent;
-                if (isUncheckedFile) {
+                if (inUncheckedFile) {
                     // In javascript files, for union types, we don't just get the members that
                     // the individual types have in common, we also include all the members that
                     // each individual type has. This is because we're going to add all identifiers
@@ -132756,7 +132873,7 @@ var ts;
                 }
                 function addSymbolSortInfo(symbol) {
                     if (isStaticProperty(symbol)) {
-                        symbolToSortTextIdMap[ts.getSymbolId(symbol)] = 10 /* LocalDeclarationPriority */;
+                        symbolToSortTextMap[ts.getSymbolId(symbol)] = Completions.SortText.LocalDeclarationPriority;
                     }
                 }
                 function addSymbolOriginInfo(symbol) {
@@ -132866,7 +132983,7 @@ var ts;
                     var symbol = symbols[i];
                     if (!typeChecker.isArgumentsSymbol(symbol) &&
                         !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === sourceFile; })) {
-                        symbolToSortTextIdMap[ts.getSymbolId(symbol)] = 15 /* GlobalsOrKeywords */;
+                        symbolToSortTextMap[ts.getSymbolId(symbol)] = Completions.SortText.GlobalsOrKeywords;
                     }
                     if (typeOnlyAliasNeedsPromotion && !(symbol.flags & 111551 /* Value */)) {
                         var typeOnlyAliasDeclaration = symbol.declarations && ts.find(symbol.declarations, ts.isTypeOnlyImportOrExportDeclaration);
@@ -132884,7 +133001,7 @@ var ts;
                             var symbol = _a[_i];
                             symbolToOriginInfoMap[symbols.length] = { kind: 1 /* ThisType */ };
                             symbols.push(symbol);
-                            symbolToSortTextIdMap[ts.getSymbolId(symbol)] = 14 /* SuggestedClassMembers */;
+                            symbolToSortTextMap[ts.getSymbolId(symbol)] = Completions.SortText.SuggestedClassMembers;
                         }
                     }
                 }
@@ -132962,7 +133079,7 @@ var ts;
                 }
                 return false;
             }
-            /** Mutates `symbols`, `symbolToOriginInfoMap`, and `symbolToSortTextIdMap` */
+            /** Mutates `symbols`, `symbolToOriginInfoMap`, and `symbolToSortTextMap` */
             function collectAutoImports() {
                 var _a, _b;
                 if (!shouldOfferImportCompletions())
@@ -133044,14 +133161,55 @@ var ts;
             }
             function pushAutoImportSymbol(symbol, origin) {
                 var symbolId = ts.getSymbolId(symbol);
-                if (symbolToSortTextIdMap[symbolId] === 15 /* GlobalsOrKeywords */) {
+                if (symbolToSortTextMap[symbolId] === Completions.SortText.GlobalsOrKeywords) {
                     // If an auto-importable symbol is available as a global, don't add the auto import
                     return;
                 }
                 symbolToOriginInfoMap[symbols.length] = origin;
-                symbolToSortTextIdMap[symbolId] = importCompletionNode ? 11 /* LocationPriority */ : 16 /* AutoImportSuggestions */;
+                symbolToSortTextMap[symbolId] = importCompletionNode ? Completions.SortText.LocationPriority : Completions.SortText.AutoImportSuggestions;
                 symbols.push(symbol);
             }
+            /* Mutates `symbols` and `symbolToOriginInfoMap`. */
+            function collectObjectLiteralMethodSymbols(members, enclosingDeclaration) {
+                // TODO: support JS files.
+                if (ts.isInJSFile(location)) {
+                    return;
+                }
+                members.forEach(function (member) {
+                    if (!isObjectLiteralMethodSymbol(member)) {
+                        return;
+                    }
+                    var displayName = getCompletionEntryDisplayNameForSymbol(member, ts.getEmitScriptTarget(compilerOptions), 
+                    /*origin*/ undefined, 0 /* ObjectPropertyDeclaration */, 
+                    /*jsxIdentifierExpected*/ false);
+                    if (!displayName) {
+                        return;
+                    }
+                    var name = displayName.name;
+                    var entryProps = getEntryForObjectLiteralMethodCompletion(member, name, enclosingDeclaration, program, host, compilerOptions, preferences, formatContext);
+                    if (!entryProps) {
+                        return;
+                    }
+                    var origin = __assign({ kind: 128 /* ObjectLiteralMethod */ }, entryProps);
+                    symbolToOriginInfoMap[symbols.length] = origin;
+                    symbols.push(member);
+                });
+            }
+            function isObjectLiteralMethodSymbol(symbol) {
+                /*
+                    For an object type
+                    `type Foo = {
+                        bar(x: number): void;
+                        foo: (x: string) => string;
+                    }`,
+                    `bar` will have symbol flag `Method`,
+                    `foo` will have symbol flag `Property`.
+                */
+                if (!(symbol.flags & (4 /* Property */ | 8192 /* Method */))) {
+                    return false;
+                }
+                return true;
+            }
             /**
              * Finds the first node that "embraces" the position, so that one may
              * accurately aggregate locals from the closest containing scope.
@@ -133185,6 +133343,7 @@ var ts;
              * @returns true if 'symbols' was successfully populated; false otherwise.
              */
             function tryGetObjectLikeCompletionSymbols() {
+                var symbolsStartIndex = symbols.length;
                 var objectLikeContainer = tryGetObjectLikeCompletionContainer(contextToken);
                 if (!objectLikeContainer)
                     return 0 /* Continue */;
@@ -133249,9 +133408,16 @@ var ts;
                 }
                 if (typeMembers && typeMembers.length > 0) {
                     // Add filtered items to the completion list
-                    symbols = ts.concatenate(symbols, filterObjectMembersList(typeMembers, ts.Debug.checkDefined(existingMembers)));
+                    var filteredMembers = filterObjectMembersList(typeMembers, ts.Debug.checkDefined(existingMembers));
+                    symbols = ts.concatenate(symbols, filteredMembers);
+                    setSortTextToOptionalMember();
+                    if (objectLikeContainer.kind === 205 /* ObjectLiteralExpression */
+                        && preferences.includeCompletionsWithObjectLiteralMethodSnippets
+                        && preferences.includeCompletionsWithInsertText) {
+                        transformObjectLiteralMembersSortText(symbolsStartIndex);
+                        collectObjectLiteralMethodSymbols(filteredMembers, objectLikeContainer);
+                    }
                 }
-                setSortTextToOptionalMember();
                 return 1 /* Success */;
             }
             /**
@@ -133326,7 +133492,7 @@ var ts;
                     var _a, _b;
                     symbols.push(symbol);
                     if ((_b = (_a = localsContainer.symbol) === null || _a === void 0 ? void 0 : _a.exports) === null || _b === void 0 ? void 0 : _b.has(name)) {
-                        symbolToSortTextIdMap[ts.getSymbolId(symbol)] = 12 /* OptionalMember */;
+                        symbolToSortTextMap[ts.getSymbolId(symbol)] = Completions.SortText.OptionalMember;
                     }
                 });
                 return 1 /* Success */;
@@ -133381,29 +133547,6 @@ var ts;
                 }
                 return 1 /* Success */;
             }
-            /**
-             * Returns the immediate owning object literal or binding pattern of a context token,
-             * on the condition that one exists and that the context implies completion should be given.
-             */
-            function tryGetObjectLikeCompletionContainer(contextToken) {
-                if (contextToken) {
-                    var parent = contextToken.parent;
-                    switch (contextToken.kind) {
-                        case 18 /* OpenBraceToken */: // const x = { |
-                        case 27 /* CommaToken */: // const x = { a: 0, |
-                            if (ts.isObjectLiteralExpression(parent) || ts.isObjectBindingPattern(parent)) {
-                                return parent;
-                            }
-                            break;
-                        case 41 /* AsteriskToken */:
-                            return ts.isMethodDeclaration(parent) ? ts.tryCast(parent.parent, ts.isObjectLiteralExpression) : undefined;
-                        case 79 /* Identifier */:
-                            return contextToken.text === "async" && ts.isShorthandPropertyAssignment(contextToken.parent)
-                                ? contextToken.parent.parent : undefined;
-                    }
-                }
-                return undefined;
-            }
             function isConstructorParameterCompletion(node) {
                 return !!node.parent && ts.isParameter(node.parent) && ts.isConstructorDeclaration(node.parent.parent)
                     && (ts.isParameterPropertyModifier(node.kind) || ts.isDeclarationName(node));
@@ -133740,7 +133883,7 @@ var ts;
                     var _a;
                     if (m.flags & 16777216 /* Optional */) {
                         var symbolId = ts.getSymbolId(m);
-                        symbolToSortTextIdMap[symbolId] = (_a = symbolToSortTextIdMap[symbolId]) !== null && _a !== void 0 ? _a : 12 /* OptionalMember */;
+                        symbolToSortTextMap[symbolId] = (_a = symbolToSortTextMap[symbolId]) !== null && _a !== void 0 ? _a : Completions.SortText.OptionalMember;
                     }
                 });
             }
@@ -133752,7 +133895,23 @@ var ts;
                 for (var _i = 0, contextualMemberSymbols_1 = contextualMemberSymbols; _i < contextualMemberSymbols_1.length; _i++) {
                     var contextualMemberSymbol = contextualMemberSymbols_1[_i];
                     if (membersDeclaredBySpreadAssignment.has(contextualMemberSymbol.name)) {
-                        symbolToSortTextIdMap[ts.getSymbolId(contextualMemberSymbol)] = 13 /* MemberDeclaredBySpreadAssignment */;
+                        symbolToSortTextMap[ts.getSymbolId(contextualMemberSymbol)] = Completions.SortText.MemberDeclaredBySpreadAssignment;
+                    }
+                }
+            }
+            function transformObjectLiteralMembersSortText(start) {
+                var _a;
+                for (var i = start; i < symbols.length; i++) {
+                    var symbol = symbols[i];
+                    var symbolId = ts.getSymbolId(symbol);
+                    var origin = symbolToOriginInfoMap === null || symbolToOriginInfoMap === void 0 ? void 0 : symbolToOriginInfoMap[i];
+                    var target = ts.getEmitScriptTarget(compilerOptions);
+                    var displayName = getCompletionEntryDisplayNameForSymbol(symbol, target, origin, 0 /* ObjectPropertyDeclaration */, 
+                    /*jsxIdentifierExpected*/ false);
+                    if (displayName) {
+                        var originalSortText = (_a = symbolToSortTextMap[symbolId]) !== null && _a !== void 0 ? _a : Completions.SortText.LocationPriority;
+                        var name = displayName.name;
+                        symbolToSortTextMap[symbolId] = Completions.SortText.ObjectLiteralProperty(originalSortText, name);
                     }
                 }
             }
@@ -133826,6 +133985,29 @@ var ts;
                 return node.getStart(sourceFile) <= position && position <= node.getEnd();
             }
         }
+        /**
+         * Returns the immediate owning object literal or binding pattern of a context token,
+         * on the condition that one exists and that the context implies completion should be given.
+         */
+        function tryGetObjectLikeCompletionContainer(contextToken) {
+            if (contextToken) {
+                var parent = contextToken.parent;
+                switch (contextToken.kind) {
+                    case 18 /* OpenBraceToken */: // const x = { |
+                    case 27 /* CommaToken */: // const x = { a: 0, |
+                        if (ts.isObjectLiteralExpression(parent) || ts.isObjectBindingPattern(parent)) {
+                            return parent;
+                        }
+                        break;
+                    case 41 /* AsteriskToken */:
+                        return ts.isMethodDeclaration(parent) ? ts.tryCast(parent.parent, ts.isObjectLiteralExpression) : undefined;
+                    case 79 /* Identifier */:
+                        return contextToken.text === "async" && ts.isShorthandPropertyAssignment(contextToken.parent)
+                            ? contextToken.parent.parent : undefined;
+                }
+            }
+            return undefined;
+        }
         function getRelevantTokens(position, sourceFile) {
             var previousToken = ts.findPrecedingToken(position, sourceFile);
             if (previousToken && position <= previousToken.end && (ts.isMemberName(previousToken) || ts.isKeyword(previousToken.kind))) {
@@ -133891,7 +134073,7 @@ var ts;
                     name: ts.tokenToString(i),
                     kind: "keyword" /* keyword */,
                     kindModifiers: "" /* none */,
-                    sortText: SortText.GlobalsOrKeywords
+                    sortText: Completions.SortText.GlobalsOrKeywords
                 });
             }
             return res;
@@ -134019,7 +134201,7 @@ var ts;
                         name: ts.tokenToString(129 /* AssertKeyword */),
                         kind: "keyword" /* keyword */,
                         kindModifiers: "" /* none */,
-                        sortText: SortText.GlobalsOrKeywords,
+                        sortText: Completions.SortText.GlobalsOrKeywords,
                     });
                 }
             }
@@ -145947,6 +146129,7 @@ var ts;
             return formatting.getFormattingScanner(sourceFile.text, sourceFile.languageVariant, getScanStartPosition(enclosingNode, originalRange, sourceFile), originalRange.end, function (scanner) { return formatSpanWorker(originalRange, enclosingNode, formatting.SmartIndenter.getIndentationForNode(enclosingNode, originalRange, sourceFile, formatContext.options), getOwnOrInheritedDelta(enclosingNode, formatContext.options, sourceFile), scanner, formatContext, requestKind, prepareRangeContainsErrorFunction(sourceFile.parseDiagnostics, originalRange), sourceFile); });
         }
         function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delta, formattingScanner, _a, requestKind, rangeContainsError, sourceFile) {
+            var _b;
             var options = _a.options, getRules = _a.getRules, host = _a.host;
             // formatting context is used by rules provider
             var formattingContext = new formatting.FormattingContext(sourceFile, requestKind, options);
@@ -145978,11 +146161,12 @@ var ts;
                 }
             }
             if (previousRange && formattingScanner.getStartPos() >= originalRange.end) {
-                var token = formattingScanner.isOnEOF() ? formattingScanner.readEOFTokenRange() :
+                var tokenInfo = formattingScanner.isOnEOF() ? formattingScanner.readEOFTokenRange() :
                     formattingScanner.isOnToken() ? formattingScanner.readTokenInfo(enclosingNode).token :
                         undefined;
-                if (token) {
-                    processPair(token, sourceFile.getLineAndCharacterOfPosition(token.pos).line, enclosingNode, previousRange, previousRangeStartLine, previousParent, enclosingNode, 
+                if (tokenInfo) {
+                    var parent = ((_b = ts.findPrecedingToken(tokenInfo.end, sourceFile, enclosingNode)) === null || _b === void 0 ? void 0 : _b.parent) || previousParent;
+                    processPair(tokenInfo, sourceFile.getLineAndCharacterOfPosition(tokenInfo.pos).line, parent, previousRange, previousRangeStartLine, previousParent, parent, 
                     /*dynamicIndentation*/ undefined);
                 }
             }