eslint-plugin-react-x 5.20.4 → 5.20.6

package/dist/index.js

@@ -5,7 +5,7 @@ import * as core from "@eslint-react/core";
 import { merge } from "@eslint-react/eslint";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { P, isMatching, match } from "ts-pattern";
-import { isAssignmentTargetEqual, isInitializedFromReact, resolve, resolveEnclosingAssignmentTarget, resolveObjectType } from "@eslint-react/var";
+import { isAssignmentTargetEqual, isInitializedFromReact, resolveEnclosingAssignmentTarget, resolveObjectType, resolveOrigin } from "@eslint-react/var";
 import { DefinitionType, ScopeType } from "@typescript-eslint/scope-manager";
 import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { findParentAttribute, getElementFullType, hasAttribute } from "@eslint-react/jsx";
@@ -145,7 +145,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.20.4";
+var version = "5.20.6";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1142,32 +1142,13 @@ const MUTATING_ARRAY_METHODS = /* @__PURE__ */ new Set([
 	"splice",
 	"unshift"
 ]);
-/**
-* Collect every write target in an assignment, including destructuring
-* patterns such as `[local, globalValue] = source`.
-*/
-function getAssignmentTargets(node) {
-	const target = Extract.unwrap(node);
-	switch (target.type) {
-		case AST_NODE_TYPES.Identifier:
-		case AST_NODE_TYPES.MemberExpression: return [target];
-		case AST_NODE_TYPES.ArrayPattern: return target.elements.flatMap((element) => element == null ? [] : getAssignmentTargets(element));
-		case AST_NODE_TYPES.AssignmentPattern: return getAssignmentTargets(target.left);
-		case AST_NODE_TYPES.ObjectPattern: return target.properties.flatMap((property) => {
-			if (property.type === AST_NODE_TYPES.RestElement) return getAssignmentTargets(property.argument);
-			return getAssignmentTargets(property.value);
-		});
-		case AST_NODE_TYPES.RestElement: return getAssignmentTargets(target.argument);
-		default: return [];
-	}
-}
 /** Resolve a direct call target, following simple function aliases. */
 function resolveToFunction(context, node, seen = /* @__PURE__ */ new Set()) {
 	const expression = Extract.unwrap(node);
 	if (Check.isFunction(expression)) return expression;
 	if (!Check.isIdentifier(expression) || seen.has(expression)) return null;
 	seen.add(expression);
-	const resolved = resolve(context, expression);
+	const resolved = resolveOrigin(context, expression);
 	if (resolved == null) return null;
 	return resolveToFunction(context, resolved, seen);
 }
