oxlint-plugin-react-doctor 0.7.4-dev.593824d → 0.7.4-dev.63fc41f

package/dist/index.d.ts

@@ -5296,6 +5296,29 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-prop-callback-in-render";
+  readonly id: "no-prop-callback-in-render";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/no-prop-types";
   readonly id: "no-prop-types";
@@ -5480,6 +5503,29 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-ref-current-in-render";
+  readonly id: "no-ref-current-in-render";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/no-render-in-render";
   readonly id: "no-render-in-render";
@@ -14516,6 +14562,29 @@ declare const RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-prop-callback-in-render";
+  readonly id: "no-prop-callback-in-render";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/no-prop-types";
   readonly id: "no-prop-types";
@@ -14700,6 +14769,29 @@ declare const RULES: readonly [{
     readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-ref-current-in-render";
+  readonly id: "no-ref-current-in-render";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Bugs";
+    readonly requires: readonly Capability[];
+    readonly id: string;
+    readonly title?: string;
+    readonly severity: RuleSeverity;
+    readonly disabledWhen?: ReadonlyArray<Capability>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly matchByOccurrence?: boolean;
+    readonly defaultEnabled?: boolean;
+    readonly lifecycle?: "retired";
+    readonly scan?: FileScan;
+    readonly committedFilesOnly?: boolean;
+    readonly recommendation?: string;
+    readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-doctor/no-render-in-render";
   readonly id: "no-render-in-render";

package/dist/index.js

@@ -35028,6 +35028,66 @@ const noPropCallbackInEffect = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/no-prop-callback-in-render.ts
+const isPreservedThroughConciseArrow = (callExpression, scopes) => {
+	let node = callExpression;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "ChainExpression")) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "SequenceExpression")) {
+			const expressions = parent.expressions ?? [];
+			if (expressions[expressions.length - 1] !== node) return false;
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (!isNodeOfType(parent, "ArrowFunctionExpression") || parent.body !== node) return !isResultDiscardedCall(node);
+		const invocation = parent.parent;
+		if (!isNodeOfType(invocation, "CallExpression") || !executesDuringRender(parent, scopes)) return true;
+		if (invocation.arguments?.[0] === parent || invocation.arguments?.[1] === parent) {
+			const callee = stripParenExpression(invocation.callee);
+			return !(isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === "forEach" && invocation.arguments[0] === parent);
+		}
+		node = invocation;
+		parent = node.parent;
+	}
+	return false;
+};
+const noPropCallbackInRender = defineRule({
+	id: "no-prop-callback-in-render",
+	title: "Prop callback invoked during render",
+	severity: "error",
+	recommendation: "Invoke the callback from the event or asynchronous operation that produced the value, or from an effect when synchronizing with an external system. Render must stay pure because React can replay or discard it.",
+	create: (context) => ({ CallExpression(node) {
+		if (!isResultDiscardedCall(node)) return;
+		if (isPreservedThroughConciseArrow(node, context.scopes)) return;
+		if (!findRenderPhaseComponentOrHook(node, context.scopes)) return;
+		const analysis = getProgramAnalysis(node);
+		if (!analysis) return;
+		const callee = stripParenExpression(node.callee);
+		if (isFunctionLike$1(callee)) return;
+		if (!getDownstreamRefs(analysis, callee).some((reference) => isPropCallbackInvocationRef(analysis, reference))) return;
+		context.report({
+			node,
+			message: "This prop callback runs during render. React can replay or discard render work, so the callback can fire more than once or for UI that never commits."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/architecture/no-prop-types.ts
 const PROP_TYPES_PROPERTY = "propTypes";
 const isPropTypesKey = (key, computed) => {
@@ -35722,6 +35782,63 @@ const noRedundantShouldComponentUpdate = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
+const resolveReactRefSymbol = (memberExpression, scopes) => {
+	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
+	if (!isNodeOfType(memberExpression, "MemberExpression") || memberExpression.computed || !isNodeOfType(memberExpression.property, "Identifier") || memberExpression.property.name !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
+	const symbol = resolveConstIdentifierAlias(receiver, scopes);
+	if (!symbol?.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	if (!isNodeOfType(initializer, "CallExpression")) return null;
+	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
+};
+const isSameRefCurrentMember = (node, refSymbol, scopes) => {
+	if (!isNodeOfType(node, "MemberExpression") || node.computed || !isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return false;
+	const receiver = stripParenExpression(node.object);
+	return isNodeOfType(receiver, "Identifier") && resolveConstIdentifierAlias(receiver, scopes)?.id === refSymbol.id;
+};
+const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
+	if (assignmentExpression.operator !== "=" || !isNodeOfType(assignmentExpression.right, "NewExpression")) return false;
+	let descendant = assignmentExpression;
+	let ancestor = descendant.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant && isNodeOfType(ancestor.test, "BinaryExpression") && (ancestor.test.operator === "===" || ancestor.test.operator === "==")) {
+			const { left, right } = ancestor.test;
+			if (isSameRefCurrentMember(left, refSymbol, scopes) && isNodeOfType(right, "Literal") && right.value === null || isSameRefCurrentMember(right, refSymbol, scopes) && isNodeOfType(left, "Literal") && left.value === null) return true;
+		}
+		descendant = ancestor;
+		ancestor = descendant.parent;
+	}
+	return false;
+};
+const noRefCurrentInRender = defineRule({
+	id: "no-ref-current-in-render",
+	title: "Ref mutated during render",
+	severity: "error",
+	recommendation: "Move ref writes into an event handler or effect. Render must stay pure because React can replay or discard it. The predictable null-guarded lazy initialization pattern remains supported.",
+	create: (context) => {
+		const report = (memberExpression) => {
+			if (!resolveReactRefSymbol(memberExpression, context.scopes)) return;
+			if (!findRenderPhaseComponentOrHook(memberExpression, context.scopes)) return;
+			context.report({
+				node: memberExpression,
+				message: "This ref is mutated during render. React can replay or discard render work, so the mutation can leak from UI that never commits."
+			});
+		};
+		return {
+			AssignmentExpression(node) {
+				const refSymbol = resolveReactRefSymbol(node.left, context.scopes);
+				if (!refSymbol) return;
+				if (isDocumentedLazyInitialization(node, refSymbol, context.scopes)) return;
+				report(node.left);
+			},
+			UpdateExpression(node) {
+				report(node.argument);
+			}
+		};
+	}
+});
+//#endregion
 //#region src/plugin/rules/architecture/no-render-in-render.ts
 const isInsideComponentContext = (node) => {
 	let cursor = node.parent;
@@ -57112,6 +57229,18 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noPropCallbackInEffect.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/no-prop-callback-in-render",
+		id: "no-prop-callback-in-render",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noPropCallbackInRender,
+			framework: "global",
+			category: "Bugs",
+			requires: [...new Set(["react", ...noPropCallbackInRender.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-prop-types",
 		id: "no-prop-types",
@@ -57203,6 +57332,18 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noRedundantShouldComponentUpdate.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/no-ref-current-in-render",
+		id: "no-ref-current-in-render",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noRefCurrentInRender,
+			framework: "global",
+			category: "Bugs",
+			requires: [...new Set(["react", ...noRefCurrentInRender.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-render-in-render",
 		id: "no-render-in-render",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.4-dev.593824d",
+  "version": "0.7.4-dev.63fc41f",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",