Add prefer-class-fields rule

docs/rules/prefer-class-fields.md

@@ -0,0 +1,58 @@
+# Prefer class field declarations over `this` assignments in constructors
+
+💼 This rule is enabled in the ✅ `recommended` [config](https://github.com/sindresorhus/eslint-plugin-unicorn#preset-configs-eslintconfigjs).
+
+🔧💡 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix) and manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
+
+<!-- end auto-generated rule header -->
+<!-- Do not manually modify this header. Run: `npm run fix:eslint-docs` -->
+
+This rule enforces the use of class field declarations for static values, instead of assigning them in constructors using `this`.
+
+> To avoid leaving empty constructors after autofixing, use the [`no-useless-constructor` rule](https://eslint.org/docs/latest/rules/no-useless-constructor).
+
+## Examples
+
+```js
+// ❌
+class Foo {
+	constructor() {
+		this.foo = 'foo';
+	}
+}
+
+// ✅
+class Foo {
+	foo = 'foo';
+}
+```
+
+```js
+// ❌
+class MyError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = 'MyError';
+	}
+}
+
+// ✅
+class MyError extends Error {
+	name = 'MyError'
+}
+```
+
+```js
+// ❌
+class Foo {
+	foo = 'foo';
+	constructor() {
+		this.foo = 'bar';
+	}
+}
+
+// ✅
+class Foo {
+	foo = 'bar';
+}
+```

readme.md

@@ -130,6 +130,7 @@ export default [
 | [prefer-array-some](docs/rules/prefer-array-some.md)                                             | Prefer `.some(…)` over `.filter(…).length` check and `.{find,findLast,findIndex,findLastIndex}(…)`.                                                                                                               | ✅  | 🔧 | 💡 |
 | [prefer-at](docs/rules/prefer-at.md)                                                             | Prefer `.at()` method for index access and `String#charAt()`.                                                                                                                                                     | ✅  | 🔧 | 💡 |
 | [prefer-blob-reading-methods](docs/rules/prefer-blob-reading-methods.md)                         | Prefer `Blob#arrayBuffer()` over `FileReader#readAsArrayBuffer(…)` and `Blob#text()` over `FileReader#readAsText(…)`.                                                                                             | ✅  |    |    |
+| [prefer-class-fields](docs/rules/prefer-class-fields.md)                                         | Prefer class field declarations over `this` assignments in constructors.                                                                                                                                          | ✅  | 🔧 | 💡 |
 | [prefer-code-point](docs/rules/prefer-code-point.md)                                             | Prefer `String#codePointAt(…)` over `String#charCodeAt(…)` and `String.fromCodePoint(…)` over `String.fromCharCode(…)`.                                                                                           | ✅  |    | 💡 |
 | [prefer-date-now](docs/rules/prefer-date-now.md)                                                 | Prefer `Date.now()` to get the number of milliseconds since the Unix Epoch.                                                                                                                                       | ✅  | 🔧 |    |
 | [prefer-default-parameters](docs/rules/prefer-default-parameters.md)                             | Prefer default parameters over reassignment.                                                                                                                                                                      | ✅  | 🔧 | 💡 |

rules/index.js

@@ -75,6 +75,7 @@ import preferArrayIndexOf from './prefer-array-index-of.js';
 import preferArraySome from './prefer-array-some.js';
 import preferAt from './prefer-at.js';
 import preferBlobReadingMethods from './prefer-blob-reading-methods.js';
+import preferClassFields from './prefer-class-fields.js';
 import preferCodePoint from './prefer-code-point.js';
 import preferDateNow from './prefer-date-now.js';
 import preferDefaultParameters from './prefer-default-parameters.js';
@@ -203,6 +204,7 @@ const rules = {
 	'prefer-array-some': createRule(preferArraySome, 'prefer-array-some'),
 	'prefer-at': createRule(preferAt, 'prefer-at'),
 	'prefer-blob-reading-methods': createRule(preferBlobReadingMethods, 'prefer-blob-reading-methods'),
+	'prefer-class-fields': createRule(preferClassFields, 'prefer-class-fields'),
 	'prefer-code-point': createRule(preferCodePoint, 'prefer-code-point'),
 	'prefer-date-now': createRule(preferDateNow, 'prefer-date-now'),
 	'prefer-default-parameters': createRule(preferDefaultParameters, 'prefer-default-parameters'),

rules/prefer-class-fields.js

@@ -0,0 +1,204 @@
+import getIndentString from './utils/get-indent-string.js';
+
+const MESSAGE_ID_ERROR = 'prefer-class-fields/error';
+const MESSAGE_ID_SUGGESTION = 'prefer-class-fields/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]:
+		'Prefer class field declaration over `this` assignment in constructor for static values.',
+	[MESSAGE_ID_SUGGESTION]:
+		'Encountered same-named class field declaration and `this` assignment in constructor. Replace the class field declaration with the value from `this` assignment.',
+};
+
+const WHITELIST_NODES_PRECEDING_THIS_ASSIGNMENT = new Set(['EmptyStatement', 'ExpressionStatement']);
+
+/**
+@param {import('eslint').Rule.Node} node
+@returns {node is import('estree').ExpressionStatement & {expression: import('estree').AssignmentExpression & {left: import('estree').MemberExpression & {object: import('estree').ThisExpression}}}}
+*/
+const isThisAssignmentExpression = node => {
+	if (
+		node.type !== 'ExpressionStatement'
+		|| node.expression.type !== 'AssignmentExpression'
+	) {
+		return false;
+	}
+
+	const lhs = node.expression.left;
+
+	if (!lhs.object || lhs.object.type !== 'ThisExpression') {
+		return false;
+	}
+
+	return true;
+};
+
+/**
+@param {import('eslint').Rule.Node} node
+@param {import('eslint').Rule.RuleContext['sourceCode']} sourceCode
+@param {import('eslint').Rule.RuleFixer} fixer
+*/
+const removeFieldAssignment = (node, sourceCode, fixer) => {
+	const {line} = node.loc.start;
+	const nodeText = sourceCode.getText(node);
+	const lineText = sourceCode.lines[line - 1];
+	const isOnlyNodeOnLine = lineText.trim() === nodeText;
+
+	return isOnlyNodeOnLine
+		? fixer.removeRange([
+			sourceCode.getIndexFromLoc({line, column: 0}),
+			sourceCode.getIndexFromLoc({line: line + 1, column: 0}),
+		])
+		: fixer.remove(node);
+};
+
+/**
+@param {string} propertyName
+@param {import('estree').ClassBody} classBody
+*/
+const findClassFieldNamed = (propertyName, classBody) => {
+	for (const classBodyChild of classBody.body) {
+		if (
+			classBodyChild.type === 'PropertyDefinition'
+			&& classBodyChild.key.type === 'Identifier'
+			&& classBodyChild.key.name === propertyName
+		) {
+			return classBodyChild;
+		}
+	}
+};
+
+/**
+@param {string} propertyName
+@param {string} propertyValue
+@param {import('estree').ClassBody} classBody
+@param {import('estree').MethodDefinition} constructor
+@param {import('eslint').Rule.RuleContext['sourceCode']} sourceCode
+@param {import('eslint').Rule.RuleFixer} fixer
+*/
+const addClassFieldDeclaration = (
+	propertyName,
+	propertyValue,
+	classBody,
+	constructor,
+	sourceCode,
+	fixer,
+) => {
+	const classBodyStartRange = [classBody.range[0], classBody.range[0] + 1];
+	const indent = getIndentString(constructor, sourceCode);
+	return fixer.insertTextAfterRange(
+		classBodyStartRange,
+		`\n${indent}${propertyName} = ${propertyValue};`,
+	);
+};
+
+/**
+@type {import('eslint').Rule.RuleModule['create']}
+*/
+const create = context => {
+	const {sourceCode} = context;
+
+	return {
+		ClassBody(classBody) {
+			const constructor = classBody.body.find(x => x.kind === 'constructor');
+
+			if (!constructor || constructor.type !== 'MethodDefinition') {
+				return;
+			}
+
+			const constructorBody = constructor.value.body?.body;
+
+			if (!constructorBody) {
+				return;
+			}
+
+			const firstInvalidProperty = constructorBody.findIndex(
+				node => !WHITELIST_NODES_PRECEDING_THIS_ASSIGNMENT.has(node.type),
+			);
+			const validConstructorProperties
+				= firstInvalidProperty === -1
+					? constructorBody
+					: constructorBody.slice(0, firstInvalidProperty);
+
+			for (
+				let index = validConstructorProperties.length - 1;
+				index >= 0;
+				index--
+			) {
+				const node = validConstructorProperties[index];
+				if (
+					isThisAssignmentExpression(node)
+					&& node.expression.right?.type === 'Literal'
+					&& node.expression.operator === '='
+					&& node.expression.left.property.type === 'Identifier'
+					&& !node.expression.left.computed
+				) {
+					const propertyName = node.expression.left.property.name;
+					const propertyValue = node.expression.right.raw;
+					const alreadyExistingClassFieldDeclaration = findClassFieldNamed(
+						propertyName,
+						classBody,
+					);
+
+					if (alreadyExistingClassFieldDeclaration) {
+						return {
+							node,
+							messageId: MESSAGE_ID_SUGGESTION,
+							data: {
+								propertyName,
+								// Class expression does not have name, e.g. const a = class {}
+								className: classBody.parent?.id?.name ?? '',
+							},
+							/**
+							@param {import('eslint').Rule.RuleFixer} fixer
+							*/
+							* suggest(fixer) {
+								yield removeFieldAssignment(node, sourceCode, fixer);
+								yield fixer.replaceText(
+									alreadyExistingClassFieldDeclaration,
+									`${propertyName} = ${propertyValue};`,
+								);
+							},
+						};
+					}
+
+					return {
+						node,
+						messageId: MESSAGE_ID_ERROR,
+
+						/**
+						@param {import('eslint').Rule.RuleFixer} fixer
+						*/
+						* fix(fixer) {
+							yield removeFieldAssignment(node, sourceCode, fixer);
+							yield addClassFieldDeclaration(
+								propertyName,
+								propertyValue,
+								classBody,
+								constructor,
+								sourceCode,
+								fixer,
+							);
+						},
+					};
+				}
+			}
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer class field declarations over `this` assignments in constructors.',
+			recommended: true,
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};
+
+export default config;

rules/utils/rule.js

@@ -3,10 +3,7 @@ import getDocumentationUrl from './get-documentation-url.js';
 const isIterable = object => typeof object?.[Symbol.iterator] === 'function';
 
 class FixAbortError extends Error {
-	constructor() {
-		super();
-		this.name = 'FixAbortError';
-	}
+	name = 'FixAbortError';
 }
 const fixOptions = {
 	abort() {

test/package.js

@@ -32,6 +32,7 @@ const RULES_WITHOUT_PASS_FAIL_SECTIONS = new Set([
 	'prefer-modern-math-apis',
 	'prefer-math-min-max',
 	'consistent-existence-index-check',
+	'prefer-class-fields',
 	'prefer-global-this',
 	'no-instanceof-builtins',
 	'no-named-default',