refactor(utilities/var): rename getVariableNode to getVariableInitNode

Rel1cx · Rel1cx · commit cbeda4e369c5 · 2025-03-04T13:51:55.000+08:00
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
@@ -183,7 +183,7 @@ export function useNoDirectSetStateInUseEffect<Ctx extends RuleContext>(
         id: string | TSESTree.Identifier,
         initialScope: Scope.Scope,
       ): TSESTree.CallExpression[] | TSESTree.Identifier[] => {
-        const node = VAR.getVariableNode(VAR.findVariable(id, initialScope), 0);
+        const node = VAR.getVariableInitNode(VAR.findVariable(id, initialScope), 0);
         switch (node?.type) {
           case T.ArrowFunctionExpression:
           case T.FunctionDeclaration:
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
@@ -60,7 +60,7 @@ export default createRule<[], MessageID>({
           .with({ type: T.ArrayExpression }, (n) => n.elements.length === 0)
           .with({ type: T.Identifier }, (n) => {
             const variable = VAR.findVariable(n.name, initialScope);
-            const variableNode = VAR.getVariableNode(variable, 0);
+            const variableNode = VAR.getVariableInitNode(variable, 0);
             if (variableNode?.type !== T.ArrayExpression) {
               return false;
             }
@@ -81,7 +81,7 @@ export default createRule<[], MessageID>({
           .with({ type: T.FunctionExpression }, identity)
           .with({ type: T.Identifier }, (n) => {
             const variable = VAR.findVariable(n.name, initialScope);
-            const variableNode = VAR.getVariableNode(variable, 0);
+            const variableNode = VAR.getVariableInitNode(variable, 0);
             if (variableNode?.type !== T.ArrowFunctionExpression && variableNode?.type !== T.FunctionExpression) {
               return _;
             }
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
@@ -65,7 +65,7 @@ export default createRule<[], MessageID>({
           .with({ type: T.ArrayExpression }, (n) => n.elements.length === 0)
           .with({ type: T.Identifier }, (n) => {
             const variable = VAR.findVariable(n.name, initialScope);
-            const variableNode = VAR.getVariableNode(variable, 0);
+            const variableNode = VAR.getVariableInitNode(variable, 0);
             if (variableNode?.type !== T.ArrayExpression) {
               return false;
             }
@@ -86,7 +86,7 @@ export default createRule<[], MessageID>({
           .with({ type: T.FunctionExpression }, identity)
           .with({ type: T.Identifier }, (n) => {
             const variable = VAR.findVariable(n.name, initialScope);
-            const variableNode = VAR.getVariableNode(variable, 0);
+            const variableNode = VAR.getVariableInitNode(variable, 0);
             if (variableNode?.type !== T.ArrowFunctionExpression && variableNode?.type !== T.FunctionExpression) {
               return _;
             }
diff --git a/packages/plugins/eslint-plugin-react-hooks-extra/src/utils/is-from-hook-call.ts b/packages/plugins/eslint-plugin-react-hooks-extra/src/utils/is-from-hook-call.ts
@@ -14,7 +14,7 @@ export function isFromHookCall(
   const hookAlias = settings.additionalHooks[name] ?? [];
   return (topLevelId: TSESTree.Identifier) => {
     const variable = VAR.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
-    const variableNode = VAR.getVariableNode(variable, 0);
+    const variableNode = VAR.getVariableInitNode(variable, 0);
     if (variableNode == null) return false;
     if (variableNode.type !== T.CallExpression) return false;
     if (!isReactHookCallWithNameAlias(context, name, hookAlias)(variableNode)) return false;
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
@@ -75,7 +75,7 @@ function getSignalValueExpression(node: TSESTree.Node | _, initialScope: Scope):
   if (node == null) return _;
   switch (node.type) {
     case T.Identifier: {
-      return getSignalValueExpression(VAR.getVariableNode(VAR.findVariable(node, initialScope), 0), initialScope);
+      return getSignalValueExpression(VAR.getVariableInitNode(VAR.findVariable(node, initialScope), 0), initialScope);
     }
     case T.MemberExpression:
       return node;
@@ -111,7 +111,7 @@ function getOptions(node: TSESTree.CallExpressionArgument, initialScope: Scope):
     switch (node.type) {
       case T.Identifier: {
         const variable = VAR.findVariable(node, initialScope);
-        const variableNode = VAR.getVariableNode(variable, 0);
+        const variableNode = VAR.getVariableInitNode(variable, 0);
         if (variableNode?.type === T.ObjectExpression) {
           return getOpts(variableNode);
         }
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
@@ -50,7 +50,7 @@ function isFromObserver(context: RuleContext, node: TSESTree.Expression): boolea
   switch (true) {
     case node.type === T.Identifier: {
       const initialScope = context.sourceCode.getScope(node);
-      const object = VAR.getVariableNode(VAR.findVariable(node, initialScope), 0);
+      const object = VAR.getVariableInitNode(VAR.findVariable(node, initialScope), 0);
       return isNewResizeObserver(object);
     }
     case node.type === T.MemberExpression:
diff --git a/packages/plugins/eslint-plugin-react-x/src/rules/no-default-props.ts b/packages/plugins/eslint-plugin-react-x/src/rules/no-default-props.ts
@@ -48,7 +48,7 @@ export default createRule<[], MessageID>({
           return;
         }
         const variable = VAR.findVariable(object.name, context.sourceCode.getScope(node));
-        const variableNode = VAR.getVariableNode(variable, 0);
+        const variableNode = VAR.getVariableInitNode(variable, 0);
         if (variableNode == null) return;
         if (!AST.isFunction(variableNode) && !isClassComponent(variableNode)) return;
         context.report({ messageId: "noDefaultProps", node: property });
diff --git a/packages/plugins/eslint-plugin-react-x/src/rules/no-prop-types.ts b/packages/plugins/eslint-plugin-react-x/src/rules/no-prop-types.ts
@@ -48,7 +48,7 @@ export default createRule<[], MessageID>({
           return;
         }
         const variable = VAR.findVariable(object.name, context.sourceCode.getScope(node));
-        const variableNode = VAR.getVariableNode(variable, 0);
+        const variableNode = VAR.getVariableInitNode(variable, 0);
         if (variableNode != null && (AST.isFunction(variableNode) || isClassComponent(variableNode))) {
           context.report({ messageId: "noPropTypes", node: property });
         }
diff --git a/packages/utilities/jsx/src/get-attribute.ts b/packages/utilities/jsx/src/get-attribute.ts
@@ -26,7 +26,7 @@ export function getAttribute(
     switch (attr.argument.type) {
       case T.Identifier: {
         const variable = VAR.findVariable(attr.argument.name, initialScope);
-        const variableNode = VAR.getVariableNode(variable, 0);
+        const variableNode = VAR.getVariableInitNode(variable, 0);
         if (variableNode?.type === T.ObjectExpression) {
           return VAR.findPropertyInProperties(name, variableNode.properties, initialScope) != null;
         }
diff --git a/packages/utilities/jsx/src/is-jsx-value.ts b/packages/utilities/jsx/src/is-jsx-value.ts
@@ -138,7 +138,7 @@ export function isJSXValue(
       }
       const variable = VAR.findVariable(name, jsxCtx.getScope(node));
       const variableNode = variable
-        && VAR.getVariableNode(variable, 0);
+        && VAR.getVariableInitNode(variable, 0);
       return !!variableNode
         && isJSXValue(variableNode, jsxCtx, hint);
     }
diff --git a/packages/utilities/var/src/find-property-in-properties.ts b/packages/utilities/var/src/find-property-in-properties.ts
@@ -4,7 +4,7 @@ import type { TSESTree } from "@typescript-eslint/types";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 
 import { findVariable } from "./find-variable";
-import { getVariableNode } from "./get-variable-node";
+import { getVariableInitNode } from "./get-variable-init-node";
 
 export function findPropertyInProperties(
   name: string,
@@ -22,7 +22,7 @@ export function findPropertyInProperties(
         case T.Identifier: {
           if (seen.has(prop.argument.name)) return false;
           const variable = findVariable(prop.argument.name, initialScope);
-          const variableNode = getVariableNode(variable, 0);
+          const variableNode = getVariableInitNode(variable, 0);
           if (variableNode?.type === T.ObjectExpression) {
             seen.add(prop.argument.name);
             return findPropertyInProperties(
diff --git a/packages/utilities/var/src/get-variable-init-node.ts b/packages/utilities/var/src/get-variable-init-node.ts
@@ -4,7 +4,7 @@ import { DefinitionType } from "@typescript-eslint/scope-manager";
 import type { TSESTree } from "@typescript-eslint/types";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 
-export function getVariableNode(variable: Variable | _, at: number):
+export function getVariableInitNode(variable: Variable | _, at: number):
   | _
   | TSESTree.ClassDeclaration
   | TSESTree.ClassDeclarationWithName
diff --git a/packages/utilities/var/src/index.ts b/packages/utilities/var/src/index.ts
@@ -2,7 +2,7 @@ export * from "./find-property-in-properties";
 export * from "./find-variable";
 export * from "./get-child-scopes";
 export * from "./get-variable-declarator-id";
-export * from "./get-variable-node";
+export * from "./get-variable-init-node";
 export * from "./get-variables";
 export * from "./is-node-value-equal";
 export * from "./lazy-value";
diff --git a/packages/utilities/var/src/is-node-value-equal.ts b/packages/utilities/var/src/is-node-value-equal.ts
@@ -5,7 +5,7 @@ import type { TSESTree } from "@typescript-eslint/types";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 
 import { findVariable } from "./find-variable";
-import { getVariableNode } from "./get-variable-node";
+import { getVariableInitNode } from "./get-variable-init-node";
 import { toStaticValue } from "./lazy-value";
 
 const thisBlockTypes = [
@@ -47,8 +47,8 @@ export function isNodeValueEqual(
       && b.type === T.Identifier: {
       const aVar = findVariable(a, aScope);
       const bVar = findVariable(b, bScope);
-      const aVarNode = getVariableNodeLoose(aVar, 0);
-      const bVarNode = getVariableNodeLoose(bVar, 0);
+      const aVarNode = getVariableInitNodeLoose(aVar, 0);
+      const bVarNode = getVariableInitNodeLoose(bVar, 0);
       const aVarNodeParent = aVarNode?.parent;
       const bVarNodeParent = bVarNode?.parent;
       const aDef = aVar?.defs.at(0);
@@ -107,9 +107,9 @@ export function isNodeValueEqual(
   }
 }
 
-function getVariableNodeLoose(variable: Variable | _, at: number): ReturnType<typeof getVariableNode> {
+function getVariableInitNodeLoose(variable: Variable | _, at: number): ReturnType<typeof getVariableInitNode> {
   if (variable == null) return _;
-  const node = getVariableNode(variable, at);
+  const node = getVariableInitNode(variable, at);
   if (node != null) return node;
   const def = variable.defs.at(at);
   if (def?.type === DefinitionType.Parameter && AST.isFunction(def.node)) return def.node;
diff --git a/packages/utilities/var/src/value-construction.ts b/packages/utilities/var/src/value-construction.ts
@@ -3,7 +3,7 @@ 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 { getVariableNode } from "./get-variable-node";
+import { getVariableInitNode } from "./get-variable-init-node";
 
 export type ValueConstruction =
   | { kind: "ArrayExpression"; node: TSESTree.ArrayExpression }
@@ -85,7 +85,7 @@ export function getValueConstruction(
         return _;
       }
       const variable = initialScope.set.get(node.name);
-      const variableNode = getVariableNode(variable, -1);
+      const variableNode = getVariableInitNode(variable, -1);
       return getValueConstruction(variableNode, initialScope, hint);
     }
     case T.Literal: {

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ function isFromObserver(context: RuleContext, node: TSESTree.Expression): boolea`
`50`	`50`	`switch (true) {`
`51`	`51`	`case node.type === T.Identifier: {`
`52`	`52`	`const initialScope = context.sourceCode.getScope(node);`
`53`		`- const object = VAR.getVariableNode(VAR.findVariable(node, initialScope), 0);`
	`53`	`+ const object = VAR.getVariableInitNode(VAR.findVariable(node, initialScope), 0);`
`54`	`54`	`return isNewResizeObserver(object);`
`55`	`55`	`}`
`56`	`56`	`case node.type === T.MemberExpression:`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ export default createRule<[], MessageID>({`
`48`	`48`	`return;`
`49`	`49`	`}`
`50`	`50`	`const variable = VAR.findVariable(object.name, context.sourceCode.getScope(node));`
`51`		`- const variableNode = VAR.getVariableNode(variable, 0);`
	`51`	`+ const variableNode = VAR.getVariableInitNode(variable, 0);`
`52`	`52`	`if (variableNode == null) return;`
`53`	`53`	`if (!AST.isFunction(variableNode) && !isClassComponent(variableNode)) return;`
`54`	`54`	`context.report({ messageId: "noDefaultProps", node: property });`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ export function getAttribute(`
`26`	`26`	`switch (attr.argument.type) {`
`27`	`27`	`case T.Identifier: {`
`28`	`28`	`const variable = VAR.findVariable(attr.argument.name, initialScope);`
`29`		`- const variableNode = VAR.getVariableNode(variable, 0);`
	`29`	`+ const variableNode = VAR.getVariableInitNode(variable, 0);`
`30`	`30`	`if (variableNode?.type === T.ObjectExpression) {`
`31`	`31`	`return VAR.findPropertyInProperties(name, variableNode.properties, initialScope) != null;`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ export function isJSXValue(`
`138`	`138`	`}`
`139`	`139`	`const variable = VAR.findVariable(name, jsxCtx.getScope(node));`
`140`	`140`	`const variableNode = variable`
`141`		`- && VAR.getVariableNode(variable, 0);`
	`141`	`+ && VAR.getVariableInitNode(variable, 0);`
`142`	`142`	`return !!variableNode`
`143`	`143`	`&& isJSXValue(variableNode, jsxCtx, hint);`
`144`	`144`	`}`