add useCallback rule features to useMemo

Author: possum-enjoyer

packages/plugins/eslint-plugin-react-x/src/rules/no-unnecessary-use-memo.spec.ts

@@ -96,6 +96,64 @@ ruleTester.run(RULE_NAME, rule, {
         },
       ],
     },
+
+    {
+      code: tsx`
+        import {useMemo, useState, useEffect} from 'react';
+
+        function veryHeavyCalculation(items) {
+          console.log(items)
+          return items
+        }
+  
+        function App({ items }) {
+          const [test, setTest] = useState(0);
+          const heavyStuff = useMemo(() => veryHeavyCalculation(items), [items]);
+
+          useEffect(() => {
+            setTest(heavyStuff.length)
+          }, [heavyStuff]);
+
+          return <div>items</div>;
+        }
+      `,
+      errors: [
+        {
+          messageId: "noUnnecessaryUseMemoInsideUseEffect",
+        },
+      ],
+      settings: {
+        "react-x": {
+          importSource: "react",
+        },
+      },
+    },
+    {
+      code: tsx`
+        const { useMemo, useState, useEffect } = require("@pika/react");
+
+        function App({ items }) {
+          const [test, setTest] = useState(0);
+          const heavyStuff = useMemo(() => veryHeavyCalculation(items), [items]);
+
+          useEffect(() => {
+            setTest(heavyStuff.length)
+          }, [heavyStuff]);
+
+          return <div>items</div>;
+        }
+      `,
+      errors: [
+        {
+          messageId: "noUnnecessaryUseMemoInsideUseEffect",
+        },
+      ],
+      settings: {
+        "react-x": {
+          importSource: "@pika/react",
+        },
+      },
+    },
   ],
   valid: [
     ...allValid,
@@ -240,5 +298,47 @@ ruleTester.run(RULE_NAME, rule, {
         return null;
       }
     `,
+
+    tsx`
+      import { useMemo, useState, useEffect } from 'react';
+
+      function App({ items }) {
+        const [test, setTest] = useState(0);
+        const heavyStuff = useMemo(() => veryHeavyCalculation(items), [items]);
+
+        useEffect(() => {
+          setTest(heavyStuff.length)
+        }, [heavyStuff]);
+
+        return <div>{heavyStuff.length}</div>;
+      }
+    `,
+    tsx`
+      import { useMemo, useState, useEffect } from 'react';
+
+      function App({ items }) {
+        const [test, setTest] = useState(0);
+        const heavyStuff = useMemo(() => veryHeavyCalculation(items), [items]);
+
+        useEffect(() => {
+          setTest(heavyStuff.length)
+        }, [heavyStuff]);
+
+        useEffect(() => {
+          console.log(heavyStuff)
+        }, [heavyStuff]);
+
+        return <div>{heavyStuff.length}</div>;
+      }
+    `,
+    tsx`
+      import { useMemo } from 'react';
+
+      function App({ items }) {
+        const heavyStuff = useMemo(() => veryHeavyCalculation(items), [items]);
+
+        return <div>{heavyStuff.length}</div>;
+      }
+    `,
   ],
 });

packages/plugins/eslint-plugin-react-x/src/rules/no-unnecessary-use-memo.ts

@@ -1,13 +1,14 @@
 import * as AST from "@eslint-react/ast";
-import { isUseMemoCall } from "@eslint-react/core";
+import { isUseEffectLikeCall, isUseMemoCall } from "@eslint-react/core";
 import { identity } from "@eslint-react/eff";
 import type { RuleContext, RuleFeature } from "@eslint-react/shared";
 import { findVariable, getChildScopes, getVariableDefinitionNode } from "@eslint-react/var";
-import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as T, type TSESTree } from "@typescript-eslint/types";
 import type { RuleListener } from "@typescript-eslint/utils/ts-eslint";
 import type { CamelCase } from "string-ts";
 import { match } from "ts-pattern";
 
+import { isIdentifier } from "@typescript-eslint/utils/ast-utils";
 import { createRule } from "../utils";
 
 export const RULE_NAME = "no-unnecessary-use-memo";
@@ -16,7 +17,7 @@ export const RULE_FEATURES = [
   "EXP",
 ] as const satisfies RuleFeature[];
 
-export type MessageID = CamelCase<typeof RULE_NAME>;
+export type MessageID = CamelCase<typeof RULE_NAME> | "noUnnecessaryUseMemoInsideUseEffect";
 
 export default createRule<[], MessageID>({
   meta: {
@@ -27,6 +28,7 @@ export default createRule<[], MessageID>({
     },
     messages: {
       noUnnecessaryUseMemo: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary.",
+      noUnnecessaryUseMemoInsideUseEffect: "{{name}} is only used inside 1 useEffect which may be unnecessary.",
     },
     schema: [],
   },
@@ -105,5 +107,40 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
         });
       }
     },
+    VariableDeclarator(node) {
+      if (!context.sourceCode.text.includes("useEffect")) {
+        return;
+      }
+
+      if (!isUseMemoCall(node.init ?? undefined)) {
+        return;
+      }
+
+      if (!isIdentifier(node.id)) {
+        return;
+      }
+
+      const references = context.sourceCode.getDeclaredVariables(node)[0]?.references ?? [];
+      const usages = references.filter((ref) => !(ref.init ?? false));
+      const effectSet = new Set<TSESTree.Node>();
+
+      for (const usage of usages) {
+        const effect = AST.findParentNode(usage.identifier, (node) => isUseEffectLikeCall(node));
+
+        if (effect == null) {
+          return;
+        }
+
+        effectSet.add(effect);
+        if (effectSet.size > 1) {
+          return;
+        }
+      }
+      context.report({
+        messageId: "noUnnecessaryUseMemoInsideUseEffect",
+        node,
+        data: { name: node.id.name },
+      });
+    },
   };
 }