typescript 4.6.0-dev.20220210 → 4.6.0-dev.20220211

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.20220210";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220211";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8274,6 +8274,7 @@ var ts;
         An_optional_element_cannot_follow_a_rest_element: diag(1266, ts.DiagnosticCategory.Error, "An_optional_element_cannot_follow_a_rest_element_1266", "An optional element cannot follow a rest element."),
         Property_0_cannot_have_an_initializer_because_it_is_marked_abstract: diag(1267, ts.DiagnosticCategory.Error, "Property_0_cannot_have_an_initializer_because_it_is_marked_abstract_1267", "Property '{0}' cannot have an initializer because it is marked abstract."),
         An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type: diag(1268, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type_1268", "An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type."),
+        Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided: diag(1269, ts.DiagnosticCategory.Error, "Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided_1269", "Cannot use 'export import' on a type or type-only namespace when the '--isolatedModules' flag is provided."),
         with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
         await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
         Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern: diag(1312, ts.DiagnosticCategory.Error, "Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_1312", "Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern."),
@@ -9832,6 +9833,9 @@ var ts;
         Add_all_missing_attributes: diag(95168, ts.DiagnosticCategory.Message, "Add_all_missing_attributes_95168", "Add all missing attributes"),
         Add_undefined_to_optional_property_type: diag(95169, ts.DiagnosticCategory.Message, "Add_undefined_to_optional_property_type_95169", "Add 'undefined' to optional property type"),
         Convert_named_imports_to_default_import: diag(95170, ts.DiagnosticCategory.Message, "Convert_named_imports_to_default_import_95170", "Convert named imports to default import"),
+        Delete_unused_param_tag_0: diag(95171, ts.DiagnosticCategory.Message, "Delete_unused_param_tag_0_95171", "Delete unused '@param' tag '{0}'"),
+        Delete_all_unused_param_tags: diag(95172, ts.DiagnosticCategory.Message, "Delete_all_unused_param_tags_95172", "Delete all unused '@param' tags"),
+        Rename_param_tag_name_0_to_1: diag(95173, ts.DiagnosticCategory.Message, "Rename_param_tag_name_0_to_1_95173", "Rename '@param' tag name '{0}' to '{1}'"),
         No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, ts.DiagnosticCategory.Error, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
         Classes_may_not_have_a_field_named_constructor: diag(18006, ts.DiagnosticCategory.Error, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
         JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, ts.DiagnosticCategory.Error, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -54829,12 +54833,9 @@ var ts;
                     }
                 }
                 if (ts.isInJSFile(declaration)) {
-                    var typeTag = ts.getJSDocType(func);
-                    if (typeTag && ts.isFunctionTypeNode(typeTag)) {
-                        var signature = getSignatureFromDeclaration(typeTag);
-                        var pos = func.parameters.indexOf(declaration);
-                        return declaration.dotDotDotToken ? getRestTypeAtPosition(signature, pos) : getTypeAtPosition(signature, pos);
-                    }
+                    var type_1 = getParameterTypeOfTypeTag(func, declaration);
+                    if (type_1)
+                        return type_1;
                 }
                 // Use contextual parameter type if one is available
                 var type = declaration.symbol.escapedName === "this" /* This */ ? getContextualThisParameterType(func) : getContextuallyTypedParameterType(declaration);
@@ -55401,9 +55402,9 @@ var ts;
                 if (typeNode === undefined) {
                     return useUnknownInCatchVariables ? unknownType : anyType;
                 }
-                var type_1 = getTypeOfNode(typeNode);
+                var type_2 = getTypeOfNode(typeNode);
                 // an errorType will make `checkTryStatement` issue an error
-                return isTypeAny(type_1) || type_1 === unknownType ? type_1 : errorType;
+                return isTypeAny(type_2) || type_2 === unknownType ? type_2 : errorType;
             }
             // Handle export default expressions
             if (ts.isSourceFile(declaration) && ts.isJsonSourceFile(declaration)) {
@@ -55632,11 +55633,11 @@ var ts;
                         return errorType;
                     }
                     var exportEquals = getMergedSymbol(symbol.exports.get("export=" /* ExportEquals */));
