refactor: simplify callee name checks and remove getPropertyName (#1905)

Author: Rel1cx

docs/rule-implementation-patterns-term-based.md

@@ -144,7 +144,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
       const [, isStatic] = methodStack.at(-1) ?? [];
       const [setState] = setStateStack.at(-1) ?? [];
       if (!isComponent || isStatic || setState == null) return;
-      if (Extract.getPropertyName(node.property) === "state") {
+      if (node.property.type === AST.Identifier && node.property.name === "state") {
         context.report({ messageId: "default", node });
       }
     },

packages/ast/docs/@eslint-react/namespaces/Extract/README.md

@@ -6,9 +6,9 @@ Helpers for extracting information from `TSESTree` nodes.
 
 ## Functions
 
-| Function                                                    | Description |
-| ----------------------------------------------------------- | ----------- |
-| [getFullyQualifiedName](functions/getFullyQualifiedName.md) | -           |
-| [getPropertyName](functions/getPropertyName.md)             | -           |
-| [getRootIdentifier](functions/getRootIdentifier.md)         | -           |
-| [unwrap](functions/unwrap.md)                               | -           |
+| Function                                                    | Description                                                                                                                |
+| ----------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| [getCalleeName](functions/getCalleeName.md)                 | Get the name of a call expression's callee when it is an identifier or a member expression whose property is an identifier |
+| [getFullyQualifiedName](functions/getFullyQualifiedName.md) | -                                                                                                                          |
+| [getRootIdentifier](functions/getRootIdentifier.md)         | -                                                                                                                          |
+| [unwrap](functions/unwrap.md)                               | -                                                                                                                          |

packages/ast/docs/@eslint-react/namespaces/Extract/functions/getCalleeName.md

@@ -0,0 +1,22 @@
+[@eslint-react/ast](../../../../README.md) / [Extract](../README.md) / getCalleeName
+
+# Function: getCalleeName()
+
+```ts
+function getCalleeName(node: CallExpression): string | null;
+```
+
+Get the name of a call expression's callee when it is an identifier
+or a member expression whose property is an identifier
+
+## Parameters
+
+| Parameter | Type             | Description              |
+| --------- | ---------------- | ------------------------ |
+| `node`    | `CallExpression` | The call expression node |
+
+## Returns
+
+`string` \| `null`
+
+The callee name, or `null` if it cannot be determined

packages/ast/docs/@eslint-react/namespaces/Extract/functions/getPropertyName.md

@@ -18,16 +18,19 @@ export function getRootIdentifier(node: TSESTree.Expression | TSESTree.PrivateId
   return null;
 }
 
-export function getPropertyName(node: TSESTree.Node, resolve = (n: TSESTree.Identifier | TSESTree.PrivateIdentifier): string | null => n.name): string | null {
-  node = unwrap(node);
-  if (node.type === AST.Identifier || node.type === AST.PrivateIdentifier) {
-    return resolve(node);
+/**
+ * Get the name of a call expression's callee when it is an identifier
+ * or a member expression whose property is an identifier
+ * @param node The call expression node
+ * @returns The callee name, or `null` if it cannot be determined
+ */
+export function getCalleeName(node: TSESTree.CallExpression): string | null {
+  const callee = unwrap(node.callee);
+  if (callee.type === AST.Identifier) {
+    return callee.name;
   }
-  if (node.type === AST.Literal) {
-    return String(node.value);
-  }
-  if (node.type === AST.TemplateLiteral && node.expressions.length === 0) {
-    return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? null;
+  if (callee.type === AST.MemberExpression && callee.property.type === AST.Identifier) {
+    return callee.property.name;
   }
   return null;
 }

packages/ast/src/extract.test.ts

@@ -141,7 +141,7 @@ export function isThisSetStateCall(node: TSESTree.CallExpression) {
   return (
     callee.type === AST.MemberExpression
     && callee.object.type === AST.ThisExpression
-    && Extract.getPropertyName(callee.property) === "setState"
+    && Extract.getCalleeName(node) === "setState"
   );
 }
 
@@ -154,7 +154,7 @@ export function isAssignmentToThisState(node: TSESTree.AssignmentExpression) {
   let current: TSESTree.Node = Extract.unwrap(left);
   while (current.type === AST.MemberExpression) {
     const { object, property } = current;
-    if (object.type === AST.ThisExpression && Extract.getPropertyName(property) === "state") {
+    if (object.type === AST.ThisExpression && property.type === AST.Identifier && property.name === "state") {
       return true;
     }
     current = Extract.unwrap(object);

packages/ast/src/extract.ts

@@ -296,6 +296,9 @@ export function isFunctionComponentDefinition(context: RuleContext, node: TSESTr
   const parentCallee = parent.type === AST.CallExpression
     ? Extract.unwrap(parent.callee)
     : null;
+  const parentCalleeName = parent.type === AST.CallExpression
+    ? Extract.getCalleeName(parent)
+    : null;
   switch (true) {
     case Check.isOneOf([AST.ArrowFunctionExpression, AST.FunctionExpression])(node)
       && parent.type === AST.Property
@@ -318,12 +321,12 @@ export function isFunctionComponentDefinition(context: RuleContext, node: TSESTr
       break;
     case parentCallee != null
       && parentCallee.type === AST.MemberExpression
-      && Extract.getPropertyName(parentCallee.property) === "map":
+      && parentCalleeName === "map":
       if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback) return false;
       break;
     case parentCallee != null
       && parentCallee.type === AST.MemberExpression
-      && Extract.getPropertyName(parentCallee.property) === "flatMap":
+      && parentCalleeName === "flatMap":
       if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback) return false;
       break;
     case parent.type === AST.CallExpression

packages/core/src/class-component.ts

@@ -113,17 +113,10 @@ export function isHookDefinition(node: TSESTreeFunction | null) {
  */
 export function isHookCall(node: TSESTree.Node | null): node is TSESTree.CallExpression {
   if (node == null) return false;
-  if (node.type !== AST.CallExpression) {
-    return false;
-  }
-  const callee = Extract.unwrap(node.callee);
-  if (callee.type === AST.Identifier) {
-    return isHookName(callee.name);
-  }
-  if (callee.type === AST.MemberExpression) {
-    return callee.property.type === AST.Identifier && isHookName(callee.property.name);
-  }
-  return false;
+  if (node.type !== AST.CallExpression) return false;
+  const name = Extract.getCalleeName(node);
+  if (name == null) return false;
+  return isHookName(name);
 }
 
 /**
@@ -137,19 +130,10 @@ export function isUseEffectLikeCall(
   additionalEffectHooks: RegExpLike = { test: constFalse },
 ): node is TSESTree.CallExpression {
   if (node == null) return false;
-  if (node.type !== AST.CallExpression) {
-    return false;
-  }
-  const callee = Extract.unwrap(node.callee);
-  return [/^use\w*Effect$/u, additionalEffectHooks].some((regexp) => {
-    if (callee.type === AST.Identifier) {
-      return regexp.test(callee.name);
-    }
-    if (callee.type === AST.MemberExpression) {
-      return callee.property.type === AST.Identifier && regexp.test(callee.property.name);
-    }
-    return false;
-  });
+  if (node.type !== AST.CallExpression) return false;
+  const name = Extract.getCalleeName(node);
+  if (name == null) return false;
+  return /^use\w*Effect$/u.test(name) || additionalEffectHooks.test(name);
 }
 
 /**
@@ -163,18 +147,10 @@ export function isUseStateLikeCall(
   additionalStateHooks: RegExpLike = { test: constFalse },
 ): node is TSESTree.CallExpression {
   if (node == null) return false;
-  if (node.type !== AST.CallExpression) {
-    return false;
-  }
-  const callee = Extract.unwrap(node.callee);
-  switch (true) {
-    case callee.type === AST.Identifier:
-      return callee.name === "useState" || additionalStateHooks.test(callee.name);
-    case callee.type === AST.MemberExpression
-      && callee.property.type === AST.Identifier:
-      return Extract.getPropertyName(callee.property) === "useState" || additionalStateHooks.test(callee.property.name);
-  }
-  return false;
+  if (node.type !== AST.CallExpression) return false;
+  const name = Extract.getCalleeName(node);
+  if (name == null) return false;
+  return name === "useState" || additionalStateHooks.test(name);
 }
 
 // #endregion

packages/core/src/function-component.ts

@@ -214,9 +214,9 @@ describe("isJsxLike", () => {
       expect(run("React.createElement('div');", hint)).toBe(false);
     });
 
-    it("should match computed member access", () => {
-      // `React['createElement']` has a Literal property.
-      expect(run("React['createElement']('div');")).toBe(true);
+    it("should not match computed member access", () => {
+      // `React['createElement']` has a Literal property, which is not statically resolved.
+      expect(run("React['createElement']('div');")).toBe(false);
     });
 
     it("should detect createElement when callee is wrapped in TSAsExpression", () => {