typescript 4.7.0-dev.20220328 → 4.7.0-dev.20220331

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.20220328";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220331";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -9689,6 +9689,7 @@ var ts;
         An_expanded_version_of_this_information_showing_all_possible_compiler_options: diag(6928, ts.DiagnosticCategory.Message, "An_expanded_version_of_this_information_showing_all_possible_compiler_options_6928", "An expanded version of this information, showing all possible compiler options"),
         Compiles_the_current_project_with_additional_settings: diag(6929, ts.DiagnosticCategory.Message, "Compiles_the_current_project_with_additional_settings_6929", "Compiles the current project, with additional settings."),
         true_for_ES2022_and_above_including_ESNext: diag(6930, ts.DiagnosticCategory.Message, "true_for_ES2022_and_above_including_ESNext_6930", "`true` for ES2022 and above, including ESNext."),
+        List_of_file_name_suffixes_to_search_when_resolving_a_module: diag(6931, ts.DiagnosticCategory.Error, "List_of_file_name_suffixes_to_search_when_resolving_a_module_6931", "List of file name suffixes to search when resolving a module."),
         Variable_0_implicitly_has_an_1_type: diag(7005, ts.DiagnosticCategory.Error, "Variable_0_implicitly_has_an_1_type_7005", "Variable '{0}' implicitly has an '{1}' type."),
         Parameter_0_implicitly_has_an_1_type: diag(7006, ts.DiagnosticCategory.Error, "Parameter_0_implicitly_has_an_1_type_7006", "Parameter '{0}' implicitly has an '{1}' type."),
         Member_0_implicitly_has_an_1_type: diag(7008, ts.DiagnosticCategory.Error, "Member_0_implicitly_has_an_1_type_7008", "Member '{0}' implicitly has an '{1}' type."),
@@ -13606,7 +13607,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) {
@@ -39681,6 +39684,18 @@ var ts;
             description: ts.Diagnostics.Allow_accessing_UMD_globals_from_modules,
             defaultValueDescription: false,
         },
+        {
+            name: "moduleSuffixes",
+            type: "list",
+            element: {
+                name: "suffix",
+                type: "string",
+            },
+            listPreserveFalsyValues: true,
+            affectsModuleResolution: true,
+            category: ts.Diagnostics.Modules,
+            description: ts.Diagnostics.List_of_file_name_suffixes_to_search_when_resolving_a_module,
+        },
         // Source Maps
         {
             name: "sourceRoot",
@@ -41607,7 +41622,7 @@ var ts;
         if (option.type === "list") {
             var listOption_1 = option;
             if (listOption_1.element.isFilePath || !ts.isString(listOption_1.element.type)) {
-                return ts.filter(ts.map(value, function (v) { return normalizeOptionValue(listOption_1.element, basePath, v); }), function (v) { return !!v; });
+                return ts.filter(ts.map(value, function (v) { return normalizeOptionValue(listOption_1.element, basePath, v); }), function (v) { return listOption_1.listPreserveFalsyValues ? true : !!v; });
             }
             return value;
         }
@@ -41648,7 +41663,7 @@ var ts;
         }
     }
     function convertJsonOptionOfListType(option, values, basePath, errors) {
-        return ts.filter(ts.map(values, function (v) { return convertJsonOption(option.element, v, basePath, errors); }), function (v) { return !!v; });
+        return ts.filter(ts.map(values, function (v) { return convertJsonOption(option.element, v, basePath, errors); }), function (v) { return option.listPreserveFalsyValues ? true : !!v; });
     }
     /**
      * Tests for a path that ends in a recursive directory wildcard.
@@ -43274,6 +43289,15 @@ var ts;
     }
     /** Return the file if it exists. */
     function tryFile(fileName, onlyRecordFailures, state) {
+        var _a, _b;
+        if (!((_a = state.compilerOptions.moduleSuffixes) === null || _a === void 0 ? void 0 : _a.length)) {
+            return tryFileLookup(fileName, onlyRecordFailures, state);
+        }
+        var ext = (_b = ts.tryGetExtensionFromPath(fileName)) !== null && _b !== void 0 ? _b : "";
+        var fileNameNoExtension = ext ? ts.removeExtension(fileName, ext) : fileName;
+        return ts.forEach(state.compilerOptions.moduleSuffixes, function (suffix) { return tryFileLookup(fileNameNoExtension + suffix + ext, onlyRecordFailures, state); });
+    }
+    function tryFileLookup(fileName, onlyRecordFailures, state) {
         if (!onlyRecordFailures) {
             if (state.host.fileExists(fileName)) {
                 if (state.traceEnabled) {
@@ -47588,6 +47612,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 +47622,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 +47961,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 +47984,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 +48139,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 +49139,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 +49168,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)) {
@@ -52247,7 +52293,15 @@ var ts;
                         if (!ts.nodeIsSynthesized(node) && ts.getParseTreeNode(node) === node) {
                             return node;
                         }
-                        return ts.setTextRange(ts.factory.cloneNode(ts.visitEachChild(node, deepCloneOrReuseNode, ts.nullTransformationContext)), node);
+                        return ts.setTextRange(ts.factory.cloneNode(ts.visitEachChild(node, deepCloneOrReuseNode, ts.nullTransformationContext, deepCloneOrReuseNodes)), node);
+                    }
+                    function deepCloneOrReuseNodes(nodes, visitor, test, start, count) {
+                        if (nodes && nodes.length === 0) {
+                            // Ensure we explicitly make a copy of an empty array; visitNodes will not do this unless the array has elements,
+                            // which can lead to us reusing the same empty NodeArray more than once within the same AST during type noding.
+                            return ts.setTextRange(ts.factory.createNodeArray(/*nodes*/ undefined, nodes.hasTrailingComma), nodes);
+                        }
+                        return ts.visitNodes(nodes, visitor, test, start, count);
                     }
                 }
                 function createTypeNodeFromObjectType(type) {
@@ -55075,6 +55129,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 +55308,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 +56048,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 +56116,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 +56154,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 +56290,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 +56331,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 & 33554432 /* Transient */) {
-                var writeType = symbol.writeType;
-                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);
             }