-                    var type_2 = getWidenedTypeForAssignmentDeclaration(exportEquals, exportEquals === resolvedModule ? undefined : resolvedModule);
+                    var type_3 = getWidenedTypeForAssignmentDeclaration(exportEquals, exportEquals === resolvedModule ? undefined : resolvedModule);
                     if (!popTypeResolution()) {
                         return reportCircularityError(symbol);
                     }
-                    return type_2;
+                    return type_3;
                 }
             }
             var type = createObjectType(16 /* Anonymous */, symbol);
@@ -57868,10 +57869,10 @@ var ts;
                     var baseTypes = [];
                     var different = false;
                     for (var _i = 0, types_7 = types; _i < types_7.length; _i++) {
-                        var type_3 = types_7[_i];
-                        var baseType = getBaseConstraint(type_3);
+                        var type_4 = types_7[_i];
+                        var baseType = getBaseConstraint(type_4);
                         if (baseType) {
-                            if (baseType !== type_3) {
+                            if (baseType !== type_4) {
                                 different = true;
                             }
                             baseTypes.push(baseType);
@@ -58584,6 +58585,13 @@ var ts;
             var typeTag = ts.getJSDocTypeTag(node);
             return (typeTag === null || typeTag === void 0 ? void 0 : typeTag.typeExpression) && getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression));
         }
