refactor: replace some _ placeholder with null or void

Rel1cx · Rel1cx · commit 5b9f8673263d · 2025-04-09T20:07:35.000+08:00
diff --git a/packages/core/src/utils/is-initialized-from-react.ts b/packages/core/src/utils/is-initialized-from-react.ts
@@ -1,7 +1,7 @@
 import type { Scope } from "@typescript-eslint/scope-manager";
 import type { TSESTree } from "@typescript-eslint/types";
 import * as AST from "@eslint-react/ast";
-import { _, identity } from "@eslint-react/eff";
+import { identity } from "@eslint-react/eff";
 import * as VAR from "@eslint-react/var";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 import { match, P } from "ts-pattern";
@@ -12,12 +12,12 @@ import { match, P } from "ts-pattern";
  * @returns The require expression arguments or undefined if the node is not a require expression
  */
 function getRequireExpressionArguments(node: TSESTree.Node) {
-  return match<typeof node, TSESTree.CallExpressionArgument[] | _>(node)
+  return match<typeof node, TSESTree.CallExpressionArgument[] | null>(node)
     // require("source")
     .with({ type: T.CallExpression, arguments: P.select(), callee: { type: T.Identifier, name: "require" } }, identity)
     // require("source").variable
     .with({ type: T.MemberExpression, object: P.select() }, getRequireExpressionArguments)
-    .otherwise(() => _);
+    .otherwise(() => null);
 }
 
 /**
diff --git a/packages/plugins/eslint-plugin-react-hooks-extra/src/hooks/use-no-direct-set-state-in-use-effect.ts b/packages/plugins/eslint-plugin-react-hooks-extra/src/hooks/use-no-direct-set-state-in-use-effect.ts
@@ -3,7 +3,7 @@ import type { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
 import type { Scope } from "@typescript-eslint/utils/ts-eslint";
 import * as AST from "@eslint-react/ast";
 import * as ER from "@eslint-react/core";
-import { _, getOrUpdate } from "@eslint-react/eff";
+import { constVoid, getOrUpdate } from "@eslint-react/eff";
 import { getSettingsFromContext } from "@eslint-react/shared";
 import * as VAR from "@eslint-react/var";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
@@ -143,7 +143,7 @@ export function useNoDirectSetStateInUseEffect<Ctx extends RuleContext>(
           if (pEntry.node !== setupFunction) return;
           indFunctionCalls.push(node);
         })
-        .otherwise(() => _);
+        .otherwise(constVoid);
     },
     Identifier(node) {
       if (node.parent.type === T.CallExpression && node.parent.callee === node) {
diff --git a/packages/plugins/eslint-plugin-react-hooks-extra/src/rules/no-unnecessary-use-callback.ts b/packages/plugins/eslint-plugin-react-hooks-extra/src/rules/no-unnecessary-use-callback.ts
@@ -86,11 +86,11 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
           const variable = VAR.findVariable(n.name, initialScope);
           const variableNode = VAR.getVariableInitNode(variable, 0);
           if (variableNode?.type !== T.ArrowFunctionExpression && variableNode?.type !== T.FunctionExpression) {
-            return _;
+            return null;
           }
           return variableNode;
         })
-        .otherwise(() => _);
+        .otherwise(() => null);
       if (arg0Node == null) return;
 
       const arg0NodeScope = context.sourceCode.getScope(arg0Node);
diff --git a/packages/plugins/eslint-plugin-react-hooks-extra/src/rules/no-unnecessary-use-memo.ts b/packages/plugins/eslint-plugin-react-hooks-extra/src/rules/no-unnecessary-use-memo.ts
@@ -3,7 +3,7 @@ import type { RuleListener } from "@typescript-eslint/utils/ts-eslint";
 import type { CamelCase } from "string-ts";
 import * as AST from "@eslint-react/ast";
 import * as ER from "@eslint-react/core";
-import { _, identity } from "@eslint-react/eff";
+import { identity } from "@eslint-react/eff";
 import { getSettingsFromContext } from "@eslint-react/shared";
 import * as VAR from "@eslint-react/var";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
@@ -91,11 +91,11 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
           const variable = VAR.findVariable(n.name, initialScope);
           const variableNode = VAR.getVariableInitNode(variable, 0);
           if (variableNode?.type !== T.ArrowFunctionExpression && variableNode?.type !== T.FunctionExpression) {
-            return _;
+            return null;
           }
           return variableNode;
         })
-        .otherwise(() => _);
+        .otherwise(() => null);
       if (arg0Node == null) return;
 
       const arg0NodeScope = context.sourceCode.getScope(arg0Node);
diff --git a/packages/plugins/eslint-plugin-react-naming-convention/src/rules/context-name.ts b/packages/plugins/eslint-plugin-react-naming-convention/src/rules/context-name.ts
@@ -39,7 +39,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
       const name = match(id)
         .with({ type: T.Identifier, name: P.select() }, identity)
         .with({ type: T.MemberExpression, property: { name: P.select(P.string) } }, identity)
-        .otherwise(() => _);
+        .otherwise(() => null);
       if (name != null && ER.isComponentName(name) && name.endsWith("Context")) return;
       context.report({
         messageId: "invalid",
diff --git a/packages/plugins/eslint-plugin-react-naming-convention/src/rules/use-state.ts b/packages/plugins/eslint-plugin-react-naming-convention/src/rules/use-state.ts
@@ -2,7 +2,6 @@ import type { RuleContext, RuleFeature } from "@eslint-react/kit";
 import type { TSESTree } from "@typescript-eslint/types";
 import type { RuleListener } from "@typescript-eslint/utils/ts-eslint";
 import * as ER from "@eslint-react/core";
-import { _ } from "@eslint-react/eff";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 import { snakeCase } from "string-ts";
 import { match } from "ts-pattern";
@@ -54,7 +53,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
       }
       const setterName = match(setter)
         .with({ type: T.Identifier }, (id) => id.name)
-        .otherwise(() => _);
+        .otherwise(() => null);
       if (setterName == null || !setterName.startsWith("set")) {
         context.report({ messageId: "invalidSetterNaming", node });
         return;
@@ -70,7 +69,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
           }, []);
           return values.join("_");
         })
-        .otherwise(() => _);
+        .otherwise(() => null);
       if (valueName == null || `set_${valueName}` !== snakeCase(setterName)) {
         context.report({ messageId: "invalidSetterNaming", node });
         return;
diff --git a/packages/plugins/eslint-plugin-react-web-api/src/rules/no-leaked-event-listener.ts b/packages/plugins/eslint-plugin-react-web-api/src/rules/no-leaked-event-listener.ts
@@ -277,7 +277,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
         .with("abort", () => {
           abortedSignals.push(node.callee);
         })
-        .otherwise(() => _);
+        .otherwise(() => null);
     },
     ["Program:exit"]() {
       for (const aEntry of aEntries) {
diff --git a/packages/plugins/eslint-plugin-react-web-api/src/rules/no-leaked-resize-observer.ts b/packages/plugins/eslint-plugin-react-web-api/src/rules/no-leaked-resize-observer.ts
@@ -1,10 +1,11 @@
+import type { _ } from "@eslint-react/eff";
 import type { RuleContext, RuleFeature } from "@eslint-react/kit";
 import type { TSESTree } from "@typescript-eslint/utils";
 import type { RuleListener } from "@typescript-eslint/utils/ts-eslint";
 import type { ObserverEntry, ObserverMethod } from "../types";
 import * as AST from "@eslint-react/ast";
 import * as ER from "@eslint-react/core";
-import { _, or } from "@eslint-react/eff";
+import { or } from "@eslint-react/eff";
 import * as VAR from "@eslint-react/var";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/utils";
 
@@ -176,7 +177,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
             phase: fKind,
           });
         })
-        .otherwise(() => _);
+        .otherwise(() => null);
     },
     ["NewExpression"](node) {
       const fEntry = fEntries.findLast((x) => x.kind !== "other");
diff --git a/packages/plugins/eslint-plugin-react-web-api/src/utils/get-phase-kind-of-function.ts b/packages/plugins/eslint-plugin-react-web-api/src/utils/get-phase-kind-of-function.ts
@@ -1,13 +1,12 @@
 import type * as AST from "@eslint-react/ast";
 import * as ER from "@eslint-react/core";
-import { _ } from "@eslint-react/eff";
 import { match } from "ts-pattern";
 
 export function getPhaseKindOfFunction(node: AST.TSESTreeFunction) {
-  return match<AST.TSESTreeFunction, ER.ComponentPhaseKind | _>(node)
+  return match<AST.TSESTreeFunction, ER.ComponentPhaseKind | null>(node)
     .when(ER.isFunctionOfUseEffectSetup, () => "setup")
     .when(ER.isFunctionOfUseEffectCleanup, () => "cleanup")
     .when(ER.isFunctionOfComponentDidMount, () => "mount")
     .when(ER.isFunctionOfComponentWillUnmount, () => "unmount")
-    .otherwise(() => _);
+    .otherwise(() => null);
 }
diff --git a/packages/plugins/eslint-plugin-react-x/src/rules/avoid-shorthand-boolean.ts b/packages/plugins/eslint-plugin-react-x/src/rules/avoid-shorthand-boolean.ts
@@ -33,8 +33,7 @@ export default createRule<[], MessageID>({
 export function create(context: RuleContext<MessageID, []>): RuleListener {
   return {
     JSXAttribute(node) {
-      // eslint-disable-next-line local/prefer-eqeq-nullish-comparison
-      if (node.value === null) {
+      if (node.value == null) {
         context.report({
           messageId: "avoidShorthandBoolean",
           node,
diff --git a/packages/plugins/eslint-plugin-react-x/src/rules/jsx-no-undef.ts b/packages/plugins/eslint-plugin-react-x/src/rules/jsx-no-undef.ts
@@ -1,7 +1,6 @@
 import type { RuleContext, RuleFeature } from "@eslint-react/kit";
 import type { RuleListener } from "@typescript-eslint/utils/ts-eslint";
 import type { CamelCase } from "string-ts";
-import { _ } from "@eslint-react/eff";
 
 import * as VAR from "@eslint-react/var";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
@@ -37,7 +36,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
       const name = match(node.name)
         .with({ type: T.JSXIdentifier }, (n) => n.name)
         .with({ type: T.JSXMemberExpression, object: { type: T.JSXIdentifier } }, (n) => n.object.name)
-        .otherwise(() => _);
+        .otherwise(() => null);
       if (name == null) return;
       if (name === "this") return;
       // Skip JsxIntrinsicElements
diff --git a/packages/plugins/eslint-plugin-react-x/src/rules/no-array-index-key.ts b/packages/plugins/eslint-plugin-react-x/src/rules/no-array-index-key.ts
@@ -199,8 +199,9 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
         if (!("value" in prop)) {
           continue;
         }
-        getReportDescriptors(prop.value)
-          .forEach(report);
+        for (const descriptor of getReportDescriptors(prop.value)) {
+          report(descriptor);
+        }
       }
     },
     "CallExpression:exit"() {
@@ -216,8 +217,9 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
       if (node.value?.type !== T.JSXExpressionContainer) {
         return;
       }
-      getReportDescriptors(node.value.expression)
-        .forEach(report);
+      for (const descriptor of getReportDescriptors(node.value.expression)) {
+        report(descriptor);
+      }
     },
   };
 }
diff --git a/packages/plugins/eslint-plugin-react-x/src/rules/no-children-prop.ts b/packages/plugins/eslint-plugin-react-x/src/rules/no-children-prop.ts
@@ -31,15 +31,12 @@ export default createRule<[], MessageID>({
 export function create(context: RuleContext<MessageID, []>): RuleListener {
   return {
     JSXElement(node) {
-      const attribute = JSX.getAttribute(
-        "children",
-        node.openingElement.attributes,
-        context.sourceCode.getScope(node),
-      );
-      if (attribute != null) {
+      const attributes = node.openingElement.attributes;
+      const childrenProp = JSX.getAttribute("children", attributes, context.sourceCode.getScope(node));
+      if (childrenProp != null) {
         context.report({
           messageId: "noChildrenProp",
-          node: attribute,
+          node: childrenProp,
         });
       }
     },
diff --git a/packages/plugins/eslint-plugin-react-x/src/rules/no-clone-element.ts b/packages/plugins/eslint-plugin-react-x/src/rules/no-clone-element.ts
@@ -31,13 +31,12 @@ export default createRule<[], MessageID>({
 export function create(context: RuleContext<MessageID, []>): RuleListener {
   return {
     CallExpression(node) {
-      if (!ER.isCloneElementCall(context, node)) {
-        return;
+      if (ER.isCloneElementCall(context, node)) {
+        context.report({
+          messageId: "noCloneElement",
+          node,
+        });
       }
-      context.report({
-        messageId: "noCloneElement",
-        node,
-      });
     },
   };
 }
diff --git a/packages/plugins/eslint-plugin-react-x/src/rules/no-forward-ref.ts b/packages/plugins/eslint-plugin-react-x/src/rules/no-forward-ref.ts
@@ -4,7 +4,6 @@ import type { RuleFix, RuleFixer, RuleListener } from "@typescript-eslint/utils/
 import type { CamelCase } from "string-ts";
 import * as AST from "@eslint-react/ast";
 import * as ER from "@eslint-react/core";
-import { _ } from "@eslint-react/eff";
 import { getSettingsFromContext } from "@eslint-react/shared";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 import { compare } from "compare-versions";
@@ -96,12 +95,12 @@ function getComponentPropsFixes(
   const fixedArg0Text = match(arg0)
     .with({ type: T.Identifier }, (n) => `...${n.name}`)
     .with({ type: T.ObjectPattern }, (n) => n.properties.map(getText).join(", "))
-    .otherwise(() => _);
+    .otherwise(() => null);
   const fixedArg1Text = match(arg1)
     .with(P.nullish, () => "ref")
     .with({ type: T.Identifier, name: "ref" }, () => "ref")
     .with({ type: T.Identifier, name: P.string }, (n) => `ref: ${n.name}`)
-    .otherwise(() => _);
+    .otherwise(() => null);
   if (fixedArg0Text == null || fixedArg1Text == null) {
     return [];
   }
diff --git a/packages/plugins/eslint-plugin-react-x/src/rules/no-missing-key.ts b/packages/plugins/eslint-plugin-react-x/src/rules/no-missing-key.ts
@@ -4,8 +4,9 @@ import * as AST from "@eslint-react/ast";
 import * as ER from "@eslint-react/core";
 import * as JSX from "@eslint-react/jsx";
 import { createReport, type RuleContext, type RuleFeature } from "@eslint-react/kit";
-import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 
+import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
+import { match } from "ts-pattern";
 import { createRule } from "../utils";
 
 export const RULE_NAME = "no-missing-key";
@@ -112,22 +113,18 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
     },
     CallExpression(node) {
       state.isWithinChildrenToArray ||= ER.isChildrenToArrayCall(context, node);
-      if (state.isWithinChildrenToArray) {
-        return;
-      }
-      const isMapCall = AST.isArrayMapCall(node);
-      if (!isMapCall && !AST.isArrayFromCall(node)) {
-        return;
-      }
-      const fn = node.arguments[isMapCall ? 0 : 1];
-      if (!AST.isFunction(fn)) {
-        return;
-      }
-      if (fn.body.type === T.BlockStatement) {
-        checkBlockStatement(fn.body).forEach(report);
+      if (state.isWithinChildrenToArray) return;
+      const callback = match(node)
+        .when(AST.isArrayMapCall, (n) => n.arguments[0])
+        .when(AST.isArrayFromCall, (n) => n.arguments[1])
+        .otherwise(() => null);
+      if (!AST.isFunction(callback)) return;
+      const body = callback.body;
+      if (body.type === T.BlockStatement) {
+        checkBlockStatement(body).forEach(report);
         return;
       }
-      report(checkExpression(fn.body));
+      report(checkExpression(body));
     },
     "CallExpression:exit"(node) {
       if (!ER.isChildrenToArrayCall(context, node)) {
diff --git a/packages/utilities/eff/src/index.ts b/packages/utilities/eff/src/index.ts
@@ -65,6 +65,13 @@ export function constant<T>(x: T) {
  */
 export function constVoid() {}
 
+/**
+ * Do nothing and return null
+ */
+export function constNull() {
+  return null;
+}
+
 /**
  * Do nothing and return true
  */
