oxlint-plugin-react-doctor 0.7.9-dev.d7d38d7 → 0.7.9-dev.d8a20e0

package/dist/index.js

@@ -19996,6 +19996,28 @@ const jsLengthCheckFirst = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/is-proven-global-namespace-reference.ts
+const isProvenGlobalObjectReference = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(strippedExpression, "Identifier")) return false;
+	if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
+	const symbol = scopes.symbolFor(strippedExpression);
+	if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isProvenGlobalObjectReference(symbol.initializer, scopes, visitedSymbolIds);
+};
+const isProvenGlobalNamespaceReference = (expression, namespaceName, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
+		if (strippedExpression.name === namespaceName && scopes.isGlobalReference(strippedExpression)) return true;
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
+		visitedSymbolIds.add(symbol.id);
+		return isProvenGlobalNamespaceReference(symbol.initializer, namespaceName, scopes, visitedSymbolIds);
+	}
+	return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isProvenGlobalObjectReference(strippedExpression.object, scopes);
+};
+//#endregion
 //#region src/plugin/rules/js-performance/js-min-max-loop.ts
 const builtinMutationByProgram = /* @__PURE__ */ new WeakMap();
 const RUNTIMELESS_SYMBOL_KINDS = new Set(["ts-interface", "ts-type-alias"]);
@@ -20052,26 +20074,6 @@ const isSafeFreshNumericArray = (arrayExpression) => {
 	}
 	return !(didFindPositiveZero && didFindNegativeZero);
 };