+        function getParameterTypeOfTypeTag(func, parameter) {
+            var signature = getSignatureOfTypeTag(func);
+            if (!signature)
+                return undefined;
+            var pos = func.parameters.indexOf(parameter);
+            return parameter.dotDotDotToken ? getRestTypeAtPosition(signature, pos) : getTypeAtPosition(signature, pos);
+        }
         function getReturnTypeOfTypeTag(node) {
             var signature = getSignatureOfTypeTag(node);
             return signature && getReturnTypeOfSignature(signature);
@@ -75773,8 +75781,8 @@ var ts;
             if (hasDefaultOnly && type && !isErrorType(type)) {
                 var synthType = type;
                 if (!synthType.defaultOnlyType) {
-                    var type_4 = createDefaultPropertyWrapperForModule(symbol, originalSymbol);
-                    synthType.defaultOnlyType = type_4;
+                    var type_5 = createDefaultPropertyWrapperForModule(symbol, originalSymbol);
+                    synthType.defaultOnlyType = type_5;
                 }
                 return synthType.defaultOnlyType;
             }
@@ -76501,12 +76509,12 @@ var ts;
                 var witnesses = getSwitchClauseTypeOfWitnesses(node, /*retainDefault*/ false);
                 // notEqualFacts states that the type of the switched value is not equal to every type in the switch.
                 var notEqualFacts_1 = getFactsFromTypeofSwitch(0, 0, witnesses, /*hasDefault*/ true);
-                var type_5 = getBaseConstraintOfType(operandType) || operandType;
+                var type_6 = getBaseConstraintOfType(operandType) || operandType;
                 // Take any/unknown as a special condition. Or maybe we could change `type` to a union containing all primitive types.
-                if (type_5.flags & 3 /* AnyOrUnknown */) {
+                if (type_6.flags & 3 /* AnyOrUnknown */) {
                     return (556800 /* AllTypeofNE */ & notEqualFacts_1) === 556800 /* AllTypeofNE */;
                 }
-                return !!(filterType(type_5, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072 /* Never */);
+                return !!(filterType(type_6, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072 /* Never */);
             }
             var type = getTypeOfExpression(node.expression);
             if (!isLiteralType(type)) {
@@ -78628,6 +78636,7 @@ var ts;
                 }
             }
             checkTypeParameters(ts.getEffectiveTypeParameterDeclarations(node));
+            checkUnmatchedJSDocParameters(node);
             ts.forEach(node.parameters, checkParameter);
             // TODO(rbuckton): Should we start checking JSDoc types?
             if (node.type) {
@@ -80199,31 +80208,6 @@ var ts;
         }
         function checkJSDocParameterTag(node) {
             checkSourceElement(node.typeExpression);
-            if (!ts.getParameterSymbolFromJSDoc(node)) {
-                var decl = ts.getHostSignatureFromJSDoc(node);
-                // don't issue an error for invalid hosts -- just functions --
-                // and give a better error message when the host function mentions `arguments`
-                // but the tag doesn't have an array type
-                if (decl) {
-                    var i = ts.getJSDocTags(decl).filter(ts.isJSDocParameterTag).indexOf(node);
-                    if (i > -1 && i < decl.parameters.length && ts.isBindingPattern(decl.parameters[i].name)) {
-                        return;
-                    }
-                    if (!containsArgumentsReference(decl)) {
-                        if (ts.isQualifiedName(node.name)) {
-                            error(node.name, ts.Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, ts.entityNameToString(node.name), ts.entityNameToString(node.name.left));
-                        }
-                        else {
-                            error(node.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(node.name));
-                        }
-                    }
-                    else if (ts.findLast(ts.getJSDocTags(decl), ts.isJSDocParameterTag) === node &&
-                        node.typeExpression && node.typeExpression.type &&
-                        !isArrayType(getTypeFromTypeNode(node.typeExpression.type))) {
-                        error(node.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, ts.idText(node.name.kind === 160 /* QualifiedName */ ? node.name.right : node.name));
-                    }
-                }
-            }
         }
         function checkJSDocPropertyTag(node) {
             checkSourceElement(node.typeExpression);
@@ -82296,6 +82280,45 @@ var ts;
                 error(name, ts.Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_with_module_0, ts.ModuleKind[moduleKind]); // https://github.com/Microsoft/TypeScript/issues/17494
             }
         }
+        function checkUnmatchedJSDocParameters(node) {
+            var jsdocParameters = ts.filter(ts.getJSDocTags(node), ts.isJSDocParameterTag);
+            if (!ts.length(jsdocParameters))
+                return;
+            var isJs = ts.isInJSFile(node);
+            var parameters = new ts.Set();
+            var excludedParameters = new ts.Set();
+            ts.forEach(node.parameters, function (_a, index) {
+                var name = _a.name;
+                if (ts.isIdentifier(name)) {
+                    parameters.add(name.escapedText);
+                }
+                if (ts.isBindingPattern(name)) {
+                    excludedParameters.add(index);
+                }
+            });
+            var containsArguments = containsArgumentsReference(node);
+            if (containsArguments) {
+                var lastJSDocParam = ts.lastOrUndefined(jsdocParameters);
+                if (lastJSDocParam && ts.isIdentifier(lastJSDocParam.name) && lastJSDocParam.typeExpression &&
+                    lastJSDocParam.typeExpression.type && !parameters.has(lastJSDocParam.name.escapedText) && !isArrayType(getTypeFromTypeNode(lastJSDocParam.typeExpression.type))) {
+                    errorOrSuggestion(isJs, lastJSDocParam.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, ts.idText(lastJSDocParam.name));
+                }
+            }
+            else {
+                ts.forEach(jsdocParameters, function (_a, index) {
+                    var name = _a.name;
+                    if (excludedParameters.has(index) || ts.isIdentifier(name) && parameters.has(name.escapedText)) {
+                        return;
+                    }
+                    if (ts.isQualifiedName(name)) {
+                        errorOrSuggestion(isJs, name, ts.Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, ts.entityNameToString(name), ts.entityNameToString(name.left));
+                    }
+                    else {
+                        errorOrSuggestion(isJs, name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(name));
+                    }
+                });
+            }
+        }
         /**
          * Check each type parameter and check that type parameters have no duplicate type parameter declarations
          */
@@ -83504,6 +83527,9 @@ var ts;
                                     var name = ts.idText(node.kind === 269 /* ImportSpecifier */ ? node.propertyName || node.name : node.name);
                                     addTypeOnlyDeclarationRelatedInfo(error(node, message, name), isType ? undefined : typeOnlyAlias, name);
                                 }
+                                if (isType && node.kind === 264 /* ImportEqualsDeclaration */ && ts.hasEffectiveModifier(node, 1 /* Export */)) {
+                                    error(node, ts.Diagnostics.Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided);
+                                }
                                 break;
                             }
                             case 274 /* ExportSpecifier */: {
@@ -146439,8 +146465,18 @@ var ts;
                 var indent = sourceFile.text.slice(startPosition, fnStart);
                 this.insertNodeAt(sourceFile, fnStart, tag, { preserveLeadingWhitespace: false, suffix: this.newLineCharacter + indent });
             };
