refactor: use Check.isIdentifier and Extract.unwrap consistently (#1938)

Author: Rel1cx

packages/ast/src/compare.ts

@@ -51,8 +51,8 @@ export const isEqual: {
       }
       return true;
     }
-    case a.type === AST.Identifier
-      && b.type === AST.Identifier:
+    case Check.isIdentifier(a)
+      && Check.isIdentifier(b):
       return a.name === b.name;
     case a.type === AST.PrivateIdentifier
       && b.type === AST.PrivateIdentifier:

packages/ast/src/extract.ts

@@ -40,10 +40,10 @@ export function findProperty(properties: TSESTree.ObjectLiteralElement[], name:
  */
 export function getCalleeName(node: TSESTree.CallExpression): string | null {
   const callee = unwrap(node.callee);
-  if (callee.type === AST.Identifier) {
+  if (Check.isIdentifier(callee)) {
     return callee.name;
   }
-  if (callee.type === AST.MemberExpression && !callee.computed && callee.property.type === AST.Identifier) {
+  if (callee.type === AST.MemberExpression && !callee.computed && Check.isIdentifier(callee.property)) {
     return callee.property.name;
   }
   return null;
@@ -73,7 +73,7 @@ export function getInnermostCall(node: TSESTree.CallExpression): TSESTree.CallEx
  */
 export function getPropertyName(property: TSESTree.Property, effort: "min" | "max" = "min"): string | null {
   const key = unwrap(property.key);
-  if (key.type === AST.Identifier && !property.computed) return key.name;
+  if (Check.isIdentifier(key) && !property.computed) return key.name;
   if (effort === "min") return null;
   if (key.type === AST.Literal && typeof key.value === "string") return key.value;
   if (key.type === AST.TemplateLiteral && key.expressions.length === 0) {
@@ -123,9 +123,9 @@ export function getIdentifierAt(node: TSESTree.Expression | TSESTree.PrivateIden
   let current: TSESTree.Node = unwrap(node);
   while (current.type === AST.MemberExpression) {
     const property = unwrap(current.property);
-    identifiers.unshift(property.type === AST.Identifier ? property : null);
+    identifiers.unshift(Check.isIdentifier(property) ? property : null);
     current = unwrap(current.object);
   }
-  identifiers.unshift(current.type === AST.Identifier ? current : null);
+  identifiers.unshift(Check.isIdentifier(current) ? current : null);
   return identifiers.at(position) ?? null;
 }

packages/core/src/class-component.test.ts

@@ -208,6 +208,19 @@ describe("isThisSetStateCall", () => {
     }, true);
     expect(result).toBe(false);
   });
+
+  it("should return true when this is wrapped in TSAsExpression", () => {
+    const code = "(this as any).setState({})";
+    let result = false;
+    simpleTraverse(parseCode(code).ast, {
+      enter(node) {
+        if (node.type === AST.CallExpression) {
+          result = isThisSetStateCall(node);
+        }
+      },
+    }, true);
+    expect(result).toBe(true);
+  });
 });
 
 describe("isAssignmentToThisState", () => {
@@ -288,4 +301,43 @@ describe("isAssignmentToThisState", () => {
     }, true);
     expect(result).toBe(false);
   });
+
+  it("should return true for (this as any).state = {}", () => {
+    const code = "(this as any).state = {}";
+    let result = false;
+    simpleTraverse(parseCode(code).ast, {
+      enter(node) {
+        if (node.type === AST.AssignmentExpression) {
+          result = isAssignmentToThisState(node);
+        }
+      },
+    }, true);
+    expect(result).toBe(true);
+  });
+
+  it("should return true for (this as any).state.foo = 'baz'", () => {
+    const code = "(this as any).state.foo = 'baz'";
+    let result = false;
+    simpleTraverse(parseCode(code).ast, {
+      enter(node) {
+        if (node.type === AST.AssignmentExpression) {
+          result = isAssignmentToThisState(node);
+        }
+      },
+    }, true);
+    expect(result).toBe(true);
+  });
+
+  it("should return true for this!.state = {}", () => {
+    const code = "this!.state = {}";
+    let result = false;
+    simpleTraverse(parseCode(code).ast, {
+      enter(node) {
+        if (node.type === AST.AssignmentExpression) {
+          result = isAssignmentToThisState(node);
+        }
+      },
+    }, true);
+    expect(result).toBe(true);
+  });
 });

packages/core/src/class-component.ts