-            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 +68436,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 +70818,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 +70910,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);
@@ -71017,7 +71031,7 @@ var ts;
                     if (func.parameters.length >= 2 && isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
                         var contextualSignature = getContextualSignature(func);
                         if (contextualSignature && contextualSignature.parameters.length === 1 && signatureHasRestParameter(contextualSignature)) {
-                            var restType = getTypeOfSymbol(contextualSignature.parameters[0]);
+                            var restType = getReducedApparentType(getTypeOfSymbol(contextualSignature.parameters[0]));
                             if (restType.flags & 1048576 /* Union */ && everyType(restType, isTupleType) && !isSymbolAssigned(symbol)) {
                                 var narrowedType = getFlowTypeOfReference(func, restType, restType, /*flowContainer*/ undefined, location.flowNode);
                                 var index = func.parameters.indexOf(declaration) - (ts.getThisParameter(func) ? 1 : 0);
@@ -71835,7 +71849,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 */) {
@@ -72322,9 +72336,14 @@ var ts;
                         return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
                     }
                     // For other purposes (e.g. determining whether to produce literal types) we only
-                    // incorporate inferences made from the return type in a function call.
+                    // incorporate inferences made from the return type in a function call. We remove
+                    // the 'boolean' type from the contextual type such that contextually typed boolean
+                    // literals actually end up widening to 'boolean' (see #48363).
                     if (inferenceContext.returnMapper) {
-                        return instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
+                        var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
+                        return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
+                            filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
+                            type;
                     }
                 }
             }
@@ -74889,7 +74908,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 +75593,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 +75694,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 +75749,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 +75765,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 +75779,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 +81847,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 +82026,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 +116945,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 +126712,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 +127813,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 +130517,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 +130560,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 +131118,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 +131159,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 +131171,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 +131202,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 +131297,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 +131395,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 +131424,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 +131435,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 +131443,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 +131524,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 +131543,7 @@ var ts;
                         name: realName,
                         kind: "warning" /* warning */,
                         kindModifiers: "",
-                        sortText: SortText.JavascriptIdentifiers,
+                        sortText: Completions.SortText.JavascriptIdentifiers,
                         isFromUncheckedFile: true
                     }, compareCompletionEntries);
                 }
@@ -131523,7 +131554,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;
@@ -131534,6 +131565,7 @@ var ts;
             var source = getSourceFromOrigin(origin);
             var sourceDisplay;
             var hasAction;
+            var labelDetails;
             var typeChecker = program.getTypeChecker();
             var insertQuestionDot = origin && originIsNullableMember(origin);
             var useBraces = origin && originIsSymbolMember(origin) || needsConvertPropertyAccess;
@@ -131594,12 +131626,25 @@ 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, labelDetails = origin.labelDetails);
+                if (!preferences.useLabelDetailsInCompletionEntries) {
+                    name = name + labelDetails.detail;
+                    labelDetails = undefined;
+                }
+                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);
@@ -131647,6 +131692,7 @@ var ts;
                 insertText: insertText,
                 replacementSpan: replacementSpan,
                 sourceDisplay: sourceDisplay,
+                labelDetails: labelDetails,
                 isSnippet: isSnippet,
                 isPackageJsonImport: originIsPackageJsonImport(origin) || undefined,
                 isImportStatementCompletion: !!importCompletionNode || undefined,
@@ -131758,27 +131804,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 +131862,113 @@ 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 signaturePrinter = ts.createPrinter({
+                removeComments: true,
+                module: options.module,
+                target: options.target,
+                omitTrailingSemicolon: true,
+            });
+            // The `labelDetails.detail` will be displayed right beside the method name,
+            // so we drop the name (and modifiers) from the signature.
+            var methodSignature = ts.factory.createMethodSignature(
+            /*modifiers*/ undefined, 
+            /*name*/ "", method.questionToken, method.typeParameters, method.parameters, method.type);
+            var labelDetails = { detail: signaturePrinter.printNode(4 /* Unspecified */, methodSignature, sourceFile) };
+            return { isSnippet: isSnippet, insertText: insertText, importAdder: importAdder, labelDetails: labelDetails };
+        }
+        ;
+        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 +131976,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 +132089,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 +132104,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 +132127,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 +132149,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 +132191,7 @@ var ts;
                             name: name,
                             kindModifiers: "" /* none */,
                             kind: "label" /* label */,
-                            sortText: SortText.LocationPriority
+                            sortText: Completions.SortText.LocationPriority
                         });
                     }
                 }
