eslint-plugin-unicorn 41.0.1 → 42.0.0

package/configs/recommended.js

@@ -52,12 +52,14 @@ module.exports = {
 		'unicorn/no-thenable': 'error',
 		'unicorn/no-this-assignment': 'error',
 		'unicorn/no-unreadable-array-destructuring': 'error',
+		'unicorn/no-unreadable-iife': 'error',
 		'unicorn/no-unsafe-regex': 'off',
 		'unicorn/no-unused-properties': 'off',
 		'unicorn/no-useless-fallback-in-spread': 'error',
 		'unicorn/no-useless-length-check': 'error',
 		'unicorn/no-useless-promise-resolve-reject': 'error',
 		'unicorn/no-useless-spread': 'error',
+		'unicorn/no-useless-switch-case': 'error',
 		'unicorn/no-useless-undefined': 'error',
 		'unicorn/no-zero-fractions': 'error',
 		'unicorn/number-literal-case': 'error',
@@ -79,11 +81,13 @@ module.exports = {
 		'unicorn/prefer-dom-node-text-content': 'error',
 		'unicorn/prefer-export-from': 'error',
 		'unicorn/prefer-includes': 'error',
-		'unicorn/prefer-json-parse-buffer': 'error',
+		'unicorn/prefer-json-parse-buffer': 'off',
 		'unicorn/prefer-keyboard-event-key': 'error',
 		'unicorn/prefer-math-trunc': 'error',
 		'unicorn/prefer-modern-dom-apis': 'error',
+		'unicorn/prefer-modern-math-apis': 'error',
 		'unicorn/prefer-module': 'error',
+		'unicorn/prefer-native-coercion-functions': 'error',
 		'unicorn/prefer-negative-index': 'error',
 		'unicorn/prefer-node-protocol': 'error',
 		'unicorn/prefer-number-properties': 'error',
@@ -113,7 +117,7 @@ module.exports = {
 		// See #1396
 		'unicorn/require-post-message-target-origin': 'off',
 		'unicorn/string-content': 'off',
-		'unicorn/template-indent': 'warn',
+		'unicorn/template-indent': 'error',
 		'unicorn/text-encoding-identifier-case': 'error',
 		'unicorn/throw-new-error': 'error',
 	},

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "41.0.1",
+	"version": "42.0.0",
 	"description": "Various awesome ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -161,12 +161,9 @@
 				"files": [
 					"rules/**/*.js"
 				],
-				"plugins": [
-					"internal-rules"
-				],
-				"rules": {
-					"internal-rules/prefer-negative-boolean-attribute": "error"
-				}
+				"extends": [
+					"plugin:internal-rules/all"
+				]
 			}
 		]
 	},

package/readme.md

@@ -69,11 +69,11 @@ Each rule has emojis denoting:
 | [new-for-builtins](docs/rules/new-for-builtins.md) | Enforce the use of `new` for all builtins, except `String`, `Number`, `Boolean`, `Symbol` and `BigInt`. | ✅ | 🔧 |  |
 | [no-abusive-eslint-disable](docs/rules/no-abusive-eslint-disable.md) | Enforce specifying rules to disable in `eslint-disable` comments. | ✅ |  |  |
 | [no-array-callback-reference](docs/rules/no-array-callback-reference.md) | Prevent passing a function reference directly to iterator methods. | ✅ |  | 💡 |
-| [no-array-for-each](docs/rules/no-array-for-each.md) | Prefer `for…of` over `Array#forEach(…)`. | ✅ | 🔧 |  |
+| [no-array-for-each](docs/rules/no-array-for-each.md) | Prefer `for…of` over `Array#forEach(…)`. | ✅ | 🔧 | 💡 |
 | [no-array-method-this-argument](docs/rules/no-array-method-this-argument.md) | Disallow using the `this` argument in array methods. | ✅ | 🔧 | 💡 |
 | [no-array-push-push](docs/rules/no-array-push-push.md) | Enforce combining multiple `Array#push()` into one call. | ✅ | 🔧 | 💡 |
 | [no-array-reduce](docs/rules/no-array-reduce.md) | Disallow `Array#reduce()` and `Array#reduceRight()`. | ✅ |  |  |
-| [no-await-expression-member](docs/rules/no-await-expression-member.md) | Forbid member access from await expression. | ✅ | 🔧 |  |
+| [no-await-expression-member](docs/rules/no-await-expression-member.md) | Disallow member access from await expression. | ✅ | 🔧 |  |
 | [no-console-spaces](docs/rules/no-console-spaces.md) | Do not use leading/trailing space between `console.log` parameters. | ✅ | 🔧 |  |
 | [no-document-cookie](docs/rules/no-document-cookie.md) | Do not use `document.cookie` directly. | ✅ |  |  |
 | [no-empty-file](docs/rules/no-empty-file.md) | Disallow empty files. | ✅ |  |  |
@@ -89,16 +89,18 @@ Each rule has emojis denoting:
 | [no-null](docs/rules/no-null.md) | Disallow the use of the `null` literal. | ✅ | 🔧 | 💡 |
 | [no-object-as-default-parameter](docs/rules/no-object-as-default-parameter.md) | Disallow the use of objects as default parameters. | ✅ |  |  |
 | [no-process-exit](docs/rules/no-process-exit.md) | Disallow `process.exit()`. | ✅ |  |  |
-| [no-static-only-class](docs/rules/no-static-only-class.md) | Forbid classes that only have static members. | ✅ | 🔧 |  |
+| [no-static-only-class](docs/rules/no-static-only-class.md) | Disallow classes that only have static members. | ✅ | 🔧 |  |
 | [no-thenable](docs/rules/no-thenable.md) | Disallow `then` property. | ✅ |  |  |
 | [no-this-assignment](docs/rules/no-this-assignment.md) | Disallow assigning `this` to a variable. | ✅ |  |  |
 | [no-unreadable-array-destructuring](docs/rules/no-unreadable-array-destructuring.md) | Disallow unreadable array destructuring. | ✅ | 🔧 |  |
