feat: fix handling of function and class expression names in no-shadow (#20432)

mdjermanovic · web-flow · commit 43677de07ebd · 2026-01-21T16:01:41.000+01:00
* feat: fix handling of function and class expression names in `no-shadow` Fixes #20425 * add more tests * add more tests * rename variables, update jsdoc * update docs * update docs examples * remove extra empty line * refactor
diff --git a/docs/src/rules/no-shadow.md b/docs/src/rules/no-shadow.md
@@ -47,6 +47,39 @@ d(a);
 if (true) {
     const a = 5;
 }
+
+const f = wrap(function f() {});
+
+const C = wrap(class C {});
+```
+
+:::
+
+Examples of **correct** code for this rule:
+
+::: correct
+
+```js
+/*eslint no-shadow: "error"*/
+
+const a = 3;
+function b(c) {
+    const d = 10;
+    if (c) {
+        const e = 20;
+    }
+}
+
+/*
+ * Function and class names are allowed to shadow a variable
+ * if the function/class expression is assigned to the variable
+ * as its initializer or default value.
+ */
+const f = function f() {};
+const g = foo ? (bar || function g() {}) : baz;
+const { h = function h() {} } = obj;
+function qux(i = function i() {}) {}
+const C = class C {};
 ```
 
 :::
diff --git a/lib/rules/no-shadow.js b/lib/rules/no-shadow.js
@@ -346,32 +346,97 @@ module.exports = {
 		}
 
 		/**
-		 * Checks if a variable is inside the initializer of scopeVar.
+		 * Finds the uppermost expression node that can evaluate to the given one.
 		 *
-		 * To avoid reporting at declarations such as `var a = function a() {};`.
-		 * But it should report `var a = function(a) {};` or `var a = function() { function a() {} };`.
-		 * @param {Object} variable The variable to check.
-		 * @param {Object} scopeVar The scope variable to look for.
-		 * @returns {boolean} Whether or not the variable is inside initializer of scopeVar.
+		 * Examples:
+		 *    If given `a` in `a || foo`, it returns the `a || foo` node.
+		 *    If given `a` in `foo ? a : bar`, it returns the `foo ? a : bar` node.
+		 *    If given `a` in `foo ? bar : (baz && a)`, it returns the `foo ? bar : (baz && a)` node.
+		 *    If given `a` in `a ? foo : bar`, it returns the `a` node.
+		 *    If given `a` in `foo(a)`, it returns the `a` node.
+		 * @param {ASTNode} expression The expression node to unwrap.
+		 * @returns {ASTNode} The uppermost ancestor that can evaluate to the given node
+		 *     or the given node if there is no such ancestor.
 		 */
-		function isOnInitializer(variable, scopeVar) {
-			const outerScope = scopeVar.scope;
-			const outerDef = scopeVar.defs[0];
-			const outer = outerDef && outerDef.parent && outerDef.parent.range;
-			const innerScope = variable.scope;
-			const innerDef = variable.defs[0];
-			const inner = innerDef && innerDef.name.range;
+		function unwrapExpression(expression) {
+			const { parent } = expression;
 
-			return (
-				outer &&
-				inner &&
-				outer[0] < inner[0] &&
-				inner[1] < outer[1] &&
-				((innerDef.type === "FunctionName" &&
-					innerDef.node.type === "FunctionExpression") ||
-					innerDef.node.type === "ClassExpression") &&
-				outerScope === innerScope.upper
-			);
+			const shouldUnwrap =
+				parent.type === "LogicalExpression" ||
+				(parent.type === "ConditionalExpression" &&
+					parent.test !== expression);
+
+			return shouldUnwrap ? unwrapExpression(parent) : expression;
+		}
+
+		/**
+		 * Checks if inner variable is the name of a function or class
+		 * that is assigned to outer variable as its initializer.
+		 *
+		 * To avoid reporting at declarations such as:
+		 *    var a = function a() {};
+		 *    var A = class A {};
+		 *    var a = foo || function a() {};
+		 *    var a = foo ? function a() {} : bar;
+		 *    var { a = function a() {} } = foo;
+		 *
+		 * But it should report at declarations such as:
+		 *    var a = function(a) {};
+		 *    var a = function() { function a() {} };
+		 *    var a = wrap(function a() {});
+		 * @param {Object} innerVariable The inner variable to check.
+		 * @param {Object} outerVariable The outer variable.
+		 * @returns {boolean} Whether or not inner variable is the name of a
+		 *   function or class that is assigned to outer variable as its initializer.
+		 */
+		function isFunctionNameInitializerException(
+			innerVariable,
+			outerVariable,
+		) {
+			const outerDef = outerVariable.defs[0];
+			const innerDef = innerVariable.defs[0];
+
+			if (!outerDef || !innerDef) {
+				return false;
+			}
+
+			if (
+				!(
+					(innerDef.type === "FunctionName" &&
+						innerDef.node.type === "FunctionExpression") ||
+					(innerDef.type === "ClassName" &&
+						innerDef.node.type === "ClassExpression")
+				)
+			) {
+				return false;
+			}
+
+			const outerIdentifier = outerDef.name;
+			let initializerNode;
+
+			if (outerIdentifier.parent.type === "VariableDeclarator") {
+				initializerNode = outerIdentifier.parent.init;
+			} else if (outerIdentifier.parent.type === "AssignmentPattern") {
+				initializerNode = outerIdentifier.parent.right;
+			}
+
+			if (!initializerNode) {
+				return false;
+			}
+
+			const nodeToCheck = innerDef.node; // FunctionExpression or ClassExpression node
+
+			// Exit early if the node to check isn't inside the initializer
+			if (
+				!(
+					initializerNode.range[0] <= nodeToCheck.range[0] &&
+					nodeToCheck.range[1] <= initializerNode.range[1]
+				)
+			) {
+				return false;
+			}
+
+			return initializerNode === unwrapExpression(nodeToCheck);
 		}
 
 		/**
@@ -577,7 +642,7 @@ module.exports = {
 					shadowed &&
 					(shadowed.identifiers.length > 0 ||
 						(builtinGlobals && "writeable" in shadowed)) &&
-					!isOnInitializer(variable, shadowed) &&
+					!isFunctionNameInitializerException(variable, shadowed) &&
 					!(
 						ignoreOnInitialization &&
 						isInitPatternNode(variable, shadowed)
diff --git a/tests/lib/rules/no-shadow.js b/tests/lib/rules/no-shadow.js
