oxlint-plugin-react-doctor 0.7.7-dev.e632f8a → 0.7.7-dev.ed241c3

package/dist/index.js

@@ -4573,23 +4573,6 @@ const hasPossibleStaticPropertyWrite = (identifier, propertyName, scopes) => {
 		return writtenPropertyName === null || writtenPropertyName === propertyName;
 	}));
 };
-const canExecuteBefore = (candidateNode, referenceNode, scopes) => {
-	const candidateBoundary = findExecutionBoundary(candidateNode);
-	const referenceBoundary = findExecutionBoundary(referenceNode);
-	if (!candidateBoundary || !referenceBoundary) return true;
-	if (candidateBoundary === referenceBoundary) return candidateNode.range[0] < referenceNode.range[0];
-	if (!isFunctionLike$1(candidateBoundary)) return true;
-	return isFunctionSynchronouslyInvokedBefore(candidateBoundary, referenceNode, scopes);
-};
-const hasPossibleStaticPropertyWriteBefore = (identifier, propertyName, referenceNode, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	return getPotentiallyAliasedSymbols(identifier, scopes).some((symbol) => symbol.references.some((reference) => {
-		const writeTarget = getMemberWriteTarget(reference.identifier);
-		if (!writeTarget || !canExecuteBefore(writeTarget, referenceNode, scopes)) return false;
-		const writtenPropertyName = getResolvedStaticPropertyName(writeTarget, scopes);
-		return writtenPropertyName === null || writtenPropertyName === propertyName;
-	}));
-};
 const hasPossibleStaticPropertyMutationOrEscape = (identifier, propertyName, scopes) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
 	if (hasPossibleStaticPropertyWrite(identifier, propertyName, scopes)) return true;
@@ -20164,14 +20147,14 @@ const isIndexOfResultUsedAsMembershipTest = (node) => {
 	if (isNegativeOneLiteral(otherOperand)) return true;
 	return isZeroLiteral(otherOperand) && (parent.operator === ">=" || parent.operator === "<");
 };
