packages/eslint-plugin/src/rules/no-this-in-static-method.ts (1)

8-28: Fix nested static methods tracking issue.

The current implementation uses a single boolean flag to track static method context, which fails when static methods are nested (e.g., a static method containing a nested class with its own static method). This creates false negatives where the rule stops detecting issues in the outer method after exiting the inner one.

Use a counter or stack-based approach instead:

-    let currentMethodIsStatic = false;
+    let staticMethodDepth = 0;
     let currentClassName = "";
+    const classNameStack: string[] = [];

     return {
       MethodDefinition(node) {
         if (node.static && node.key.type === "Identifier") {
-          currentMethodIsStatic = true;
+          staticMethodDepth++;
           if (node.parent?.type === "ClassBody" && node.parent.parent?.type === "ClassDeclaration") {
             const classNode = node.parent.parent as TSESTree.ClassDeclaration;
             if (classNode.id?.name) {
-              currentClassName = classNode.id.name;
+              classNameStack.push(classNode.id.name);
+              currentClassName = classNode.id.name;
             }
           }
         }
       },
       "MethodDefinition:exit"(node: TSESTree.MethodDefinition) {
         if (node.static) {
-          currentMethodIsStatic = false;
-          currentClassName = "";
+          staticMethodDepth--;
+          if (staticMethodDepth === 0) {
+            currentClassName = "";
+            classNameStack.length = 0;
+          } else {
+            classNameStack.pop();
+            currentClassName = classNameStack[classNameStack.length - 1] || "";
+          }
         }
       },
       MemberExpression(node) {
         if (
-          currentMethodIsStatic &&
+          staticMethodDepth > 0 &&

packages/eslint-plugin/src/rules/no-this-in-static-method.ts (2)

37-61: Consider edge cases in function argument detection.

The isFunctionArgument logic excludes array methods but might miss other scenarios where context loss occurs. Consider these edge cases:

1. Method chaining: items.map(this.method).filter(this.otherMethod)
2. Nested function calls: Promise.resolve(this.method)
3. Event handlers: element.addEventListener('click', this.method)

Consider expanding the detection logic or documenting known limitations:

 const isFunctionArgument =
   parent?.type === "CallExpression" &&
   parent.arguments.includes(node) &&
   !(
     parent.callee.type === "MemberExpression" &&
     parent.callee.property.type === "Identifier" &&
-    ["map", "filter", "forEach", "reduce", "find", "some", "every"].includes(
+    ["map", "filter", "forEach", "reduce", "find", "some", "every", "then", "catch", "finally"].includes(
       parent.callee.property.name
     )
   );

---

80-85: Enhance auto-fix safety checks.

The auto-fix implementation should validate that the replacement is safe and doesn't introduce naming conflicts.

Add safety checks for the auto-fix:

 fix(fixer) {
-  if (currentClassName && node.property.type === "Identifier") {
+  if (currentClassName && node.property.type === "Identifier") {
+    // Ensure the class name is valid and doesn't conflict
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(currentClassName)) {
+      return null;
+    }
     return fixer.replaceText(node, `${currentClassName}.${node.property.name}`);
   }
   return null;
 },

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro