eslint-plugin-unicorn 28.0.2 → 29.0.0

package/index.js

@@ -71,6 +71,7 @@ module.exports = {
 				'unicorn/no-null': 'error',
 				'unicorn/no-object-as-default-parameter': 'error',
 				'unicorn/no-process-exit': 'error',
+				'unicorn/no-static-only-class': 'error',
 				'unicorn/no-this-assignment': 'error',
 				'unicorn/no-unreadable-array-destructuring': 'error',
 				'unicorn/no-unsafe-regex': 'off',
@@ -83,6 +84,8 @@ module.exports = {
 				'unicorn/prefer-add-event-listener': 'error',
 				'unicorn/prefer-array-find': 'error',
 				// TODO: Enable this by default when targeting Node.js 12.
+				'unicorn/prefer-array-flat': 'off',
+				// TODO: Enable this by default when targeting Node.js 12.
 				'unicorn/prefer-array-flat-map': 'off',
 				'unicorn/prefer-array-index-of': 'error',
 				'unicorn/prefer-array-some': 'error',

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "28.0.2",
+	"version": "29.0.0",
 	"description": "Various awesome ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -16,7 +16,7 @@
 	"scripts": {
 		"test": "xo && nyc ava",
 		"create-rule": "node ./scripts/create-rule.js",
-		"run-rules-on-codebase": "node ./test/run-rules-on-codebase/lint.js",
+		"run-rules-on-codebase": "node ./test/run-rules-on-codebase/lint.mjs",
 		"integration": "node ./test/integration/test.js",
 		"smoke": "eslint-remote-tester --config ./test/smoke/eslint-remote-tester.config.js"
 	},
@@ -35,52 +35,52 @@
 		"xo"
 	],
 	"dependencies": {
-		"ci-info": "^2.0.0",
+		"ci-info": "^3.1.1",
 		"clean-regexp": "^1.0.0",
-		"eslint-template-visitor": "^2.2.2",
+		"eslint-template-visitor": "^2.3.2",
 		"eslint-utils": "^2.1.0",
 		"eslint-visitor-keys": "^2.0.0",
 		"import-modules": "^2.1.0",
 		"lodash": "^4.17.20",
 		"pluralize": "^8.0.0",
 		"read-pkg-up": "^7.0.1",
-		"regexp-tree": "^0.1.22",
+		"regexp-tree": "^0.1.23",
 		"reserved-words": "^0.1.2",
 		"safe-regex": "^2.1.1",
 		"semver": "^7.3.4"
 	},
 	"devDependencies": {
-		"@ava/babel": "^1.0.1",
 		"@babel/code-frame": "7.12.13",
-		"@babel/core": "7.12.10",
-		"@babel/eslint-parser": "7.12.1",
+		"@babel/core": "7.12.17",
+		"@babel/eslint-parser": "7.12.17",
 		"@lubien/fixture-beta-package": "^1.0.0-beta.1",
-		"@typescript-eslint/parser": "^4.12.0",
+		"@typescript-eslint/parser": "^4.15.1",
 		"ava": "^3.15.0",
 		"babel-eslint": "^10.1.0",
 		"chalk": "^4.1.0",
 		"enquirer": "2.3.6",
-		"eslint": "^7.15.0",
+		"eslint": "^7.20.0",
 		"eslint-ava-rule-tester": "^4.0.0",
 		"eslint-plugin-eslint-plugin": "^2.3.0",
 		"eslint-remote-tester": "^1.1.0",
 		"execa": "^5.0.0",
 		"listr": "^0.14.3",
+		"lodash-es": "4.17.20",
 		"mem": "8.0.0",
 		"nyc": "^15.1.0",
 		"outdent": "^0.8.0",
 		"pify": "^5.0.0",
-		"typescript": "^4.1.3",
-		"vue-eslint-parser": "^7.3.0",
-		"xo": "^0.37.1"
+		"typescript": "^4.1.5",
+		"vue-eslint-parser": "^7.5.0",
+		"xo": "^0.38.1"
 	},
 	"peerDependencies": {
-		"eslint": ">=7.17.0"
+		"eslint": ">=7.20.0"
 	},
 	"ava": {
-		"babel": true,
 		"files": [
-			"test/*.js"
+			"test/*.mjs",
+			"test/unit/*.mjs"
 		]
 	},
 	"nyc": {
@@ -114,7 +114,6 @@
 			},
 			{
 				"files": [
-					"test/*.js",
 					"**/*.mjs"
 				],
 				"parserOptions": {
@@ -124,6 +123,14 @@
 		],
 		"rules": {
 			"strict": "error",
+			"node/no-unsupported-features/node-builtins": [
+				"off",
+				{
+					"ignores": [
+						"module.createRequire"
+					]
+				}
+			],
 			"unicorn/no-null": "error",
 			"unicorn/prevent-abbreviations": [
 				"error",

package/readme.md

@@ -65,6 +65,7 @@ Configure it in `package.json`.
 			"unicorn/no-null": "error",
 			"unicorn/no-object-as-default-parameter": "error",
 			"unicorn/no-process-exit": "error",
+			"unicorn/no-static-only-class": "error",
 			"unicorn/no-this-assignment": "error",
 			"unicorn/no-unreadable-array-destructuring": "error",
 			"unicorn/no-unsafe-regex": "off",
@@ -75,6 +76,7 @@ Configure it in `package.json`.
 			"unicorn/numeric-separators-style": "off",
 			"unicorn/prefer-add-event-listener": "error",
 			"unicorn/prefer-array-find": "error",
+			"unicorn/prefer-array-flat": "error",
 			"unicorn/prefer-array-flat-map": "error",
 			"unicorn/prefer-array-index-of": "error",
 			"unicorn/prefer-array-some": "error",
@@ -143,6 +145,7 @@ Configure it in `package.json`.
 - [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. *(partly fixable)*
 - [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. *(partly fixable)*
 - [no-unsafe-regex](docs/rules/no-unsafe-regex.md) - Disallow unsafe regular expressions.
@@ -153,6 +156,7 @@ Configure it in `package.json`.
 - [numeric-separators-style](docs/rules/numeric-separators-style.md) - Enforce the style of numeric separators by correctly grouping digits. *(fixable)*
 - [prefer-add-event-listener](docs/rules/prefer-add-event-listener.md) - Prefer `.addEventListener()` and `.removeEventListener()` over `on`-functions. *(partly fixable)*
 - [prefer-array-find](docs/rules/prefer-array-find.md) - Prefer `.find(…)` over the first element from `.filter(…)`. *(partly fixable)*
+- [prefer-array-flat](docs/rules/prefer-array-flat.md) - Prefer `Array#flat()` over legacy techniques to flatten arrays. *(fixable)*
 - [prefer-array-flat-map](docs/rules/prefer-array-flat-map.md) - Prefer `.flatMap(…)` over `.map(…).flat()`. *(fixable)*
 - [prefer-array-index-of](docs/rules/prefer-array-index-of.md) - Prefer `Array#indexOf()` over `Array#findIndex()` when looking for the index of an item. *(partly fixable)*
 - [prefer-array-some](docs/rules/prefer-array-some.md) - Prefer `.some(…)` over `.find(…)`.
@@ -173,7 +177,7 @@ Configure it in `package.json`.
 - [prefer-reflect-apply](docs/rules/prefer-reflect-apply.md) - Prefer `Reflect.apply()` over `Function#apply()`. *(fixable)*
 - [prefer-regexp-test](docs/rules/prefer-regexp-test.md) - Prefer `RegExp#test()` over `String#match()` and `RegExp#exec()`. *(fixable)*
 - [prefer-set-has](docs/rules/prefer-set-has.md) - Prefer `Set#has()` over `Array#includes()` when checking for existence or non-existence. *(fixable)*
-- [prefer-spread](docs/rules/prefer-spread.md) - Prefer the spread operator over `Array.from()` and `Array#concat()`. *(partly fixable)*
+- [prefer-spread](docs/rules/prefer-spread.md) - Prefer the spread operator over `Array.from(…)`, `Array#concat(…)` and `Array#slice()`. *(partly fixable)*
 - [prefer-string-replace-all](docs/rules/prefer-string-replace-all.md) - Prefer `String#replaceAll()` over regex searches with the global flag. *(fixable)*
 - [prefer-string-slice](docs/rules/prefer-string-slice.md) - Prefer `String#slice()` over `String#substr()` and `String#substring()`. *(partly fixable)*
 - [prefer-string-starts-ends-with](docs/rules/prefer-string-starts-ends-with.md) - Prefer `String#startsWith()` & `String#endsWith()` over `RegExp#test()`. *(fixable)*

package/rules/filename-case.js

@@ -137,9 +137,7 @@ function englishishJoinWords(words) {
 		return `${words[0]} or ${words[1]}`;
 	}
 
-	words = words.slice();
-	const last = words.pop();
-	return `${words.join(', ')}, or ${last}`;
+	return `${words.slice(0, -1).join(', ')}, or ${words[words.length - 1]}`;
 }
 
 const create = context => {

package/rules/no-array-callback-reference.js

@@ -3,7 +3,7 @@ const {isParenthesized} = require('eslint-utils');
 const getDocumentationUrl = require('./utils/get-documentation-url');
 const methodSelector = require('./utils/method-selector');
 const {notFunctionSelector} = require('./utils/not-function');
-const isNodeMatches = require('./utils/is-node-matches');
+const {isNodeMatches} = require('./utils/is-node-matches');
 
 const ERROR_WITH_NAME_MESSAGE_ID = 'error-with-name';
 const ERROR_WITHOUT_NAME_MESSAGE_ID = 'error-without-name';

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

@@ -14,7 +14,8 @@ const shouldAddParenthesesToExpressionStatementExpression = require('./utils/sho
 const getParenthesizedTimes = require('./utils/get-parenthesized-times');
 const extendFixRange = require('./utils/extend-fix-range');
 const isFunctionSelfUsedInside = require('./utils/is-function-self-used-inside');
-const isNodeMatches = require('./utils/is-node-matches');
+const {isNodeMatches} = require('./utils/is-node-matches');
+const assertToken = require('./utils/assert-token');
 
 const MESSAGE_ID = 'no-array-for-each';
 const messages = {
@@ -23,7 +24,8 @@ const messages = {
 
 const arrayForEachCallSelector = methodSelector({
 	name: 'forEach',
-	includeOptional: true
+	includeOptionalCall: true,
+	includeOptionalMember: true
 });
 
 const continueAbleNodeTypes = new Set([
@@ -48,15 +50,16 @@ function getFixFunction(callExpression, sourceCode, functionInfo) {
 	const [callback] = callExpression.arguments;
 	const parameters = callback.params;
 	const array = callExpression.callee.object;
-	const {returnStatements} = functionInfo.get(callback);
+	const {returnStatements, scope} = functionInfo.get(callback);
 
 	const getForOfLoopHeadText = () => {
 		const [elementText, indexText] = parameters.map(parameter => sourceCode.getText(parameter));
 		const useEntries = parameters.length === 2;
 
-		let text = 'for (const ';
+		let text = 'for (';
+		text += parameters.some(parameter => isParameterReassigned(parameter, scope)) ? 'let' : 'const';
+		text += ' ';
 		text += useEntries ? `[${indexText}, ${elementText}]` : elementText;
-
 		text += ' of ';
 
 		let arrayText = sourceCode.getText(array);
@@ -81,6 +84,9 @@ function getFixFunction(callExpression, sourceCode, functionInfo) {
 		if (callback.body.type === 'BlockStatement') {
 			end = callback.body.range[0];
 		} else {
+			// In this case, parentheses are not included in body location, so we look for `=>` token
+			// foo.forEach(bar => ({bar}))
+			//                     ^
 			const arrowToken = sourceCode.getTokenBefore(callback.body, isArrowToken);
 			end = arrowToken.range[1];
 		}
@@ -90,11 +96,10 @@ function getFixFunction(callExpression, sourceCode, functionInfo) {
 
 	function * replaceReturnStatement(returnStatement, fixer) {
 		const returnToken = sourceCode.getFirstToken(returnStatement);
-
-		/* istanbul ignore next: `ReturnStatement` firstToken should be `return` */
-		if (returnToken.value !== 'return') {
-			throw new Error(`Unexpected token ${returnToken.value}.`);
-		}
+		assertToken(returnToken, {
+			expected: 'return',
+			ruleId: 'no-array-for-each'
+		});
 
 		if (!returnStatement.argument) {
 			yield fixer.replaceText(returnToken, 'continue');
@@ -166,20 +171,35 @@ function getFixFunction(callExpression, sourceCode, functionInfo) {
 	}
 
 	return function * (fixer) {
+		// Replace these with `for (const … of …) `
+		// foo.forEach(bar =>    bar)
+		// ^^^^^^^^^^^^^^^^^^ (space after `=>` didn't included)
+		// foo.forEach(bar =>    {})
+		// ^^^^^^^^^^^^^^^^^^^^^^
+		// foo.forEach(function(bar)    {})
+		// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 		yield fixer.replaceTextRange(getForOfLoopHeadRange(), getForOfLoopHeadText());
 
+		// Parenthesized callback function
+		// foo.forEach( ((bar => {})) )
+		//                         ^^
 		yield * removeCallbackParentheses(fixer);
 
-		// Remove call expression trailing comma
 		const [
 			penultimateToken,
 			lastToken
 		] = sourceCode.getLastTokens(callExpression, 2);
 
+		// The possible trailing comma token of `Array#forEach()` CallExpression
+		// foo.forEach(bar => {},)
+		//                      ^
 		if (isCommaToken(penultimateToken)) {
 			yield fixer.remove(penultimateToken);
 		}
 
+		// The closing parenthesis token of `Array#forEach()` CallExpression
+		// foo.forEach(bar => {})
+		//                      ^
 		yield fixer.remove(lastToken);
 
 		for (const returnStatement of returnStatements) {
@@ -187,11 +207,14 @@ function getFixFunction(callExpression, sourceCode, functionInfo) {
 		}
 
 		const expressionStatementLastToken = sourceCode.getLastToken(callExpression.parent);
+		// Remove semicolon if it's not needed anymore
+		// foo.forEach(bar => {});
+		//                       ^
 		if (shouldRemoveExpressionStatementLastToken(expressionStatementLastToken)) {
 			yield fixer.remove(expressionStatementLastToken, fixer);
 		}
 
-		// Prevent possible conflicts
+		// Prevent possible variable conflicts
 		yield * extendFixRange(fixer, callExpression.parent.range);
 	};
 }
@@ -257,6 +280,17 @@ function isParameterSafeToFix(parameter, {scope, array, allIdentifiers}) {
 	return true;
 }
 
+function isParameterReassigned(parameter, scope) {
+	const variable = findVariable(scope, parameter);
+	const {references} = variable;
+	return references.some(reference => {
+		const node = reference.identifier;
+		const {parent} = node;
+		return parent.type === 'UpdateExpression' ||
+			(parent.type === 'AssignmentExpression' && parent.left === node);
+	});
+}
+
 function isFixable(callExpression, sourceCode, {scope, functionInfo, allIdentifiers}) {
 	// Check `CallExpression`
 	if (

package/rules/no-array-push-push.js

@@ -3,6 +3,7 @@ const {hasSideEffect, isCommaToken, isSemicolonToken} = require('eslint-utils');
 const getDocumentationUrl = require('./utils/get-documentation-url');
 const methodSelector = require('./utils/method-selector');
 const getCallExpressionArgumentsText = require('./utils/get-call-expression-arguments-text');
+const isSameReference = require('./utils/is-same-reference');
 
 const ERROR = 'error';
 const SUGGESTION = 'suggestion';
@@ -53,7 +54,7 @@ function create(context) {
 			const secondCallArray = secondCall.callee.object;
 
 			// Not same array
-			if (sourceCode.getText(firstCallArray) !== sourceCode.getText(secondCallArray)) {
+			if (!isSameReference(firstCallArray, secondCallArray)) {
 				return;
 			}
 
@@ -83,10 +84,7 @@ function create(context) {
 				);
 			};
 
-			if (
-				hasSideEffect(firstCallArray, sourceCode) ||
-				secondCallArguments.some(element => hasSideEffect(element, sourceCode))
-			) {
+			if (secondCallArguments.some(element => hasSideEffect(element, sourceCode))) {
 				problem.suggest = [
 					{
 						messageId: SUGGESTION,

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

@@ -0,0 +1,233 @@
+'use strict';
+const {isSemicolonToken} = require('eslint-utils');
+const getDocumentationUrl = require('./utils/get-documentation-url');
+const getClassHeadLocation = require('./utils/get-class-head-location');
+const removeSpacesAfter = require('./utils/remove-spaces-after');
+const assertToken = require('./utils/assert-token');
+
+const MESSAGE_ID = 'no-static-only-class';
+const messages = {
+	[MESSAGE_ID]: 'Use an object instead of a class with only static members.'
+};
+
+const selector = [
+	':matches(ClassDeclaration, ClassExpression)',
+	':not([superClass], [decorators.length>0])',
+	'[body.type="ClassBody"]',
+	'[body.body.length>0]'
+].join('');
+
+const isEqualToken = ({type, value}) => type === 'Punctuator' && value === '=';
+const isDeclarationOfExportDefaultDeclaration = node =>
+	node.type === 'ClassDeclaration' &&
+	node.parent.type === 'ExportDefaultDeclaration' &&
+	node.parent.declaration === node;
+
+function isStaticMember(node) {
+	const {
+		type,
+		private: isPrivate,
+		static: isStatic,
+		declare: isDeclare,
+		readonly: isReadonly,
+		accessibility,
+		decorators,
+		key
+	} = node;
+
+	// Avoid matching unexpected node. For example: https://github.com/tc39/proposal-class-static-block
+	/* istanbul ignore next */
+	if (type !== 'ClassProperty' && type !== 'MethodDefinition') {
+		return false;
+	}
+
+	if (!isStatic || isPrivate) {
+		return false;
+	}
+
+	// TypeScript class
+	if (
+		isDeclare ||
+		isReadonly ||
+		typeof accessibility !== 'undefined' ||
+		(Array.isArray(decorators) && decorators.length > 0) ||
+		key.type === 'TSPrivateIdentifier'
+	) {
+		return false;
+	}
+
+	return true;
+}
+
+function * switchClassMemberToObjectProperty(node, sourceCode, fixer) {
+	const {type} = node;
+
+	const staticToken = sourceCode.getFirstToken(node);
+	assertToken(staticToken, {
+		expected: [
+			{type: 'Keyword', value: 'static'},
+			// `babel-eslint` and `@babel/eslint-parser` use `{type: 'Identifier', value: 'static'}`
+			{type: 'Identifier', value: 'static'}
+		],
+		ruleId: 'no-static-only-class'
+	});
+
+	yield fixer.remove(staticToken);
+	yield removeSpacesAfter(staticToken, sourceCode, fixer);
+
+	const maybeSemicolonToken = type === 'ClassProperty' ?
+		sourceCode.getLastToken(node) :
+		sourceCode.getTokenAfter(node);
+	const hasSemicolonToken = isSemicolonToken(maybeSemicolonToken);
+
+	if (type === 'ClassProperty') {
+		const {key, value} = node;
+
+		if (value) {
+			// Computed key may have `]` after `key`
+			const equalToken = sourceCode.getTokenAfter(key, isEqualToken);
+			yield fixer.replaceText(equalToken, ':');
+		} else if (hasSemicolonToken) {
+			yield fixer.insertTextBefore(maybeSemicolonToken, ': undefined');
+		} else {
+			yield fixer.insertTextAfter(node, ': undefined');
+		}
+	}
+
+	yield (
+		hasSemicolonToken ?
+			fixer.replaceText(maybeSemicolonToken, ',') :
+			fixer.insertTextAfter(node, ',')
+	);
+}
+
+function switchClassToObject(node, sourceCode) {
+	const {
+		type,
+		id,
+		body,
+		declare: isDeclare,
+		abstract: isAbstract,
+		implements: classImplements,
+		parent
+	} = node;
+
+	if (
+		isDeclare ||
+		isAbstract ||
+		(Array.isArray(classImplements) && classImplements.length > 0)
+	) {
+		return;
+	}
+
+	if (type === 'ClassExpression' && id) {
+		return;
+	}
+
+	const isExportDefault = isDeclarationOfExportDefaultDeclaration(node);
+
+	if (isExportDefault && id) {
+		return;
+	}
+
+	for (const node of body.body) {
+		if (
+			node.type === 'ClassProperty' &&
+			(
+				node.typeAnnotation ||
+				// This is a stupid way to check if `value` of `ClassProperty` uses `this`
+				(node.value && sourceCode.getText(node).includes('this'))
+			)
+		) {
+			return;
+		}
+	}
+
+	return function * (fixer) {
+		const classToken = sourceCode.getFirstToken(node);
+		/* istanbul ignore next */
+		assertToken(classToken, {
+			expected: {type: 'Keyword', value: 'class'},
+			ruleId: 'no-static-only-class'
+		});
+
+		if (isExportDefault || type === 'ClassExpression') {
+			/*
+				There are comments after return, and `{` is not on same line
+
+				```js
+				function a() {
+					return class // comment
+					{
+						static a() {}
+					}
+				}
+				```
+			*/
+			if (
+				type === 'ClassExpression' &&
+				parent.type === 'ReturnStatement' &&
+				body.loc.start.line !== parent.loc.start.line &&
+				sourceCode.text.slice(classToken.range[1], body.range[0]).trim()
+			) {
+				yield fixer.replaceText(classToken, '{');
+
+				const openingBraceToken = sourceCode.getFirstToken(body);
+				yield fixer.remove(openingBraceToken);
+			} else {
+				yield fixer.replaceText(classToken, '');
+
+				/*
+						Avoid breaking case like
+
+						```js
+						return class
+						{};
+						```
+				*/
+				yield removeSpacesAfter(classToken, sourceCode, fixer);
+			}
+
+			// There should not be ASI problem
+		} else {
+			yield fixer.replaceText(classToken, 'const');
+			yield fixer.insertTextBefore(body, '= ');
+			yield fixer.insertTextAfter(body, ';');
+		}
+
+		for (const node of body.body) {
+			yield * switchClassMemberToObjectProperty(node, sourceCode, fixer);
+		}
+	};
+}
+
+function create(context) {
+	const sourceCode = context.getSourceCode();
+
+	return {
+		[selector](node) {
+			if (node.body.body.some(node => !isStaticMember(node))) {
+				return;
+			}
+
+			context.report({
+				node,
+				loc: getClassHeadLocation(node, sourceCode),
+				messageId: MESSAGE_ID,
+				fix: switchClassToObject(node, sourceCode)
+			});
+		}
+	};
+}
+
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			url: getDocumentationUrl(__filename)
+		},
+		fixable: 'code',
+		messages
+	}
+};