-const getTypeAnnotation$1 = (node) => {
+const getTypeAnnotation = (node) => {
 	if (!node || !("typeAnnotation" in node)) return null;
 	const annotation = node.typeAnnotation;
 	if (!annotation || !isNodeOfType(annotation, "TSTypeAnnotation")) return null;
 	return annotation.typeAnnotation;
 };
 const getDeclaredPropertyType = (members, propertyName) => {
-	for (const member of members) if (isNodeOfType(member, "TSPropertySignature") && isNodeOfType(member.key, "Identifier") && member.key.name === propertyName) return getTypeAnnotation$1(member);
+	for (const member of members) if (isNodeOfType(member, "TSPropertySignature") && isNodeOfType(member.key, "Identifier") && member.key.name === propertyName) return getTypeAnnotation(member);
 	return null;
 };
 const getArrayElementType = (typeNode) => {
@@ -20190,7 +20173,7 @@ const getDestructuredDeclaredType = (identifier) => {
 	const property = binding.bindingIdentifier.parent;
 	const objectPattern = property?.parent;
 	if (!isNodeOfType(property, "Property") || !isNodeOfType(property.key, "Identifier") || !isNodeOfType(objectPattern, "ObjectPattern")) return null;
-	const propsType = getTypeAnnotation$1(objectPattern);
+	const propsType = getTypeAnnotation(objectPattern);
 	if (!propsType) return null;
 	if (isNodeOfType(propsType, "TSTypeLiteral")) return getDeclaredPropertyType(propsType.members ?? [], property.key.name);
 	if (!isNodeOfType(propsType, "TSTypeReference") || !isNodeOfType(propsType.typeName, "Identifier")) return null;
@@ -20207,7 +20190,7 @@ const getIdentifierDeclaredType = (identifier, visitedBindingIdentifiers = /* @_
 	const binding = findVariableInitializer(identifier, identifier.name);
 	if (!binding || visitedBindingIdentifiers.has(binding.bindingIdentifier)) return null;
 	visitedBindingIdentifiers.add(binding.bindingIdentifier);
-	const directType = getTypeAnnotation$1(binding.bindingIdentifier);
+	const directType = getTypeAnnotation(binding.bindingIdentifier);
 	if (directType) return directType;
 	const initializer = binding.initializer;
 	if (isNodeOfType(initializer, "TSAsExpression") || isNodeOfType(initializer, "TSTypeAssertion") || isNodeOfType(initializer, "TSSatisfiesExpression")) return initializer.typeAnnotation;
@@ -27372,211 +27355,6 @@ const computeExternallyDriven = (analysis, declarator) => {
 	return hasDeferredCallSite;
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/effect/is-proven-native-read-method.ts
-const ARRAY_READ_METHOD_NAMES$1 = new Set([
-	"at",
-	"concat",
-	"entries",
-	"every",
-	"filter",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"flat",
-	"flatMap",
-	"forEach",
-	"includes",
-	"indexOf",
-	"join",
-	"keys",
-	"lastIndexOf",
-	"map",
-	"reduce",
-	"reduceRight",
-	"slice",
-	"some",
-	"toLocaleString",
-	"toReversed",
-	"toSorted",
-	"toSpliced",
-	"toString",
-	"values",
-	"with"
-]);
-const MAP_READ_METHOD_NAMES = new Set([
-	"entries",
-	"forEach",
-	"get",
-	"has",
-	"keys",
-	"values"
-]);
-const SET_READ_METHOD_NAMES = new Set([
-	"difference",
-	"entries",
-	"forEach",
-	"has",
-	"intersection",
-	"isDisjointFrom",
-	"isSubsetOf",
-	"isSupersetOf",
-	"keys",
-	"symmetricDifference",
-	"union",
-	"values"
-]);
-const FUNCTION_READ_METHOD_NAMES = new Set(["bind"]);
-const PROMISE_READ_METHOD_NAMES = new Set([
-	"catch",
-	"finally",
-	"then"
-]);
-const STRING_READ_METHOD_NAMES$1 = new Set([
-	"at",
-	"charAt",
-	"charCodeAt",
-	"codePointAt",
-	"concat",
-	"endsWith",
-	"includes",
-	"indexOf",
-	"isWellFormed",
-	"lastIndexOf",
-	"localeCompare",
-	"match",
-	"matchAll",
-	"normalize",
-	"padEnd",
-	"padStart",
-	"repeat",
-	"replace",
-	"replaceAll",
-	"search",
-	"slice",
-	"split",
-	"startsWith",
-	"substring",
-	"toLocaleLowerCase",
-	"toLocaleUpperCase",
-	"toLowerCase",
-	"toString",
-	"toUpperCase",
-	"toWellFormed",
-	"trim",
-	"trimEnd",
-	"trimStart",
-	"valueOf"
-]);
-const NATIVE_TYPE_NAMES = new Set([
-	"Array",
-	"Map",
-	"Promise",
-	"PromiseLike",
-	"ReadonlyArray",
-	"ReadonlyMap",
-	"ReadonlySet",
-	"Set"
-]);
-const nativeTypeDeclarationsByProgram = /* @__PURE__ */ new WeakMap();
-const shadowedNativeTypeNamesByBinding = /* @__PURE__ */ new WeakMap();
-const isWithinNode = (node, ancestor) => {
-	let current = node;
-	while (current) {
-		if (current === ancestor) return true;
-		current = current.parent;
-	}
-	return false;
-};
-const findTypeDeclarationScope = (declaration) => {
-	let current = declaration.parent;
-	while (current) {
-		if (isNodeOfType(current, "Program") || isNodeOfType(current, "BlockStatement") || isNodeOfType(current, "TSModuleBlock") || isNodeOfType(current, "StaticBlock")) return current;
-		current = current.parent;
-	}
-	return null;
-};
-const getDeclaredTypeName = (declaration) => {
-	if (!isNodeOfType(declaration, "ClassDeclaration") && !isNodeOfType(declaration, "TSEnumDeclaration") && !isNodeOfType(declaration, "TSImportEqualsDeclaration") && !isNodeOfType(declaration, "TSInterfaceDeclaration") && !isNodeOfType(declaration, "TSModuleDeclaration") && !isNodeOfType(declaration, "TSTypeAliasDeclaration")) return null;
-	return declaration.id && isNodeOfType(declaration.id, "Identifier") ? declaration.id.name : null;
-};
-const getNativeTypeDeclarations = (program) => {
-	const cachedDeclarations = nativeTypeDeclarationsByProgram.get(program);
-	if (cachedDeclarations) return cachedDeclarations;
-	const declarations = [];
-	walkAst(program, (candidate) => {
-		if (isNodeOfType(candidate, "ImportDeclaration")) {
-			for (const specifier of candidate.specifiers) if (NATIVE_TYPE_NAMES.has(specifier.local.name)) declarations.push({
-				name: specifier.local.name,
-				scope: program
-			});
-			return;
-		}
-		const declaredTypeName = getDeclaredTypeName(candidate);
-		if (!declaredTypeName || !NATIVE_TYPE_NAMES.has(declaredTypeName)) return;
-		const declarationScope = findTypeDeclarationScope(candidate);
-		if (declarationScope) declarations.push({
-			name: declaredTypeName,
-			scope: declarationScope
-		});
-	});
-	nativeTypeDeclarationsByProgram.set(program, declarations);
-	return declarations;
-};
-const getShadowedNativeTypeNames = (binding) => {
-	const cachedNames = shadowedNativeTypeNamesByBinding.get(binding);
-	if (cachedNames) return cachedNames;
-	const shadowedNames = /* @__PURE__ */ new Set();
-	for (const typeName of NATIVE_TYPE_NAMES) if (hasEnclosingTypeParameterNamed(binding, typeName)) shadowedNames.add(typeName);
-	const program = findProgramRoot(binding);
-	if (program) {
-		for (const declaration of getNativeTypeDeclarations(program)) if (isWithinNode(binding, declaration.scope)) shadowedNames.add(declaration.name);
-	}
-	shadowedNativeTypeNamesByBinding.set(binding, shadowedNames);
-	return shadowedNames;
-};
-const getParameterBinding = (definitionName) => {
-	if (isNodeOfType(definitionName, "Identifier")) return definitionName;
-	if (!isNodeOfType(definitionName, "AssignmentPattern")) return null;
-	return isNodeOfType(definitionName.left, "Identifier") ? definitionName.left : null;
-};
-const getTypeAnnotation = (binding) => {
-	if (!isNodeOfType(binding, "Identifier")) return null;
-	const annotation = binding.typeAnnotation;
-	return annotation && isNodeOfType(annotation, "TSTypeAnnotation") ? annotation.typeAnnotation : null;
-};
-const isNullishType = (typeNode) => isNodeOfType(typeNode, "TSNullKeyword") || isNodeOfType(typeNode, "TSUndefinedKeyword");
-const isNativeReadMethod = (typeNode, methodName, shadowedTypeNames) => {
-	if (isNodeOfType(typeNode, "TSArrayType") || isNodeOfType(typeNode, "TSTupleType")) return ARRAY_READ_METHOD_NAMES$1.has(methodName);
-	if (isNodeOfType(typeNode, "TSStringKeyword")) return STRING_READ_METHOD_NAMES$1.has(methodName);
-	if (isNodeOfType(typeNode, "TSFunctionType")) return FUNCTION_READ_METHOD_NAMES.has(methodName);
-	if (isNodeOfType(typeNode, "TSLiteralType") && isNodeOfType(typeNode.literal, "Literal") && typeof typeNode.literal.value === "string") return STRING_READ_METHOD_NAMES$1.has(methodName);
-	if (isNodeOfType(typeNode, "TSTypeOperator") && typeNode.operator === "readonly" && typeNode.typeAnnotation) return isNativeReadMethod(typeNode.typeAnnotation, methodName, shadowedTypeNames);
-	if (isNodeOfType(typeNode, "TSUnionType")) {
-		let hasNonNullishMember = false;
-		for (const memberType of typeNode.types) {
-			if (isNullishType(memberType)) continue;
-			hasNonNullishMember = true;
-			if (!isNativeReadMethod(memberType, methodName, shadowedTypeNames)) return false;
-		}
-		return hasNonNullishMember;
-	}
-	if (!isNodeOfType(typeNode, "TSTypeReference") || !isNodeOfType(typeNode.typeName, "Identifier")) return false;
-	if (shadowedTypeNames.has(typeNode.typeName.name)) return false;
-	if (typeNode.typeName.name === "Array" || typeNode.typeName.name === "ReadonlyArray") return ARRAY_READ_METHOD_NAMES$1.has(methodName);
-	if (typeNode.typeName.name === "Map" || typeNode.typeName.name === "ReadonlyMap") return MAP_READ_METHOD_NAMES.has(methodName);
-	if (typeNode.typeName.name === "Set" || typeNode.typeName.name === "ReadonlySet") return SET_READ_METHOD_NAMES.has(methodName);
-	if (typeNode.typeName.name === "Promise" || typeNode.typeName.name === "PromiseLike") return PROMISE_READ_METHOD_NAMES.has(methodName);
-	return false;
-};
-const isProvenNativeReadMethod = (ref, methodName) => Boolean(ref.resolved?.defs.some((definition) => {
-	if (definition.type !== "Parameter") return false;
-	const parameterBinding = getParameterBinding(definition.name);
-	if (!parameterBinding) return false;
-	const typeAnnotation = getTypeAnnotation(parameterBinding);
-	return Boolean(typeAnnotation && isNativeReadMethod(typeAnnotation, methodName, getShadowedNativeTypeNames(parameterBinding)));
-}));
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/react.ts
 const KNOWN_PURE_HOC_NAMES = new Set(["memo", "forwardRef"]);
 const startsWithUppercase = (name) => Boolean(name && name.length > 0 && name[0] >= "A" && name[0] <= "Z");
@@ -27803,132 +27581,7 @@ const isRefCurrent = (ref) => {
 const isStateSetterCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isStateSetter(analysis, innerRef));
 const isSyncStateSetterCall = (analysis, ref, effectFn) => isStateSetterCall(analysis, ref) && isSynchronous(ref.identifier, effectFn) && !resolvesToAsyncFunction(ref);
 const HANDLER_NAMED_METHOD_PATTERN = /^(on|handle)[A-Z]/;
-const SYNCHRONOUS_CALLBACK_ARGUMENT_INDEX_BY_METHOD = new Map([
-	["every", 0],
-	["filter", 0],
-	["find", 0],
-	["findIndex", 0],
-	["findLast", 0],
-	["findLastIndex", 0],
-	["flatMap", 0],
-	["forEach", 0],
-	["map", 0],
-	["reduce", 0],
-	["reduceRight", 0],
-	["replace", 1],
-	["replaceAll", 1],
-	["some", 0]
-]);
-const addSimpleBindingNames = (pattern, names) => {
-	if (isNodeOfType(pattern, "Identifier")) {
-		if (names.has(pattern.name)) return false;
-		names.add(pattern.name);
-		return true;
-	}
-	if (isNodeOfType(pattern, "AssignmentPattern")) return addSimpleBindingNames(pattern.left, names);
-	if (isNodeOfType(pattern, "RestElement")) return addSimpleBindingNames(pattern.argument, names);
-	if (isNodeOfType(pattern, "ObjectPattern")) {
-		let didAddName = false;
-		for (const property of pattern.properties) didAddName = addSimpleBindingNames(isNodeOfType(property, "Property") ? property.value : property, names) || didAddName;
-		return didAddName;
-	}
-	if (isNodeOfType(pattern, "ArrayPattern")) {
-		let didAddName = false;
-		for (const element of pattern.elements) if (element) didAddName = addSimpleBindingNames(element, names) || didAddName;
-		return didAddName;
-	}
-	return false;
-};
-const getSimpleParameterNames = (callback) => {
-	if (!isFunctionLike$1(callback)) return /* @__PURE__ */ new Set();
-	const names = /* @__PURE__ */ new Set();
-	for (const parameter of callback.params ?? []) addSimpleBindingNames(parameter, names);
-	return names;
-};
-const inlineCallbackInvokesParameter = (callback) => {
-	const parameterNames = getSimpleParameterNames(callback);
-	if (parameterNames.size === 0 || !isFunctionLike$1(callback)) return false;
-	let didAddAlias = true;
-	while (didAddAlias) {
-		didAddAlias = false;
-		walkAst(callback.body, (candidate) => {
-			if (candidate !== callback.body && isFunctionLike$1(candidate)) return false;
-			if (isNodeOfType(candidate, "AssignmentExpression") && candidate.operator === "=" && isNodeOfType(candidate.left, "Identifier")) {
-				const assignedValueRoot = getRootIdentifier$1(candidate.right);
-				if (isNodeOfType(assignedValueRoot, "Identifier") && parameterNames.has(assignedValueRoot.name) && !parameterNames.has(candidate.left.name)) {
-					parameterNames.add(candidate.left.name);
-					didAddAlias = true;
-				}
-				return;
-			}
-			if (!isNodeOfType(candidate, "VariableDeclarator") || !candidate.init) return;
-			const initializerRoot = getRootIdentifier$1(candidate.init);
-			if (!isNodeOfType(initializerRoot, "Identifier") || !parameterNames.has(initializerRoot.name)) return;
-			if (addSimpleBindingNames(candidate.id, parameterNames)) didAddAlias = true;
-		});
-	}
-	let didInvokeParameter = false;
-	walkAst(callback.body, (candidate) => {
-		if (didInvokeParameter) return false;
-		if (candidate !== callback.body && isFunctionLike$1(candidate)) return false;
-		if (!isNodeOfType(candidate, "CallExpression")) return;
-		const callee = stripParenExpression(candidate.callee);
-		if (isNodeOfType(callee, "Identifier") && parameterNames.has(callee.name)) {
-			didInvokeParameter = true;
-			return false;
-		}
-		if (isNodeOfType(callee, "MemberExpression")) {
-			const receiverRoot = getRootIdentifier$1(callee.object);
-			if (receiverRoot && parameterNames.has(receiverRoot.name)) {
-				didInvokeParameter = true;
-				return false;
-			}
-		}
-	});
-	return didInvokeParameter;
-};
-const callbackInvokesPropCallback = (analysis, callback) => {
-	if (!isFunctionLike$1(callback)) return false;
-	let didInvokePropCallback = false;
-	walkAst(callback.body, (candidate) => {
-		if (didInvokePropCallback) return false;
-		if (candidate !== callback.body && isFunctionLike$1(candidate)) return false;
-		if (!isNodeOfType(candidate, "CallExpression")) return;
-		if (getDownstreamRefs(analysis, stripParenExpression(candidate.callee)).some((reference) => isPropCallbackInvocationRef(analysis, reference))) {
-			didInvokePropCallback = true;
-			return false;
-		}
-	});
-	return didInvokePropCallback;
-};
-const isNativeMethodSuppressionSafe = (analysis, callExpression, methodName, scopes) => {
-	if (!isNodeOfType(callExpression, "CallExpression")) return false;
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const receiver = stripParenExpression(callee.object);
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	const receiverSymbol = scopes.symbolFor(receiver);
-	if (!receiverSymbol || hasSymbolWriteBefore(receiverSymbol, callExpression, scopes) || hasPossibleStaticPropertyWriteBefore(receiver, methodName, callExpression, scopes)) return false;
-	let callResult = callExpression;
-	let callResultConsumer = callResult.parent;
-	while (callResultConsumer && (TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(callResultConsumer.type) && "expression" in callResultConsumer && callResultConsumer.expression === callResult || isNodeOfType(callResultConsumer, "MemberExpression") && callResultConsumer.object === callResult)) {
-		callResult = callResultConsumer;
-		callResultConsumer = callResult.parent;
-	}
-	if (isNodeOfType(callResultConsumer, "CallExpression") && callResultConsumer.callee === callResult) return false;
-	const callbackArgumentIndex = SYNCHRONOUS_CALLBACK_ARGUMENT_INDEX_BY_METHOD.get(methodName);
-	if (callbackArgumentIndex === void 0) return true;
-	const callbackArgument = callExpression.arguments?.[callbackArgumentIndex];
-	if (!callbackArgument) return true;
-	const callbackValue = stripParenExpression(callbackArgument);
-	if (isFunctionLike$1(callbackValue)) return !inlineCallbackInvokesParameter(callbackValue) && !callbackInvokesPropCallback(analysis, callbackValue);
-	if (!isNodeOfType(callbackValue, "Identifier")) return false;
-	const callbackRef = getRef(analysis, callbackValue);
-	if (!callbackRef || isPropAlias(analysis, callbackRef)) return false;
-	const callbackFunction = resolveToFunction(callbackRef);
-	return Boolean(callbackFunction && isFunctionLike$1(callbackFunction) && !inlineCallbackInvokesParameter(callbackFunction) && !callbackInvokesPropCallback(analysis, callbackFunction));
-};
-const isPropCallbackInvocationRef = (analysis, ref, options = {}) => {
+const isPropCallbackInvocationRef = (analysis, ref) => {
 	if (!isPropAlias(analysis, ref)) return false;
 	let effectiveNode = ref.identifier;
 	let parent = effectiveNode.parent;
@@ -27941,9 +27594,7 @@ const isPropCallbackInvocationRef = (analysis, ref, options = {}) => {
 	if (isNodeOfType(parent, "MemberExpression") && parent.object === effectiveNode) {
 		const memberParent = parent.parent;
 		if (isNodeOfType(memberParent, "CallExpression") && memberParent.callee === parent) {
-			const propertyName = getStaticPropertyName(parent);
-			if (propertyName && HANDLER_NAMED_METHOD_PATTERN.test(propertyName)) return true;
-			if (options.nativeMethodScopes && isCustomHookParameter(ref) && propertyName && isProvenNativeReadMethod(ref, propertyName) && isNativeMethodSuppressionSafe(analysis, memberParent, propertyName, options.nativeMethodScopes)) return false;
+			if (!parent.computed && isNodeOfType(parent.property, "Identifier") && HANDLER_NAMED_METHOD_PATTERN.test(parent.property.name)) return true;
 			return isWholePropsObjectReference(analysis, ref);
 		}
 	}
@@ -41414,7 +41065,7 @@ const noPropCallbackInRender = defineRule({
 		if (!analysis) return;
 		const callee = stripParenExpression(node.callee);
 		if (isFunctionLike$1(callee)) return;
-		if (!getDownstreamRefs(analysis, callee).some((reference) => isPropCallbackInvocationRef(analysis, reference, { nativeMethodScopes: context.scopes }))) 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."

package/package.json

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