feat(UPO10): reworked FunctionScopeNameFinder to AnyExpressionFinder

renamed FunctionScopeNameFinder to AnyExpressionFinder
moved AnyExpressionFinder to super_call_with_parameters.rs
updated test cases and snapshots
removed duplicated parents

Now AnyExpressionFinder finds any expression by given conditions

Author: IDrokin117

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP008.py

@@ -144,143 +144,82 @@ def method3(self):
 
 # See: https://github.com/astral-sh/ruff/issues/19357
 # Must be detected
-class ParentD1:
+class ParentD:
     def f(self):
-        print("!")
+        print("D")
 
-class ChildD1(ParentD1):
+class ChildD1(ParentD):
     def f(self):
         if False: __class__ # Python injects __class__ into scope
         builtins.super(ChildD1, self).f()
 
-ChildD1().f()
-
-class ParentD2:
-    def f(self):
-        print("!")
-
-class ChildD2(ParentD2):
+class ChildD2(ParentD):
     def f(self):
         if False: super # Python injects __class__ into scope
         builtins.super(ChildD2, self).f()
 
-ChildD2().f()
-
-class ParentD3:
-    def f(self):
-        print("!")
-
-class ChildD3(ParentD3):
+class ChildD3(ParentD):
     def f(self):
         builtins.super(ChildD3, self).f()
         super # Python injects __class__ into scope
 
-ChildD3().f()
-
 import builtins as builtins_alias
-
-class ParentD4:
-    def f(self):
-        print("!")
-
-class ChildD4(ParentD4):
+class ChildD4(ParentD):
     def f(self):
         builtins_alias.super(ChildD4, self).f()
         super # Python injects __class__ into scope
 
-ChildD4().f()
-
-class ParentD5:
-    def f(self):
-        print("!")
-
-class ChildD5(ParentD5):
+class ChildD5(ParentD):
     def f(self):
         super = 1
         super # Python injects __class__ into scope
         builtins.super(ChildD5, self).f()
 
-ChildD5().f()
-
-class ParentD6:
-    def f(self):
-        print("!")
-
-class ChildD6(ParentD6):
+class ChildD6(ParentD):
     def f(self):
         super: "Any"
         __class__ # Python injects __class__ into scope
         builtins.super(ChildD6, self).f()
 
-ChildD6().f()
-
-class ParentD7:
-    def f(self):
-        print("!")
-
-class ChildD7(ParentD7):
+class ChildD7(ParentD):
     def f(self):
         def x():
             __class__ # Python injects __class__ into scope
         builtins.super(ChildD7, self).f()
 
-ChildD7().f()
-
-class ParentD8:
-    def f(self):
-        print("!")
-
-class ChildD8(ParentD8):
+class ChildD8(ParentD):
     def f(self):
         def x():
             super = 1
         super # Python injects __class__ into scope
         builtins.super(ChildD8, self).f()
 
-ChildD8().f()
-
-class ParentD9:
-    def f(self):
-        print("!")
-
-class ChildD9(ParentD9):
+class ChildD9(ParentD):
     def f(self):
         def x():
             __class__ = 1
         __class__ # Python injects __class__ into scope
         builtins.super(ChildD9, self).f()
 
-ChildD9().f()
-
-class ParentD10:
-    def f(self):
-        print("!")
-
-class ChildD10(ParentD10):
+class ChildD10(ParentD):
     def f(self):
         def x():
             __class__ = 1
         super # Python injects __class__ into scope
         builtins.super(ChildD10, self).f()
 
-ChildD10().f()
 
 # Must be ignored
-class ParentI1:
+class ParentI:
     def f(self):
-        print("!")
+        print("I")
 
-class ChildI1(ParentI1):
+class ChildI1(ParentI):
     def f(self):
         builtins.super(ChildI1, self).f() # no __class__ in the local scope
 
-ChildI1().f()
-
-class ParentI2:
-    def f(self):
-        print("!")
 
-class ChildI2(ParentI2):
+class ChildI2(ParentI):
     def b(self):
         x = __class__
         if False: super
@@ -289,90 +228,46 @@ def f(self):
         self.b()
         builtins.super(ChildI2, self).f() # no __class__ in the local scope
 
-ChildI2().f()
-
-class ParentI3:
-    def f(self):
-        print("!")
-
-class ChildI3(ParentI3):
+class ChildI3(ParentI):
     def f(self):
         if False: super
         def x(_):
             builtins.super(ChildI3, self).f() # no __class__ in the local scope
         x(None)
 
-ChildI3().f()
-
-class ParentI4:
-    def f(self):
-        print("!")
-
-class ChildI4(ParentI4):
+class ChildI4(ParentI):
     def f(self):
         super: "str"
         builtins.super(ChildI4, self).f() # no __class__ in the local scope
 
-ChildI4().f()
-
-class ParentI5:
-    def f(self):
-        print("!")
-
-class ChildI5(ParentI5):
+class ChildI5(ParentI):
     def f(self):
         super = 1
         __class__ = 3
         builtins.super(ChildI5, self).f() # no __class__ in the local scope
 
-ChildI5().f()
-
-class ParentI6:
-    def f(self):
-        print("!")
-
-class ChildI6(ParentI6):
+class ChildI6(ParentI):
     def f(self):
         __class__ = None
         __class__
         builtins.super(ChildI6, self).f() # no __class__ in the local scope
 
-ChildI6().f()
-
-class ParentI7:
-    def f(self):
-        print("!")
-
-class ChildI7(ParentI7):
+class ChildI7(ParentI):
     def f(self):
         __class__ = None
         super
         builtins.super(ChildI7, self).f()
 
