From 4eac9baf43a54bb59637c8f923a14b2ca0bc2c04 Mon Sep 17 00:00:00 2001 From: Gautier Moin Date: Mon, 4 Mar 2024 03:22:54 +0100 Subject: [PATCH] [`pep8_naming`] Add fixes `N804` and `N805` (#10215) ## Summary This PR fixes for `invalid-first-argument` rules. The fixes rename the first argument of methods and class methods to the valid one. References to this argument are also renamed. Fixes are skipped when another argument is named as the valid first argument. The fix is marked as unsafe due The functions for the `N804` and `N805` rules are now merged, as they only differ by the name of the valid first argument. The rules were moved from the AST iteration to the deferred scopes to be in the function scope while creating the fix. ## Test Plan `cargo test` --- .../test/fixtures/pep8_naming/N804.py | 23 ++ .../test/fixtures/pep8_naming/N805.py | 26 +- .../checkers/ast/analyze/deferred_scopes.rs | 13 +- .../src/checkers/ast/analyze/statement.rs | 24 -- .../rules/invalid_first_argument_name.rs | 277 ++++++++++++++++++ ...id_first_argument_name_for_class_method.rs | 104 ------- .../invalid_first_argument_name_for_method.rs | 96 ------ .../src/rules/pep8_naming/rules/mod.rs | 6 +- ...les__pep8_naming__tests__N804_N804.py.snap | 132 ++++++++- ...les__pep8_naming__tests__N805_N805.py.snap | 209 ++++++++++++- ...naming__tests__classmethod_decorators.snap | 170 ++++++++++- ...ing__tests__ignore_names_N804_N804.py.snap | 37 ++- ...ing__tests__ignore_names_N805_N805.py.snap | 55 +++- ...aming__tests__staticmethod_decorators.snap | 196 ++++++++++++- 14 files changed, 1098 insertions(+), 270 deletions(-) create mode 100644 crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name.rs delete mode 100644 crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name_for_class_method.rs delete mode 100644 crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name_for_method.rs diff --git a/crates/ruff_linter/resources/test/fixtures/pep8_naming/N804.py b/crates/ruff_linter/resources/test/fixtures/pep8_naming/N804.py index 6ca9a649e1ce5..17d4d5187adc5 100644 --- a/crates/ruff_linter/resources/test/fixtures/pep8_naming/N804.py +++ b/crates/ruff_linter/resources/test/fixtures/pep8_naming/N804.py @@ -50,6 +50,29 @@ def good_method(cls): def static_method(not_cls) -> bool: return False +class ClsInArgsClass(ABCMeta): + def cls_as_argument(this, cls): + pass + + def cls_as_pos_only_argument(this, cls, /): + pass + + def cls_as_kw_only_argument(this, *, cls): + pass + + def cls_as_varags(this, *cls): + pass + + def cls_as_kwargs(this, **cls): + pass + +class RenamingInMethodBodyClass(ABCMeta): + def bad_method(this): + this = this + this + + def bad_method(this): + self = this def func(x): return x diff --git a/crates/ruff_linter/resources/test/fixtures/pep8_naming/N805.py b/crates/ruff_linter/resources/test/fixtures/pep8_naming/N805.py index 395da9c81a8c0..ade0a7c78bfbd 100644 --- a/crates/ruff_linter/resources/test/fixtures/pep8_naming/N805.py +++ b/crates/ruff_linter/resources/test/fixtures/pep8_naming/N805.py @@ -61,7 +61,7 @@ class PosOnlyClass: def good_method_pos_only(self, blah, /, something: str): pass - def bad_method_pos_only(this, blah, /, self, something: str): + def bad_method_pos_only(this, blah, /, something: str): pass @@ -93,3 +93,27 @@ def good(self): @foobar.thisisstatic def badstatic(foo): pass + +class SelfInArgsClass: + def self_as_argument(this, self): + pass + + def self_as_pos_only_argument(this, self, /): + pass + + def self_as_kw_only_argument(this, *, self): + pass + + def self_as_varags(this, *self): + pass + + def self_as_kwargs(this, **self): + pass + +class RenamingInMethodBodyClass: + def bad_method(this): + this = this + this + + def bad_method(this): + self = this diff --git a/crates/ruff_linter/src/checkers/ast/analyze/deferred_scopes.rs b/crates/ruff_linter/src/checkers/ast/analyze/deferred_scopes.rs index c2d2dc1492357..e1d662922384b 100644 --- a/crates/ruff_linter/src/checkers/ast/analyze/deferred_scopes.rs +++ b/crates/ruff_linter/src/checkers/ast/analyze/deferred_scopes.rs @@ -7,8 +7,8 @@ use crate::checkers::ast::Checker; use crate::codes::Rule; use crate::fix; use crate::rules::{ - flake8_builtins, flake8_pyi, flake8_type_checking, flake8_unused_arguments, pyflakes, pylint, - ruff, + flake8_builtins, flake8_pyi, flake8_type_checking, flake8_unused_arguments, pep8_naming, + pyflakes, pylint, ruff, }; /// Run lint rules over all deferred scopes in the [`SemanticModel`]. @@ -18,6 +18,8 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) { Rule::GlobalVariableNotAssigned, Rule::ImportPrivateName, Rule::ImportShadowedByLoopVar, + Rule::InvalidFirstArgumentNameForMethod, + Rule::InvalidFirstArgumentNameForClassMethod, Rule::NoSelfUse, Rule::RedefinedArgumentFromLocal, Rule::RedefinedWhileUnused, @@ -394,6 +396,13 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) { if checker.enabled(Rule::SingledispatchMethod) { pylint::rules::singledispatch_method(checker, scope, &mut diagnostics); } + + if checker.any_enabled(&[ + Rule::InvalidFirstArgumentNameForClassMethod, + Rule::InvalidFirstArgumentNameForMethod, + ]) { + pep8_naming::rules::invalid_first_argument_name(checker, scope, &mut diagnostics); + } } } checker.diagnostics.extend(diagnostics); diff --git a/crates/ruff_linter/src/checkers/ast/analyze/statement.rs b/crates/ruff_linter/src/checkers/ast/analyze/statement.rs index f8867e68cf5c3..ea1335bbc0cd1 100644 --- a/crates/ruff_linter/src/checkers/ast/analyze/statement.rs +++ b/crates/ruff_linter/src/checkers/ast/analyze/statement.rs @@ -105,30 +105,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) { checker.diagnostics.push(diagnostic); } } - if checker.enabled(Rule::InvalidFirstArgumentNameForClassMethod) { - if let Some(diagnostic) = - pep8_naming::rules::invalid_first_argument_name_for_class_method( - checker, - checker.semantic.current_scope(), - name, - decorator_list, - parameters, - ) - { - checker.diagnostics.push(diagnostic); - } - } - if checker.enabled(Rule::InvalidFirstArgumentNameForMethod) { - if let Some(diagnostic) = pep8_naming::rules::invalid_first_argument_name_for_method( - checker, - checker.semantic.current_scope(), - name, - decorator_list, - parameters, - ) { - checker.diagnostics.push(diagnostic); - } - } if checker.source_type.is_stub() { if checker.enabled(Rule::PassStatementStubBody) { flake8_pyi::rules::pass_statement_stub_body(checker, body); diff --git a/crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name.rs b/crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name.rs new file mode 100644 index 0000000000000..a560fab4c1a8c --- /dev/null +++ b/crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name.rs @@ -0,0 +1,277 @@ +use anyhow::Result; + +use ruff_diagnostics::{Diagnostic, DiagnosticKind, Fix, Violation}; +use ruff_macros::{derive_message_formats, violation}; +use ruff_python_ast as ast; +use ruff_python_ast::ParameterWithDefault; +use ruff_python_semantic::analyze::function_type; +use ruff_python_semantic::{Scope, ScopeKind, SemanticModel}; +use ruff_text_size::Ranged; + +use crate::checkers::ast::Checker; +use crate::registry::Rule; +use crate::renamer::Renamer; + +/// ## What it does +/// Checks for instance methods that use a name other than `self` for their +/// first argument. +/// +/// ## Why is this bad? +/// [PEP 8] recommends the use of `self` as first argument for all instance +/// methods: +/// +/// > Always use self for the first argument to instance methods. +/// > +/// > If a function argument’s name clashes with a reserved keyword, it is generally better to +/// > append a single trailing underscore rather than use an abbreviation or spelling corruption. +/// > Thus `class_` is better than `clss`. (Perhaps better is to avoid such clashes by using a synonym.) +/// +/// Names can be excluded from this rule using the [`lint.pep8-naming.ignore-names`] +/// or [`lint.pep8-naming.extend-ignore-names`] configuration options. For example, +/// to allow the use of `this` as the first argument to instance methods, set +/// the [`lint.pep8-naming.extend-ignore-names`] option to `["this"]`. +/// +/// ## Example +/// ```python +/// class Example: +/// def function(cls, data): +/// ... +/// ``` +/// +/// Use instead: +/// ```python +/// class Example: +/// def function(self, data): +/// ... +/// ``` +/// +/// ## Fix safety +/// This rule's fix is marked as unsafe, as renaming a method parameter +/// can change the behavior of the program. +/// +/// ## Options +/// - `lint.pep8-naming.classmethod-decorators` +/// - `lint.pep8-naming.staticmethod-decorators` +/// - `lint.pep8-naming.ignore-names` +/// - `lint.pep8-naming.extend-ignore-names` +/// +/// [PEP 8]: https://peps.python.org/pep-0008/#function-and-method-arguments +#[violation] +pub struct InvalidFirstArgumentNameForMethod { + argument_name: String, +} + +impl Violation for InvalidFirstArgumentNameForMethod { + const FIX_AVAILABILITY: ruff_diagnostics::FixAvailability = + ruff_diagnostics::FixAvailability::Sometimes; + + #[derive_message_formats] + fn message(&self) -> String { + format!("First argument of a method should be named `self`") + } + + fn fix_title(&self) -> Option { + let Self { argument_name } = self; + Some(format!("Rename `{argument_name}` to `self`")) + } +} + +/// ## What it does +/// Checks for class methods that use a name other than `cls` for their +/// first argument. +/// +/// ## Why is this bad? +/// [PEP 8] recommends the use of `cls` as the first argument for all class +/// methods: +/// +/// > Always use `cls` for the first argument to class methods. +/// > +/// > If a function argument’s name clashes with a reserved keyword, it is generally better to +/// > append a single trailing underscore rather than use an abbreviation or spelling corruption. +/// > Thus `class_` is better than `clss`. (Perhaps better is to avoid such clashes by using a synonym.) +/// +/// Names can be excluded from this rule using the [`lint.pep8-naming.ignore-names`] +/// or [`lint.pep8-naming.extend-ignore-names`] configuration options. For example, +/// to allow the use of `klass` as the first argument to class methods, set +/// the [`lint.pep8-naming.extend-ignore-names`] option to `["klass"]`. +/// +/// ## Example +/// ```python +/// class Example: +/// @classmethod +/// def function(self, data): +/// ... +/// ``` +/// +/// Use instead: +/// ```python +/// class Example: +/// @classmethod +/// def function(cls, data): +/// ... +/// ``` +/// +/// ## Fix safety +/// This rule's fix is marked as unsafe, as renaming a method parameter +/// can change the behavior of the program. +/// +/// ## Options +/// - `lint.pep8-naming.classmethod-decorators` +/// - `lint.pep8-naming.staticmethod-decorators` +/// - `lint.pep8-naming.ignore-names` +/// - `lint.pep8-naming.extend-ignore-names` +/// +/// [PEP 8]: https://peps.python.org/pep-0008/#function-and-method-arguments +#[violation] +pub struct InvalidFirstArgumentNameForClassMethod { + argument_name: String, +} + +impl Violation for InvalidFirstArgumentNameForClassMethod { + const FIX_AVAILABILITY: ruff_diagnostics::FixAvailability = + ruff_diagnostics::FixAvailability::Sometimes; + + #[derive_message_formats] + fn message(&self) -> String { + format!("First argument of a class method should be named `cls`") + } + + fn fix_title(&self) -> Option { + let Self { argument_name } = self; + Some(format!("Rename `{argument_name}` to `cls`")) + } +} + +#[derive(Debug, Copy, Clone)] +enum FunctionType { + /// The function is an instance method. + Method, + /// The function is a class method. + ClassMethod, +} + +impl FunctionType { + fn diagnostic_kind(self, argument_name: String) -> DiagnosticKind { + match self { + Self::Method => InvalidFirstArgumentNameForMethod { argument_name }.into(), + Self::ClassMethod => InvalidFirstArgumentNameForClassMethod { argument_name }.into(), + } + } + + const fn valid_first_argument_name(self) -> &'static str { + match self { + Self::Method => "self", + Self::ClassMethod => "cls", + } + } + + const fn rule(self) -> Rule { + match self { + Self::Method => Rule::InvalidFirstArgumentNameForMethod, + Self::ClassMethod => Rule::InvalidFirstArgumentNameForClassMethod, + } + } +} + +/// N804, N805 +pub(crate) fn invalid_first_argument_name( + checker: &Checker, + scope: &Scope, + diagnostics: &mut Vec, +) { + let ScopeKind::Function(ast::StmtFunctionDef { + name, + parameters, + decorator_list, + .. + }) = &scope.kind + else { + panic!("Expected ScopeKind::Function") + }; + + let Some(parent) = &checker.semantic().first_non_type_parent_scope(scope) else { + return; + }; + + let function_type = match function_type::classify( + name, + decorator_list, + parent, + checker.semantic(), + &checker.settings.pep8_naming.classmethod_decorators, + &checker.settings.pep8_naming.staticmethod_decorators, + ) { + function_type::FunctionType::Function | function_type::FunctionType::StaticMethod => { + return; + } + function_type::FunctionType::Method => FunctionType::Method, + function_type::FunctionType::ClassMethod => FunctionType::ClassMethod, + }; + if !checker.enabled(function_type.rule()) + || checker.settings.pep8_naming.ignore_names.matches(name) + { + return; + } + + let Some(ParameterWithDefault { + parameter: self_or_cls, + .. + }) = parameters + .posonlyargs + .first() + .or_else(|| parameters.args.first()) + else { + return; + }; + + if &self_or_cls.name == function_type.valid_first_argument_name() { + return; + } + + let mut diagnostic = Diagnostic::new( + function_type.diagnostic_kind(self_or_cls.name.to_string()), + self_or_cls.range(), + ); + diagnostic.try_set_optional_fix(|| { + rename_parameter( + scope, + self_or_cls, + parameters, + checker.semantic(), + function_type, + ) + }); + diagnostics.push(diagnostic); +} + +/// Rename the first parameter to `self` or `cls`, if no other parameter has the target name. +fn rename_parameter( + scope: &Scope<'_>, + self_or_cls: &ast::Parameter, + parameters: &ast::Parameters, + semantic: &SemanticModel<'_>, + function_type: FunctionType, +) -> Result> { + // Don't fix if another parameter has the valid name. + if parameters + .posonlyargs + .iter() + .chain(¶meters.args) + .chain(¶meters.kwonlyargs) + .skip(1) + .map(|parameter_with_default| ¶meter_with_default.parameter) + .chain(parameters.vararg.as_deref()) + .chain(parameters.kwarg.as_deref()) + .any(|parameter| ¶meter.name == function_type.valid_first_argument_name()) + { + return Ok(None); + } + + let (edit, rest) = Renamer::rename( + &self_or_cls.name, + function_type.valid_first_argument_name(), + scope, + semantic, + )?; + Ok(Some(Fix::unsafe_edits(edit, rest))) +} diff --git a/crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name_for_class_method.rs b/crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name_for_class_method.rs deleted file mode 100644 index ce6e75ea3c0f3..0000000000000 --- a/crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name_for_class_method.rs +++ /dev/null @@ -1,104 +0,0 @@ -use ruff_python_ast::{Decorator, ParameterWithDefault, Parameters}; - -use ruff_diagnostics::{Diagnostic, Violation}; -use ruff_macros::{derive_message_formats, violation}; -use ruff_python_semantic::analyze::function_type; -use ruff_python_semantic::Scope; -use ruff_text_size::Ranged; - -use crate::checkers::ast::Checker; - -/// ## What it does -/// Checks for class methods that use a name other than `cls` for their -/// first argument. -/// -/// ## Why is this bad? -/// [PEP 8] recommends the use of `cls` as the first argument for all class -/// methods: -/// -/// > Always use `cls` for the first argument to class methods. -/// > -/// > If a function argument’s name clashes with a reserved keyword, it is generally better to -/// > append a single trailing underscore rather than use an abbreviation or spelling corruption. -/// > Thus `class_` is better than `clss`. (Perhaps better is to avoid such clashes by using a synonym.) -/// -/// Names can be excluded from this rule using the [`lint.pep8-naming.ignore-names`] -/// or [`lint.pep8-naming.extend-ignore-names`] configuration options. For example, -/// to allow the use of `klass` as the first argument to class methods, set -/// the [`lint.pep8-naming.extend-ignore-names`] option to `["klass"]`. -/// -/// ## Example -/// ```python -/// class Example: -/// @classmethod -/// def function(self, data): -/// ... -/// ``` -/// -/// Use instead: -/// ```python -/// class Example: -/// @classmethod -/// def function(cls, data): -/// ... -/// ``` -/// -/// ## Options -/// - `lint.pep8-naming.classmethod-decorators` -/// - `lint.pep8-naming.staticmethod-decorators` -/// - `lint.pep8-naming.ignore-names` -/// - `lint.pep8-naming.extend-ignore-names` -/// -/// [PEP 8]: https://peps.python.org/pep-0008/#function-and-method-arguments -#[violation] -pub struct InvalidFirstArgumentNameForClassMethod; - -impl Violation for InvalidFirstArgumentNameForClassMethod { - #[derive_message_formats] - fn message(&self) -> String { - format!("First argument of a class method should be named `cls`") - } -} - -/// N804 -pub(crate) fn invalid_first_argument_name_for_class_method( - checker: &Checker, - scope: &Scope, - name: &str, - decorator_list: &[Decorator], - parameters: &Parameters, -) -> Option { - if !matches!( - function_type::classify( - name, - decorator_list, - scope, - checker.semantic(), - &checker.settings.pep8_naming.classmethod_decorators, - &checker.settings.pep8_naming.staticmethod_decorators, - ), - function_type::FunctionType::ClassMethod - ) { - return None; - } - if let Some(ParameterWithDefault { - parameter, - default: _, - range: _, - }) = parameters - .posonlyargs - .first() - .or_else(|| parameters.args.first()) - { - if ¶meter.name != "cls" { - if checker.settings.pep8_naming.ignore_names.matches(name) { - return None; - } - return Some(Diagnostic::new( - InvalidFirstArgumentNameForClassMethod, - parameter.range(), - )); - } - } - None -} diff --git a/crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name_for_method.rs b/crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name_for_method.rs deleted file mode 100644 index 1407ef0842790..0000000000000 --- a/crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name_for_method.rs +++ /dev/null @@ -1,96 +0,0 @@ -use ruff_python_ast::{Decorator, Parameters}; - -use ruff_diagnostics::{Diagnostic, Violation}; -use ruff_macros::{derive_message_formats, violation}; -use ruff_python_semantic::analyze::function_type; -use ruff_python_semantic::Scope; -use ruff_text_size::Ranged; - -use crate::checkers::ast::Checker; - -/// ## What it does -/// Checks for instance methods that use a name other than `self` for their -/// first argument. -/// -/// ## Why is this bad? -/// [PEP 8] recommends the use of `self` as first argument for all instance -/// methods: -/// -/// > Always use self for the first argument to instance methods. -/// > -/// > If a function argument’s name clashes with a reserved keyword, it is generally better to -/// > append a single trailing underscore rather than use an abbreviation or spelling corruption. -/// > Thus `class_` is better than `clss`. (Perhaps better is to avoid such clashes by using a synonym.) -/// -/// Names can be excluded from this rule using the [`lint.pep8-naming.ignore-names`] -/// or [`lint.pep8-naming.extend-ignore-names`] configuration options. For example, -/// to allow the use of `this` as the first argument to instance methods, set -/// the [`lint.pep8-naming.extend-ignore-names`] option to `["this"]`. -/// -/// ## Example -/// ```python -/// class Example: -/// def function(cls, data): -/// ... -/// ``` -/// -/// Use instead: -/// ```python -/// class Example: -/// def function(self, data): -/// ... -/// ``` -/// -/// ## Options -/// - `lint.pep8-naming.classmethod-decorators` -/// - `lint.pep8-naming.staticmethod-decorators` -/// - `lint.pep8-naming.ignore-names` -/// - `lint.pep8-naming.extend-ignore-names` -/// -/// [PEP 8]: https://peps.python.org/pep-0008/#function-and-method-arguments -#[violation] -pub struct InvalidFirstArgumentNameForMethod; - -impl Violation for InvalidFirstArgumentNameForMethod { - #[derive_message_formats] - fn message(&self) -> String { - format!("First argument of a method should be named `self`") - } -} - -/// N805 -pub(crate) fn invalid_first_argument_name_for_method( - checker: &Checker, - scope: &Scope, - name: &str, - decorator_list: &[Decorator], - parameters: &Parameters, -) -> Option { - if !matches!( - function_type::classify( - name, - decorator_list, - scope, - checker.semantic(), - &checker.settings.pep8_naming.classmethod_decorators, - &checker.settings.pep8_naming.staticmethod_decorators, - ), - function_type::FunctionType::Method - ) { - return None; - } - let arg = parameters - .posonlyargs - .first() - .or_else(|| parameters.args.first())?; - if &arg.parameter.name == "self" { - return None; - } - if checker.settings.pep8_naming.ignore_names.matches(name) { - return None; - } - Some(Diagnostic::new( - InvalidFirstArgumentNameForMethod, - arg.parameter.range(), - )) -} diff --git a/crates/ruff_linter/src/rules/pep8_naming/rules/mod.rs b/crates/ruff_linter/src/rules/pep8_naming/rules/mod.rs index 636ae11477c0f..36d10ddd8f44b 100644 --- a/crates/ruff_linter/src/rules/pep8_naming/rules/mod.rs +++ b/crates/ruff_linter/src/rules/pep8_naming/rules/mod.rs @@ -6,8 +6,7 @@ pub(crate) use dunder_function_name::*; pub(crate) use error_suffix_on_exception_name::*; pub(crate) use invalid_argument_name::*; pub(crate) use invalid_class_name::*; -pub(crate) use invalid_first_argument_name_for_class_method::*; -pub(crate) use invalid_first_argument_name_for_method::*; +pub(crate) use invalid_first_argument_name::*; pub(crate) use invalid_function_name::*; pub(crate) use invalid_module_name::*; pub(crate) use lowercase_imported_as_non_lowercase::*; @@ -23,8 +22,7 @@ mod dunder_function_name; mod error_suffix_on_exception_name; mod invalid_argument_name; mod invalid_class_name; -mod invalid_first_argument_name_for_class_method; -mod invalid_first_argument_name_for_method; +mod invalid_first_argument_name; mod invalid_function_name; mod invalid_module_name; mod lowercase_imported_as_non_lowercase; diff --git a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__N804_N804.py.snap b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__N804_N804.py.snap index 0546db9dc8cfc..ae7c7a8bc9c07 100644 --- a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__N804_N804.py.snap +++ b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__N804_N804.py.snap @@ -1,7 +1,7 @@ --- source: crates/ruff_linter/src/rules/pep8_naming/mod.rs --- -N804.py:30:27: N804 First argument of a class method should be named `cls` +N804.py:30:27: N804 [*] First argument of a class method should be named `cls` | 28 | ... 29 | @@ -9,21 +9,147 @@ N804.py:30:27: N804 First argument of a class method should be named `cls` | ^^^^ N804 31 | ... | + = help: Rename `self` to `cls` -N804.py:38:56: N804 First argument of a class method should be named `cls` +ℹ Unsafe fix +27 27 | def __new__(cls, *args, **kwargs): +28 28 | ... +29 29 | +30 |- def __init_subclass__(self, default_name, **kwargs): + 30 |+ def __init_subclass__(cls, default_name, **kwargs): +31 31 | ... +32 32 | +33 33 | @classmethod + +N804.py:38:56: N804 [*] First argument of a class method should be named `cls` | 37 | @classmethod 38 | def bad_class_method_with_positional_only_argument(self, x, /, other): | ^^^^ N804 39 | ... | + = help: Rename `self` to `cls` + +ℹ Unsafe fix +35 35 | ... +36 36 | +37 37 | @classmethod +38 |- def bad_class_method_with_positional_only_argument(self, x, /, other): + 38 |+ def bad_class_method_with_positional_only_argument(cls, x, /, other): +39 39 | ... +40 40 | +41 41 | -N804.py:43:20: N804 First argument of a class method should be named `cls` +N804.py:43:20: N804 [*] First argument of a class method should be named `cls` | 42 | class MetaClass(ABCMeta): 43 | def bad_method(self): | ^^^^ N804 44 | pass | + = help: Rename `self` to `cls` + +ℹ Unsafe fix +40 40 | +41 41 | +42 42 | class MetaClass(ABCMeta): +43 |- def bad_method(self): + 43 |+ def bad_method(cls): +44 44 | pass +45 45 | +46 46 | def good_method(cls): + +N804.py:54:25: N804 First argument of a class method should be named `cls` + | +53 | class ClsInArgsClass(ABCMeta): +54 | def cls_as_argument(this, cls): + | ^^^^ N804 +55 | pass + | + = help: Rename `this` to `cls` + +N804.py:57:34: N804 First argument of a class method should be named `cls` + | +55 | pass +56 | +57 | def cls_as_pos_only_argument(this, cls, /): + | ^^^^ N804 +58 | pass + | + = help: Rename `this` to `cls` + +N804.py:60:33: N804 First argument of a class method should be named `cls` + | +58 | pass +59 | +60 | def cls_as_kw_only_argument(this, *, cls): + | ^^^^ N804 +61 | pass + | + = help: Rename `this` to `cls` + +N804.py:63:23: N804 First argument of a class method should be named `cls` + | +61 | pass +62 | +63 | def cls_as_varags(this, *cls): + | ^^^^ N804 +64 | pass + | + = help: Rename `this` to `cls` +N804.py:66:23: N804 First argument of a class method should be named `cls` + | +64 | pass +65 | +66 | def cls_as_kwargs(this, **cls): + | ^^^^ N804 +67 | pass + | + = help: Rename `this` to `cls` + +N804.py:70:20: N804 [*] First argument of a class method should be named `cls` + | +69 | class RenamingInMethodBodyClass(ABCMeta): +70 | def bad_method(this): + | ^^^^ N804 +71 | this = this +72 | this + | + = help: Rename `this` to `cls` + +ℹ Unsafe fix +67 67 | pass +68 68 | +69 69 | class RenamingInMethodBodyClass(ABCMeta): +70 |- def bad_method(this): +71 |- this = this +72 |- this + 70 |+ def bad_method(cls): + 71 |+ cls = cls + 72 |+ cls +73 73 | +74 74 | def bad_method(this): +75 75 | self = this + +N804.py:74:20: N804 [*] First argument of a class method should be named `cls` + | +72 | this +73 | +74 | def bad_method(this): + | ^^^^ N804 +75 | self = this + | + = help: Rename `this` to `cls` +ℹ Unsafe fix +71 71 | this = this +72 72 | this +73 73 | +74 |- def bad_method(this): +75 |- self = this + 74 |+ def bad_method(cls): + 75 |+ self = cls +76 76 | +77 77 | def func(x): +78 78 | return x diff --git a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__N805_N805.py.snap b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__N805_N805.py.snap index 3a50cb65fb51d..d0ee08834b9f9 100644 --- a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__N805_N805.py.snap +++ b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__N805_N805.py.snap @@ -1,15 +1,26 @@ --- source: crates/ruff_linter/src/rules/pep8_naming/mod.rs --- -N805.py:7:20: N805 First argument of a method should be named `self` +N805.py:7:20: N805 [*] First argument of a method should be named `self` | 6 | class Class: 7 | def bad_method(this): | ^^^^ N805 8 | pass | + = help: Rename `this` to `self` -N805.py:12:30: N805 First argument of a method should be named `self` +ℹ Unsafe fix +4 4 | +5 5 | +6 6 | class Class: +7 |- def bad_method(this): + 7 |+ def bad_method(self): +8 8 | pass +9 9 | +10 10 | if False: + +N805.py:12:30: N805 [*] First argument of a method should be named `self` | 10 | if False: 11 | @@ -17,33 +28,77 @@ N805.py:12:30: N805 First argument of a method should be named `self` | ^^^^ N805 13 | pass | + = help: Rename `this` to `self` + +ℹ Unsafe fix +9 9 | +10 10 | if False: +11 11 | +12 |- def extra_bad_method(this): + 12 |+ def extra_bad_method(self): +13 13 | pass +14 14 | +15 15 | def good_method(self): -N805.py:31:15: N805 First argument of a method should be named `self` +N805.py:31:15: N805 [*] First argument of a method should be named `self` | 30 | @pydantic.validator 31 | def lower(cls, my_field: str) -> str: | ^^^ N805 32 | pass | + = help: Rename `cls` to `self` + +ℹ Unsafe fix +28 28 | return x +29 29 | +30 30 | @pydantic.validator +31 |- def lower(cls, my_field: str) -> str: + 31 |+ def lower(self, my_field: str) -> str: +32 32 | pass +33 33 | +34 34 | @pydantic.validator("my_field") -N805.py:35:15: N805 First argument of a method should be named `self` +N805.py:35:15: N805 [*] First argument of a method should be named `self` | 34 | @pydantic.validator("my_field") 35 | def lower(cls, my_field: str) -> str: | ^^^ N805 36 | pass | + = help: Rename `cls` to `self` -N805.py:64:29: N805 First argument of a method should be named `self` +ℹ Unsafe fix +32 32 | pass +33 33 | +34 34 | @pydantic.validator("my_field") +35 |- def lower(cls, my_field: str) -> str: + 35 |+ def lower(self, my_field: str) -> str: +36 36 | pass +37 37 | +38 38 | def __init__(self): + +N805.py:64:29: N805 [*] First argument of a method should be named `self` | 62 | pass 63 | -64 | def bad_method_pos_only(this, blah, /, self, something: str): +64 | def bad_method_pos_only(this, blah, /, something: str): | ^^^^ N805 65 | pass | + = help: Rename `this` to `self` + +ℹ Unsafe fix +61 61 | def good_method_pos_only(self, blah, /, something: str): +62 62 | pass +63 63 | +64 |- def bad_method_pos_only(this, blah, /, something: str): + 64 |+ def bad_method_pos_only(self, blah, /, something: str): +65 65 | pass +66 66 | +67 67 | -N805.py:70:13: N805 First argument of a method should be named `self` +N805.py:70:13: N805 [*] First argument of a method should be named `self` | 68 | class ModelClass: 69 | @hybrid_property @@ -51,29 +106,163 @@ N805.py:70:13: N805 First argument of a method should be named `self` | ^^^ N805 71 | pass | + = help: Rename `cls` to `self` -N805.py:78:13: N805 First argument of a method should be named `self` +ℹ Unsafe fix +67 67 | +68 68 | class ModelClass: +69 69 | @hybrid_property +70 |- def bad(cls): + 70 |+ def bad(self): +71 71 | pass +72 72 | +73 73 | @bad.expression + +N805.py:78:13: N805 [*] First argument of a method should be named `self` | 77 | @bad.wtf 78 | def bad(cls): | ^^^ N805 79 | pass | + = help: Rename `cls` to `self` + +ℹ Unsafe fix +75 75 | pass +76 76 | +77 77 | @bad.wtf +78 |- def bad(cls): + 78 |+ def bad(self): +79 79 | pass +80 80 | +81 81 | @hybrid_property -N805.py:86:14: N805 First argument of a method should be named `self` +N805.py:86:14: N805 [*] First argument of a method should be named `self` | 85 | @good.expression 86 | def good(cls): | ^^^ N805 87 | pass | + = help: Rename `cls` to `self` -N805.py:94:19: N805 First argument of a method should be named `self` +ℹ Unsafe fix +83 83 | pass +84 84 | +85 85 | @good.expression +86 |- def good(cls): + 86 |+ def good(self): +87 87 | pass +88 88 | +89 89 | @good.wtf + +N805.py:94:19: N805 [*] First argument of a method should be named `self` | 93 | @foobar.thisisstatic 94 | def badstatic(foo): | ^^^ N805 95 | pass | + = help: Rename `foo` to `self` + +ℹ Unsafe fix +91 91 | pass +92 92 | +93 93 | @foobar.thisisstatic +94 |- def badstatic(foo): + 94 |+ def badstatic(self): +95 95 | pass +96 96 | +97 97 | class SelfInArgsClass: + +N805.py:98:26: N805 First argument of a method should be named `self` + | +97 | class SelfInArgsClass: +98 | def self_as_argument(this, self): + | ^^^^ N805 +99 | pass + | + = help: Rename `this` to `self` + +N805.py:101:35: N805 First argument of a method should be named `self` + | + 99 | pass +100 | +101 | def self_as_pos_only_argument(this, self, /): + | ^^^^ N805 +102 | pass + | + = help: Rename `this` to `self` + +N805.py:104:34: N805 First argument of a method should be named `self` + | +102 | pass +103 | +104 | def self_as_kw_only_argument(this, *, self): + | ^^^^ N805 +105 | pass + | + = help: Rename `this` to `self` + +N805.py:107:24: N805 First argument of a method should be named `self` + | +105 | pass +106 | +107 | def self_as_varags(this, *self): + | ^^^^ N805 +108 | pass + | + = help: Rename `this` to `self` + +N805.py:110:24: N805 First argument of a method should be named `self` + | +108 | pass +109 | +110 | def self_as_kwargs(this, **self): + | ^^^^ N805 +111 | pass + | + = help: Rename `this` to `self` + +N805.py:114:20: N805 [*] First argument of a method should be named `self` + | +113 | class RenamingInMethodBodyClass: +114 | def bad_method(this): + | ^^^^ N805 +115 | this = this +116 | this + | + = help: Rename `this` to `self` + +ℹ Unsafe fix +111 111 | pass +112 112 | +113 113 | class RenamingInMethodBodyClass: +114 |- def bad_method(this): +115 |- this = this +116 |- this + 114 |+ def bad_method(self): + 115 |+ self = self + 116 |+ self +117 117 | +118 118 | def bad_method(this): +119 119 | self = this +N805.py:118:20: N805 [*] First argument of a method should be named `self` + | +116 | this +117 | +118 | def bad_method(this): + | ^^^^ N805 +119 | self = this + | + = help: Rename `this` to `self` +ℹ Unsafe fix +115 115 | this = this +116 116 | this +117 117 | +118 |- def bad_method(this): +119 |- self = this + 118 |+ def bad_method(self): + 119 |+ self = self diff --git a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__classmethod_decorators.snap b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__classmethod_decorators.snap index 59e0688efa8ff..76d07c7ca9d1b 100644 --- a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__classmethod_decorators.snap +++ b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__classmethod_decorators.snap @@ -1,15 +1,26 @@ --- source: crates/ruff_linter/src/rules/pep8_naming/mod.rs --- -N805.py:7:20: N805 First argument of a method should be named `self` +N805.py:7:20: N805 [*] First argument of a method should be named `self` | 6 | class Class: 7 | def bad_method(this): | ^^^^ N805 8 | pass | + = help: Rename `this` to `self` -N805.py:12:30: N805 First argument of a method should be named `self` +ℹ Unsafe fix +4 4 | +5 5 | +6 6 | class Class: +7 |- def bad_method(this): + 7 |+ def bad_method(self): +8 8 | pass +9 9 | +10 10 | if False: + +N805.py:12:30: N805 [*] First argument of a method should be named `self` | 10 | if False: 11 | @@ -17,17 +28,39 @@ N805.py:12:30: N805 First argument of a method should be named `self` | ^^^^ N805 13 | pass | + = help: Rename `this` to `self` + +ℹ Unsafe fix +9 9 | +10 10 | if False: +11 11 | +12 |- def extra_bad_method(this): + 12 |+ def extra_bad_method(self): +13 13 | pass +14 14 | +15 15 | def good_method(self): -N805.py:64:29: N805 First argument of a method should be named `self` +N805.py:64:29: N805 [*] First argument of a method should be named `self` | 62 | pass 63 | -64 | def bad_method_pos_only(this, blah, /, self, something: str): +64 | def bad_method_pos_only(this, blah, /, something: str): | ^^^^ N805 65 | pass | + = help: Rename `this` to `self` -N805.py:70:13: N805 First argument of a method should be named `self` +ℹ Unsafe fix +61 61 | def good_method_pos_only(self, blah, /, something: str): +62 62 | pass +63 63 | +64 |- def bad_method_pos_only(this, blah, /, something: str): + 64 |+ def bad_method_pos_only(self, blah, /, something: str): +65 65 | pass +66 66 | +67 67 | + +N805.py:70:13: N805 [*] First argument of a method should be named `self` | 68 | class ModelClass: 69 | @hybrid_property @@ -35,21 +68,144 @@ N805.py:70:13: N805 First argument of a method should be named `self` | ^^^ N805 71 | pass | + = help: Rename `cls` to `self` + +ℹ Unsafe fix +67 67 | +68 68 | class ModelClass: +69 69 | @hybrid_property +70 |- def bad(cls): + 70 |+ def bad(self): +71 71 | pass +72 72 | +73 73 | @bad.expression -N805.py:78:13: N805 First argument of a method should be named `self` +N805.py:78:13: N805 [*] First argument of a method should be named `self` | 77 | @bad.wtf 78 | def bad(cls): | ^^^ N805 79 | pass | + = help: Rename `cls` to `self` -N805.py:94:19: N805 First argument of a method should be named `self` +ℹ Unsafe fix +75 75 | pass +76 76 | +77 77 | @bad.wtf +78 |- def bad(cls): + 78 |+ def bad(self): +79 79 | pass +80 80 | +81 81 | @hybrid_property + +N805.py:94:19: N805 [*] First argument of a method should be named `self` | 93 | @foobar.thisisstatic 94 | def badstatic(foo): | ^^^ N805 95 | pass | + = help: Rename `foo` to `self` + +ℹ Unsafe fix +91 91 | pass +92 92 | +93 93 | @foobar.thisisstatic +94 |- def badstatic(foo): + 94 |+ def badstatic(self): +95 95 | pass +96 96 | +97 97 | class SelfInArgsClass: + +N805.py:98:26: N805 First argument of a method should be named `self` + | +97 | class SelfInArgsClass: +98 | def self_as_argument(this, self): + | ^^^^ N805 +99 | pass + | + = help: Rename `this` to `self` + +N805.py:101:35: N805 First argument of a method should be named `self` + | + 99 | pass +100 | +101 | def self_as_pos_only_argument(this, self, /): + | ^^^^ N805 +102 | pass + | + = help: Rename `this` to `self` + +N805.py:104:34: N805 First argument of a method should be named `self` + | +102 | pass +103 | +104 | def self_as_kw_only_argument(this, *, self): + | ^^^^ N805 +105 | pass + | + = help: Rename `this` to `self` + +N805.py:107:24: N805 First argument of a method should be named `self` + | +105 | pass +106 | +107 | def self_as_varags(this, *self): + | ^^^^ N805 +108 | pass + | + = help: Rename `this` to `self` + +N805.py:110:24: N805 First argument of a method should be named `self` + | +108 | pass +109 | +110 | def self_as_kwargs(this, **self): + | ^^^^ N805 +111 | pass + | + = help: Rename `this` to `self` + +N805.py:114:20: N805 [*] First argument of a method should be named `self` + | +113 | class RenamingInMethodBodyClass: +114 | def bad_method(this): + | ^^^^ N805 +115 | this = this +116 | this + | + = help: Rename `this` to `self` + +ℹ Unsafe fix +111 111 | pass +112 112 | +113 113 | class RenamingInMethodBodyClass: +114 |- def bad_method(this): +115 |- this = this +116 |- this + 114 |+ def bad_method(self): + 115 |+ self = self + 116 |+ self +117 117 | +118 118 | def bad_method(this): +119 119 | self = this +N805.py:118:20: N805 [*] First argument of a method should be named `self` + | +116 | this +117 | +118 | def bad_method(this): + | ^^^^ N805 +119 | self = this + | + = help: Rename `this` to `self` +ℹ Unsafe fix +115 115 | this = this +116 116 | this +117 117 | +118 |- def bad_method(this): +119 |- self = this + 118 |+ def bad_method(self): + 119 |+ self = self diff --git a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__ignore_names_N804_N804.py.snap b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__ignore_names_N804_N804.py.snap index cc74a934cea20..4434e4b603717 100644 --- a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__ignore_names_N804_N804.py.snap +++ b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__ignore_names_N804_N804.py.snap @@ -1,23 +1,45 @@ --- source: crates/ruff_linter/src/rules/pep8_naming/mod.rs --- -N804.py:5:27: N804 First argument of a class method should be named `cls` +N804.py:5:27: N804 [*] First argument of a class method should be named `cls` | 4 | class Class: 5 | def __init_subclass__(self, default_name, **kwargs): | ^^^^ N804 6 | ... | + = help: Rename `self` to `cls` -N804.py:13:18: N804 First argument of a class method should be named `cls` +ℹ Unsafe fix +2 2 | +3 3 | +4 4 | class Class: +5 |- def __init_subclass__(self, default_name, **kwargs): + 5 |+ def __init_subclass__(cls, default_name, **kwargs): +6 6 | ... +7 7 | +8 8 | @classmethod + +N804.py:13:18: N804 [*] First argument of a class method should be named `cls` | 12 | @classmethod 13 | def stillBad(self, x, /, other): | ^^^^ N804 14 | ... | + = help: Rename `self` to `cls` + +ℹ Unsafe fix +10 10 | ... +11 11 | +12 12 | @classmethod +13 |- def stillBad(self, x, /, other): + 13 |+ def stillBad(cls, x, /, other): +14 14 | ... +15 15 | +16 16 | -N804.py:21:18: N804 First argument of a class method should be named `cls` +N804.py:21:18: N804 [*] First argument of a class method should be named `cls` | 19 | pass 20 | @@ -25,5 +47,12 @@ N804.py:21:18: N804 First argument of a class method should be named `cls` | ^^^^ N804 22 | pass | + = help: Rename `self` to `cls` - +ℹ Unsafe fix +18 18 | def badAllowed(self): +19 19 | pass +20 20 | +21 |- def stillBad(self): + 21 |+ def stillBad(cls): +22 22 | pass diff --git a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__ignore_names_N805_N805.py.snap b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__ignore_names_N805_N805.py.snap index e4844d4fe3cbe..4596583f3fe0a 100644 --- a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__ignore_names_N805_N805.py.snap +++ b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__ignore_names_N805_N805.py.snap @@ -1,7 +1,7 @@ --- source: crates/ruff_linter/src/rules/pep8_naming/mod.rs --- -N805.py:10:18: N805 First argument of a method should be named `self` +N805.py:10:18: N805 [*] First argument of a method should be named `self` | 8 | pass 9 | @@ -9,8 +9,19 @@ N805.py:10:18: N805 First argument of a method should be named `self` | ^^^^ N805 11 | pass | + = help: Rename `this` to `self` -N805.py:18:22: N805 First argument of a method should be named `self` +ℹ Unsafe fix +7 7 | def badAllowed(this): +8 8 | pass +9 9 | +10 |- def stillBad(this): + 10 |+ def stillBad(self): +11 11 | pass +12 12 | +13 13 | if False: + +N805.py:18:22: N805 [*] First argument of a method should be named `self` | 16 | pass 17 | @@ -18,22 +29,55 @@ N805.py:18:22: N805 First argument of a method should be named `self` | ^^^^ N805 19 | pass | + = help: Rename `this` to `self` + +ℹ Unsafe fix +15 15 | def badAllowed(this): +16 16 | pass +17 17 | +18 |- def stillBad(this): + 18 |+ def stillBad(self): +19 19 | pass +20 20 | +21 21 | @pydantic.validator -N805.py:26:18: N805 First argument of a method should be named `self` +N805.py:26:18: N805 [*] First argument of a method should be named `self` | 25 | @pydantic.validator 26 | def stillBad(cls, my_field: str) -> str: | ^^^ N805 27 | pass | + = help: Rename `cls` to `self` + +ℹ Unsafe fix +23 23 | pass +24 24 | +25 25 | @pydantic.validator +26 |- def stillBad(cls, my_field: str) -> str: + 26 |+ def stillBad(self, my_field: str) -> str: +27 27 | pass +28 28 | +29 29 | @pydantic.validator("my_field") -N805.py:34:18: N805 First argument of a method should be named `self` +N805.py:34:18: N805 [*] First argument of a method should be named `self` | 33 | @pydantic.validator("my_field") 34 | def stillBad(cls, my_field: str) -> str: | ^^^ N805 35 | pass | + = help: Rename `cls` to `self` + +ℹ Unsafe fix +31 31 | pass +32 32 | +33 33 | @pydantic.validator("my_field") +34 |- def stillBad(cls, my_field: str) -> str: + 34 |+ def stillBad(self, my_field: str) -> str: +35 35 | pass +36 36 | +37 37 | @classmethod N805.py:58:18: N805 First argument of a method should be named `self` | @@ -43,5 +87,4 @@ N805.py:58:18: N805 First argument of a method should be named `self` | ^^^^ N805 59 | pass | - - + = help: Rename `this` to `self` diff --git a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__staticmethod_decorators.snap b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__staticmethod_decorators.snap index 8e72fe683ac0b..b32a5581675ef 100644 --- a/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__staticmethod_decorators.snap +++ b/crates/ruff_linter/src/rules/pep8_naming/snapshots/ruff_linter__rules__pep8_naming__tests__staticmethod_decorators.snap @@ -1,15 +1,26 @@ --- source: crates/ruff_linter/src/rules/pep8_naming/mod.rs --- -N805.py:7:20: N805 First argument of a method should be named `self` +N805.py:7:20: N805 [*] First argument of a method should be named `self` | 6 | class Class: 7 | def bad_method(this): | ^^^^ N805 8 | pass | + = help: Rename `this` to `self` -N805.py:12:30: N805 First argument of a method should be named `self` +ℹ Unsafe fix +4 4 | +5 5 | +6 6 | class Class: +7 |- def bad_method(this): + 7 |+ def bad_method(self): +8 8 | pass +9 9 | +10 10 | if False: + +N805.py:12:30: N805 [*] First argument of a method should be named `self` | 10 | if False: 11 | @@ -17,33 +28,77 @@ N805.py:12:30: N805 First argument of a method should be named `self` | ^^^^ N805 13 | pass | + = help: Rename `this` to `self` + +ℹ Unsafe fix +9 9 | +10 10 | if False: +11 11 | +12 |- def extra_bad_method(this): + 12 |+ def extra_bad_method(self): +13 13 | pass +14 14 | +15 15 | def good_method(self): -N805.py:31:15: N805 First argument of a method should be named `self` +N805.py:31:15: N805 [*] First argument of a method should be named `self` | 30 | @pydantic.validator 31 | def lower(cls, my_field: str) -> str: | ^^^ N805 32 | pass | + = help: Rename `cls` to `self` + +ℹ Unsafe fix +28 28 | return x +29 29 | +30 30 | @pydantic.validator +31 |- def lower(cls, my_field: str) -> str: + 31 |+ def lower(self, my_field: str) -> str: +32 32 | pass +33 33 | +34 34 | @pydantic.validator("my_field") -N805.py:35:15: N805 First argument of a method should be named `self` +N805.py:35:15: N805 [*] First argument of a method should be named `self` | 34 | @pydantic.validator("my_field") 35 | def lower(cls, my_field: str) -> str: | ^^^ N805 36 | pass | + = help: Rename `cls` to `self` -N805.py:64:29: N805 First argument of a method should be named `self` +ℹ Unsafe fix +32 32 | pass +33 33 | +34 34 | @pydantic.validator("my_field") +35 |- def lower(cls, my_field: str) -> str: + 35 |+ def lower(self, my_field: str) -> str: +36 36 | pass +37 37 | +38 38 | def __init__(self): + +N805.py:64:29: N805 [*] First argument of a method should be named `self` | 62 | pass 63 | -64 | def bad_method_pos_only(this, blah, /, self, something: str): +64 | def bad_method_pos_only(this, blah, /, something: str): | ^^^^ N805 65 | pass | + = help: Rename `this` to `self` + +ℹ Unsafe fix +61 61 | def good_method_pos_only(self, blah, /, something: str): +62 62 | pass +63 63 | +64 |- def bad_method_pos_only(this, blah, /, something: str): + 64 |+ def bad_method_pos_only(self, blah, /, something: str): +65 65 | pass +66 66 | +67 67 | -N805.py:70:13: N805 First argument of a method should be named `self` +N805.py:70:13: N805 [*] First argument of a method should be named `self` | 68 | class ModelClass: 69 | @hybrid_property @@ -51,21 +106,144 @@ N805.py:70:13: N805 First argument of a method should be named `self` | ^^^ N805 71 | pass | + = help: Rename `cls` to `self` -N805.py:78:13: N805 First argument of a method should be named `self` +ℹ Unsafe fix +67 67 | +68 68 | class ModelClass: +69 69 | @hybrid_property +70 |- def bad(cls): + 70 |+ def bad(self): +71 71 | pass +72 72 | +73 73 | @bad.expression + +N805.py:78:13: N805 [*] First argument of a method should be named `self` | 77 | @bad.wtf 78 | def bad(cls): | ^^^ N805 79 | pass | + = help: Rename `cls` to `self` + +ℹ Unsafe fix +75 75 | pass +76 76 | +77 77 | @bad.wtf +78 |- def bad(cls): + 78 |+ def bad(self): +79 79 | pass +80 80 | +81 81 | @hybrid_property -N805.py:86:14: N805 First argument of a method should be named `self` +N805.py:86:14: N805 [*] First argument of a method should be named `self` | 85 | @good.expression 86 | def good(cls): | ^^^ N805 87 | pass | + = help: Rename `cls` to `self` + +ℹ Unsafe fix +83 83 | pass +84 84 | +85 85 | @good.expression +86 |- def good(cls): + 86 |+ def good(self): +87 87 | pass +88 88 | +89 89 | @good.wtf + +N805.py:98:26: N805 First argument of a method should be named `self` + | +97 | class SelfInArgsClass: +98 | def self_as_argument(this, self): + | ^^^^ N805 +99 | pass + | + = help: Rename `this` to `self` + +N805.py:101:35: N805 First argument of a method should be named `self` + | + 99 | pass +100 | +101 | def self_as_pos_only_argument(this, self, /): + | ^^^^ N805 +102 | pass + | + = help: Rename `this` to `self` + +N805.py:104:34: N805 First argument of a method should be named `self` + | +102 | pass +103 | +104 | def self_as_kw_only_argument(this, *, self): + | ^^^^ N805 +105 | pass + | + = help: Rename `this` to `self` + +N805.py:107:24: N805 First argument of a method should be named `self` + | +105 | pass +106 | +107 | def self_as_varags(this, *self): + | ^^^^ N805 +108 | pass + | + = help: Rename `this` to `self` + +N805.py:110:24: N805 First argument of a method should be named `self` + | +108 | pass +109 | +110 | def self_as_kwargs(this, **self): + | ^^^^ N805 +111 | pass + | + = help: Rename `this` to `self` + +N805.py:114:20: N805 [*] First argument of a method should be named `self` + | +113 | class RenamingInMethodBodyClass: +114 | def bad_method(this): + | ^^^^ N805 +115 | this = this +116 | this + | + = help: Rename `this` to `self` + +ℹ Unsafe fix +111 111 | pass +112 112 | +113 113 | class RenamingInMethodBodyClass: +114 |- def bad_method(this): +115 |- this = this +116 |- this + 114 |+ def bad_method(self): + 115 |+ self = self + 116 |+ self +117 117 | +118 118 | def bad_method(this): +119 119 | self = this +N805.py:118:20: N805 [*] First argument of a method should be named `self` + | +116 | this +117 | +118 | def bad_method(this): + | ^^^^ N805 +119 | self = this + | + = help: Rename `this` to `self` +ℹ Unsafe fix +115 115 | this = this +116 116 | this +117 117 | +118 |- def bad_method(this): +119 |- self = this + 118 |+ def bad_method(self): + 119 |+ self = self