-const isGlobalObjectReference = (expression, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
-	const strippedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(strippedExpression, "Identifier")) return false;
-	if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
-	const symbol = scopes.symbolFor(strippedExpression);
-	if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
-	visitedSymbols.add(symbol.id);
-	return isGlobalObjectReference(symbol.initializer, scopes, visitedSymbols);
-};
-const resolvesToGlobalNamespace = (expression, namespaceName, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
-	const strippedExpression = stripParenExpression(expression);
-	if (isNodeOfType(strippedExpression, "Identifier")) {
-		if (strippedExpression.name === namespaceName && scopes.isGlobalReference(strippedExpression)) return true;
-		const symbol = scopes.symbolFor(strippedExpression);
-		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
-		visitedSymbols.add(symbol.id);
-		return resolvesToGlobalNamespace(symbol.initializer, namespaceName, scopes, visitedSymbols);
-	}
-	return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isGlobalObjectReference(strippedExpression.object, scopes);
-};
 const resolvesToGlobalMethod = (expression, namespaceName, methodNames, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
 	const strippedExpression = stripParenExpression(expression);
 	if (isNodeOfType(strippedExpression, "Identifier")) {
@@ -20080,7 +20082,7 @@ const resolvesToGlobalMethod = (expression, namespaceName, methodNames, scopes,
 		visitedSymbols.add(symbol.id);
 		return resolvesToGlobalMethod(symbol.initializer, namespaceName, methodNames, scopes, visitedSymbols);
 	}
-	return isNodeOfType(strippedExpression, "MemberExpression") && methodNames.has(getStaticPropertyName(strippedExpression) ?? "") && resolvesToGlobalNamespace(strippedExpression.object, namespaceName, scopes);
+	return isNodeOfType(strippedExpression, "MemberExpression") && methodNames.has(getStaticPropertyName(strippedExpression) ?? "") && isProvenGlobalNamespaceReference(strippedExpression.object, namespaceName, scopes);
 };
 const resolvesToNativeArrayPrototype = (expression, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
 	const strippedExpression = stripParenExpression(expression);
@@ -20092,7 +20094,7 @@ const resolvesToNativeArrayPrototype = (expression, scopes, visitedSymbols = /*
 	}
 	if (isNodeOfType(strippedExpression, "MemberExpression")) {
 		const propertyName = getStaticPropertyName(strippedExpression);
-		if (propertyName === "prototype") return resolvesToGlobalNamespace(strippedExpression.object, "Array", scopes);
+		if (propertyName === "prototype") return isProvenGlobalNamespaceReference(strippedExpression.object, "Array", scopes);
 		return propertyName === "__proto__" && isNodeOfType(stripParenExpression(strippedExpression.object), "ArrayExpression");
 	}
 	if (!isNodeOfType(strippedExpression, "CallExpression")) return false;
@@ -20103,23 +20105,23 @@ const resolvesToNativeArrayPrototype = (expression, scopes, visitedSymbols = /*
 const isGlobalNamespaceReplacementTarget = (target, namespaceName, scopes) => {
 	const strippedTarget = stripParenExpression(target);
 	if (isNodeOfType(strippedTarget, "Identifier")) return strippedTarget.name === namespaceName && scopes.isGlobalReference(strippedTarget);
-	return isNodeOfType(strippedTarget, "MemberExpression") && getStaticPropertyName(strippedTarget) === namespaceName && isGlobalObjectReference(strippedTarget.object, scopes);
+	return isNodeOfType(strippedTarget, "MemberExpression") && getStaticPropertyName(strippedTarget) === namespaceName && isProvenGlobalObjectReference(strippedTarget.object, scopes);
 };
 const isUnsafeBuiltinMemberTarget = (target, targetFunction, scopes) => {
 	const strippedTarget = stripParenExpression(target);
 	if (!isNodeOfType(strippedTarget, "MemberExpression")) return false;
 	const propertyName = getStaticPropertyName(strippedTarget);
 	if (resolvesToNativeArrayPrototype(strippedTarget.object, scopes)) return propertyName === null || propertyName === "sort";
-	if (resolvesToGlobalNamespace(strippedTarget.object, "Math", scopes)) return propertyName === null || propertyName === targetFunction;
-	return isGlobalObjectReference(strippedTarget.object, scopes) && (propertyName === null || propertyName === "Math");
+	if (isProvenGlobalNamespaceReference(strippedTarget.object, "Math", scopes)) return propertyName === null || propertyName === targetFunction;
+	return isProvenGlobalObjectReference(strippedTarget.object, scopes) && (propertyName === null || propertyName === "Math");
 };
 const isUnsafeBuiltinMutationApiCall = (callExpression, targetFunction, scopes) => {
 	const target = callExpression.arguments[0];
 	if (!target) return false;
 	let propertyName = null;
 	if (resolvesToNativeArrayPrototype(target, scopes)) propertyName = "sort";
-	else if (resolvesToGlobalNamespace(target, "Math", scopes)) propertyName = targetFunction;
-	else if (isGlobalObjectReference(target, scopes)) propertyName = "Math";
+	else if (isProvenGlobalNamespaceReference(target, "Math", scopes)) propertyName = targetFunction;
+	else if (isProvenGlobalObjectReference(target, scopes)) propertyName = "Math";
 	if (!propertyName) return false;
 	const canObjectExpressionSetProperty = (properties) => {
 		if (!isNodeOfType(properties, "ObjectExpression")) return true;
@@ -20170,7 +20172,7 @@ const hasUnsafeMathBinding = (node, scopes) => {
 	let scope = scopes.scopeFor(node);
 	while (scope) {
 		const symbol = scope.symbolsByName.get("Math");
-		if (symbol && !RUNTIMELESS_SYMBOL_KINDS.has(symbol.kind)) return !(symbol.kind === "const" && symbol.initializer && resolvesToGlobalNamespace(symbol.initializer, "Math", scopes));
+		if (symbol && !RUNTIMELESS_SYMBOL_KINDS.has(symbol.kind)) return !(symbol.kind === "const" && symbol.initializer && isProvenGlobalNamespaceReference(symbol.initializer, "Math", scopes));
 		scope = scope.parent;
 	}
 	return false;
@@ -44369,11 +44371,110 @@ const isSameRefCurrentMember = (node, refSymbol, scopes) => {
 	return isNodeOfType(receiver, "Identifier") && resolveConstIdentifierAlias(receiver, scopes)?.id === refSymbol.id;
 };
 const isSameRefCurrentAlias = (node, refSymbol, scopes) => {
-	if (isSameRefCurrentMember(node, refSymbol, scopes)) return true;
-	if (!isNodeOfType(node, "Identifier")) return false;
-	const aliasSymbol = scopes.symbolFor(node);
+	const expression = stripParenExpression(node);
+	if (isSameRefCurrentMember(expression, refSymbol, scopes)) return true;
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const aliasSymbol = scopes.symbolFor(expression);
 	return aliasSymbol?.kind === "const" && aliasSymbol.initializer !== null && isSameRefCurrentMember(stripParenExpression(aliasSymbol.initializer), refSymbol, scopes);
 };
+const resolveImmutableInitializationValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (!isNodeOfType(expression, "Identifier")) return expression;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer || symbol.references.some((reference) => reference.flag !== "read") || visitedSymbolIds.has(symbol.id)) return null;
+	visitedSymbolIds.add(symbol.id);
+	return resolveImmutableInitializationValue(symbol.initializer, 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")));
+};
+const getInitializationConstructorName = (node, scopes) => {
+	const expression = resolveImmutableInitializationValue(node, scopes);
+	if (!expression) return null;
+	if (isNodeOfType(expression, "NewExpression")) {
+		const callee = stripParenExpression(expression.callee);
+		return isNodeOfType(callee, "Identifier") ? callee.name : null;
+	}
+	return null;
+};
+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, "TSTypeReference")) return false;
+	const typeName = typeNode.typeName;
+	return isNodeOfType(typeName, "Identifier") && typeName.name === getInitializationConstructorName(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;
+	const [declaredType] = initializer.typeArguments?.params ?? [];
+	if (!declaredType || !isNodeOfType(declaredType, "TSUnionType")) return false;
+	let hasEmptySentinel = false;
+	let hasTruthyDomain = false;
+	for (const memberType of declaredType.types ?? []) {
+		if (isNodeOfType(memberType, "TSNullKeyword") || isNodeOfType(memberType, "TSUndefinedKeyword")) {
+			hasEmptySentinel = true;
+			continue;
+		}
+		if (!isClosedTruthyTypeDomain(memberType, initializationValue, scopes)) return false;
+		hasTruthyDomain = true;
+	}
+	return hasEmptySentinel && hasTruthyDomain;
+};
+const isSafeRefIdentifierUse = (identifier) => {
+	const expressionRoot = findTransparentExpressionRoot(identifier);
+	const parent = expressionRoot.parent;
+	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.id === expressionRoot && parent.parent !== null && isNodeOfType(parent.parent, "VariableDeclaration") && parent.parent.kind === "const") return true;
+	if (parent && isNodeOfType(parent, "MemberExpression") && parent.object === expressionRoot && getStaticPropertyName(parent) === "current") return true;
+	if (!parent || !isNodeOfType(parent, "VariableDeclarator") || parent.init !== expressionRoot) return false;
+	return isNodeOfType(parent.id, "Identifier") && parent.parent !== null && isNodeOfType(parent.parent, "VariableDeclaration") && parent.parent.kind === "const";
+};
+const refDoesNotEscape = (branchRoot, refSymbol, scopes) => {
+	let didEscape = false;
+	walkAst(branchRoot, (child) => {
+		if (didEscape) return false;
+		if (!isNodeOfType(child, "Identifier")) return;
+		if (resolveConstIdentifierAlias(child, scopes)?.id !== refSymbol.id) return;
+		if (child === refSymbol.bindingIdentifier || isSafeRefIdentifierUse(child)) return;
+		didEscape = true;
+		return false;
+	});
+	return !didEscape;
+};
+const expressionContainsRefCurrent = (expression, refSymbol, scopes) => {
+	let didFindRefCurrent = false;
+	walkAst(expression, (child) => {
+		if (didFindRefCurrent) return false;
+		if (resolveReactRefSymbol(child, scopes)?.id !== refSymbol.id) return;
+		didFindRefCurrent = true;
+		return false;
+	});
+	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;
+		}
+		if (isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") {
+			if (expressionContainsRefCurrent(child.argument, refSymbol, scopes)) writeCount++;
+			return;
+		}
+		if (isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement")) {
+			if (expressionContainsRefCurrent(child.left, refSymbol, scopes)) writeCount++;
+		}
+	});
+	return writeCount === 1 && expressionContainsRefCurrent(assignmentExpression.left, refSymbol, scopes);
+};
 const isEmptySentinel = (node, scopes) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined" && scopes.isGlobalReference(node);
 const hasRepeatedExecutionAncestor = (node, stop) => {
 	let ancestor = node.parent;
@@ -44422,18 +44523,22 @@ const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol
 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;
 	let descendant = assignmentExpression;
 	let ancestor = descendant.parent;
 	while (ancestor) {
-		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(ancestor.test, "BinaryExpression") && [
+		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") && isNodeOfType(test, "BinaryExpression") && [
 			"===",
 			"==",
 			"!==",
 			"!="
-		].includes(ancestor.test.operator)) {
-			const { left, right } = ancestor.test;
+		].includes(test.operator)) {
+			const { left, right } = test;
 			const comparesEmptySentinel = isSameRefCurrentAlias(left, refSymbol, scopes) && isEmptySentinel(right, scopes) || isSameRefCurrentAlias(right, refSymbol, scopes) && isEmptySentinel(left, scopes);
-			const guardedBranch = ancestor.test.operator === "===" || ancestor.test.operator === "==" ? ancestor.consequent : ancestor.alternate;
+			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;
 		}
 		descendant = ancestor;
@@ -51558,6 +51663,31 @@ const preferModuleScopePureFunction = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-require-call-source.ts
+const getRequireCallSource = (expression) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return getRequireCallSource(unwrappedExpression.object);
+	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return null;
+	if (!isNodeOfType(unwrappedExpression.callee, "Identifier") || unwrappedExpression.callee.name !== "require") return null;
+	const [firstArgument] = unwrappedExpression.arguments ?? [];
+	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
+	return typeof firstArgument.value === "string" ? firstArgument.value : null;
+};
+//#endregion
+//#region src/plugin/utils/is-proven-node-crypto-namespace-reference.ts
+const NODE_CRYPTO_MODULE_SOURCES = new Set(["crypto", "node:crypto"]);
+const isProvenNodeCryptoNamespaceReference = (expression, scopes) => {
+	const identifier = stripParenExpression(expression);
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const symbol = resolveConstIdentifierAlias(identifier, scopes);
+	if (!symbol) return false;
+	if (symbol.kind === "import") {
+		const importBinding = getImportBindingForName(identifier, symbol.name);
+		return Boolean(importBinding && NODE_CRYPTO_MODULE_SOURCES.has(importBinding.source));
+	}
+	return Boolean(symbol.kind === "const" && symbol.initializer && NODE_CRYPTO_MODULE_SOURCES.has(getRequireCallSource(symbol.initializer) ?? ""));
+};
+//#endregion
 //#region src/plugin/rules/architecture/prefer-module-scope-static-value.ts
 const MUTATING_RECEIVER_METHOD_NAMES = new Set([...MUTATING_ARRAY_METHODS, ...MUTATING_COLLECTION_METHODS]);
 const isMutationContext = (referenceIdentifier) => {
@@ -51671,9 +51801,9 @@ const isImpureCall = (node, scopes) => {
 	const callee = node.callee;
 	if (isNodeOfType(callee, "Identifier")) return isImpureBareCallee(callee, scopes);
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return false;
-	if (!isNodeOfType(callee.object, "Identifier")) return false;
 	if (!isNodeOfType(callee.property, "Identifier")) return false;
-	return Boolean(IMPURE_MEMBER_RECEIVERS.get(callee.object.name)?.has(callee.property.name));
+	for (const [receiverName, receiverMethodNames] of IMPURE_MEMBER_RECEIVERS) if (receiverMethodNames.has(callee.property.name) && (isProvenGlobalNamespaceReference(callee.object, receiverName, scopes) || receiverName === "crypto" && isProvenNodeCryptoNamespaceReference(callee.object, scopes))) return true;
+	return false;
 };
 const containsImpureExpression = (expression, scopes) => {
 	let foundImpure = false;
@@ -56442,16 +56572,6 @@ const rnListCallbackPerRow = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/get-require-call-source.ts
-const getRequireCallSource = (expression) => {
-	if (isNodeOfType(expression, "MemberExpression")) return getRequireCallSource(expression.object);
-	if (!isNodeOfType(expression, "CallExpression")) return null;
-	if (!isNodeOfType(expression.callee, "Identifier") || expression.callee.name !== "require") return null;
-	const [firstArgument] = expression.arguments ?? [];
-	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
-	return typeof firstArgument.value === "string" ? firstArgument.value : null;
-};
-//#endregion
 //#region src/plugin/utils/get-initializer-module-source.ts
 const getInitializerModuleSource = (contextNode, initializer) => {
 	const requireSource = getRequireCallSource(initializer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.9-dev.d7d38d7",
+  "version": "0.7.9-dev.d8a20e0",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",