Add no-accessor-recursion rule

docs/rules/no-accessor-recursion.md

@@ -0,0 +1,74 @@
+# Disallow recursive access to `this` within getters and setters
+
+💼 This rule is enabled in the ✅ `recommended` [config](https://github.com/sindresorhus/eslint-plugin-unicorn#preset-configs-eslintconfigjs).
+
+<!-- end auto-generated rule header -->
+<!-- Do not manually modify this header. Run: `npm run fix:eslint-docs` -->
+
+This rule prevents recursive access to `this` within getter and setter methods in objects and classes, avoiding infinite recursion and stack overflow errors.
+
+## Examples
+
+```js
+// ❌
+const foo = {
+	get bar() {
+		return this.bar;
+	}
+};
+
+// ✅
+const foo = {
+	get bar() {
+		return this.baz;
+	}
+};
+```
+
+```js
+// ❌
+class Foo {
+	get bar() {
+		return this.bar;
+	}
+}
+
+// ✅
+class Foo {
+	get bar() {
+		return this.baz;
+	}
+}
+```
+
+```js
+// ❌
+const foo = {
+	set bar(value) {
+		this.bar = value;
+	}
+};
+
+// ✅
+const foo = {
+	set bar(value) {
+		this._bar = value;
+	}
+};
+```
+
+```js
+// ❌
+class Foo {
+	set bar(value) {
+		this.bar = value;
+	}
+}
+
+// ✅
+class Foo {
+	set bar(value) {
+		this._bar = value;
+	}
+}
+```

readme.md

@@ -72,6 +72,7 @@ export default [
 | [import-style](docs/rules/import-style.md)                                                       | Enforce specific import styles per module.                                                                                                                                                                        | ✅  |    |    |
 | [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-accessor-recursion](docs/rules/no-accessor-recursion.md)                                     | Disallow recursive access to `this` within getters and setters.                                                                                                                                                   | ✅  |    |    |
 | [no-anonymous-default-export](docs/rules/no-anonymous-default-export.md)                         | Disallow anonymous functions and classes as the default export.                                                                                                                                                   | ✅  |    | 💡 |
 | [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 the `forEach` method.                                                                                                                                                                        | ✅  | 🔧 | 💡 |

rules/index.js

@@ -17,6 +17,7 @@ import filenameCase from './filename-case.js';
 import importStyle from './import-style.js';
 import newForBuiltins from './new-for-builtins.js';
 import noAbusiveEslintDisable from './no-abusive-eslint-disable.js';
+import noAccessorRecursion from './no-accessor-recursion.js';
 import noAnonymousDefaultExport from './no-anonymous-default-export.js';
 import noArrayCallbackReference from './no-array-callback-reference.js';
 import noArrayForEach from './no-array-for-each.js';
@@ -143,6 +144,7 @@ const rules = {
 	'import-style': createRule(importStyle, 'import-style'),
 	'new-for-builtins': createRule(newForBuiltins, 'new-for-builtins'),
 	'no-abusive-eslint-disable': createRule(noAbusiveEslintDisable, 'no-abusive-eslint-disable'),
+	'no-accessor-recursion': createRule(noAccessorRecursion, 'no-accessor-recursion'),
 	'no-anonymous-default-export': createRule(noAnonymousDefaultExport, 'no-anonymous-default-export'),
 	'no-array-callback-reference': createRule(noArrayCallbackReference, 'no-array-callback-reference'),
 	'no-array-for-each': createRule(noArrayForEach, 'no-array-for-each'),

rules/no-accessor-recursion.js

@@ -0,0 +1,160 @@
+const MESSAGE_ID_ERROR = 'no-accessor-recursion/error';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Disallow recursive access to `this` within {{kind}}ters.',
+};
+
+/**
+Get the closest non-arrow function scope.
+
+@param {import('eslint').SourceCode} sourceCode
+@param {import('estree').Node} node
+@return {import('eslint').Scope.Scope | undefined}
+*/
+const getClosestFunctionScope = (sourceCode, node) => {
+	for (let scope = sourceCode.getScope(node); scope; scope = scope.upper) {
+		if (scope.type === 'class') {
+			return;
+		}
+
+		if (scope.type === 'function' && scope.block.type !== 'ArrowFunctionExpression') {
+			return scope;
+		}
+	}
+};
+
+/** @param {import('estree').Identifier | import('estree').PrivateIdentifier} node */
+const isIdentifier = node => node.type === 'Identifier' || node.type === 'PrivateIdentifier';
+
+/** @param {import('estree').ThisExpression} node */
+const isDotNotationAccess = node =>
+	node.parent.type === 'MemberExpression'
+	&& node.parent.object === node
+	&& !node.parent.computed
+	&& isIdentifier(node.parent.property);
+
+/**
+Check if a property is a valid getter or setter.
+
+@param {import('estree').Property | import('estree').MethodDefinition} property
+*/
+const isValidProperty = property =>
+	['Property', 'MethodDefinition'].includes(property.type)
+	&& !property.computed
+	&& ['set', 'get'].includes(property.kind)
+	&& isIdentifier(property.key);
+
+/**
+Check if two property keys are the same.
+
+@param {import('estree').Property['key']} keyLeft
+@param {import('estree').Property['key']} keyRight
+*/
+const isSameKey = (keyLeft, keyRight) => ['type', 'name'].every(key => keyLeft[key] === keyRight[key]);
+
+/**
+Check if `this` is accessed recursively within a getter or setter.
+
+@param {import('estree').ThisExpression} node
+@param {import('estree').Property | import('estree').MethodDefinition} property
+*/
+const isMemberAccess = (node, property) =>
+	isDotNotationAccess(node)
+	&& isSameKey(node.parent.property, property.key);
+
+/**
+Check if `this` is accessed recursively within a destructuring assignment.
+
+@param {import('estree').ThisExpression} node
+@param {import('estree').Property | import('estree').MethodDefinition} property
+*/
+const isRecursiveDestructuringAccess = (node, property) =>
+	node.parent.type === 'VariableDeclarator'
+	&& node.parent.init === node
+	&& node.parent.id.type === 'ObjectPattern'
+	&& node.parent.id.properties.some(declaratorProperty =>
+		declaratorProperty.type === 'Property'
+		&& !declaratorProperty.computed
+		&& isSameKey(declaratorProperty.key, property.key),
+	);
+
+const isPropertyRead = (thisExpression, property) =>
+	isMemberAccess(thisExpression, property)
+	|| isRecursiveDestructuringAccess(thisExpression, property);
+
+const isPropertyWrite = (thisExpression, property) => {
+	if (!isMemberAccess(thisExpression, property)) {
+		return false;
+	}
+
+	const memberExpression = thisExpression.parent;
+	const {parent} = memberExpression;
+
+	// This part is similar to `isLeftHandSide`, try to DRY in future
+	return (
+		// `this.foo = …`
+		// `[this.foo = …] = …`
+		// `({property: this.foo = …] = …)`
+		(
+			(parent.type === 'AssignmentExpression' || parent.type === 'AssignmentPattern')
+			&& parent.left === memberExpression
+		)
+		// `++ this.foo`
+		|| (parent.type === 'UpdateExpression' && parent.argument === memberExpression)
+		// `[this.foo] = …`
+		|| (parent.type === 'ArrayPattern' && parent.elements.includes(memberExpression))
+		// `({property: this.foo} = …)`
+		|| (
+			parent.type === 'Property'
+			&& parent.value === memberExpression
+			&& parent.parent.type === 'ObjectPattern'
+			&& parent.parent.properties.includes(memberExpression.parent)
+		)
+	);
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	return {
+		/** @param {import('estree').ThisExpression} thisExpression */
+		ThisExpression(thisExpression) {
+			const scope = getClosestFunctionScope(sourceCode, thisExpression);
+
+			if (!scope) {
+				return;
+			}
+
+			/** @type {import('estree').Property | import('estree').MethodDefinition} */
+			const property = scope.block.parent;
+
+			if (!isValidProperty(property)) {
+				return;
+			}
+
+			if (property.kind === 'get' && isPropertyRead(thisExpression, property)) {
+				return {node: thisExpression.parent, messageId: MESSAGE_ID_ERROR, data: {kind: property.kind}};
+			}
+
+			if (property.kind === 'set' && isPropertyWrite(thisExpression, property)) {
+				return {node: thisExpression.parent, messageId: MESSAGE_ID_ERROR, data: {kind: property.kind}};
+			}
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow recursive access to `this` within getters and setters.',
+			recommended: true,
+		},
+		defaultOptions: [],
+		messages,
+	},
+};
+
+export default config;