From e9fc63331a063910a8bbb119ddf95a3ba181c72e Mon Sep 17 00:00:00 2001 From: Charlie Marsh Date: Sun, 21 May 2023 14:52:39 -0400 Subject: [PATCH] Reverts --- crates/ruff/src/checkers/ast/mod.rs | 34 ++++++++++--------- crates/ruff/src/checkers/ast/traits.rs | 14 ++++---- crates/ruff/src/lib.rs | 1 - .../rules/locals_in_render_function.rs | 4 +-- .../ruff/src/rules/flake8_django/rules/mod.rs | 4 +-- ...convert_named_tuple_functional_to_class.rs | 1 + .../convert_typed_dict_functional_to_class.rs | 1 + .../rules/deprecated_unittest_alias.rs | 4 +-- crates/ruff/src/rules/pyupgrade/rules/mod.rs | 24 ++++++------- .../rules/pyupgrade/rules/native_literals.rs | 4 +-- .../src/rules/pyupgrade/rules/open_alias.rs | 4 +-- .../rules/pyupgrade/rules/os_error_alias.rs | 4 +-- .../pyupgrade/rules/redundant_open_modes.rs | 4 +-- .../pyupgrade/rules/replace_stdout_stderr.rs | 4 +-- .../rules/replace_universal_newlines.rs | 4 +-- .../rules/super_call_with_parameters.rs | 4 +-- .../pyupgrade/rules/type_of_primitive.rs | 4 +-- .../rules/unnecessary_encode_utf8.rs | 4 +-- .../pyupgrade/rules/use_pep604_annotation.rs | 1 + .../pyupgrade/rules/use_pep604_isinstance.rs | 9 +++-- crates/ruff_benchmark/benches/linter.rs | 18 +++++----- foo.py | 8 ----- 22 files changed, 78 insertions(+), 81 deletions(-) delete mode 100644 foo.py diff --git a/crates/ruff/src/checkers/ast/mod.rs b/crates/ruff/src/checkers/ast/mod.rs index 2f03169693..942d6164d6 100644 --- a/crates/ruff/src/checkers/ast/mod.rs +++ b/crates/ruff/src/checkers/ast/mod.rs @@ -35,7 +35,7 @@ use ruff_python_stdlib::builtins::{BUILTINS, MAGIC_GLOBALS}; use ruff_python_stdlib::path::is_python_stub_file; use crate::checkers::ast::deferred::Deferred; -use crate::checkers::ast::traits::RegisteredAstRule; +use crate::checkers::ast::traits::RegisteredRule; use crate::docstrings::extraction::ExtractionTarget; use crate::docstrings::Docstring; use crate::fs::relativize_path; @@ -80,7 +80,7 @@ pub(crate) struct Checker<'a> { // Check-specific state. pub(crate) flake8_bugbear_seen: Vec<&'a Expr>, // Dispatchers - call_rules: Vec>, + call_rules: Vec>, } pub(crate) struct RuleContext<'a> { @@ -123,18 +123,18 @@ impl<'a> Checker<'a> { deletions: FxHashSet::default(), flake8_bugbear_seen: Vec::default(), call_rules: [ - RegisteredAstRule::new::(), - RegisteredAstRule::new::(), - RegisteredAstRule::new::(), - RegisteredAstRule::new::(), - RegisteredAstRule::new::(), - RegisteredAstRule::new::(), - RegisteredAstRule::new::(), - RegisteredAstRule::new::(), - RegisteredAstRule::new::(), - RegisteredAstRule::new::(), - RegisteredAstRule::new::(), - RegisteredAstRule::new::(), + RegisteredRule::new::(), + RegisteredRule::new::(), + RegisteredRule::new::(), + RegisteredRule::new::(), + RegisteredRule::new::(), + RegisteredRule::new::(), + RegisteredRule::new::(), + RegisteredRule::new::(), + RegisteredRule::new::(), + RegisteredRule::new::(), + RegisteredRule::new::(), + RegisteredRule::new::(), ] .into_iter() .filter(|rule| rule.enabled(settings)) @@ -143,6 +143,7 @@ impl<'a> Checker<'a> { } } +// TODO(charlie): Remove these methods from `Checker`, use the immutable `RuleContext` everywhere. impl<'a> RuleContext<'a> { /// Return `true` if a patch should be generated under the given autofix /// `Mode`. @@ -2632,7 +2633,7 @@ where pandas_vet::rules::attr(self, attr, value, expr); } Expr::Call(call) => { - let immutable_checker = RuleContext { + let context = RuleContext { settings: self.settings, locator: self.locator, stylist: self.stylist, @@ -2640,9 +2641,10 @@ where ctx: &self.ctx, }; for rule in &self.call_rules { - rule.run(&mut self.diagnostics, &immutable_checker, call); + rule.run(&mut self.diagnostics, &context, call); } + // Destructure for the rest of the rules, for now. let ast::ExprCall { func, args, diff --git a/crates/ruff/src/checkers/ast/traits.rs b/crates/ruff/src/checkers/ast/traits.rs index 022f9a92bf..1c12140594 100644 --- a/crates/ruff/src/checkers/ast/traits.rs +++ b/crates/ruff/src/checkers/ast/traits.rs @@ -5,7 +5,7 @@ use crate::registry::Rule; use crate::settings::Settings; /// Trait for a lint rule that can be run on an AST node of type `T`. -pub(crate) trait AstAnalyzer: Sized { +pub(crate) trait Analyzer: Sized { /// The [`Rule`] that this analyzer implements. fn rule() -> Rule; @@ -14,13 +14,13 @@ pub(crate) trait AstAnalyzer: Sized { } /// Internal representation of a single [`Rule`] that can be run on an AST node of type `T`. -pub(super) struct RegisteredAstRule { +pub(super) struct RegisteredRule { rule: Rule, - run: Run, + run: Executor, } -impl RegisteredAstRule { - pub(super) fn new + 'static>() -> Self { +impl RegisteredRule { + pub(super) fn new + 'static>() -> Self { Self { rule: R::rule(), run: R::run, @@ -38,5 +38,5 @@ impl RegisteredAstRule { } } -/// Executor for an [`AstAnalyzer`] as a generic function pointer. -type Run = fn(diagnostics: &mut Vec, checker: &RuleContext, node: &T); +/// Executor for an [`Analyzer`] as a generic function pointer. +type Executor = fn(diagnostics: &mut Vec, checker: &RuleContext, node: &T); diff --git a/crates/ruff/src/lib.rs b/crates/ruff/src/lib.rs index e7b13e3bea..e359ffdbd0 100644 --- a/crates/ruff/src/lib.rs +++ b/crates/ruff/src/lib.rs @@ -5,7 +5,6 @@ //! //! [Ruff]: https://github.com/charliermarsh/ruff -pub use codes::{Pyupgrade, RuleCodePrefix}; pub use ruff_python_ast::source_code::round_trip; pub use rule_selector::RuleSelector; pub use rules::pycodestyle::rules::IOError; diff --git a/crates/ruff/src/rules/flake8_django/rules/locals_in_render_function.rs b/crates/ruff/src/rules/flake8_django/rules/locals_in_render_function.rs index efbbf21f54..5d79b4cd8b 100644 --- a/crates/ruff/src/rules/flake8_django/rules/locals_in_render_function.rs +++ b/crates/ruff/src/rules/flake8_django/rules/locals_in_render_function.rs @@ -3,7 +3,7 @@ use rustpython_parser::ast::{self, Expr, Ranged}; use ruff_diagnostics::{Diagnostic, Violation}; use ruff_macros::{derive_message_formats, violation}; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::RuleContext; use crate::registry::Rule; @@ -45,7 +45,7 @@ impl Violation for DjangoLocalsInRenderFunction { } /// DJ003 -impl AstAnalyzer for DjangoLocalsInRenderFunction { +impl Analyzer for DjangoLocalsInRenderFunction { fn rule() -> Rule { Rule::DjangoLocalsInRenderFunction } diff --git a/crates/ruff/src/rules/flake8_django/rules/mod.rs b/crates/ruff/src/rules/flake8_django/rules/mod.rs index fa28c7a6d7..072214376a 100644 --- a/crates/ruff/src/rules/flake8_django/rules/mod.rs +++ b/crates/ruff/src/rules/flake8_django/rules/mod.rs @@ -1,8 +1,6 @@ pub(crate) use all_with_model_form::{all_with_model_form, DjangoAllWithModelForm}; pub(crate) use exclude_with_model_form::{exclude_with_model_form, DjangoExcludeWithModelForm}; -pub(crate) use locals_in_render_function::{ - DjangoLocalsInRenderFunction, -}; +pub(crate) use locals_in_render_function::DjangoLocalsInRenderFunction; pub(crate) use model_without_dunder_str::{model_without_dunder_str, DjangoModelWithoutDunderStr}; pub(crate) use non_leading_receiver_decorator::{ non_leading_receiver_decorator, DjangoNonLeadingReceiverDecorator, diff --git a/crates/ruff/src/rules/pyupgrade/rules/convert_named_tuple_functional_to_class.rs b/crates/ruff/src/rules/pyupgrade/rules/convert_named_tuple_functional_to_class.rs index 68af4a45aa..0143fa4a2e 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/convert_named_tuple_functional_to_class.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/convert_named_tuple_functional_to_class.rs @@ -5,6 +5,7 @@ use rustpython_parser::ast::{self, Constant, Expr, ExprContext, Keyword, Ranged, use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation}; use ruff_macros::{derive_message_formats, violation}; + use ruff_python_ast::source_code::Generator; use ruff_python_stdlib::identifiers::is_identifier; diff --git a/crates/ruff/src/rules/pyupgrade/rules/convert_typed_dict_functional_to_class.rs b/crates/ruff/src/rules/pyupgrade/rules/convert_typed_dict_functional_to_class.rs index 2c8d7f0f6a..7992137612 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/convert_typed_dict_functional_to_class.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/convert_typed_dict_functional_to_class.rs @@ -5,6 +5,7 @@ use rustpython_parser::ast::{self, Constant, Expr, ExprContext, Keyword, Ranged, use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation}; use ruff_macros::{derive_message_formats, violation}; + use ruff_python_ast::source_code::Generator; use ruff_python_stdlib::identifiers::is_identifier; diff --git a/crates/ruff/src/rules/pyupgrade/rules/deprecated_unittest_alias.rs b/crates/ruff/src/rules/pyupgrade/rules/deprecated_unittest_alias.rs index e620550c23..8ecd1dcf14 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/deprecated_unittest_alias.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/deprecated_unittest_alias.rs @@ -5,7 +5,7 @@ use rustpython_parser::ast::{self, Expr}; use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix}; use ruff_macros::{derive_message_formats, violation}; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::RuleContext; use crate::registry::{AsRule, Rule}; @@ -28,7 +28,7 @@ impl AlwaysAutofixableViolation for DeprecatedUnittestAlias { } } -impl AstAnalyzer for DeprecatedUnittestAlias { +impl Analyzer for DeprecatedUnittestAlias { fn rule() -> Rule { Rule::DeprecatedUnittestAlias } diff --git a/crates/ruff/src/rules/pyupgrade/rules/mod.rs b/crates/ruff/src/rules/pyupgrade/rules/mod.rs index 7b5eb7813d..313b66f739 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/mod.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/mod.rs @@ -10,7 +10,7 @@ pub(crate) use deprecated_import::{deprecated_import, DeprecatedImport}; pub(crate) use deprecated_mock_import::{ deprecated_mock_attribute, deprecated_mock_import, DeprecatedMockImport, }; -pub(crate) use deprecated_unittest_alias::{DeprecatedUnittestAlias}; +pub(crate) use deprecated_unittest_alias::DeprecatedUnittestAlias; pub(crate) use extraneous_parentheses::{extraneous_parentheses, ExtraneousParentheses}; pub(crate) use f_strings::{f_strings, FString}; pub(crate) use format_literals::{format_literals, FormatLiterals}; @@ -20,31 +20,29 @@ pub(crate) use lru_cache_with_maxsize_none::{ pub(crate) use lru_cache_without_parameters::{ lru_cache_without_parameters, LRUCacheWithoutParameters, }; -pub(crate) use native_literals::{NativeLiterals}; -pub(crate) use open_alias::{OpenAlias}; -pub(crate) use os_error_alias::{ - os_error_alias_handlers, os_error_alias_raise, OSErrorAlias, -}; +pub(crate) use native_literals::NativeLiterals; +pub(crate) use open_alias::OpenAlias; +pub(crate) use os_error_alias::{os_error_alias_handlers, os_error_alias_raise, OSErrorAlias}; pub(crate) use outdated_version_block::{outdated_version_block, OutdatedVersionBlock}; pub(crate) use printf_string_formatting::{printf_string_formatting, PrintfStringFormatting}; pub(crate) use quoted_annotation::{quoted_annotation, QuotedAnnotation}; -pub(crate) use redundant_open_modes::{RedundantOpenModes}; -pub(crate) use replace_stdout_stderr::{ReplaceStdoutStderr}; -pub(crate) use replace_universal_newlines::{ReplaceUniversalNewlines}; -pub(crate) use super_call_with_parameters::{SuperCallWithParameters}; -pub(crate) use type_of_primitive::{TypeOfPrimitive}; +pub(crate) use redundant_open_modes::RedundantOpenModes; +pub(crate) use replace_stdout_stderr::ReplaceStdoutStderr; +pub(crate) use replace_universal_newlines::ReplaceUniversalNewlines; +pub(crate) use super_call_with_parameters::SuperCallWithParameters; +pub(crate) use type_of_primitive::TypeOfPrimitive; pub(crate) use typing_text_str_alias::{typing_text_str_alias, TypingTextStrAlias}; pub(crate) use unicode_kind_prefix::{unicode_kind_prefix, UnicodeKindPrefix}; pub(crate) use unnecessary_builtin_import::{unnecessary_builtin_import, UnnecessaryBuiltinImport}; pub(crate) use unnecessary_coding_comment::{unnecessary_coding_comment, UTF8EncodingDeclaration}; -pub(crate) use unnecessary_encode_utf8::{UnnecessaryEncodeUTF8}; +pub(crate) use unnecessary_encode_utf8::UnnecessaryEncodeUTF8; pub(crate) use unnecessary_future_import::{unnecessary_future_import, UnnecessaryFutureImport}; pub(crate) use unpacked_list_comprehension::{ unpacked_list_comprehension, UnpackedListComprehension, }; pub(crate) use use_pep585_annotation::{use_pep585_annotation, NonPEP585Annotation}; pub(crate) use use_pep604_annotation::{use_pep604_annotation, NonPEP604Annotation}; -pub(crate) use use_pep604_isinstance::{NonPEP604Isinstance}; +pub(crate) use use_pep604_isinstance::NonPEP604Isinstance; pub(crate) use useless_metaclass_type::{useless_metaclass_type, UselessMetaclassType}; pub(crate) use useless_object_inheritance::{useless_object_inheritance, UselessObjectInheritance}; pub(crate) use yield_in_for_loop::{yield_in_for_loop, YieldInForLoop}; diff --git a/crates/ruff/src/rules/pyupgrade/rules/native_literals.rs b/crates/ruff/src/rules/pyupgrade/rules/native_literals.rs index 59e6472496..e9424b5a42 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/native_literals.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/native_literals.rs @@ -6,7 +6,7 @@ use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix}; use ruff_macros::{derive_message_formats, violation}; use ruff_python_ast::str::is_implicit_concatenation; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::RuleContext; use crate::registry::{AsRule, Rule}; @@ -43,7 +43,7 @@ impl AlwaysAutofixableViolation for NativeLiterals { } } -impl AstAnalyzer for NativeLiterals { +impl Analyzer for NativeLiterals { fn rule() -> Rule { Rule::NativeLiterals } diff --git a/crates/ruff/src/rules/pyupgrade/rules/open_alias.rs b/crates/ruff/src/rules/pyupgrade/rules/open_alias.rs index 05696ea9b3..7145d0d376 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/open_alias.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/open_alias.rs @@ -3,7 +3,7 @@ use rustpython_parser::ast::{self, Ranged}; use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation}; use ruff_macros::{derive_message_formats, violation}; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::RuleContext; use crate::registry::{AsRule, Rule}; @@ -23,7 +23,7 @@ impl Violation for OpenAlias { } } -impl AstAnalyzer for OpenAlias { +impl Analyzer for OpenAlias { fn rule() -> Rule { Rule::OpenAlias } diff --git a/crates/ruff/src/rules/pyupgrade/rules/os_error_alias.rs b/crates/ruff/src/rules/pyupgrade/rules/os_error_alias.rs index 4fed54057b..70f86606f6 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/os_error_alias.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/os_error_alias.rs @@ -6,7 +6,7 @@ use ruff_macros::{derive_message_formats, violation}; use ruff_python_ast::call_path::compose_call_path; use ruff_python_semantic::context::Context; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::{Checker, RuleContext}; use crate::registry::{AsRule, Rule}; @@ -30,7 +30,7 @@ impl AlwaysAutofixableViolation for OSErrorAlias { } } -impl AstAnalyzer for OSErrorAlias { +impl Analyzer for OSErrorAlias { fn rule() -> Rule { Rule::OSErrorAlias } diff --git a/crates/ruff/src/rules/pyupgrade/rules/redundant_open_modes.rs b/crates/ruff/src/rules/pyupgrade/rules/redundant_open_modes.rs index 7a45c9b5fe..d8a779ee05 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/redundant_open_modes.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/redundant_open_modes.rs @@ -10,7 +10,7 @@ use ruff_macros::{derive_message_formats, violation}; use ruff_python_ast::helpers::find_keyword; use ruff_python_ast::source_code::Locator; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::RuleContext; use crate::registry::Rule; @@ -42,7 +42,7 @@ impl AlwaysAutofixableViolation for RedundantOpenModes { } } -impl AstAnalyzer for RedundantOpenModes { +impl Analyzer for RedundantOpenModes { fn rule() -> Rule { Rule::RedundantOpenModes } diff --git a/crates/ruff/src/rules/pyupgrade/rules/replace_stdout_stderr.rs b/crates/ruff/src/rules/pyupgrade/rules/replace_stdout_stderr.rs index 937d5a561d..7e612ca642 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/replace_stdout_stderr.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/replace_stdout_stderr.rs @@ -7,7 +7,7 @@ use ruff_python_ast::helpers::find_keyword; use ruff_python_ast::source_code::Locator; use crate::autofix::actions::remove_argument; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::RuleContext; use crate::registry::{AsRule, Rule}; @@ -25,7 +25,7 @@ impl AlwaysAutofixableViolation for ReplaceStdoutStderr { } } -impl AstAnalyzer for ReplaceStdoutStderr { +impl Analyzer for ReplaceStdoutStderr { fn rule() -> Rule { Rule::ReplaceStdoutStderr } diff --git a/crates/ruff/src/rules/pyupgrade/rules/replace_universal_newlines.rs b/crates/ruff/src/rules/pyupgrade/rules/replace_universal_newlines.rs index 7d8dbfcd77..4e8ca40ea9 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/replace_universal_newlines.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/replace_universal_newlines.rs @@ -5,7 +5,7 @@ use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix}; use ruff_macros::{derive_message_formats, violation}; use ruff_python_ast::helpers::find_keyword; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::RuleContext; use crate::registry::{AsRule, Rule}; @@ -23,7 +23,7 @@ impl AlwaysAutofixableViolation for ReplaceUniversalNewlines { } } -impl AstAnalyzer for ReplaceUniversalNewlines { +impl Analyzer for ReplaceUniversalNewlines { fn rule() -> Rule { Rule::ReplaceUniversalNewlines } diff --git a/crates/ruff/src/rules/pyupgrade/rules/super_call_with_parameters.rs b/crates/ruff/src/rules/pyupgrade/rules/super_call_with_parameters.rs index 5244ff246c..b370bd77c5 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/super_call_with_parameters.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/super_call_with_parameters.rs @@ -4,7 +4,7 @@ use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix}; use ruff_macros::{derive_message_formats, violation}; use ruff_python_semantic::scope::ScopeKind; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::RuleContext; use crate::registry::{AsRule, Rule}; use crate::rules::pyupgrade::fixes; @@ -23,7 +23,7 @@ impl AlwaysAutofixableViolation for SuperCallWithParameters { } } -impl AstAnalyzer for SuperCallWithParameters { +impl Analyzer for SuperCallWithParameters { fn rule() -> Rule { Rule::SuperCallWithParameters } diff --git a/crates/ruff/src/rules/pyupgrade/rules/type_of_primitive.rs b/crates/ruff/src/rules/pyupgrade/rules/type_of_primitive.rs index fb0767dd32..f1552686a9 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/type_of_primitive.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/type_of_primitive.rs @@ -3,7 +3,7 @@ use rustpython_parser::ast::{self, Expr}; use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix}; use ruff_macros::{derive_message_formats, violation}; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::RuleContext; use crate::registry::{AsRule, Rule}; @@ -27,7 +27,7 @@ impl AlwaysAutofixableViolation for TypeOfPrimitive { } } -impl AstAnalyzer for TypeOfPrimitive { +impl Analyzer for TypeOfPrimitive { fn rule() -> Rule { Rule::TypeOfPrimitive } diff --git a/crates/ruff/src/rules/pyupgrade/rules/unnecessary_encode_utf8.rs b/crates/ruff/src/rules/pyupgrade/rules/unnecessary_encode_utf8.rs index 4dd4617b9a..c5dd15925a 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/unnecessary_encode_utf8.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/unnecessary_encode_utf8.rs @@ -7,7 +7,7 @@ use ruff_macros::{derive_message_formats, violation}; use ruff_python_ast::source_code::Locator; use crate::autofix::actions::remove_argument; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::RuleContext; use crate::registry::Rule; @@ -36,7 +36,7 @@ impl AlwaysAutofixableViolation for UnnecessaryEncodeUTF8 { } } -impl AstAnalyzer for UnnecessaryEncodeUTF8 { +impl Analyzer for UnnecessaryEncodeUTF8 { fn rule() -> Rule { Rule::UnnecessaryEncodeUTF8 } diff --git a/crates/ruff/src/rules/pyupgrade/rules/use_pep604_annotation.rs b/crates/ruff/src/rules/pyupgrade/rules/use_pep604_annotation.rs index 5dd43375f1..75149e1349 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/use_pep604_annotation.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/use_pep604_annotation.rs @@ -3,6 +3,7 @@ use rustpython_parser::ast::{self, Constant, Expr, Operator, Ranged}; use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation}; use ruff_macros::{derive_message_formats, violation}; + use ruff_python_semantic::analyze::typing::Pep604Operator; use crate::checkers::ast::Checker; diff --git a/crates/ruff/src/rules/pyupgrade/rules/use_pep604_isinstance.rs b/crates/ruff/src/rules/pyupgrade/rules/use_pep604_isinstance.rs index 07edbc054b..d1075377ed 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/use_pep604_isinstance.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/use_pep604_isinstance.rs @@ -6,9 +6,10 @@ use rustpython_parser::ast::{self, Expr, Operator, Ranged}; use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix}; use ruff_macros::{derive_message_formats, violation}; -use crate::checkers::ast::traits::AstAnalyzer; +use crate::checkers::ast::traits::Analyzer; use crate::checkers::ast::RuleContext; use crate::registry::{AsRule, Rule}; +use crate::settings::types::PythonVersion; #[derive(Debug, PartialEq, Eq, Copy, Clone)] pub(crate) enum CallKind { @@ -51,7 +52,7 @@ impl AlwaysAutofixableViolation for NonPEP604Isinstance { } } -impl AstAnalyzer for NonPEP604Isinstance { +impl Analyzer for NonPEP604Isinstance { fn rule() -> Rule { Rule::NonPEP604Isinstance } @@ -82,6 +83,10 @@ pub(crate) fn use_pep604_isinstance( func, args, range, .. }: &ast::ExprCall, ) { + if checker.settings.target_version < PythonVersion::Py310 { + return; + } + if let Expr::Name(ast::ExprName { id, .. }) = func.as_ref() { let Some(kind) = CallKind::from_name(id) else { return; diff --git a/crates/ruff_benchmark/benches/linter.rs b/crates/ruff_benchmark/benches/linter.rs index 8e0be3a3f8..b07390edbb 100644 --- a/crates/ruff_benchmark/benches/linter.rs +++ b/crates/ruff_benchmark/benches/linter.rs @@ -4,7 +4,7 @@ use criterion::{ }; use ruff::linter::lint_only; use ruff::settings::{flags, Settings}; -use ruff::{Pyupgrade, RuleCodePrefix, RuleSelector}; +use ruff::RuleSelector; use ruff_benchmark::{TestCase, TestCaseSpeed, TestFile, TestFileDownloadError}; use std::time::Duration; @@ -73,14 +73,14 @@ fn benchmark_linter(mut group: BenchmarkGroup, settings: &Settings) { group.finish(); } +fn benchmark_default_rules(criterion: &mut Criterion) { + let group = criterion.benchmark_group("linter/default-rules"); + benchmark_linter(group, &Settings::default()); +} + fn benchmark_all_rules(criterion: &mut Criterion) { let settings = Settings { - rules: RuleSelector::Prefix { - prefix: RuleCodePrefix::Pyupgrade(Pyupgrade::_0), - redirected_from: None, - } - .into_iter() - .collect(), + rules: RuleSelector::All.into_iter().collect(), ..Settings::default() }; @@ -88,6 +88,6 @@ fn benchmark_all_rules(criterion: &mut Criterion) { benchmark_linter(group, &settings); } -// criterion_group!(default_rules, benchmark_default_rules); +criterion_group!(default_rules, benchmark_default_rules); criterion_group!(all_rules, benchmark_all_rules); -criterion_main!(all_rules); +criterion_main!(default_rules, all_rules); diff --git a/foo.py b/foo.py deleted file mode 100644 index f791921c59..0000000000 --- a/foo.py +++ /dev/null @@ -1,8 +0,0 @@ -def foo(a): - """Summary - - Args: - ---- - a: list - parameter a - """