eslint-plugin-lube 0.7.0 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.8.1
+
+### Fixed
+
+- `svelte-naming-convention` no longer reports or renames an ambient TypeScript declaration (`declare function`, `declare const`, `declare let`, `declare var`, `declare class`, and anything inside `declare global { }` or `declare module "m" { }`) or its usages, since the name belongs to the host that injects it.
+- `svelte-naming-convention` renames every overload signature and the implementation of a function together with its calls, instead of only the calls.
+
+## 0.8.0
+
+### Breaking
+
+- **The strict config moves inline parameter types into `@param` tags** with the new
+  `prefer-param-tag`: `function f(/** @type {T} */ a) {}` becomes `@param {T} a` in the JSDoc block of
+  the declaration. It has a fix, so run `eslint --fix` once; a destructured parameter is left to you.
+
+### Added
+
+- `prefer-param-tag`, in the strict config: reports a function declaration whose parameters are typed
+  with inline comments, `function f(/** @type {T} */ a) {}`, and fixes it into `@param {T} a` tags in the
+  JSDoc block of the declaration, creating the block if there is none, each tag at the position of its
+  parameter among the existing `@param` tags. Arrow functions and function expressions stay, and a
+  destructured parameter is reported without a fix.
+
 ## 0.7.0
 
 ### Breaking

package/README.md

@@ -89,6 +89,7 @@ Both configs are flat config objects with `plugins` and `rules`, and differ in h
 
 **`configs.strict`** is the house style of this repository, and several of its rules cannot be fixed. It is everything in `recommended` plus:
 - `svelte-naming-convention`, which renames declarations to snake_case.
+- `prefer-param-tag`, which moves the inline `/** @type {T} */` comments of a function declaration's parameters into `@param` tags on the declaration ([prefer-param-tag](https://github.com/artxe/lube-series/blob/master/packages/eslint-plugin-lube/docs/prefer-param-tag.md)).
 - `prefer-type-tag`, which moves the cast of a declaration's value into a `@type` tag on the declaration, in a project linted with type information ([prefer-type-tag](https://github.com/artxe/lube-series/blob/master/packages/eslint-plugin-lube/docs/prefer-type-tag.md) shows the parser options).
 - `ascii-order` for import statements, object keys, function declarations and test cases too (see below).
 - `pretty-sequence` and `pretty-imports` at 30 characters.