+            ChangeTracker.prototype.createJSDocText = function (sourceFile, node) {
+                var comments = ts.flatMap(node.jsDoc, function (jsDoc) {
+                    return ts.isString(jsDoc.comment) ? ts.factory.createJSDocText(jsDoc.comment) : jsDoc.comment;
+                });
+                var jsDoc = ts.singleOrUndefined(node.jsDoc);
+                return jsDoc && ts.positionsAreOnSameLine(jsDoc.pos, jsDoc.end, sourceFile) && ts.length(comments) === 0 ? undefined :
+                    ts.factory.createNodeArray(ts.intersperse(comments, ts.factory.createJSDocText("\n")));
+            };
+            ChangeTracker.prototype.replaceJSDocComment = function (sourceFile, node, tags) {
+                this.insertJsdocCommentBefore(sourceFile, updateJSDocHost(node), ts.factory.createJSDocComment(this.createJSDocText(sourceFile, node), ts.factory.createNodeArray(tags)));
+            };
             ChangeTracker.prototype.addJSDocTags = function (sourceFile, parent, newTags) {
-                var comments = ts.flatMap(parent.jsDoc, function (j) { return typeof j.comment === "string" ? ts.factory.createJSDocText(j.comment) : j.comment; });
                 var oldTags = ts.flatMapToMutable(parent.jsDoc, function (j) { return j.tags; });
                 var unmergedNewTags = newTags.filter(function (newTag) { return !oldTags.some(function (tag, i) {
                     var merged = tryMergeJsdocTags(tag, newTag);
@@ -146448,20 +146484,10 @@ var ts;
                         oldTags[i] = merged;
                     return !!merged;
                 }); });
-                var tags = __spreadArray(__spreadArray([], oldTags, true), unmergedNewTags, true);
-                var jsDoc = ts.singleOrUndefined(parent.jsDoc);
-                var comment = jsDoc && ts.positionsAreOnSameLine(jsDoc.pos, jsDoc.end, sourceFile) && !ts.length(comments) ? undefined :
-                    ts.factory.createNodeArray(ts.intersperse(comments, ts.factory.createJSDocText("\n")));
-                var tag = ts.factory.createJSDocComment(comment, ts.factory.createNodeArray(tags));
-                var host = updateJSDocHost(parent);
-                this.insertJsdocCommentBefore(sourceFile, host, tag);
+                this.replaceJSDocComment(sourceFile, parent, __spreadArray(__spreadArray([], oldTags, true), unmergedNewTags, true));
             };
             ChangeTracker.prototype.filterJSDocTags = function (sourceFile, parent, predicate) {
-                var comments = ts.flatMap(parent.jsDoc, function (j) { return typeof j.comment === "string" ? ts.factory.createJSDocText(j.comment) : j.comment; });
-                var oldTags = ts.flatMapToMutable(parent.jsDoc, function (j) { return j.tags; });
-                var tag = ts.factory.createJSDocComment(ts.factory.createNodeArray(ts.intersperse(comments, ts.factory.createJSDocText("\n"))), ts.factory.createNodeArray(__spreadArray([], (ts.filter(oldTags, predicate) || ts.emptyArray), true)));
-                var host = updateJSDocHost(parent);
-                this.insertJsdocCommentBefore(sourceFile, host, tag);
+                this.replaceJSDocComment(sourceFile, parent, ts.filter(ts.flatMapToMutable(parent.jsDoc, function (j) { return j.tags; }), predicate));
             };
             ChangeTracker.prototype.replaceRangeWithText = function (sourceFile, range, text) {
                 this.changes.push({ kind: ChangeKind.Text, sourceFile: sourceFile, range: range, text: text });
@@ -150256,9 +150282,9 @@ var ts;
                 var symbolName = ts.getNameForExportedSymbol(exportedSymbol, ts.getEmitScriptTarget(compilerOptions));
                 var checker = program.getTypeChecker();
                 var symbol = checker.getMergedSymbol(ts.skipAlias(exportedSymbol, checker));
-                var exportInfos = getAllReExportingModules(sourceFile, symbol, moduleSymbol, symbolName, /*isJsxTagName*/ false, host, program, preferences, useAutoImportProvider);
+                var exportInfo = getAllReExportingModules(sourceFile, symbol, moduleSymbol, symbolName, /*isJsxTagName*/ false, host, program, preferences, useAutoImportProvider);
                 var useRequire = shouldUseRequire(sourceFile, program);
-                var fix = getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, /*position*/ undefined, !!isValidTypeOnlyUseSite, useRequire, host, preferences);
+                var fix = getImportFixForSymbol(sourceFile, exportInfo, moduleSymbol, symbolName, program, /*position*/ undefined, !!isValidTypeOnlyUseSite, useRequire, host, preferences);
                 if (fix) {
                     addImport({ fixes: [fix], symbolName: symbolName, errorIdentifierText: undefined });
                 }
