oxlint-plugin-react-doctor 0.9.2-dev.16972ae → 0.9.2-dev.1f6e181

package/dist/index.js

@@ -82275,6 +82275,45 @@ const noRefCallbackCleanupBeforeReact19 = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/contains-non-deterministic-source.ts
+const NON_DETERMINISTIC_MEMBER_CALLS = new Set([
+	"Math.random",
+	"Date.now",
+	"performance.now",
+	"crypto.randomUUID",
+	"crypto.getRandomValues"
+]);
+const NON_DETERMINISTIC_ID_GENERATOR_NAMES = new Set([
+	"nanoid",
+	"uuid",
+	"cuid",
+	"ulid",
+	"createId"
+]);
+const isZeroArgDateConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Date" && (node.arguments?.length ?? 0) === 0;
+const containsNonDeterministicSource = (root) => {
+	let found = false;
+	walkAst(root, (child) => {
+		if (found) return false;
+		if (isFunctionLike$1(child)) return false;
+		if (isZeroArgDateConstruction(child)) {
+			found = true;
+			return false;
+		}
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const callee = child.callee;
+		if (isNodeOfType(callee, "Identifier") && NON_DETERMINISTIC_ID_GENERATOR_NAMES.has(callee.name)) {
+			found = true;
+			return false;
+		}
+		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && isNodeOfType(callee.property, "Identifier") && NON_DETERMINISTIC_MEMBER_CALLS.has(`${callee.object.name}.${callee.property.name}`)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
 const REPEATED_ANCESTOR_TYPES = new Set([
 	"DoWhileStatement",
@@ -82305,45 +82344,75 @@ const resolveImmutableInitializationValue = (node, scopes, visitedSymbolIds = /*
 };
 const isProvablyTruthyInitializationValue = (node, scopes) => {
 	const expression = resolveImmutableInitializationValue(node, scopes);
-	return Boolean(expression && (isNodeOfType(expression, "NewExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "ClassExpression")));
+	if (!expression) return false;
+	if (isNodeOfType(expression, "CallExpression")) {
+		const callee = stripParenExpression(expression.callee);
+		return isNodeOfType(callee, "Identifier") && callee.name.startsWith("create");
+	}
+	return isNodeOfType(expression, "NewExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "ClassExpression");
 };
-const getInitializationConstructorName = (node, scopes) => {
+const getInitializationValueName = (node, scopes) => {
 	const expression = resolveImmutableInitializationValue(node, scopes);
 	if (!expression) return null;
-	if (isNodeOfType(expression, "NewExpression")) {
+	if (isNodeOfType(expression, "NewExpression") || isNodeOfType(expression, "CallExpression")) {
 		const callee = stripParenExpression(expression.callee);
-		return isNodeOfType(callee, "Identifier") ? callee.name : null;
+		if (!isNodeOfType(callee, "Identifier")) return null;
+		return callee.name.startsWith("create") && callee.name.length > 6 ? callee.name.slice(6) : callee.name;
 	}
 	return null;
 };
+const isMatchingReturnType = (typeNode, initializationValue, scopes) => {
+	if (!isNodeOfType(typeNode, "TSTypeReference")) return false;
+	const typeName = typeNode.typeName;
+	if (!isNodeOfType(typeName, "Identifier") || typeName.name !== "ReturnType") return false;
+	const [returnTypeArgument] = typeNode.typeArguments?.params ?? [];
+	if (!returnTypeArgument || !isNodeOfType(returnTypeArgument, "TSTypeQuery")) return false;
+	const queriedName = returnTypeArgument.exprName;
+	const expression = stripParenExpression(initializationValue);
+	if (!isNodeOfType(queriedName, "Identifier") || !isNodeOfType(expression, "CallExpression")) return false;
+	const callee = stripParenExpression(expression.callee);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const queriedSymbol = scopes.symbolFor(queriedName);
+	const calleeSymbol = scopes.symbolFor(callee);
+	return queriedSymbol && calleeSymbol ? queriedSymbol.id === calleeSymbol.id : queriedName.name === callee.name;
+};
 const isClosedTruthyTypeDomain = (typeNode, initializationValue, scopes) => {
 	const initializationExpression = stripParenExpression(initializationValue);
 	if (isNodeOfType(typeNode, "TSTypeLiteral")) return isNodeOfType(initializationExpression, "ObjectExpression");
 	if (isNodeOfType(typeNode, "TSArrayType") || isNodeOfType(typeNode, "TSTupleType")) return isNodeOfType(initializationExpression, "ArrayExpression");
 	if (isNodeOfType(typeNode, "TSFunctionType") || isNodeOfType(typeNode, "TSConstructorType")) return isNodeOfType(initializationExpression, "ArrowFunctionExpression") || isNodeOfType(initializationExpression, "FunctionExpression") || isNodeOfType(initializationExpression, "ClassExpression");
 	if (isNodeOfType(typeNode, "TSObjectKeyword")) return true;
+	if (isNodeOfType(typeNode, "TSIndexedAccessType")) return isNodeOfType(initializationExpression, "ObjectExpression");
 	if (!isNodeOfType(typeNode, "TSTypeReference")) return false;
 	const typeName = typeNode.typeName;
-	return isNodeOfType(typeName, "Identifier") && typeName.name === getInitializationConstructorName(initializationExpression, scopes);
+	if (isNodeOfType(initializationExpression, "ObjectExpression") || isMatchingReturnType(typeNode, initializationExpression, scopes)) return true;
+	return isNodeOfType(typeName, "Identifier") && typeName.name === getInitializationValueName(initializationExpression, scopes);
 };
 const refHasClosedFalsySentinelDomain = (refSymbol, initializationValue, scopes) => {
 	const initializer = refSymbol.initializer ? stripParenExpression(refSymbol.initializer) : null;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
 	const [initialValue] = initializer.arguments ?? [];
-	if (!initialValue || isNodeOfType(initialValue, "SpreadElement") || !isEmptySentinel(initialValue, scopes)) return false;
+	if (initialValue && isNodeOfType(initialValue, "SpreadElement") || initialValue && !isEmptySentinel(initialValue, scopes)) return false;
 	const [declaredType] = initializer.typeArguments?.params ?? [];
-	if (!declaredType || !isNodeOfType(declaredType, "TSUnionType")) return false;
-	let hasEmptySentinel = false;
+	if (!declaredType) return false;
+	const domainTypes = isNodeOfType(declaredType, "TSUnionType") ? declaredType.types : [declaredType];
 	let hasTruthyDomain = false;
-	for (const memberType of declaredType.types ?? []) {
-		if (isNodeOfType(memberType, "TSNullKeyword") || isNodeOfType(memberType, "TSUndefinedKeyword")) {
-			hasEmptySentinel = true;
-			continue;
-		}
+	for (const memberType of domainTypes) {
+		if (isNodeOfType(memberType, "TSNullKeyword") || isNodeOfType(memberType, "TSUndefinedKeyword")) continue;
 		if (!isClosedTruthyTypeDomain(memberType, initializationValue, scopes)) return false;
 		hasTruthyDomain = true;
 	}
-	return hasEmptySentinel && hasTruthyDomain;
+	return hasTruthyDomain;
+};
+const refHasEmptySentinelInitializer = (refSymbol, scopes) => {
+	const initializer = refSymbol.initializer ? stripParenExpression(refSymbol.initializer) : null;
+	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
+	const [initialValue] = initializer.arguments ?? [];
+	return Boolean(!initialValue || !isNodeOfType(initialValue, "SpreadElement") && isEmptySentinel(initialValue, scopes));
+};
+const refHasDeclaredType = (refSymbol) => {
+	const initializer = refSymbol.initializer ? stripParenExpression(refSymbol.initializer) : null;
+	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && (initializer.typeArguments?.params.length ?? 0) > 0);
 };
 const isSafeRefIdentifierUse = (identifier) => {
 	const expressionRoot = findTransparentExpressionRoot(identifier);
@@ -82375,25 +82444,40 @@ const expressionContainsRefCurrent = (expression, refSymbol, scopes) => {
 	});
 	return didFindRefCurrent;
 };
-const hasNoCompetingRefCurrentWrite = (branchRoot, assignmentExpression, refSymbol, scopes) => {
-	let writeCount = 0;
-	walkAst(branchRoot, (child) => {
-		if (writeCount > 1) return false;
-		if (isNodeOfType(child, "AssignmentExpression")) {
-			if (expressionContainsRefCurrent(child.left, refSymbol, scopes)) writeCount++;
-			return;
+const isEmptySentinel = (node, scopes) => {
+	const expression = stripParenExpression(node);
+	return isNodeOfType(expression, "Literal") && expression.value === null || isNodeOfType(expression, "Identifier") && expression.name === "undefined" && scopes.isGlobalReference(expression);
+};
+const isInitializationInputIndependent = (node, renderOwner, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	let isInputIndependent = true;
+	walkAst(node, (child) => {
+		if (!isInputIndependent) return false;
+		if (resolveReactRefSymbol(child, scopes)) return false;
+		if (!isNodeOfType(child, "Identifier")) return;
+		const symbol = scopes.symbolFor(child);
+		if (!symbol) return;
+		if (symbol.kind === "import") return false;
+		if (symbol.kind === "let" || symbol.kind === "var" || symbol.kind === "using") {
+			isInputIndependent = false;
+			return false;
 		}
-		if (isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") {
-			if (expressionContainsRefCurrent(child.argument, refSymbol, scopes)) writeCount++;
-			return;
+		if (isOutsideAllFunctions(symbol)) return false;
+		if (symbol.kind === "parameter") {
+			if (symbol.scope.node === renderOwner) isInputIndependent = false;
+			return false;
 		}
-		if (isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement")) {
-			if (expressionContainsRefCurrent(child.left, refSymbol, scopes)) writeCount++;
+		if (!symbol.initializer || symbol.references.some((reference) => reference.flag !== "read")) {
+			isInputIndependent = false;
+			return false;
 		}
+		if (visitedSymbolIds.has(symbol.id)) return false;
+		visitedSymbolIds.add(symbol.id);
+		if (!isInitializationInputIndependent(symbol.initializer, renderOwner, scopes, visitedSymbolIds)) isInputIndependent = false;
+		return false;
 	});
-	return writeCount === 1 && expressionContainsRefCurrent(assignmentExpression.left, refSymbol, scopes);
+	return isInputIndependent;
 };
-const isEmptySentinel = (node, scopes) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined" && scopes.isGlobalReference(node);
+const isPredictableInitializationValue = (node, refSymbol, renderOwner, scopes, requiresClosedTruthyDomain) => isInitializationInputIndependent(node, renderOwner, scopes) && !containsNonDeterministicSource(node) && (isProvablyTruthyInitializationValue(node, scopes) && (!requiresClosedTruthyDomain || !refHasDeclaredType(refSymbol)) || refHasClosedFalsySentinelDomain(refSymbol, node, scopes));
 const hasRepeatedExecutionAncestor = (node, stop) => {
 	let ancestor = node.parent;
 	while (ancestor && ancestor !== stop) {
@@ -82423,6 +82507,27 @@ const canExecuteTogether = (firstConstraints, secondConstraints) => {
 	}
 	return true;
 };
+const hasNoCoExecutableCompetingWrite = (assignmentExpression, renderOwner, refSymbol, scopes) => {
+	const assignmentConstraints = getBranchConstraints(assignmentExpression, renderOwner);
+	const synchronouslyInvokedFunctions = collectSynchronouslyEffectInvokedFunctions(renderOwner, scopes);
+	let hasCompetingWrite = false;
+	walkAst(renderOwner, (child) => {
+		if (hasCompetingWrite) return false;
+		let writtenExpression = null;
+		if (isNodeOfType(child, "AssignmentExpression")) {
+			if (child === assignmentExpression) return;
+			writtenExpression = child.left;
+		} else if (isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") writtenExpression = child.argument;
+		else if (isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement")) writtenExpression = child.left;
+		const deferredExecutionBoundary = findDeferredExecutionBoundary(child);
+		const deferredWriteValue = isNodeOfType(child, "AssignmentExpression") && child.operator === "=" ? resolveImmutableInitializationValue(child.right, scopes) : null;
+		const isDeferredTruthyWrite = deferredExecutionBoundary !== null && deferredExecutionBoundary !== renderOwner && !synchronouslyInvokedFunctions.has(deferredExecutionBoundary) && !executesDuringRender(deferredExecutionBoundary, scopes) && deferredWriteValue !== null && !isNodeOfType(deferredWriteValue, "CallExpression") && isProvablyTruthyInitializationValue(deferredWriteValue, scopes);
+		if (!writtenExpression || isDeferredTruthyWrite || !expressionContainsRefCurrent(writtenExpression, refSymbol, scopes) || !canExecuteTogether(assignmentConstraints, getBranchConstraints(child, renderOwner))) return;
+		hasCompetingWrite = true;
+		return false;
+	});
+	return !hasCompetingWrite;
+};
 const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol, scopes) => {
 	const assignmentConstraints = getBranchConstraints(assignmentExpression, branchRoot);
 	const assignmentStart = getRangeStart(assignmentExpression);
@@ -82438,16 +82543,17 @@ const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol
 	});
 	return !hasCoExecutableWrite;
 };
+const isPredictableGuardedInitialization = (assignmentExpression, guardedBranch, renderOwner, refSymbol, scopes, requiresClosedTruthyDomain) => refHasEmptySentinelInitializer(refSymbol, scopes) && isPredictableInitializationValue(assignmentExpression.right, refSymbol, renderOwner, scopes, requiresClosedTruthyDomain) && !hasRepeatedExecutionAncestor(assignmentExpression, guardedBranch) && (guardedBranch === renderOwner || !hasRepeatedExecutionAncestor(guardedBranch, renderOwner)) && hasNoPriorCoExecutableWrite(assignmentExpression, renderOwner, refSymbol, scopes) && hasNoCoExecutableCompetingWrite(assignmentExpression, renderOwner, refSymbol, scopes) && refDoesNotEscape(renderOwner, refSymbol, scopes);
 const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
-	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return true;
-	if (assignmentExpression.operator !== "=") return false;
 	const renderOwner = findRenderPhaseComponentOrHook(assignmentExpression, scopes);
 	if (!renderOwner) return false;
+	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return isPredictableGuardedInitialization(assignmentExpression, renderOwner, renderOwner, refSymbol, scopes, assignmentExpression.operator === "||=");
+	if (assignmentExpression.operator !== "=") return false;
 	let descendant = assignmentExpression;
 	let ancestor = descendant.parent;
 	while (ancestor) {
 		const test = isNodeOfType(ancestor, "IfStatement") ? stripParenExpression(ancestor.test) : null;
-		if (isNodeOfType(ancestor, "IfStatement") && test && isNodeOfType(test, "UnaryExpression") && test.operator === "!" && isSameRefCurrentAlias(test.argument, refSymbol, scopes) && ancestor.consequent === descendant && isProvablyTruthyInitializationValue(assignmentExpression.right, scopes) && refHasClosedFalsySentinelDomain(refSymbol, assignmentExpression.right, scopes) && !hasRepeatedExecutionAncestor(assignmentExpression, ancestor.consequent) && !hasRepeatedExecutionAncestor(ancestor, renderOwner) && hasNoPriorCoExecutableWrite(assignmentExpression, ancestor.consequent, refSymbol, scopes) && hasNoCompetingRefCurrentWrite(renderOwner, assignmentExpression, refSymbol, scopes) && refDoesNotEscape(renderOwner, refSymbol, scopes)) return true;
+		if (isNodeOfType(ancestor, "IfStatement") && test && isNodeOfType(test, "UnaryExpression") && test.operator === "!" && isSameRefCurrentAlias(test.argument, refSymbol, scopes) && ancestor.consequent === descendant && isPredictableGuardedInitialization(assignmentExpression, ancestor.consequent, renderOwner, refSymbol, scopes, true)) return true;
 		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(test, "BinaryExpression") && [
 			"===",
 			"==",
@@ -82457,7 +82563,7 @@ const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes)
 			const { left, right } = test;
 			const comparesEmptySentinel = isSameRefCurrentAlias(left, refSymbol, scopes) && isEmptySentinel(right, scopes) || isSameRefCurrentAlias(right, refSymbol, scopes) && isEmptySentinel(left, scopes);
 			const guardedBranch = test.operator === "===" || test.operator === "==" ? ancestor.consequent : ancestor.alternate;
-			if (comparesEmptySentinel && guardedBranch === descendant && guardedBranch && !hasRepeatedExecutionAncestor(assignmentExpression, guardedBranch) && hasNoPriorCoExecutableWrite(assignmentExpression, guardedBranch, refSymbol, scopes)) return true;
+			if (comparesEmptySentinel && guardedBranch === descendant && guardedBranch && isPredictableGuardedInitialization(assignmentExpression, guardedBranch, renderOwner, refSymbol, scopes, false)) return true;
 		}
 		descendant = ancestor;
 		ancestor = descendant.parent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.9.2-dev.16972ae",
+  "version": "0.9.2-dev.1f6e181",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",