refactor: replace construction detection with object type detection and remove unused code (#1292)

Signed-off-by: REL1CX <[email protected]>
Co-authored-by: Copilot <[email protected]>

Author: Rel1cx

packages/plugins/eslint-plugin-react-x/src/rules/no-unstable-context-value.ts

@@ -3,7 +3,7 @@ import { getJsxElementType, isReactHookCall, useComponentCollector } from "@esli
 import { getOrElseUpdate } from "@eslint-react/eff";
 import type { RuleContext, RuleFeature } from "@eslint-react/shared";
 import { getSettingsFromContext } from "@eslint-react/shared";
-import { type Construction, getConstruction } from "@eslint-react/var";
+import { type ObjectType, getObjectType } from "@eslint-react/var";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 import type { RuleListener } from "@typescript-eslint/utils/ts-eslint";
 import { compare } from "compare-versions";
@@ -39,7 +39,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
   const { version } = getSettingsFromContext(context);
   const isReact18OrBelow = compare(version, "19.0.0", "<");
   const { ctx, listeners } = useComponentCollector(context);
-  const constructions = new WeakMap<AST.TSESTreeFunction, Construction[]>();
+  const constructions = new WeakMap<AST.TSESTreeFunction, ObjectType[]>();
 
   return {
     ...listeners,
@@ -61,7 +61,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
       if (value?.type !== T.JSXExpressionContainer) return;
       const valueExpression = value.expression;
       const initialScope = context.sourceCode.getScope(valueExpression);
-      const construction = getConstruction(valueExpression, initialScope);
+      const construction = getObjectType(valueExpression, initialScope);
       if (construction == null) return;
       if (isReactHookCall(construction.node)) {
         return;
@@ -73,7 +73,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
       for (const { node: component } of components) {
         for (const construction of constructions.get(component) ?? []) {
           const { kind, node: constructionNode } = construction;
-          const suggestion = kind.startsWith("Function")
+          const suggestion = kind === "function"
             ? "Consider wrapping it in a useCallback hook."
             : "Consider wrapping it in a useMemo hook.";
           context.report({

packages/plugins/eslint-plugin-react-x/src/rules/no-unstable-default-props.ts

@@ -2,7 +2,7 @@ import * as AST from "@eslint-react/ast";
 import { isReactHookCall, useComponentCollector } from "@eslint-react/core";
 import { getOrElseUpdate } from "@eslint-react/eff";
 import { type RuleContext, type RuleFeature } from "@eslint-react/shared";
-import { ConstructionDetectionHint, getConstruction } from "@eslint-react/var";
+import { getObjectType } from "@eslint-react/var";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 import type { RuleListener } from "@typescript-eslint/utils/ts-eslint";
 import type { CamelCase } from "string-ts";
@@ -72,10 +72,9 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
           const { value } = prop;
           const { right } = value;
           const initialScope = context.sourceCode.getScope(value);
-          const construction = getConstruction(
+          const construction = getObjectType(
             value,
             initialScope,
-            ConstructionDetectionHint.StrictCallExpression,
           );
           if (construction == null) {
             continue;

packages/utilities/var/src/construction-detection.ts

@@ -0,0 +1,127 @@
+import { unit } 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 { getVariableDefinitionNode } from "./get-variable-definition-node";
+
+export type ObjectType =
+  | {
+    kind: "jsx";
+    node:
+      | TSESTree.JSXElement
+      | TSESTree.JSXFragment;
+  }
+  | {
+    kind: "array";
+    node: TSESTree.ArrayExpression;
+  }
+  | {
+    kind: "plain";
+    node: TSESTree.ObjectExpression;
+  }
+  | {
+    kind: "class";
+    node: TSESTree.ClassExpression;
+  }
+  | {
+    kind: "instance";
+    node:
+      | TSESTree.NewExpression
+      | TSESTree.ThisExpression;
+  }
+  | {
+    kind: "function";
+    node:
+      | TSESTree.FunctionDeclaration
+      | TSESTree.FunctionExpression
+      | TSESTree.ArrowFunctionExpression;
+  }
+  | {
+    kind: "regexp";
+    node: TSESTree.RegExpLiteral;
+  }
+  | {
+    kind: "unknown";
+    node: TSESTree.Node;
+    // Reason for why the type is unknown
+    reason: "call-expression" | "unsupported-node";
+  };
+
+/**
+ * Detects the ObjectType of a given node
+ * @param node The node to check
+ * @param initialScope  The initial scope to check for variable declarations
+ * @returns The ObjectType of the node, or undefined if not detected
+ */
+export function getObjectType(
+  node: TSESTree.Node | unit,
+  initialScope: Scope,
+): ObjectType | unit {
+  if (node == null) return unit;
+  switch (node.type) {
+    case T.JSXElement:
+    case T.JSXFragment:
+      return { kind: "jsx", node } as const;
+    case T.ArrayExpression:
+      return { kind: "array", node } as const;
+    case T.ObjectExpression:
+      return { kind: "plain", node } as const;
+    case T.ClassExpression:
+      return { kind: "class", node } as const;
+    case T.NewExpression:
+    case T.ThisExpression:
+      return { kind: "instance", node } as const;
+    case T.FunctionDeclaration:
+    case T.FunctionExpression:
+    case T.ArrowFunctionExpression:
+      return { kind: "function", node } as const;
+    case T.Literal: {
+      if ("regex" in node) {
+        return { kind: "regexp", node } as const;
+      }
+      return unit;
+    }
+    case T.Identifier: {
+      if (!("name" in node) || typeof node.name !== "string") {
+        return unit;
+      }
+      const variable = initialScope.set.get(node.name);
+      const variableNode = getVariableDefinitionNode(variable, -1);
+      return getObjectType(variableNode, initialScope);
+    }
+    case T.MemberExpression: {
+      if (!("object" in node)) return unit;
+      return getObjectType(node.object, initialScope);
+    }
+    case T.AssignmentExpression:
+    case T.AssignmentPattern: {
+      if (!("right" in node)) return unit;
+      return getObjectType(node.right, initialScope);
+    }
+    case T.LogicalExpression: {
+      return getObjectType(node.right, initialScope);
+    }
+    case T.ConditionalExpression: {
+      return getObjectType(node.consequent, initialScope) ?? getObjectType(node.alternate, initialScope);
+    }
+    case T.SequenceExpression: {
+      if (node.expressions.length === 0) {
+        return unit;
+      }
+      return getObjectType(
+        node.expressions[node.expressions.length - 1],
+        initialScope,
+      );
+    }
+    case T.CallExpression: {
+      return { kind: "unknown", node, reason: "call-expression" } as const;
+    }
+    default: {
+      if (!("expression" in node) || typeof node.expression !== "object") {
+        return unit;
+      }
+      return getObjectType(node.expression, initialScope);
+    }
+  }
+}

packages/utilities/var/src/get-object-type.ts

@@ -1,7 +1,7 @@
-export * from "./construction-detection";
 export * from "./find-assignment-target";
 export * from "./find-property";
 export * from "./get-child-scopes";
+export * from "./get-object-type";
 export * from "./get-variable-definition-node";
 export * from "./get-variables-from-scope";
 export * from "./is-node-value-equal";