typescript 4.7.0-dev.20220330 → 4.7.0-dev.20220402

package/lib/typescript.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.20220330";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220402";
     /* @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."),
@@ -39683,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",
@@ -41609,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;
         }
@@ -41650,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.
@@ -43276,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) {
@@ -52271,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) {
@@ -71001,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);
@@ -72306,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;
                     }
                 }
             }
@@ -111317,6 +111352,7 @@ var ts;
                 writeLine();
                 decreaseIndent();
             }
+            emitList(node, node.members, 2 /* PreserveLines */);
             writePunctuation("}");
         }
         function emitLiteralType(node) {
@@ -131530,6 +131566,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;
@@ -131598,7 +131635,11 @@ var ts;
             }
             if (origin && originIsObjectLiteralMethod(origin)) {
                 var importAdder = void 0;
-                (insertText = origin.insertText, isSnippet = origin.isSnippet, importAdder = origin.importAdder, sourceDisplay = origin.sourceDisplay);
+                (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()) {
@@ -131652,6 +131693,7 @@ var ts;
                 insertText: insertText,
                 replacementSpan: replacementSpan,
                 sourceDisplay: sourceDisplay,
+                labelDetails: labelDetails,
                 isSnippet: isSnippet,
                 isPackageJsonImport: originIsPackageJsonImport(origin) || undefined,
                 isImportStatementCompletion: !!importCompletionNode || undefined,
@@ -131843,9 +131885,19 @@ var ts;
             else {
                 insertText = printer.printSnippetList(16 /* CommaDelimited */ | 64 /* AllowTrailingComma */, ts.factory.createNodeArray([method], /*hasTrailingComma*/ true), sourceFile);
             }
-            var methodSignature = ts.factory.createMethodSignature(method.modifiers, method.name, method.questionToken, method.typeParameters, method.parameters, method.type);
-            var sourceDisplay = ts.nodeToDisplayParts(methodSignature, enclosingDeclaration);
-            return { isSnippet: isSnippet, insertText: insertText, importAdder: importAdder, sourceDisplay: sourceDisplay };
+            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) {
@@ -136015,9 +136067,10 @@ var ts;
         })(FindReferencesUse = FindAllReferences.FindReferencesUse || (FindAllReferences.FindReferencesUse = {}));
         function findReferencedSymbols(program, cancellationToken, sourceFiles, sourceFile, position) {
             var node = ts.getTouchingPropertyName(sourceFile, position);
-            var referencedSymbols = Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, { use: 1 /* References */ });
+            var options = { use: 1 /* References */ };
+            var referencedSymbols = Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options);
             var checker = program.getTypeChecker();
-            var symbol = checker.getSymbolAtLocation(node);
+            var symbol = checker.getSymbolAtLocation(ts.getAdjustedReferenceLocation(Core.getAdjustedNode(node, options)));
             return !referencedSymbols || !referencedSymbols.length ? undefined : ts.mapDefined(referencedSymbols, function (_a) {
                 var definition = _a.definition, references = _a.references;
                 // Only include referenced symbols that have a valid definition.
@@ -136362,12 +136415,7 @@ var ts;
                 var _a, _b;
                 if (options === void 0) { options = {}; }
                 if (sourceFilesSet === void 0) { sourceFilesSet = new ts.Set(sourceFiles.map(function (f) { return f.fileName; })); }
-                if (options.use === 1 /* References */) {
-                    node = ts.getAdjustedReferenceLocation(node);
-                }
-                else if (options.use === 2 /* Rename */) {
-                    node = ts.getAdjustedRenameLocation(node);
-                }
+                node = getAdjustedNode(node, options);
                 if (ts.isSourceFile(node)) {
                     var resolvedRef = ts.GoToDefinition.getReferenceAtPosition(node, position, program);
                     if (!(resolvedRef === null || resolvedRef === void 0 ? void 0 : resolvedRef.file)) {
@@ -136428,6 +136476,16 @@ var ts;
                 return mergeReferences(program, moduleReferences, references, moduleReferencesOfExportTarget);
             }
             Core.getReferencedSymbolsForNode = getReferencedSymbolsForNode;
+            function getAdjustedNode(node, options) {
+                if (options.use === 1 /* References */) {
+                    node = ts.getAdjustedReferenceLocation(node);
+                }
+                else if (options.use === 2 /* Rename */) {
+                    node = ts.getAdjustedRenameLocation(node);
+                }
+                return node;
+            }
+            Core.getAdjustedNode = getAdjustedNode;
             function getReferencesForFileName(fileName, program, sourceFiles, sourceFilesSet) {
                 var _a, _b;
                 if (sourceFilesSet === void 0) { sourceFilesSet = new ts.Set(sourceFiles.map(function (f) { return f.fileName; })); }
@@ -139394,7 +139452,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);
@@ -148088,25 +148147,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
@@ -148125,13 +148184,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:
@@ -148141,11 +148200,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,
@@ -148439,8 +148498,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);
@@ -151723,7 +151782,7 @@ var ts;
                     changeTracker.insertNodeAfter(sourceFile, constructor, newElement);
                 }
                 else {
-                    changeTracker.insertNodeAtClassStart(sourceFile, cls, newElement);
+                    changeTracker.insertMemberAtStart(sourceFile, cls, newElement);
                 }
             }
         }
@@ -153507,7 +153566,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)];
                 }
@@ -153535,10 +153594,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; })) {
@@ -153547,11 +153606,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;
@@ -153565,11 +153624,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 */);
                                 }
                             }
@@ -153584,8 +153643,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";
@@ -153655,20 +153714,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;
         }
@@ -153681,7 +153741,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 */)); });
@@ -153692,7 +153752,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 */) {
@@ -153700,7 +153760,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(
@@ -153711,10 +153771,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 {
@@ -153723,7 +153783,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) {
@@ -153745,13 +153805,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);
@@ -153759,24 +153819,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;
@@ -153784,7 +153843,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(
@@ -153796,7 +153855,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]);
         }
@@ -153819,13 +153878,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);
         }
@@ -153988,6 +154048,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 */
@@ -154131,7 +154198,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) {
@@ -156704,13 +156771,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) {
@@ -157036,7 +157110,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);
         }