-ChildI7().f()
-
-class ParentI8:
-    def f(self):
-        print("!")
-
-class ChildI8(ParentI8):
+class ChildI8(ParentI):
     def f(self):
         __class__: "Any"
         super
         builtins.super(ChildI8, self).f()
 
-ChildI8().f()
-
-class ParentI9:
-    def f(self):
-        print("!")
-
-class ChildI9(ParentI9):
+class ChildI9(ParentI):
     def f(self):
         class A:
             def foo(self):
                 if False: super
                 if False: __class__
         builtins.super(ChildI9, self).f()
-
-ChildI9().f()

crates/ruff_linter/src/rules/pyupgrade/rules/super_call_with_parameters.rs

@@ -1,7 +1,6 @@
 use ruff_diagnostics::Applicability;
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-use ruff_python_ast::helpers::FunctionScopeNameFinder;
-use ruff_python_ast::visitor::Visitor;
+use ruff_python_ast::visitor::{Visitor, walk_expr, walk_stmt};
 use ruff_python_ast::{self as ast, Expr, Stmt};
 use ruff_python_semantic::SemanticModel;
 use ruff_text_size::{Ranged, TextSize};
@@ -97,13 +96,12 @@ pub(crate) fn super_call_with_parameters(checker: &Checker, call: &ast::ExprCall
     };
 
     // Find the enclosing function definition (if any).
-    let Some(func_stmt) = parents.find(|stmt| stmt.is_function_def_stmt()) else {
-        return;
-    };
-    let Stmt::FunctionDef(ast::StmtFunctionDef {
-        parameters: parent_parameters,
-        ..
-    }) = func_stmt
+    let Some(
+        func_stmt @ Stmt::FunctionDef(ast::StmtFunctionDef {
+            parameters: parent_parameters,
+            ..
+        }),
+    ) = parents.find(|stmt| stmt.is_function_def_stmt())
     else {
         return;
     };
@@ -205,24 +203,30 @@ pub(crate) fn super_call_with_parameters(checker: &Checker, call: &ast::ExprCall
 fn is_super_call_with_arguments(call: &ast::ExprCall, checker: &Checker) -> bool {
     checker.semantic().match_builtin_expr(&call.func, "super") && !call.arguments.is_empty()
 }
+
 /// Returns `true` if the function contains load references to `__class__` or `super` without
 /// local binding.
 ///
 /// This indicates that the function relies on the implicit `__class__` cell variable created by
 /// Python when `super()` is called without arguments, making it unsafe to remove `super()` parameters.
 fn has_local_dunder_class_var_ref(semantic: &SemanticModel, func_stmt: &Stmt) -> bool {
-    let mut finder = FunctionScopeNameFinder::default();
+    if semantic.current_scope().has("__class__") {
+        return false;
+    }
+
+    let mut finder = AnyExpressionFinder::new(vec![
+        |expr: &Expr| {
+            expr.as_name_expr()
+                .is_some_and(|name| name.id.as_str() == "super" && name.ctx.is_load())
+        },
+        |expr: &Expr| {
+            expr.as_name_expr()
+                .is_some_and(|name| name.id.as_str() == "__class__" && name.ctx.is_load())
+        },
+    ]);
     finder.visit_stmt(func_stmt);
-    let has_load_super = finder
-        .names
-        .iter()
-        .any(|expr| expr.id.as_str() == "super" && expr.ctx.is_load());
-    let has_load_dunder_class = finder
-        .names
-        .iter()
-        .any(|expr| expr.id.as_str() == "__class__" && expr.ctx.is_load());
-    let has_dunder_class_binding = semantic.current_scope().has("__class__");
-    (has_load_super || has_load_dunder_class) && !has_dunder_class_binding
+
+    finder.has_expression()
 }
 
 /// Returns `true` if the call is to the built-in `builtins.super` function.
@@ -231,3 +235,46 @@ fn is_builtins_super(semantic: &SemanticModel, call: &ast::ExprCall) -> bool {
         .resolve_qualified_name(&call.func)
         .is_some_and(|qualified_name| matches!(qualified_name.segments(), ["builtins", "super"]))
 }
+
+/// A [`Visitor`] that searches for [`Expr`] matching any of the provided conditions
+/// , excluding nested class definitions.
+#[derive(Debug)]
+struct AnyExpressionFinder<'a> {
+    result_expression: Vec<&'a Expr>,
+    conditions: Vec<fn(&Expr) -> bool>,
+}
+
+impl AnyExpressionFinder<'_> {
+    pub(crate) fn new(conditions: Vec<fn(&Expr) -> bool>) -> Self {
+        AnyExpressionFinder {
+            result_expression: Vec::with_capacity(1),
+            conditions,
+        }
+    }
+    pub(crate) fn has_expression(&self) -> bool {
+        !self.result_expression.is_empty()
+    }
+}
+
+impl<'a> Visitor<'a> for AnyExpressionFinder<'a> {
+    fn visit_stmt(&mut self, stmt: &'a Stmt) {
+        match stmt {
+            Stmt::ClassDef(_) => {}
+            _ => {
+                if self.result_expression.is_empty() {
+                    walk_stmt(self, stmt);
+                }
+            }
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &'a Expr) {
+        for condition in &self.conditions {
+            if condition(expr) {
+                self.result_expression.insert(0, expr);
+                return;
+            }
+        }
+        walk_expr(self, expr);
+    }
+}