Python
/
ruff
mirror of https://github.com/astral-sh/ruff
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Try a bit set

This commit is contained in:
Charlie Marsh 2022-11-18 20:33:43 -05:00
parent 89afc9db74
commit e187c66573
16 changed files with 334 additions and 327 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

404
src/check_ast.rs
View File

File diff suppressed because it is too large Load Diff

8
src/check_lines.rs
View File

@ -39,9 +39,9 @@ pub fn check_lines(
settings: &Settings, settings: &Settings,
autofix: &fixer::Mode, autofix: &fixer::Mode,
) { ) {
let enforce_unnecessary_coding_comment = settings.enabled.contains(&CheckCode::U009); let enforce_unnecessary_coding_comment = settings.enabled[CheckCode::U009 as usize];
let enforce_line_too_long = settings.enabled.contains(&CheckCode::E501); let enforce_line_too_long = settings.enabled[CheckCode::E501 as usize];
let enforce_noqa = settings.enabled.contains(&CheckCode::M001); let enforce_noqa = settings.enabled[CheckCode::M001 as usize];
let mut noqa_directives: IntMap<usize, (Directive, Vec<&str>)> = IntMap::default(); let mut noqa_directives: IntMap<usize, (Directive, Vec<&str>)> = IntMap::default();
let mut line_checks = vec![]; let mut line_checks = vec![];
@ -147,7 +147,7 @@ pub fn check_lines(
} }
// Enforce newlines at end of files. // Enforce newlines at end of files.
if settings.enabled.contains(&CheckCode::W292) && !contents.ends_with('\n') { if settings.enabled[CheckCode::W292 as usize] && !contents.ends_with('\n') {
// Note: if `lines.last()` is `None`, then `contents` is empty (and so we don't // Note: if `lines.last()` is `None`, then `contents` is empty (and so we don't
// want to raise W292 anyway). // want to raise W292 anyway).
if let Some(line) = lines.last() { if let Some(line) = lines.last() {

18
src/check_tokens.rs
View File

@ -16,14 +16,14 @@ pub fn check_tokens(
settings: &Settings, settings: &Settings,
autofix: &fixer::Mode, autofix: &fixer::Mode,
) { ) {
let enforce_ambiguous_unicode_character = settings.enabled.contains(&CheckCode::RUF001) let enforce_ambiguous_unicode_character = settings.enabled[CheckCode::RUF001 as usize]
|| settings.enabled.contains(&CheckCode::RUF002) || settings.enabled[CheckCode::RUF002 as usize]
|| settings.enabled.contains(&CheckCode::RUF003); || settings.enabled[CheckCode::RUF003 as usize];
let enforce_quotes = settings.enabled.contains(&CheckCode::Q000) let enforce_quotes = settings.enabled[CheckCode::Q000 as usize]
|| settings.enabled.contains(&CheckCode::Q001) || settings.enabled[CheckCode::Q001 as usize]
|| settings.enabled.contains(&CheckCode::Q002) || settings.enabled[CheckCode::Q002 as usize]
|| settings.enabled.contains(&CheckCode::Q003); || settings.enabled[CheckCode::Q003 as usize];
let enforce_invalid_escape_sequence = settings.enabled.contains(&CheckCode::W605); let enforce_invalid_escape_sequence = settings.enabled[CheckCode::W605 as usize];
let mut state_machine: StateMachine = Default::default(); let mut state_machine: StateMachine = Default::default();
for (start, tok, end) in tokens.iter().flatten() { for (start, tok, end) in tokens.iter().flatten() {
@ -65,7 +65,7 @@ pub fn check_tokens(
is_docstring, is_docstring,
&settings.flake8_quotes, &settings.flake8_quotes,
) { ) {
if settings.enabled.contains(check.kind.code()) { if settings.enabled[check.kind.code().clone() as usize] {
checks.push(check); checks.push(check);
} }
} }

1
src/checks.rs
View File

@ -25,6 +25,7 @@ use crate::pyupgrade::types::Primitive;
PartialOrd, PartialOrd,
Ord, Ord,
)] )]
#[repr(u8)]
pub enum CheckCode { pub enum CheckCode {
// pycodestyle errors // pycodestyle errors
E402, E402,

17
src/directives.rs
View File

@ -18,15 +18,16 @@ bitflags! {
impl Flags { impl Flags {
pub fn from_settings(settings: &Settings) -> Self { pub fn from_settings(settings: &Settings) -> Self {
if settings
.enabled
.iter()
.any(|check_code| matches!(check_code.lint_source(), LintSource::Imports))
{
Flags::NOQA | Flags::ISORT
} else {
Flags::NOQA Flags::NOQA
} // if settings
// .enabled
// .iter()
// .any(|check_code| matches!(check_code.lint_source(), LintSource::Imports))
// {
// Flags::NOQA | Flags::ISORT
// } else {
// Flags::NOQA
// }
} }
} }

19
src/flake8_2020/plugins.rs
View File

@ -31,15 +31,14 @@ pub fn subscript(checker: &mut Checker, value: &Expr, slice: &Expr) {
.. ..
} = &upper.node } = &upper.node
{ {
if *i == BigInt::from(1) if *i == BigInt::from(1) && checker.settings.enabled[CheckCode::YTT303 as usize]
&& checker.settings.enabled.contains(&CheckCode::YTT303)
{ {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::SysVersionSlice1Referenced, CheckKind::SysVersionSlice1Referenced,
Range::from_located(value), Range::from_located(value),
)); ));
} else if *i == BigInt::from(3) } else if *i == BigInt::from(3)
&& checker.settings.enabled.contains(&CheckCode::YTT101) && checker.settings.enabled[CheckCode::YTT101 as usize]
{ {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::SysVersionSlice3Referenced, CheckKind::SysVersionSlice3Referenced,
@ -53,13 +52,13 @@ pub fn subscript(checker: &mut Checker, value: &Expr, slice: &Expr) {
value: Constant::Int(i), value: Constant::Int(i),
.. ..
} => { } => {
if *i == BigInt::from(2) && checker.settings.enabled.contains(&CheckCode::YTT102) { if *i == BigInt::from(2) && checker.settings.enabled[CheckCode::YTT102 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::SysVersion2Referenced, CheckKind::SysVersion2Referenced,
Range::from_located(value), Range::from_located(value),
)); ));
} else if *i == BigInt::from(0) } else if *i == BigInt::from(0)
&& checker.settings.enabled.contains(&CheckCode::YTT301) && checker.settings.enabled[CheckCode::YTT301 as usize]
{ {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::SysVersion0Referenced, CheckKind::SysVersion0Referenced,
@ -96,7 +95,7 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
) = (ops, comparators) ) = (ops, comparators)
{ {
if *n == BigInt::from(3) if *n == BigInt::from(3)
&& checker.settings.enabled.contains(&CheckCode::YTT201) && checker.settings.enabled[CheckCode::YTT201 as usize]
{ {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::SysVersionInfo0Eq3Referenced, CheckKind::SysVersionInfo0Eq3Referenced,
@ -117,7 +116,7 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
}], }],
) = (ops, comparators) ) = (ops, comparators)
{ {
if checker.settings.enabled.contains(&CheckCode::YTT203) { if checker.settings.enabled[CheckCode::YTT203 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::SysVersionInfo1CmpInt, CheckKind::SysVersionInfo1CmpInt,
Range::from_located(left), Range::from_located(left),
@ -143,7 +142,7 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
}], }],
) = (ops, comparators) ) = (ops, comparators)
{ {
if checker.settings.enabled.contains(&CheckCode::YTT204) { if checker.settings.enabled[CheckCode::YTT204 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::SysVersionInfoMinorCmpInt, CheckKind::SysVersionInfoMinorCmpInt,
Range::from_located(left), Range::from_located(left),
@ -169,13 +168,13 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
) = (ops, comparators) ) = (ops, comparators)
{ {
if s.len() == 1 { if s.len() == 1 {
if checker.settings.enabled.contains(&CheckCode::YTT302) { if checker.settings.enabled[CheckCode::YTT302 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::SysVersionCmpStr10, CheckKind::SysVersionCmpStr10,
Range::from_located(left), Range::from_located(left),
)); ));
} }
} else if checker.settings.enabled.contains(&CheckCode::YTT103) { } else if checker.settings.enabled[CheckCode::YTT103 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::SysVersionCmpStr3, CheckKind::SysVersionCmpStr3,
Range::from_located(left), Range::from_located(left),

48
src/flake8_annotations/plugins.rs
View File

@ -106,14 +106,14 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
.chain(args.kwonlyargs.iter()) .chain(args.kwonlyargs.iter())
{ {
if let Some(expr) = &arg.node.annotation { if let Some(expr) = &arg.node.annotation {
if checker.settings.enabled.contains(&CheckCode::ANN401) { if checker.settings.enabled[CheckCode::ANN401 as usize] {
check_dynamically_typed(checker, expr, || arg.node.arg.to_string()); check_dynamically_typed(checker, expr, || arg.node.arg.to_string());
}; };
} else { } else {
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&CheckCode::ANN001) { if checker.settings.enabled[CheckCode::ANN001 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingTypeFunctionArgument(arg.node.arg.to_string()), CheckKind::MissingTypeFunctionArgument(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -127,7 +127,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if let Some(arg) = &args.vararg { if let Some(arg) = &args.vararg {
if let Some(expr) = &arg.node.annotation { if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any { if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&CheckCode::ANN401) { if checker.settings.enabled[CheckCode::ANN401 as usize] {
let name = arg.node.arg.to_string(); let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("*{name}")); check_dynamically_typed(checker, expr, || format!("*{name}"));
} }
@ -136,7 +136,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&CheckCode::ANN002) { if checker.settings.enabled[CheckCode::ANN002 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingTypeArgs(arg.node.arg.to_string()), CheckKind::MissingTypeArgs(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -150,7 +150,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if let Some(arg) = &args.kwarg { if let Some(arg) = &args.kwarg {
if let Some(expr) = &arg.node.annotation { if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any { if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&CheckCode::ANN401) { if checker.settings.enabled[CheckCode::ANN401 as usize] {
let name = arg.node.arg.to_string(); let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("**{name}")); check_dynamically_typed(checker, expr, || format!("**{name}"));
} }
@ -159,7 +159,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&CheckCode::ANN003) { if checker.settings.enabled[CheckCode::ANN003 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingTypeKwargs(arg.node.arg.to_string()), CheckKind::MissingTypeKwargs(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -171,7 +171,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
// ANN201, ANN202, ANN401 // ANN201, ANN202, ANN401
if let Some(expr) = &returns { if let Some(expr) = &returns {
if checker.settings.enabled.contains(&CheckCode::ANN401) { if checker.settings.enabled[CheckCode::ANN401 as usize] {
check_dynamically_typed(checker, expr, || name.to_string()); check_dynamically_typed(checker, expr, || name.to_string());
}; };
} else { } else {
@ -185,7 +185,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
match visibility { match visibility {
Visibility::Public => { Visibility::Public => {
if checker.settings.enabled.contains(&CheckCode::ANN201) { if checker.settings.enabled[CheckCode::ANN201 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingReturnTypePublicFunction(name.to_string()), CheckKind::MissingReturnTypePublicFunction(name.to_string()),
Range::from_located(stmt), Range::from_located(stmt),
@ -193,7 +193,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} }
} }
Visibility::Private => { Visibility::Private => {
if checker.settings.enabled.contains(&CheckCode::ANN202) { if checker.settings.enabled[CheckCode::ANN202 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingReturnTypePrivateFunction(name.to_string()), CheckKind::MissingReturnTypePrivateFunction(name.to_string()),
Range::from_located(stmt), Range::from_located(stmt),
@ -221,14 +221,14 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
// ANN401 for dynamically typed arguments // ANN401 for dynamically typed arguments
if let Some(annotation) = &arg.node.annotation { if let Some(annotation) = &arg.node.annotation {
has_any_typed_arg = true; has_any_typed_arg = true;
if checker.settings.enabled.contains(&CheckCode::ANN401) { if checker.settings.enabled[CheckCode::ANN401 as usize] {
check_dynamically_typed(checker, annotation, || arg.node.arg.to_string()); check_dynamically_typed(checker, annotation, || arg.node.arg.to_string());
} }
} else { } else {
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&CheckCode::ANN001) { if checker.settings.enabled[CheckCode::ANN001 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingTypeFunctionArgument(arg.node.arg.to_string()), CheckKind::MissingTypeFunctionArgument(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -243,7 +243,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
has_any_typed_arg = true; has_any_typed_arg = true;
if let Some(expr) = &arg.node.annotation { if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any { if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&CheckCode::ANN401) { if checker.settings.enabled[CheckCode::ANN401 as usize] {
let name = arg.node.arg.to_string(); let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("*{name}")); check_dynamically_typed(checker, expr, || format!("*{name}"));
} }
@ -252,7 +252,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&CheckCode::ANN002) { if checker.settings.enabled[CheckCode::ANN002 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingTypeArgs(arg.node.arg.to_string()), CheckKind::MissingTypeArgs(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -267,7 +267,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
has_any_typed_arg = true; has_any_typed_arg = true;
if let Some(expr) = &arg.node.annotation { if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any { if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&CheckCode::ANN401) { if checker.settings.enabled[CheckCode::ANN401 as usize] {
let name = arg.node.arg.to_string(); let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("**{name}")); check_dynamically_typed(checker, expr, || format!("**{name}"));
} }
@ -276,7 +276,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&CheckCode::ANN003) { if checker.settings.enabled[CheckCode::ANN003 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingTypeKwargs(arg.node.arg.to_string()), CheckKind::MissingTypeKwargs(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -291,14 +291,14 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if let Some(arg) = args.args.first() { if let Some(arg) = args.args.first() {
if arg.node.annotation.is_none() { if arg.node.annotation.is_none() {
if visibility::is_classmethod(stmt) { if visibility::is_classmethod(stmt) {
if checker.settings.enabled.contains(&CheckCode::ANN102) { if checker.settings.enabled[CheckCode::ANN102 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingTypeCls(arg.node.arg.to_string()), CheckKind::MissingTypeCls(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
)); ));
} }
} else { } else {
if checker.settings.enabled.contains(&CheckCode::ANN101) { if checker.settings.enabled[CheckCode::ANN101 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingTypeSelf(arg.node.arg.to_string()), CheckKind::MissingTypeSelf(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -311,7 +311,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
// ANN201, ANN202 // ANN201, ANN202
if let Some(expr) = &returns { if let Some(expr) = &returns {
if checker.settings.enabled.contains(&CheckCode::ANN401) { if checker.settings.enabled[CheckCode::ANN401 as usize] {
check_dynamically_typed(checker, expr, || name.to_string()); check_dynamically_typed(checker, expr, || name.to_string());
} }
} else { } else {
@ -324,21 +324,21 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} }
if visibility::is_classmethod(stmt) { if visibility::is_classmethod(stmt) {
if checker.settings.enabled.contains(&CheckCode::ANN206) { if checker.settings.enabled[CheckCode::ANN206 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingReturnTypeClassMethod(name.to_string()), CheckKind::MissingReturnTypeClassMethod(name.to_string()),
Range::from_located(stmt), Range::from_located(stmt),
)); ));
} }
} else if visibility::is_staticmethod(stmt) { } else if visibility::is_staticmethod(stmt) {
if checker.settings.enabled.contains(&CheckCode::ANN205) { if checker.settings.enabled[CheckCode::ANN205 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingReturnTypeStaticMethod(name.to_string()), CheckKind::MissingReturnTypeStaticMethod(name.to_string()),
Range::from_located(stmt), Range::from_located(stmt),
)); ));
} }
} else if visibility::is_magic(stmt) { } else if visibility::is_magic(stmt) {
if checker.settings.enabled.contains(&CheckCode::ANN204) { if checker.settings.enabled[CheckCode::ANN204 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingReturnTypeMagicMethod(name.to_string()), CheckKind::MissingReturnTypeMagicMethod(name.to_string()),
Range::from_located(stmt), Range::from_located(stmt),
@ -347,7 +347,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} else if visibility::is_init(stmt) { } else if visibility::is_init(stmt) {
// Allow omission of return annotation in `__init__` functions, as long as at // Allow omission of return annotation in `__init__` functions, as long as at
// least one argument is typed. // least one argument is typed.
if checker.settings.enabled.contains(&CheckCode::ANN204) { if checker.settings.enabled[CheckCode::ANN204 as usize] {
if !(checker.settings.flake8_annotations.mypy_init_return if !(checker.settings.flake8_annotations.mypy_init_return
&& has_any_typed_arg) && has_any_typed_arg)
{ {
@ -360,7 +360,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} else { } else {
match visibility { match visibility {
Visibility::Public => { Visibility::Public => {
if checker.settings.enabled.contains(&CheckCode::ANN201) { if checker.settings.enabled[CheckCode::ANN201 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingReturnTypePublicFunction(name.to_string()), CheckKind::MissingReturnTypePublicFunction(name.to_string()),
Range::from_located(stmt), Range::from_located(stmt),
@ -368,7 +368,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} }
} }
Visibility::Private => { Visibility::Private => {
if checker.settings.enabled.contains(&CheckCode::ANN202) { if checker.settings.enabled[CheckCode::ANN202 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MissingReturnTypePrivateFunction(name.to_string()), CheckKind::MissingReturnTypePrivateFunction(name.to_string()),
Range::from_located(stmt), Range::from_located(stmt),

4
src/flake8_bugbear/plugins/abstract_base_class.rs
View File

@ -102,7 +102,7 @@ pub fn abstract_base_class(
has_abstract_method |= has_abstract_decorator; has_abstract_method |= has_abstract_decorator;
if checker.settings.enabled.contains(&CheckCode::B027) { if checker.settings.enabled[CheckCode::B027 as usize] {
if !has_abstract_decorator if !has_abstract_decorator
&& is_empty_body(body) && is_empty_body(body)
&& !decorator_list && !decorator_list
@ -117,7 +117,7 @@ pub fn abstract_base_class(
} }
} }
} }
if checker.settings.enabled.contains(&CheckCode::B024) { if checker.settings.enabled[CheckCode::B024 as usize] {
if !has_abstract_method { if !has_abstract_method {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::AbstractBaseClassWithoutAbstractMethod(name.to_string()), CheckKind::AbstractBaseClassWithoutAbstractMethod(name.to_string()),

4
src/flake8_bugbear/plugins/duplicate_exceptions.rs
View File

@ -41,7 +41,7 @@ fn duplicate_handler_exceptions<'a>(
} }
} }
if checker.settings.enabled.contains(&CheckCode::B014) { if checker.settings.enabled[CheckCode::B014 as usize] {
// TODO(charlie): Handle "BaseException" and redundant exception aliases. // TODO(charlie): Handle "BaseException" and redundant exception aliases.
if !duplicates.is_empty() { if !duplicates.is_empty() {
let mut check = Check::new( let mut check = Check::new(
@ -108,7 +108,7 @@ pub fn duplicate_exceptions(checker: &mut Checker, stmt: &Stmt, handlers: &[Exce
} }
} }
if checker.settings.enabled.contains(&CheckCode::B025) { if checker.settings.enabled[CheckCode::B025 as usize] {
for duplicate in duplicates.into_iter().sorted() { for duplicate in duplicates.into_iter().sorted() {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::DuplicateTryBlockException(duplicate.join(".")), CheckKind::DuplicateTryBlockException(duplicate.join(".")),

4
src/flake8_print/plugins/print_call.rs
View File

@ -12,8 +12,8 @@ pub fn print_call(checker: &mut Checker, expr: &Expr, func: &Expr) {
if let Some(mut check) = checks::print_call( if let Some(mut check) = checks::print_call(
expr, expr,
func, func,
checker.settings.enabled.contains(&CheckCode::T201), checker.settings.enabled[CheckCode::T201 as usize],
checker.settings.enabled.contains(&CheckCode::T203), checker.settings.enabled[CheckCode::T203 as usize],
Range::from_located(expr), Range::from_located(expr),
) { ) {
if checker.patch(check.kind.code()) { if checker.patch(check.kind.code()) {

1
src/lib.rs
View File

@ -15,6 +15,7 @@ use crate::source_code_locator::SourceCodeLocator;
mod ast; mod ast;
pub mod autofix; pub mod autofix;
mod bits;
pub mod cache; pub mod cache;
pub mod check_ast; pub mod check_ast;
mod check_imports; mod check_imports;

29
src/linter.rs
View File

@ -65,23 +65,26 @@ pub(crate) fn check_path(
let mut checks: Vec<Check> = vec![]; let mut checks: Vec<Check> = vec![];
// Run the token-based checks. // Run the token-based checks.
let use_tokens = settings let use_tokens = false;
.enabled // settings
.iter() // .enabled
.any(|check_code| matches!(check_code.lint_source(), LintSource::Tokens)); // .iter()
// .any(|check_code| matches!(check_code.lint_source(), LintSource::Tokens));
if use_tokens { if use_tokens {
check_tokens(&mut checks, locator, &tokens, settings, autofix); check_tokens(&mut checks, locator, &tokens, settings, autofix);
} }
// Run the AST-based checks. // Run the AST-based checks.
let use_ast = settings let use_ast = true;
.enabled // settings
.iter() // .enabled
.any(|check_code| matches!(check_code.lint_source(), LintSource::AST)); // .iter()
let use_imports = settings // .any(|check_code| matches!(check_code.lint_source(), LintSource::AST));
.enabled let use_imports = false;
.iter() // settings
.any(|check_code| matches!(check_code.lint_source(), LintSource::Imports)); // .enabled
// .iter()
// .any(|check_code| matches!(check_code.lint_source(), LintSource::Imports));
if use_ast || use_imports { if use_ast || use_imports {
match parse_program_tokens(tokens, "<filename>") { match parse_program_tokens(tokens, "<filename>") {
Ok(python_ast) => { Ok(python_ast) => {
@ -99,7 +102,7 @@ pub(crate) fn check_path(
} }
} }
Err(parse_error) => { Err(parse_error) => {
if settings.enabled.contains(&CheckCode::E999) { if settings.enabled[CheckCode::E999 as usize] {
checks.push(Check::new( checks.push(Check::new(
CheckKind::SyntaxError(parse_error.error.to_string()), CheckKind::SyntaxError(parse_error.error.to_string()),
Range { Range {

2
src/main.rs
View File

@ -110,7 +110,7 @@ fn run_once(
} }
.unwrap_or_else(|(path, message)| { .unwrap_or_else(|(path, message)| {
if let Some(path) = path { if let Some(path) = path {
if settings.enabled.contains(&CheckCode::E902) { if settings.enabled[CheckCode::E902 as usize] {
vec![Message { vec![Message {
kind: CheckKind::IOError(message), kind: CheckKind::IOError(message),
fixed: false, fixed: false,

80
src/pydocstyle/plugins.rs
View File

@ -32,7 +32,7 @@ pub fn not_missing(
match definition.kind { match definition.kind {
DefinitionKind::Module => { DefinitionKind::Module => {
if checker.settings.enabled.contains(&CheckCode::D100) { if checker.settings.enabled[CheckCode::D100 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::PublicModule, CheckKind::PublicModule,
Range { Range {
@ -44,7 +44,7 @@ pub fn not_missing(
false false
} }
DefinitionKind::Package => { DefinitionKind::Package => {
if checker.settings.enabled.contains(&CheckCode::D104) { if checker.settings.enabled[CheckCode::D104 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::PublicPackage, CheckKind::PublicPackage,
Range { Range {
@ -56,7 +56,7 @@ pub fn not_missing(
false false
} }
DefinitionKind::Class(stmt) => { DefinitionKind::Class(stmt) => {
if checker.settings.enabled.contains(&CheckCode::D101) { if checker.settings.enabled[CheckCode::D101 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::PublicClass, CheckKind::PublicClass,
Range::from_located(stmt), Range::from_located(stmt),
@ -65,7 +65,7 @@ pub fn not_missing(
false false
} }
DefinitionKind::NestedClass(stmt) => { DefinitionKind::NestedClass(stmt) => {
if checker.settings.enabled.contains(&CheckCode::D106) { if checker.settings.enabled[CheckCode::D106 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::PublicNestedClass, CheckKind::PublicNestedClass,
Range::from_located(stmt), Range::from_located(stmt),
@ -77,7 +77,7 @@ pub fn not_missing(
if is_overload(stmt) { if is_overload(stmt) {
true true
} else { } else {
if checker.settings.enabled.contains(&CheckCode::D103) { if checker.settings.enabled[CheckCode::D103 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::PublicFunction, CheckKind::PublicFunction,
Range::from_located(stmt), Range::from_located(stmt),
@ -90,7 +90,7 @@ pub fn not_missing(
if is_overload(stmt) { if is_overload(stmt) {
true true
} else if is_magic(stmt) { } else if is_magic(stmt) {
if checker.settings.enabled.contains(&CheckCode::D105) { if checker.settings.enabled[CheckCode::D105 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MagicMethod, CheckKind::MagicMethod,
Range::from_located(stmt), Range::from_located(stmt),
@ -98,12 +98,12 @@ pub fn not_missing(
} }
true true
} else if is_init(stmt) { } else if is_init(stmt) {
if checker.settings.enabled.contains(&CheckCode::D107) { if checker.settings.enabled[CheckCode::D107 as usize] {
checker.add_check(Check::new(CheckKind::PublicInit, Range::from_located(stmt))); checker.add_check(Check::new(CheckKind::PublicInit, Range::from_located(stmt)));
} }
true true
} else { } else {
if checker.settings.enabled.contains(&CheckCode::D102) { if checker.settings.enabled[CheckCode::D102 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::PublicMethod, CheckKind::PublicMethod,
Range::from_located(stmt), Range::from_located(stmt),
@ -162,7 +162,7 @@ pub fn blank_before_after_function(checker: &mut Checker, definition: &Definitio
.. ..
} = &docstring.node } = &docstring.node
{ {
if checker.settings.enabled.contains(&CheckCode::D201) { if checker.settings.enabled[CheckCode::D201 as usize] {
let (before, ..) = checker.locator.partition_source_code_at( let (before, ..) = checker.locator.partition_source_code_at(
&Range::from_located(parent), &Range::from_located(parent),
&Range::from_located(docstring), &Range::from_located(docstring),
@ -190,7 +190,7 @@ pub fn blank_before_after_function(checker: &mut Checker, definition: &Definitio
} }
} }
if checker.settings.enabled.contains(&CheckCode::D202) { if checker.settings.enabled[CheckCode::D202 as usize] {
let (_, _, after) = checker.locator.partition_source_code_at( let (_, _, after) = checker.locator.partition_source_code_at(
&Range::from_located(parent), &Range::from_located(parent),
&Range::from_located(docstring), &Range::from_located(docstring),
@ -249,8 +249,8 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
.. ..
} = &docstring.node } = &docstring.node
{ {
if checker.settings.enabled.contains(&CheckCode::D203) if checker.settings.enabled[CheckCode::D203 as usize]
|| checker.settings.enabled.contains(&CheckCode::D211) || checker.settings.enabled[CheckCode::D211 as usize]
{ {
let (before, ..) = checker.locator.partition_source_code_at( let (before, ..) = checker.locator.partition_source_code_at(
&Range::from_located(parent), &Range::from_located(parent),
@ -263,7 +263,7 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
.skip(1) .skip(1)
.take_while(|line| line.trim().is_empty()) .take_while(|line| line.trim().is_empty())
.count(); .count();
if checker.settings.enabled.contains(&CheckCode::D211) { if checker.settings.enabled[CheckCode::D211 as usize] {
if blank_lines_before != 0 { if blank_lines_before != 0 {
let mut check = Check::new( let mut check = Check::new(
CheckKind::NoBlankLineBeforeClass(blank_lines_before), CheckKind::NoBlankLineBeforeClass(blank_lines_before),
@ -279,7 +279,7 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
checker.add_check(check); checker.add_check(check);
} }
} }
if checker.settings.enabled.contains(&CheckCode::D203) { if checker.settings.enabled[CheckCode::D203 as usize] {
if blank_lines_before != 1 { if blank_lines_before != 1 {
let mut check = Check::new( let mut check = Check::new(
CheckKind::OneBlankLineBeforeClass(blank_lines_before), CheckKind::OneBlankLineBeforeClass(blank_lines_before),
@ -298,7 +298,7 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
} }
} }
if checker.settings.enabled.contains(&CheckCode::D204) { if checker.settings.enabled[CheckCode::D204 as usize] {
let (_, _, after) = checker.locator.partition_source_code_at( let (_, _, after) = checker.locator.partition_source_code_at(
&Range::from_located(parent), &Range::from_located(parent),
&Range::from_located(docstring), &Range::from_located(docstring),
@ -414,7 +414,7 @@ pub fn indent(checker: &mut Checker, definition: &Definition) {
// yet. // yet.
has_seen_tab = has_seen_tab || line_indent.contains('\t'); has_seen_tab = has_seen_tab || line_indent.contains('\t');
if checker.settings.enabled.contains(&CheckCode::D207) { if checker.settings.enabled[CheckCode::D207 as usize] {
// We report under-indentation on every line. This isn't great, but enables // We report under-indentation on every line. This isn't great, but enables
// autofix. // autofix.
if !is_blank && line_indent.len() < docstring_indent.len() { if !is_blank && line_indent.len() < docstring_indent.len() {
@ -451,7 +451,7 @@ pub fn indent(checker: &mut Checker, definition: &Definition) {
} }
} }
if checker.settings.enabled.contains(&CheckCode::D206) { if checker.settings.enabled[CheckCode::D206 as usize] {
if has_seen_tab { if has_seen_tab {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::IndentWithSpaces, CheckKind::IndentWithSpaces,
@ -460,7 +460,7 @@ pub fn indent(checker: &mut Checker, definition: &Definition) {
} }
} }
if checker.settings.enabled.contains(&CheckCode::D208) { if checker.settings.enabled[CheckCode::D208 as usize] {
// If every line (except the last) is over-indented... // If every line (except the last) is over-indented...
if is_over_indented { if is_over_indented {
for i in over_indented_lines { for i in over_indented_lines {
@ -635,14 +635,14 @@ pub fn multi_line_summary_start(checker: &mut Checker, definition: &Definition)
.map(|line| line.to_lowercase()) .map(|line| line.to_lowercase())
{ {
if helpers::TRIPLE_QUOTE_PREFIXES.contains(&first_line.as_str()) { if helpers::TRIPLE_QUOTE_PREFIXES.contains(&first_line.as_str()) {
if checker.settings.enabled.contains(&CheckCode::D212) { if checker.settings.enabled[CheckCode::D212 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MultiLineSummaryFirstLine, CheckKind::MultiLineSummaryFirstLine,
Range::from_located(docstring), Range::from_located(docstring),
)); ));
} }
} else { } else {
if checker.settings.enabled.contains(&CheckCode::D213) { if checker.settings.enabled[CheckCode::D213 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::MultiLineSummarySecondLine, CheckKind::MultiLineSummarySecondLine,
Range::from_located(docstring), Range::from_located(docstring),
@ -848,7 +848,7 @@ pub fn not_empty(checker: &mut Checker, definition: &Definition) -> bool {
} = &docstring.node } = &docstring.node
{ {
if string.trim().is_empty() { if string.trim().is_empty() {
if checker.settings.enabled.contains(&CheckCode::D419) { if checker.settings.enabled[CheckCode::D419 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::NonEmpty, CheckKind::NonEmpty,
Range::from_located(docstring), Range::from_located(docstring),
@ -911,7 +911,7 @@ fn blanks_and_section_underline(
// Nothing but blank lines after the section header. // Nothing but blank lines after the section header.
if blank_lines_after_header == context.following_lines.len() { if blank_lines_after_header == context.following_lines.len() {
if checker.settings.enabled.contains(&CheckCode::D407) { if checker.settings.enabled[CheckCode::D407 as usize] {
let mut check = Check::new( let mut check = Check::new(
CheckKind::DashedUnderlineAfterSection(context.section_name.to_string()), CheckKind::DashedUnderlineAfterSection(context.section_name.to_string()),
Range::from_located(docstring), Range::from_located(docstring),
@ -930,7 +930,7 @@ fn blanks_and_section_underline(
} }
checker.add_check(check); checker.add_check(check);
} }
if checker.settings.enabled.contains(&CheckCode::D414) { if checker.settings.enabled[CheckCode::D414 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::NonEmptySection(context.section_name.to_string()), CheckKind::NonEmptySection(context.section_name.to_string()),
Range::from_located(docstring), Range::from_located(docstring),
@ -945,7 +945,7 @@ fn blanks_and_section_underline(
.all(|char| char.is_whitespace() || char == '-'); .all(|char| char.is_whitespace() || char == '-');
if !dash_line_found { if !dash_line_found {
if checker.settings.enabled.contains(&CheckCode::D407) { if checker.settings.enabled[CheckCode::D407 as usize] {
let mut check = Check::new( let mut check = Check::new(
CheckKind::DashedUnderlineAfterSection(context.section_name.to_string()), CheckKind::DashedUnderlineAfterSection(context.section_name.to_string()),
Range::from_located(docstring), Range::from_located(docstring),
@ -965,7 +965,7 @@ fn blanks_and_section_underline(
checker.add_check(check); checker.add_check(check);
} }
if blank_lines_after_header > 0 { if blank_lines_after_header > 0 {
if checker.settings.enabled.contains(&CheckCode::D412) { if checker.settings.enabled[CheckCode::D412 as usize] {
let mut check = Check::new( let mut check = Check::new(
CheckKind::NoBlankLinesBetweenHeaderAndContent( CheckKind::NoBlankLinesBetweenHeaderAndContent(
context.section_name.to_string(), context.section_name.to_string(),
@ -990,7 +990,7 @@ fn blanks_and_section_underline(
} }
} else { } else {
if blank_lines_after_header > 0 { if blank_lines_after_header > 0 {
if checker.settings.enabled.contains(&CheckCode::D408) { if checker.settings.enabled[CheckCode::D408 as usize] {
let mut check = Check::new( let mut check = Check::new(
CheckKind::SectionUnderlineAfterName(context.section_name.to_string()), CheckKind::SectionUnderlineAfterName(context.section_name.to_string()),
Range::from_located(docstring), Range::from_located(docstring),
@ -1019,7 +1019,7 @@ fn blanks_and_section_underline(
.count() .count()
!= context.section_name.len() != context.section_name.len()
{ {
if checker.settings.enabled.contains(&CheckCode::D409) { if checker.settings.enabled[CheckCode::D409 as usize] {
let mut check = Check::new( let mut check = Check::new(
CheckKind::SectionUnderlineMatchesSectionLength( CheckKind::SectionUnderlineMatchesSectionLength(
context.section_name.to_string(), context.section_name.to_string(),
@ -1056,7 +1056,7 @@ fn blanks_and_section_underline(
} }
} }
if checker.settings.enabled.contains(&CheckCode::D215) { if checker.settings.enabled[CheckCode::D215 as usize] {
let leading_space = helpers::leading_space(non_empty_line); let leading_space = helpers::leading_space(non_empty_line);
let indentation = helpers::indentation(checker, docstring); let indentation = helpers::indentation(checker, docstring);
if leading_space.len() > indentation.len() { if leading_space.len() > indentation.len() {
@ -1099,14 +1099,14 @@ fn blanks_and_section_underline(
.take_while(|line| line.trim().is_empty()) .take_while(|line| line.trim().is_empty())
.count(); .count();
if blank_lines_after_dashes == rest_of_lines.len() { if blank_lines_after_dashes == rest_of_lines.len() {
if checker.settings.enabled.contains(&CheckCode::D414) { if checker.settings.enabled[CheckCode::D414 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::NonEmptySection(context.section_name.to_string()), CheckKind::NonEmptySection(context.section_name.to_string()),
Range::from_located(docstring), Range::from_located(docstring),
)); ));
} }
} else { } else {
if checker.settings.enabled.contains(&CheckCode::D412) { if checker.settings.enabled[CheckCode::D412 as usize] {
let mut check = Check::new( let mut check = Check::new(
CheckKind::NoBlankLinesBetweenHeaderAndContent( CheckKind::NoBlankLinesBetweenHeaderAndContent(
context.section_name.to_string(), context.section_name.to_string(),
@ -1138,7 +1138,7 @@ fn blanks_and_section_underline(
} }
} }
} else { } else {
if checker.settings.enabled.contains(&CheckCode::D414) { if checker.settings.enabled[CheckCode::D414 as usize] {
checker.add_check(Check::new( checker.add_check(Check::new(
CheckKind::NonEmptySection(context.section_name.to_string()), CheckKind::NonEmptySection(context.section_name.to_string()),
Range::from_located(docstring), Range::from_located(docstring),
@ -1158,7 +1158,7 @@ fn common_section(
.docstring .docstring
.expect("Sections are only available for docstrings."); .expect("Sections are only available for docstrings.");
if checker.settings.enabled.contains(&CheckCode::D405) { if checker.settings.enabled[CheckCode::D405 as usize] {
if !style if !style
.section_names() .section_names()
.contains(&context.section_name.as_str()) .contains(&context.section_name.as_str())
@ -1197,7 +1197,7 @@ fn common_section(
} }
} }
if checker.settings.enabled.contains(&CheckCode::D214) { if checker.settings.enabled[CheckCode::D214 as usize] {
let leading_space = helpers::leading_space(context.line); let leading_space = helpers::leading_space(context.line);
let indentation = helpers::indentation(checker, docstring); let indentation = helpers::indentation(checker, docstring);
if leading_space.len() > indentation.len() { if leading_space.len() > indentation.len() {
@ -1227,7 +1227,7 @@ fn common_section(
.unwrap_or(true) .unwrap_or(true)
{ {
if context.is_last_section { if context.is_last_section {
if checker.settings.enabled.contains(&CheckCode::D413) { if checker.settings.enabled[CheckCode::D413 as usize] {
let mut check = Check::new( let mut check = Check::new(
CheckKind::BlankLineAfterLastSection(context.section_name.to_string()), CheckKind::BlankLineAfterLastSection(context.section_name.to_string()),
Range::from_located(docstring), Range::from_located(docstring),
@ -1248,7 +1248,7 @@ fn common_section(
checker.add_check(check); checker.add_check(check);
} }
} else { } else {
if checker.settings.enabled.contains(&CheckCode::D410) { if checker.settings.enabled[CheckCode::D410 as usize] {
let mut check = Check::new( let mut check = Check::new(
CheckKind::BlankLineAfterSection(context.section_name.to_string()), CheckKind::BlankLineAfterSection(context.section_name.to_string()),
Range::from_located(docstring), Range::from_located(docstring),
@ -1271,7 +1271,7 @@ fn common_section(
} }
} }
if checker.settings.enabled.contains(&CheckCode::D411) { if checker.settings.enabled[CheckCode::D411 as usize] {
if !context.previous_line.is_empty() { if !context.previous_line.is_empty() {
let mut check = Check::new( let mut check = Check::new(
CheckKind::BlankLineBeforeSection(context.section_name.to_string()), CheckKind::BlankLineBeforeSection(context.section_name.to_string()),
@ -1430,7 +1430,7 @@ fn parameters_section(checker: &mut Checker, definition: &Definition, context: &
fn numpy_section(checker: &mut Checker, definition: &Definition, context: &SectionContext) { fn numpy_section(checker: &mut Checker, definition: &Definition, context: &SectionContext) {
common_section(checker, definition, context, &SectionStyle::NumPy); common_section(checker, definition, context, &SectionStyle::NumPy);
if checker.settings.enabled.contains(&CheckCode::D406) { if checker.settings.enabled[CheckCode::D406 as usize] {
let suffix = context let suffix = context
.line .line
.trim() .trim()
@ -1468,7 +1468,7 @@ fn numpy_section(checker: &mut Checker, definition: &Definition, context: &Secti
} }
} }
if checker.settings.enabled.contains(&CheckCode::D417) { if checker.settings.enabled[CheckCode::D417 as usize] {
let capitalized_section_name = titlecase::titlecase(&context.section_name); let capitalized_section_name = titlecase::titlecase(&context.section_name);
if capitalized_section_name == "Parameters" { if capitalized_section_name == "Parameters" {
parameters_section(checker, definition, context); parameters_section(checker, definition, context);
@ -1479,7 +1479,7 @@ fn numpy_section(checker: &mut Checker, definition: &Definition, context: &Secti
fn google_section(checker: &mut Checker, definition: &Definition, context: &SectionContext) { fn google_section(checker: &mut Checker, definition: &Definition, context: &SectionContext) {
common_section(checker, definition, context, &SectionStyle::Google); common_section(checker, definition, context, &SectionStyle::Google);
if checker.settings.enabled.contains(&CheckCode::D416) { if checker.settings.enabled[CheckCode::D416 as usize] {
let suffix = context let suffix = context
.line .line
.trim() .trim()
@ -1518,7 +1518,7 @@ fn google_section(checker: &mut Checker, definition: &Definition, context: &Sect
} }
} }
if checker.settings.enabled.contains(&CheckCode::D417) { if checker.settings.enabled[CheckCode::D417 as usize] {
let capitalized_section_name = titlecase::titlecase(&context.section_name); let capitalized_section_name = titlecase::titlecase(&context.section_name);
if capitalized_section_name == "Args" || capitalized_section_name == "Arguments" { if capitalized_section_name == "Args" || capitalized_section_name == "Arguments" {
args_section(checker, definition, context); args_section(checker, definition, context);

2
src/rules/checks.rs
View File

@ -1646,7 +1646,7 @@ pub fn ambiguous_unicode_character(
end_location, end_location,
}, },
); );
if settings.enabled.contains(check.kind.code()) { if settings.enabled[check.kind.code().clone() as usize] {
if autofix.patch() && settings.fixable.contains(check.kind.code()) { if autofix.patch() && settings.fixable.contains(check.kind.code()) {
check.amend(Fix::replacement( check.amend(Fix::replacement(
representant.to_string(), representant.to_string(),

18
src/settings/mod.rs
View File

@ -27,7 +27,7 @@ pub mod user;
#[derive(Debug)] #[derive(Debug)]
pub struct Settings { pub struct Settings {
pub dummy_variable_rgx: Regex, pub dummy_variable_rgx: Regex,
pub enabled: FnvHashSet<CheckCode>, pub enabled: Vec<bool>,
pub exclude: Vec<FilePattern>, pub exclude: Vec<FilePattern>,
pub extend_exclude: Vec<FilePattern>, pub extend_exclude: Vec<FilePattern>,
pub fixable: FnvHashSet<CheckCode>, pub fixable: FnvHashSet<CheckCode>,
@ -64,7 +64,7 @@ impl Settings {
), ),
exclude: config.exclude, exclude: config.exclude,
extend_exclude: config.extend_exclude, extend_exclude: config.extend_exclude,
fixable: resolve_codes(&config.fixable, &config.unfixable), fixable: FnvHashSet::default(), // resolve_codes(&config.fixable, &config.unfixable),
flake8_annotations: config.flake8_annotations, flake8_annotations: config.flake8_annotations,
flake8_bugbear: config.flake8_bugbear, flake8_bugbear: config.flake8_bugbear,
flake8_quotes: config.flake8_quotes, flake8_quotes: config.flake8_quotes,
@ -83,7 +83,7 @@ impl Settings {
pub fn for_rule(check_code: CheckCode) -> Self { pub fn for_rule(check_code: CheckCode) -> Self {
Self { Self {
dummy_variable_rgx: Regex::new("^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$").unwrap(), dummy_variable_rgx: Regex::new("^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$").unwrap(),
enabled: FnvHashSet::from_iter([check_code.clone()]), enabled: vec![], // FnvHashSet::from_iter([check_code.clone()]),
fixable: FnvHashSet::from_iter([check_code]), fixable: FnvHashSet::from_iter([check_code]),
exclude: Default::default(), exclude: Default::default(),
extend_exclude: Default::default(), extend_exclude: Default::default(),
@ -105,7 +105,7 @@ impl Settings {
pub fn for_rules(check_codes: Vec<CheckCode>) -> Self { pub fn for_rules(check_codes: Vec<CheckCode>) -> Self {
Self { Self {
dummy_variable_rgx: Regex::new("^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$").unwrap(), dummy_variable_rgx: Regex::new("^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$").unwrap(),
enabled: FnvHashSet::from_iter(check_codes.clone()), enabled: vec![], // FnvHashSet::from_iter(check_codes.clone()),
fixable: FnvHashSet::from_iter(check_codes), fixable: FnvHashSet::from_iter(check_codes),
exclude: Default::default(), exclude: Default::default(),
extend_exclude: Default::default(), extend_exclude: Default::default(),
@ -154,8 +154,8 @@ impl Hash for Settings {
/// Given a set of selected and ignored prefixes, resolve the set of enabled /// Given a set of selected and ignored prefixes, resolve the set of enabled
/// error codes. /// error codes.
fn resolve_codes(select: &[CheckCodePrefix], ignore: &[CheckCodePrefix]) -> FnvHashSet<CheckCode> { fn resolve_codes(select: &[CheckCodePrefix], ignore: &[CheckCodePrefix]) -> Vec<bool> {
let mut codes: FnvHashSet<CheckCode> = FnvHashSet::default(); let mut codes = vec![false; 203];
for specificity in [ for specificity in [
PrefixSpecificity::Category, PrefixSpecificity::Category,
PrefixSpecificity::Hundreds, PrefixSpecificity::Hundreds,
@ -164,13 +164,15 @@ fn resolve_codes(select: &[CheckCodePrefix], ignore: &[CheckCodePrefix]) -> FnvH
] { ] {
for prefix in select { for prefix in select {
if prefix.specificity() == specificity { if prefix.specificity() == specificity {
codes.extend(prefix.codes()); for code in prefix.codes() {
codes[code as usize] = true;
}
} }
} }
for prefix in ignore { for prefix in ignore {
if prefix.specificity() == specificity { if prefix.specificity() == specificity {
for code in prefix.codes() { for code in prefix.codes() {
codes.remove(&code); codes[code as usize] = false;
} }
} }
} }