@@ -150447,7 +150473,7 @@ var ts;
         function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
             ts.Debug.assert(exportInfos.some(function (info) { return info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol; }), "Some exportInfo should match the specified moduleSymbol");
             var packageJsonImportFilter = ts.createPackageJsonImportFilter(sourceFile, preferences, host);
-            return getBestFix(getImportFixes(exportInfos, symbolName, position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences), sourceFile, program, packageJsonImportFilter);
+            return getBestFix(getImportFixes(exportInfos, symbolName, position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences), sourceFile, program, packageJsonImportFilter, host);
         }
         function codeFixActionToCodeAction(_a) {
             var description = _a.description, changes = _a.changes, commands = _a.commands;
@@ -150507,7 +150533,7 @@ var ts;
             /*position*/ undefined, 
             /*isValidTypeOnlyUseSite*/ false, 
             /*useRequire*/ false, exportInfo, host, preferences, fromCacheOnly), fixes = _a.fixes, computedWithoutCacheCount = _a.computedWithoutCacheCount;
-            var result = getBestFix(fixes, importingFile, program, packageJsonImportFilter || ts.createPackageJsonImportFilter(importingFile, preferences, host));
+            var result = getBestFix(fixes, importingFile, program, packageJsonImportFilter || ts.createPackageJsonImportFilter(importingFile, preferences, host), host);
             return result && __assign(__assign({}, result), { computedWithoutCacheCount: computedWithoutCacheCount });
         }
         codefix.getModuleSpecifierForBestExportInfo = getModuleSpecifierForBestExportInfo;
@@ -150677,7 +150703,7 @@ var ts;
             // 5. Literally nothing to go on
             return true;
         }
-        function getNewImportFixes(program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, moduleSymbols, host, preferences, fromCacheOnly) {
+        function getNewImportFixes(program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, exportInfo, host, preferences, fromCacheOnly) {
             var isJs = ts.isSourceFileJS(sourceFile);
             var compilerOptions = program.getCompilerOptions();
             var moduleSpecifierResolutionHost = ts.createModuleSpecifierResolutionHost(program, host);
@@ -150686,7 +150712,7 @@ var ts;
                 ? function (moduleSymbol) { return ({ moduleSpecifiers: ts.moduleSpecifiers.tryGetModuleSpecifiersFromCache(moduleSymbol, sourceFile, moduleSpecifierResolutionHost, preferences), computedWithoutCache: false }); }
                 : function (moduleSymbol, checker) { return ts.moduleSpecifiers.getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, sourceFile, moduleSpecifierResolutionHost, preferences); };
             var computedWithoutCacheCount = 0;
-            var fixes = ts.flatMap(moduleSymbols, function (exportInfo) {
+            var fixes = ts.flatMap(exportInfo, function (exportInfo, i) {
                 var checker = getChecker(exportInfo.isFromPackageJson);
                 var _a = getModuleSpecifiers(exportInfo.moduleSymbol, checker), computedWithoutCache = _a.computedWithoutCache, moduleSpecifiers = _a.moduleSpecifiers;
                 var importedSymbolHasValueMeaning = !!(exportInfo.targetFlags & 111551 /* Value */);
@@ -150695,7 +150721,7 @@ var ts;
                 return moduleSpecifiers === null || moduleSpecifiers === void 0 ? void 0 : moduleSpecifiers.map(function (moduleSpecifier) {
                     // `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types.
                     return !importedSymbolHasValueMeaning && isJs && position !== undefined
-                        ? { kind: 1 /* JsdocTypeImport */, moduleSpecifier: moduleSpecifier, position: position, exportInfo: exportInfo }
+                        ? { kind: 1 /* JsdocTypeImport */, moduleSpecifier: moduleSpecifier, position: position, exportInfo: exportInfo, isReExport: i > 0 }
                         : {
                             kind: 3 /* AddNew */,
                             moduleSpecifier: moduleSpecifier,
@@ -150703,6 +150729,7 @@ var ts;
                             useRequire: useRequire,
                             addAsTypeOnly: addAsTypeOnly,
                             exportInfo: exportInfo,
+                            isReExport: i > 0,
                         };
                 });
             });
@@ -150740,12 +150767,13 @@ var ts;
                 info = getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider);
             }
             var packageJsonImportFilter = ts.createPackageJsonImportFilter(context.sourceFile, context.preferences, context.host);
-            return info && __assign(__assign({}, info), { fixes: sortFixes(info.fixes, context.sourceFile, context.program, packageJsonImportFilter) });
+            return info && __assign(__assign({}, info), { fixes: sortFixes(info.fixes, context.sourceFile, context.program, packageJsonImportFilter, context.host) });
         }