+| [no-unreadable-iife](docs/rules/no-unreadable-iife.md) | Disallow unreadable IIFEs. | ✅ |  |  |
 | [no-unsafe-regex](docs/rules/no-unsafe-regex.md) | Disallow unsafe regular expressions. |  |  |  |
 | [no-unused-properties](docs/rules/no-unused-properties.md) | Disallow unused object properties. |  |  |  |
-| [no-useless-fallback-in-spread](docs/rules/no-useless-fallback-in-spread.md) | Forbid useless fallback when spreading in object literals. | ✅ | 🔧 |  |
+| [no-useless-fallback-in-spread](docs/rules/no-useless-fallback-in-spread.md) | Disallow useless fallback when spreading in object literals. | ✅ | 🔧 |  |
 | [no-useless-length-check](docs/rules/no-useless-length-check.md) | Disallow useless array length check. | ✅ | 🔧 |  |
 | [no-useless-promise-resolve-reject](docs/rules/no-useless-promise-resolve-reject.md) | Disallow returning/yielding `Promise.resolve/reject()` in async functions or promise callbacks | ✅ | 🔧 |  |
 | [no-useless-spread](docs/rules/no-useless-spread.md) | Disallow unnecessary spread. | ✅ | 🔧 |  |
+| [no-useless-switch-case](docs/rules/no-useless-switch-case.md) | Disallow useless case in switch statements. | ✅ |  | 💡 |
 | [no-useless-undefined](docs/rules/no-useless-undefined.md) | Disallow useless `undefined`. | ✅ | 🔧 |  |
 | [no-zero-fractions](docs/rules/no-zero-fractions.md) | Disallow number literals with zero fractions or dangling dots. | ✅ | 🔧 |  |
 | [number-literal-case](docs/rules/number-literal-case.md) | Enforce proper case for numeric literals. | ✅ | 🔧 |  |
@@ -119,11 +121,13 @@ Each rule has emojis denoting:
 | [prefer-dom-node-text-content](docs/rules/prefer-dom-node-text-content.md) | Prefer `.textContent` over `.innerText`. | ✅ |  | 💡 |
 | [prefer-export-from](docs/rules/prefer-export-from.md) | Prefer `export…from` when re-exporting. | ✅ | 🔧 | 💡 |
 | [prefer-includes](docs/rules/prefer-includes.md) | Prefer `.includes()` over `.indexOf()` and `Array#some()` when checking for existence or non-existence. | ✅ | 🔧 | 💡 |
-| [prefer-json-parse-buffer](docs/rules/prefer-json-parse-buffer.md) | Prefer reading a JSON file as a buffer. | ✅ | 🔧 |  |
+| [prefer-json-parse-buffer](docs/rules/prefer-json-parse-buffer.md) | Prefer reading a JSON file as a buffer. |  | 🔧 |  |
 | [prefer-keyboard-event-key](docs/rules/prefer-keyboard-event-key.md) | Prefer `KeyboardEvent#key` over `KeyboardEvent#keyCode`. | ✅ | 🔧 |  |
 | [prefer-math-trunc](docs/rules/prefer-math-trunc.md) | Enforce the use of `Math.trunc` instead of bitwise operators. | ✅ | 🔧 | 💡 |
 | [prefer-modern-dom-apis](docs/rules/prefer-modern-dom-apis.md) | Prefer `.before()` over `.insertBefore()`, `.replaceWith()` over `.replaceChild()`, prefer one of `.before()`, `.after()`, `.append()` or `.prepend()` over `insertAdjacentText()` and `insertAdjacentElement()`. | ✅ | 🔧 |  |
+| [prefer-modern-math-apis](docs/rules/prefer-modern-math-apis.md) | Prefer modern `Math` APIs over legacy patterns. | ✅ | 🔧 |  |
 | [prefer-module](docs/rules/prefer-module.md) | Prefer JavaScript modules (ESM) over CommonJS. | ✅ | 🔧 | 💡 |
+| [prefer-native-coercion-functions](docs/rules/prefer-native-coercion-functions.md) | Prefer using `String`, `Number`, `BigInt`, `Boolean`, and `Symbol` directly. | ✅ | 🔧 |  |
 | [prefer-negative-index](docs/rules/prefer-negative-index.md) | Prefer negative index over `.length - index` for `{String,Array,TypedArray}#slice()`, `Array#splice()` and `Array#at()`. | ✅ | 🔧 |  |
 | [prefer-node-protocol](docs/rules/prefer-node-protocol.md) | Prefer using the `node:` protocol when importing Node.js builtin modules. | ✅ | 🔧 |  |
 | [prefer-number-properties](docs/rules/prefer-number-properties.md) | Prefer `Number` static properties over global ones. | ✅ | 🔧 | 💡 |
@@ -150,7 +154,7 @@ Each rule has emojis denoting:
 | [require-post-message-target-origin](docs/rules/require-post-message-target-origin.md) | Enforce using the `targetOrigin` argument with `window.postMessage()`. |  |  | 💡 |
 | [string-content](docs/rules/string-content.md) | Enforce better string content. |  | 🔧 | 💡 |
 | [template-indent](docs/rules/template-indent.md) | Fix whitespace-insensitive template indentation. | ✅ | 🔧 |  |
-| [text-encoding-identifier-case](docs/rules/text-encoding-identifier-case.md) | Enforce consistent case for text encoding identifiers. | ✅ |  | 💡 |
+| [text-encoding-identifier-case](docs/rules/text-encoding-identifier-case.md) | Enforce consistent case for text encoding identifiers. | ✅ | 🔧 | 💡 |
 | [throw-new-error](docs/rules/throw-new-error.md) | Require `new` when throwing an error. | ✅ | 🔧 |  |
 <!-- /RULES_TABLE -->
 

