[pylint] - implement super-without-brackets/W0245 (#9257)

## Summary

Implement
[`super-without-brackets`/`W0245`](https://pylint.readthedocs.io/en/latest/user_guide/messages/warning/super-without-brackets.html)

See: #970 

## Test Plan

`cargo test`

crates/ruff_linter/resources/test/fixtures/pylint/super_without_brackets.py

@@ -0,0 +1,33 @@
+class Animal:
+ @staticmethod
+ def speak():
+ return f"This animal says something."
+
+
+class BadDog(Animal):
+ @staticmethod
+ def speak():
+ original_speak = super.speak() # PLW0245
+ return f"{original_speak} But as a dog, it barks!"
+
+
+class GoodDog(Animal):
+ @staticmethod
+ def speak():
+ original_speak = super().speak() # OK
+ return f"{original_speak} But as a dog, it barks!"
+
+
+class FineDog(Animal):
+ @staticmethod
+ def speak():
+ super = "super"
+ original_speak = super.speak() # OK
+ return f"{original_speak} But as a dog, it barks!"
+
+
+def super_without_class() -> None:
+ super.blah() # OK
+
+
+super.blah() # OK

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -438,6 +438,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
  }
  }
  }
+ if checker.enabled(Rule::SuperWithoutBrackets) {
+ pylint::rules::super_without_brackets(checker, func);
+ }
  if checker.enabled(Rule::BitCount) {
  refurb::rules::bit_count(checker, call);
  }

crates/ruff_linter/src/codes.rs

@@ -275,6 +275,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
  (Pylint, "W0127") => (RuleGroup::Stable, rules::pylint::rules::SelfAssigningVariable),
  (Pylint, "W0129") => (RuleGroup::Stable, rules::pylint::rules::AssertOnStringLiteral),
  (Pylint, "W0131") => (RuleGroup::Stable, rules::pylint::rules::NamedExprWithoutContext),
+ (Pylint, "W0245") => (RuleGroup::Preview, rules::pylint::rules::SuperWithoutBrackets),
  (Pylint, "W0406") => (RuleGroup::Stable, rules::pylint::rules::ImportSelf),
  (Pylint, "W0602") => (RuleGroup::Stable, rules::pylint::rules::GlobalVariableNotAssigned),
  (Pylint, "W0604") => (RuleGroup::Preview, rules::pylint::rules::GlobalAtModuleLevel),

crates/ruff_linter/src/rules/pylint/mod.rs

@@ -162,6 +162,7 @@ mod tests {
  )]
  #[test_case(Rule::NoClassmethodDecorator, Path::new("no_method_decorator.py"))]
  #[test_case(Rule::NoStaticmethodDecorator, Path::new("no_method_decorator.py"))]
+ #[test_case(Rule::SuperWithoutBrackets, Path::new("super_without_brackets.py"))]
  #[test_case(
  Rule::UnnecessaryDictIndexLookup,
  Path::new("unnecessary_dict_index_lookup.py")

crates/ruff_linter/src/rules/pylint/rules/mod.rs

@@ -52,6 +52,7 @@ pub(crate) use self_assigning_variable::*;
 pub(crate) use single_string_slots::*;
 pub(crate) use subprocess_popen_preexec_fn::*;
 pub(crate) use subprocess_run_without_check::*;
+pub(crate) use super_without_brackets::*;
 pub(crate) use sys_exit_alias::*;
 pub(crate) use too_many_arguments::*;
 pub(crate) use too_many_boolean_expressions::*;
@@ -131,6 +132,7 @@ mod self_assigning_variable;
 mod single_string_slots;
 mod subprocess_popen_preexec_fn;
 mod subprocess_run_without_check;
+mod super_without_brackets;
 mod sys_exit_alias;
 mod too_many_arguments;
 mod too_many_boolean_expressions;

crates/ruff_linter/src/rules/pylint/rules/super_without_brackets.rs