@@ -111,6 +112,7 @@ Override a rule after the spread: `rules: { ...lube.configs.recommended.rules, "
 | --- | --- | --- |
 | [ascii-order](https://github.com/artxe/lube-series/blob/master/packages/eslint-plugin-lube/docs/ascii-order.md) | ASCII order of import statements, import and export names, object keys, function declarations and test cases | names only |
 | [curly](https://eslint.org/docs/latest/rules/curly) | Braces around the bodies of `if`, `else`, `for`, `while` and `do`, as ESLint's own rule does, with a fix that keeps a comment in front of the body, such as a JSDoc cast, inside the braces | no |
+| [prefer-param-tag](https://github.com/artxe/lube-series/blob/master/packages/eslint-plugin-lube/docs/prefer-param-tag.md) | JSDoc `@param` tags on a function declaration instead of inline `/** @type {T} */` comments in its parameter list | no |
 | [prefer-type-tag](https://github.com/artxe/lube-series/blob/master/packages/eslint-plugin-lube/docs/prefer-type-tag.md) | A JSDoc `@type` tag on a declaration instead of a cast of its value, wherever the tag would type check (needs type information) | no |
 | [pretty-imports](https://github.com/artxe/lube-series/blob/master/packages/eslint-plugin-lube/docs/pretty-imports.md) | Import and export names on one line when they fit, or one per line | yes |
 | [pretty-jsdoc-casting](https://github.com/artxe/lube-series/blob/master/packages/eslint-plugin-lube/docs/pretty-jsdoc-casting.md) | JSDoc type casts written as `/** @type {T} */(value)/**/` | yes |

package/docs/prefer-param-tag.md

@@ -0,0 +1,25 @@
+# prefer-param-tag
+Enforces JSDoc `@param` tags on a function declaration, instead of inline `/** @type {T} */` comments inside its parameter list.
+
+- Only function declarations are checked, `export` and `export default` ones too. Arrow functions and function expressions, such as `items.map((/** @type {string} */ x) => x)`, have no declaration to carry a tag and are left alone, and so are casts in a body.
+- The fix removes the inline comments and adds one `@param {T} name` line per parameter to the JSDoc block above the declaration, in parameter order, after the existing `@param` tags and before `@returns` and the like. It creates the block when there is none, and keeps the indentation of the declaration. A `@param` tag that already names the parameter is not repeated.
+- A default value, `/** @type {number} */ n = 1`, is typed by `@param {number} n` too.
+- A destructured or rest parameter has no simple name to write in a tag and is reported without a fix. So is a declaration that does not start its line, where a block cannot be added.
+
+## options
+None.
+
+## Valid
+```js
+/**
+ * @param {string} tx
+ */
+function use(tx) {}
+items.map((/** @type {string} */ x) => x)
+```
+
+## Invalid
+```js
+function use(/** @type {string} */ tx) {}
+async function source(/** @type {unknown} */ n, /** @type {number} */ m = 1) {}
+```

package/docs/svelte-naming-convention.md

@@ -6,6 +6,7 @@ The strict config turns it on and the recommended config leaves it off, since it
 - The message names the expected name, `Rename 'camelCase' to 'camel_case'`, or, for a name without a snake_case form such as `NO_SNAKE__CASE`, asks for snake_case, UPPER_SNAKE_CASE or PascalCase.
 - Usages such as assignments, function bodies, `extends` clauses, JSX and TypeScript expressions are only renamed along with their declaration; `fixSameNames` sets the order.
 - Usages are matched to declarations by scope, so a global, an import or an exported camelCase function of the same name is left as it is.
+- An ambient TypeScript declaration, `declare function acquireVsCodeApi(): Api`, `declare const`, `declare class`, or anything inside `declare global { }` or `declare module "m" { }`, names a binding the code does not own: it is neither reported nor renamed, and neither are its usages.
 - A declaration exported with `export { camelCase }` is renamed together with the export specifier, `export { camel_case as camelCase }`.
 - The JSDoc of a renamed parameter follows it: `@param {T} [camelCase]`, `{camelCase is T}` and `{typeof camelCase}`.
 - In a `.svelte` file, the store subscriptions of a renamed store are renamed with it, `$camelCase` into `$camel_case`, in the same fix, and so are the usages in the markup: mustache tags, attributes, directives and the expression of `{#if}`, `{#each}`, `{#await}` and `{#key}`. A shorthand attribute is written out, `{camelCase}` into `camelCase={camel_case}`, so the name of the property stays. Names the markup declares, the context of `{#each}`, the value of `{#await}` and a `let:` property, are not reported.

package/package.json

@@ -7,11 +7,6 @@
     "@stylistic/eslint-plugin": "^5.10.0"
   },
   "description": "Fixable ESLint rules that format code without Prettier",
-  "devDependencies": {
-    "@types/estree": "^1.0.9",
-    "@typescript/native": "npm:typescript@^7.0.2",
-    "eslint": "^10.10.0"
-  },
   "engines": {
     "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
   },
@@ -53,10 +48,10 @@
   },
   "type": "module",
   "types": "types/index.d.ts",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "scripts": {
     "dts": "node ../../scripts/tsc_with_clean.js eslint-plugin-lube",
     "lint": "pnpm -w lint",
-    "test": "pnpm -w exec vitest run --coverage test/eslint-plugin-lube"
+    "test": "pnpm -w exec vitest run --coverage --coverage.include=packages/eslint-plugin-lube/src/** test/eslint-plugin-lube"
   }
 }

package/src/index.js

@@ -1,4 +1,5 @@
 import ascii_order from "./rules/ascii-order.js"