package/rules/ast/index.js

@@ -0,0 +1,4 @@
+'use strict';
+module.exports = {
+	isEmptyNode: require('./is-empty-node.js'),
+};

package/rules/ast/is-empty-node.js

@@ -0,0 +1,20 @@
+'use strict';
+function isEmptyNode(node, additionalEmpty) {
+	const {type} = node;
+
+	if (type === 'BlockStatement') {
+		return node.body.every(currentNode => isEmptyNode(currentNode, additionalEmpty));
+	}
+
+	if (type === 'EmptyStatement') {
+		return true;
+	}
+
+	if (additionalEmpty && additionalEmpty(node)) {
+		return true;
+	}
+
+	return false;
+}
+
+module.exports = isEmptyNode;

package/rules/no-array-for-each.js

@@ -6,20 +6,24 @@ const {
 	isSemicolonToken,
 	isClosingParenToken,
 	findVariable,
+	hasSideEffect,
 } = require('eslint-utils');
 const {methodCallSelector, referenceIdentifierSelector} = require('./selectors/index.js');
 const {extendFixRange} = require('./fix/index.js');
 const needsSemicolon = require('./utils/needs-semicolon.js');
 const shouldAddParenthesesToExpressionStatementExpression = require('./utils/should-add-parentheses-to-expression-statement-expression.js');
+const shouldAddParenthesesToMemberExpressionObject = require('./utils/should-add-parentheses-to-member-expression-object.js');
 const {getParentheses} = require('./utils/parentheses.js');
 const isFunctionSelfUsedInside = require('./utils/is-function-self-used-inside.js');
 const {isNodeMatches} = require('./utils/is-node-matches.js');
 const assertToken = require('./utils/assert-token.js');
-const {fixSpaceAroundKeyword} = require('./fix/index.js');
+const {fixSpaceAroundKeyword, removeParentheses} = require('./fix/index.js');
 