@@ -37,10 +37,10 @@ export function isClassComponent(node: TSESTree.Node): node is TSESTreeClass {
   if ("superClass" in node && node.superClass != null) {
     const re = /^(?:Pure)?Component$/u;
     switch (true) {
-      case node.superClass.type === AST.Identifier:
+      case Check.isIdentifier(node.superClass):
         return re.test(node.superClass.name);
       case node.superClass.type === AST.MemberExpression
-        && node.superClass.property.type === AST.Identifier:
+        && Check.isIdentifier(node.superClass.property):
         return re.test(node.superClass.property.name);
     }
   }
@@ -57,10 +57,10 @@ export function isPureComponent(node: TSESTree.Node) {
   if ("superClass" in node && node.superClass != null) {
     const re = /^PureComponent$/u;
     switch (true) {
-      case node.superClass.type === AST.Identifier:
+      case Check.isIdentifier(node.superClass):
         return re.test(node.superClass.name);
       case node.superClass.type === AST.MemberExpression
-        && node.superClass.property.type === AST.Identifier:
+        && Check.isIdentifier(node.superClass.property):
         return re.test(node.superClass.property.name);
     }
   }
@@ -75,7 +75,7 @@ function createLifecycleChecker(methodName: string, isStatic = false) {
   return (node: TSESTree.Node): node is TSESTreeMethodOrPropertyDefinition => (
     Check.isPropertyOrMethod(node)
     && node.static === isStatic
-    && node.key.type === AST.Identifier
+    && Check.isIdentifier(node.key)
     && node.key.name === methodName
   );
 }
@@ -110,7 +110,6 @@ export const isUnsafeComponentWillMount = createLifecycleChecker("UNSAFE_compone
 export const isUnsafeComponentWillReceiveProps = createLifecycleChecker("UNSAFE_componentWillReceiveProps");
 /** @deprecated Class components are legacy. */
 export const isUnsafeComponentWillUpdate = createLifecycleChecker("UNSAFE_componentWillUpdate");
-
 /** @deprecated Class components are legacy. */
 export const isGetDefaultProps = createLifecycleChecker("getDefaultProps", true);
 /** @deprecated Class components are legacy. */
@@ -130,7 +129,7 @@ export const isGetDerivedStateFromError = createLifecycleChecker("getDerivedStat
  */
 export function isRenderMethodLike(node: TSESTree.Node): node is TSESTreeMethodOrPropertyDefinition {
   return Check.isPropertyOrMethod(node)
-    && node.key.type === AST.Identifier
+    && Check.isIdentifier(node.key)
     && node.key.name.startsWith("render")
     && Check.isOneOf([AST.ClassDeclaration, AST.ClassExpression])(node.parent.parent);
 }
@@ -144,9 +143,8 @@ export function isRenderMethodCallback(node: TSESTreeFunction) {
   const parent = node.parent;
   const grandparent = parent.parent;
   const greatGrandparent = grandparent?.parent;
-  return greatGrandparent != null
-    && isRenderMethodLike(parent)
-    && isClassComponent(greatGrandparent);
+  if (greatGrandparent == null) return false;
+  return isRenderMethodLike(parent) && isClassComponent(greatGrandparent);
 }
 
 // #endregion
@@ -163,7 +161,7 @@ export function isThisSetStateCall(node: TSESTree.CallExpression) {
   const callee = Extract.unwrap(node.callee);
   return (
     callee.type === AST.MemberExpression
-    && callee.object.type === AST.ThisExpression
+    && Extract.unwrap(callee.object).type === AST.ThisExpression
     && Extract.getCalleeName(node) === "setState"
   );
 }
@@ -178,11 +176,12 @@ export function isAssignmentToThisState(node: TSESTree.AssignmentExpression) {
   const { left } = node;
   let current: TSESTree.Node = Extract.unwrap(left);
   while (current.type === AST.MemberExpression) {
-    const { object, property } = current;
-    if (object.type === AST.ThisExpression && property.type === AST.Identifier && property.name === "state") {
+    const object = Extract.unwrap(current.object);
+    const property = current.property;
+    if (object.type === AST.ThisExpression && Check.isIdentifier(property, "state")) {
       return true;
     }
-    current = Extract.unwrap(object);
+    current = object;
   }
   return false;
 }

packages/core/src/function-component.test.ts

@@ -24,7 +24,7 @@ function createMockContext(): RuleContext {
   return {
     sourceCode: {
       getText: (node: TSESTree.Node) => {
-        if (node.type === AST.Identifier) {
+        if (Check.isIdentifier(node)) {
           return node.name;
         }
         return "";
@@ -180,7 +180,7 @@ describe("getFunctionComponentId", () => {
         if (Check.isFunction(node) && node.type === expectedType) {
           const id = getFunctionComponentId(context, node);
           expect(id).not.toBeNull();
-          if (id?.type === AST.Identifier) {
+          if (id != null && Check.isIdentifier(id)) {
             expect(id.name).toBe(expectedName);
           }
           found = true;

packages/core/src/function-component.ts

@@ -179,10 +179,10 @@ export function isFunctionComponentNameLoose(name: string) {
 export function isFunctionWithLooseComponentName(context: RuleContext, fn: TSESTreeFunction, allowNone = false) {
   const id = getFunctionComponentId(context, fn);
   if (id == null) return allowNone;
-  if (id.type === AST.Identifier) {
+  if (Check.isIdentifier(id)) {
     return isFunctionComponentNameLoose(id.name);
   }
-  if (id.type === AST.MemberExpression && id.property.type === AST.Identifier) {
+  if (id.type === AST.MemberExpression && Check.isIdentifier(id.property)) {
     return isFunctionComponentNameLoose(id.property.name);
   }
   return false;

packages/core/src/function.test.ts

@@ -95,7 +95,7 @@ describe("getFunctionId", () => {
         if (Check.isFunction(node) && node.type === expectedType) {
           const id = getFunctionId(node);
           expect(id).not.toBeNull();
-          if (id?.type === AST.Identifier) {
+          if (id != null && Check.isIdentifier(id)) {
             expect(id.name).toBe(expectedName);
           }
           found = true;

packages/core/src/function.ts

@@ -230,7 +230,7 @@ export function isFunctionHasCallInInitPath(callName: string, initPath: Function
     const callee = Extract.unwrap(node.callee);
 
     // Check direct function calls: memo(...)
-    if (callee.type === AST.Identifier) {
+    if (Check.isIdentifier(callee)) {
       return callee.name === callName;
     }
 

packages/jsx/src/attribute-find.ts

@@ -1,4 +1,4 @@
-import { type TSESTreeJSXAttributeLike, Traverse } from "@eslint-react/ast";
+import { Check, type TSESTreeJSXAttributeLike, Traverse } from "@eslint-react/ast";
 import type { RuleContext } from "@eslint-react/eslint";
 import { resolve } from "@eslint-react/var";
 import { AST_NODE_TYPES as AST, type TSESTree } from "@typescript-eslint/types";
@@ -75,11 +75,11 @@ export function findSpreadProperty(
   seen: Set<TSESTree.Node> = new Set(),
 ): TSESTree.Property | undefined {
   let objectExpression: TSESTree.ObjectExpression | undefined;
-  if (argument.type === AST.Identifier) {
+  if (Check.isIdentifier(argument)) {
     // Follow identifier aliases (`const b = a`) until a non-identifier
     // initializer is reached, mirroring `getStaticValue`'s identifier tracking.
     let initNode: TSESTree.Node | null = resolve(context, argument);
-    while (initNode != null && initNode.type === AST.Identifier && !seen.has(initNode)) {
+    while (initNode != null && Check.isIdentifier(initNode) && !seen.has(initNode)) {
       seen.add(initNode);
       initNode = resolve(context, initNode);
     }
@@ -103,7 +103,7 @@ export function findSpreadProperty(
         if (getStaticValue(key, keyScope)?.value === name) return property;
         continue;
       }
-      if (key.type === AST.Identifier && key.name === name) return property;
+      if (Check.isIdentifier(key, name)) return property;
       if (key.type === AST.Literal && key.value === name) return property;
       continue;
     }

packages/var/src/get-require-expression-arguments.ts

@@ -1,4 +1,4 @@
-import { Extract } from "@eslint-react/ast";
+import { Check, Extract } from "@eslint-react/ast";
 import { AST_NODE_TYPES as AST, type TSESTree } from "@typescript-eslint/types";
 
 /**
@@ -11,7 +11,7 @@ export function getRequireExpressionArguments(node: TSESTree.Node) {
   const unwrapped = Extract.unwrap(node);
   if (unwrapped.type === AST.CallExpression) {
     const callee = Extract.unwrap(unwrapped.callee);
-    if (callee.type === AST.Identifier && callee.name === "require") {
+    if (Check.isIdentifier(callee, "require")) {
       return unwrapped.arguments;
     }
   }