-        function sortFixes(fixes, sourceFile, program, packageJsonImportFilter) {
-            return ts.sort(fixes, function (a, b) { return ts.compareValues(a.kind, b.kind) || compareModuleSpecifiers(a, b, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier); });
+        function sortFixes(fixes, sourceFile, program, packageJsonImportFilter, host) {
+            var _toPath = function (fileName) { return ts.toPath(fileName, host.getCurrentDirectory(), ts.hostGetCanonicalFileName(host)); };
+            return ts.sort(fixes, function (a, b) { return ts.compareValues(a.kind, b.kind) || compareModuleSpecifiers(a, b, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier, _toPath); });
         }
-        function getBestFix(fixes, sourceFile, program, packageJsonImportFilter) {
+        function getBestFix(fixes, sourceFile, program, packageJsonImportFilter, host) {
             if (!ts.some(fixes))
                 return;
             // These will always be placed first if available, and are better than other kinds
@@ -150754,22 +150782,37 @@ var ts;
             }
             return fixes.reduce(function (best, fix) {
                 // Takes true branch of conditional if `fix` is better than `best`
-                return compareModuleSpecifiers(fix, best, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier) === -1 /* LessThan */ ? fix : best;
+                return compareModuleSpecifiers(fix, best, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier, function (fileName) { return ts.toPath(fileName, host.getCurrentDirectory(), ts.hostGetCanonicalFileName(host)); }) === -1 /* LessThan */ ? fix : best;
             });
         }
         /** @returns `Comparison.LessThan` if `a` is better than `b`. */
-        function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier) {
+        function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier, toPath) {
             if (a.kind !== 0 /* UseNamespace */ && b.kind !== 0 /* UseNamespace */) {
                 return ts.compareBooleans(allowsImportingSpecifier(b.moduleSpecifier), allowsImportingSpecifier(a.moduleSpecifier))
                     || compareNodeCoreModuleSpecifiers(a.moduleSpecifier, b.moduleSpecifier, importingFile, program)
-                    || ts.compareBooleans(isOnlyDotsAndSlashes(a.moduleSpecifier), isOnlyDotsAndSlashes(b.moduleSpecifier))
+                    || ts.compareBooleans(isFixPossiblyReExportingImportingFile(a, importingFile, program.getCompilerOptions(), toPath), isFixPossiblyReExportingImportingFile(b, importingFile, program.getCompilerOptions(), toPath))
                     || ts.compareNumberOfDirectorySeparators(a.moduleSpecifier, b.moduleSpecifier);
             }
             return 0 /* EqualTo */;
         }