+import prefer_param_tag from "./rules/prefer-param-tag.js"
 import prefer_type_tag from "./rules/prefer-type-tag.js"
 import pretty_imports from "./rules/pretty-imports.js"
 import pretty_jsdoc_casting from "./rules/pretty-jsdoc-casting.js"
@@ -152,6 +153,7 @@ const strict_rules = {
 		}
 	],
 	"lube/curly": [ "error", "all" ],
+	"lube/prefer-param-tag": "error",
 	"lube/prefer-type-tag": "error",
 	"lube/pretty-imports": "error",
 	"lube/pretty-jsdoc-casting": "error",
@@ -246,6 +248,7 @@ const plugin = {
 		"curly": keep_body_comments(
 			/** @type {import("eslint").Rule.RuleModule} */(builtinRules.get("curly"))/**/
 		),
+		"prefer-param-tag": prefer_param_tag,
 		"prefer-type-tag": prefer_type_tag,
 		"pretty-imports": pretty_imports,
 		"pretty-jsdoc-casting": pretty_jsdoc_casting,

package/src/rules/ascii-order.js

@@ -251,13 +251,8 @@ function create_reorder(context) {
 	 * @returns {string}
 	 */
 	function get_snippet(node) {
-		const value = node.type == "Property"
-			? node.computed && node.key.type != "Literal"
-				? node.key
-				: node.value
-			: node
 		const snippet = source_code.getText(
-			/** @type {import("estree").Node} */(value)/**/
+			/** @type {import("estree").Property} */(node)/**/.value
 		).replace(/\s+/g, " ")
 		return snippet.length > 30 ? snippet.slice(0, 29) + "…" : snippet
 	}
@@ -341,7 +336,7 @@ function get_name(node) {
 	case "TemplateLiteral":
 		return node.expressions.length
 			? undefined
-			: /** @type {import("estree").TemplateElement} */(node.quasis[0])/**/.value.cooked ?? undefined
+			: /** @type {string} */(/** @type {import("estree").TemplateElement} */(node.quasis[0])/**/.value.cooked)/**/
 	}
 	return undefined
 }

package/src/rules/prefer-param-tag.js

@@ -0,0 +1,252 @@
+const blank_regex = /^\s*\*?\s*$/
+const directive_regex = /^\s*(?:eslint-disable-next-line\b|@ts-(?:expect-error|ignore)\b)/
+const line_break_regex = /\s*(?:\r\n|[\n\r\p{Zl}\p{Zp}])\s*/gu
+const line_terminator_regex = /\r\n|[\n\r\p{Zl}\p{Zp}]/u
+const param_tag_regex = /^\s*\*\s*@param\b/
+const space_regex = /^\s*$/
+const tag_after_param_regex = /^\s*\*\s*@(?:deprecated|example|returns?|see|throws|yields?)\b/
+const tag_regex = /^\s*\*\s*@/
+const type_regex = /^\*\s*@type\s*(\{[^]*\})\s*$/
+const white_space_regex = /\s/
+/**
+ * @param {string} text
+ * @returns {string}
+ */
+function escape_regex(text) {
+	return text.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&")
+}
+/**
+ * @param {import("estree").Comment} comment
+ * @param {string} indent
+ * @param {string} eol
+ * @param {{ index: number, tag: string }[]} tags
+ * @returns {string}
+ */
+function jsdoc_with(comment, indent, eol, tags) {
+	let rows = `/*${comment.value}*/`.split(line_terminator_regex)
+	/**
+	 * @param {number} index
+	 * @returns {string}
+	 */
+	function row_at(index) {
+		return /** @type {string} */(rows[index])/**/
+	}
+	if (rows.length < 2 || !/^\/\*\*\s*$/.test(row_at(0)) || !/^\s*\*\/$/.test(row_at(rows.length - 1))) {
+		const body = comment.value.slice(1).split(line_terminator_regex)
+			.map(
+				row => row.replace(/^\s*\*?\s?/, "").trimEnd()
+			)
+		while (body[0] === "") {
+			body.shift()
+		}
+		while (body.at(-1) === "") {
+			body.pop()
+		}
+		rows = [
+			"/**",
+			...body.map(
+				row => `${indent} * ${row}`.trimEnd()
+			),
+			`${indent} */`
+		]
+	}
+	for (const { index, tag } of tags) {
+		const rows_end = rows.length - 1
+		/** @type {{ end: number, start: number }[]} */
+		const blocks = []
+		for (let i = 1; i < rows_end; i++) {
+			if (param_tag_regex.test(row_at(i))) {
+				let end = i + 1
+				while (end < rows_end && !tag_regex.test(row_at(end)) && !blank_regex.test(row_at(end))) {
+					end++
+				}
+				blocks.push({ end, start: i })
+			}
+		}
+		let at = rows_end
+		const first = blocks[0]
+		if (first) {
+			at = index == 0
+				? first.start
+				: /** @type {{ end: number, start: number }} */(blocks[Math.min(index, blocks.length) - 1])/**/.end
+		} else {
+			const tag_at = rows.findIndex(
+				row => tag_after_param_regex.test(row)
+			)
+			if (tag_at >= 0) {
+				at = tag_at
+			}
+		}
+		const added = [ `${indent} * ${tag}` ]
+		if (at == rows_end && at > 1 && !tag_regex.test(row_at(at - 1)) && !blank_regex.test(row_at(at - 1))) {
+			added.unshift(`${indent} *`)
+		}
+		rows.splice(at, 0, ...added)
+	}
+	return rows.join(eol)
+}
+/** @type {import("eslint").Rule.RuleModule} */
+export default {
+	create(context) {
+		const source_code = context.sourceCode
+		const text = source_code.text
+		/**
+		 * @param {import("estree").Comment} comment
+		 * @returns {import("eslint").AST.Range}
+		 */
+		function comment_range(comment) {
+			return /** @type {import("eslint").AST.Range} */(comment.range)/**/
+		}
+		/**
+		 * @param {number} position
+		 * @returns {number}
+		 */
+		function line_start_of(position) {
+			let start = position
+			while (start > 0 && !line_terminator_regex.test(text.charAt(start - 1))) {
+				start--
+			}
+			return start
+		}
+		/**
+		 * @param {import("estree").Comment} comment
+		 * @returns {boolean}
+		 */
+		function starts_line(comment) {
+			const start = comment_range(comment)[0]
+			return space_regex.test(
+				text.slice(line_start_of(start), start)
+			)
+		}
+		return {
+			FunctionDeclaration(node) {
+				/** @type {{ comment: import("estree").Comment, index: number, name: string, type: string }[]} */
+				const named = []
+				const data = {
+					name: node.id?.name ?? "default"
+				}
+				for (const [ index, param ] of node.params.entries()) {
+					const comment = source_code.getCommentsBefore(param).findLast(
+						item => item.type == "Block" && type_regex.test(item.value)
+					)
+					if (!comment) {
+						continue
+					}
+					const target = param.type == "AssignmentPattern" ? param.left : param
+					if (target.type == "Identifier") {
+						named.push(
+							{
+								comment,
+								index,
+								name: target.name,
+								type: /** @type {string} */(/** @type {RegExpExecArray} */(type_regex.exec(comment.value))/**/[1])/**/.replace(line_break_regex, " ")
+							}
+						)
+					} else {
+						context.report(
+							{
+								data,
+								loc: /** @type {import("estree").SourceLocation} */(comment.loc)/**/,
+								messageId: "name"
+							}
+						)
+					}
+				}
+				const first = named[0]
+				if (!first) {
+					return
+				}
+				const loc = /** @type {import("estree").SourceLocation} */(first.comment.loc)/**/
+				const statement = node.parent.type == "ExportNamedDeclaration" || node.parent.type == "ExportDefaultDeclaration"
+					? node.parent
+					: node
+				const leading = source_code.getCommentsBefore(statement)
+				let start = /** @type {import("eslint").AST.Range} */(statement.range)/**/[0]
+				let last = leading.length - 1
+				while (last >= 0) {
+					const item = /** @type {import("estree").Comment} */(leading[last])/**/
+					if (!starts_line(item) || !directive_regex.test(item.value)) {
+						break
+					}
+					start = comment_range(item)[0]
+					last--
+				}
+				const candidate = leading[last]
+				const jsdoc = candidate?.type == "Block" && candidate.value.startsWith("*")
+					? candidate
+					: undefined
+				const anchor = jsdoc ? comment_range(jsdoc)[0] : start
+				const indent = text.slice(line_start_of(anchor), anchor)
+				if (!space_regex.test(indent)) {
+					context.report(
+						{ data, loc, messageId: "hand" }
+					)
+					return
+				}
+				const eol = text.match(line_terminator_regex)?.[0] ?? "\n"
+				const tags = named.filter(
+					item => !jsdoc || !new RegExp(
+						`@param\\s+(?:\\{[^]*?\\}\\s+)?\\[?${escape_regex(item.name)}(?![\\w$])`
+					).test(jsdoc.value)
+				).map(
+					item => (
+						{
+							index: item.index,
+							tag: `@param ${item.type} ${item.name}`
+						}
+					)
+				)
+				context.report(
+					{
+						data,
+						fix(fixer) {
+							const fixes = named.map(
+								({ comment }) => {
+									const [ begin, close ] = comment_range(comment)
+									let end = close
+									while (white_space_regex.test(text.charAt(end))) {
+										end++
+									}
+									return fixer.removeRange([ begin, end ])
+								}
+							)
+							if (jsdoc) {
+								fixes.push(
+									fixer.replaceTextRange(
+										comment_range(jsdoc),
+										jsdoc_with(jsdoc, indent, eol, tags)
+									)
+								)
+							} else {
+								fixes.push(
+									fixer.insertTextBeforeRange(
+										[ start, start ],
+										`/**${eol}${tags.map(({ tag }) => `${indent} * ${tag}${eol}`).join("")}${indent} */${eol}${indent}`
+									)
+								)
+							}
+							return fixes
+						},
+						loc,
+						messageId: "tag"
+					}
+				)
+			}
+		}
+	},
+	meta: {
+		docs: {
+			description: "Enforces JSDoc `@param` tags on a function declaration instead of inline `/** @type {T} */` comments inside its parameter list.",
+			recommended: false,
+			url: "https://github.com/artxe/lube-series/blob/master/packages/eslint-plugin-lube/docs/prefer-param-tag.md"
+		},
+		fixable: "code",
+		messages: {
+			hand: "Type the parameters of `{{name}}` with `@param` tags on the declaration instead of inline comments; it is not fixed automatically because the declaration or its JSDoc comment does not start its line, so write the tags by hand",
+			name: "Type this parameter of `{{name}}` with a `@param` tag on the declaration instead of an inline comment; it is not fixed automatically because the parameter has no simple name to write in the tag, so document it by hand",
+			tag: "Type the parameters of `{{name}}` with `@param` tags on the declaration instead of inline `@type` comments"
+		},
+		schema: [],
+		type: "suggestion"
+	}
+}

package/src/rules/pretty-imports.js

@@ -52,9 +52,6 @@ export default {
 			const open_index = tokens.findIndex(
 				token => token.range[0] == first.range[0]
 			) - 1
-			if (tokens[open_index]?.value != "{") {
-				return
-			}
 			const head = tokens.slice(0, open_index)
 				.map(token => token.value)
 				.join(" ")

package/src/rules/pretty-jsdoc-casting.js

@@ -36,10 +36,7 @@ export default {
 		 * @returns {boolean}
 		 */
 		function is_arguments(position) {
-			const node = /** @type {import("../../private.js").AstNode | null} */(/** @type {unknown} */(source_code.getNodeByRangeIndex(position)))/**/
-			if (!node) {
-				return false
-			}
+			const node = /** @type {import("../../private.js").AstNode} */(/** @type {unknown} */(source_code.getNodeByRangeIndex(position)))/**/
 			const type = node.type
 			if (type != "CallExpression" && type != "ImportExpression" && type != "NewExpression") {
 				return false
@@ -73,7 +70,7 @@ export default {
 		 * @param {number} start
 		 * @param {number} end
 		 * @param {[number, number][]} removed
-		 * @returns {string | null}
+		 * @returns {string}
 		 */
 		function render_without(start, end, removed) {
 			let position = start
@@ -82,9 +79,6 @@ export default {
 				if (removed_end <= start || removed_start >= end) {
 					continue
 				}
-				if (source.crosses_edit(removed_start) || source.crosses_edit(removed_end)) {
-					return null
-				}
 				let chunk_end = removed_start
 				if (text[removed_start] == ")") {
 					while (chunk_end > position && is_space(text.charCodeAt(chunk_end - 1))) {
@@ -239,12 +233,10 @@ export default {
 			const prefix = render_without(left, content_start, removed)
 			const suffix = render_without(content_end, right, removed)
 			if (
-				prefix == null
-				|| suffix == null
-				|| line_break_regex.test(prefix)
-					&& restricted_regex.test(
-						text.slice(Math.max(0, left - 7), left)
-					)
+				line_break_regex.test(prefix)
+				&& restricted_regex.test(
+					text.slice(Math.max(0, left - 7), left)
+				)
 			) {
 				return
 			}

package/src/rules/pretty-sequence.js

@@ -73,12 +73,8 @@ export default {
 				if (left <= start || text[left - 1] != "(") {
 					break
 				}
-				const right = source.skip_right(code_end, end)
-				if (right >= end || text[right] != ")") {
-					break
-				}
 				code_start = left - 1
-				code_end = right + 1
+				code_end = source.skip_right(code_end, end) + 1
 			}
 			const right = source.skip_right(code_end, end)
 			let last = right
@@ -197,10 +193,10 @@ export default {
 					node.properties,
 					object_curly_spacing
 				)
-			case "SequenceExpression":
+			default:
 				return {
 					end: node.range[1],
-					items: node.expressions,
+					items: /** @type {import("../../private.js").AstNode & import("estree").SequenceExpression} */(node)/**/.expressions,
 					line_indent: source.get_line_indent(
 						node,
 						source.get_anchor(node.range[0]),
@@ -210,7 +206,6 @@ export default {
 					start: node.range[0]
 				}
 			}
-			return undefined
 		}
 		/**
 		 * @param {import("../../private.js").AstNode} node

package/src/rules/pretty-ternary.js

@@ -23,26 +23,18 @@ export default {
 		 */
 		function collect(node, depth, gaps) {
 			const parts = get_parts(node)
-			const question = source_code.getTokenAfter(
+			const question = /** @type {import("eslint").AST.Token} */(source_code.getTokenAfter(
 				/** @type {import("estree").Node} */(/** @type {unknown} */(parts.test))/**/,
 				{
 					filter: token => token.value == "?"
 				}
-			)
-			const colon = question && source_code.getTokenAfter(
+			))/**/
+			const colon = /** @type {import("eslint").AST.Token} */(source_code.getTokenAfter(
 				/** @type {import("estree").Node} */(/** @type {unknown} */(parts.consequent))/**/,
 				{
 					filter: token => token.value == ":"
 				}
-			)
-			if (
-				!question
-				|| !colon
-				|| question.range[1] > parts.consequent.range[0]
-				|| colon.range[1] > parts.alternate.range[0]
-			) {
-				return false
-			}
+			))/**/
 			for (const operator of [ question, colon ]) {
 				const before = /** @type {import("eslint").AST.Token | import("estree").Comment} */(source_code.getTokenBefore(
 					operator,

package/src/rules/svelte-naming-convention.js

@@ -160,16 +160,14 @@ export default {
 		function declaration_edits(node, resolution) {
 			/** @type {import("../../private.js").RenameEdit[]} */
 			const edits = [ rename_edit(node) ]
-			const block = /** @type {import("../../private.js").AstNode | undefined} */(resolution.get(node)?.scope.block)/**/
+			const block = /** @type {import("../../private.js").AstNode} */(/** @type {import("eslint").Scope.Variable} */(resolution.get(node))/**/.scope.block)/**/
 			const func = function_of_param(node)
 			const leading = func && leading_comment(func)
 			/** @type {Set<import("../../private.js").Comment>} */
 			const comments = new Set(
-				block
-					? /** @type {import("../../private.js").Comment[]} */(source.getAllComments())/**/.filter(
-						comment => block.type == "Program" || comment.range[0] >= block.range[0] && comment.range[1] <= block.range[1]
-					)
-					: []
+				/** @type {import("../../private.js").Comment[]} */(source.getAllComments())/**/.filter(
+					comment => block.type == "Program" || comment.range[0] >= block.range[0] && comment.range[1] <= block.range[1]
+				)
 			)
 			if (leading) {
 				comments.add(leading)
@@ -190,7 +188,9 @@ export default {
 		 * @returns {void}
 		 */
 		function declare(node) {
-			add(declarations, node)
+			if (!is_ambient(node)) {
+				add(declarations, node)
+			}
 		}
 		/**
 		 * @param {import("../../private.js").AstNode & import("estree").Identifier} node
@@ -236,12 +236,28 @@ export default {
 			}
 			return depth > 0
 		}
+		/**
+		 * @param {import("../../private.js").AstNode} node
+		 * @returns {boolean}
+		 */
+		function is_ambient(node) {
+			for (
+				let current = /** @type {import("../../private.js").AstNode | undefined} */(node)/**/;
+				current;
+				current = current.parent
+			) {
+				if ("declare" in current && current.declare === true) {
+					return true
+				}
+			}
+			return false
+		}
 		/**
 		 * @param {import("../../private.js").AstNode} node
 		 * @returns {boolean}
 		 */
 		function is_declaration(node) {
-			for (let parent = node.parent; parent; parent = parent.parent) {
+			for (let parent = node.parent; ; parent = parent.parent) {
 				switch (parent.type) {
 				case "ArrayPattern":
 				case "AssignmentPattern":
@@ -257,7 +273,6 @@ export default {
 					return true
 				}
 			}
-			return true
 		}
 		/**
 		 * @param {import("../../private.js").AstNode} node
@@ -308,9 +323,7 @@ export default {
 				anchor = parent
 				break
 			case "VariableDeclarator":
-				if (parent.init == func) {
-					anchor = parent.parent
-				}
+				anchor = parent.parent
 			}
 			if (anchor.parent.type == "ExportDefaultDeclaration" || anchor.parent.type == "ExportNamedDeclaration") {
 				anchor = anchor.parent
@@ -771,7 +784,7 @@ export default {
 				const resolution = new Map()
 				/** @type {Map<string, import("eslint").Scope.Variable[]>} */
 				const variables_by_name = new Map()
-				const scopes = source.scopeManager?.scopes ?? []
+				const scopes = /** @type {import("eslint").Scope.ScopeManager} */(source.scopeManager)/**/.scopes
 				for (const scope of scopes) {
 					for (const variable of scope.variables) {
 						const same_names = variables_by_name.get(variable.name)
@@ -808,10 +821,9 @@ export default {
 				for (const nodes of declarations.values()) {
 					for (const node of nodes) {
 						declared.add(node)
-						const variable = resolution.get(node)
-						if (variable) {
-							renamable.add(variable)
-						}
+						renamable.add(
+							/** @type {import("eslint").Scope.Variable} */(resolution.get(node))/**/
+						)
 					}
 				}
 				/** @type {Map<string, Set<import("eslint").Scope.Scope>>} */
@@ -859,7 +871,7 @@ export default {
 					if (!others.length) {
 						return false
 					}
-					for (const variable of variables_by_name.get(name) ?? []) {
+					for (const variable of /** @type {import("eslint").Scope.Variable[]} */(variables_by_name.get(name))/**/) {
 						if (!renamable.has(variable)) {
 							continue
 						}
@@ -895,7 +907,7 @@ export default {
 				 * @returns {boolean}
 				 */
 				function has_foreign_declaration(name) {
-					return (variables_by_name.get(name) ?? []).some(
+					return /** @type {import("eslint").Scope.Variable[]} */(variables_by_name.get(name))/**/.some(
 						variable => renamable.has(variable) && variable.identifiers.some(
 							identifier => !declared.has(
 								/** @type {import("../../private.js").AstNode} */(/** @type {unknown} */(identifier))/**/
@@ -922,7 +934,7 @@ export default {
 					plans.set(
 						name,
 						{
-							atomic: !fix_same_names || variables_by_name.has(target) || nested_targets.has(target) || store_usages.has(name),
+							atomic: !fix_same_names || nodes.length > 1 || variables_by_name.has(target) || nested_targets.has(target) || store_usages.has(name),
 							exported: (export_locals.get(name) ?? []).filter(belongs),
 							fixable: !blocked.has(name)
 								&& fixable_name_regex.test(name)
@@ -936,21 +948,16 @@ export default {
 				}
 				/**
 				 * @param {import("../../private.js").NamingIdentifier} node
-				 * @param {import("../../private.js").NamingIdentifier[]} nodes
 				 * @param {import("../../private.js").NamingIdentifier[]} usages_held
 				 * @returns {import("../../private.js").RenameEdit[]}
 				 */
-				function declaration_fix(node, nodes, usages_held) {
+				function declaration_fix(node, usages_held) {
 					const variable = resolution.get(node)
 					return [
 						...declaration_edits(node, resolution),
-						...nodes.find(
-							other => resolution.get(other) == variable
-						) == node
-							? usages_held.filter(
-								usage => resolution.get(usage) == variable
-							).map(rename_edit)
-							: []
+						...usages_held.filter(
+							usage => resolution.get(usage) == variable
+						).map(rename_edit)
 					]
 				}
 				/** @type {import("../../private.js").RenameEdit[]} */
@@ -996,7 +1003,7 @@ export default {
 						for (const node of nodes) {
 							report(
 								node,
-								fixable && !used.length ? declaration_fix(node, nodes, usages_held) : null
+								fixable && !used.length ? declaration_fix(node, usages_held) : null
 							)
 						}
 					} else {

package/src/utils/skip_hole_commas.js

@@ -13,14 +13,12 @@ function skip_hole_commas(rule) {
 					{
 						report: {
 							value: (
-								/** @type {import("eslint").Rule.ReportDescriptor & { node?: import("eslint").AST.Token }} */ descriptor
+								/** @type {import("eslint").Rule.ReportDescriptor & { node: import("eslint").AST.Token }} */ descriptor
 							) => {
 								const token = descriptor.node
-								if (token?.type == "Punctuator" && token.value == ",") {
-									const before = source_code.getTokenBefore(token)
-									if (before?.value == "," && before.loc.end.line < token.loc.start.line) {
-										return
-									}
+								const before = source_code.getTokenBefore(token)
+								if (before?.value == "," && before.loc.end.line < token.loc.start.line) {
+									return
 								}
 								context.report(descriptor)
 							}

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAyNA;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,MAAM,EAbF,OAAO,QAAQ,EAAE,MAAM,CAAC,MAAM,GAAG;IACtC,OAAO,EAAE;QACP,WAAW,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,MAAM,GAAG;YAC5C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;YACvD,KAAK,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAA;SAC3C,CAAA;QACD,MAAM,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,MAAM,GAAG;YACvC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;YACvD,KAAK,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAA;SAC3C,CAAA;KACF,CAAA;CA2BL,CAAA;eAmDc,MAAM;AACrB,OAAO,EAAE,MAAM,IAAI,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AA2NA;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,MAAM,EAbF,OAAO,QAAQ,EAAE,MAAM,CAAC,MAAM,GAAG;IACtC,OAAO,EAAE;QACP,WAAW,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,MAAM,GAAG;YAC5C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;YACvD,KAAK,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAA;SAC3C,CAAA;QACD,MAAM,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,MAAM,GAAG;YACvC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;YACvD,KAAK,EAAE,OAAO,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAA;SAC3C,CAAA;KACF,CAAA;CA4BL,CAAA;eAmDc,MAAM;AACrB,OAAO,EAAE,MAAM,IAAI,gBAAgB,EAAE,CAAA"}