consistent-function-scoping: Fix TypeScript false positives for lexical this (#2885)

sindresorhus · web-flow · commit a383657a2322 · 2026-03-05T19:50:03.000+07:00
diff --git a/rules/consistent-function-scoping.js b/rules/consistent-function-scoping.js
@@ -1,5 +1,5 @@
 import {getFunctionHeadLocation, getFunctionNameWithKind} from '@eslint-community/eslint-utils';
-import {getReferences, isNodeMatches} from './utils/index.js';
+import {getReferences, isNodeContainsLexicalThis, isNodeMatches} from './utils/index.js';
 import {functionTypes} from './ast/index.js';
 
 const MESSAGE_ID = 'consistent-function-scoping';
@@ -94,10 +94,11 @@ const isReactHook = scope =>
 	scope.block?.parent?.callee
 	&& isNodeMatches(scope.block.parent.callee, reactHooks);
 
-const isArrowFunctionWithThis = scope =>
-	scope.type === 'function'
-	&& scope.block?.type === 'ArrowFunctionExpression'
-	&& (scope.thisFound || scope.childScopes.some(scope => isArrowFunctionWithThis(scope)));
+const isArrowFunctionNodeWithThis = (node, visitorKeys) =>
+	node.type === 'ArrowFunctionExpression'
+	// We avoid `scope.thisFound` because parser scope metadata differs; AST lexical checks are consistent.
+	// Include both params and body, because parameter defaults can reference lexical `this`.
+	&& isNodeContainsLexicalThis(node, visitorKeys);
 
 const iifeFunctionTypes = new Set([
 	'FunctionExpression',
@@ -145,10 +146,13 @@ function handleNestedArrowFunctions(parentNode, node) {
 	return parentNode;
 }
 
-function checkNode(node, scopeManager) {
+function checkNode(node, scopeManager, sourceCode) {
 	const scope = scopeManager.acquire(node);
 
-	if (!scope || isArrowFunctionWithThis(scope)) {
+	if (
+		!scope
+		|| isArrowFunctionNodeWithThis(node, sourceCode.visitorKeys)
+	) {
 		return true;
 	}
 
@@ -220,7 +224,7 @@ const create = context => {
 			return;
 		}
 
-		if (checkNode(node, scopeManager)) {
+		if (checkNode(node, scopeManager, sourceCode)) {
 			return;
 		}
 
diff --git a/rules/utils/index.js b/rules/utils/index.js
@@ -42,6 +42,7 @@ export {default as isNewExpressionWithParentheses} from './is-new-expression-wit
 export {default as isNumber} from './is-number.js';
 export {default as isNodeValueNotDomNode} from './is-node-value-not-dom-node.js';
 export {default as isNodeValueNotFunction} from './is-node-value-not-function.js';
+export {default as isNodeContainsLexicalThis} from './is-node-contains-lexical-this.js';
 export {default as isOnSameLine} from './is-on-same-line.js';
 export {default as isSameIdentifier} from './is-same-identifier.js';
 export {default as isSameReference} from './is-same-reference.js';
diff --git a/rules/utils/is-node-contains-lexical-this.js b/rules/utils/is-node-contains-lexical-this.js
@@ -0,0 +1,65 @@
+/**
+Check whether a node subtree contains lexical `this`.
+
+This is parser-agnostic and intentionally does not use `scope.thisFound`, because that flag is inconsistent across supported parsers.
+*/
+const isNodeContainsLexicalThis = (node, visitorKeys) => {
+	if (node.type === 'ThisExpression') {
+		return true;
+	}
+
+	if (
+		node.type === 'FunctionDeclaration'
+		|| node.type === 'FunctionExpression'
+	) {
+		// `this` inside non-arrow functions is rebound and does not affect outer arrows.
+		return false;
+	}
+
+	if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
+		// Class bodies create their own `this`, but computed keys/superclass are evaluated in outer scope.
+		if (node.superClass && isNodeContainsLexicalThis(node.superClass, visitorKeys)) {
+			return true;
+		}
+
+		for (const classElement of node.body.body) {
+			if (classElement.computed && isNodeContainsLexicalThis(classElement.key, visitorKeys)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	const keys = visitorKeys[node.type];
+
+	if (!keys) {
+		return false;
+	}
+
+	for (const key of keys) {
+		const value = node[key];
+
+		if (!value) {
+			continue;
+		}
+
+		if (Array.isArray(value)) {
+			for (const childNode of value) {
+				if (childNode && isNodeContainsLexicalThis(childNode, visitorKeys)) {
+					return true;
+				}
+			}
+
+			continue;
+		}
+
+		if (isNodeContainsLexicalThis(value, visitorKeys)) {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+export default isNodeContainsLexicalThis;
diff --git a/test/consistent-function-scoping.js b/test/consistent-function-scoping.js
@@ -248,6 +248,20 @@ test({
 				return doBar();
 			};
 		`,
+		outdent`
+			function doFoo(Foo) {
+				const doBar = (value = this) => value;
+				return doBar();
+			};
+		`,
+		outdent`
+			function doFoo(Foo) {
+				const doBar = () => class C {
+					[this.x]() {}
+				};
+				return doBar();
+			};
+		`,
 		// `arguments`
 		outdent`
 			function doFoo(Foo) {
@@ -953,6 +967,21 @@ test.typescript({
 				return b(1)(2);
 			}
 		`,
+		// #2088
+		outdent`
+			class Foo {
+				public bar = new FinalizationRegistry(() => {
+					console.log(this);
+				})
+			}
+		`,
+		// #2088
+		outdent`
+			function foo(this: unknown) {
+				const bar = () => console.log(this);
+				return [].map(() => bar);
+			}
+		`,
 	],
 	invalid: [],
 });