@@ -132066,7 +132217,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 +132235,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 +132319,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 +132425,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 +132670,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 +132725,7 @@ var ts;
                 contextToken: contextToken,
                 isJsxInitializer: isJsxInitializer,
                 insideJsDocTagTypeExpression: insideJsDocTagTypeExpression,
-                symbolToSortTextIdMap: symbolToSortTextIdMap,
+                symbolToSortTextMap: symbolToSortTextMap,
                 isTypeOnlyLocation: isTypeOnlyLocation,
                 isJsxIdentifierExpected: isJsxIdentifierExpected,
                 isRightOfOpenTag: isRightOfOpenTag,
@@ -132671,7 +132839,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 +132924,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 +133034,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 +133052,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 +133130,7 @@ var ts;
                 }
                 return false;
             }
-            /** Mutates `symbols`, `symbolToOriginInfoMap`, and `symbolToSortTextIdMap` */
+            /** Mutates `symbols`, `symbolToOriginInfoMap`, and `symbolToSortTextMap` */
             function collectAutoImports() {
                 var _a, _b;
                 if (!shouldOfferImportCompletions())
@@ -133044,14 +133212,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 +133394,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 +133459,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 +133543,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 +133598,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 +133934,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 +133946,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 +134036,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 +134124,7 @@ var ts;
                     name: ts.tokenToString(i),
                     kind: "keyword" /* keyword */,
                     kindModifiers: "" /* none */,
-                    sortText: SortText.GlobalsOrKeywords
+                    sortText: Completions.SortText.GlobalsOrKeywords
                 });
             }
             return res;
@@ -134019,7 +134252,7 @@ var ts;
                         name: ts.tokenToString(129 /* AssertKeyword */),
                         kind: "keyword" /* keyword */,
                         kindModifiers: "" /* none */,
-                        sortText: SortText.GlobalsOrKeywords,
+                        sortText: Completions.SortText.GlobalsOrKeywords,
                     });
                 }
             }
@@ -139212,7 +139445,8 @@ var ts;
                 return undefined;
             }
             var commentOwner = commentOwnerInfo.commentOwner, parameters = commentOwnerInfo.parameters, hasReturn = commentOwnerInfo.hasReturn;
-            if (commentOwner.getStart(sourceFile) < position) {
+            var commentOwnerJSDoc = ts.hasJSDocNodes(commentOwner) && commentOwner.jsDoc ? ts.lastOrUndefined(commentOwner.jsDoc) : undefined;
+            if (commentOwner.getStart(sourceFile) < position || commentOwnerJSDoc && commentOwnerJSDoc !== existingDocComment) {
                 return undefined;
             }
             var indentationStr = getIndentationStringAtPosition(sourceFile, position);
@@ -145947,6 +146181,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 +146213,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);
                 }
             }
@@ -147904,25 +148140,25 @@ var ts;
                     suffix: this.newLineCharacter
                 });
             };
