oxlint-plugin-react-doctor 0.8.3-dev.01820bb → 0.8.3-dev.416fdcc

package/dist/index.js

@@ -8262,6 +8262,56 @@ const isNodeReachableWithinFunction = (node, context) => {
 	return false;
 };
 //#endregion
+//#region src/plugin/utils/is-proven-non-throwing-built-in-call.ts
+const NON_THROWING_CONSOLE_METHOD_NAMES = new Set([
+	"debug",
+	"error",
+	"info",
+	"log",
+	"trace",
+	"warn"
+]);
+const NON_THROWING_NUMBER_BINARY_OPERATORS = new Set([
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"**"
+]);
+const isGlobalPerformanceNowCall = (callNode, scopes) => {
+	const callee = stripParenExpression(callNode.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || callNode.arguments.length !== 0) return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && receiver.name === "performance" && scopes.isGlobalReference(receiver) && getStaticPropertyName(callee) === "now";
+};
+const isProvenNonThrowingNumberExpression = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Literal")) return typeof strippedExpression.value === "number";
+	if (isNodeOfType(strippedExpression, "CallExpression")) return isGlobalPerformanceNowCall(strippedExpression, scopes);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (symbol?.kind !== "const" || !symbol.initializer || symbol.declarationNode.range[0] >= strippedExpression.range[0] || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return false;
+		visitedSymbolIds.add(symbol.id);
+		return isProvenNonThrowingNumberExpression(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (isNodeOfType(strippedExpression, "UnaryExpression")) return (strippedExpression.operator === "+" || strippedExpression.operator === "-") && isProvenNonThrowingNumberExpression(strippedExpression.argument, scopes, visitedSymbolIds);
+	if (!isNodeOfType(strippedExpression, "BinaryExpression")) return false;
+	if (!NON_THROWING_NUMBER_BINARY_OPERATORS.has(strippedExpression.operator)) return false;
+	return isProvenNonThrowingNumberExpression(strippedExpression.left, scopes, new Set(visitedSymbolIds)) && isProvenNonThrowingNumberExpression(strippedExpression.right, scopes, new Set(visitedSymbolIds));
+};
+const isProvenNonThrowingBuiltInCall = (callNode, scopes) => {
+	if (isGlobalPerformanceNowCall(callNode, scopes)) return true;
+	const callee = stripParenExpression(callNode.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const receiver = stripParenExpression(callee.object);
+	if (!isNodeOfType(receiver, "Identifier") || !scopes.isGlobalReference(receiver)) return false;
+	const methodName = getStaticPropertyName(callee);
+	if (receiver.name === "console") return NON_THROWING_CONSOLE_METHOD_NAMES.has(methodName ?? "");
+	const firstArgument = callNode.arguments[0];
+	return Boolean(receiver.name === "Math" && methodName === "round" && callNode.arguments.length === 1 && firstArgument && isProvenNonThrowingNumberExpression(firstArgument, scopes));
+};
+//#endregion
 //#region src/plugin/utils/serialize-reference-key.ts
 const serializeReferenceKey = ({ node, scopes }) => {
 	const expression = stripParenExpression(node);
@@ -9039,11 +9089,10 @@ const functionHasPotentialSynchronousThrow = (functionNode, classBody, scopes, b
 		}
 		if (!isNodeOfType(candidate, "CallExpression")) return;
 		if (cleanupReleaseKeys(candidate, scopes, classBody).length > 0) return;
+		if (isProvenNonThrowingBuiltInCall(candidate, scopes)) return;
 		const callee = stripParenExpression(candidate.callee);
 		if (isNodeOfType(callee, "MemberExpression")) {
-			const receiver = stripParenExpression(callee.object);
-			if (isNodeOfType(receiver, "Identifier") && receiver.name === "console" && scopes.isGlobalReference(receiver)) return;
-			if (isNodeOfType(receiver, "ThisExpression")) {
+			if (isNodeOfType(stripParenExpression(callee.object), "ThisExpression")) {
 				const memberName = getStaticPropertyName(callee);
 				const memberFunction = memberName ? classMemberFunction(classBody, memberName, candidate) : null;
 				if (memberFunction && !functionHasPotentialSynchronousThrow(memberFunction, classBody, scopes, Number.POSITIVE_INFINITY, new Set(visitedFunctions))) return;
@@ -18015,7 +18064,7 @@ const hasPotentialInterruptionAfterGuard = (callback, guardState, usageNode, con
 		if (child !== callback.body && isFunctionLike$1(child)) return false;
 		const childStart = getRangeStart(child);
 		if (childStart === null || childStart <= guardStart || childStart >= usageStart) return;
-		if (isNodeOfType(child, "CallExpression") || isNodeOfType(child, "AwaitExpression") || isNodeOfType(child, "YieldExpression")) {
+		if (isNodeOfType(child, "AwaitExpression") || isNodeOfType(child, "YieldExpression") || isNodeOfType(child, "CallExpression") && !isProvenNonThrowingBuiltInCall(child, context.scopes)) {
 			if (canNodeReachLaterNodeWithinFunction(child, usageNode, callback, context) || canInterruptionReachUsageThroughCatch(child, usageNode, callback, context)) {
 				hasPotentialInterruption = true;
 				return false;
@@ -18181,7 +18230,7 @@ const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) =>
 	for (const argument of usage.node.arguments ?? []) walkAst(argument, (argumentChild) => {
 		if (hasPotentialInterruption) return false;
 		if (isFunctionLike$1(argumentChild)) return false;
-		if (isNodeOfType(argumentChild, "CallExpression") || isNodeOfType(argumentChild, "AwaitExpression") || isNodeOfType(argumentChild, "YieldExpression")) {
+		if (isNodeOfType(argumentChild, "AwaitExpression") || isNodeOfType(argumentChild, "YieldExpression") || isNodeOfType(argumentChild, "CallExpression") && !isProvenNonThrowingBuiltInCall(argumentChild, context.scopes)) {
 			hasPotentialInterruption = true;
 			return false;
 		}
@@ -63409,10 +63458,9 @@ const chainCarriesRejectionHandler = (node, scopes) => {
 			}
 			if (isNodeOfType(child, "CallExpression")) {
 				const callee = stripParenExpression(child.callee);
-				const receiver = isNodeOfType(callee, "MemberExpression") ? stripParenExpression(callee.object) : null;
-				const isConsoleCall = isNodeOfType(receiver, "Identifier") && receiver.name === "console" && (!scopes || scopes.isGlobalReference(receiver));
+				const isKnownNonThrowingBuiltInCall = Boolean(scopes && isProvenNonThrowingBuiltInCall(child, scopes));
 				const localFunction = scopes && isNodeOfType(callee, "Identifier") ? resolveExactLocalFunction(callee, scopes) : null;
-				if (!isConsoleCall && !isPromiseResolveCall(child, scopes) && !chainCarriesRejectionHandler(child, scopes) && (!localFunction || !scopes || subtreeCanThrowSynchronously(localFunction, localFunction, scopes))) {
+				if (!isKnownNonThrowingBuiltInCall && !isPromiseResolveCall(child, scopes) && !chainCarriesRejectionHandler(child, scopes) && (!localFunction || !scopes || subtreeCanThrowSynchronously(localFunction, localFunction, scopes))) {
 					canReject = true;
 					return false;
 				}
@@ -63889,6 +63937,7 @@ const helperHasUnhandledSynchronousCall = (helper, depth, scopes, visitedFunctio
 			ancestor = ancestor.parent ?? null;
 		}
 		if (isInsideNonRethrowingTry(child, helper)) return;
+		if (scopes && isProvenNonThrowingBuiltInCall(child, scopes)) return;
 		if (isPromiseResolveCall(child, scopes) || chainCarriesRejectionHandler(child, scopes) || isSyncArrayLiteralMethodCall(child, scopes) || isThunkActionDispatchCall(child) || isNeverRejectingPromiseCombinatorCall(child, depth, scopes)) return;
 		const callee = stripParenExpression(child.callee);
 		if (scopes && isNodeOfType(callee, "Identifier") && isReactHookResultReference(callee, STATE_HOOK_NAMES, 1, scopes)) return;
@@ -63898,7 +63947,6 @@ const helperHasUnhandledSynchronousCall = (helper, depth, scopes, visitedFunctio
 		}
 		if (isNodeOfType(callee, "MemberExpression")) {
 			const receiver = stripParenExpression(callee.object);
-			if (isNodeOfType(receiver, "Identifier") && receiver.name === "console" && (!scopes || scopes.isGlobalReference(receiver))) return;
 			if (getStaticPropertyName(callee) === "push" && isNodeOfType(receiver, "Identifier")) {
 				const receiverSymbol = scopes?.symbolFor(receiver);
 				if (isNodeOfType(receiverSymbol?.initializer ? stripParenExpression(receiverSymbol.initializer) : null, "ArrayExpression") && receiverSymbol?.references.every((reference) => {
@@ -64368,16 +64416,20 @@ const areOnExclusiveBranches = (first, second, functionNode) => {
 };
 const REACT_SETTER_CALLEE_PATTERN = /^set[A-Z]/;
 const isProvenNonThrowingSynchronousCall = (callNode, context) => {
+	if (isProvenNonThrowingBuiltInCall(callNode, context.scopes)) return true;
 	const callee = stripParenExpression(callNode.callee);
 	if (isNodeOfType(callee, "Identifier")) {
 		if (isReactHookResultReference(callee, STATE_HOOK_NAMES, 1, context.scopes) || context.scopes.isGlobalReference(callee) && REACT_SETTER_CALLEE_PATTERN.test(callee.name)) return true;
+		if (context.scopes.isGlobalReference(callee) && callee.name === "String") {
+			const firstArgument = callNode.arguments[0];
+			const strippedArgument = firstArgument ? stripParenExpression(firstArgument) : null;
+			return Boolean(callNode.arguments.length === 1 && strippedArgument && isNodeOfType(strippedArgument, "Identifier") && context.scopes.symbolFor(strippedArgument)?.kind === "catch-clause-parameter");
+		}
 		const localFunction = resolveExactLocalFunction(callee, context.scopes);
 		if (localFunction && isFunctionLike$1(localFunction) && !localFunction.async) return !subtreeCanThrowSynchronously(localFunction, localFunction, context.scopes) && !helperHasUnhandledSynchronousCall(localFunction, NEVER_REJECTING_ANALYSIS_MAX_DEPTH, context.scopes);
 		return false;
 	}
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const receiver = stripParenExpression(callee.object);
-	return Boolean(isNodeOfType(receiver, "Identifier") && receiver.name === "console" && context.scopes.isGlobalReference(receiver));
+	return false;
 };
 const subtreeHasAbruptSynchronousOperation = (root, functionBoundary, context) => {
 	let canCompleteAbruptly = false;
@@ -73606,14 +73658,6 @@ const REJECTING_PROMISE_COMBINATOR_NAMES = new Set([
 const MAX_INITIATOR_RESOLUTION_DEPTH = 3;
 const STATE_DISPATCHER_HOOK_NAMES = new Set(["useState", "useReducer"]);
 const REF_HOOK_NAMES = new Set(["useRef"]);
-const NON_REJECTING_CONSOLE_METHOD_NAMES = new Set([
-	"debug",
-	"error",
-	"info",
-	"log",
-	"trace",
-	"warn"
-]);
 const MESSAGE$26 = "This promise chain runs in an effect, ends in a `.then` that sets state or mutates a ref, and has no `.catch` or enclosing try/catch, so a rejection leaves the state unset and surfaces as an unhandled rejection. Add a `.catch` handler on the chain (`.finally` does not count).";
 const isKnownNonThenableHandlerReturn = (expression, context, visitedBindingIdentifiers = /* @__PURE__ */ new Set()) => {
 	const strippedExpression = stripParenExpression(expression);
@@ -73650,6 +73694,10 @@ const isKnownNonRejectingHandler = (argument, context) => {
 			return false;
 		}
 		if (!isNodeOfType(child, "CallExpression")) return;
+		if (isProvenNonThrowingBuiltInCall(child, context.scopes)) {
+			didFindKnownNonRejectingCall = true;
+			return;
+		}
 		const callee = stripParenExpression(child.callee);
 		if (isNodeOfType(callee, "Identifier") && isReactHookResultReference(callee, STATE_DISPATCHER_HOOK_NAMES, 1, context.scopes)) {
 			if (context.scopes.symbolFor(callee)?.references.every((reference) => reference.flag === "read")) {
@@ -73657,13 +73705,6 @@ const isKnownNonRejectingHandler = (argument, context) => {
 				return;
 			}
 		}
-		if (isNodeOfType(callee, "MemberExpression")) {
-			const receiver = stripParenExpression(callee.object);
-			if (isNodeOfType(receiver, "Identifier") && receiver.name === "console" && context.scopes.isGlobalReference(receiver) && NON_REJECTING_CONSOLE_METHOD_NAMES.has(getStaticPropertyName(callee) ?? "")) {
-				didFindKnownNonRejectingCall = true;
-				return;
-			}
-		}
 		canReject = true;
 		return false;
 	});
@@ -73672,11 +73713,10 @@ const isKnownNonRejectingHandler = (argument, context) => {
 const isTrustedNonThrowingMethodCallee = (member, context) => {
 	const parent = member.parent;
 	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== member) return false;
+	if (isProvenNonThrowingBuiltInCall(parent, context.scopes)) return true;
 	const receiver = stripParenExpression(member.object);
 	if (!isNodeOfType(receiver, "Identifier") || !context.scopes.isGlobalReference(receiver)) return false;
-	const methodName = getStaticPropertyName(member);
-	if (receiver.name === "console") return NON_REJECTING_CONSOLE_METHOD_NAMES.has(methodName ?? "");
-	return receiver.name === "Promise" && methodName === "resolve";
+	return receiver.name === "Promise" && getStaticPropertyName(member) === "resolve";
 };
 const handlerHasPotentiallyThrowingMemberRead = (argument, context) => {
 	if (!argument) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.8.3-dev.01820bb",
+  "version": "0.8.3-dev.416fdcc",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",