refactor: rename value construction to construction detection and update related types

Author: Rel1cx

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

@@ -40,7 +40,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
   const { version } = getSettingsFromContext(context);
   const isReact18OrBelow = compare(version, "19.0.0", "<");
   const { ctx, listeners } = ER.useComponentCollector(context);
-  const constructions = new Map<AST.TSESTreeFunction, VAR.ValueConstruction[]>();
+  const constructions = new Map<AST.TSESTreeFunction, VAR.Construction[]>();
 
   return {
     ...listeners,
@@ -62,7 +62,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 = VAR.getValueConstruction(valueExpression, initialScope);
+      const construction = VAR.getConstructionDetectionResult(valueExpression, initialScope);
       if (construction == null) return;
       if (ER.isReactHookCall(construction.node)) {
         return;

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

@@ -72,10 +72,10 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
           const { value } = prop;
           const { right } = value;
           const initialScope = context.sourceCode.getScope(value);
-          const construction = VAR.getValueConstruction(
+          const construction = VAR.getConstructionDetectionResult(
             value,
             initialScope,
-            VAR.ValueConstructionHint.StrictCallExpression,
+            VAR.ConstructionDetectionHint.StrictCallExpression,
           );
           if (construction == null) {
             continue;

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

@@ -0,0 +1,6 @@
+export type ConstructionDetectionHint = bigint;
+
+export const ConstructionDetectionHint = {
+  None: 0n,
+  StrictCallExpression: 1n << 0n,
+};

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

@@ -0,0 +1,84 @@
+import type { Scope } from "@typescript-eslint/scope-manager";
+import type { TSESTree } from "@typescript-eslint/types";
+import type { Construction } from "./construction";
+import { _ } from "@eslint-react/eff";
+
+import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
+import { getVariableInitNode } from "../get-variable-init-node";
+import { ConstructionDetectionHint } from "./construction-detection-hint";
+
+/**
+ * Detects the construction type of a given node.
+ * @param node The node to check.
+ * @param initialScope  The initial scope to check for variable declarations.
+ * @param hint Optional hint to control the detection behavior.
+ * @returns The construction type of the node, or `_` if not found.
+ */
+export function getConstructionDetectionResult(
+  node: TSESTree.Node | _,
+  initialScope: Scope,
+  hint = ConstructionDetectionHint.None,
+): Construction | _ {
+  if (node == null) return _;
+  switch (node.type) {
+    case T.JSXElement:
+    case T.JSXFragment:
+      return { kind: "JSXElement", node } as const;
+    case T.ArrayExpression:
+      return { kind: "ArrayExpression", node } as const;
+    case T.ObjectExpression:
+      return { kind: "ObjectExpression", node } as const;
+    case T.ClassExpression:
+      return { kind: "ClassExpression", node } as const;
+    case T.NewExpression:
+      return { kind: "NewExpression", node } as const;
+    case T.FunctionExpression:
+    case T.ArrowFunctionExpression:
+      return { kind: "FunctionExpression", node } as const;
+    case T.CallExpression: {
+      if (hint & ConstructionDetectionHint.StrictCallExpression) {
+        return { kind: "CallExpression", node } as const;
+      }
+      return _;
+    }
+    case T.MemberExpression: {
+      if (!("object" in node)) return _;
+      return getConstructionDetectionResult(node.object, initialScope, hint);
+    }
+    case T.AssignmentExpression:
+    case T.AssignmentPattern: {
+      if (!("right" in node)) return _;
+      return getConstructionDetectionResult(node.right, initialScope, hint);
+    }
+    case T.LogicalExpression: {
+      const lvc = getConstructionDetectionResult(node.left, initialScope, hint);
+      if (lvc == null) return _;
+      return getConstructionDetectionResult(node.right, initialScope, hint);
+    }
+    case T.ConditionalExpression: {
+      const cvc = getConstructionDetectionResult(node.consequent, initialScope, hint);
+      if (cvc == null) return _;
+      return getConstructionDetectionResult(node.alternate, initialScope, hint);
+    }
+    case T.Identifier: {
+      if (!("name" in node) || typeof node.name !== "string") {
+        return _;
+      }
+      const variable = initialScope.set.get(node.name);
+      const variableNode = getVariableInitNode(variable, -1);
+      return getConstructionDetectionResult(variableNode, initialScope, hint);
+    }
+    case T.Literal: {
+      if ("regex" in node) {
+        return { kind: "RegExpLiteral", node } as const;
+      }
+      return _;
+    }
+    default: {
+      if (!("expression" in node) || typeof node.expression !== "object") {
+        return _;
+      }
+      return getConstructionDetectionResult(node.expression, initialScope, hint);
+    }
+  }
+}

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

@@ -0,0 +1,15 @@
+import type { TSESTree } from "@typescript-eslint/types";
+
+/**
+ * Represents the construction type of a expression like node.
+ */
+export type Construction =
+  | { kind: "ArrayExpression"; node: TSESTree.ArrayExpression }
+  | { kind: "CallExpression"; node: TSESTree.CallExpression }
+  | { kind: "ClassExpression"; node: TSESTree.ClassExpression }
+  | { kind: "FunctionDeclaration"; node: TSESTree.FunctionDeclaration }
+  | { kind: "FunctionExpression"; node: TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression }
+  | { kind: "JSXElement"; node: TSESTree.JSXElement | TSESTree.JSXFragment }
+  | { kind: "NewExpression"; node: TSESTree.NewExpression }
+  | { kind: "ObjectExpression"; node: TSESTree.ObjectExpression }
+  | { kind: "RegExpLiteral"; node: TSESTree.RegExpLiteral };

packages/utilities/var/src/construction/index.ts

@@ -0,0 +1,3 @@
+export type * from "./construction";
+export * from "./construction-detection";
+export * from "./construction-detection-hint";

packages/utilities/var/src/index.ts

@@ -1,3 +1,4 @@
+export * from "./construction";
 export * from "./find-property-in-properties";
 export * from "./find-variable";
 export * from "./get-child-scopes";
@@ -6,4 +7,3 @@ export * from "./get-variable-init-node";
 export * from "./get-variables";
 export * from "./is-node-value-equal";
 export * from "./lazy-value";
-export * from "./value-construction";