From 739c57b31b66ea2dec846a2de52439bee1dee6e4 Mon Sep 17 00:00:00 2001 From: Aarni Koskela Date: Thu, 2 Feb 2023 22:17:54 +0200 Subject: [PATCH] Move flake8-annotations violations to rules file (#2496) --- src/registry.rs | 22 ++-- src/rules/flake8_annotations/rules.rs | 176 ++++++++++++++++++++++++-- src/violations.rs | 150 ---------------------- 3 files changed, 174 insertions(+), 174 deletions(-) diff --git a/src/registry.rs b/src/registry.rs index 9654271a80..c1d54c999f 100644 --- a/src/registry.rs +++ b/src/registry.rs @@ -175,17 +175,17 @@ ruff_macros::define_rule_mapping!( Q002 => rules::flake8_quotes::rules::BadQuotesDocstring, Q003 => rules::flake8_quotes::rules::AvoidQuoteEscape, // flake8-annotations - ANN001 => violations::MissingTypeFunctionArgument, - ANN002 => violations::MissingTypeArgs, - ANN003 => violations::MissingTypeKwargs, - ANN101 => violations::MissingTypeSelf, - ANN102 => violations::MissingTypeCls, - ANN201 => violations::MissingReturnTypePublicFunction, - ANN202 => violations::MissingReturnTypePrivateFunction, - ANN204 => violations::MissingReturnTypeSpecialMethod, - ANN205 => violations::MissingReturnTypeStaticMethod, - ANN206 => violations::MissingReturnTypeClassMethod, - ANN401 => violations::DynamicallyTypedExpression, + ANN001 => rules::flake8_annotations::rules::MissingTypeFunctionArgument, + ANN002 => rules::flake8_annotations::rules::MissingTypeArgs, + ANN003 => rules::flake8_annotations::rules::MissingTypeKwargs, + ANN101 => rules::flake8_annotations::rules::MissingTypeSelf, + ANN102 => rules::flake8_annotations::rules::MissingTypeCls, + ANN201 => rules::flake8_annotations::rules::MissingReturnTypePublicFunction, + ANN202 => rules::flake8_annotations::rules::MissingReturnTypePrivateFunction, + ANN204 => rules::flake8_annotations::rules::MissingReturnTypeSpecialMethod, + ANN205 => rules::flake8_annotations::rules::MissingReturnTypeStaticMethod, + ANN206 => rules::flake8_annotations::rules::MissingReturnTypeClassMethod, + ANN401 => rules::flake8_annotations::rules::DynamicallyTypedExpression, // flake8-2020 YTT101 => violations::SysVersionSlice3Referenced, YTT102 => violations::SysVersion2Referenced, diff --git a/src/rules/flake8_annotations/rules.rs b/src/rules/flake8_annotations/rules.rs index ebd45d5426..764d6c22dc 100644 --- a/src/rules/flake8_annotations/rules.rs +++ b/src/rules/flake8_annotations/rules.rs @@ -7,10 +7,160 @@ use crate::ast::types::Range; use crate::ast::visitor::Visitor; use crate::ast::{cast, helpers, visitor}; use crate::checkers::ast::Checker; +use crate::define_violation; use crate::docstrings::definition::{Definition, DefinitionKind}; use crate::registry::{Diagnostic, Rule}; +use crate::violation::{AlwaysAutofixableViolation, Violation}; +use crate::visibility; use crate::visibility::Visibility; -use crate::{violations, visibility}; +use ruff_macros::derive_message_formats; + +define_violation!( + pub struct MissingTypeFunctionArgument { + pub name: String, + } +); +impl Violation for MissingTypeFunctionArgument { + #[derive_message_formats] + fn message(&self) -> String { + let MissingTypeFunctionArgument { name } = self; + format!("Missing type annotation for function argument `{name}`") + } +} + +define_violation!( + pub struct MissingTypeArgs { + pub name: String, + } +); +impl Violation for MissingTypeArgs { + #[derive_message_formats] + fn message(&self) -> String { + let MissingTypeArgs { name } = self; + format!("Missing type annotation for `*{name}`") + } +} + +define_violation!( + pub struct MissingTypeKwargs { + pub name: String, + } +); +impl Violation for MissingTypeKwargs { + #[derive_message_formats] + fn message(&self) -> String { + let MissingTypeKwargs { name } = self; + format!("Missing type annotation for `**{name}`") + } +} + +define_violation!( + pub struct MissingTypeSelf { + pub name: String, + } +); +impl Violation for MissingTypeSelf { + #[derive_message_formats] + fn message(&self) -> String { + let MissingTypeSelf { name } = self; + format!("Missing type annotation for `{name}` in method") + } +} + +define_violation!( + pub struct MissingTypeCls { + pub name: String, + } +); +impl Violation for MissingTypeCls { + #[derive_message_formats] + fn message(&self) -> String { + let MissingTypeCls { name } = self; + format!("Missing type annotation for `{name}` in classmethod") + } +} + +define_violation!( + pub struct MissingReturnTypePublicFunction { + pub name: String, + } +); +impl Violation for MissingReturnTypePublicFunction { + #[derive_message_formats] + fn message(&self) -> String { + let MissingReturnTypePublicFunction { name } = self; + format!("Missing return type annotation for public function `{name}`") + } +} + +define_violation!( + pub struct MissingReturnTypePrivateFunction { + pub name: String, + } +); +impl Violation for MissingReturnTypePrivateFunction { + #[derive_message_formats] + fn message(&self) -> String { + let MissingReturnTypePrivateFunction { name } = self; + format!("Missing return type annotation for private function `{name}`") + } +} + +define_violation!( + pub struct MissingReturnTypeSpecialMethod { + pub name: String, + } +); +impl AlwaysAutofixableViolation for MissingReturnTypeSpecialMethod { + #[derive_message_formats] + fn message(&self) -> String { + let MissingReturnTypeSpecialMethod { name } = self; + format!("Missing return type annotation for special method `{name}`") + } + + fn autofix_title(&self) -> String { + "Add `None` return type".to_string() + } +} + +define_violation!( + pub struct MissingReturnTypeStaticMethod { + pub name: String, + } +); +impl Violation for MissingReturnTypeStaticMethod { + #[derive_message_formats] + fn message(&self) -> String { + let MissingReturnTypeStaticMethod { name } = self; + format!("Missing return type annotation for staticmethod `{name}`") + } +} + +define_violation!( + pub struct MissingReturnTypeClassMethod { + pub name: String, + } +); +impl Violation for MissingReturnTypeClassMethod { + #[derive_message_formats] + fn message(&self) -> String { + let MissingReturnTypeClassMethod { name } = self; + format!("Missing return type annotation for classmethod `{name}`") + } +} + +define_violation!( + pub struct DynamicallyTypedExpression { + pub name: String, + } +); +impl Violation for DynamicallyTypedExpression { + #[derive_message_formats] + fn message(&self) -> String { + let DynamicallyTypedExpression { name } = self; + format!("Dynamically typed expressions (typing.Any) are disallowed in `{name}`") + } +} #[derive(Default)] struct ReturnStatementVisitor<'a> { @@ -58,7 +208,7 @@ where { if checker.match_typing_expr(annotation, "Any") { checker.diagnostics.push(Diagnostic::new( - violations::DynamicallyTypedExpression { name: func() }, + DynamicallyTypedExpression { name: func() }, Range::from_located(annotation), )); }; @@ -115,7 +265,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V .enabled(&Rule::MissingTypeFunctionArgument) { checker.diagnostics.push(Diagnostic::new( - violations::MissingTypeFunctionArgument { + MissingTypeFunctionArgument { name: arg.node.arg.to_string(), }, Range::from_located(arg), @@ -145,7 +295,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V { if checker.settings.rules.enabled(&Rule::MissingTypeArgs) { checker.diagnostics.push(Diagnostic::new( - violations::MissingTypeArgs { + MissingTypeArgs { name: arg.node.arg.to_string(), }, Range::from_located(arg), @@ -175,7 +325,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V { if checker.settings.rules.enabled(&Rule::MissingTypeKwargs) { checker.diagnostics.push(Diagnostic::new( - violations::MissingTypeKwargs { + MissingTypeKwargs { name: arg.node.arg.to_string(), }, Range::from_located(arg), @@ -192,7 +342,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V if visibility::is_classmethod(checker, cast::decorator_list(stmt)) { if checker.settings.rules.enabled(&Rule::MissingTypeCls) { checker.diagnostics.push(Diagnostic::new( - violations::MissingTypeCls { + MissingTypeCls { name: arg.node.arg.to_string(), }, Range::from_located(arg), @@ -201,7 +351,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V } else { if checker.settings.rules.enabled(&Rule::MissingTypeSelf) { checker.diagnostics.push(Diagnostic::new( - violations::MissingTypeSelf { + MissingTypeSelf { name: arg.node.arg.to_string(), }, Range::from_located(arg), @@ -237,7 +387,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V .enabled(&Rule::MissingReturnTypeClassMethod) { checker.diagnostics.push(Diagnostic::new( - violations::MissingReturnTypeClassMethod { + MissingReturnTypeClassMethod { name: name.to_string(), }, helpers::identifier_range(stmt, checker.locator), @@ -252,7 +402,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V .enabled(&Rule::MissingReturnTypeStaticMethod) { checker.diagnostics.push(Diagnostic::new( - violations::MissingReturnTypeStaticMethod { + MissingReturnTypeStaticMethod { name: name.to_string(), }, helpers::identifier_range(stmt, checker.locator), @@ -270,7 +420,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V && has_any_typed_arg) { let mut diagnostic = Diagnostic::new( - violations::MissingReturnTypeSpecialMethod { + MissingReturnTypeSpecialMethod { name: name.to_string(), }, helpers::identifier_range(stmt, checker.locator), @@ -293,7 +443,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V .enabled(&Rule::MissingReturnTypeSpecialMethod) { checker.diagnostics.push(Diagnostic::new( - violations::MissingReturnTypeSpecialMethod { + MissingReturnTypeSpecialMethod { name: name.to_string(), }, helpers::identifier_range(stmt, checker.locator), @@ -308,7 +458,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V .enabled(&Rule::MissingReturnTypePublicFunction) { checker.diagnostics.push(Diagnostic::new( - violations::MissingReturnTypePublicFunction { + MissingReturnTypePublicFunction { name: name.to_string(), }, helpers::identifier_range(stmt, checker.locator), @@ -322,7 +472,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V .enabled(&Rule::MissingReturnTypePrivateFunction) { checker.diagnostics.push(Diagnostic::new( - violations::MissingReturnTypePrivateFunction { + MissingReturnTypePrivateFunction { name: name.to_string(), }, helpers::identifier_range(stmt, checker.locator), diff --git a/src/violations.rs b/src/violations.rs index 430439218f..b542d5ce3c 100644 --- a/src/violations.rs +++ b/src/violations.rs @@ -106,156 +106,6 @@ impl AlwaysAutofixableViolation for PPrintFound { "Remove `pprint`".to_string() } } - -// flake8-annotations - -define_violation!( - pub struct MissingTypeFunctionArgument { - pub name: String, - } -); -impl Violation for MissingTypeFunctionArgument { - #[derive_message_formats] - fn message(&self) -> String { - let MissingTypeFunctionArgument { name } = self; - format!("Missing type annotation for function argument `{name}`") - } -} - -define_violation!( - pub struct MissingTypeArgs { - pub name: String, - } -); -impl Violation for MissingTypeArgs { - #[derive_message_formats] - fn message(&self) -> String { - let MissingTypeArgs { name } = self; - format!("Missing type annotation for `*{name}`") - } -} - -define_violation!( - pub struct MissingTypeKwargs { - pub name: String, - } -); -impl Violation for MissingTypeKwargs { - #[derive_message_formats] - fn message(&self) -> String { - let MissingTypeKwargs { name } = self; - format!("Missing type annotation for `**{name}`") - } -} - -define_violation!( - pub struct MissingTypeSelf { - pub name: String, - } -); -impl Violation for MissingTypeSelf { - #[derive_message_formats] - fn message(&self) -> String { - let MissingTypeSelf { name } = self; - format!("Missing type annotation for `{name}` in method") - } -} - -define_violation!( - pub struct MissingTypeCls { - pub name: String, - } -); -impl Violation for MissingTypeCls { - #[derive_message_formats] - fn message(&self) -> String { - let MissingTypeCls { name } = self; - format!("Missing type annotation for `{name}` in classmethod") - } -} - -define_violation!( - pub struct MissingReturnTypePublicFunction { - pub name: String, - } -); -impl Violation for MissingReturnTypePublicFunction { - #[derive_message_formats] - fn message(&self) -> String { - let MissingReturnTypePublicFunction { name } = self; - format!("Missing return type annotation for public function `{name}`") - } -} - -define_violation!( - pub struct MissingReturnTypePrivateFunction { - pub name: String, - } -); -impl Violation for MissingReturnTypePrivateFunction { - #[derive_message_formats] - fn message(&self) -> String { - let MissingReturnTypePrivateFunction { name } = self; - format!("Missing return type annotation for private function `{name}`") - } -} - -define_violation!( - pub struct MissingReturnTypeSpecialMethod { - pub name: String, - } -); -impl AlwaysAutofixableViolation for MissingReturnTypeSpecialMethod { - #[derive_message_formats] - fn message(&self) -> String { - let MissingReturnTypeSpecialMethod { name } = self; - format!("Missing return type annotation for special method `{name}`") - } - - fn autofix_title(&self) -> String { - "Add `None` return type".to_string() - } -} - -define_violation!( - pub struct MissingReturnTypeStaticMethod { - pub name: String, - } -); -impl Violation for MissingReturnTypeStaticMethod { - #[derive_message_formats] - fn message(&self) -> String { - let MissingReturnTypeStaticMethod { name } = self; - format!("Missing return type annotation for staticmethod `{name}`") - } -} - -define_violation!( - pub struct MissingReturnTypeClassMethod { - pub name: String, - } -); -impl Violation for MissingReturnTypeClassMethod { - #[derive_message_formats] - fn message(&self) -> String { - let MissingReturnTypeClassMethod { name } = self; - format!("Missing return type annotation for classmethod `{name}`") - } -} - -define_violation!( - pub struct DynamicallyTypedExpression { - pub name: String, - } -); -impl Violation for DynamicallyTypedExpression { - #[derive_message_formats] - fn message(&self) -> String { - let DynamicallyTypedExpression { name } = self; - format!("Dynamically typed expressions (typing.Any) are disallowed in `{name}`") - } -} - // flake8-2020 define_violation!(