@@ -0,0 +1,116 @@
+use ruff_python_ast::{self as ast, Expr};
+use ruff_python_semantic::{analyze::function_type, ScopeKind};
+
+use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
+use ruff_macros::{derive_message_formats, violation};
+use ruff_text_size::Ranged;
+
+use crate::checkers::ast::Checker;
+
+/// ## What it does
+/// Checks for `super` calls without parentheses.
+///
+/// ## Why is this bad?
+/// When `super` is used without parentheses, it is not an actual call, and
+/// thus has no effect.
+///
+/// ## Example
+/// ```python
+/// class Animal:
+/// @staticmethod
+/// def speak():
+/// return "This animal says something."
+///
+///
+/// class Dog(Animal):
+/// @staticmethod
+/// def speak():
+/// original_speak = super.speak()
+/// return f"{original_speak} But as a dog, it barks!"
+/// ```
+///
+/// Use instead:
+/// ```python
+/// class Animal:
+/// @staticmethod
+/// def speak():
+/// return "This animal says something."
+///
+///
+/// class Dog(Animal):
+/// @staticmethod
+/// def speak():
+/// original_speak = super().speak()
+/// return f"{original_speak} But as a dog, it barks!"
+/// ```
+#[violation]
+pub struct SuperWithoutBrackets;
+
+impl AlwaysFixableViolation for SuperWithoutBrackets {
+ #[derive_message_formats]
+ fn message(&self) -> String {
+ format!("`super` call is missing parentheses")
+ }
+
+ fn fix_title(&self) -> String {
+ "Add parentheses to `super` call".to_string()
+ }
+}
+
+/// PLW0245
+pub(crate) fn super_without_brackets(checker: &mut Checker, func: &Expr) {
+ // The call must be to `super` (without parentheses).
+ let Expr::Attribute(ast::ExprAttribute { value, .. }) = func else {
+ return;
+ };
+
+ let Expr::Name(ast::ExprName { id, .. }) = value.as_ref() else {
+ return;
+ };
+
+ if id.as_str() != "super" {
+ return;
+ }
+
+ if !checker.semantic().is_builtin(id.as_str()) {
+ return;
+ }
+
+ let scope = checker.semantic().current_scope();
+
+ // The current scope _must_ be a function.
+ let ScopeKind::Function(function_def) = scope.kind else {
+ return;
+ };
+
+ let Some(parent) = &checker.semantic().first_non_type_parent_scope(scope) else {
+ return;
+ };
+
+ // The function must be a method, class method, or static method.
+ let classification = function_type::classify(
+ &function_def.name,
+ &function_def.decorator_list,
+ parent,
+ checker.semantic(),
+ &checker.settings.pep8_naming.classmethod_decorators,
+ &checker.settings.pep8_naming.staticmethod_decorators,
+ );
+ if !matches!(
+ classification,
+ function_type::FunctionType::Method { .. }
+ | function_type::FunctionType::ClassMethod { .. }
+ | function_type::FunctionType::StaticMethod { .. }
+ ) {
+ return;
+ }
+
+ let mut diagnostic = Diagnostic::new(SuperWithoutBrackets, value.range());
+
+ diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
+ "super()".to_string(),
+ value.range(),
+ )));
+
+ checker.diagnostics.push(diagnostic);
+}

crates/ruff_linter/src/rules/pylint/snapshots/ruff_linter__rules__pylint__tests__PLW0245_super_without_brackets.py.snap

@@ -0,0 +1,24 @@
+---
+source: crates/ruff_linter/src/rules/pylint/mod.rs
+---
+super_without_brackets.py:10:26: PLW0245 [*] `super` call is missing parentheses
+ |
+ 8 | @staticmethod
+ 9 | def speak():
+10 | original_speak = super.speak() # PLW0245
+ | ^^^^^ PLW0245
+11 | return f"{original_speak} But as a dog, it barks!"
+ |
+ = help: Add parentheses to `super` call
+
+ℹ Safe fix
+7 7 | class BadDog(Animal):
+8 8 | @staticmethod
+9 9 | def speak():
+10 |- original_speak = super.speak() # PLW0245
+ 10 |+ original_speak = super().speak() # PLW0245
+11 11 | return f"{original_speak} But as a dog, it barks!"
+12 12 | 
+13 13 | 
+
+