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';
@@ -142,6 +143,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,99 @@
+const MESSAGE_ID_ERROR = 'no-accessor-recursion/error';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Disallow recursive access to `this` within getters and setters.',
+};
+
+/** @param {import('eslint').Scope.Scope} scope */
+const isArrowFunctionScope = scope => scope.type === 'function' && scope.block.type === 'ArrowFunctionExpression';
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const functionExpressionStack = [];
+
+	return {
+		// Getter for object literal
+		'Property[value.type="FunctionExpression"], [kind="get"]'(node) {
+			functionExpressionStack.push(node);
+		},
+		'Property[value.type="FunctionExpression"], [kind="get"]:exit'() {
+			functionExpressionStack.pop();
+		},
+		// Setter for object literal
+		'Property[value.type="FunctionExpression"], [kind="set"]'(node) {
+			functionExpressionStack.push(node);
+		},
+		'Property[value.type="FunctionExpression"], [kind="set"]:exit'() {
+			functionExpressionStack.pop();
+		},
+		// Getter for class
+		'MethodDefinition[kind="get"]'(node) {
+			functionExpressionStack.push(node);
+		},
+		'MethodDefinition[kind="get"]:exit'() {
+			functionExpressionStack.pop();
+		},
+		// Setter for class
+		'MethodDefinition[kind="set"]'(node) {
+			functionExpressionStack.push(node);
+		},
+		'MethodDefinition[kind="set"]:exit'() {
+			functionExpressionStack.pop();
+		},
+		ThisExpression(node) {
+			if (functionExpressionStack.length > 0) {
+				/** @type {import('estree').Property | import('estree').MethodDefinition} */
+				const property = functionExpressionStack.at(-1);
+
+				let scope = context.sourceCode.getScope(node);
+
+				while (scope.type !== 'function' || isArrowFunctionScope(scope)) {
+					scope = scope.upper;
+				}
+
+				// Check if `this` is in the current function expression scope
+				if (scope.block === property.value) {
+					/** @type {import('estree').MemberExpression} */
+					const {parent} = node;
+
+					const isThisAccessed = () => parent.type === 'MemberExpression' && parent.property.type === 'Identifier' && parent.property.name === property.key.name;
+
+					switch (property.kind) {
+						case 'get': {
+							if (isThisAccessed()) {
+								context.report({node: parent, messageId: MESSAGE_ID_ERROR});
+							}
+
+							break;
+						}
+
+						case 'set': {
+							if (isThisAccessed() && parent.parent.type === 'AssignmentExpression') {
+								context.report({node: parent.parent, messageId: MESSAGE_ID_ERROR});
+							}
+
+							break;
+						}
+
+						default:
+					}
+				}
+			}
+		},
+	};
+};
+
+/** @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;

test/no-accessor-recursion.js

@@ -0,0 +1,161 @@
+import outdent from 'outdent';
+import {getTester} from './utils/test.js';
+
+const {test} = getTester(import.meta);
+
+test.snapshot({
+	valid: [
+		'function foo () { this.bar }',
+		'function foo () { this.foo }',
+		'function foo (value) { this.bar = value }',
+		'this.foo = foo',
+		outdent`
+			{
+				this.foo = foo;		
+			}
+		`,
+		'this.foo = function () { this.foo }',
+		'const foo = () => this.foo',
+		outdent`
+			const foo = {
+				bar() {
+					this.bar = void 0;
+					return this.bar;
+				}
+			};
+		`,
+		outdent`
+			class Foo {
+				foo() {
+					this.foo = void 0;
+					return this.foo;
+				}
+			}
+		`,
+		// Deep property setter
+		outdent`
+			class Foo {
+				set bar(value) {
+					this.bar.baz = value;
+				}
+			}
+		`,
+		// Define this to alias
+		outdent`
+			class Foo {
+				get bar() {
+					const self = this;
+					return self.bar;
+				}
+			}
+		`,
+		outdent`
+			class Foo {
+				set bar(value) {
+					const self = this;
+					return self.bar = value;
+				}
+			}
+		`,
+		outdent`
+			const foo = {
+				get bar() {
+					return this._bar;
+				}
+			};
+		`,
+		// Access this in function scope
+		outdent`
+			const foo = {
+				get bar() {
+					function baz() {
+						return this.bar;
+					}
+				}
+			};
+		`,
+		// Nest getter
+		outdent`
+			const foo = {
+				get bar() {
+					const qux = {
+						get quux () {
+							return this.bar;
+						}
+					}
+				}
+			};
+		`,
+	],
+	invalid: [
+		// Getter
+		outdent`
+			const foo = {
+				get bar() {
+					return this.bar;
+				}
+			};
+		`,
+		outdent`
+			class Foo {
+				get bar() {
+					return this.bar;
+				}
+			}
+		`,
+		// Setter
+		outdent`
+			const foo = {
+				set bar(value) {
+					this.bar = value;
+				}
+			};
+		`,
+		outdent`
+			class Foo {
+				set bar(value) {
+					this.bar = value;
+				}
+			}
+		`,
+		// Deep property getter
+		outdent`
+			const foo = {
+				get bar() {
+					return this.bar.baz;
+				}
+			};
+		`,
+		// Access this in nest block
+		outdent`
+			const foo = {
+				get bar() {
+					if (true) {
+						return this.bar;
+					}
+				}
+			};
+		`,
+		// Access this in arrow function scope
+		outdent`
+			const foo = {
+				get bar() {
+					const baz = () => {
+						return this.bar;
+					}
+				}
+			};
+		`,
+		outdent`
+			const foo = {
+				get bar() {
+					const baz = () => {
+						return () => {
+							return this.bar;
+						}
+					}
+				}
+			};
+		`,
+	],
+});

test/package.js

@@ -33,6 +33,7 @@ const RULES_WITHOUT_PASS_FAIL_SECTIONS = new Set([
 	'prefer-math-min-max',
 	'consistent-existence-index-check',
 	'prefer-global-this',
+	'no-accessor-recursion',
 ]);
 
 test('Every rule is defined in index file in alphabetical order', t => {