@@ -1196,7 +1177,7 @@ function createFactCollector$2() {
 		facts,
 		visitor: {
 			AssignmentExpression(node) {
-				for (const target of getAssignmentTargets(node.left)) pushWrite(node, target);
+				for (const target of Extract.getAssignmentTargets(node.left)) pushWrite(node, target);
 			},
 			CallExpression(node) {
 				const caller = getEnclosingFunction(node);
@@ -1216,6 +1197,14 @@ function createFactCollector$2() {
 					receiver: callee.object
 				});
 			},
+			ForInStatement(node) {
+				if (node.left.type === AST_NODE_TYPES.VariableDeclaration) return;
+				for (const target of Extract.getAssignmentTargets(node.left)) pushWrite(node, target);
+			},
+			ForOfStatement(node) {
+				if (node.left.type === AST_NODE_TYPES.VariableDeclaration) return;
+				for (const target of Extract.getAssignmentTargets(node.left)) pushWrite(node, target);
+			},
 			UnaryExpression(node) {
 				if (node.operator !== "delete") return;
 				const argument = Extract.unwrap(node.argument);
@@ -1445,7 +1434,7 @@ function resolveToFunctionNode(context, node, seen = /* @__PURE__ */ new Set())
 	if (Check.isFunction(expr)) return expr;
 	if (!Check.isIdentifier(expr) || seen.has(expr)) return null;
 	seen.add(expr);
-	const resolved = resolve(context, expr);
+	const resolved = resolveOrigin(context, expr);
 	return resolved == null ? null : resolveToFunctionNode(context, resolved, seen);
 }
 function resolveVariableOrigin(context, variable, seen = /* @__PURE__ */ new Set()) {
@@ -1514,19 +1503,18 @@ function createFactCollector$1() {
 		if (root == null || !Check.isIdentifier(root)) return;
 		pushMutation("value", node, target, root);
 	}
+	function pushTargetMutation(node, target) {
+		if (Check.isIdentifier(target)) {
+			pushMutation("binding", node, target, target);
+			return;
+		}
+		pushMemberMutation(node, target);
+	}
 	return {
 		facts,
 		visitor: {
 			AssignmentExpression(node) {
-				const target = Extract.unwrap(node.left);
-				switch (target.type) {
-					case AST_NODE_TYPES.Identifier:
-						pushMutation("binding", node, target, target);
-						return;
-					case AST_NODE_TYPES.MemberExpression:
-						pushMemberMutation(node, target);
-						return;
-				}
+				for (const target of Extract.getAssignmentTargets(node.left)) pushTargetMutation(node, target);
 			},
 			CallExpression(node) {
 				const callee = Extract.unwrap(node.callee);
@@ -1543,6 +1531,14 @@ function createFactCollector$1() {
 					});
 				}
 			},
+			ForInStatement(node) {
+				if (node.left.type === AST_NODE_TYPES.VariableDeclaration) return;
+				for (const target of Extract.getAssignmentTargets(node.left)) pushTargetMutation(node, target);
+			},
+			ForOfStatement(node) {
+				if (node.left.type === AST_NODE_TYPES.VariableDeclaration) return;
+				for (const target of Extract.getAssignmentTargets(node.left)) pushTargetMutation(node, target);
+			},
 			JSXAttribute(node) {
 				if (node.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
 				const expression = node.value.expression;
@@ -4871,8 +4867,159 @@ const IMPURE_CTORS = /* @__PURE__ */ new Set([
 	"XMLHttpRequest"
 ]);
 /**
-* Recursively resolve an identifier to the root builtin global object name.
-* Follows simple assignment chains like `const M = Math` or `const w = window`.
+* Known pure functions
+*/
+const PURE_FUNCS = /* @__PURE__ */ new Map([
+	["Array", /* @__PURE__ */ new Set([
+		"from",
+		"isArray",
+		"of"
+	])],
+	["Atomics", /* @__PURE__ */ new Set(["isLockFree"])],
+	["BigInt", /* @__PURE__ */ new Set(["asIntN", "asUintN"])],
+	["Date", /* @__PURE__ */ new Set(["parse", "UTC"])],
+	["globalThis", /* @__PURE__ */ new Set([
+		"atob",
+		"Boolean",
+		"btoa",
+		"decodeURI",
+		"decodeURIComponent",
+		"encodeURI",
+		"encodeURIComponent",
+		"escape",
+		"isFinite",
+		"isNaN",
+		"Number",
+		"parseFloat",
+		"parseInt",
+		"String",
+		"unescape"
+	])],
+	["JSON", /* @__PURE__ */ new Set(["parse", "stringify"])],
+	["Math", /* @__PURE__ */ new Set([
+		"abs",
+		"acos",
+		"acosh",
+		"asin",
+		"asinh",
+		"atan",
+		"atan2",
+		"atanh",
+		"cbrt",
+		"ceil",
+		"clz32",
+		"cos",
+		"cosh",
+		"exp",
+		"expm1",
+		"floor",
+		"fround",
+		"hypot",
+		"imul",
+		"log",
+		"log1p",
+		"log2",
+		"log10",
+		"max",
+		"min",
+		"pow",
+		"round",
+		"sign",
+		"sin",
+		"sinh",
+		"sqrt",
+		"tan",
+		"tanh",
+		"trunc"
+	])],
+	["Number", /* @__PURE__ */ new Set([
+		"isFinite",
+		"isInteger",
+		"isNaN",
+		"isSafeInteger",
+		"parseFloat",
+		"parseInt"
+	])],
+	["Object", /* @__PURE__ */ new Set([
+		"entries",
+		"fromEntries",
+		"getOwnPropertyDescriptor",
+		"getOwnPropertyDescriptors",
+		"getOwnPropertyNames",
+		"getOwnPropertySymbols",
+		"getPrototypeOf",
+		"groupBy",
+		"hasOwn",
+		"is",
+		"isExtensible",
+		"isFrozen",
+		"isSealed",
+		"keys",
+		"values"
+	])],
+	["Reflect", /* @__PURE__ */ new Set([
+		"apply",
+		"construct",
+		"get",
+		"getOwnPropertyDescriptor",
+		"getPrototypeOf",
+		"has",
+		"isExtensible",
+		"ownKeys"
+	])],
+	["String", /* @__PURE__ */ new Set([
+		"fromCharCode",
+		"fromCodePoint",
+		"raw"
+	])]
+]);
+function isCatalogObject(name) {
+	return IMPURE_FUNCS.has(name) || PURE_FUNCS.has(name);
+}
+/**
+* Find the property key under which `name` is bound in an object destructuring
+* pattern, e.g. `"random"` for `random` in `const { random } = Math` or for
+* `r` in `const { random: r } = Math`.
+*/
+function getDestructuredPropertyName(pattern, name) {
+	for (const property of pattern.properties) {
+		if (property.type !== AST_NODE_TYPES.Property) continue;
+		if ((property.value.type === AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value) !== name) continue;
+		return Extract.getPropertyName(property, "max");
+	}
+	return null;
+}
+/**
+* Resolve a member expression to a builtin object name and property, e.g.
+* `window.Math.random` resolves to `{ object: "Math", property: "random" }`.
+* Intermediate segments are followed only while they name known catalog
+* objects (`window`, `Math`, ...), so unknown-global chains like
+* `foo.Math.random` do not resolve.
+*/
+function resolveBuiltinMember(context, node, seen = /* @__PURE__ */ new Set()) {
+	const chain = Extract.getMemberChain(node);
+	const rootId = chain.at(0);
+	if (rootId == null || !Check.isIdentifier(rootId)) return null;
+	const segments = chain.slice(1);
+	if (segments.length === 0 || !segments.every((segment) => Check.isIdentifier(segment))) return null;
+	const resolved = resolveBuiltinObjectName(context, rootId, seen);
+	if (resolved == null) return null;
+	let object = resolved.property ?? resolved.object;
+	const names = segments.map((segment) => segment.name);
+	if (isCatalogObject(object)) for (const name of names.slice(0, -1)) {
+		if (!isCatalogObject(name)) break;
+		object = name;
+	}
+	return {
+		object,
+		property: names.at(-1) ?? null
+	};
+}
+/**
+* Recursively resolve an identifier to a builtin global object name and
+* optional property. Follows simple assignment chains like `const M = Math`,
+* member-function aliases like `const random = Math.random`, and destructured
+* aliases like `const { random } = Math`.
 * Returns `null` if the identifier is locally defined (parameter, import, function declaration, etc.)
 * or resolves to a non-builtin source.
 * @param context - The rule context.
@@ -4884,17 +5031,33 @@ function resolveBuiltinObjectName(context, node, seen = /* @__PURE__ */ new Set(
 	seen.add(node.name);
 	const scope = context.sourceCode.getScope(node);
 	const variable = findVariable(scope, node);
-	if (variable == null) return node.name;
+	if (variable == null) return {
+		object: node.name,
+		property: null
+	};
 	const def = variable.defs[0];
-	if (def == null) return node.name;
-	if (def.type === DefinitionType.ImplicitGlobalVariable) return node.name;
+	if (def == null) return {
+		object: node.name,
+		property: null
+	};
+	if (def.type === DefinitionType.ImplicitGlobalVariable) return {
+		object: node.name,
+		property: null
+	};
 	if (def.type === DefinitionType.Variable && def.node.init != null) {
 		const init = Extract.unwrap(def.node.init);
-		if (Check.isIdentifier(init)) return resolveBuiltinObjectName(context, init, seen);
-		if (init.type === AST_NODE_TYPES.MemberExpression) {
-			const rootId = Extract.getMemberChain(init).at(0);
-			if (rootId != null && Check.isIdentifier(rootId)) return resolveBuiltinObjectName(context, rootId, seen);
+		const resolved = Check.isIdentifier(init) ? resolveBuiltinObjectName(context, init, seen) : init.type === AST_NODE_TYPES.MemberExpression ? resolveBuiltinMember(context, init, seen) : null;
+		if (resolved == null) return null;
+		if (def.node.id.type === AST_NODE_TYPES.ObjectPattern) {
+			const key = getDestructuredPropertyName(def.node.id, def.name);
+			if (key == null) return null;
+			return {
+				object: resolved.property ?? resolved.object,
+				property: key
+			};
 		}
+		if (def.node.id.type === AST_NODE_TYPES.ArrayPattern) return null;
+		return resolved;
 	}
 	return null;
 }
@@ -4923,10 +5086,9 @@ function create$7(context) {
 			const expr = Extract.unwrap(node.callee);
 			switch (true) {
 				case Check.isIdentifier(expr): {
-					const builtinName = resolveBuiltinObjectName(context, expr);
-					if (builtinName == null) return;
-					const globalThisImpure = IMPURE_FUNCS.get("globalThis");
-					if (globalThisImpure == null || !globalThisImpure.has(builtinName)) return;
+					const resolved = resolveBuiltinObjectName(context, expr);
+					if (resolved == null) return;
+					if (!(resolved.property != null ? IMPURE_FUNCS.get(resolved.object)?.has(resolved.property) ?? false : IMPURE_FUNCS.get("globalThis")?.has(resolved.object) ?? false)) return;
 					const func = Traverse.findParent(node, Check.isFunction);
 					if (func == null) return;
 					cEntries.push({
@@ -4936,13 +5098,9 @@ function create$7(context) {
 					break;
 				}
 				case expr.type === AST_NODE_TYPES.MemberExpression && Check.isIdentifier(expr.property): {
-					const rootId = Extract.getMemberChain(expr.object).at(0);
-					if (rootId == null || !Check.isIdentifier(rootId)) return;
-					const objectName = resolveBuiltinObjectName(context, rootId);
-					if (objectName == null) return;
-					const propertyName = expr.property.name;
-					const objectImpure = IMPURE_FUNCS.get(objectName);
-					if (objectImpure == null || !objectImpure.has(propertyName)) return;
+					const resolved = resolveBuiltinMember(context, expr);
+					if (resolved == null || resolved.property == null) return;
+					if (!IMPURE_FUNCS.get(resolved.object)?.has(resolved.property)) return;
 					const func = Traverse.findParent(node, Check.isFunction);
 					if (func == null) return;
 					cEntries.push({
@@ -4956,10 +5114,11 @@ function create$7(context) {
 		NewExpression(node) {
 			const expr = Extract.unwrap(node.callee);
 			if (!Check.isIdentifier(expr)) return;
-			const builtinName = resolveBuiltinObjectName(context, expr);
-			if (builtinName == null) return;
-			if (!IMPURE_CTORS.has(builtinName)) return;
-			if (builtinName === "Date" && node.arguments.length > 0) return;
+			const resolved = resolveBuiltinObjectName(context, expr);
+			if (resolved == null) return;
+			const ctorName = resolved.property != null && isCatalogObject(resolved.object) ? resolved.property : resolved.object;
+			if (!IMPURE_CTORS.has(ctorName)) return;
+			if (ctorName === "Date" && node.arguments.length > 0) return;
 			const func = Traverse.findParent(node, Check.isFunction);
 			if (func == null) return;
 			nEntries.push({
@@ -5029,14 +5188,47 @@ function isReachedThroughFunctions(node, boundary, reached) {
 function getRefAccess(node) {
 	let parent = node.parent;
 	while (Check.isTypeExpression(parent)) parent = parent.parent;
-	const isDirectWrite = parent.type === AST_NODE_TYPES.AssignmentExpression ? parent.left === node || Extract.unwrap(parent.left) === node : parent.type === AST_NODE_TYPES.UpdateExpression ? parent.argument === node || Extract.unwrap(parent.argument) === node : false;
+	const isDirectWrite = parent.type === AST_NODE_TYPES.AssignmentExpression ? parent.left === node || Extract.unwrap(parent.left) === node : parent.type === AST_NODE_TYPES.UpdateExpression ? parent.argument === node || Extract.unwrap(parent.argument) === node : parent.type === AST_NODE_TYPES.UnaryExpression && parent.operator === "delete" ? parent.argument === node || Extract.unwrap(parent.argument) === node : false;
 	return {
 		isInitializationWrite: parent.type === AST_NODE_TYPES.AssignmentExpression && parent.operator === "=" && (parent.left === node || Extract.unwrap(parent.left) === node),
-		isWrite: isDirectWrite || isNestedRefCurrentWrite(node),
+		isWrite: isDirectWrite || isNestedRefCurrentWrite(node) || isPatternWriteTarget(node),
 		node
 	};
 }
 /**
+* Check whether `node` (a `ref.current` MemberExpression) is assigned through a
+* destructuring pattern or a for-in/of loop target, e.g.
+* `({ a: ref.current } = value)`, `[ref.current] = value`,
+* `({ a: ref.current.x } = value)`, or `for (ref.current of items)`. Defaults
+* and computed keys inside patterns are reads, not writes.
+*/
+function isPatternWriteTarget(node) {
+	let child = node;
+	let current = node.parent;
+	while (true) {
+		switch (current.type) {
+			case AST_NODE_TYPES.MemberExpression:
+				if (current.object !== child && Extract.unwrap(current.object) !== child) return false;
+				break;
+			case AST_NODE_TYPES.Property:
+				if (current.value !== child) return false;
+				break;
+			case AST_NODE_TYPES.ObjectPattern:
+			case AST_NODE_TYPES.ArrayPattern:
+			case AST_NODE_TYPES.RestElement: break;
+			case AST_NODE_TYPES.AssignmentPattern:
+				if (current.left !== child) return false;
+				break;
+			case AST_NODE_TYPES.AssignmentExpression: return current.operator === "=" && current.left === child;
+			case AST_NODE_TYPES.ForInStatement:
+			case AST_NODE_TYPES.ForOfStatement: return current.left === child;
+			default: return false;
+		}
+		child = current;
+		current = current.parent;
+	}
+}
+/**
 * Check whether `node` (a `ref.current` MemberExpression) is being written to indirectly through
 * a nested property write, e.g. `ref.current.inner = value` or `ref.current.inner++`.
 */
@@ -5054,6 +5246,7 @@ function isNestedRefCurrentWrite(node) {
 		if (!sawNesting) return false;
 		if (parent.type === AST_NODE_TYPES.AssignmentExpression) return parent.left === outer || Extract.unwrap(parent.left) === outer;
 		if (parent.type === AST_NODE_TYPES.UpdateExpression) return parent.argument === outer || Extract.unwrap(parent.argument) === outer;
+		if (parent.type === AST_NODE_TYPES.UnaryExpression && parent.operator === "delete") return parent.argument === outer || Extract.unwrap(parent.argument) === outer;
 		return false;
 	}
 }
@@ -5137,15 +5330,17 @@ function isAfterTerminatingNonNullGuard(node, getNullBranch) {
 /**
 * Collect the raw facts the refs rule reasons about: identifier/member/function
 * bindings with their source positions, JSX `ref` attribute targets, call
-* expressions, and every `.current` member access. Facts outside any function
-* are never reachable during render and are not collected. All inference is
-* deferred to `Program:exit`.
+* expressions, ref pass sites (calls, constructor calls, tagged templates), and
+* every `.current` member access. Facts outside any function are never
+* reachable during render and are not collected. All inference is deferred to
+* `Program:exit`.
 */
 function createFactCollector() {
 	const facts = {
 		bindings: [],
 		callEdges: [],
 		jsxRefs: [],
+		passSites: [],
 		refAccesses: []
 	};
 	return {
@@ -5180,6 +5375,10 @@ function createFactCollector() {
 					caller,
 					node
 				});
+				facts.passSites.push({
+					caller,
+					node
+				});
 			},
 			FunctionDeclaration(node) {
 				if (node.id != null) facts.bindings.push({
@@ -5204,6 +5403,22 @@ function createFactCollector() {
 					enclosingFunction
 				});
 			},
+			NewExpression(node) {
+				const caller = Traverse.findParent(node, Check.isFunction);
+				if (caller == null) return;
+				facts.passSites.push({
+					caller,
+					node
+				});
+			},
+			TaggedTemplateExpression(node) {
+				const caller = Traverse.findParent(node, Check.isFunction);
+				if (caller == null) return;
+				facts.passSites.push({
+					caller,
+					node
+				});
+			},
 			VariableDeclarator(node) {
 				if (!Check.isIdentifier(node.id) || node.init == null) return;
 				facts.bindings.push({
@@ -5322,21 +5537,43 @@ function inferRefViolations(accesses, boundaries, reachability, resolver) {
 	return violations;
 }
 /**
+* Get the statically known name of a pass-site callee, whether it is a plain
+* call, a constructor call, or a tagged template.
+*/
+function getPassSiteCalleeName(node) {
+	const callee = Extract.unwrap(node.type === AST_NODE_TYPES.TaggedTemplateExpression ? node.tag : node.callee);
+	if (Check.isIdentifier(callee)) return callee.name;
+	if (callee.type === AST_NODE_TYPES.MemberExpression && !callee.computed && Check.isIdentifier(callee.property)) return callee.property.name;
+	return null;
+}
+/**
+* The `mergeRefs` exemption is name-based but alias-aware: a simple variable
+* alias of a `mergeRefs` binding keeps the exemption.
+*/
+function isMergeRefsCallee(callee, calleeName, position, resolver) {
+	if (calleeName === "mergeRefs") return true;
+	if (callee.type !== AST_NODE_TYPES.Identifier) return false;
+	const variable = resolver.getVariable(callee);
+	return variable != null && resolver.resolveAliasTarget(variable, position).name === "mergeRefs";
+}
+/**
 * Passing a ref to an unknown function can expose its value during render.
 * Hook callbacks, mergeRefs, and the existing render-prop compatibility case
 * remain exempt.
 */
-function inferRefPassViolations(callEdges, boundaries, reachability, resolver) {
+function inferRefPassViolations(passSites, boundaries, reachability, resolver) {
 	const violations = [];
-	for (const edge of callEdges) {
-		const boundary = getBoundaryOf(edge.caller, boundaries);
-		if (boundary == null || !isReachedDuringRender(edge.node, boundary, reachability)) continue;
-		const call = edge.node;
-		const callee = Extract.unwrap(call.callee);
-		const calleeName = Extract.getCalleeName(call);
-		const callArguments = call.arguments;
-		if (core.isHookCall(call) || calleeName === "mergeRefs" || calleeName === "render" && callee.type === AST_NODE_TYPES.MemberExpression) continue;
-		for (const argument of callArguments) {
+	for (const site of passSites) {
+		const boundary = getBoundaryOf(site.caller, boundaries);
+		if (boundary == null || !isReachedDuringRender(site.node, boundary, reachability)) continue;
+		const node = site.node;
+		const callee = Extract.unwrap(node.type === AST_NODE_TYPES.TaggedTemplateExpression ? node.tag : node.callee);
+		const calleeName = getPassSiteCalleeName(node);
+		const args = node.type === AST_NODE_TYPES.TaggedTemplateExpression ? node.quasi.expressions : node.arguments;
+		if (node.type === AST_NODE_TYPES.CallExpression && core.isHookCall(node)) continue;
+		if (isMergeRefsCallee(callee, calleeName, node.range[0], resolver)) continue;
+		if (calleeName === "render" && callee.type === AST_NODE_TYPES.MemberExpression) continue;
+		for (const argument of args) {
 			if (argument.type === AST_NODE_TYPES.SpreadElement) continue;
 			const value = Extract.unwrap(argument);
 			if (!Check.isIdentifier(value)) continue;
@@ -5450,6 +5687,18 @@ function createBindingResolver(context, facts) {
 			case "unknown": return null;
 		}
 	}
+	/**
+	* Follow simple variable-to-variable aliases to the terminal variable, e.g.
+	* `const combine = mergeRefs` resolves to the `mergeRefs` variable itself.
+	* Position-aware, so a reassigned alias resolves to its latest source.
+	*/
+	function resolveAliasTarget(variable, position, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(variable)) return variable;
+		seen.add(variable);
+		const event = getLatestValue(bindings.get(variable), position);
+		if (event != null && event.value.kind === "variable") return resolveAliasTarget(event.value.variable, event.position, seen);
+		return variable;
+	}
 	function resolveCallable(node, position) {
 		const callee = Extract.unwrap(node);
 		if (isFunctionExpressionLike(callee)) return callee;
@@ -5499,6 +5748,7 @@ function createBindingResolver(context, facts) {
 		getNullBranch,
 		getRefTarget,
 		getVariable,
+		resolveAliasTarget,
 		resolveCallable,
 		resolveRef
 	};
@@ -5540,7 +5790,7 @@ function create$6(context) {
 		const resolver = createBindingResolver(context, facts.facts);
 		const callGraph = inferCallGraph(boundaries, facts.facts.callEdges, resolver.resolveCallable);
 		const reachability = collectReachableFunctions(boundaries, callGraph);
-		const violations = [...inferRefViolations(facts.facts.refAccesses, boundaries, reachability, resolver), ...inferRefPassViolations(facts.facts.callEdges, boundaries, reachability, resolver)];
+		const violations = [...inferRefViolations(facts.facts.refAccesses, boundaries, reachability, resolver), ...inferRefPassViolations(facts.facts.passSites, boundaries, reachability, resolver)];
 		for (const violation of violations) context.report({
 			messageId: match(violation).with({ kind: "duplicate-init" }, () => "duplicateRefInit").with({ kind: "pass" }, () => "refPassedToFunction").with({ kind: "read" }, () => "readDuringRender").with({ kind: "write" }, () => "writeDuringRender").exhaustive(),
 			node: violation.node
@@ -7887,7 +8137,7 @@ function create$5(context) {
 		}
 	}
 	function isIdFromUseStateCall(id, at) {
-		const initNode = resolve(context, id);
+		const initNode = resolveOrigin(context, id);
 		if (initNode == null) return false;
 		if (initNode.type !== AST_NODE_TYPES.CallExpression) return false;
 		if (!isUseStateCall(initNode)) return false;
@@ -8012,7 +8262,7 @@ function create$5(context) {
 			const getSetStateCalls = (context, id) => {
 				const variable = findVariable(context.sourceCode.getScope(id), id);
 				if (variable != null && variable.defs.some((def) => def.type === DefinitionType.Parameter)) return [];
-				const node = resolve(context, id);
+				const node = resolveOrigin(context, id);
 				switch (node?.type) {
 					case AST_NODE_TYPES.ArrowFunctionExpression:
 					case AST_NODE_TYPES.FunctionDeclaration:
@@ -8112,7 +8362,7 @@ function create$4(context) {
 		return core.isUseStateLikeCall(node, additionalStateHooks);
 	}
 	function isIdFromUseStateCall(topLevelId, at) {
-		const initNode = resolve(context, topLevelId);
+		const initNode = resolveOrigin(context, topLevelId);
 		if (initNode == null) return false;
 		if (initNode.type !== AST_NODE_TYPES.CallExpression) return false;
 		if (!isUseStateCall(initNode)) return false;
@@ -8473,18 +8723,28 @@ function create$1(context) {
 	function validateNoOuterVariableReassignment(callback) {
 		const violations = [];
 		if (callback.body == null) return violations;
-		simpleTraverse(callback.body, { enter(node) {
-			if (node.type !== AST_NODE_TYPES.AssignmentExpression) return;
-			const left = Extract.unwrap(node.left);
-			if (!Check.isIdentifier(left)) return;
+		function checkWriteTarget(node, target) {
+			if (!Check.isIdentifier(target)) return;
 			if (Traverse.findParent(node, Check.isFunction, (n) => n === callback) != null) return;
-			const scope = context.sourceCode.getScope(left);
-			const variable = findVariable(scope, left);
+			const scope = context.sourceCode.getScope(target);
+			const variable = findVariable(scope, target);
 			if (variable != null && variable.defs.length > 0 && isDeclaredInsideCallback(variable, callback)) return;
 			violations.push({
 				messageId: "noReassigningOuterVariables",
-				node: left
+				node: target
 			});
+		}
+		simpleTraverse(callback.body, { enter(node) {
+			switch (node.type) {
+				case AST_NODE_TYPES.AssignmentExpression:
+					for (const target of Extract.getAssignmentTargets(node.left)) checkWriteTarget(node, target);
+					return;
+				case AST_NODE_TYPES.ForInStatement:
+				case AST_NODE_TYPES.ForOfStatement:
+					if (node.left.type === AST_NODE_TYPES.VariableDeclaration) return;
+					for (const target of Extract.getAssignmentTargets(node.left)) checkWriteTarget(node, target);
+					return;
+			}
 		} });
 		return violations;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.20.4",
+  "version": "5.20.6",
   "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
   "keywords": [
     "react",
@@ -36,12 +36,12 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.20.4",
-    "@eslint-react/core": "5.20.4",
-    "@eslint-react/eslint": "5.20.4",
-    "@eslint-react/jsx": "5.20.4",
-    "@eslint-react/shared": "5.20.4",
-    "@eslint-react/var": "5.20.4",
+    "@eslint-react/ast": "5.20.6",
+    "@eslint-react/core": "5.20.6",
+    "@eslint-react/eslint": "5.20.6",
+    "@eslint-react/jsx": "5.20.6",
+    "@eslint-react/shared": "5.20.6",
+    "@eslint-react/var": "5.20.6",
     "@typescript-eslint/scope-manager": "^8.70.0",
     "@typescript-eslint/type-utils": "^8.70.0",
     "@typescript-eslint/types": "^8.70.0",
@@ -63,7 +63,7 @@
     "react-dom": "^19.3.0",
     "tsdown": "^0.23.0",
     "tsl": "^1.0.30",
-    "tsl-dx": "^0.13.5",
+    "tsl-dx": "^0.13.6",
     "typescript": "6.0.3"
   },
   "peerDependencies": {