-            ChangeTracker.prototype.insertNodeAtClassStart = function (sourceFile, cls, newElement) {
-                this.insertNodeAtStartWorker(sourceFile, cls, newElement);
+            ChangeTracker.prototype.insertMemberAtStart = function (sourceFile, node, newElement) {
+                this.insertNodeAtStartWorker(sourceFile, node, newElement);
             };
             ChangeTracker.prototype.insertNodeAtObjectStart = function (sourceFile, obj, newElement) {
                 this.insertNodeAtStartWorker(sourceFile, obj, newElement);
             };
-            ChangeTracker.prototype.insertNodeAtStartWorker = function (sourceFile, cls, newElement) {
+            ChangeTracker.prototype.insertNodeAtStartWorker = function (sourceFile, node, newElement) {
                 var _a;
-                var indentation = (_a = this.guessIndentationFromExistingMembers(sourceFile, cls)) !== null && _a !== void 0 ? _a : this.computeIndentationForNewMember(sourceFile, cls);
-                this.insertNodeAt(sourceFile, getMembersOrProperties(cls).pos, newElement, this.getInsertNodeAtStartInsertOptions(sourceFile, cls, indentation));
+                var indentation = (_a = this.guessIndentationFromExistingMembers(sourceFile, node)) !== null && _a !== void 0 ? _a : this.computeIndentationForNewMember(sourceFile, node);
+                this.insertNodeAt(sourceFile, getMembersOrProperties(node).pos, newElement, this.getInsertNodeAtStartInsertOptions(sourceFile, node, indentation));
             };
             /**
              * Tries to guess the indentation from the existing members of a class/interface/object. All members must be on
              * new lines and must share the same indentation.
              */
-            ChangeTracker.prototype.guessIndentationFromExistingMembers = function (sourceFile, cls) {
+            ChangeTracker.prototype.guessIndentationFromExistingMembers = function (sourceFile, node) {
                 var indentation;
-                var lastRange = cls;
-                for (var _i = 0, _a = getMembersOrProperties(cls); _i < _a.length; _i++) {
+                var lastRange = node;
+                for (var _i = 0, _a = getMembersOrProperties(node); _i < _a.length; _i++) {
                     var member = _a[_i];
                     if (ts.rangeStartPositionsAreOnSameLine(lastRange, member, sourceFile)) {
                         // each indented member must be on a new line
@@ -147941,13 +148177,13 @@ var ts;
                 }
                 return indentation;
             };
-            ChangeTracker.prototype.computeIndentationForNewMember = function (sourceFile, cls) {
+            ChangeTracker.prototype.computeIndentationForNewMember = function (sourceFile, node) {
                 var _a;
-                var clsStart = cls.getStart(sourceFile);
-                return ts.formatting.SmartIndenter.findFirstNonWhitespaceColumn(ts.getLineStartPositionForPosition(clsStart, sourceFile), clsStart, sourceFile, this.formatContext.options)
+                var nodeStart = node.getStart(sourceFile);
+                return ts.formatting.SmartIndenter.findFirstNonWhitespaceColumn(ts.getLineStartPositionForPosition(nodeStart, sourceFile), nodeStart, sourceFile, this.formatContext.options)
                     + ((_a = this.formatContext.options.indentSize) !== null && _a !== void 0 ? _a : 4);
             };
-            ChangeTracker.prototype.getInsertNodeAtStartInsertOptions = function (sourceFile, cls, indentation) {
+            ChangeTracker.prototype.getInsertNodeAtStartInsertOptions = function (sourceFile, node, indentation) {
                 // Rules:
                 // - Always insert leading newline.
                 // - For object literals:
@@ -147957,11 +148193,11 @@ var ts;
                 //     and the node is empty (because we didn't add a trailing comma per the previous rule).
                 // - Only insert a trailing newline if body is single-line and there are no other insertions for the node.
                 //   NOTE: This is handled in `finishClassesWithNodesInsertedAtStart`.
-                var members = getMembersOrProperties(cls);
+                var members = getMembersOrProperties(node);
                 var isEmpty = members.length === 0;
-                var isFirstInsertion = ts.addToSeen(this.classesWithNodesInsertedAtStart, ts.getNodeId(cls), { node: cls, sourceFile: sourceFile });
-                var insertTrailingComma = ts.isObjectLiteralExpression(cls) && (!ts.isJsonSourceFile(sourceFile) || !isEmpty);
-                var insertLeadingComma = ts.isObjectLiteralExpression(cls) && ts.isJsonSourceFile(sourceFile) && isEmpty && !isFirstInsertion;
+                var isFirstInsertion = ts.addToSeen(this.classesWithNodesInsertedAtStart, ts.getNodeId(node), { node: node, sourceFile: sourceFile });
+                var insertTrailingComma = ts.isObjectLiteralExpression(node) && (!ts.isJsonSourceFile(sourceFile) || !isEmpty);
+                var insertLeadingComma = ts.isObjectLiteralExpression(node) && ts.isJsonSourceFile(sourceFile) && isEmpty && !isFirstInsertion;
                 return {
                     indentation: indentation,
                     prefix: (insertLeadingComma ? "," : "") + this.newLineCharacter,
@@ -148255,8 +148491,8 @@ var ts;
             var close = ts.findChildOfKind(cls, 19 /* CloseBraceToken */, sourceFile);
             return [open === null || open === void 0 ? void 0 : open.end, close === null || close === void 0 ? void 0 : close.end];
         }
-        function getMembersOrProperties(cls) {
-            return ts.isObjectLiteralExpression(cls) ? cls.properties : cls.members;
+        function getMembersOrProperties(node) {
+            return ts.isObjectLiteralExpression(node) ? node.properties : node.members;
         }
         function getNewFileText(statements, scriptKind, newLineCharacter, formatContext) {
             return changesToText.newFileChangesWorker(/*oldFile*/ undefined, scriptKind, statements, newLineCharacter, formatContext);
@@ -151539,7 +151775,7 @@ var ts;
                     changeTracker.insertNodeAfter(sourceFile, constructor, newElement);
                 }
                 else {
-                    changeTracker.insertNodeAtClassStart(sourceFile, cls, newElement);
+                    changeTracker.insertMemberAtStart(sourceFile, cls, newElement);
                 }
             }
         }
@@ -153323,7 +153559,7 @@ var ts;
                     var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addFunctionDeclaration(t, context, info); });
                     return [codefix.createCodeFixAction(fixMissingFunctionDeclaration, changes, [ts.Diagnostics.Add_missing_function_declaration_0, info.token.text], fixMissingFunctionDeclaration, ts.Diagnostics.Add_all_missing_function_declarations)];
                 }
-                if (info.kind === 0 /* Enum */) {
+                if (info.kind === 1 /* Enum */) {
                     var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addEnumMemberDeclaration(t, context.program.getTypeChecker(), info); });
                     return [codefix.createCodeFixAction(fixMissingMember, changes, [ts.Diagnostics.Add_missing_enum_member_0, info.token.text], fixMissingMember, ts.Diagnostics.Add_all_missing_members)];
                 }
@@ -153351,10 +153587,10 @@ var ts;
                             addJsxAttributes(changes, context, info);
                         }
                         else {
-                            if (info.kind === 0 /* Enum */) {
+                            if (info.kind === 1 /* Enum */) {
                                 addEnumMemberDeclaration(changes, checker, info);
                             }
-                            if (info.kind === 1 /* ClassOrInterface */) {
+                            if (info.kind === 0 /* TypeLikeDeclaration */) {
                                 var parentDeclaration = info.parentDeclaration, token_1 = info.token;
                                 var infos = ts.getOrUpdate(typeDeclToMembers, parentDeclaration, function () { return []; });
                                 if (!infos.some(function (i) { return i.token.text === token_1.text; })) {
@@ -153363,11 +153599,11 @@ var ts;
                             }
                         }
                     });
-                    typeDeclToMembers.forEach(function (infos, classDeclaration) {
-                        var supers = codefix.getAllSupers(classDeclaration, checker);
+                    typeDeclToMembers.forEach(function (infos, declaration) {
+                        var supers = ts.isTypeLiteralNode(declaration) ? undefined : codefix.getAllSupers(declaration, checker);
                         var _loop_15 = function (info) {
                             // If some superclass added this property, don't add it again.
-                            if (supers.some(function (superClassOrInterface) {
+                            if (supers === null || supers === void 0 ? void 0 : supers.some(function (superClassOrInterface) {
                                 var superInfos = typeDeclToMembers.get(superClassOrInterface);
                                 return !!superInfos && superInfos.some(function (_a) {
                                     var token = _a.token;
@@ -153381,11 +153617,11 @@ var ts;
                                 addMethodDeclaration(context, changes, call, token, modifierFlags & 32 /* Static */, parentDeclaration, declSourceFile);
                             }
                             else {
-                                if (isJSFile && !ts.isInterfaceDeclaration(parentDeclaration)) {
+                                if (isJSFile && !ts.isInterfaceDeclaration(parentDeclaration) && !ts.isTypeLiteralNode(parentDeclaration)) {
                                     addMissingMemberInJs(changes, declSourceFile, parentDeclaration, token, !!(modifierFlags & 32 /* Static */));
                                 }
                                 else {
-                                    var typeNode = getTypeNode(program.getTypeChecker(), parentDeclaration, token);
+                                    var typeNode = getTypeNode(checker, parentDeclaration, token);
                                     addPropertyDeclaration(changes, declSourceFile, parentDeclaration, token.text, typeNode, modifierFlags & 32 /* Static */);
                                 }
                             }
@@ -153400,8 +153636,8 @@ var ts;
         });
         var InfoKind;
         (function (InfoKind) {
-            InfoKind[InfoKind["Enum"] = 0] = "Enum";
-            InfoKind[InfoKind["ClassOrInterface"] = 1] = "ClassOrInterface";
+            InfoKind[InfoKind["TypeLikeDeclaration"] = 0] = "TypeLikeDeclaration";
+            InfoKind[InfoKind["Enum"] = 1] = "Enum";
             InfoKind[InfoKind["Function"] = 2] = "Function";
             InfoKind[InfoKind["ObjectLiteral"] = 3] = "ObjectLiteral";
             InfoKind[InfoKind["JsxAttributes"] = 4] = "JsxAttributes";
@@ -153471,20 +153707,21 @@ var ts;
             if (!classDeclaration && ts.isPrivateIdentifier(token))
                 return undefined;
             // Prefer to change the class instead of the interface if they are merged
-            var classOrInterface = classDeclaration || ts.find(symbol.declarations, ts.isInterfaceDeclaration);
-            if (classOrInterface && !isSourceFileFromLibrary(program, classOrInterface.getSourceFile())) {
-                var makeStatic = (leftExpressionType.target || leftExpressionType) !== checker.getDeclaredTypeOfSymbol(symbol);
-                if (makeStatic && (ts.isPrivateIdentifier(token) || ts.isInterfaceDeclaration(classOrInterface)))
+            var declaration = classDeclaration || ts.find(symbol.declarations, function (d) { return ts.isInterfaceDeclaration(d) || ts.isTypeLiteralNode(d); });
+            if (declaration && !isSourceFileFromLibrary(program, declaration.getSourceFile())) {
+                var makeStatic = !ts.isTypeLiteralNode(declaration) && (leftExpressionType.target || leftExpressionType) !== checker.getDeclaredTypeOfSymbol(symbol);
+                if (makeStatic && (ts.isPrivateIdentifier(token) || ts.isInterfaceDeclaration(declaration)))
                     return undefined;
-                var declSourceFile = classOrInterface.getSourceFile();
-                var modifierFlags = (makeStatic ? 32 /* Static */ : 0) | (ts.startsWithUnderscore(token.text) ? 8 /* Private */ : 0);
+                var declSourceFile = declaration.getSourceFile();
+                var modifierFlags = ts.isTypeLiteralNode(declaration) ? 0 /* None */ :
+                    (makeStatic ? 32 /* Static */ : 0 /* None */) | (ts.startsWithUnderscore(token.text) ? 8 /* Private */ : 0 /* None */);
                 var isJSFile = ts.isSourceFileJS(declSourceFile);
                 var call = ts.tryCast(parent.parent, ts.isCallExpression);
-                return { kind: 1 /* ClassOrInterface */, token: token, call: call, modifierFlags: modifierFlags, parentDeclaration: classOrInterface, declSourceFile: declSourceFile, isJSFile: isJSFile };
+                return { kind: 0 /* TypeLikeDeclaration */, token: token, call: call, modifierFlags: modifierFlags, parentDeclaration: declaration, declSourceFile: declSourceFile, isJSFile: isJSFile };
             }
             var enumDeclaration = ts.find(symbol.declarations, ts.isEnumDeclaration);
             if (enumDeclaration && !ts.isPrivateIdentifier(token) && !isSourceFileFromLibrary(program, enumDeclaration.getSourceFile())) {
-                return { kind: 0 /* Enum */, token: token, parentDeclaration: enumDeclaration };
+                return { kind: 1 /* Enum */, token: token, parentDeclaration: enumDeclaration };
             }
             return undefined;
         }
@@ -153497,7 +153734,7 @@ var ts;
         }
         function createActionForAddMissingMemberInJavascriptFile(context, _a) {
             var parentDeclaration = _a.parentDeclaration, declSourceFile = _a.declSourceFile, modifierFlags = _a.modifierFlags, token = _a.token;
-            if (ts.isInterfaceDeclaration(parentDeclaration)) {
+            if (ts.isInterfaceDeclaration(parentDeclaration) || ts.isTypeLiteralNode(parentDeclaration)) {
                 return undefined;
             }
             var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingMemberInJs(t, declSourceFile, parentDeclaration, token, !!(modifierFlags & 32 /* Static */)); });
@@ -153508,7 +153745,7 @@ var ts;
                 ts.isPrivateIdentifier(token) ? ts.Diagnostics.Declare_a_private_field_named_0 : ts.Diagnostics.Initialize_property_0_in_the_constructor;
             return codefix.createCodeFixAction(fixMissingMember, changes, [diagnostic, token.text], fixMissingMember, ts.Diagnostics.Add_all_missing_members);
         }
-        function addMissingMemberInJs(changeTracker, declSourceFile, classDeclaration, token, makeStatic) {
+        function addMissingMemberInJs(changeTracker, sourceFile, classDeclaration, token, makeStatic) {
             var tokenName = token.text;
             if (makeStatic) {
                 if (classDeclaration.kind === 226 /* ClassExpression */) {
@@ -153516,7 +153753,7 @@ var ts;
                 }
                 var className = classDeclaration.name.getText();
                 var staticInitialization = initializePropertyToUndefined(ts.factory.createIdentifier(className), tokenName);
-                changeTracker.insertNodeAfter(declSourceFile, classDeclaration, staticInitialization);
+                changeTracker.insertNodeAfter(sourceFile, classDeclaration, staticInitialization);
             }
             else if (ts.isPrivateIdentifier(token)) {
                 var property = ts.factory.createPropertyDeclaration(
@@ -153527,10 +153764,10 @@ var ts;
                 /*initializer*/ undefined);
                 var lastProp = getNodeToInsertPropertyAfter(classDeclaration);
                 if (lastProp) {
-                    changeTracker.insertNodeAfter(declSourceFile, lastProp, property);
+                    changeTracker.insertNodeAfter(sourceFile, lastProp, property);
                 }
                 else {
-                    changeTracker.insertNodeAtClassStart(declSourceFile, classDeclaration, property);
+                    changeTracker.insertMemberAtStart(sourceFile, classDeclaration, property);
                 }
             }
             else {
@@ -153539,7 +153776,7 @@ var ts;
                     return;
                 }
                 var propertyInitialization = initializePropertyToUndefined(ts.factory.createThis(), tokenName);
-                changeTracker.insertNodeAtConstructorEnd(declSourceFile, classConstructor, propertyInitialization);
+                changeTracker.insertNodeAtConstructorEnd(sourceFile, classConstructor, propertyInitialization);
             }
         }
         function initializePropertyToUndefined(obj, propertyName) {
@@ -153561,13 +153798,13 @@ var ts;
             actions.push(createAddIndexSignatureAction(context, declSourceFile, parentDeclaration, token.text, typeNode));
             return actions;
         }
-        function getTypeNode(checker, classDeclaration, token) {
+        function getTypeNode(checker, node, token) {
             var typeNode;
             if (token.parent.parent.kind === 221 /* BinaryExpression */) {
                 var binaryExpression = token.parent.parent;
                 var otherExpression = token.parent === binaryExpression.left ? binaryExpression.right : binaryExpression.left;
                 var widenedType = checker.getWidenedType(checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(otherExpression)));
-                typeNode = checker.typeToTypeNode(widenedType, classDeclaration, 1 /* NoTruncation */);
+                typeNode = checker.typeToTypeNode(widenedType, node, 1 /* NoTruncation */);
             }
             else {
                 var contextualType = checker.getContextualType(token.parent);
@@ -153575,24 +153812,23 @@ var ts;
             }
             return typeNode || ts.factory.createKeywordTypeNode(130 /* AnyKeyword */);
         }
-        function addPropertyDeclaration(changeTracker, declSourceFile, classDeclaration, tokenName, typeNode, modifierFlags) {
-            var property = ts.factory.createPropertyDeclaration(
-            /*decorators*/ undefined, 
-            /*modifiers*/ modifierFlags ? ts.factory.createNodeArray(ts.factory.createModifiersFromModifierFlags(modifierFlags)) : undefined, tokenName, 
-            /*questionToken*/ undefined, typeNode, 
-            /*initializer*/ undefined);
-            var lastProp = getNodeToInsertPropertyAfter(classDeclaration);
+        function addPropertyDeclaration(changeTracker, sourceFile, node, tokenName, typeNode, modifierFlags) {
+            var modifiers = modifierFlags ? ts.factory.createNodeArray(ts.factory.createModifiersFromModifierFlags(modifierFlags)) : undefined;
+            var property = ts.isClassLike(node)
+                ? ts.factory.createPropertyDeclaration(/*decorators*/ undefined, modifiers, tokenName, /*questionToken*/ undefined, typeNode, /*initializer*/ undefined)
+                : ts.factory.createPropertySignature(/*modifiers*/ undefined, tokenName, /*questionToken*/ undefined, typeNode);
+            var lastProp = getNodeToInsertPropertyAfter(node);
             if (lastProp) {
-                changeTracker.insertNodeAfter(declSourceFile, lastProp, property);
+                changeTracker.insertNodeAfter(sourceFile, lastProp, property);
             }
             else {
-                changeTracker.insertNodeAtClassStart(declSourceFile, classDeclaration, property);
+                changeTracker.insertMemberAtStart(sourceFile, node, property);
             }
         }
         // Gets the last of the first run of PropertyDeclarations, or undefined if the class does not start with a PropertyDeclaration.
-        function getNodeToInsertPropertyAfter(cls) {
+        function getNodeToInsertPropertyAfter(node) {
             var res;
-            for (var _i = 0, _a = cls.members; _i < _a.length; _i++) {
+            for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
                 if (!ts.isPropertyDeclaration(member))
                     break;
@@ -153600,7 +153836,7 @@ var ts;
             }
             return res;
         }
-        function createAddIndexSignatureAction(context, declSourceFile, classDeclaration, tokenName, typeNode) {
+        function createAddIndexSignatureAction(context, sourceFile, node, tokenName, typeNode) {
             // Index signatures cannot have the static modifier.
             var stringTypeNode = ts.factory.createKeywordTypeNode(150 /* StringKeyword */);
             var indexingParameter = ts.factory.createParameterDeclaration(
@@ -153612,7 +153848,7 @@ var ts;
             var indexSignature = ts.factory.createIndexSignature(
             /*decorators*/ undefined, 
             /*modifiers*/ undefined, [indexingParameter], typeNode);
-            var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return t.insertNodeAtClassStart(declSourceFile, classDeclaration, indexSignature); });
+            var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return t.insertMemberAtStart(sourceFile, node, indexSignature); });
             // No fixId here because code-fix-all currently only works on adding individual named properties.
             return codefix.createCodeFixActionWithoutFixAll(fixMissingMember, changes, [ts.Diagnostics.Add_index_signature_for_property_0, tokenName]);
         }
@@ -153635,13 +153871,14 @@ var ts;
         }
         function addMethodDeclaration(context, changes, callExpression, name, modifierFlags, parentDeclaration, sourceFile) {
             var importAdder = codefix.createImportAdder(sourceFile, context.program, context.preferences, context.host);
-            var methodDeclaration = codefix.createSignatureDeclarationFromCallExpression(169 /* MethodDeclaration */, context, importAdder, callExpression, name, modifierFlags, parentDeclaration);
-            var containingMethodDeclaration = ts.findAncestor(callExpression, function (n) { return ts.isMethodDeclaration(n) || ts.isConstructorDeclaration(n); });
-            if (containingMethodDeclaration && containingMethodDeclaration.parent === parentDeclaration) {
-                changes.insertNodeAfter(sourceFile, containingMethodDeclaration, methodDeclaration);
+            var kind = ts.isClassLike(parentDeclaration) ? 169 /* MethodDeclaration */ : 168 /* MethodSignature */;
+            var signatureDeclaration = codefix.createSignatureDeclarationFromCallExpression(kind, context, importAdder, callExpression, name, modifierFlags, parentDeclaration);
+            var containingMethodDeclaration = tryGetContainingMethodDeclaration(parentDeclaration, callExpression);
+            if (containingMethodDeclaration) {
+                changes.insertNodeAfter(sourceFile, containingMethodDeclaration, signatureDeclaration);
             }
             else {
-                changes.insertNodeAtClassStart(sourceFile, parentDeclaration, methodDeclaration);
+                changes.insertMemberAtStart(sourceFile, parentDeclaration, signatureDeclaration);
             }
             importAdder.writeFixes(changes);
         }
@@ -153804,6 +154041,13 @@ var ts;
                 return ts.isIdentifierText(targetProp.name, target, 1 /* JSX */) && !((targetProp.flags & 16777216 /* Optional */ || ts.getCheckFlags(targetProp) & 48 /* Partial */) || seenNames.has(targetProp.escapedName));
             });
         }
+        function tryGetContainingMethodDeclaration(node, callExpression) {
+            if (ts.isTypeLiteralNode(node)) {
+                return undefined;
+            }
+            var declaration = ts.findAncestor(callExpression, function (n) { return ts.isMethodDeclaration(n) || ts.isConstructorDeclaration(n); });
+            return declaration && declaration.parent === node ? declaration : undefined;
+        }
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
 /* @internal */
@@ -153947,7 +154191,7 @@ var ts;
             // so duplicates cannot occur.
             var abstractAndNonPrivateExtendsSymbols = checker.getPropertiesOfType(instantiatedExtendsType).filter(symbolPointsToNonPrivateAndAbstractMember);
             var importAdder = codefix.createImportAdder(sourceFile, context.program, preferences, context.host);
-            codefix.createMissingMemberNodes(classDeclaration, abstractAndNonPrivateExtendsSymbols, sourceFile, context, preferences, importAdder, function (member) { return changeTracker.insertNodeAtClassStart(sourceFile, classDeclaration, member); });
+            codefix.createMissingMemberNodes(classDeclaration, abstractAndNonPrivateExtendsSymbols, sourceFile, context, preferences, importAdder, function (member) { return changeTracker.insertMemberAtStart(sourceFile, classDeclaration, member); });
             importAdder.writeFixes(changeTracker);
         }
         function symbolPointsToNonPrivateAndAbstractMember(symbol) {
@@ -156520,13 +156764,20 @@ var ts;
             var type = isJs || contextualType === undefined
                 ? undefined
                 : checker.typeToTypeNode(contextualType, contextNode, /*flags*/ undefined, tracker);
-            if (kind === 169 /* MethodDeclaration */) {
-                return ts.factory.createMethodDeclaration(
-                /*decorators*/ undefined, modifiers, asteriskToken, name, 
-                /*questionToken*/ undefined, typeParameters, parameters, type, ts.isInterfaceDeclaration(contextNode) ? undefined : createStubbedMethodBody(quotePreference));
+            switch (kind) {
+                case 169 /* MethodDeclaration */:
+                    return ts.factory.createMethodDeclaration(
+                    /*decorators*/ undefined, modifiers, asteriskToken, name, 
+                    /*questionToken*/ undefined, typeParameters, parameters, type, createStubbedMethodBody(quotePreference));
+                case 168 /* MethodSignature */:
+                    return ts.factory.createMethodSignature(modifiers, name, 
+                    /*questionToken*/ undefined, typeParameters, parameters, type);
+                case 256 /* FunctionDeclaration */:
+                    return ts.factory.createFunctionDeclaration(
+                    /*decorators*/ undefined, modifiers, asteriskToken, name, typeParameters, parameters, type, createStubbedBody(ts.Diagnostics.Function_not_implemented.message, quotePreference));
+                default:
+                    ts.Debug.fail("Unexpected kind");
             }
-            return ts.factory.createFunctionDeclaration(
-            /*decorators*/ undefined, modifiers, asteriskToken, name, typeParameters, parameters, type, createStubbedBody(ts.Diagnostics.Function_not_implemented.message, quotePreference));
         }
         codefix.createSignatureDeclarationFromCallExpression = createSignatureDeclarationFromCallExpression;
         function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, tracker) {
@@ -156852,7 +157103,7 @@ var ts;
             }
         }
         function insertAccessor(changeTracker, file, accessor, declaration, container) {
-            ts.isParameterPropertyDeclaration(declaration, declaration.parent) ? changeTracker.insertNodeAtClassStart(file, container, accessor) :
+            ts.isParameterPropertyDeclaration(declaration, declaration.parent) ? changeTracker.insertMemberAtStart(file, container, accessor) :
                 ts.isPropertyAssignment(declaration) ? changeTracker.insertNodeAfterComma(file, declaration, accessor) :
                     changeTracker.insertNodeAfter(file, declaration, accessor);
         }
@@ -175045,10 +175296,26 @@ var ts;
                 var prefix = args.prefix || "";
                 var entries = ts.mapDefined(completions.entries, function (entry) {
                     if (completions.isMemberCompletion || ts.startsWith(entry.name.toLowerCase(), prefix.toLowerCase())) {
-                        var name = entry.name, kind_1 = entry.kind, kindModifiers = entry.kindModifiers, sortText = entry.sortText, insertText = entry.insertText, replacementSpan = entry.replacementSpan, hasAction = entry.hasAction, source = entry.source, sourceDisplay = entry.sourceDisplay, isSnippet = entry.isSnippet, isRecommended = entry.isRecommended, isPackageJsonImport = entry.isPackageJsonImport, isImportStatementCompletion = entry.isImportStatementCompletion, data = entry.data;
+                        var name = entry.name, kind_1 = entry.kind, kindModifiers = entry.kindModifiers, sortText = entry.sortText, insertText = entry.insertText, replacementSpan = entry.replacementSpan, hasAction = entry.hasAction, source = entry.source, sourceDisplay = entry.sourceDisplay, labelDetails = entry.labelDetails, isSnippet = entry.isSnippet, isRecommended = entry.isRecommended, isPackageJsonImport = entry.isPackageJsonImport, isImportStatementCompletion = entry.isImportStatementCompletion, data = entry.data;
                         var convertedSpan = replacementSpan ? toProtocolTextSpan(replacementSpan, scriptInfo) : undefined;
                         // Use `hasAction || undefined` to avoid serializing `false`.
-                        return { name: name, kind: kind_1, kindModifiers: kindModifiers, sortText: sortText, insertText: insertText, replacementSpan: convertedSpan, isSnippet: isSnippet, hasAction: hasAction || undefined, source: source, sourceDisplay: sourceDisplay, isRecommended: isRecommended, isPackageJsonImport: isPackageJsonImport, isImportStatementCompletion: isImportStatementCompletion, data: data };
+                        return {
+                            name: name,
+                            kind: kind_1,
+                            kindModifiers: kindModifiers,
+                            sortText: sortText,
+                            insertText: insertText,
+                            replacementSpan: convertedSpan,
+                            isSnippet: isSnippet,
+                            hasAction: hasAction || undefined,
+                            source: source,
+                            sourceDisplay: sourceDisplay,
+                            labelDetails: labelDetails,
+                            isRecommended: isRecommended,
+                            isPackageJsonImport: isPackageJsonImport,
+                            isImportStatementCompletion: isImportStatementCompletion,
+                            data: data
+                        };
                     }
                 });
                 if (kind === "completions" /* Completions */) {