[pylint] Implement PLE0302 unexpected-special-method-signature

crates/ruff/resources/test/fixtures/pylint/unexpected_special_method_signature.py

@@ -0,0 +1,51 @@
+class TestClass:
+    def __bool__(self):
+        ...
+
+    def __bool__(self, x):  # too many mandatory args
+        ...
+
+    def __bool__(self, x=1):  # additional optional args OK
+        ...
+
+    def __bool__(self, *args):  # varargs OK
+        ...
+
+    def __bool__():  # ignored; should be caughty by E0211/N805
+        ...
+
+    @staticmethod
+    def __bool__():
+        ...
+
+    @staticmethod
+    def __bool__(x):  # too many mandatory args
+        ...
+
+    @staticmethod
+    def __bool__(x=1):  # additional optional args OK
+        ...
+
+    def __eq__(self, other):  # multiple args
+        ...
+
+    def __eq__(self, other=1):  # expected arg is optional
+        ...
+
+    def __eq__(self):  # too few mandatory args
+        ...
+
+    def __eq__(self, other, other_other):  # too many mandatory args
+        ...
+
+    def __round__(self):  # allow zero additional args.
+        ...
+
+    def __round__(self, x):  # allow one additional args.
+        ...
+
+    def __round__(self, x, y):  # disallow 2 args
+        ...
+
+    def __round__(self, x, y, z=2):  # disallow 3 args even when one is optional
+        ...

crates/ruff/src/checkers/ast/mod.rs

@@ -590,6 +590,21 @@ where
                     );
                 }
 
+                if self
+                    .settings
+                    .rules
+                    .enabled(Rule::UnexpectedSpecialMethodSignature)
+                {
+                    pylint::rules::unexpected_special_method_signature(
+                        self,
+                        stmt,
+                        name,
+                        decorator_list,
+                        args,
+                        self.locator,
+                    );
+                }
+
                 self.check_builtin_shadowing(name, stmt, true);
 
                 // Visit the decorators and arguments, but avoid the body, which will be

crates/ruff/src/codes.rs

