refactor: replace isMatching with direct type checks for improved performance

Author: Rel1cx

packages/core/src/render-prop/hierarchy.ts

@@ -2,7 +2,6 @@ import * as AST from "@eslint-react/ast";
 import { F, O } from "@eslint-react/eff";
 import type { TSESTree } from "@typescript-eslint/types";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
-import { isMatching, P } from "ts-pattern";
 
 /**
  * Unsafe check whether given node is declared directly inside a render property
@@ -17,15 +16,12 @@ import { isMatching, P } from "ts-pattern";
  * @returns `true` if component is declared inside a render property, `false` if not
  */
 export function isDirectValueOfRenderPropertyLoose(node: TSESTree.Node) {
-  const matching = isMatching({
-    key: {
-      type: T.Identifier,
-      name: P.string.startsWith("render"),
-    },
-    type: T.Property,
-  });
-
-  return matching(node) || matching(node.parent);
+  const matching = (node: TSESTree.Node) => {
+    return node.type === T.Property
+      && node.key.type === T.Identifier
+      && node.key.name.startsWith("render");
+  };
+  return matching(node) || (node.parent != null && matching(node.parent));
 }
 
 /**
@@ -49,9 +45,9 @@ export function isDeclaredInRenderPropLoose(node: TSESTree.Node) {
     O.flatMapNullable(c => c.parent),
     O.filter(AST.is(T.JSXAttribute)),
     O.flatMapNullable(a => a.name),
-    O.exists(isMatching({
-      type: T.JSXIdentifier,
-      name: P.string.startsWith("render"),
-    })),
+    O.exists(n =>
+      n.type === T.JSXIdentifier
+      && n.name.startsWith("render")
+    ),
   );
 }

packages/plugins/eslint-plugin-react-hooks-extra/src/utils/is-set-function-call.ts

@@ -4,7 +4,6 @@ import type { RuleContext } from "@eslint-react/types";
 import * as VAR from "@eslint-react/var";
 import type { TSESTree } from "@typescript-eslint/types";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
-import { isMatching } from "ts-pattern";
 
 import { isFromUseStateCall } from "./is-from-use-state-call";
 
@@ -22,13 +21,7 @@ export function isSetFunctionCall(context: RuleContext, settings: ESLintReactSet
         if (!("name" in callee.object)) {
           return false;
         }
-        const isAt = isMatching({
-          type: T.MemberExpression,
-          property: {
-            type: T.Identifier,
-            name: "at",
-          },
-        }, callee);
+        const isAt = callee.property.type === T.Identifier && callee.property.name === "at";
         const [index] = node.callee.arguments;
         if (!isAt || index == null) {
           return false;

packages/plugins/eslint-plugin-react-x/src/rules/no-leaked-conditional-rendering.ts

@@ -243,12 +243,12 @@ export default createRule<[], MessageID>({
       return match<typeof node, O.Option<ReportDescriptor<MessageID>>>(node)
         .when(AST.isJSX, O.none)
         .with({ type: T.LogicalExpression, operator: "&&" }, ({ left, right }) => {
-          const isLeftUnaryNot = isMatching({ type: T.UnaryExpression, operator: "!" }, left);
+          const isLeftUnaryNot = left.type === T.UnaryExpression && left.operator === "!";
           if (isLeftUnaryNot) {
             return getReportDescriptor(right);
           }
           const initialScope = context.sourceCode.getScope(left);
-          const isLeftNan = isMatching({ type: T.Identifier, name: "NaN" }, left)
+          const isLeftNan = (left.type === T.Identifier && left.name === "NaN")
             || O.exists(VAR.getStaticValue(left, initialScope), v => v === "NaN");
           if (isLeftNan) {
             return O.some({
@@ -283,7 +283,7 @@ export default createRule<[], MessageID>({
         })
         .otherwise(O.none);
     }
-    const visitorFunction = F.flow(getReportDescriptor, O.map(context.report), F.constVoid);
+    const visitorFunction = F.flow(getReportDescriptor, O.map(context.report));
     return {
       "JSXExpressionContainer > ConditionalExpression": visitorFunction,
       "JSXExpressionContainer > LogicalExpression": visitorFunction,

packages/plugins/eslint-plugin-react-x/src/rules/prefer-destructuring-assignment.ts

@@ -6,7 +6,6 @@ import type { Scope } from "@typescript-eslint/scope-manager";
 import type { TSESTree } from "@typescript-eslint/types";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 import type { CamelCase } from "string-ts";
-import { isMatching } from "ts-pattern";
 
 import { createRule } from "../utils";
 
@@ -85,7 +84,10 @@ export default createRule<[], MessageID>({
             continue;
           }
           const [props, ctx] = component.params;
-          const isMatch = isMatching({ name: memberExpression.object.name });
+          const isMatch = (node: null | TSESTree.Node | undefined) =>
+            node != null
+            && node.type === T.Identifier
+            && node.name === memberExpression.object.name;
           if (isMatch(props)) {
             context.report({
               messageId: "preferDestructuringAssignment",

packages/utilities/var/src/is-initialized-from-source.ts

@@ -3,7 +3,6 @@ import { F, O } from "@eslint-react/eff";
 import type { Scope } from "@typescript-eslint/scope-manager";
 import type { TSESTree } from "@typescript-eslint/types";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
-import { isMatching } from "ts-pattern";
 
 import { findVariable } from "./find-variable";
 
@@ -44,7 +43,7 @@ export function isInitializedFromSource(
     );
   }
   // latest definition is an import declaration: import { variable } from 'source'
-  return isMatching({ type: "ImportDeclaration", source: { value: source } }, parent);
+  return parent?.type === T.ImportDeclaration && parent.source.value === source;
 }
 
 function getRequireExpressionArguments(node: TSESTree.Node): O.Option<TSESTree.CallExpressionArgument[]> {