-        var notDotOrSlashPattern = /[^.\/]/;
-        function isOnlyDotsAndSlashes(path) {
-            return !notDotOrSlashPattern.test(path);
+        // This is a simple heuristic to try to avoid creating an import cycle with a barrel re-export.
+        // E.g., do not `import { Foo } from ".."` when you could `import { Foo } from "../Foo"`.
+        // This can produce false positives or negatives if re-exports cross into sibling directories
+        // (e.g. `export * from "../whatever"`) or are not named "index" (we don't even try to consider
+        // this if we're in a resolution mode where you can't drop trailing "/index" from paths).
+        function isFixPossiblyReExportingImportingFile(fix, importingFile, compilerOptions, toPath) {
+            var _a;
+            if (fix.isReExport &&
+                ((_a = fix.exportInfo) === null || _a === void 0 ? void 0 : _a.moduleFileName) &&
+                ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs &&
+                isIndexFileName(fix.exportInfo.moduleFileName)) {
+                var reExportDir = toPath(ts.getDirectoryPath(fix.exportInfo.moduleFileName));
+                return ts.startsWith((importingFile.path), reExportDir);
+            }
+            return false;
+        }
+        function isIndexFileName(fileName) {
+            return ts.getBaseFileName(fileName, [".js", ".jsx", ".d.ts", ".ts", ".tsx"], /*ignoreCase*/ true) === "index";
         }
         function compareNodeCoreModuleSpecifiers(a, b, importingFile, program) {
             if (ts.startsWith(a, "node:") && !ts.startsWith(b, "node:"))
@@ -150787,9 +150830,9 @@ var ts;
                 return undefined;
             var symbol = checker.getAliasedSymbol(umdSymbol);
             var symbolName = umdSymbol.name;
-            var exportInfos = [{ symbol: umdSymbol, moduleSymbol: symbol, moduleFileName: undefined, exportKind: 3 /* UMD */, targetFlags: symbol.flags, isFromPackageJson: false }];
+            var exportInfo = [{ symbol: umdSymbol, moduleSymbol: symbol, moduleFileName: undefined, exportKind: 3 /* UMD */, targetFlags: symbol.flags, isFromPackageJson: false }];
             var useRequire = shouldUseRequire(sourceFile, program);
-            var fixes = getImportFixes(exportInfos, symbolName, ts.isIdentifier(token) ? token.getStart(sourceFile) : undefined, /*isValidTypeOnlyUseSite*/ false, useRequire, program, sourceFile, host, preferences);
+            var fixes = getImportFixes(exportInfo, symbolName, ts.isIdentifier(token) ? token.getStart(sourceFile) : undefined, /*isValidTypeOnlyUseSite*/ false, useRequire, program, sourceFile, host, preferences);
             return { fixes: fixes, symbolName: symbolName, errorIdentifierText: (_b = ts.tryCast(token, ts.isIdentifier)) === null || _b === void 0 ? void 0 : _b.text };
         }
         function getUmdSymbol(token, checker) {
@@ -150856,8 +150899,8 @@ var ts;
             ts.Debug.assert(symbolName !== "default" /* Default */, "'default' isn't a legal identifier and couldn't occur here");
             var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(symbolToken);
             var useRequire = shouldUseRequire(sourceFile, program);
-            var exportInfos = getExportInfos(symbolName, ts.isJSXTagName(symbolToken), ts.getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, program, useAutoImportProvider, host, preferences);
-            var fixes = ts.arrayFrom(ts.flatMapIterator(exportInfos.entries(), function (_a) {
+            var exportInfo = getExportInfos(symbolName, ts.isJSXTagName(symbolToken), ts.getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, program, useAutoImportProvider, host, preferences);
+            var fixes = ts.arrayFrom(ts.flatMapIterator(exportInfo.entries(), function (_a) {
                 var _ = _a[0], exportInfos = _a[1];
                 return getImportFixes(exportInfos, symbolName, symbolToken.getStart(sourceFile), isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences);
             }));
@@ -152958,6 +153001,95 @@ var ts;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
+(function (ts) {
+    var codefix;
+    (function (codefix) {
+        var deleteUnmatchedParameter = "deleteUnmatchedParameter";
+        var renameUnmatchedParameter = "renameUnmatchedParameter";
+        var errorCodes = [
+            ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name.code,
+        ];
+        codefix.registerCodeFix({
+            fixIds: [deleteUnmatchedParameter, renameUnmatchedParameter],
+            errorCodes: errorCodes,
+            getCodeActions: function getCodeActionsToFixUnmatchedParameter(context) {
+                var sourceFile = context.sourceFile, span = context.span;
+                var actions = [];
+                var info = getInfo(sourceFile, span.start);
+                if (info) {
+                    ts.append(actions, getDeleteAction(context, info));
+                    ts.append(actions, getRenameAction(context, info));
+                    return actions;
+                }
+                return undefined;
+            },
+            getAllCodeActions: function getAllCodeActionsToFixUnmatchedParameter(context) {
+                var tagsToSignature = new ts.Map();
+                return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) {
+                    codefix.eachDiagnostic(context, errorCodes, function (_a) {
+                        var file = _a.file, start = _a.start;
+                        var info = getInfo(file, start);
+                        if (info) {
+                            tagsToSignature.set(info.signature, ts.append(tagsToSignature.get(info.signature), info.jsDocParameterTag));
+                        }
+                    });
+                    tagsToSignature.forEach(function (tags, signature) {
+                        if (context.fixId === deleteUnmatchedParameter) {
+                            var tagsSet_1 = new ts.Set(tags);
+                            changes.filterJSDocTags(signature.getSourceFile(), signature, function (t) { return !tagsSet_1.has(t); });
+                        }
+                    });
+                }));
+            }
+        });
+        function getDeleteAction(context, _a) {
+            var name = _a.name, signature = _a.signature, jsDocParameterTag = _a.jsDocParameterTag;
+            var changes = ts.textChanges.ChangeTracker.with(context, function (changeTracker) {
+                return changeTracker.filterJSDocTags(context.sourceFile, signature, function (t) { return t !== jsDocParameterTag; });
+            });
+            return codefix.createCodeFixAction(deleteUnmatchedParameter, changes, [ts.Diagnostics.Delete_unused_param_tag_0, name.getText(context.sourceFile)], deleteUnmatchedParameter, ts.Diagnostics.Delete_all_unused_param_tags);
+        }
+        function getRenameAction(context, _a) {
+            var name = _a.name, signature = _a.signature, jsDocParameterTag = _a.jsDocParameterTag;
+            if (!ts.length(signature.parameters))
+                return undefined;
+            var sourceFile = context.sourceFile;
+            var tags = ts.getJSDocTags(signature);
+            var names = new ts.Set();
+            for (var _i = 0, tags_2 = tags; _i < tags_2.length; _i++) {
+                var tag = tags_2[_i];
+                if (ts.isJSDocParameterTag(tag) && ts.isIdentifier(tag.name)) {
+                    names.add(tag.name.escapedText);
+                }
+            }
+            // @todo - match to all available names instead to the first parameter name
+            // @see /codeFixRenameUnmatchedParameter3.ts
+            var parameterName = ts.firstDefined(signature.parameters, function (p) {
+                return ts.isIdentifier(p.name) && !names.has(p.name.escapedText) ? p.name.getText(sourceFile) : undefined;
+            });
+            if (parameterName === undefined)
+                return undefined;
+            var newJSDocParameterTag = ts.factory.updateJSDocParameterTag(jsDocParameterTag, jsDocParameterTag.tagName, ts.factory.createIdentifier(parameterName), jsDocParameterTag.isBracketed, jsDocParameterTag.typeExpression, jsDocParameterTag.isNameFirst, jsDocParameterTag.comment);
+            var changes = ts.textChanges.ChangeTracker.with(context, function (changeTracker) {
+                return changeTracker.replaceJSDocComment(sourceFile, signature, ts.map(tags, function (t) { return t === jsDocParameterTag ? newJSDocParameterTag : t; }));
+            });
+            return codefix.createCodeFixActionWithoutFixAll(renameUnmatchedParameter, changes, [ts.Diagnostics.Rename_param_tag_name_0_to_1, name.getText(sourceFile), parameterName]);
+        }
+        function getInfo(sourceFile, pos) {
+            var token = ts.getTokenAtPosition(sourceFile, pos);
+            if (token.parent && ts.isJSDocParameterTag(token.parent) && ts.isIdentifier(token.parent.name)) {
+                var jsDocParameterTag = token.parent;
+                var signature = ts.getHostSignatureFromJSDoc(jsDocParameterTag);
+                if (signature) {
+                    return { signature: signature, name: token.parent.name, jsDocParameterTag: jsDocParameterTag };
+                }
+            }
+            return undefined;
+        }
+    })(codefix = ts.codefix || (ts.codefix = {}));
+})(ts || (ts = {}));
+/* @internal */
+var ts;
 (function (ts) {
     var codefix;
     (function (codefix) {