@@ -202,6 +202,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<Rule> {
         (Pylint, "W0711") => Rule::BinaryOpException,
         (Pylint, "W1508") => Rule::InvalidEnvvarDefault,
         (Pylint, "W2901") => Rule::RedefinedLoopName,
+        (Pylint, "E0302") => Rule::UnexpectedSpecialMethodSignature,
 
         // flake8-builtins
         (Flake8Builtins, "001") => Rule::BuiltinVariableShadowing,

crates/ruff/src/registry.rs

@@ -187,6 +187,7 @@ ruff_macros::register_rules!(
     rules::pylint::rules::RedefinedLoopName,
     rules::pylint::rules::LoggingTooFewArgs,
     rules::pylint::rules::LoggingTooManyArgs,
+    rules::pylint::rules::UnexpectedSpecialMethodSignature,
     // flake8-builtins
     rules::flake8_builtins::rules::BuiltinVariableShadowing,
     rules::flake8_builtins::rules::BuiltinArgumentShadowing,

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

@@ -60,6 +60,7 @@ mod tests {
     #[test_case(Rule::TooManyBranches, Path::new("too_many_branches.py"); "PLR0912")]
     #[test_case(Rule::TooManyReturnStatements, Path::new("too_many_return_statements.py"); "PLR0911")]
     #[test_case(Rule::TooManyStatements, Path::new("too_many_statements.py"); "PLR0915")]
+    #[test_case(Rule::UnexpectedSpecialMethodSignature, Path::new("unexpected_special_method_signature.py"); "PLE0302")]
     #[test_case(Rule::UnnecessaryDirectLambdaCall, Path::new("unnecessary_direct_lambda_call.py"); "PLC3002")]
     #[test_case(Rule::LoadBeforeGlobalDeclaration, Path::new("load_before_global_declaration.py"); "PLE0118")]
     #[test_case(Rule::UselessElseOnLoop, Path::new("useless_else_on_loop.py"); "PLW0120")]

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

@@ -34,6 +34,9 @@ pub use too_many_arguments::{too_many_arguments, TooManyArguments};
 pub use too_many_branches::{too_many_branches, TooManyBranches};
 pub use too_many_return_statements::{too_many_return_statements, TooManyReturnStatements};
 pub use too_many_statements::{too_many_statements, TooManyStatements};
+pub use unexpected_special_method_signature::{
+    unexpected_special_method_signature, UnexpectedSpecialMethodSignature,
+};
 pub use unnecessary_direct_lambda_call::{
     unnecessary_direct_lambda_call, UnnecessaryDirectLambdaCall,
 };
@@ -73,6 +76,7 @@ mod too_many_arguments;
 mod too_many_branches;
 mod too_many_return_statements;
 mod too_many_statements;
+mod unexpected_special_method_signature;
 mod unnecessary_direct_lambda_call;
 mod useless_else_on_loop;
 mod useless_import_alias;

crates/ruff/src/rules/pylint/rules/unexpected_special_method_signature.rs

@@ -0,0 +1,132 @@
+use std::ops::RangeInclusive;
+
+use rustpython_parser::ast::{Arguments, Expr, Stmt};
+
+use ruff_diagnostics::{Diagnostic, Violation};
+use ruff_macros::{derive_message_formats, violation};
+use ruff_python_ast::helpers::identifier_range;
+use ruff_python_ast::source_code::Locator;
+use ruff_python_semantic::analyze::visibility::is_staticmethod;
+use ruff_python_semantic::scope::ScopeKind;
+
+use crate::checkers::ast::Checker;
+
+#[violation]
+pub struct UnexpectedSpecialMethodSignature {
+    pub method_name: String,
+    pub expected_params: std::ops::RangeInclusive<usize>,
+    pub actual_params: usize,
+}
+
+impl Violation for UnexpectedSpecialMethodSignature {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        let verb = if self.actual_params > 1 {
+            "were"
+        } else {
+            "was"
+        };
+        if self.expected_params.end() - self.expected_params.start() > 1 {
+            format!(
+                "The special method '{}' expects between {} and {} param(s), {} {} given",
+                self.method_name,
+                self.expected_params.start(),
+                self.expected_params.end(),
+                self.actual_params,
+                verb,
+            )
+        } else {
+            format!(
+                "The special method '{}' expects {} param(s), {} {} given",
+                self.method_name,
+                self.expected_params.start(),
+                self.actual_params,
+                verb,
+            )
+        }
+    }
+}
+
+fn expected_params(name: &str, is_staticmethod: bool) -> Option<RangeInclusive<usize>> {
+    match name {
+        "__del__" | "__repr__" | "__str__" | "__bytes__" | "__hash__" | "__bool__" | "__dir__"
+        | "__len__" | "__length_hint__" | "__iter__" | "__reversed__" | "__neg__" | "__pos__"
+        | "__abs__" | "__invert__" | "__complex__" | "__int__" | "__float__" | "__index__"
+        | "__trunc__" | "__floor__" | "__ceil__" | "__enter__" | "__aenter__"
+        | "__getnewargs_ex__" | "__getnewargs__" | "__getstate__" | "__reduce__" | "__copy__"
+        | "__unicode__" | "__nonzero__" | "__await__" | "__aiter__" | "__anext__"
+        | "__fspath__" | "__subclasses__" => Some(0..=0),
+        "__format__" | "__lt__" | "__le__" | "__eq__" | "__ne__" | "__gt__" | "__ge__"
+        | "__getattr__" | "__getattribute__" | "__delattr__" | "__delete__"
+        | "__instancecheck__" | "__subclasscheck__" | "__getitem__" | "__missing__"
+        | "__delitem__" | "__contains__" | "__add__" | "__sub__" | "__mul__" | "__truediv__"
+        | "__floordiv__" | "__rfloordiv__" | "__mod__" | "__divmod__" | "__lshift__"
+        | "__rshift__" | "__and__" | "__xor__" | "__or__" | "__radd__" | "__rsub__"
+        | "__rmul__" | "__rtruediv__" | "__rmod__" | "__rdivmod__" | "__rpow__" | "__rlshift__"
+        | "__rrshift__" | "__rand__" | "__rxor__" | "__ror__" | "__iadd__" | "__isub__"
+        | "__imul__" | "__itruediv__" | "__ifloordiv__" | "__imod__" | "__ilshift__"
+        | "__irshift__" | "__iand__" | "__ixor__" | "__ior__" | "__ipow__" | "__setstate__"
+        | "__reduce_ex__" | "__deepcopy__" | "__cmp__" | "__matmul__" | "__rmatmul__"
+        | "__imatmul__" | "__div__" => Some(1..=1),
+        "__setattr__" | "__get__" | "__set__" | "__setitem__" | "__set_name__" => Some(2..=2),
+        "__exit__" | "__aexit__" => Some(3..=3),
+        "__round__" => Some(0..=1),
+        "__pow__" => Some(1..=2),
+        _ => return None,
+    }
+    .map(|r| {
+        if is_staticmethod {
+            r
+        } else {
+            RangeInclusive::new(r.start() + 1, r.end() + 1)
+        }
+    })
+}
+
+/// PLE0302
+pub fn unexpected_special_method_signature(
+    checker: &mut Checker,
+    stmt: &Stmt,
+    name: &str,
+    decorator_list: &[Expr],
+    args: &Arguments,
+    locator: &Locator,
+) {
+    if !matches!(checker.ctx.scope().kind, ScopeKind::Class(_)) {
+        return;
+    }
+
+    // Method has no parameter, will be caught by no-method-argument (E0211/N805).
+    if args.args.is_empty() && args.vararg.is_none() {
+        return;
+    }
+
+    let actual_params = args.args.len();
+    let optional_params = args.defaults.len();
+    let mandatory_params = actual_params - optional_params;
+
+    if let Some(expected_params) =
+        expected_params(name, is_staticmethod(&checker.ctx, decorator_list))
+    {
+        let emit = if expected_params.end() - expected_params.start() > 1 {
+            !expected_params.contains(&actual_params)
+        } else if *expected_params.start() < mandatory_params {
+            true
+        } else if *expected_params.start() > mandatory_params {
+            args.vararg.is_none() && optional_params < (*expected_params.start() - mandatory_params)
+        } else {
+            false
+        };
+
+        if emit {
+            checker.diagnostics.push(Diagnostic::new(
+                UnexpectedSpecialMethodSignature {
+                    method_name: name.to_owned(),
+                    expected_params,
+                    actual_params,
+                },
+                identifier_range(stmt, locator),
+            ));
+        }
+    }
+}

crates/ruff/src/rules/pylint/snapshots/ruff__rules__pylint__tests__PLE0302_unexpected_special_method_signature.py.snap

@@ -0,0 +1,66 @@
+---
+source: crates/ruff/src/rules/pylint/mod.rs
+---
+unexpected_special_method_signature.py:5:9: PLE0302 The special method '__bool__' expects 1 param(s), 2 were given
+  |
+5 |         ...
+6 |     
+7 |     def __bool__(self, x):  # too many mandatory args
+  |         ^^^^^^^^ PLE0302
+8 |         ...
+  |
+
+unexpected_special_method_signature.py:22:9: PLE0302 The special method '__bool__' expects 0 param(s), 1 was given
+   |
+22 |     @staticmethod
+23 |     def __bool__(x):  # too many mandatory args
+   |         ^^^^^^^^ PLE0302
+24 |         ...
+   |
+
+unexpected_special_method_signature.py:35:9: PLE0302 The special method '__eq__' expects 2 param(s), 1 was given
+   |
+35 |         ...
+36 |     
+37 |     def __eq__(self):  # too few mandatory args
+   |         ^^^^^^ PLE0302
+38 |         ...
+   |
+
+unexpected_special_method_signature.py:38:9: PLE0302 The special method '__eq__' expects 2 param(s), 3 were given
+   |
+38 |         ...
+39 |     
+40 |     def __eq__(self, other, other_other):  # too many mandatory args
+   |         ^^^^^^ PLE0302
+41 |         ...
+   |
+
+unexpected_special_method_signature.py:44:9: PLE0302 The special method '__round__' expects 1 param(s), 2 were given
+   |
+44 |         ...
+45 |     
+46 |     def __round__(self, x):  # allow one additional args.
+   |         ^^^^^^^^^ PLE0302
+47 |         ...
+   |
+
+unexpected_special_method_signature.py:47:9: PLE0302 The special method '__round__' expects 1 param(s), 3 were given
+   |
+47 |         ...
+48 |     
+49 |     def __round__(self, x, y):  # disallow 2 args
+   |         ^^^^^^^^^ PLE0302
+50 |         ...
+   |
+
+unexpected_special_method_signature.py:50:9: PLE0302 The special method '__round__' expects 1 param(s), 4 were given
+   |
+50 |         ...
+51 |     
+52 |     def __round__(self, x, y, z=2):  # disallow 3 args even when one is optional
+   |         ^^^^^^^^^ PLE0302
+53 |         ...
+   |
+
+