-const MESSAGE_ID = 'no-array-for-each';
+const MESSAGE_ID_ERROR = 'no-array-for-each/error';
+const MESSAGE_ID_SUGGESTION = 'no-array-for-each/suggestion';
 const messages = {
-	[MESSAGE_ID]: 'Use `for…of` instead of `Array#forEach(…)`.',
+	[MESSAGE_ID_ERROR]: 'Use `for…of` instead of `Array#forEach(…)`.',
+	[MESSAGE_ID_SUGGESTION]: 'Switch to `for…of`.',
 };
 
 const arrayForEachCallSelector = methodCallSelector({
@@ -36,6 +40,11 @@ const continueAbleNodeTypes = new Set([
 	'ForInStatement',
 ]);
 
+const stripChainExpression = node =>
+	(node.parent.type === 'ChainExpression' && node.parent.expression === node)
+		? node.parent
+		: node;
+
 function isReturnStatementInContinueAbleNodes(returnStatement, callbackFunction) {
 	for (let node = returnStatement; node && node !== callbackFunction; node = node.parent) {
 		if (continueAbleNodeTypes.has(node.type)) {
@@ -73,6 +82,9 @@ function getFixFunction(callExpression, functionInfo, context) {
 	const parameters = callback.params;
 	const array = callExpression.callee.object;
 	const {returnStatements} = functionInfo.get(callback);
+	const isOptionalArray = callExpression.callee.optional;
+	const expressionStatement = stripChainExpression(callExpression).parent;
+	const arrayText = sourceCode.getText(array);
 
 	const getForOfLoopHeadText = () => {
 		const [elementText, indexText] = parameters.map(parameter => sourceCode.getText(parameter));
@@ -84,12 +96,16 @@ function getFixFunction(callExpression, functionInfo, context) {
 		text += useEntries ? `[${indexText}, ${elementText}]` : elementText;
 		text += ' of ';
 
-		let arrayText = sourceCode.getText(array);
-		if (isParenthesized(array, sourceCode)) {
-			arrayText = `(${arrayText})`;
-		}
+		const shouldAddParenthesesToArray
+			= isParenthesized(array, sourceCode)
+			|| (
+				// `1?.forEach()` -> `(1).entries()`
+				isOptionalArray
+				&& useEntries
+				&& shouldAddParenthesesToMemberExpressionObject(array, sourceCode)
+			);
 
-		text += arrayText;
+		text += shouldAddParenthesesToArray ? `(${arrayText})` : arrayText;
 
 		if (useEntries) {
 			text += '.entries()';
@@ -193,6 +209,9 @@ function getFixFunction(callExpression, functionInfo, context) {
 	}
 
 	return function * (fixer) {
+		// `(( foo.forEach(bar => bar) ))`
+		yield * removeParentheses(callExpression, fixer, sourceCode);
+
 		// Replace these with `for (const … of …) `
 		// foo.forEach(bar =>    bar)
 		// ^^^^^^^^^^^^^^^^^^ (space after `=>` didn't included)
@@ -228,7 +247,7 @@ function getFixFunction(callExpression, functionInfo, context) {
 			yield * replaceReturnStatement(returnStatement, fixer);
 		}
 
-		const expressionStatementLastToken = sourceCode.getLastToken(callExpression.parent);
+		const expressionStatementLastToken = sourceCode.getLastToken(expressionStatement);
 		// Remove semicolon if it's not needed anymore
 		// foo.forEach(bar => {});
 		//                       ^
@@ -238,6 +257,10 @@ function getFixFunction(callExpression, functionInfo, context) {
 
 		yield * fixSpaceAroundKeyword(fixer, callExpression.parent, sourceCode);
 
+		if (isOptionalArray) {
+			yield fixer.insertTextBefore(callExpression, `if (${arrayText}) `);
+		}
+
 		// Prevent possible variable conflicts
 		yield * extendFixRange(fixer, callExpression.parent.range);
 	};
@@ -303,25 +326,13 @@ function isFunctionParameterVariableReassigned(callbackFunction, context) {
 }
 
 function isFixable(callExpression, {scope, functionInfo, allIdentifiers, context}) {
-	const sourceCode = context.getSourceCode();
 	// Check `CallExpression`
-	if (
-		callExpression.optional
-		|| isParenthesized(callExpression, sourceCode)
-		|| callExpression.arguments.length !== 1
-	) {
+	if (callExpression.optional || callExpression.arguments.length !== 1) {
 		return false;
 	}
 
-	// Check `CallExpression.parent`
-	if (callExpression.parent.type !== 'ExpressionStatement') {
-		return false;
-	}
-
-	// Check `CallExpression.callee`
-	// Because of `ChainExpression` wrapper, `foo?.forEach()` is already failed on previous check keep this just for safety
-	/* c8 ignore next 3 */
-	if (callExpression.callee.optional) {
+	// Check ancestors, we only fix `ExpressionStatement`
+	if (stripChainExpression(callExpression).parent.type !== 'ExpressionStatement') {
 		return false;
 	}
 
@@ -373,6 +384,7 @@ const create = context => {
 	const callExpressions = [];
 	const allIdentifiers = [];
 	const functionInfo = new Map();
+	const sourceCode = context.getSourceCode();
 
 	return {
 		':function'(node) {
@@ -405,13 +417,31 @@ const create = context => {
 		},
 		* 'Program:exit'() {
 			for (const {node, scope} of callExpressions) {
+				// TODO: Rename this to iteratable
+				const array = node.callee;
+
 				const problem = {
-					node: node.callee.property,
-					messageId: MESSAGE_ID,
+					node: array.property,
+					messageId: MESSAGE_ID_ERROR,
 				};
 
-				if (isFixable(node, {scope, allIdentifiers, functionInfo, context})) {
-					problem.fix = getFixFunction(node, functionInfo, context);
+				if (!isFixable(node, {scope, allIdentifiers, functionInfo, context})) {
+					yield problem;
+					continue;
+				}
+
+				const shouldUseSuggestion = array.optional && hasSideEffect(array, sourceCode);
+				const fix = getFixFunction(node, functionInfo, context);
+
+				if (shouldUseSuggestion) {
+					problem.suggest = [
+						{
+							messageId: MESSAGE_ID_SUGGESTION,
+							fix,
+						},
+					];
+				} else {
+					problem.fix = fix;
 				}
 
 				yield problem;
@@ -429,6 +459,7 @@ module.exports = {
 			description: 'Prefer `for…of` over `Array#forEach(…)`.',
 		},
 		fixable: 'code',
+		hasSuggestions: true,
 		messages,
 	},
 };

package/rules/no-await-expression-member.js

@@ -76,7 +76,7 @@ module.exports = {
 	meta: {
 		type: 'suggestion',
 		docs: {
-			description: 'Forbid member access from await expression.',
+			description: 'Disallow member access from await expression.',
 		},
 		fixable: 'code',
 		messages,

package/rules/no-empty-file.js

@@ -1,17 +1,13 @@
 'use strict';
+const {isEmptyNode} = require('./ast/index.js');
 
 const MESSAGE_ID = 'no-empty-file';
 const messages = {
 	[MESSAGE_ID]: 'Empty files are not allowed.',
 };
 
-const isEmpty = node =>
-	(
-		(node.type === 'Program' || node.type === 'BlockStatement')
-		&& node.body.every(currentNode => isEmpty(currentNode))
-	)
-	|| node.type === 'EmptyStatement'
-	|| (node.type === 'ExpressionStatement' && 'directive' in node);
+const isDirective = node => node.type === 'ExpressionStatement' && 'directive' in node;
+const isEmpty = node => isEmptyNode(node, isDirective);
 
 const isTripleSlashDirective = node =>
 	node.type === 'Line' && node.value.startsWith('/');
@@ -29,7 +25,7 @@ const create = context => {
 
 	return {
 		Program(node) {
-			if (!isEmpty(node)) {
+			if (node.body.some(node => !isEmpty(node))) {
 				return;
 			}
 

package/rules/no-static-only-class.js

@@ -221,7 +221,7 @@ module.exports = {
 	meta: {
 		type: 'suggestion',
 		docs: {
-			description: 'Forbid classes that only have static members.',
+			description: 'Disallow classes that only have static members.',
 		},
 		fixable: 'code',
 		messages,

package/rules/no-unreadable-iife.js

@@ -0,0 +1,48 @@
+'use strict';
+const {
+	isParenthesized,
+	getParenthesizedRange,
+} = require('./utils/parentheses.js');
+const toLocation = require('./utils/to-location.js');
+
+const MESSAGE_ID_ERROR = 'no-unreadable-iife';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'IIFE with parenthesized arrow function body is considered unreadable.',
+};
+
+const selector = [
+	'CallExpression',
+	' > ',
+	'ArrowFunctionExpression.callee',
+	' > ',
+	':not(BlockStatement).body',
+].join('');
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	[selector](node) {
+		const sourceCode = context.getSourceCode();
+		if (!isParenthesized(node, sourceCode)) {
+			return;
+		}
+
+		return {
+			node,
+			loc: toLocation(getParenthesizedRange(node, sourceCode), sourceCode),
+			messageId: MESSAGE_ID_ERROR,
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow unreadable IIFEs.',
+		},
+		hasSuggestions: false,
+		messages,
+	},
+};

package/rules/no-useless-fallback-in-spread.js

@@ -62,7 +62,7 @@ module.exports = {
 	meta: {
 		type: 'suggestion',
 		docs: {
-			description: 'Forbid useless fallback when spreading in object literals.',
+			description: 'Disallow useless fallback when spreading in object literals.',
 		},
 		fixable: 'code',
 		messages,

package/rules/no-useless-switch-case.js

@@ -0,0 +1,71 @@
+'use strict';
+const {isEmptyNode} = require('./ast/index.js');
+const getSwitchCaseHeadLocation = require('./utils/get-switch-case-head-location.js');
+
+const MESSAGE_ID_ERROR = 'no-useless-switch-case/error';
+const MESSAGE_ID_SUGGESTION = 'no-useless-switch-case/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Useless case in switch statement.',
+	[MESSAGE_ID_SUGGESTION]: 'Remove this case.',
+};
+
+const isEmptySwitchCase = node => node.consequent.every(node => isEmptyNode(node));
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	* 'SwitchStatement[cases.length>1]'(switchStatement) {
+		const {cases} = switchStatement;
+
+		// TypeScript allows multiple `default` cases
+		const defaultCases = cases.filter(switchCase => switchCase.test === null);
+		if (defaultCases.length !== 1) {
+			return;
+		}
+
+		const [defaultCase] = defaultCases;
+
+		// We only check cases where the last case is the `default` case
+		if (defaultCase !== cases[cases.length - 1]) {
+			return;
+		}
+
+		const uselessCases = [];
+
+		for (let index = cases.length - 2; index >= 0; index--) {
+			const node = cases[index];
+			if (isEmptySwitchCase(node)) {
+				uselessCases.unshift(node);
+			} else {
+				break;
+			}
+		}
+
+		for (const node of uselessCases) {
+			yield {
+				node,
+				loc: getSwitchCaseHeadLocation(node, context.getSourceCode()),
+				messageId: MESSAGE_ID_ERROR,
+				suggest: [
+					{
+						messageId: MESSAGE_ID_SUGGESTION,
+						/** @param {import('eslint').Rule.RuleFixer} fixer */
+						fix: fixer => fixer.remove(node),
+					},
+				],
+			};
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow useless case in switch statements.',
+		},
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/no-useless-undefined.js

@@ -91,6 +91,13 @@ const getFunction = scope => {
 	}
 };
 
+const isFunctionBindCall = node =>
+	!node.optional
+	&& node.callee.type === 'MemberExpression'
+	&& !node.callee.computed
+	&& node.callee.property.type === 'Identifier'
+	&& node.callee.property.name === 'bind';
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	const listener = (fix, checkFunctionReturnType) => node => {
@@ -142,6 +149,12 @@ const create = context => {
 			}
 
 			const argumentNodes = node.arguments;
+
+			// Ignore arguments in `Function#bind()`, but not `this` argument
+			if (isFunctionBindCall(node) && argumentNodes.length !== 1) {
+				return;
+			}
+
 			const undefinedArguments = [];
 			for (let index = argumentNodes.length - 1; index >= 0; index--) {
 				const node = argumentNodes[index];

package/rules/prefer-modern-dom-apis.js

@@ -23,7 +23,7 @@ const replaceChildOrInsertBeforeSelector = [
 	'[callee.object.type="Identifier"]',
 ].join('');
 
-const forbiddenMethods = new Map([
+const disallowedMethods = new Map([
 	['replaceChild', 'replaceWith'],
 	['insertBefore', 'before'],
 ]);
@@ -32,7 +32,7 @@ const checkForReplaceChildOrInsertBefore = (context, node) => {
 	const method = node.callee.property.name;
 	const parentNode = node.callee.object.name;
 	const [newChildNode, oldChildNode] = node.arguments.map(({name}) => name);
-	const preferredMethod = forbiddenMethods.get(method);
+	const preferredMethod = disallowedMethods.get(method);
 
 	const fix = isValueNotUsable(node)
 		? fixer => fixer.replaceText(

package/rules/prefer-modern-math-apis.js

@@ -0,0 +1,138 @@
+'use strict';
+const {getParenthesizedText} = require('./utils/parentheses.js');
+
+const MESSAGE_ID = 'prefer-modern-math-apis';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `{{replacement}}` over `{{description}}`.',
+};
+
+const isMathProperty = (node, property) =>
+	node.type === 'MemberExpression'
+	&& !node.optional
+	&& !node.computed
+	&& node.object.type === 'Identifier'
+	&& node.object.name === 'Math'
+	&& node.property.type === 'Identifier'
+	&& node.property.name === property;
+
+const isMathMethodCall = (node, method) =>
+	node.type === 'CallExpression'
+	&& !node.optional
+	&& isMathProperty(node.callee, method)
+	&& node.arguments.length === 1
+	&& node.arguments[0].type !== 'SpreadElement';
+
+// `Math.log(x) * Math.LOG10E` -> `Math.log10(x)`
+// `Math.LOG10E * Math.log(x)` -> `Math.log10(x)`
+// `Math.log(x) * Math.LOG2E` -> `Math.log2(x)`
+// `Math.LOG2E * Math.log(x)` -> `Math.log2(x)`
+function createLogCallTimesConstantCheck({constantName, replacementMethod}) {
+	const replacement = `Math.${replacementMethod}(…)`;
+
+	return function (node, context) {
+		if (!(node.type === 'BinaryExpression' && node.operator === '*')) {
+			return;
+		}
+
+		let mathLogCall;
+		let description;
+		if (isMathMethodCall(node.left, 'log') && isMathProperty(node.right, constantName)) {
+			mathLogCall = node.left;
+			description = `Math.log(…) * Math.${constantName}`;
+		} else if (isMathMethodCall(node.right, 'log') && isMathProperty(node.left, constantName)) {
+			mathLogCall = node.right;
+			description = `Math.${constantName} * Math.log(…)`;
+		}
+
+		if (!mathLogCall) {
+			return;
+		}
+
+		const [valueNode] = mathLogCall.arguments;
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			data: {
+				replacement,
+				description,
+			},
+			fix: fixer => fixer.replaceText(node, `Math.${replacementMethod}(${getParenthesizedText(valueNode, context.getSourceCode())})`),
+		};
+	};
+}
+
+// `Math.log(x) / Math.LN10` -> `Math.log10(x)`
+// `Math.log(x) / Math.LN2` -> `Math.log2(x)`
+function createLogCallDivideConstantCheck({constantName, replacementMethod}) {
+	const message = {
+		messageId: MESSAGE_ID,
+		data: {
+			replacement: `Math.${replacementMethod}(…)`,
+			description: `Math.log(…) / Math.${constantName}`,
+		},
+	};
+
+	return function (node, context) {
+		if (
+			!(
+				node.type === 'BinaryExpression'
+				&& node.operator === '/'
+				&& isMathMethodCall(node.left, 'log')
+				&& isMathProperty(node.right, constantName)
+			)
+		) {
+			return;
+		}
+
+		const [valueNode] = node.left.arguments;
+
+		return {
+			...message,
+			node,
+			fix: fixer => fixer.replaceText(node, `Math.${replacementMethod}(${getParenthesizedText(valueNode, context.getSourceCode())})`),
+		};
+	};
+}
+
+const checkFunctions = [
+	createLogCallTimesConstantCheck({constantName: 'LOG10E', replacementMethod: 'log10'}),
+	createLogCallTimesConstantCheck({constantName: 'LOG2E', replacementMethod: 'log2'}),
+	createLogCallDivideConstantCheck({constantName: 'LN10', replacementMethod: 'log10'}),
+	createLogCallDivideConstantCheck({constantName: 'LN2', replacementMethod: 'log2'}),
+];
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const nodes = [];
+
+	return {
+		BinaryExpression(node) {
+			nodes.push(node);
+		},
+		* 'Program:exit'() {
+			for (const node of nodes) {
+				for (const getProblem of checkFunctions) {
+					const problem = getProblem(node, context);
+
+					if (problem) {
+						yield problem;
+					}
+				}
+			}
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer modern `Math` APIs over legacy patterns.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-native-coercion-functions.js

@@ -0,0 +1,182 @@
+'use strict';
+const {getFunctionHeadLocation, getFunctionNameWithKind} = require('eslint-utils');
+const {not} = require('./selectors/index.js');
+
+const MESSAGE_ID = 'prefer-native-coercion-functions';
+const messages = {
+	[MESSAGE_ID]: '{{functionNameWithKind}} is equivalent to `{{replacementFunction}}`. Use `{{replacementFunction}}` directly.',
+};
+
+const nativeCoercionFunctionNames = new Set(['String', 'Number', 'BigInt', 'Boolean', 'Symbol']);
+const arrayMethodsWithBooleanCallback = new Set(['every', 'filter', 'find', 'findIndex', 'some']);
+
+const isNativeCoercionFunctionCall = (node, firstArgumentName) =>
+	node
+	&& node.type === 'CallExpression'
+	&& !node.optional
+	&& node.callee.type === 'Identifier'
+	&& nativeCoercionFunctionNames.has(node.callee.name)
+	&& node.arguments[0]
+	&& node.arguments[0].type === 'Identifier'
+	&& node.arguments[0].name === firstArgumentName;
+
+const isIdentityFunction = node =>
+	(
+		// `v => v`
+		node.type === 'ArrowFunctionExpression'
+		&& node.body.type === 'Identifier'
+		&& node.body.name === node.params[0].name
+	)
+	|| (
+		// `(v) => {return v;}`
+		// `function (v) {return v;}`
+		node.body.type === 'BlockStatement'
+		&& node.body.body.length === 1
+		&& node.body.body[0].type === 'ReturnStatement'
+		&& node.body.body[0].argument
+		&& node.body.body[0].argument.type === 'Identifier'
+		&& node.body.body[0].argument.name === node.params[0].name
+	);
+
+const isArrayIdentityCallback = node =>
+	isIdentityFunction(node)
+	&& node.parent.type === 'CallExpression'
+	&& !node.parent.optional
+	&& node.parent.arguments[0] === node
+	&& node.parent.callee.type === 'MemberExpression'
+	&& !node.parent.callee.computed
+	&& !node.parent.callee.optional
+	&& node.parent.callee.property.type === 'Identifier'
+	&& arrayMethodsWithBooleanCallback.has(node.parent.callee.property.name);
+
+function getCallExpression(node) {
+	const firstParameterName = node.params[0].name;
+
+	// `(v) => String(v)`
+	if (
+		node.type === 'ArrowFunctionExpression'
+		&& isNativeCoercionFunctionCall(node.body, firstParameterName)
+	) {
+		return node.body;
+	}
+
+	// `(v) => {return String(v);}`
+	// `function (v) {return String(v);}`
+	if (
+		node.body.type === 'BlockStatement'
+		&& node.body.body.length === 1
+		&& node.body.body[0].type === 'ReturnStatement'
+		&& isNativeCoercionFunctionCall(node.body.body[0].argument, firstParameterName)
+	) {
+		return node.body.body[0].argument;
+	}
+}
+
+const functionsSelector = [
+	':function',
+	'[async!=true]',
+	'[generator!=true]',
+	'[params.length>0]',
+	'[params.0.type="Identifier"]',
+	not([
+		'MethodDefinition[kind="constructor"] > .value',
+		'MethodDefinition[kind="set"] > .value',
+		'Property[kind="set"] > .value',
+	]),
+].join('');
+
+function getArrayCallbackProblem(node) {
+	if (!isArrayIdentityCallback(node)) {
+		return;
+	}
+
+	return {
+		replacementFunction: 'Boolean',
+		fix: fixer => fixer.replaceText(node, 'Boolean'),
+	};
+}
+
+function getCoercionFunctionProblem(node) {
+	const callExpression = getCallExpression(node);
+
+	if (!callExpression) {
+		return;
+	}
+
+	const {name} = callExpression.callee;
+
+	const problem = {replacementFunction: name};
+
+	if (node.type === 'FunctionDeclaration' || callExpression.arguments.length !== 1) {
+		return problem;
+	}
+
+	/** @param {import('eslint').Rule.RuleFixer} fixer */
+	problem.fix = fixer => {
+		let text = name;
+
+		if (
+			node.parent.type === 'Property'
+			&& node.parent.method
+			&& node.parent.value === node
+		) {
+			text = `: ${text}`;
+		} else if (node.parent.type === 'MethodDefinition') {
+			text = ` = ${text};`;
+		}
+
+		return fixer.replaceText(node, text);
+	};
+
+	return problem;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	[functionsSelector](node) {
+		let problem = getArrayCallbackProblem(node) || getCoercionFunctionProblem(node);
+
+		if (!problem) {
+			return;
+		}
+
+		const sourceCode = context.getSourceCode();
+		const {replacementFunction, fix} = problem;
+
+		problem = {
+			node,
+			loc: getFunctionHeadLocation(node, sourceCode),
+			messageId: MESSAGE_ID,
+			data: {
+				functionNameWithKind: getFunctionNameWithKind(node, sourceCode),
+				replacementFunction,
+			},
+		};
+
+		/*
+		We do not fix if there are:
+		- Comments: No proper place to put them.
+		- Extra parameters: Removing them may break types.
+		*/
+		if (!fix || node.params.length !== 1 || sourceCode.getCommentsInside(node).length > 0) {
+			return problem;
+		}
+
+		problem.fix = fix;
+
+		return problem;
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer using `String`, `Number`, `BigInt`, `Boolean`, and `Symbol` directly.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-object-from-entries.js

@@ -183,10 +183,6 @@ function create(context) {
 
 	for (const {selector, test, getProperty} of fixableArrayReduceCases) {
 		listeners[selector] = node => {
-			// If this listener exits without adding a fix, the `arrayReduceWithEmptyObject` listener
-			// should still add it into the `arrayReduce` map. To be safer, add it here too.
-			arrayReduce.set(node, undefined);
-
 			const [callbackFunction] = node.arguments;
 			if (!test(callbackFunction)) {
 				return;
@@ -211,12 +207,6 @@ function create(context) {
 		};
 	}
 
-	listeners[arrayReduceWithEmptyObject] = node => {
-		if (!arrayReduce.has(node)) {
-			arrayReduce.set(node, undefined);
-		}
-	};
-
 	listeners['Program:exit'] = () => {
 		for (const [node, fix] of arrayReduce.entries()) {
 			context.report({

package/rules/prefer-query-selector.js

@@ -14,7 +14,7 @@ const selector = [
 	notDomNodeSelector('callee.object'),
 ].join('');
 
-const forbiddenIdentifierNames = new Map([
+const disallowedIdentifierNames = new Map([
 	['getElementById', 'querySelector'],
 	['getElementsByClassName', 'querySelectorAll'],
 	['getElementsByTagName', 'querySelectorAll'],
@@ -103,7 +103,7 @@ const fix = (node, identifierName, preferredSelector) => {
 const create = () => ({
 	[selector](node) {
 		const method = node.callee.property.name;
-		const preferredSelector = forbiddenIdentifierNames.get(method);
+		const preferredSelector = disallowedIdentifierNames.get(method);
 
 		const problem = {
 			node: node.callee.property,

package/rules/prefer-string-trim-start-end.js

@@ -10,6 +10,7 @@ const selector = [
 	methodCallSelector({
 		methods: ['trimLeft', 'trimRight'],
 		argumentsLength: 0,
+		includeOptionalMember: true,
 	}),
 	' > .callee',
 	' > .property',

package/rules/prefer-ternary.js

@@ -194,61 +194,65 @@ const create = context => {
 				return;
 			}
 
-			const scope = context.getScope();
-
-			return {
-				node,
-				messageId,
-				* fix(fixer) {
-					const testText = getText(node.test);
-					const consequentText = typeof result.consequent === 'string'
-						? result.consequent
-						: getText(result.consequent);
-					const alternateText = typeof result.alternate === 'string'
-						? result.alternate
-						: getText(result.alternate);
-
-					let {type, before, after} = result;
-
-					let generateNewVariables = false;
-					if (type === 'ThrowStatement') {
-						const scopes = getScopes(scope);
-						const errorName = avoidCapture('error', scopes, isSafeName);
-
-						for (const scope of scopes) {
-							if (!scopeToNamesGeneratedByFixer.has(scope)) {
-								scopeToNamesGeneratedByFixer.set(scope, new Set());
-							}
-
-							const generatedNames = scopeToNamesGeneratedByFixer.get(scope);
-							generatedNames.add(errorName);
-						}
+			const problem = {node, messageId};
 
-						const indentString = getIndentString(node, sourceCode);
+			// Don't fix if there are comments
+			if (sourceCode.getCommentsInside(node).length > 0) {
+				return problem;
+			}
 
-						after = after
-							.replace('{{INDENT_STRING}}', indentString)
-							.replace('{{ERROR_NAME}}', errorName);
-						before = before
-							.replace('{{INDENT_STRING}}', indentString)
-							.replace('{{ERROR_NAME}}', errorName);
-						generateNewVariables = true;
-					}
+			const scope = context.getScope();
+			problem.fix = function * (fixer) {
+				const testText = getText(node.test);
+				const consequentText = typeof result.consequent === 'string'
+					? result.consequent
+					: getText(result.consequent);
+				const alternateText = typeof result.alternate === 'string'
+					? result.alternate
+					: getText(result.alternate);
+
+				let {type, before, after} = result;
+
+				let generateNewVariables = false;
+				if (type === 'ThrowStatement') {
+					const scopes = getScopes(scope);
+					const errorName = avoidCapture('error', scopes, isSafeName);
+
+					for (const scope of scopes) {
+						if (!scopeToNamesGeneratedByFixer.has(scope)) {
+							scopeToNamesGeneratedByFixer.set(scope, new Set());
+						}
 
-					let fixed = `${before}${testText} ? ${consequentText} : ${alternateText}${after}`;
-					const tokenBefore = sourceCode.getTokenBefore(node);
-					const shouldAddSemicolonBefore = needsSemicolon(tokenBefore, sourceCode, fixed);
-					if (shouldAddSemicolonBefore) {
-						fixed = `;${fixed}`;
+						const generatedNames = scopeToNamesGeneratedByFixer.get(scope);
+						generatedNames.add(errorName);
 					}
 
-					yield fixer.replaceText(node, fixed);
-
-					if (generateNewVariables) {
-						yield * extendFixRange(fixer, sourceCode.ast.range);
-					}
-				},
+					const indentString = getIndentString(node, sourceCode);
+
+					after = after
+						.replace('{{INDENT_STRING}}', indentString)
+						.replace('{{ERROR_NAME}}', errorName);
+					before = before
+						.replace('{{INDENT_STRING}}', indentString)
+						.replace('{{ERROR_NAME}}', errorName);
+					generateNewVariables = true;
+				}
+
+				let fixed = `${before}${testText} ? ${consequentText} : ${alternateText}${after}`;
+				const tokenBefore = sourceCode.getTokenBefore(node);
+				const shouldAddSemicolonBefore = needsSemicolon(tokenBefore, sourceCode, fixed);
+				if (shouldAddSemicolonBefore) {
+					fixed = `;${fixed}`;
+				}
+
+				yield fixer.replaceText(node, fixed);
+
+				if (generateNewVariables) {
+					yield * extendFixRange(fixer, sourceCode.ast.range);
+				}
 			};
+
+			return problem;
 		},
 	};
 };

package/rules/shared/abbreviations.js

@@ -59,6 +59,9 @@ module.exports.defaultReplacements = {
 	dirs: {
 		directories: true,
 	},
+	dist: {
+		distribution: true,
+	},
 	doc: {
 		document: true,
 	},
@@ -66,6 +69,11 @@ module.exports.defaultReplacements = {
 		documentation: true,
 		documents: true,
 	},
+	dst: {
+		daylightSavingTime: true,
+		destination: true,
+		distribution: true,
+	},
 	e: {
 		error: true,
 		event: true,

package/rules/text-encoding-identifier-case.js

@@ -19,6 +19,19 @@ const getReplacement = encoding => {
 	}
 };
 
+// `fs.{readFile,readFileSync}()`
+const isFsReadFileEncoding = node =>
+	node.parent.type === 'CallExpression'
+	&& !node.parent.optional
+	&& node.parent.arguments[1] === node
+	&& node.parent.arguments[0]
+	&& node.parent.arguments[0].type !== 'SpreadElement'
+	&& node.parent.callee.type === 'MemberExpression'
+	&& !node.parent.callee.optional
+	&& !node.parent.callee.computed
+	&& node.parent.callee.property.type === 'Identifier'
+	&& (node.parent.callee.property.name === 'readFile' || node.parent.callee.property.name === 'readFileSync');
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = () => ({
 	Literal(node) {
@@ -39,19 +52,29 @@ const create = () => ({
 			replacement,
 		};
 
-		return {
+		/** @param {import('eslint').Rule.RuleFixer} fixer */
+		const fix = fixer => replaceStringLiteral(fixer, node, replacement);
+
+		const problem = {
 			node,
 			messageId: MESSAGE_ID_ERROR,
 			data: messageData,
-			suggest: [
-				{
-					messageId: MESSAGE_ID_SUGGESTION,
-					data: messageData,
-					/** @param {import('eslint').Rule.RuleFixer} fixer */
-					fix: fixer => replaceStringLiteral(fixer, node, replacement),
-				},
-			],
 		};
+
+		if (isFsReadFileEncoding(node)) {
+			problem.fix = fix;
+			return problem;
+		}
+
+		problem.suggest = [
+			{
+				messageId: MESSAGE_ID_SUGGESTION,
+				data: messageData,
+				fix: fixer => replaceStringLiteral(fixer, node, replacement),
+			},
+		];
+
+		return problem;
 	},
 });
 
@@ -63,6 +86,7 @@ module.exports = {
 		docs: {
 			description: 'Enforce consistent case for text encoding identifiers.',
 		},
+		fixable: 'code',
 		hasSuggestions: true,
 		messages,
 	},

package/rules/utils/get-switch-case-head-location.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const {isColonToken} = require('eslint-utils');
+
+/**
+@typedef {line: number, column: number} Position
+
+Get the location of the given `SwitchCase` node for reporting.
+
+@param {Node} node - The `SwitchCase` node to get.
+@param {SourceCode} sourceCode - The source code object to get tokens from.
+@returns {{start: Position, end: Position}} The location of the class node for reporting.
+*/
+function getSwitchCaseHeadLocation(node, sourceCode) {
+	const startToken = node.test || sourceCode.getFirstToken(node);
+	const colonToken = sourceCode.getTokenAfter(startToken, isColonToken);
+
+	return {start: node.loc.start, end: colonToken.loc.end};
+}
+
+module.exports = getSwitchCaseHeadLocation;