Add enhanced FQN helper and replace internal key check

Author: Rel1cx

packages/plugins/eslint-plugin-react-x/src/rules/no-implicit-key.ts

@@ -3,9 +3,8 @@ import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
 import { ESLintUtils } from "@typescript-eslint/utils";
 import type { RuleListener } from "@typescript-eslint/utils/ts-eslint";
 import { unionConstituents } from "ts-api-utils";
-import ts from "typescript";
 
-import { createRule } from "../utils";
+import { createRule, getFullyQualifiedNameEx } from "../utils";
 
 export const RULE_NAME = "no-implicit-key";
 
@@ -43,7 +42,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
         if (key == null) return;
         // Allow pass-through of React internally defined keys
         // https://github.com/Rel1cx/eslint-react/issues/1472
-        if (isReactInternalKey(checker, key)) return;
+        if (getFullyQualifiedNameEx(checker, key).endsWith("React.Attributes.key")) return;
         context.report({
           messageId: "default",
           node,
@@ -52,21 +51,3 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
     },
   };
 }
-
-/**
- * Check if a symbol is a React internal key
- * @param checker TypeScript type checker
- * @param key Symbol to check
- * @returns True if the symbol is a React internal key, false otherwise
- */
-function isReactInternalKey(checker: ts.TypeChecker, key: ts.Symbol) {
-  if (checker.getFullyQualifiedName(key) === "React.Attributes.key") return true;
-  let parent = key.declarations?.at(0)?.parent;
-  while (parent != null && parent.kind !== ts.SyntaxKind.SourceFile) {
-    if (ts.isModuleDeclaration(parent) && ts.isIdentifier(parent.name) && parent.name.text === "React") {
-      return true;
-    }
-    parent = parent.parent;
-  }
-  return false;
-}

packages/plugins/eslint-plugin-react-x/src/utils/index.ts

@@ -1,3 +1,4 @@
 export * from "./create-rule";
 export * from "./type-is";
+export * from "./type-name";
 export * from "./type-variant";

packages/plugins/eslint-plugin-react-x/src/utils/type-name.ts

@@ -0,0 +1,79 @@
+import ts from "typescript";
+
+/**
+ * An enhanced version of getFullyQualifiedName that handles cases that original function does not handle
+ * @param checker TypeScript type checker
+ * @param symbol Symbol to get fully qualified name for
+ * @returns Fully qualified name of the symbol
+ */
+export function getFullyQualifiedNameEx(checker: ts.TypeChecker, symbol: ts.Symbol) {
+  let name = symbol.name;
+  let parent = symbol.declarations?.at(0)?.parent;
+  if (parent == null) return checker.getFullyQualifiedName(symbol);
+  while (parent.kind !== ts.SyntaxKind.SourceFile) {
+    switch (true) {
+      case ts.isInterfaceDeclaration(parent):
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isTypeAliasDeclaration(parent):
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isEnumDeclaration(parent):
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isClassDeclaration(parent)
+        && parent.name != null:
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isModuleDeclaration(parent):
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isNamespaceImport(parent):
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isNamespaceExport(parent):
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isEnumMember(parent):
+        name = `${parent.name.getText()}.${name}`;
+        break;
+      case ts.isFunctionDeclaration(parent)
+        && parent.name != null:
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isClassExpression(parent)
+        && parent.name != null:
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isPropertySignature(parent)
+        && ts.isIdentifier(parent.name):
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isPropertyDeclaration(parent)
+        && ts.isIdentifier(parent.name):
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isMethodDeclaration(parent)
+        && ts.isIdentifier(parent.name):
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isMethodSignature(parent)
+        && ts.isIdentifier(parent.name):
+        name = `${parent.name.text}.${name}`;
+        break;
+      case ts.isPropertyAssignment(parent)
+        && ts.isIdentifier(parent.name):
+        name = `${parent.name.text}.${name}`;
+        break;
+      // Skip unnamed structural type nodes (they don't contribute a name segment)
+      case ts.isTypeLiteralNode(parent):
+      case ts.isMappedTypeNode(parent):
+      case ts.isObjectLiteralExpression(parent):
+      case ts.isIntersectionTypeNode(parent):
+      case ts.isUnionTypeNode(parent):
+        break;
+    }
+    parent = parent.parent;
+  }
+  return name;
+}