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

Rename `Check` to `Diagnostic` (#1725) 

Along with:

- `CheckKind` -> `DiagnosticKind`
- `CheckCode` -> `RuleCode`
- `CheckCodePrefix` -> `RuleCodePrefix`
This commit is contained in:
Charlie Marsh 2023-01-08 17:46:20 -05:00 committed by GitHub
parent 498134b7ee
commit 09dc3c7225
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
204 changed files with 4222 additions and 4145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
README.md
View File

@ -344,7 +344,7 @@ Options:
--isolated
Ignore all configuration files
--select <SELECT>
Comma-separated list of error codes to enable (or ALL, to enable all checks)
Comma-separated list of rule codes to enable (or ALL, to enable all rules)
--extend-select <EXTEND_SELECT>
Like --select, but adds additional error codes on top of the selected ones
--ignore <IGNORE>
@ -1867,7 +1867,7 @@ by `ignore`.
**Default value**: `[]`
**Type**: `Vec<CheckCodePrefix>`
**Type**: `Vec<RuleCodePrefix>`
**Example usage**:
@ -1886,7 +1886,7 @@ by `select`.
**Default value**: `[]`
**Type**: `Vec<CheckCodePrefix>`
**Type**: `Vec<RuleCodePrefix>`
**Example usage**:
@ -1961,7 +1961,7 @@ A list of check code prefixes to consider autofix-able.
**Default value**: `["A", "ANN", "ARG", "B", "BLE", "C", "D", "E", "ERA", "F", "FBT", "I", "ICN", "N", "PGH", "PLC", "PLE", "PLR", "PLW", "Q", "RET", "RUF", "S", "T", "TID", "UP", "W", "YTT"]`
**Type**: `Vec<CheckCodePrefix>`
**Type**: `Vec<RuleCodePrefix>`
**Example usage**:
@ -2033,7 +2033,7 @@ specific prefixes.
**Default value**: `[]`
**Type**: `Vec<CheckCodePrefix>`
**Type**: `Vec<RuleCodePrefix>`
**Example usage**:
@ -2092,7 +2092,7 @@ when considering any matching files.
**Default value**: `{}`
**Type**: `HashMap<String, Vec<CheckCodePrefix>>`
**Type**: `HashMap<String, Vec<RuleCodePrefix>>`
**Example usage**:
@ -2156,7 +2156,7 @@ specific prefixes.
**Default value**: `["E", "F"]`
**Type**: `Vec<CheckCodePrefix>`
**Type**: `Vec<RuleCodePrefix>`
**Example usage**:
@ -2276,7 +2276,7 @@ A list of check code prefixes to consider un-autofix-able.
**Default value**: `[]`
**Type**: `Vec<CheckCodePrefix>`
**Type**: `Vec<RuleCodePrefix>`
**Example usage**:

54
flake8_to_ruff/src/converter.rs
View File

@ -7,7 +7,7 @@ use ruff::flake8_pytest_style::types::{
use ruff::flake8_quotes::settings::Quote;
use ruff::flake8_tidy_imports::settings::Strictness;
use ruff::pydocstyle::settings::Convention;
use ruff::registry::CheckCodePrefix;
use ruff::registry::RuleCodePrefix;
use ruff::settings::options::Options;
use ruff::settings::pyproject::Pyproject;
use ruff::{
@ -30,7 +30,7 @@ pub fn convert(
.expect("Unable to find flake8 section in INI file");
// Extract all referenced check code prefixes, to power plugin inference.
let mut referenced_codes: BTreeSet<CheckCodePrefix> = BTreeSet::default();
let mut referenced_codes: BTreeSet<RuleCodePrefix> = BTreeSet::default();
for (key, value) in flake8 {
if let Some(value) = value {
match key.as_str() {
@ -60,7 +60,7 @@ pub fn convert(
}
let from_codes = plugin::infer_plugins_from_codes(&referenced_codes);
if !from_codes.is_empty() {
eprintln!("Inferred plugins from referenced check codes: {from_codes:#?}");
eprintln!("Inferred plugins from referenced codes: {from_codes:#?}");
}
from_options.into_iter().chain(from_codes).collect()
});
@ -345,7 +345,7 @@ mod tests {
use anyhow::Result;
use ruff::pydocstyle::settings::Convention;
use ruff::registry::CheckCodePrefix;
use ruff::registry::RuleCodePrefix;
use ruff::settings::options::Options;
use ruff::settings::pyproject::Pyproject;
use ruff::{flake8_quotes, pydocstyle};
@ -382,9 +382,9 @@ mod tests {
required_version: None,
respect_gitignore: None,
select: Some(vec![
CheckCodePrefix::E,
CheckCodePrefix::F,
CheckCodePrefix::W,
RuleCodePrefix::E,
RuleCodePrefix::F,
RuleCodePrefix::W,
]),
show_source: None,
src: None,
@ -445,9 +445,9 @@ mod tests {
required_version: None,
respect_gitignore: None,
select: Some(vec![
CheckCodePrefix::E,
CheckCodePrefix::F,
CheckCodePrefix::W,
RuleCodePrefix::E,
RuleCodePrefix::F,
RuleCodePrefix::W,
]),
show_source: None,
src: None,
@ -508,9 +508,9 @@ mod tests {
required_version: None,
respect_gitignore: None,
select: Some(vec![
CheckCodePrefix::E,
CheckCodePrefix::F,
CheckCodePrefix::W,
RuleCodePrefix::E,
RuleCodePrefix::F,
RuleCodePrefix::W,
]),
show_source: None,
src: None,
@ -571,9 +571,9 @@ mod tests {
required_version: None,
respect_gitignore: None,
select: Some(vec![
CheckCodePrefix::E,
CheckCodePrefix::F,
CheckCodePrefix::W,
RuleCodePrefix::E,
RuleCodePrefix::F,
RuleCodePrefix::W,
]),
show_source: None,
src: None,
@ -634,9 +634,9 @@ mod tests {
required_version: None,
respect_gitignore: None,
select: Some(vec![
CheckCodePrefix::E,
CheckCodePrefix::F,
CheckCodePrefix::W,
RuleCodePrefix::E,
RuleCodePrefix::F,
RuleCodePrefix::W,
]),
show_source: None,
src: None,
@ -705,10 +705,10 @@ mod tests {
required_version: None,
respect_gitignore: None,
select: Some(vec![
CheckCodePrefix::D,
CheckCodePrefix::E,
CheckCodePrefix::F,
CheckCodePrefix::W,
RuleCodePrefix::D,
RuleCodePrefix::E,
RuleCodePrefix::F,
RuleCodePrefix::W,
]),
show_source: None,
src: None,
@ -771,10 +771,10 @@ mod tests {
required_version: None,
respect_gitignore: None,
select: Some(vec![
CheckCodePrefix::E,
CheckCodePrefix::F,
CheckCodePrefix::Q,
CheckCodePrefix::W,
RuleCodePrefix::E,
RuleCodePrefix::F,
RuleCodePrefix::Q,
RuleCodePrefix::W,
]),
show_source: None,
src: None,

69
flake8_to_ruff/src/parser.rs
View File

@ -3,16 +3,16 @@ use std::str::FromStr;
use anyhow::{bail, Result};
use once_cell::sync::Lazy;
use regex::Regex;
use ruff::registry::{CheckCodePrefix, PREFIX_REDIRECTS};
use ruff::registry::{RuleCodePrefix, PREFIX_REDIRECTS};
use ruff::settings::types::PatternPrefixPair;
use rustc_hash::FxHashMap;
static COMMA_SEPARATED_LIST_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"[,\s]").unwrap());
/// Parse a comma-separated list of `CheckCodePrefix` values (e.g.,
/// Parse a comma-separated list of `RuleCodePrefix` values (e.g.,
/// "F401,E501").
pub fn parse_prefix_codes(value: &str) -> Vec<CheckCodePrefix> {
let mut codes: Vec<CheckCodePrefix> = vec![];
pub fn parse_prefix_codes(value: &str) -> Vec<RuleCodePrefix> {
let mut codes: Vec<RuleCodePrefix> = vec![];
for code in COMMA_SEPARATED_LIST_RE.split(value) {
let code = code.trim();
if code.is_empty() {
@ -20,7 +20,7 @@ pub fn parse_prefix_codes(value: &str) -> Vec<CheckCodePrefix> {
}
if let Some(code) = PREFIX_REDIRECTS.get(code) {
codes.push(code.clone());
} else if let Ok(code) = CheckCodePrefix::from_str(code) {
} else if let Ok(code) = RuleCodePrefix::from_str(code) {
codes.push(code);
} else {
eprintln!("Unsupported prefix code: {code}");
@ -81,7 +81,8 @@ impl State {
}
}
/// Generate the list of `StrCheckCodePair` pairs for the current state.
/// Generate the list of `StrRuleCodePair` pairs for the current
/// state.
fn parse(&self) -> Vec<PatternPrefixPair> {
let mut codes: Vec<PatternPrefixPair> = vec![];
for code in &self.codes {
@ -92,7 +93,7 @@ impl State {
prefix: code.clone(),
});
}
} else if let Ok(code) = CheckCodePrefix::from_str(code) {
} else if let Ok(code) = RuleCodePrefix::from_str(code) {
for filename in &self.filenames {
codes.push(PatternPrefixPair {
pattern: filename.clone(),
@ -186,8 +187,8 @@ pub fn parse_files_to_codes_mapping(value: &str) -> Result<Vec<PatternPrefixPair
/// Collect a list of `PatternPrefixPair` structs as a `BTreeMap`.
pub fn collect_per_file_ignores(
pairs: Vec<PatternPrefixPair>,
) -> FxHashMap<String, Vec<CheckCodePrefix>> {
let mut per_file_ignores: FxHashMap<String, Vec<CheckCodePrefix>> = FxHashMap::default();
) -> FxHashMap<String, Vec<RuleCodePrefix>> {
let mut per_file_ignores: FxHashMap<String, Vec<RuleCodePrefix>> = FxHashMap::default();
for pair in pairs {
per_file_ignores
.entry(pair.pattern)
@ -200,7 +201,7 @@ pub fn collect_per_file_ignores(
#[cfg(test)]
mod tests {
use anyhow::Result;
use ruff::registry::CheckCodePrefix;
use ruff::registry::RuleCodePrefix;
use ruff::settings::types::PatternPrefixPair;
use crate::parser::{parse_files_to_codes_mapping, parse_prefix_codes, parse_strings};
@ -208,27 +209,27 @@ mod tests {
#[test]
fn it_parses_prefix_codes() {
let actual = parse_prefix_codes("");
let expected: Vec<CheckCodePrefix> = vec![];
let expected: Vec<RuleCodePrefix> = vec![];
assert_eq!(actual, expected);
let actual = parse_prefix_codes(" ");
let expected: Vec<CheckCodePrefix> = vec![];
let expected: Vec<RuleCodePrefix> = vec![];
assert_eq!(actual, expected);
let actual = parse_prefix_codes("F401");
let expected = vec![CheckCodePrefix::F401];
let expected = vec![RuleCodePrefix::F401];
assert_eq!(actual, expected);
let actual = parse_prefix_codes("F401,");
let expected = vec![CheckCodePrefix::F401];
let expected = vec![RuleCodePrefix::F401];
assert_eq!(actual, expected);
let actual = parse_prefix_codes("F401,E501");
let expected = vec![CheckCodePrefix::F401, CheckCodePrefix::E501];
let expected = vec![RuleCodePrefix::F401, RuleCodePrefix::E501];
assert_eq!(actual, expected);
let actual = parse_prefix_codes("F401, E501");
let expected = vec![CheckCodePrefix::F401, CheckCodePrefix::E501];
let expected = vec![RuleCodePrefix::F401, RuleCodePrefix::E501];
assert_eq!(actual, expected);
}
@ -281,11 +282,11 @@ mod tests {
let expected: Vec<PatternPrefixPair> = vec![
PatternPrefixPair {
pattern: "locust/test/*".to_string(),
prefix: CheckCodePrefix::F841,
prefix: RuleCodePrefix::F841,
},
PatternPrefixPair {
pattern: "examples/*".to_string(),
prefix: CheckCodePrefix::F841,
prefix: RuleCodePrefix::F841,
},
];
assert_eq!(actual, expected);
@ -301,23 +302,23 @@ mod tests {
let expected: Vec<PatternPrefixPair> = vec![
PatternPrefixPair {
pattern: "t/*".to_string(),
prefix: CheckCodePrefix::D,
prefix: RuleCodePrefix::D,
},
PatternPrefixPair {
pattern: "setup.py".to_string(),
prefix: CheckCodePrefix::D,
prefix: RuleCodePrefix::D,
},
PatternPrefixPair {
pattern: "examples/*".to_string(),
prefix: CheckCodePrefix::D,
prefix: RuleCodePrefix::D,
},
PatternPrefixPair {
pattern: "docs/*".to_string(),
prefix: CheckCodePrefix::D,
prefix: RuleCodePrefix::D,
},
PatternPrefixPair {
pattern: "extra/*".to_string(),
prefix: CheckCodePrefix::D,
prefix: RuleCodePrefix::D,
},
];
assert_eq!(actual, expected);
@ -339,47 +340,47 @@ mod tests {
let expected: Vec<PatternPrefixPair> = vec![
PatternPrefixPair {
pattern: "scrapy/__init__.py".to_string(),
prefix: CheckCodePrefix::E402,
prefix: RuleCodePrefix::E402,
},
PatternPrefixPair {
pattern: "scrapy/core/downloader/handlers/http.py".to_string(),
prefix: CheckCodePrefix::F401,
prefix: RuleCodePrefix::F401,
},
PatternPrefixPair {
pattern: "scrapy/http/__init__.py".to_string(),
prefix: CheckCodePrefix::F401,
prefix: RuleCodePrefix::F401,
},
PatternPrefixPair {
pattern: "scrapy/linkextractors/__init__.py".to_string(),
prefix: CheckCodePrefix::E402,
prefix: RuleCodePrefix::E402,
},
PatternPrefixPair {
pattern: "scrapy/linkextractors/__init__.py".to_string(),
prefix: CheckCodePrefix::F401,
prefix: RuleCodePrefix::F401,
},
PatternPrefixPair {
pattern: "scrapy/selector/__init__.py".to_string(),
prefix: CheckCodePrefix::F401,
prefix: RuleCodePrefix::F401,
},
PatternPrefixPair {
pattern: "scrapy/spiders/__init__.py".to_string(),
prefix: CheckCodePrefix::E402,
prefix: RuleCodePrefix::E402,
},
PatternPrefixPair {
pattern: "scrapy/spiders/__init__.py".to_string(),
prefix: CheckCodePrefix::F401,
prefix: RuleCodePrefix::F401,
},
PatternPrefixPair {
pattern: "scrapy/utils/url.py".to_string(),
prefix: CheckCodePrefix::F403,
prefix: RuleCodePrefix::F403,
},
PatternPrefixPair {
pattern: "scrapy/utils/url.py".to_string(),
prefix: CheckCodePrefix::F405,
prefix: RuleCodePrefix::F405,
},
PatternPrefixPair {
pattern: "tests/test_loader.py".to_string(),
prefix: CheckCodePrefix::E741,
prefix: RuleCodePrefix::E741,
},
];
assert_eq!(actual, expected);

57
flake8_to_ruff/src/plugin.rs
View File

@ -3,7 +3,7 @@ use std::fmt;
use std::str::FromStr;
use anyhow::anyhow;
use ruff::registry::CheckCodePrefix;
use ruff::registry::RuleCodePrefix;
#[derive(Clone, Ord, PartialOrd, Eq, PartialEq)]
pub enum Plugin {
@ -97,32 +97,32 @@ impl fmt::Debug for Plugin {
}
impl Plugin {
pub fn prefix(&self) -> CheckCodePrefix {
pub fn prefix(&self) -> RuleCodePrefix {
match self {
Plugin::Flake8Annotations => CheckCodePrefix::ANN,
Plugin::Flake8Bandit => CheckCodePrefix::S,
Plugin::Flake8Annotations => RuleCodePrefix::ANN,
Plugin::Flake8Bandit => RuleCodePrefix::S,
// TODO(charlie): Handle rename of `B` to `BLE`.
Plugin::Flake8BlindExcept => CheckCodePrefix::BLE,
Plugin::Flake8Bugbear => CheckCodePrefix::B,
Plugin::Flake8Builtins => CheckCodePrefix::A,
Plugin::Flake8Comprehensions => CheckCodePrefix::C4,
Plugin::Flake8Datetimez => CheckCodePrefix::DTZ,
Plugin::Flake8Debugger => CheckCodePrefix::T1,
Plugin::Flake8Docstrings => CheckCodePrefix::D,
Plugin::Flake8BlindExcept => RuleCodePrefix::BLE,
Plugin::Flake8Bugbear => RuleCodePrefix::B,
Plugin::Flake8Builtins => RuleCodePrefix::A,
Plugin::Flake8Comprehensions => RuleCodePrefix::C4,
Plugin::Flake8Datetimez => RuleCodePrefix::DTZ,
Plugin::Flake8Debugger => RuleCodePrefix::T1,
Plugin::Flake8Docstrings => RuleCodePrefix::D,
// TODO(charlie): Handle rename of `E` to `ERA`.
Plugin::Flake8Eradicate => CheckCodePrefix::ERA,
Plugin::Flake8ErrMsg => CheckCodePrefix::EM,
Plugin::Flake8ImplicitStrConcat => CheckCodePrefix::ISC,
Plugin::Flake8Print => CheckCodePrefix::T2,
Plugin::Flake8PytestStyle => CheckCodePrefix::PT,
Plugin::Flake8Quotes => CheckCodePrefix::Q,
Plugin::Flake8Return => CheckCodePrefix::RET,
Plugin::Flake8Simplify => CheckCodePrefix::SIM,
Plugin::Flake8TidyImports => CheckCodePrefix::TID25,
Plugin::McCabe => CheckCodePrefix::C9,
Plugin::PandasVet => CheckCodePrefix::PD,
Plugin::PEP8Naming => CheckCodePrefix::N,
Plugin::Pyupgrade => CheckCodePrefix::UP,
Plugin::Flake8Eradicate => RuleCodePrefix::ERA,
Plugin::Flake8ErrMsg => RuleCodePrefix::EM,
Plugin::Flake8ImplicitStrConcat => RuleCodePrefix::ISC,
Plugin::Flake8Print => RuleCodePrefix::T2,
Plugin::Flake8PytestStyle => RuleCodePrefix::PT,
Plugin::Flake8Quotes => RuleCodePrefix::Q,
Plugin::Flake8Return => RuleCodePrefix::RET,
Plugin::Flake8Simplify => RuleCodePrefix::SIM,
Plugin::Flake8TidyImports => RuleCodePrefix::TID25,
Plugin::McCabe => RuleCodePrefix::C9,
Plugin::PandasVet => RuleCodePrefix::PD,
Plugin::PEP8Naming => RuleCodePrefix::N,
Plugin::Pyupgrade => RuleCodePrefix::UP,
}
}
}
@ -269,7 +269,7 @@ pub fn infer_plugins_from_options(flake8: &HashMap<String, Option<String>>) -> V
///
/// For example, if the user ignores `ANN101`, we should infer that
/// `flake8-annotations` is active.
pub fn infer_plugins_from_codes(codes: &BTreeSet<CheckCodePrefix>) -> Vec<Plugin> {
pub fn infer_plugins_from_codes(codes: &BTreeSet<RuleCodePrefix>) -> Vec<Plugin> {
[
Plugin::Flake8Annotations,
Plugin::Flake8Bandit,
@ -307,9 +307,10 @@ pub fn infer_plugins_from_codes(codes: &BTreeSet<CheckCodePrefix>) -> Vec<Plugin
.collect()
}
/// Resolve the set of enabled `CheckCodePrefix` values for the given plugins.
pub fn resolve_select(plugins: &[Plugin]) -> BTreeSet<CheckCodePrefix> {
let mut select = BTreeSet::from([CheckCodePrefix::F, CheckCodePrefix::E, CheckCodePrefix::W]);
/// Resolve the set of enabled `RuleCodePrefix` values for the given
/// plugins.
pub fn resolve_select(plugins: &[Plugin]) -> BTreeSet<RuleCodePrefix> {
let mut select = BTreeSet::from([RuleCodePrefix::F, RuleCodePrefix::E, RuleCodePrefix::W]);
select.extend(plugins.iter().map(Plugin::prefix));
select
}

1076
ruff.schema.json
View File

File diff suppressed because it is too large Load Diff

16
ruff_dev/src/generate_rules_table.rs
View File

@ -3,7 +3,7 @@
use anyhow::Result;
use clap::Args;
use itertools::Itertools;
use ruff::registry::{CheckCategory, CheckCode};
use ruff::registry::{CheckCategory, RuleCode};
use strum::IntoEnumIterator;
use crate::utils::replace_readme_section;
@ -55,15 +55,15 @@ pub fn main(cli: &Cli) -> Result<()> {
table_out.push_str("| ---- | ---- | ------- | --- |");
table_out.push('\n');
for check_code in CheckCode::iter() {
if check_code.category() == check_category {
let check_kind = check_code.kind();
let fix_token = if check_kind.fixable() { "🛠" } else { "" };
for rule_code in RuleCode::iter() {
if rule_code.category() == check_category {
let kind = rule_code.kind();
let fix_token = if kind.fixable() { "🛠" } else { "" };
table_out.push_str(&format!(
"| {} | {} | {} | {} |",
check_kind.code().as_ref(),
check_kind.as_ref(),
check_kind.summary().replace('|', r"\|"),
kind.code().as_ref(),
kind.as_ref(),
kind.summary().replace('|', r"\|"),
fix_token
));
table_out.push('\n');

8
ruff_macros/src/lib.rs
View File

@ -14,8 +14,8 @@
use syn::{parse_macro_input, DeriveInput};
mod check_code_prefix;
mod config;
mod rule_code_prefix;
#[proc_macro_derive(ConfigurationOptions, attributes(option, doc, option_group))]
pub fn derive_config(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@ -26,11 +26,11 @@ pub fn derive_config(input: proc_macro::TokenStream) -> proc_macro::TokenStream
.into()
}
#[proc_macro_derive(CheckCodePrefix)]
pub fn derive_check_code_prefix(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
#[proc_macro_derive(RuleCodePrefix)]
pub fn derive_rule_code_prefix(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = parse_macro_input!(input as DeriveInput);
check_code_prefix::derive_impl(input)
rule_code_prefix::derive_impl(input)
.unwrap_or_else(syn::Error::into_compile_error)
.into()
}

19
ruff_macros/src/check_code_prefix.rs → ruff_macros/src/rule_code_prefix.rs
View File

@ -9,7 +9,8 @@ use syn::{DataEnum, DeriveInput, Ident, Variant};
const ALL: &str = "ALL";
/// A hash map from deprecated `CheckCodePrefix` to latest `CheckCodePrefix`.
/// A hash map from deprecated `RuleCodePrefix` to latest
/// `RuleCodePrefix`.
pub static PREFIX_REDIRECTS: Lazy<HashMap<&'static str, &'static str>> = Lazy::new(|| {
HashMap::from_iter([
// TODO(charlie): Remove by 2023-01-01.
@ -90,7 +91,7 @@ pub fn derive_impl(input: DeriveInput) -> syn::Result<proc_macro2::TokenStream>
let syn::Data::Enum(DataEnum { variants, .. }) = data else {
return Err(syn::Error::new(
ident.span(),
"Can only derive `CheckCodePrefix` from enums.",
"Can only derive `RuleCodePrefix` from enums.",
));
};
@ -117,7 +118,7 @@ fn expand(
prefix_ident: &Ident,
variants: &Punctuated<Variant, Comma>,
) -> proc_macro2::TokenStream {
// Build up a map from prefix to matching CheckCodes.
// Build up a map from prefix to matching RuleCodes.
let mut prefix_to_codes: BTreeMap<Ident, BTreeSet<String>> = BTreeMap::default();
for variant in variants {
let span = variant.ident.span();
@ -141,12 +142,12 @@ fn expand(
}
// Add any prefix aliases (e.g., "U" to "UP").
for (alias, check_code) in PREFIX_REDIRECTS.iter() {
for (alias, rule_code) in PREFIX_REDIRECTS.iter() {
prefix_to_codes.insert(
Ident::new(alias, Span::call_site()),
prefix_to_codes
.get(&Ident::new(check_code, Span::call_site()))
.unwrap_or_else(|| panic!("Unknown CheckCode: {alias:?}"))
.get(&Ident::new(rule_code, Span::call_site()))
.unwrap_or_else(|| panic!("Unknown RuleCode: {alias:?}"))
.clone(),
);
}
@ -159,8 +160,8 @@ fn expand(
let prefix_impl = generate_impls(ident, prefix_ident, &prefix_to_codes);
let prefix_redirects = PREFIX_REDIRECTS.iter().map(|(alias, check_code)| {
let code = Ident::new(check_code, Span::call_site());
let prefix_redirects = PREFIX_REDIRECTS.iter().map(|(alias, rule_code)| {
let code = Ident::new(rule_code, Span::call_site());
quote! {
(#alias, #prefix_ident::#code)
}
@ -186,7 +187,7 @@ fn expand(
#prefix_impl
/// A hash map from deprecated `CheckCodePrefix` to latest `CheckCodePrefix`.
/// A hash map from deprecated `RuleCodePrefix` to latest `RuleCodePrefix`.
pub static PREFIX_REDIRECTS: ::once_cell::sync::Lazy<::rustc_hash::FxHashMap<&'static str, #prefix_ident>> = ::once_cell::sync::Lazy::new(|| {
::rustc_hash::FxHashMap::from_iter([
#(#prefix_redirects),*

26
scripts/add_check.py
View File

@ -43,9 +43,9 @@ def main(*, name: str, code: str, plugin: str) -> None:
with open(os.path.join(ROOT_DIR, f"src/{dir_name(plugin)}/mod.rs"), "w") as fp:
for line in content.splitlines():
if line.strip() == "fn checks(check_code: CheckCode, path: &Path) -> Result<()> {":
indent = line.split("fn checks(check_code: CheckCode, path: &Path) -> Result<()> {")[0]
fp.write(f'{indent}#[test_case(CheckCode::{code}, Path::new("{code}.py"); "{code}")]')
if line.strip() == "fn diagnostics(check_code: RuleCode, path: &Path) -> Result<()> {":
indent = line.split("fn diagnostics(check_code: RuleCode, path: &Path) -> Result<()> {")[0]
fp.write(f'{indent}#[test_case(RuleCode::{code}, Path::new("{code}.py"); "{code}")]')
fp.write("\n")
fp.write(line)
@ -73,39 +73,39 @@ pub fn {snake_case(name)}(checker: &mut Checker) {{}}
if line.strip() == f"// {plugin}":
if index == 0:
# `CheckCode` definition
# `RuleCode` definition
indent = line.split(f"// {plugin}")[0]
fp.write(f"{indent}{code},")
fp.write("\n")
elif index == 1:
# `CheckKind` definition
# `DiagnosticKind` definition
indent = line.split(f"// {plugin}")[0]
fp.write(f"{indent}{name},")
fp.write("\n")
elif index == 2:
# `CheckCode#kind()`
# `RuleCode#kind()`
indent = line.split(f"// {plugin}")[0]
fp.write(f"{indent}CheckCode::{code} => CheckKind::{name},")
fp.write(f"{indent}RuleCode::{code} => DiagnosticKind::{name},")
fp.write("\n")
elif index == 3:
# `CheckCode#category()`
# `RuleCode#category()`
indent = line.split(f"// {plugin}")[0]
fp.write(f"{indent}CheckCode::{code} => CheckCategory::{pascal_case(plugin)},")
fp.write(f"{indent}RuleCode::{code} => CheckCategory::{pascal_case(plugin)},")
fp.write("\n")
elif index == 4:
# `CheckKind#code()`
# `DiagnosticKind#code()`
indent = line.split(f"// {plugin}")[0]
fp.write(f"{indent}CheckKind::{name} => &CheckCode::{code},")
fp.write(f"{indent}DiagnosticKind::{name} => &RuleCode::{code},")
fp.write("\n")
elif index == 5:
# `CheckCode#body`
# `RuleCode#body`
indent = line.split(f"// {plugin}")[0]
fp.write(f'{indent}CheckKind::{name} => todo!("Write message body for {code}"),')
fp.write(f'{indent}DiagnosticKind::{name} => todo!("Write message body for {code}"),')
fp.write("\n")
index += 1

12
scripts/add_plugin.py
View File

@ -45,19 +45,19 @@ mod tests {
use anyhow::Result;
use test_case::test_case;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::linter::test_path;
use crate::settings;
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
fn diagnostics(check_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
let diagnostics =test_path(
Path::new("./resources/test/fixtures/%s")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}
@ -90,8 +90,8 @@ mod tests {
fp.write(f'{indent}CheckCategory::{pascal_case(plugin)} => "{plugin}",')
fp.write("\n")
elif line.strip() == "CheckCategory::Ruff => vec![CheckCodePrefix::RUF],":
indent = line.split("CheckCategory::Ruff => vec![CheckCodePrefix::RUF],")[0]
elif line.strip() == "CheckCategory::Ruff => vec![RuleCodePrefix::RUF],":
indent = line.split("CheckCategory::Ruff => vec![RuleCodePrefix::RUF],")[0]
fp.write(
f"{indent}CheckCategory::{pascal_case(plugin)} => vec![\n"
f'{indent} todo!("Fill-in prefix after generating codes")\n'

4
src/autofix/fixer.rs
View File

@ -7,7 +7,7 @@ use rustpython_parser::ast::Location;
use crate::ast::types::Range;
use crate::autofix::Fix;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::source_code_locator::SourceCodeLocator;
#[derive(Debug, Copy, Clone, Hash)]
@ -30,7 +30,7 @@ impl From<bool> for Mode {
/// Auto-fix errors in a file, and write the fixed source code to disk.
pub fn fix_file<'a>(
checks: &'a [Check],
checks: &'a [Diagnostic],
locator: &'a SourceCodeLocator<'a>,
) -> Option<(Cow<'a, str>, usize)> {
if checks.iter().all(|check| check.fix.is_none()) {

1550
src/checkers/ast.rs
View File

File diff suppressed because it is too large Load Diff

14
src/checkers/imports.rs
View File

@ -8,7 +8,7 @@ use crate::ast::visitor::Visitor;
use crate::directives::IsortDirectives;
use crate::isort;
use crate::isort::track::ImportTracker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::settings::{flags, Settings};
use crate::source_code_locator::SourceCodeLocator;
use crate::source_code_style::SourceCodeStyleDetector;
@ -20,18 +20,18 @@ fn check_import_blocks(
stylist: &SourceCodeStyleDetector,
autofix: flags::Autofix,
package: Option<&Path>,
) -> Vec<Check> {
let mut checks = vec![];
) -> Vec<Diagnostic> {
let mut diagnostics = vec![];
for block in tracker.into_iter() {
if !block.imports.is_empty() {
if let Some(check) =
if let Some(diagnostic) =
isort::plugins::check_imports(&block, locator, settings, stylist, autofix, package)
{
checks.push(check);
diagnostics.push(diagnostic);
}
}
}
checks
diagnostics
}
#[allow(clippy::too_many_arguments)]
@ -44,7 +44,7 @@ pub fn check_imports(
autofix: flags::Autofix,
path: &Path,
package: Option<&Path>,
) -> Vec<Check> {
) -> Vec<Diagnostic> {
let mut tracker = ImportTracker::new(locator, directives, path);
for stmt in python_ast {
tracker.visit_stmt(stmt);

24
src/checkers/lines.rs
View File

@ -3,7 +3,7 @@
use crate::pycodestyle::checks::{line_too_long, no_newline_at_end_of_file};
use crate::pygrep_hooks::plugins::{blanket_noqa, blanket_type_ignore};
use crate::pyupgrade::checks::unnecessary_coding_comment;
use crate::registry::{Check, CheckCode};
use crate::registry::{Diagnostic, RuleCode};
use crate::settings::{flags, Settings};
pub fn check_lines(
@ -11,14 +11,14 @@ pub fn check_lines(
commented_lines: &[usize],
settings: &Settings,
autofix: flags::Autofix,
) -> Vec<Check> {
let mut checks: Vec<Check> = vec![];
) -> Vec<Diagnostic> {
let mut checks: Vec<Diagnostic> = vec![];
let enforce_unnecessary_coding_comment = settings.enabled.contains(&CheckCode::UP009);
let enforce_line_too_long = settings.enabled.contains(&CheckCode::E501);
let enforce_no_newline_at_end_of_file = settings.enabled.contains(&CheckCode::W292);
let enforce_blanket_type_ignore = settings.enabled.contains(&CheckCode::PGH003);
let enforce_blanket_noqa = settings.enabled.contains(&CheckCode::PGH004);
let enforce_unnecessary_coding_comment = settings.enabled.contains(&RuleCode::UP009);
let enforce_line_too_long = settings.enabled.contains(&RuleCode::E501);
let enforce_no_newline_at_end_of_file = settings.enabled.contains(&RuleCode::W292);
let enforce_blanket_type_ignore = settings.enabled.contains(&RuleCode::PGH003);
let enforce_blanket_noqa = settings.enabled.contains(&RuleCode::PGH004);
let mut commented_lines_iter = commented_lines.iter().peekable();
for (index, line) in contents.lines().enumerate() {
@ -32,7 +32,7 @@ pub fn check_lines(
index,
line,
matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(&CheckCode::UP009),
&& settings.fixable.contains(&RuleCode::UP009),
) {
checks.push(check);
}
@ -67,7 +67,7 @@ pub fn check_lines(
if let Some(check) = no_newline_at_end_of_file(
contents,
matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(&CheckCode::W292),
&& settings.fixable.contains(&RuleCode::W292),
) {
checks.push(check);
}
@ -80,7 +80,7 @@ pub fn check_lines(
mod tests {
use super::check_lines;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings::{flags, Settings};
#[test]
@ -92,7 +92,7 @@ mod tests {
&[],
&Settings {
line_length,
..Settings::for_rule(CheckCode::E501)
..Settings::for_rule(RuleCode::E501)
},
flags::Autofix::Enabled,
)

18
src/checkers/noqa.rs
View File

@ -8,12 +8,12 @@ use rustpython_parser::ast::Location;
use crate::ast::types::Range;
use crate::autofix::Fix;
use crate::noqa::{is_file_exempt, Directive};
use crate::registry::{Check, CheckCode, CheckKind, UnusedCodes, CODE_REDIRECTS};
use crate::registry::{Diagnostic, DiagnosticKind, RuleCode, UnusedCodes, CODE_REDIRECTS};
use crate::settings::{flags, Settings};
use crate::{noqa, violations};
pub fn check_noqa(
checks: &mut Vec<Check>,
checks: &mut Vec<Diagnostic>,
contents: &str,
commented_lines: &[usize],
noqa_line_for: &IntMap<usize, usize>,
@ -23,7 +23,7 @@ pub fn check_noqa(
let mut noqa_directives: IntMap<usize, (Directive, Vec<&str>)> = IntMap::default();
let mut ignored = vec![];
let enforce_noqa = settings.enabled.contains(&CheckCode::RUF100);
let enforce_noqa = settings.enabled.contains(&RuleCode::RUF100);
let lines: Vec<&str> = contents.lines().collect();
for lineno in commented_lines {
@ -42,7 +42,7 @@ pub fn check_noqa(
// Remove any ignored checks.
for (index, check) in checks.iter().enumerate() {
if matches!(check.kind, CheckKind::BlanketNOQA(..)) {
if matches!(check.kind, DiagnosticKind::BlanketNOQA(..)) {
continue;
}
@ -100,7 +100,7 @@ pub fn check_noqa(
match directive {
Directive::All(spaces, start, end) => {
if matches.is_empty() {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UnusedNOQA(None),
Range::new(Location::new(row + 1, start), Location::new(row + 1, end)),
);
@ -123,7 +123,7 @@ pub fn check_noqa(
let mut self_ignore = false;
for code in codes {
let code = CODE_REDIRECTS.get(code).map_or(code, AsRef::as_ref);
if code == CheckCode::RUF100.as_ref() {
if code == RuleCode::RUF100.as_ref() {
self_ignore = true;
break;
}
@ -131,8 +131,8 @@ pub fn check_noqa(
if matches.contains(&code) || settings.external.contains(code) {
valid_codes.push(code);
} else {
if let Ok(check_code) = CheckCode::from_str(code) {
if settings.enabled.contains(&check_code) {
if let Ok(rule_code) = RuleCode::from_str(code) {
if settings.enabled.contains(&rule_code) {
unmatched_codes.push(code);
} else {
disabled_codes.push(code);
@ -151,7 +151,7 @@ pub fn check_noqa(
&& unknown_codes.is_empty()
&& unmatched_codes.is_empty())
{
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UnusedNOQA(Some(UnusedCodes {
disabled: disabled_codes
.iter()

30
src/checkers/tokens.rs
View File

@ -3,7 +3,7 @@
use rustpython_parser::lexer::{LexResult, Tok};
use crate::lex::docstring_detection::StateMachine;
use crate::registry::{Check, CheckCode};
use crate::registry::{Diagnostic, RuleCode};
use crate::ruff::checks::Context;
use crate::settings::flags;
use crate::source_code_locator::SourceCodeLocator;
@ -14,20 +14,20 @@ pub fn check_tokens(
tokens: &[LexResult],
settings: &Settings,
autofix: flags::Autofix,
) -> Vec<Check> {
let mut checks: Vec<Check> = vec![];
) -> Vec<Diagnostic> {
let mut checks: Vec<Diagnostic> = vec![];
let enforce_ambiguous_unicode_character = settings.enabled.contains(&CheckCode::RUF001)
|| settings.enabled.contains(&CheckCode::RUF002)
|| settings.enabled.contains(&CheckCode::RUF003);
let enforce_quotes = settings.enabled.contains(&CheckCode::Q000)
|| settings.enabled.contains(&CheckCode::Q001)
|| settings.enabled.contains(&CheckCode::Q002)
|| settings.enabled.contains(&CheckCode::Q003);
let enforce_commented_out_code = settings.enabled.contains(&CheckCode::ERA001);
let enforce_invalid_escape_sequence = settings.enabled.contains(&CheckCode::W605);
let enforce_implicit_string_concatenation = settings.enabled.contains(&CheckCode::ISC001)
|| settings.enabled.contains(&CheckCode::ISC002);
let enforce_ambiguous_unicode_character = settings.enabled.contains(&RuleCode::RUF001)
|| settings.enabled.contains(&RuleCode::RUF002)
|| settings.enabled.contains(&RuleCode::RUF003);
let enforce_quotes = settings.enabled.contains(&RuleCode::Q000)
|| settings.enabled.contains(&RuleCode::Q001)
|| settings.enabled.contains(&RuleCode::Q002)
|| settings.enabled.contains(&RuleCode::Q003);
let enforce_commented_out_code = settings.enabled.contains(&RuleCode::ERA001);
let enforce_invalid_escape_sequence = settings.enabled.contains(&RuleCode::W605);
let enforce_implicit_string_concatenation = settings.enabled.contains(&RuleCode::ISC001)
|| settings.enabled.contains(&RuleCode::ISC002);
let mut state_machine = StateMachine::default();
for &(start, ref tok, end) in tokens.iter().flatten() {
@ -95,7 +95,7 @@ pub fn check_tokens(
start,
end,
matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(&CheckCode::W605),
&& settings.fixable.contains(&RuleCode::W605),
));
}
}

36
src/cli.rs
View File

@ -6,7 +6,7 @@ use rustc_hash::FxHashMap;
use crate::fs;
use crate::logging::LogLevel;
use crate::registry::{CheckCode, CheckCodePrefix};
use crate::registry::{RuleCode, RuleCodePrefix};
use crate::settings::types::{
FilePattern, PatternPrefixPair, PerFileIgnore, PythonVersion, SerializationFormat,
};
@ -59,21 +59,21 @@ pub struct Cli {
/// Ignore all configuration files.
#[arg(long, conflicts_with = "config")]
pub isolated: bool,
/// Comma-separated list of error codes to enable (or ALL, to enable all
/// checks).
/// Comma-separated list of rule codes to enable (or ALL, to enable all
/// rules).
#[arg(long, value_delimiter = ',')]
pub select: Option<Vec<CheckCodePrefix>>,
pub select: Option<Vec<RuleCodePrefix>>,
/// Like --select, but adds additional error codes on top of the selected
/// ones.
#[arg(long, value_delimiter = ',')]
pub extend_select: Option<Vec<CheckCodePrefix>>,
pub extend_select: Option<Vec<RuleCodePrefix>>,
/// Comma-separated list of error codes to disable.
#[arg(long, value_delimiter = ',')]
pub ignore: Option<Vec<CheckCodePrefix>>,
pub ignore: Option<Vec<RuleCodePrefix>>,
/// Like --ignore, but adds additional error codes on top of the ignored
/// ones.
#[arg(long, value_delimiter = ',')]
pub extend_ignore: Option<Vec<CheckCodePrefix>>,
pub extend_ignore: Option<Vec<RuleCodePrefix>>,
/// List of paths, used to exclude files and/or directories from checks.
#[arg(long, value_delimiter = ',')]
pub exclude: Option<Vec<FilePattern>>,
@ -84,11 +84,11 @@ pub struct Cli {
/// List of error codes to treat as eligible for autofix. Only applicable
/// when autofix itself is enabled (e.g., via `--fix`).
#[arg(long, value_delimiter = ',')]
pub fixable: Option<Vec<CheckCodePrefix>>,
pub fixable: Option<Vec<RuleCodePrefix>>,
/// List of error codes to treat as ineligible for autofix. Only applicable
/// when autofix itself is enabled (e.g., via `--fix`).
#[arg(long, value_delimiter = ',')]
pub unfixable: Option<Vec<CheckCodePrefix>>,
pub unfixable: Option<Vec<RuleCodePrefix>>,
/// List of mappings from file pattern to code to exclude
#[arg(long, value_delimiter = ',')]
pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
@ -179,7 +179,7 @@ pub struct Cli {
conflicts_with = "stdin_filename",
conflicts_with = "watch",
)]
pub explain: Option<CheckCode>,
pub explain: Option<RuleCode>,
/// Generate shell completion
#[arg(
long,
@ -302,7 +302,7 @@ pub struct Arguments {
pub config: Option<PathBuf>,
pub diff: bool,
pub exit_zero: bool,
pub explain: Option<CheckCode>,
pub explain: Option<RuleCode>,
pub files: Vec<PathBuf>,
pub generate_shell_completion: Option<clap_complete_command::Shell>,
pub isolated: bool,
@ -323,18 +323,18 @@ pub struct Overrides {
pub dummy_variable_rgx: Option<Regex>,
pub exclude: Option<Vec<FilePattern>>,
pub extend_exclude: Option<Vec<FilePattern>>,
pub extend_ignore: Option<Vec<CheckCodePrefix>>,
pub extend_select: Option<Vec<CheckCodePrefix>>,
pub fixable: Option<Vec<CheckCodePrefix>>,
pub ignore: Option<Vec<CheckCodePrefix>>,
pub extend_ignore: Option<Vec<RuleCodePrefix>>,
pub extend_select: Option<Vec<RuleCodePrefix>>,
pub fixable: Option<Vec<RuleCodePrefix>>,
pub ignore: Option<Vec<RuleCodePrefix>>,
pub line_length: Option<usize>,
pub max_complexity: Option<usize>,
pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
pub respect_gitignore: Option<bool>,
pub select: Option<Vec<CheckCodePrefix>>,
pub select: Option<Vec<RuleCodePrefix>>,
pub show_source: Option<bool>,
pub target_version: Option<PythonVersion>,
pub unfixable: Option<Vec<CheckCodePrefix>>,
pub unfixable: Option<Vec<RuleCodePrefix>>,
// TODO(charlie): Captured in pyproject.toml as a default, but not part of `Settings`.
pub cache_dir: Option<PathBuf>,
pub fix: Option<bool>,
@ -359,7 +359,7 @@ pub fn extract_log_level(cli: &Arguments) -> LogLevel {
/// Convert a list of `PatternPrefixPair` structs to `PerFileIgnore`.
pub fn collect_per_file_ignores(pairs: Vec<PatternPrefixPair>) -> Vec<PerFileIgnore> {
let mut per_file_ignores: FxHashMap<String, Vec<CheckCodePrefix>> = FxHashMap::default();
let mut per_file_ignores: FxHashMap<String, Vec<RuleCodePrefix>> = FxHashMap::default();
for pair in pairs {
per_file_ignores
.entry(pair.pattern)

8
src/commands.rs
View File

@ -22,7 +22,7 @@ use crate::iterators::par_iter;
use crate::linter::{add_noqa_to_path, lint_path, lint_stdin, Diagnostics};
use crate::logging::LogLevel;
use crate::message::Message;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::resolver::{FileDiscovery, PyprojectDiscovery};
use crate::settings::flags;
use crate::settings::types::SerializationFormat;
@ -117,7 +117,7 @@ pub fn run(
.unwrap_or_else(|(path, message)| {
if let Some(path) = &path {
let settings = resolver.resolve(path, pyproject_strategy);
if settings.enabled.contains(&CheckCode::E902) {
if settings.enabled.contains(&RuleCode::E902) {
Diagnostics::new(vec![Message {
kind: violations::IOError(message).into(),
location: Location::default(),
@ -302,8 +302,8 @@ struct Explanation<'a> {
summary: &'a str,
}
/// Explain a `CheckCode` to the user.
pub fn explain(code: &CheckCode, format: &SerializationFormat) -> Result<()> {
/// Explain a `RuleCode` to the user.
pub fn explain(code: &RuleCode, format: &SerializationFormat) -> Result<()> {
match format {
SerializationFormat::Text | SerializationFormat::Grouped => {
println!(

2
src/directives.rs
View File

@ -20,7 +20,7 @@ impl Flags {
if settings
.enabled
.iter()
.any(|check_code| matches!(check_code.lint_source(), LintSource::Imports))
.any(|rule_code| matches!(rule_code.lint_source(), LintSource::Imports))
{
Flags::NOQA | Flags::ISORT
} else {

10
src/eradicate/checks.rs
View File

@ -3,9 +3,9 @@ use rustpython_ast::Location;
use crate::ast::types::Range;
use crate::autofix::Fix;
use crate::eradicate::detection::comment_contains_code;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings::flags;
use crate::{violations, Check, Settings, SourceCodeLocator};
use crate::{violations, Diagnostic, Settings, SourceCodeLocator};
fn is_standalone_comment(line: &str) -> bool {
for char in line.chars() {
@ -25,16 +25,16 @@ pub fn commented_out_code(
end: Location,
settings: &Settings,
autofix: flags::Autofix,
) -> Option<Check> {
) -> Option<Diagnostic> {
let location = Location::new(start.row(), 0);
let end_location = Location::new(end.row() + 1, 0);
let line = locator.slice_source_code_range(&Range::new(location, end_location));
// Verify that the comment is on its own line, and that it contains code.
if is_standalone_comment(&line) && comment_contains_code(&line, &settings.task_tags[..]) {
let mut check = Check::new(violations::CommentedOutCode, Range::new(start, end));
let mut check = Diagnostic::new(violations::CommentedOutCode, Range::new(start, end));
if matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(&CheckCode::ERA001)
&& settings.fixable.contains(&RuleCode::ERA001)
{
check.amend(Fix::deletion(location, end_location));
}

14
src/eradicate/mod.rs
View File

@ -10,19 +10,19 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::ERA001, Path::new("ERA001.py"); "ERA001")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::ERA001, Path::new("ERA001.py"); "ERA001")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/eradicate")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
&settings::Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

32
src/flake8_2020/mod.rs
View File

@ -9,28 +9,28 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::YTT101, Path::new("YTT101.py"); "YTT101")]
#[test_case(CheckCode::YTT102, Path::new("YTT102.py"); "YTT102")]
#[test_case(CheckCode::YTT103, Path::new("YTT103.py"); "YTT103")]
#[test_case(CheckCode::YTT201, Path::new("YTT201.py"); "YTT201")]
#[test_case(CheckCode::YTT202, Path::new("YTT202.py"); "YTT202")]
#[test_case(CheckCode::YTT203, Path::new("YTT203.py"); "YTT203")]
#[test_case(CheckCode::YTT204, Path::new("YTT204.py"); "YTT204")]
#[test_case(CheckCode::YTT301, Path::new("YTT301.py"); "YTT301")]
#[test_case(CheckCode::YTT302, Path::new("YTT302.py"); "YTT302")]
#[test_case(CheckCode::YTT303, Path::new("YTT303.py"); "YTT303")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::YTT101, Path::new("YTT101.py"); "YTT101")]
#[test_case(RuleCode::YTT102, Path::new("YTT102.py"); "YTT102")]
#[test_case(RuleCode::YTT103, Path::new("YTT103.py"); "YTT103")]
#[test_case(RuleCode::YTT201, Path::new("YTT201.py"); "YTT201")]
#[test_case(RuleCode::YTT202, Path::new("YTT202.py"); "YTT202")]
#[test_case(RuleCode::YTT203, Path::new("YTT203.py"); "YTT203")]
#[test_case(RuleCode::YTT204, Path::new("YTT204.py"); "YTT204")]
#[test_case(RuleCode::YTT301, Path::new("YTT301.py"); "YTT301")]
#[test_case(RuleCode::YTT302, Path::new("YTT302.py"); "YTT302")]
#[test_case(RuleCode::YTT303, Path::new("YTT303.py"); "YTT303")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_2020")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
&settings::Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

41
src/flake8_2020/plugins.rs
View File

@ -4,7 +4,7 @@ use rustpython_ast::{Cmpop, Constant, Expr, ExprKind, Located};
use crate::ast::helpers::match_module_member;
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::{Check, CheckCode};
use crate::registry::{Diagnostic, RuleCode};
use crate::violations;
fn is_sys(checker: &Checker, expr: &Expr, target: &str) -> bool {
@ -32,17 +32,16 @@ pub fn subscript(checker: &mut Checker, value: &Expr, slice: &Expr) {
..
} = &upper.node
{
if *i == BigInt::from(1)
&& checker.settings.enabled.contains(&CheckCode::YTT303)
if *i == BigInt::from(1) && checker.settings.enabled.contains(&RuleCode::YTT303)
{
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::SysVersionSlice1Referenced,
Range::from_located(value),
));
} else if *i == BigInt::from(3)
&& checker.settings.enabled.contains(&CheckCode::YTT101)
&& checker.settings.enabled.contains(&RuleCode::YTT101)
{
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::SysVersionSlice3Referenced,
Range::from_located(value),
));
@ -54,15 +53,15 @@ pub fn subscript(checker: &mut Checker, value: &Expr, slice: &Expr) {
value: Constant::Int(i),
..
} => {
if *i == BigInt::from(2) && checker.settings.enabled.contains(&CheckCode::YTT102) {
checker.checks.push(Check::new(
if *i == BigInt::from(2) && checker.settings.enabled.contains(&RuleCode::YTT102) {
checker.diagnostics.push(Diagnostic::new(
violations::SysVersion2Referenced,
Range::from_located(value),
));
} else if *i == BigInt::from(0)
&& checker.settings.enabled.contains(&CheckCode::YTT301)
&& checker.settings.enabled.contains(&RuleCode::YTT301)
{
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::SysVersion0Referenced,
Range::from_located(value),
));
@ -97,9 +96,9 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
) = (ops, comparators)
{
if *n == BigInt::from(3)
&& checker.settings.enabled.contains(&CheckCode::YTT201)
&& checker.settings.enabled.contains(&RuleCode::YTT201)
{
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::SysVersionInfo0Eq3Referenced,
Range::from_located(left),
));
@ -118,8 +117,8 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
}],
) = (ops, comparators)
{
if checker.settings.enabled.contains(&CheckCode::YTT203) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::YTT203) {
checker.diagnostics.push(Diagnostic::new(
violations::SysVersionInfo1CmpInt,
Range::from_located(left),
));
@ -144,8 +143,8 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
}],
) = (ops, comparators)
{
if checker.settings.enabled.contains(&CheckCode::YTT204) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::YTT204) {
checker.diagnostics.push(Diagnostic::new(
violations::SysVersionInfoMinorCmpInt,
Range::from_located(left),
));
@ -170,14 +169,14 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
) = (ops, comparators)
{
if s.len() == 1 {
if checker.settings.enabled.contains(&CheckCode::YTT302) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::YTT302) {
checker.diagnostics.push(Diagnostic::new(
violations::SysVersionCmpStr10,
Range::from_located(left),
));
}
} else if checker.settings.enabled.contains(&CheckCode::YTT103) {
checker.checks.push(Check::new(
} else if checker.settings.enabled.contains(&RuleCode::YTT103) {
checker.diagnostics.push(Diagnostic::new(
violations::SysVersionCmpStr3,
Range::from_located(left),
));
@ -195,7 +194,7 @@ pub fn name_or_attribute(checker: &mut Checker, expr: &Expr) {
&checker.from_imports,
&checker.import_aliases,
) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::SixPY3Referenced,
Range::from_located(expr),
));

90
src/flake8_annotations/mod.rs
View File

@ -10,36 +10,36 @@ mod tests {
use anyhow::Result;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::{flake8_annotations, Settings};
#[test]
fn defaults() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_annotations/annotation_presence.py"),
&Settings {
..Settings::for_rules(vec![
CheckCode::ANN001,
CheckCode::ANN002,
CheckCode::ANN003,
CheckCode::ANN101,
CheckCode::ANN102,
CheckCode::ANN201,
CheckCode::ANN202,
CheckCode::ANN204,
CheckCode::ANN205,
CheckCode::ANN206,
CheckCode::ANN401,
RuleCode::ANN001,
RuleCode::ANN002,
RuleCode::ANN003,
RuleCode::ANN101,
RuleCode::ANN102,
RuleCode::ANN201,
RuleCode::ANN202,
RuleCode::ANN204,
RuleCode::ANN205,
RuleCode::ANN206,
RuleCode::ANN401,
])
},
)?;
insta::assert_yaml_snapshot!(checks);
insta::assert_yaml_snapshot!(diagnostics);
Ok(())
}
#[test]
fn suppress_dummy_args() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_annotations/suppress_dummy_args.py"),
&Settings {
flake8_annotations: flake8_annotations::settings::Settings {
@ -49,21 +49,21 @@ mod tests {
allow_star_arg_any: false,
},
..Settings::for_rules(vec![
CheckCode::ANN001,
CheckCode::ANN002,
CheckCode::ANN003,
CheckCode::ANN101,
CheckCode::ANN102,
RuleCode::ANN001,
RuleCode::ANN002,
RuleCode::ANN003,
RuleCode::ANN101,
RuleCode::ANN102,
])
},
)?;
insta::assert_yaml_snapshot!(checks);
insta::assert_yaml_snapshot!(diagnostics);
Ok(())
}
#[test]
fn mypy_init_return() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_annotations/mypy_init_return.py"),
&Settings {
flake8_annotations: flake8_annotations::settings::Settings {
@ -73,21 +73,21 @@ mod tests {
allow_star_arg_any: false,
},
..Settings::for_rules(vec![
CheckCode::ANN201,
CheckCode::ANN202,
CheckCode::ANN204,
CheckCode::ANN205,
CheckCode::ANN206,
RuleCode::ANN201,
RuleCode::ANN202,
RuleCode::ANN204,
RuleCode::ANN205,
RuleCode::ANN206,
])
},
)?;
insta::assert_yaml_snapshot!(checks);
insta::assert_yaml_snapshot!(diagnostics);
Ok(())
}
#[test]
fn suppress_none_returning() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_annotations/suppress_none_returning.py"),
&Settings {
flake8_annotations: flake8_annotations::settings::Settings {
@ -97,21 +97,21 @@ mod tests {
allow_star_arg_any: false,
},
..Settings::for_rules(vec![
CheckCode::ANN201,
CheckCode::ANN202,
CheckCode::ANN204,
CheckCode::ANN205,
CheckCode::ANN206,
RuleCode::ANN201,
RuleCode::ANN202,
RuleCode::ANN204,
RuleCode::ANN205,
RuleCode::ANN206,
])
},
)?;
insta::assert_yaml_snapshot!(checks);
insta::assert_yaml_snapshot!(diagnostics);
Ok(())
}
#[test]
fn allow_star_arg_any() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_annotations/allow_star_arg_any.py"),
&Settings {
flake8_annotations: flake8_annotations::settings::Settings {
@ -120,28 +120,28 @@ mod tests {
suppress_none_returning: false,
allow_star_arg_any: true,
},
..Settings::for_rules(vec![CheckCode::ANN401])
..Settings::for_rules(vec![RuleCode::ANN401])
},
)?;
insta::assert_yaml_snapshot!(checks);
insta::assert_yaml_snapshot!(diagnostics);
Ok(())
}
#[test]
fn allow_overload() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_annotations/allow_overload.py"),
&Settings {
..Settings::for_rules(vec![
CheckCode::ANN201,
CheckCode::ANN202,
CheckCode::ANN204,
CheckCode::ANN205,
CheckCode::ANN206,
RuleCode::ANN201,
RuleCode::ANN202,
RuleCode::ANN204,
RuleCode::ANN205,
RuleCode::ANN206,
])
},
)?;
insta::assert_yaml_snapshot!(checks);
insta::assert_yaml_snapshot!(diagnostics);
Ok(())
}
}

88
src/flake8_annotations/plugins.rs
View File

@ -8,9 +8,9 @@ use crate::checkers::ast::Checker;
use crate::docstrings::definition::{Definition, DefinitionKind};
use crate::flake8_annotations::fixes;
use crate::flake8_annotations::helpers::match_function_def;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::visibility::Visibility;
use crate::{violations, visibility, Check};
use crate::{violations, visibility, Diagnostic};
#[derive(Default)]
struct ReturnStatementVisitor<'a> {
@ -57,7 +57,7 @@ where
F: FnOnce() -> String,
{
if checker.match_typing_expr(annotation, "Any") {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::DynamicallyTypedExpression(func()),
Range::from_located(annotation),
));
@ -85,15 +85,15 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
.chain(args.kwonlyargs.iter())
{
if let Some(expr) = &arg.node.annotation {
if checker.settings.enabled.contains(&CheckCode::ANN401) {
if checker.settings.enabled.contains(&RuleCode::ANN401) {
check_dynamically_typed(checker, expr, || arg.node.arg.to_string());
};
} else {
if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{
if checker.settings.enabled.contains(&CheckCode::ANN001) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN001) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeFunctionArgument(arg.node.arg.to_string()),
Range::from_located(arg),
));
@ -106,7 +106,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if let Some(arg) = &args.vararg {
if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&CheckCode::ANN401) {
if checker.settings.enabled.contains(&RuleCode::ANN401) {
let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("*{name}"));
}
@ -115,8 +115,8 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{
if checker.settings.enabled.contains(&CheckCode::ANN002) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN002) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeArgs(arg.node.arg.to_string()),
Range::from_located(arg),
));
@ -129,7 +129,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if let Some(arg) = &args.kwarg {
if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&CheckCode::ANN401) {
if checker.settings.enabled.contains(&RuleCode::ANN401) {
let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("**{name}"));
}
@ -138,8 +138,8 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{
if checker.settings.enabled.contains(&CheckCode::ANN003) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN003) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeKwargs(arg.node.arg.to_string()),
Range::from_located(arg),
));
@ -150,7 +150,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
// ANN201, ANN202, ANN401
if let Some(expr) = &returns {
if checker.settings.enabled.contains(&CheckCode::ANN401) {
if checker.settings.enabled.contains(&RuleCode::ANN401) {
check_dynamically_typed(checker, expr, || name.to_string());
};
} else {
@ -164,16 +164,16 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
match visibility {
Visibility::Public => {
if checker.settings.enabled.contains(&CheckCode::ANN201) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN201) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypePublicFunction(name.to_string()),
helpers::identifier_range(stmt, checker.locator),
));
}
}
Visibility::Private => {
if checker.settings.enabled.contains(&CheckCode::ANN202) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN202) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypePrivateFunction(name.to_string()),
helpers::identifier_range(stmt, checker.locator),
));
@ -203,15 +203,15 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
// ANN401 for dynamically typed arguments
if let Some(annotation) = &arg.node.annotation {
has_any_typed_arg = true;
if checker.settings.enabled.contains(&CheckCode::ANN401) {
if checker.settings.enabled.contains(&RuleCode::ANN401) {
check_dynamically_typed(checker, annotation, || arg.node.arg.to_string());
}
} else {
if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{
if checker.settings.enabled.contains(&CheckCode::ANN001) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN001) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeFunctionArgument(arg.node.arg.to_string()),
Range::from_located(arg),
));
@ -225,7 +225,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
has_any_typed_arg = true;
if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&CheckCode::ANN401) {
if checker.settings.enabled.contains(&RuleCode::ANN401) {
let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("*{name}"));
}
@ -234,8 +234,8 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{
if checker.settings.enabled.contains(&CheckCode::ANN002) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN002) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeArgs(arg.node.arg.to_string()),
Range::from_located(arg),
));
@ -249,7 +249,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
has_any_typed_arg = true;
if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&CheckCode::ANN401) {
if checker.settings.enabled.contains(&RuleCode::ANN401) {
let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("**{name}"));
}
@ -258,8 +258,8 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{
if checker.settings.enabled.contains(&CheckCode::ANN003) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN003) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeKwargs(arg.node.arg.to_string()),
Range::from_located(arg),
));
@ -273,15 +273,15 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if let Some(arg) = args.args.first() {
if arg.node.annotation.is_none() {
if visibility::is_classmethod(checker, cast::decorator_list(stmt)) {
if checker.settings.enabled.contains(&CheckCode::ANN102) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN102) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeCls(arg.node.arg.to_string()),
Range::from_located(arg),
));
}
} else {
if checker.settings.enabled.contains(&CheckCode::ANN101) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN101) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeSelf(arg.node.arg.to_string()),
Range::from_located(arg),
));
@ -293,7 +293,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
// ANN201, ANN202
if let Some(expr) = &returns {
if checker.settings.enabled.contains(&CheckCode::ANN401) {
if checker.settings.enabled.contains(&RuleCode::ANN401) {
check_dynamically_typed(checker, expr, || name.to_string());
}
} else {
@ -306,15 +306,15 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
}
if visibility::is_classmethod(checker, cast::decorator_list(stmt)) {
if checker.settings.enabled.contains(&CheckCode::ANN206) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN206) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypeClassMethod(name.to_string()),
helpers::identifier_range(stmt, checker.locator),
));
}
} else if visibility::is_staticmethod(checker, cast::decorator_list(stmt)) {
if checker.settings.enabled.contains(&CheckCode::ANN205) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN205) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypeStaticMethod(name.to_string()),
helpers::identifier_range(stmt, checker.locator),
));
@ -322,11 +322,11 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} else if visibility::is_init(stmt) {
// Allow omission of return annotation in `__init__` functions, as long as at
// least one argument is typed.
if checker.settings.enabled.contains(&CheckCode::ANN204) {
if checker.settings.enabled.contains(&RuleCode::ANN204) {
if !(checker.settings.flake8_annotations.mypy_init_return
&& has_any_typed_arg)
{
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::MissingReturnTypeSpecialMethod(name.to_string()),
helpers::identifier_range(stmt, checker.locator),
);
@ -338,12 +338,12 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
Err(e) => error!("Failed to generate fix: {e}"),
}
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
} else if visibility::is_magic(stmt) {
if checker.settings.enabled.contains(&CheckCode::ANN204) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN204) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypeSpecialMethod(name.to_string()),
helpers::identifier_range(stmt, checker.locator),
));
@ -351,16 +351,16 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} else {
match visibility {
Visibility::Public => {
if checker.settings.enabled.contains(&CheckCode::ANN201) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN201) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypePublicFunction(name.to_string()),
helpers::identifier_range(stmt, checker.locator),
));
}
}
Visibility::Private => {
if checker.settings.enabled.contains(&CheckCode::ANN202) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::ANN202) {
checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypePrivateFunction(name.to_string()),
helpers::identifier_range(stmt, checker.locator),
));

6
src/flake8_bandit/checks/assert_used.rs
View File

@ -1,10 +1,10 @@
use rustpython_ast::{Located, StmtKind};
use crate::ast::types::Range;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// S101
pub fn assert_used(stmt: &Located<StmtKind>) -> Check {
Check::new(violations::AssertUsed, Range::from_located(stmt))
pub fn assert_used(stmt: &Located<StmtKind>) -> Diagnostic {
Diagnostic::new(violations::AssertUsed, Range::from_located(stmt))
}

6
src/flake8_bandit/checks/bad_file_permissions.rs
View File

@ -5,7 +5,7 @@ use rustpython_ast::{Constant, Expr, ExprKind, Keyword, Operator};
use crate::ast::helpers::{compose_call_path, match_module_member, SimpleCallArgs};
use crate::ast::types::Range;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
const WRITE_WORLD: u16 = 0o2;
@ -91,13 +91,13 @@ pub fn bad_file_permissions(
keywords: &[Keyword],
from_imports: &FxHashMap<&str, FxHashSet<&str>>,
import_aliases: &FxHashMap<&str, &str>,
) -> Option<Check> {
) -> Option<Diagnostic> {
if match_module_member(func, "os", "chmod", from_imports, import_aliases) {
let call_args = SimpleCallArgs::new(args, keywords);
if let Some(mode_arg) = call_args.get_argument("mode", Some(1)) {
if let Some(int_value) = get_int_value(mode_arg) {
if (int_value & WRITE_WORLD > 0) || (int_value & EXECUTE_GROUP > 0) {
return Some(Check::new(
return Some(Diagnostic::new(
violations::BadFilePermissions(int_value),
Range::from_located(mode_arg),
));

9
src/flake8_bandit/checks/exec_used.rs
View File

@ -1,16 +1,19 @@
use rustpython_ast::{Expr, ExprKind};
use crate::ast::types::Range;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// S102
pub fn exec_used(expr: &Expr, func: &Expr) -> Option<Check> {
pub fn exec_used(expr: &Expr, func: &Expr) -> Option<Diagnostic> {
let ExprKind::Name { id, .. } = &func.node else {
return None;
};
if id != "exec" {
return None;
}
Some(Check::new(violations::ExecUsed, Range::from_located(expr)))
Some(Diagnostic::new(
violations::ExecUsed,
Range::from_located(expr),
))
}

9
src/flake8_bandit/checks/hardcoded_bind_all_interfaces.rs
View File

@ -1,11 +1,14 @@
use crate::ast::types::Range;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// S104
pub fn hardcoded_bind_all_interfaces(value: &str, range: &Range) -> Option<Check> {
pub fn hardcoded_bind_all_interfaces(value: &str, range: &Range) -> Option<Diagnostic> {
if value == "0.0.0.0" {
Some(Check::new(violations::HardcodedBindAllInterfaces, *range))
Some(Diagnostic::new(
violations::HardcodedBindAllInterfaces,
*range,
))
} else {
None
}

10
src/flake8_bandit/checks/hardcoded_password_default.rs
View File

@ -2,24 +2,24 @@ use rustpython_ast::{ArgData, Arguments, Expr, Located};
use crate::ast::types::Range;
use crate::flake8_bandit::helpers::{matches_password_name, string_literal};
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
fn check_password_kwarg(arg: &Located<ArgData>, default: &Expr) -> Option<Check> {
fn check_password_kwarg(arg: &Located<ArgData>, default: &Expr) -> Option<Diagnostic> {
let string = string_literal(default)?;
let kwarg_name = &arg.node.arg;
if !matches_password_name(kwarg_name) {
return None;
}
Some(Check::new(
Some(Diagnostic::new(
violations::HardcodedPasswordDefault(string.to_string()),
Range::from_located(default),
))
}
/// S107
pub fn hardcoded_password_default(arguments: &Arguments) -> Vec<Check> {
let mut checks: Vec<Check> = Vec::new();
pub fn hardcoded_password_default(arguments: &Arguments) -> Vec<Diagnostic> {
let mut checks: Vec<Diagnostic> = Vec::new();
let defaults_start =
arguments.posonlyargs.len() + arguments.args.len() - arguments.defaults.len();

6
src/flake8_bandit/checks/hardcoded_password_func_arg.rs
View File

@ -2,11 +2,11 @@ use rustpython_ast::Keyword;
use crate::ast::types::Range;
use crate::flake8_bandit::helpers::{matches_password_name, string_literal};
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// S106
pub fn hardcoded_password_func_arg(keywords: &[Keyword]) -> Vec<Check> {
pub fn hardcoded_password_func_arg(keywords: &[Keyword]) -> Vec<Diagnostic> {
keywords
.iter()
.filter_map(|keyword| {
@ -15,7 +15,7 @@ pub fn hardcoded_password_func_arg(keywords: &[Keyword]) -> Vec<Check> {
if !matches_password_name(arg) {
return None;
}
Some(Check::new(
Some(Diagnostic::new(
violations::HardcodedPasswordFuncArg(string.to_string()),
Range::from_located(keyword),
))

10
src/flake8_bandit/checks/hardcoded_password_string.rs
View File

@ -2,7 +2,7 @@ use rustpython_ast::{Constant, Expr, ExprKind};
use crate::ast::types::Range;
use crate::flake8_bandit::helpers::{matches_password_name, string_literal};
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
fn is_password_target(target: &Expr) -> bool {
@ -26,7 +26,7 @@ fn is_password_target(target: &Expr) -> bool {
}
/// S105
pub fn compare_to_hardcoded_password_string(left: &Expr, comparators: &[Expr]) -> Vec<Check> {
pub fn compare_to_hardcoded_password_string(left: &Expr, comparators: &[Expr]) -> Vec<Diagnostic> {
comparators
.iter()
.filter_map(|comp| {
@ -34,7 +34,7 @@ pub fn compare_to_hardcoded_password_string(left: &Expr, comparators: &[Expr]) -
if !is_password_target(left) {
return None;
}
Some(Check::new(
Some(Diagnostic::new(
violations::HardcodedPasswordString(string.to_string()),
Range::from_located(comp),
))
@ -43,11 +43,11 @@ pub fn compare_to_hardcoded_password_string(left: &Expr, comparators: &[Expr]) -
}
/// S105
pub fn assign_hardcoded_password_string(value: &Expr, targets: &[Expr]) -> Option<Check> {
pub fn assign_hardcoded_password_string(value: &Expr, targets: &[Expr]) -> Option<Diagnostic> {
if let Some(string) = string_literal(value) {
for target in targets {
if is_password_target(target) {
return Some(Check::new(
return Some(Diagnostic::new(
violations::HardcodedPasswordString(string.to_string()),
Range::from_located(value),
));

10
src/flake8_bandit/checks/hardcoded_tmp_directory.rs
View File

@ -1,13 +1,17 @@
use rustpython_ast::Expr;
use crate::ast::types::Range;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// S108
pub fn hardcoded_tmp_directory(expr: &Expr, value: &str, prefixes: &[String]) -> Option<Check> {
pub fn hardcoded_tmp_directory(
expr: &Expr,
value: &str,
prefixes: &[String],
) -> Option<Diagnostic> {
if prefixes.iter().any(|prefix| value.starts_with(prefix)) {
Some(Check::new(
Some(Diagnostic::new(
violations::HardcodedTempFile(value.to_string()),
Range::from_located(expr),
))

8
src/flake8_bandit/checks/hashlib_insecure_hash_functions.rs
View File

@ -4,7 +4,7 @@ use rustpython_ast::{Constant, Expr, ExprKind, Keyword};
use crate::ast::helpers::{match_module_member, SimpleCallArgs};
use crate::ast::types::Range;
use crate::flake8_bandit::helpers::string_literal;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
const WEAK_HASHES: [&str; 4] = ["md4", "md5", "sha", "sha1"];
@ -29,7 +29,7 @@ pub fn hashlib_insecure_hash_functions(
keywords: &[Keyword],
from_imports: &FxHashMap<&str, FxHashSet<&str>>,
import_aliases: &FxHashMap<&str, &str>,
) -> Option<Check> {
) -> Option<Diagnostic> {
if match_module_member(func, "hashlib", "new", from_imports, import_aliases) {
let call_args = SimpleCallArgs::new(args, keywords);
@ -41,7 +41,7 @@ pub fn hashlib_insecure_hash_functions(
let hash_func_name = string_literal(name_arg)?;
if WEAK_HASHES.contains(&hash_func_name.to_lowercase().as_str()) {
return Some(Check::new(
return Some(Diagnostic::new(
violations::HashlibInsecureHashFunction(hash_func_name.to_string()),
Range::from_located(name_arg),
));
@ -56,7 +56,7 @@ pub fn hashlib_insecure_hash_functions(
return None;
}
return Some(Check::new(
return Some(Diagnostic::new(
violations::HashlibInsecureHashFunction((*func_name).to_string()),
Range::from_located(func),
));

8
src/flake8_bandit/checks/request_with_no_cert_validation.rs
View File

@ -4,7 +4,7 @@ use rustpython_parser::ast::Constant;
use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path, SimpleCallArgs};
use crate::ast::types::Range;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
const REQUESTS_HTTP_VERBS: [&str; 7] = ["get", "options", "head", "post", "put", "patch", "delete"];
@ -29,7 +29,7 @@ pub fn request_with_no_cert_validation(
keywords: &[Keyword],
from_imports: &FxHashMap<&str, FxHashSet<&str>>,
import_aliases: &FxHashMap<&str, &str>,
) -> Option<Check> {
) -> Option<Diagnostic> {
let call_path = dealias_call_path(collect_call_paths(func), import_aliases);
let call_args = SimpleCallArgs::new(args, keywords);
@ -41,7 +41,7 @@ pub fn request_with_no_cert_validation(
..
} = &verify_arg.node
{
return Some(Check::new(
return Some(Diagnostic::new(
violations::RequestWithNoCertValidation("requests".to_string()),
Range::from_located(verify_arg),
));
@ -58,7 +58,7 @@ pub fn request_with_no_cert_validation(
..
} = &verify_arg.node
{
return Some(Check::new(
return Some(Diagnostic::new(
violations::RequestWithNoCertValidation("httpx".to_string()),
Range::from_located(verify_arg),
));

8
src/flake8_bandit/checks/request_without_timeout.rs
View File

@ -4,7 +4,7 @@ use rustpython_parser::ast::Constant;
use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path, SimpleCallArgs};
use crate::ast::types::Range;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
const HTTP_VERBS: [&str; 7] = ["get", "options", "head", "post", "put", "patch", "delete"];
@ -16,7 +16,7 @@ pub fn request_without_timeout(
keywords: &[Keyword],
from_imports: &FxHashMap<&str, FxHashSet<&str>>,
import_aliases: &FxHashMap<&str, &str>,
) -> Option<Check> {
) -> Option<Diagnostic> {
let call_path = dealias_call_path(collect_call_paths(func), import_aliases);
for func_name in &HTTP_VERBS {
if match_call_path(&call_path, "requests", func_name, from_imports) {
@ -29,13 +29,13 @@ pub fn request_without_timeout(
} => Some(value.to_string()),
_ => None,
} {
return Some(Check::new(
return Some(Diagnostic::new(
violations::RequestWithoutTimeout(Some(timeout)),
Range::from_located(timeout_arg),
));
}
} else {
return Some(Check::new(
return Some(Diagnostic::new(
violations::RequestWithoutTimeout(None),
Range::from_located(func),
));

8
src/flake8_bandit/checks/unsafe_yaml_load.rs
View File

@ -3,7 +3,7 @@ use rustpython_ast::{Expr, ExprKind, Keyword};
use crate::ast::helpers::{match_module_member, SimpleCallArgs};
use crate::ast::types::Range;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// S506
@ -13,7 +13,7 @@ pub fn unsafe_yaml_load(
keywords: &[Keyword],
from_imports: &FxHashMap<&str, FxHashSet<&str>>,
import_aliases: &FxHashMap<&str, &str>,
) -> Option<Check> {
) -> Option<Diagnostic> {
if match_module_member(func, "yaml", "load", from_imports, import_aliases) {
let call_args = SimpleCallArgs::new(args, keywords);
if let Some(loader_arg) = call_args.get_argument("Loader", Some(1)) {
@ -35,13 +35,13 @@ pub fn unsafe_yaml_load(
ExprKind::Name { id, .. } => Some(id.to_string()),
_ => None,
};
return Some(Check::new(
return Some(Diagnostic::new(
violations::UnsafeYAMLLoad(loader),
Range::from_located(loader_arg),
));
}
} else {
return Some(Check::new(
return Some(Diagnostic::new(
violations::UnsafeYAMLLoad(None),
Range::from_located(func),
));

42
src/flake8_bandit/mod.rs
View File

@ -10,36 +10,36 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::{flake8_bandit, Settings};
#[test_case(CheckCode::S101, Path::new("S101.py"); "S101")]
#[test_case(CheckCode::S102, Path::new("S102.py"); "S102")]
#[test_case(CheckCode::S103, Path::new("S103.py"); "S103")]
#[test_case(CheckCode::S104, Path::new("S104.py"); "S104")]
#[test_case(CheckCode::S105, Path::new("S105.py"); "S105")]
#[test_case(CheckCode::S106, Path::new("S106.py"); "S106")]
#[test_case(CheckCode::S107, Path::new("S107.py"); "S107")]
#[test_case(CheckCode::S108, Path::new("S108.py"); "S108")]
#[test_case(CheckCode::S113, Path::new("S113.py"); "S113")]
#[test_case(CheckCode::S324, Path::new("S324.py"); "S324")]
#[test_case(CheckCode::S501, Path::new("S501.py"); "S501")]
#[test_case(CheckCode::S506, Path::new("S506.py"); "S506")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::S101, Path::new("S101.py"); "S101")]
#[test_case(RuleCode::S102, Path::new("S102.py"); "S102")]
#[test_case(RuleCode::S103, Path::new("S103.py"); "S103")]
#[test_case(RuleCode::S104, Path::new("S104.py"); "S104")]
#[test_case(RuleCode::S105, Path::new("S105.py"); "S105")]
#[test_case(RuleCode::S106, Path::new("S106.py"); "S106")]
#[test_case(RuleCode::S107, Path::new("S107.py"); "S107")]
#[test_case(RuleCode::S108, Path::new("S108.py"); "S108")]
#[test_case(RuleCode::S113, Path::new("S113.py"); "S113")]
#[test_case(RuleCode::S324, Path::new("S324.py"); "S324")]
#[test_case(RuleCode::S501, Path::new("S501.py"); "S501")]
#[test_case(RuleCode::S506, Path::new("S506.py"); "S506")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_bandit")
.join(path)
.as_path(),
&Settings::for_rule(check_code),
&Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
#[test]
fn check_hardcoded_tmp_additional_dirs() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_bandit/S108.py"),
&Settings {
flake8_bandit: flake8_bandit::settings::Settings {
@ -50,10 +50,10 @@ mod tests {
"/foo".to_string(),
],
},
..Settings::for_rule(CheckCode::S108)
..Settings::for_rule(RuleCode::S108)
},
)?;
insta::assert_yaml_snapshot!("S108_extend", checks);
insta::assert_yaml_snapshot!("S108_extend", diagnostics);
Ok(())
}
}

14
src/flake8_blind_except/mod.rs
View File

@ -9,19 +9,19 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::BLE001, Path::new("BLE.py"); "BLE001")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::BLE001, Path::new("BLE.py"); "BLE001")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_blind_except")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
&settings::Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

4
src/flake8_blind_except/plugins.rs
View File

@ -2,7 +2,7 @@ use rustpython_ast::{Expr, ExprKind, Stmt, StmtKind};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// BLE001
@ -36,7 +36,7 @@ pub fn blind_except(
false
}
}) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::BlindExcept(id.to_string()),
Range::from_located(type_),
));

18
src/flake8_boolean_trap/mod.rs
View File

@ -9,21 +9,21 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::FBT001, Path::new("FBT.py"); "FBT001")]
#[test_case(CheckCode::FBT002, Path::new("FBT.py"); "FBT002")]
#[test_case(CheckCode::FBT003, Path::new("FBT.py"); "FBT003")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::FBT001, Path::new("FBT.py"); "FBT001")]
#[test_case(RuleCode::FBT002, Path::new("FBT.py"); "FBT002")]
#[test_case(RuleCode::FBT003, Path::new("FBT.py"); "FBT003")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_boolean_trap")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
&settings::Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

10
src/flake8_boolean_trap/plugins.rs
View File

@ -3,7 +3,7 @@ use rustpython_parser::ast::{Constant, Expr};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::{Check, CheckKind};
use crate::registry::{Diagnostic, DiagnosticKind};
use crate::violations;
const FUNC_NAME_ALLOWLIST: &[&str] = &[
@ -47,11 +47,11 @@ fn is_boolean_arg(arg: &Expr) -> bool {
)
}
fn add_if_boolean(checker: &mut Checker, arg: &Expr, kind: CheckKind) {
fn add_if_boolean(checker: &mut Checker, arg: &Expr, kind: DiagnosticKind) {
if is_boolean_arg(arg) {
checker
.checks
.push(Check::new(kind, Range::from_located(arg)));
.diagnostics
.push(Diagnostic::new(kind, Range::from_located(arg)));
}
}
@ -76,7 +76,7 @@ pub fn check_positional_boolean_in_def(checker: &mut Checker, arguments: &Argume
if !hint {
continue;
}
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::BooleanPositionalArgInFunctionDefinition,
Range::from_located(arg),
));

74
src/flake8_bugbear/mod.rs
View File

@ -9,53 +9,53 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::{flake8_bugbear, Settings};
#[test_case(CheckCode::B002, Path::new("B002.py"); "B002")]
#[test_case(CheckCode::B003, Path::new("B003.py"); "B003")]
#[test_case(CheckCode::B004, Path::new("B004.py"); "B004")]
#[test_case(CheckCode::B005, Path::new("B005.py"); "B005")]
#[test_case(CheckCode::B006, Path::new("B006_B008.py"); "B006")]
#[test_case(CheckCode::B007, Path::new("B007.py"); "B007")]
#[test_case(CheckCode::B008, Path::new("B006_B008.py"); "B008")]
#[test_case(CheckCode::B009, Path::new("B009_B010.py"); "B009")]
#[test_case(CheckCode::B010, Path::new("B009_B010.py"); "B010")]
#[test_case(CheckCode::B011, Path::new("B011.py"); "B011")]
#[test_case(CheckCode::B012, Path::new("B012.py"); "B012")]
#[test_case(CheckCode::B013, Path::new("B013.py"); "B013")]
#[test_case(CheckCode::B014, Path::new("B014.py"); "B014")]
#[test_case(CheckCode::B015, Path::new("B015.py"); "B015")]
#[test_case(CheckCode::B016, Path::new("B016.py"); "B016")]
#[test_case(CheckCode::B017, Path::new("B017.py"); "B017")]
#[test_case(CheckCode::B018, Path::new("B018.py"); "B018")]
#[test_case(CheckCode::B019, Path::new("B019.py"); "B019")]
#[test_case(CheckCode::B020, Path::new("B020.py"); "B020")]
#[test_case(CheckCode::B021, Path::new("B021.py"); "B021")]
#[test_case(CheckCode::B022, Path::new("B022.py"); "B022")]
#[test_case(CheckCode::B023, Path::new("B023.py"); "B023")]
#[test_case(CheckCode::B024, Path::new("B024.py"); "B024")]
#[test_case(CheckCode::B025, Path::new("B025.py"); "B025")]
#[test_case(CheckCode::B026, Path::new("B026.py"); "B026")]
#[test_case(CheckCode::B027, Path::new("B027.py"); "B027")]
#[test_case(CheckCode::B904, Path::new("B904.py"); "B904")]
#[test_case(CheckCode::B905, Path::new("B905.py"); "B905")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::B002, Path::new("B002.py"); "B002")]
#[test_case(RuleCode::B003, Path::new("B003.py"); "B003")]
#[test_case(RuleCode::B004, Path::new("B004.py"); "B004")]
#[test_case(RuleCode::B005, Path::new("B005.py"); "B005")]
#[test_case(RuleCode::B006, Path::new("B006_B008.py"); "B006")]
#[test_case(RuleCode::B007, Path::new("B007.py"); "B007")]
#[test_case(RuleCode::B008, Path::new("B006_B008.py"); "B008")]
#[test_case(RuleCode::B009, Path::new("B009_B010.py"); "B009")]
#[test_case(RuleCode::B010, Path::new("B009_B010.py"); "B010")]
#[test_case(RuleCode::B011, Path::new("B011.py"); "B011")]
#[test_case(RuleCode::B012, Path::new("B012.py"); "B012")]
#[test_case(RuleCode::B013, Path::new("B013.py"); "B013")]
#[test_case(RuleCode::B014, Path::new("B014.py"); "B014")]
#[test_case(RuleCode::B015, Path::new("B015.py"); "B015")]
#[test_case(RuleCode::B016, Path::new("B016.py"); "B016")]
#[test_case(RuleCode::B017, Path::new("B017.py"); "B017")]
#[test_case(RuleCode::B018, Path::new("B018.py"); "B018")]
#[test_case(RuleCode::B019, Path::new("B019.py"); "B019")]
#[test_case(RuleCode::B020, Path::new("B020.py"); "B020")]
#[test_case(RuleCode::B021, Path::new("B021.py"); "B021")]
#[test_case(RuleCode::B022, Path::new("B022.py"); "B022")]
#[test_case(RuleCode::B023, Path::new("B023.py"); "B023")]
#[test_case(RuleCode::B024, Path::new("B024.py"); "B024")]
#[test_case(RuleCode::B025, Path::new("B025.py"); "B025")]
#[test_case(RuleCode::B026, Path::new("B026.py"); "B026")]
#[test_case(RuleCode::B027, Path::new("B027.py"); "B027")]
#[test_case(RuleCode::B904, Path::new("B904.py"); "B904")]
#[test_case(RuleCode::B905, Path::new("B905.py"); "B905")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_bugbear")
.join(path)
.as_path(),
&Settings::for_rule(check_code),
&Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
#[test]
fn extend_immutable_calls() -> Result<()> {
let snapshot = "extend_immutable_calls".to_string();
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_bugbear/B008_extended.py"),
&Settings {
flake8_bugbear: flake8_bugbear::settings::Settings {
@ -64,10 +64,10 @@ mod tests {
"fastapi.Query".to_string(),
],
},
..Settings::for_rules(vec![CheckCode::B008])
..Settings::for_rules(vec![RuleCode::B008])
},
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

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

@ -4,7 +4,7 @@ use rustpython_ast::{Constant, Expr, ExprKind, Keyword, Stmt, StmtKind};
use crate::ast::helpers::match_module_member;
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::{Check, CheckCode};
use crate::registry::{Diagnostic, RuleCode};
use crate::violations;
fn is_abc_class(
@ -108,7 +108,7 @@ pub fn abstract_base_class(
has_abstract_method |= has_abstract_decorator;
if !checker.settings.enabled.contains(&CheckCode::B027) {
if !checker.settings.enabled.contains(&RuleCode::B027) {
continue;
}
@ -118,15 +118,15 @@ pub fn abstract_base_class(
.iter()
.any(|d| is_overload(d, &checker.from_imports, &checker.import_aliases))
{
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::EmptyMethodWithoutAbstractDecorator(name.to_string()),
Range::from_located(stmt),
));
}
}
if checker.settings.enabled.contains(&CheckCode::B024) {
if checker.settings.enabled.contains(&RuleCode::B024) {
if !has_abstract_method {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::AbstractBaseClassWithoutAbstractMethod(name.to_string()),
Range::from_located(stmt),
));

6
src/flake8_bugbear/plugins/assert_false.rs
View File

@ -3,7 +3,7 @@ use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Location, Stmt, Stmt
use crate::ast::types::Range;
use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::source_code_generator::SourceCodeGenerator;
use crate::violations;
@ -46,7 +46,7 @@ pub fn assert_false(checker: &mut Checker, stmt: &Stmt, test: &Expr, msg: Option
return;
};
let mut check = Check::new(violations::DoNotAssertFalse, Range::from_located(test));
let mut check = Diagnostic::new(violations::DoNotAssertFalse, Range::from_located(test));
if checker.patch(check.kind.code()) {
let mut generator: SourceCodeGenerator = checker.style.into();
generator.unparse_stmt(&assertion_error(msg));
@ -56,5 +56,5 @@ pub fn assert_false(checker: &mut Checker, stmt: &Stmt, test: &Expr, msg: Option
stmt.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}

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

@ -3,7 +3,7 @@ use rustpython_ast::{ExprKind, Stmt, Withitem};
use crate::ast::helpers::match_module_member;
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// B017
@ -34,7 +34,7 @@ pub fn assert_raises_exception(checker: &mut Checker, stmt: &Stmt, items: &[With
return;
}
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::NoAssertRaisesException,
Range::from_located(stmt),
));

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

@ -2,7 +2,7 @@ use rustpython_ast::{Expr, ExprKind};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// B003
@ -23,7 +23,7 @@ pub fn assignment_to_os_environ(checker: &mut Checker, targets: &[Expr]) {
if id != "os" {
return;
}
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::AssignmentToOsEnviron,
Range::from_located(target),
));

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

@ -3,7 +3,7 @@ use rustpython_ast::{Expr, ExprKind};
use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path};
use crate::ast::types::{Range, ScopeKind};
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
fn is_cache_func(checker: &Checker, expr: &Expr) -> bool {
@ -34,7 +34,7 @@ pub fn cached_instance_method(checker: &mut Checker, decorator_list: &[Expr]) {
_ => decorator,
},
) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::CachedInstanceMethod,
Range::from_located(decorator),
));

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

@ -2,7 +2,7 @@ use rustpython_ast::{Expr, ExprKind};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// B016
@ -10,7 +10,7 @@ pub fn cannot_raise_literal(checker: &mut Checker, expr: &Expr) {
let ExprKind::Constant { .. } = &expr.node else {
return;
};
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::CannotRaiseLiteral,
Range::from_located(expr),
));

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

@ -6,7 +6,7 @@ use crate::ast::helpers;
use crate::ast::types::Range;
use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::registry::{Check, CheckCode};
use crate::registry::{Diagnostic, RuleCode};
use crate::source_code_generator::SourceCodeGenerator;
use crate::violations;
@ -41,10 +41,10 @@ fn duplicate_handler_exceptions<'a>(
}
}
if checker.settings.enabled.contains(&CheckCode::B014) {
if checker.settings.enabled.contains(&RuleCode::B014) {
// TODO(charlie): Handle "BaseException" and redundant exception aliases.
if !duplicates.is_empty() {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::DuplicateHandlerException(
duplicates
.into_iter()
@ -67,7 +67,7 @@ fn duplicate_handler_exceptions<'a>(
expr.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
@ -105,10 +105,10 @@ pub fn duplicate_exceptions(checker: &mut Checker, handlers: &[Excepthandler]) {
}
}
if checker.settings.enabled.contains(&CheckCode::B025) {
if checker.settings.enabled.contains(&RuleCode::B025) {
for (name, exprs) in duplicates {
for expr in exprs {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::DuplicateTryBlockException(name.join(".")),
Range::from_located(expr),
));

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

@ -2,7 +2,7 @@ use rustpython_ast::{ExprKind, Stmt, StmtKind};
use crate::ast::helpers;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// B021
@ -16,7 +16,7 @@ pub fn f_string_docstring(checker: &mut Checker, body: &[Stmt]) {
let ExprKind::JoinedStr { .. } = value.node else {
return;
};
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::FStringDocstring,
helpers::identifier_range(stmt, checker.locator),
));

6
src/flake8_bugbear/plugins/function_call_argument_default.rs
View File

@ -9,7 +9,7 @@ use crate::ast::visitor;
use crate::ast::visitor::Visitor;
use crate::checkers::ast::Checker;
use crate::flake8_bugbear::plugins::mutable_argument_default::is_mutable_func;
use crate::registry::{Check, CheckKind};
use crate::registry::{Diagnostic, DiagnosticKind};
use crate::violations;
const IMMUTABLE_FUNCS: [(&str, &str); 7] = [
@ -36,7 +36,7 @@ fn is_immutable_func(
}
struct ArgumentDefaultVisitor<'a> {
checks: Vec<(CheckKind, Range)>,
checks: Vec<(DiagnosticKind, Range)>,
extend_immutable_calls: &'a [(&'a str, &'a str)],
from_imports: &'a FxHashMap<&'a str, FxHashSet<&'a str>>,
import_aliases: &'a FxHashMap<&'a str, &'a str>,
@ -118,6 +118,6 @@ pub fn function_call_argument_default(checker: &mut Checker, arguments: &Argumen
visitor.visit_expr(expr);
}
for (check, range) in visitor.checks {
checker.checks.push(Check::new(check, range));
checker.diagnostics.push(Diagnostic::new(check, range));
}
}

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

@ -6,7 +6,7 @@ use crate::ast::types::{Node, Range};
use crate::ast::visitor;
use crate::ast::visitor::Visitor;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
#[derive(Default)]
@ -212,7 +212,7 @@ where
if reassigned_in_loop.contains(name) {
if !checker.flake8_bugbear_seen.contains(&expr) {
checker.flake8_bugbear_seen.push(expr);
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::FunctionUsesLoopVariable(name.to_string()),
range,
));

6
src/flake8_bugbear/plugins/getattr_with_constant.rs
View File

@ -5,7 +5,7 @@ use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::python::identifiers::IDENTIFIER_REGEX;
use crate::python::keyword::KWLIST;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::source_code_generator::SourceCodeGenerator;
use crate::violations;
@ -45,7 +45,7 @@ pub fn getattr_with_constant(checker: &mut Checker, expr: &Expr, func: &Expr, ar
return;
}
let mut check = Check::new(violations::GetAttrWithConstant, Range::from_located(expr));
let mut check = Diagnostic::new(violations::GetAttrWithConstant, Range::from_located(expr));
if checker.patch(check.kind.code()) {
let mut generator: SourceCodeGenerator = checker.style.into();
generator.unparse_expr(&attribute(obj, value), 0);
@ -55,5 +55,5 @@ pub fn getattr_with_constant(checker: &mut Checker, expr: &Expr, func: &Expr, ar
expr.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}

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

@ -2,13 +2,13 @@ use rustpython_ast::{Stmt, StmtKind};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
fn walk_stmt(checker: &mut Checker, body: &[Stmt], f: fn(&Stmt) -> bool) {
for stmt in body {
if f(stmt) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::JumpStatementInFinally(match &stmt.node {
StmtKind::Break { .. } => "break".to_string(),
StmtKind::Continue { .. } => "continue".to_string(),

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

@ -5,7 +5,7 @@ use crate::ast::types::Range;
use crate::ast::visitor;
use crate::ast::visitor::Visitor;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
#[derive(Default)]
@ -56,7 +56,7 @@ pub fn loop_variable_overrides_iterator(checker: &mut Checker, target: &Expr, it
for (name, expr) in target_names {
if iter_names.contains_key(name) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::LoopVariableOverridesIterator(name.to_string()),
Range::from_located(expr),
));

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

@ -4,7 +4,7 @@ use rustpython_ast::{Arguments, Constant, Expr, ExprKind, Operator};
use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
const MUTABLE_FUNCS: &[(&str, &str)] = &[
@ -165,7 +165,7 @@ pub fn mutable_argument_default(checker: &mut Checker, arguments: &Arguments) {
!is_immutable_annotation(expr, &checker.from_imports, &checker.import_aliases)
})
{
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::MutableArgumentDefault,
Range::from_located(default),
));

8
src/flake8_bugbear/plugins/raise_without_from_inside_except.rs
View File

@ -4,11 +4,11 @@ use crate::ast::types::Range;
use crate::ast::visitor::Visitor;
use crate::checkers::ast::Checker;
use crate::python::string::is_lower;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
struct RaiseVisitor {
checks: Vec<Check>,
checks: Vec<Diagnostic>,
}
impl<'a> Visitor<'a> for RaiseVisitor {
@ -20,7 +20,7 @@ impl<'a> Visitor<'a> for RaiseVisitor {
} => match &exc.node {
ExprKind::Name { id, .. } if is_lower(id) => {}
_ => {
self.checks.push(Check::new(
self.checks.push(Diagnostic::new(
violations::RaiseWithoutFromInsideExcept,
Range::from_located(stmt),
));
@ -50,5 +50,5 @@ pub fn raise_without_from_inside_except(checker: &mut Checker, body: &[Stmt]) {
for stmt in body {
visitor.visit_stmt(stmt);
}
checker.checks.extend(visitor.checks);
checker.diagnostics.extend(visitor.checks);
}

6
src/flake8_bugbear/plugins/redundant_tuple_in_exception_handler.rs
View File

@ -3,7 +3,7 @@ use rustpython_ast::{Excepthandler, ExcepthandlerKind, ExprKind};
use crate::ast::types::Range;
use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::source_code_generator::SourceCodeGenerator;
use crate::violations;
@ -19,7 +19,7 @@ pub fn redundant_tuple_in_exception_handler(checker: &mut Checker, handlers: &[E
let [elt] = &elts[..] else {
continue;
};
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::RedundantTupleInExceptionHandler(elt.to_string()),
Range::from_located(type_),
);
@ -32,6 +32,6 @@ pub fn redundant_tuple_in_exception_handler(checker: &mut Checker, handlers: &[E
type_.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}

7
src/flake8_bugbear/plugins/setattr_with_constant.rs
View File

@ -5,7 +5,7 @@ use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::python::identifiers::IDENTIFIER_REGEX;
use crate::python::keyword::KWLIST;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::source_code_generator::SourceCodeGenerator;
use crate::source_code_style::SourceCodeStyleDetector;
use crate::violations;
@ -61,7 +61,8 @@ pub fn setattr_with_constant(checker: &mut Checker, expr: &Expr, func: &Expr, ar
// (i.e., it's directly within an `StmtKind::Expr`).
if let StmtKind::Expr { value: child } = &checker.current_stmt().node {
if expr == child.as_ref() {
let mut check = Check::new(violations::SetAttrWithConstant, Range::from_located(expr));
let mut check =
Diagnostic::new(violations::SetAttrWithConstant, Range::from_located(expr));
if checker.patch(check.kind.code()) {
check.amend(Fix::replacement(
assignment(obj, name, value, checker.style),
@ -69,7 +70,7 @@ pub fn setattr_with_constant(checker: &mut Checker, expr: &Expr, func: &Expr, ar
expr.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
}

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

@ -2,7 +2,7 @@ use rustpython_ast::{Expr, ExprKind, Keyword};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// B026
@ -21,7 +21,7 @@ pub fn star_arg_unpacking_after_keyword_arg(
if arg.location <= keyword.location {
continue;
}
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::StarArgUnpackingAfterKeywordArg,
Range::from_located(arg),
));

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

@ -3,7 +3,7 @@ use rustpython_ast::{Constant, Expr, ExprKind};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// B005
@ -26,7 +26,7 @@ pub fn strip_with_multi_characters(checker: &mut Checker, expr: &Expr, func: &Ex
};
if value.len() > 1 && value.chars().unique().count() != value.len() {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::StripWithMultiCharacters,
Range::from_located(expr),
));

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

@ -2,7 +2,7 @@ use rustpython_ast::{Expr, ExprKind, Unaryop};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// B002
@ -16,7 +16,7 @@ pub fn unary_prefix_increment(checker: &mut Checker, expr: &Expr, op: &Unaryop,
if !matches!(op, Unaryop::UAdd) {
return;
}
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::UnaryPrefixIncrement,
Range::from_located(expr),
));

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

@ -2,7 +2,7 @@ use rustpython_ast::{Constant, Expr, ExprKind};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// B004
@ -26,7 +26,7 @@ pub fn unreliable_callable_check(checker: &mut Checker, expr: &Expr, func: &Expr
if s != "__call__" {
return;
}
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::UnreliableCallableCheck,
Range::from_located(expr),
));

6
src/flake8_bugbear/plugins/unused_loop_control_variable.rs
View File

@ -6,7 +6,7 @@ use crate::ast::visitor;
use crate::ast::visitor::Visitor;
use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// Identify all `ExprKind::Name` nodes in an AST.
@ -62,7 +62,7 @@ pub fn unused_loop_control_variable(checker: &mut Checker, target: &Expr, body:
continue;
}
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UnusedLoopControlVariable(name.to_string()),
Range::from_located(expr),
);
@ -74,6 +74,6 @@ pub fn unused_loop_control_variable(checker: &mut Checker, target: &Expr, body:
expr.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}

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

@ -2,12 +2,12 @@ use rustpython_ast::{Expr, ExprKind};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
pub fn useless_comparison(checker: &mut Checker, expr: &Expr) {
if matches!(expr.node, ExprKind::Compare { .. }) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::UselessComparison,
Range::from_located(expr),
));

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

@ -3,7 +3,7 @@ use rustpython_ast::Expr;
use crate::ast::helpers::{collect_call_paths, match_call_path};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// B005
@ -15,7 +15,7 @@ pub fn useless_contextlib_suppress(checker: &mut Checker, expr: &Expr, args: &[E
&checker.from_imports,
) && args.is_empty()
{
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::UselessContextlibSuppress,
Range::from_located(expr),
));

6
src/flake8_bugbear/plugins/useless_expression.rs
View File

@ -2,7 +2,7 @@ use rustpython_ast::{Constant, ExprKind, Stmt, StmtKind};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
// B018
@ -11,7 +11,7 @@ pub fn useless_expression(checker: &mut Checker, body: &[Stmt]) {
if let StmtKind::Expr { value } = &stmt.node {
match &value.node {
ExprKind::List { .. } | ExprKind::Dict { .. } | ExprKind::Set { .. } => {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::UselessExpression,
Range::from_located(value),
));
@ -19,7 +19,7 @@ pub fn useless_expression(checker: &mut Checker, body: &[Stmt]) {
ExprKind::Constant { value: val, .. } => match &val {
Constant::Str { .. } | Constant::Ellipsis => {}
_ => {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::UselessExpression,
Range::from_located(value),
));

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

@ -2,7 +2,7 @@ use rustpython_ast::{Expr, ExprKind, Keyword};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// B905
@ -23,7 +23,7 @@ pub fn zip_without_explicit_strict(
.map_or(false, |name| name == "strict")
})
{
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::ZipWithoutExplicitStrict,
Range::from_located(expr),
));

6
src/flake8_builtins/checks.rs
View File

@ -3,7 +3,7 @@ use rustpython_ast::Located;
use crate::ast::types::Range;
use crate::flake8_builtins::types::ShadowingType;
use crate::python::builtins::BUILTINS;
use crate::registry::{Check, CheckKind};
use crate::registry::{Diagnostic, DiagnosticKind};
use crate::violations;
/// Check builtin name shadowing.
@ -11,9 +11,9 @@ pub fn builtin_shadowing<T>(
name: &str,
located: &Located<T>,
node_type: ShadowingType,
) -> Option<Check> {
) -> Option<Diagnostic> {
if BUILTINS.contains(&name) {
Some(Check::new::<CheckKind>(
Some(Diagnostic::new::<DiagnosticKind>(
match node_type {
ShadowingType::Variable => {
violations::BuiltinVariableShadowing(name.to_string()).into()

18
src/flake8_builtins/mod.rs
View File

@ -10,21 +10,21 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::A001, Path::new("A001.py"); "A001")]
#[test_case(CheckCode::A002, Path::new("A002.py"); "A002")]
#[test_case(CheckCode::A003, Path::new("A003.py"); "A003")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::A001, Path::new("A001.py"); "A001")]
#[test_case(RuleCode::A002, Path::new("A002.py"); "A002")]
#[test_case(RuleCode::A003, Path::new("A003.py"); "A003")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_builtins")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
&settings::Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

70
src/flake8_comprehensions/checks.rs
View File

@ -6,7 +6,7 @@ use rustpython_ast::{
use crate::ast::types::Range;
use crate::flake8_comprehensions::fixes;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::source_code_locator::SourceCodeLocator;
use crate::violations;
@ -56,10 +56,10 @@ pub fn unnecessary_generator_list(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let argument = exactly_one_argument_with_matching_function("list", func, args, keywords)?;
if let ExprKind::GeneratorExp { .. } = argument {
let mut check = Check::new(violations::UnnecessaryGeneratorList, location);
let mut check = Diagnostic::new(violations::UnnecessaryGeneratorList, location);
if fix {
match fixes::fix_unnecessary_generator_list(locator, expr) {
Ok(fix) => {
@ -82,10 +82,10 @@ pub fn unnecessary_generator_set(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let argument = exactly_one_argument_with_matching_function("set", func, args, keywords)?;
if let ExprKind::GeneratorExp { .. } = argument {
let mut check = Check::new(violations::UnnecessaryGeneratorSet, location);
let mut check = Diagnostic::new(violations::UnnecessaryGeneratorSet, location);
if fix {
match fixes::fix_unnecessary_generator_set(locator, expr) {
Ok(fix) => {
@ -108,12 +108,12 @@ pub fn unnecessary_generator_dict(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let argument = exactly_one_argument_with_matching_function("dict", func, args, keywords)?;
if let ExprKind::GeneratorExp { elt, .. } = argument {
match &elt.node {
ExprKind::Tuple { elts, .. } if elts.len() == 2 => {
let mut check = Check::new(violations::UnnecessaryGeneratorDict, location);
let mut check = Diagnostic::new(violations::UnnecessaryGeneratorDict, location);
if fix {
match fixes::fix_unnecessary_generator_dict(locator, expr) {
Ok(fix) => {
@ -139,10 +139,10 @@ pub fn unnecessary_list_comprehension_set(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let argument = exactly_one_argument_with_matching_function("set", func, args, keywords)?;
if let ExprKind::ListComp { .. } = &argument {
let mut check = Check::new(violations::UnnecessaryListComprehensionSet, location);
let mut check = Diagnostic::new(violations::UnnecessaryListComprehensionSet, location);
if fix {
match fixes::fix_unnecessary_list_comprehension_set(locator, expr) {
Ok(fix) => {
@ -165,7 +165,7 @@ pub fn unnecessary_list_comprehension_dict(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let argument = exactly_one_argument_with_matching_function("dict", func, args, keywords)?;
let ExprKind::ListComp { elt, .. } = &argument else {
return None;
@ -176,7 +176,7 @@ pub fn unnecessary_list_comprehension_dict(
if elts.len() != 2 {
return None;
}
let mut check = Check::new(violations::UnnecessaryListComprehensionDict, location);
let mut check = Diagnostic::new(violations::UnnecessaryListComprehensionDict, location);
if fix {
match fixes::fix_unnecessary_list_comprehension_dict(locator, expr) {
Ok(fix) => {
@ -197,14 +197,14 @@ pub fn unnecessary_literal_set(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let argument = exactly_one_argument_with_matching_function("set", func, args, keywords)?;
let kind = match argument {
ExprKind::List { .. } => "list",
ExprKind::Tuple { .. } => "tuple",
_ => return None,
};
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UnnecessaryLiteralSet(kind.to_string()),
location,
);
@ -228,7 +228,7 @@ pub fn unnecessary_literal_dict(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let argument = exactly_one_argument_with_matching_function("dict", func, args, keywords)?;
let (kind, elts) = match argument {
ExprKind::Tuple { elts, .. } => ("tuple", elts),
@ -242,7 +242,7 @@ pub fn unnecessary_literal_dict(
{
return None;
}
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UnnecessaryLiteralDict(kind.to_string()),
location,
);
@ -266,7 +266,7 @@ pub fn unnecessary_collection_call(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
if !args.is_empty() {
return None;
}
@ -280,7 +280,7 @@ pub fn unnecessary_collection_call(
}
_ => return None,
};
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UnnecessaryCollectionCall(id.to_string()),
location,
);
@ -303,14 +303,14 @@ pub fn unnecessary_literal_within_tuple_call(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let argument = first_argument_with_matching_function("tuple", func, args)?;
let argument_kind = match argument {
ExprKind::Tuple { .. } => "tuple",
ExprKind::List { .. } => "list",
_ => return None,
};
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UnnecessaryLiteralWithinTupleCall(argument_kind.to_string()),
location,
);
@ -333,14 +333,14 @@ pub fn unnecessary_literal_within_list_call(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let argument = first_argument_with_matching_function("list", func, args)?;
let argument_kind = match argument {
ExprKind::Tuple { .. } => "tuple",
ExprKind::List { .. } => "list",
_ => return None,
};
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UnnecessaryLiteralWithinListCall(argument_kind.to_string()),
location,
);
@ -363,12 +363,12 @@ pub fn unnecessary_list_call(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let argument = first_argument_with_matching_function("list", func, args)?;
if !matches!(argument, ExprKind::ListComp { .. }) {
return None;
}
let mut check = Check::new(violations::UnnecessaryListCall, location);
let mut check = Diagnostic::new(violations::UnnecessaryListCall, location);
if fix {
match fixes::fix_unnecessary_list_call(locator, expr) {
Ok(fix) => {
@ -388,7 +388,7 @@ pub fn unnecessary_call_around_sorted(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let outer = function_name(func)?;
if !(outer == "list" || outer == "reversed") {
return None;
@ -400,7 +400,7 @@ pub fn unnecessary_call_around_sorted(
return None;
}
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UnnecessaryCallAroundSorted(outer.to_string()),
location,
);
@ -420,9 +420,9 @@ pub fn unnecessary_double_cast_or_process(
func: &Expr,
args: &[Expr],
location: Range,
) -> Option<Check> {
fn new_check(inner: &str, outer: &str, location: Range) -> Check {
Check::new(
) -> Option<Diagnostic> {
fn new_check(inner: &str, outer: &str, location: Range) -> Diagnostic {
Diagnostic::new(
violations::UnnecessaryDoubleCastOrProcess(inner.to_string(), outer.to_string()),
location,
)
@ -463,7 +463,7 @@ pub fn unnecessary_subscript_reversal(
func: &Expr,
args: &[Expr],
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
let first_arg = args.first()?;
let id = function_name(func)?;
if !["set", "sorted", "reversed"].contains(&id) {
@ -493,7 +493,7 @@ pub fn unnecessary_subscript_reversal(
if *val != BigInt::from(1) {
return None;
};
Some(Check::new(
Some(Diagnostic::new(
violations::UnnecessarySubscriptReversal(id.to_string()),
location,
))
@ -507,7 +507,7 @@ pub fn unnecessary_comprehension(
locator: &SourceCodeLocator,
fix: bool,
location: Range,
) -> Option<Check> {
) -> Option<Diagnostic> {
if generators.len() != 1 {
return None;
}
@ -525,7 +525,7 @@ pub fn unnecessary_comprehension(
ExprKind::SetComp { .. } => "set",
_ => return None,
};
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UnnecessaryComprehension(expr_kind.to_string()),
location,
);
@ -541,9 +541,9 @@ pub fn unnecessary_comprehension(
}
/// C417
pub fn unnecessary_map(func: &Expr, args: &[Expr], location: Range) -> Option<Check> {
fn new_check(kind: &str, location: Range) -> Check {
Check::new(violations::UnnecessaryMap(kind.to_string()), location)
pub fn unnecessary_map(func: &Expr, args: &[Expr], location: Range) -> Option<Diagnostic> {
fn new_check(kind: &str, location: Range) -> Diagnostic {
Diagnostic::new(violations::UnnecessaryMap(kind.to_string()), location)
}
let id = function_name(func)?;
match id {

44
src/flake8_comprehensions/mod.rs
View File

@ -10,35 +10,35 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::C400, Path::new("C400.py"); "C400")]
#[test_case(CheckCode::C401, Path::new("C401.py"); "C401")]
#[test_case(CheckCode::C402, Path::new("C402.py"); "C402")]
#[test_case(CheckCode::C403, Path::new("C403.py"); "C403")]
#[test_case(CheckCode::C404, Path::new("C404.py"); "C404")]
#[test_case(CheckCode::C405, Path::new("C405.py"); "C405")]
#[test_case(CheckCode::C406, Path::new("C406.py"); "C406")]
#[test_case(CheckCode::C408, Path::new("C408.py"); "C408")]
#[test_case(CheckCode::C409, Path::new("C409.py"); "C409")]
#[test_case(CheckCode::C410, Path::new("C410.py"); "C410")]
#[test_case(CheckCode::C411, Path::new("C411.py"); "C411")]
#[test_case(CheckCode::C413, Path::new("C413.py"); "C413")]
#[test_case(CheckCode::C414, Path::new("C414.py"); "C414")]
#[test_case(CheckCode::C415, Path::new("C415.py"); "C415")]
#[test_case(CheckCode::C416, Path::new("C416.py"); "C416")]
#[test_case(CheckCode::C417, Path::new("C417.py"); "C417")]
#[test_case(RuleCode::C400, Path::new("C400.py"); "C400")]
#[test_case(RuleCode::C401, Path::new("C401.py"); "C401")]
#[test_case(RuleCode::C402, Path::new("C402.py"); "C402")]
#[test_case(RuleCode::C403, Path::new("C403.py"); "C403")]
#[test_case(RuleCode::C404, Path::new("C404.py"); "C404")]
#[test_case(RuleCode::C405, Path::new("C405.py"); "C405")]
#[test_case(RuleCode::C406, Path::new("C406.py"); "C406")]
#[test_case(RuleCode::C408, Path::new("C408.py"); "C408")]
#[test_case(RuleCode::C409, Path::new("C409.py"); "C409")]
#[test_case(RuleCode::C410, Path::new("C410.py"); "C410")]
#[test_case(RuleCode::C411, Path::new("C411.py"); "C411")]
#[test_case(RuleCode::C413, Path::new("C413.py"); "C413")]
#[test_case(RuleCode::C414, Path::new("C414.py"); "C414")]
#[test_case(RuleCode::C415, Path::new("C415.py"); "C415")]
#[test_case(RuleCode::C416, Path::new("C416.py"); "C416")]
#[test_case(RuleCode::C417, Path::new("C417.py"); "C417")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_comprehensions")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
&settings::Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

30
src/flake8_datetimez/mod.rs
View File

@ -9,27 +9,27 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::DTZ001, Path::new("DTZ001.py"); "DTZ001")]
#[test_case(CheckCode::DTZ002, Path::new("DTZ002.py"); "DTZ002")]
#[test_case(CheckCode::DTZ003, Path::new("DTZ003.py"); "DTZ003")]
#[test_case(CheckCode::DTZ004, Path::new("DTZ004.py"); "DTZ004")]
#[test_case(CheckCode::DTZ005, Path::new("DTZ005.py"); "DTZ005")]
#[test_case(CheckCode::DTZ006, Path::new("DTZ006.py"); "DTZ006")]
#[test_case(CheckCode::DTZ007, Path::new("DTZ007.py"); "DTZ007")]
#[test_case(CheckCode::DTZ011, Path::new("DTZ011.py"); "DTZ011")]
#[test_case(CheckCode::DTZ012, Path::new("DTZ012.py"); "DTZ012")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::DTZ001, Path::new("DTZ001.py"); "DTZ001")]
#[test_case(RuleCode::DTZ002, Path::new("DTZ002.py"); "DTZ002")]
#[test_case(RuleCode::DTZ003, Path::new("DTZ003.py"); "DTZ003")]
#[test_case(RuleCode::DTZ004, Path::new("DTZ004.py"); "DTZ004")]
#[test_case(RuleCode::DTZ005, Path::new("DTZ005.py"); "DTZ005")]
#[test_case(RuleCode::DTZ006, Path::new("DTZ006.py"); "DTZ006")]
#[test_case(RuleCode::DTZ007, Path::new("DTZ007.py"); "DTZ007")]
#[test_case(RuleCode::DTZ011, Path::new("DTZ011.py"); "DTZ011")]
#[test_case(RuleCode::DTZ012, Path::new("DTZ012.py"); "DTZ012")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_datetimez")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
&settings::Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

65
src/flake8_datetimez/plugins.rs
View File

@ -5,7 +5,7 @@ use crate::ast::helpers::{
};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
pub fn call_datetime_without_tzinfo(
@ -22,17 +22,19 @@ pub fn call_datetime_without_tzinfo(
// No positional arg: keyword is missing or constant None.
if args.len() < 8 && !has_non_none_keyword(keywords, "tzinfo") {
checker
.checks
.push(Check::new(violations::CallDatetimeWithoutTzinfo, location));
checker.diagnostics.push(Diagnostic::new(
violations::CallDatetimeWithoutTzinfo,
location,
));
return;
}
// Positional arg: is constant None.
if args.len() >= 8 && is_const_none(&args[7]) {
checker
.checks
.push(Check::new(violations::CallDatetimeWithoutTzinfo, location));
checker.diagnostics.push(Diagnostic::new(
violations::CallDatetimeWithoutTzinfo,
location,
));
}
}
@ -46,8 +48,8 @@ pub fn call_datetime_today(checker: &mut Checker, func: &Expr, location: Range)
&checker.from_imports,
) {
checker
.checks
.push(Check::new(violations::CallDatetimeToday, location));
.diagnostics
.push(Diagnostic::new(violations::CallDatetimeToday, location));
}
}
@ -61,8 +63,8 @@ pub fn call_datetime_utcnow(checker: &mut Checker, func: &Expr, location: Range)
&checker.from_imports,
) {
checker
.checks
.push(Check::new(violations::CallDatetimeUtcnow, location));
.diagnostics
.push(Diagnostic::new(violations::CallDatetimeUtcnow, location));
}
}
@ -75,7 +77,7 @@ pub fn call_datetime_utcfromtimestamp(checker: &mut Checker, func: &Expr, locati
"utcfromtimestamp",
&checker.from_imports,
) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::CallDatetimeUtcfromtimestamp,
location,
));
@ -102,7 +104,7 @@ pub fn call_datetime_now_without_tzinfo(
// no args / no args unqualified
if args.is_empty() && keywords.is_empty() {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::CallDatetimeNowWithoutTzinfo,
location,
));
@ -111,7 +113,7 @@ pub fn call_datetime_now_without_tzinfo(
// none args
if !args.is_empty() && is_const_none(&args[0]) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::CallDatetimeNowWithoutTzinfo,
location,
));
@ -120,7 +122,7 @@ pub fn call_datetime_now_without_tzinfo(
// wrong keywords / none keyword
if !keywords.is_empty() && !has_non_none_keyword(keywords, "tz") {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::CallDatetimeNowWithoutTzinfo,
location,
));
@ -147,25 +149,28 @@ pub fn call_datetime_fromtimestamp(
// no args / no args unqualified
if args.len() < 2 && keywords.is_empty() {
checker
.checks
.push(Check::new(violations::CallDatetimeFromtimestamp, location));
checker.diagnostics.push(Diagnostic::new(
violations::CallDatetimeFromtimestamp,
location,
));
return;
}
// none args
if args.len() > 1 && is_const_none(&args[1]) {
checker
.checks
.push(Check::new(violations::CallDatetimeFromtimestamp, location));
checker.diagnostics.push(Diagnostic::new(
violations::CallDatetimeFromtimestamp,
location,
));
return;
}
// wrong keywords / none keyword
if !keywords.is_empty() && !has_non_none_keyword(keywords, "tz") {
checker
.checks
.push(Check::new(violations::CallDatetimeFromtimestamp, location));
checker.diagnostics.push(Diagnostic::new(
violations::CallDatetimeFromtimestamp,
location,
));
}
}
@ -198,7 +203,7 @@ pub fn call_datetime_strptime_without_zone(
};
let (Some(grandparent), Some(parent)) = (checker.current_expr_grandparent(), checker.current_expr_parent()) else {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::CallDatetimeStrptimeWithoutZone,
location,
));
@ -221,7 +226,7 @@ pub fn call_datetime_strptime_without_zone(
}
}
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::CallDatetimeStrptimeWithoutZone,
location,
));
@ -232,8 +237,8 @@ pub fn call_date_today(checker: &mut Checker, func: &Expr, location: Range) {
let call_path = dealias_call_path(collect_call_paths(func), &checker.import_aliases);
if match_call_path(&call_path, "datetime.date", "today", &checker.from_imports) {
checker
.checks
.push(Check::new(violations::CallDateToday, location));
.diagnostics
.push(Diagnostic::new(violations::CallDateToday, location));
}
}
@ -247,7 +252,7 @@ pub fn call_date_fromtimestamp(checker: &mut Checker, func: &Expr, location: Ran
&checker.from_imports,
) {
checker
.checks
.push(Check::new(violations::CallDateFromtimestamp, location));
.diagnostics
.push(Diagnostic::new(violations::CallDateFromtimestamp, location));
}
}

12
src/flake8_debugger/checks.rs
View File

@ -4,7 +4,7 @@ use rustpython_ast::{Expr, Stmt};
use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path};
use crate::ast::types::Range;
use crate::flake8_debugger::types::DebuggerUsingType;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
const DEBUGGERS: &[(&str, &str)] = &[
@ -25,13 +25,13 @@ pub fn debugger_call(
func: &Expr,
from_imports: &FxHashMap<&str, FxHashSet<&str>>,
import_aliases: &FxHashMap<&str, &str>,
) -> Option<Check> {
) -> Option<Diagnostic> {
let call_path = dealias_call_path(collect_call_paths(func), import_aliases);
if DEBUGGERS
.iter()
.any(|(module, member)| match_call_path(&call_path, module, member, from_imports))
{
Some(Check::new(
Some(Diagnostic::new(
violations::Debugger(DebuggerUsingType::Call(call_path.join("."))),
Range::from_located(expr),
))
@ -41,7 +41,7 @@ pub fn debugger_call(
}
/// Checks for the presence of a debugger import.
pub fn debugger_import(stmt: &Stmt, module: Option<&str>, name: &str) -> Option<Check> {
pub fn debugger_import(stmt: &Stmt, module: Option<&str>, name: &str) -> Option<Diagnostic> {
// Special-case: allow `import builtins`, which is far more general than (e.g.)
// `import celery.contrib.rdb`).
if module.is_none() && name == "builtins" {
@ -53,7 +53,7 @@ pub fn debugger_import(stmt: &Stmt, module: Option<&str>, name: &str) -> Option<
.iter()
.find(|(module_name, member)| module_name == &module && member == &name)
{
return Some(Check::new(
return Some(Diagnostic::new(
violations::Debugger(DebuggerUsingType::Import(format!("{module_name}.{member}"))),
Range::from_located(stmt),
));
@ -62,7 +62,7 @@ pub fn debugger_import(stmt: &Stmt, module: Option<&str>, name: &str) -> Option<
.iter()
.any(|(module_name, ..)| module_name == &name)
{
return Some(Check::new(
return Some(Diagnostic::new(
violations::Debugger(DebuggerUsingType::Import(name.to_string())),
Range::from_located(stmt),
));

14
src/flake8_debugger/mod.rs
View File

@ -10,19 +10,19 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::T100, Path::new("T100.py"); "T100")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::T100, Path::new("T100.py"); "T100")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_debugger")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
&settings::Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

22
src/flake8_errmsg/mod.rs
View File

@ -8,39 +8,35 @@ mod tests {
use anyhow::Result;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::{flake8_errmsg, settings};
#[test]
fn defaults() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_errmsg/EM.py"),
&settings::Settings::for_rules(vec![
CheckCode::EM101,
CheckCode::EM102,
CheckCode::EM103,
]),
&settings::Settings::for_rules(vec![RuleCode::EM101, RuleCode::EM102, RuleCode::EM103]),
)?;
insta::assert_yaml_snapshot!("defaults", checks);
insta::assert_yaml_snapshot!("defaults", diagnostics);
Ok(())
}
#[test]
fn custom() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_errmsg/EM.py"),
&settings::Settings {
flake8_errmsg: flake8_errmsg::settings::Settings {
max_string_length: 20,
},
..settings::Settings::for_rules(vec![
CheckCode::EM101,
CheckCode::EM102,
CheckCode::EM103,
RuleCode::EM101,
RuleCode::EM102,
RuleCode::EM103,
])
},
)?;
insta::assert_yaml_snapshot!("custom", checks);
insta::assert_yaml_snapshot!("custom", diagnostics);
Ok(())
}
}

14
src/flake8_errmsg/plugins.rs
View File

@ -2,7 +2,7 @@ use rustpython_ast::{Constant, Expr, ExprKind};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::{Check, CheckCode};
use crate::registry::{Diagnostic, RuleCode};
use crate::violations;
/// EM101, EM102, EM103
@ -15,9 +15,9 @@ pub fn string_in_exception(checker: &mut Checker, exc: &Expr) {
value: Constant::Str(string),
..
} => {
if checker.settings.enabled.contains(&CheckCode::EM101) {
if checker.settings.enabled.contains(&RuleCode::EM101) {
if string.len() > checker.settings.flake8_errmsg.max_string_length {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::RawStringInException,
Range::from_located(first),
));
@ -26,8 +26,8 @@ pub fn string_in_exception(checker: &mut Checker, exc: &Expr) {
}
// Check for f-strings
ExprKind::JoinedStr { .. } => {
if checker.settings.enabled.contains(&CheckCode::EM102) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::EM102) {
checker.diagnostics.push(Diagnostic::new(
violations::FStringInException,
Range::from_located(first),
));
@ -35,10 +35,10 @@ pub fn string_in_exception(checker: &mut Checker, exc: &Expr) {
}
// Check for .format() calls
ExprKind::Call { func, .. } => {
if checker.settings.enabled.contains(&CheckCode::EM103) {
if checker.settings.enabled.contains(&RuleCode::EM103) {
if let ExprKind::Attribute { value, attr, .. } = &func.node {
if attr == "format" && matches!(value.node, ExprKind::Constant { .. }) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::DotFormatInException,
Range::from_located(first),
));

16
src/flake8_implicit_str_concat/checks.rs
View File

@ -3,19 +3,19 @@ use rustpython_ast::{Constant, Expr, ExprKind, Location, Operator};
use rustpython_parser::lexer::{LexResult, Tok};
use crate::ast::types::Range;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::source_code_locator::SourceCodeLocator;
use crate::violations;
/// ISC001, ISC002
pub fn implicit(tokens: &[LexResult], locator: &SourceCodeLocator) -> Vec<Check> {
let mut checks = vec![];
pub fn implicit(tokens: &[LexResult], locator: &SourceCodeLocator) -> Vec<Diagnostic> {
let mut diagnostics = vec![];
for ((a_start, a_tok, a_end), (b_start, b_tok, b_end)) in
tokens.iter().flatten().tuple_windows()
{
if matches!(a_tok, Tok::String { .. }) && matches!(b_tok, Tok::String { .. }) {
if a_end.row() == b_start.row() {
checks.push(Check::new(
diagnostics.push(Diagnostic::new(
violations::SingleLineImplicitStringConcatenation,
Range {
location: *a_start,
@ -30,7 +30,7 @@ pub fn implicit(tokens: &[LexResult], locator: &SourceCodeLocator) -> Vec<Check>
end_location: Location::new(a_end.row() + 1, 0),
});
if contents.trim_end().ends_with('\\') {
checks.push(Check::new(
diagnostics.push(Diagnostic::new(
violations::MultiLineImplicitStringConcatenation,
Range {
location: *a_start,
@ -41,11 +41,11 @@ pub fn implicit(tokens: &[LexResult], locator: &SourceCodeLocator) -> Vec<Check>
}
}
}
checks
diagnostics
}
/// ISC003
pub fn explicit(expr: &Expr) -> Option<Check> {
pub fn explicit(expr: &Expr) -> Option<Diagnostic> {
if let ExprKind::BinOp { left, op, right } = &expr.node {
if matches!(op, Operator::Add) {
if matches!(
@ -63,7 +63,7 @@ pub fn explicit(expr: &Expr) -> Option<Check> {
..
}
) {
return Some(Check::new(
return Some(Diagnostic::new(
violations::ExplicitStringConcatenation,
Range::from_located(expr),
));

18
src/flake8_implicit_str_concat/mod.rs
View File

@ -9,21 +9,21 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::ISC001, Path::new("ISC.py"); "ISC001")]
#[test_case(CheckCode::ISC002, Path::new("ISC.py"); "ISC002")]
#[test_case(CheckCode::ISC003, Path::new("ISC.py"); "ISC003")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::ISC001, Path::new("ISC.py"); "ISC001")]
#[test_case(RuleCode::ISC002, Path::new("ISC.py"); "ISC002")]
#[test_case(RuleCode::ISC003, Path::new("ISC.py"); "ISC003")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_implicit_str_concat")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
&settings::Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

6
src/flake8_import_conventions/checks.rs
View File

@ -2,7 +2,7 @@ use rustc_hash::FxHashMap;
use rustpython_ast::Stmt;
use crate::ast::types::Range;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// ICN001
@ -11,7 +11,7 @@ pub fn check_conventional_import(
name: &str,
asname: Option<&str>,
conventions: &FxHashMap<String, String>,
) -> Option<Check> {
) -> Option<Diagnostic> {
let mut is_valid_import = true;
if let Some(expected_alias) = conventions.get(name) {
if !expected_alias.is_empty() {
@ -24,7 +24,7 @@ pub fn check_conventional_import(
}
}
if !is_valid_import {
return Some(Check::new(
return Some(Diagnostic::new(
violations::ImportAliasIsNotConventional(
name.to_string(),
expected_alias.to_string(),

26
src/flake8_import_conventions/mod.rs
View File

@ -10,22 +10,22 @@ mod tests {
use rustc_hash::FxHashMap;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::{flake8_import_conventions, Settings};
#[test]
fn defaults() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_import_conventions/defaults.py"),
&Settings::for_rule(CheckCode::ICN001),
&Settings::for_rule(RuleCode::ICN001),
)?;
insta::assert_yaml_snapshot!("defaults", checks);
insta::assert_yaml_snapshot!("defaults", diagnostics);
Ok(())
}
#[test]
fn custom() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_import_conventions/custom.py"),
&Settings {
flake8_import_conventions: flake8_import_conventions::settings::Options {
@ -36,16 +36,16 @@ mod tests {
])),
}
.into(),
..Settings::for_rule(CheckCode::ICN001)
..Settings::for_rule(RuleCode::ICN001)
},
)?;
insta::assert_yaml_snapshot!("custom", checks);
insta::assert_yaml_snapshot!("custom", diagnostics);
Ok(())
}
#[test]
fn remove_defaults() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_import_conventions/remove_default.py"),
&Settings {
flake8_import_conventions: flake8_import_conventions::settings::Options {
@ -58,16 +58,16 @@ mod tests {
extend_aliases: None,
}
.into(),
..Settings::for_rule(CheckCode::ICN001)
..Settings::for_rule(RuleCode::ICN001)
},
)?;
insta::assert_yaml_snapshot!("remove_default", checks);
insta::assert_yaml_snapshot!("remove_default", diagnostics);
Ok(())
}
#[test]
fn override_defaults() -> Result<()> {
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_import_conventions/override_default.py"),
&Settings {
flake8_import_conventions: flake8_import_conventions::settings::Options {
@ -78,10 +78,10 @@ mod tests {
)])),
}
.into(),
..Settings::for_rule(CheckCode::ICN001)
..Settings::for_rule(RuleCode::ICN001)
},
)?;
insta::assert_yaml_snapshot!("override_default", checks);
insta::assert_yaml_snapshot!("override_default", diagnostics);
Ok(())
}
}

18
src/flake8_pie/mod.rs
View File

@ -9,21 +9,21 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::PIE790, Path::new("PIE790.py"); "PIE790")]
#[test_case(CheckCode::PIE794, Path::new("PIE794.py"); "PIE794")]
#[test_case(CheckCode::PIE807, Path::new("PIE807.py"); "PIE807")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::PIE790, Path::new("PIE790.py"); "PIE790")]
#[test_case(RuleCode::PIE794, Path::new("PIE794.py"); "PIE794")]
#[test_case(RuleCode::PIE807, Path::new("PIE807.py"); "PIE807")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_pie")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
&settings::Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

20
src/flake8_pie/plugins.rs
View File

@ -6,7 +6,7 @@ use crate::ast::types::Range;
use crate::autofix::helpers::delete_stmt;
use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::registry::{Check, CheckCode};
use crate::registry::{Diagnostic, RuleCode};
use crate::violations;
/// PIE790
@ -27,11 +27,11 @@ pub fn no_unnecessary_pass(checker: &mut Checker, body: &[Stmt]) {
}
) {
if matches!(pass_stmt.node, StmtKind::Pass) {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::NoUnnecessaryPass,
Range::from_located(pass_stmt),
);
if checker.patch(&CheckCode::PIE790) {
if checker.patch(&RuleCode::PIE790) {
match delete_stmt(pass_stmt, None, &[], checker.locator) {
Ok(fix) => {
check.amend(fix);
@ -41,7 +41,7 @@ pub fn no_unnecessary_pass(checker: &mut Checker, body: &[Stmt]) {
}
}
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
}
@ -78,14 +78,14 @@ pub fn dupe_class_field_definitions(checker: &mut Checker, bases: &[Expr], body:
};
if seen_targets.contains(target) {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::DupeClassFieldDefinitions(target.to_string()),
Range::from_located(stmt),
);
if checker.patch(&CheckCode::PIE794) {
if checker.patch(&RuleCode::PIE794) {
check.amend(Fix::deletion(stmt.location, stmt.end_location.unwrap()));
}
checker.checks.push(check);
checker.diagnostics.push(check);
} else {
seen_targets.insert(target);
}
@ -101,15 +101,15 @@ pub fn prefer_list_builtin(checker: &mut Checker, expr: &Expr) {
if let ExprKind::List { elts, .. } = &body.node {
if elts.is_empty() {
let mut check =
Check::new(violations::PreferListBuiltin, Range::from_located(expr));
if checker.patch(&CheckCode::PIE807) {
Diagnostic::new(violations::PreferListBuiltin, Range::from_located(expr));
if checker.patch(&RuleCode::PIE807) {
check.amend(Fix::replacement(
"list".to_string(),
expr.location,
expr.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
}

16
src/flake8_print/mod.rs
View File

@ -9,20 +9,20 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::T201, Path::new("T201.py"); "T201")]
#[test_case(CheckCode::T203, Path::new("T203.py"); "T203")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::T201, Path::new("T201.py"); "T201")]
#[test_case(RuleCode::T203, Path::new("T203.py"); "T203")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_print")
.join(path)
.as_path(),
&settings::Settings::for_rule(check_code),
&settings::Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

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

@ -5,7 +5,7 @@ use crate::ast::helpers::{collect_call_paths, dealias_call_path, is_const_none,
use crate::ast::types::Range;
use crate::autofix::helpers;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// T201, T203
@ -28,9 +28,9 @@ pub fn print_call(checker: &mut Checker, func: &Expr, keywords: &[Keyword]) {
}
}
}
Check::new(violations::PrintFound, Range::from_located(func))
Diagnostic::new(violations::PrintFound, Range::from_located(func))
} else if match_call_path(&call_path, "pprint", "pprint", &checker.from_imports) {
Check::new(violations::PPrintFound, Range::from_located(func))
Diagnostic::new(violations::PPrintFound, Range::from_located(func))
} else {
return;
}
@ -66,5 +66,5 @@ pub fn print_call(checker: &mut Checker, func: &Expr, keywords: &[Keyword]) {
}
}
checker.checks.push(check);
checker.diagnostics.push(check);
}

80
src/flake8_pytest_style/mod.rs
View File

@ -12,12 +12,12 @@ mod tests {
use crate::flake8_pytest_style::settings::Settings;
use crate::flake8_pytest_style::types;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::settings;
#[test_case(CheckCode::PT001, Path::new("PT001.py"), Settings::default(), "PT001_default"; "PT001_0")]
#[test_case(RuleCode::PT001, Path::new("PT001.py"), Settings::default(), "PT001_default"; "PT001_0")]
#[test_case(
CheckCode::PT001,
RuleCode::PT001,
Path::new("PT001.py"),
Settings {
fixture_parentheses: false,
@ -26,13 +26,13 @@ mod tests {
"PT001_no_parentheses";
"PT001_1"
)]
#[test_case(CheckCode::PT002, Path::new("PT002.py"), Settings::default(), "PT002"; "PT002")]
#[test_case(CheckCode::PT003, Path::new("PT003.py"), Settings::default(), "PT003"; "PT003")]
#[test_case(CheckCode::PT004, Path::new("PT004.py"), Settings::default(), "PT004"; "PT004")]
#[test_case(CheckCode::PT005, Path::new("PT005.py"), Settings::default(), "PT005"; "PT005")]
#[test_case(CheckCode::PT006, Path::new("PT006.py"), Settings::default(), "PT006_default"; "PT006_0")]
#[test_case(RuleCode::PT002, Path::new("PT002.py"), Settings::default(), "PT002"; "PT002")]
#[test_case(RuleCode::PT003, Path::new("PT003.py"), Settings::default(), "PT003"; "PT003")]
#[test_case(RuleCode::PT004, Path::new("PT004.py"), Settings::default(), "PT004"; "PT004")]
#[test_case(RuleCode::PT005, Path::new("PT005.py"), Settings::default(), "PT005"; "PT005")]
#[test_case(RuleCode::PT006, Path::new("PT006.py"), Settings::default(), "PT006_default"; "PT006_0")]
#[test_case(
CheckCode::PT006,
RuleCode::PT006,
Path::new("PT006.py"),
Settings {
parametrize_names_type: types::ParametrizeNameType::CSV,
@ -42,7 +42,7 @@ mod tests {
"PT006_1"
)]
#[test_case(
CheckCode::PT006,
RuleCode::PT006,
Path::new("PT006.py"),
Settings {
parametrize_names_type: types::ParametrizeNameType::List,
@ -52,14 +52,14 @@ mod tests {
"PT006_2"
)]
#[test_case(
CheckCode::PT007,
RuleCode::PT007,
Path::new("PT007.py"),
Settings::default(),
"PT007_list_of_tuples";
"PT007_0"
)]
#[test_case(
CheckCode::PT007,
RuleCode::PT007,
Path::new("PT007.py"),
Settings {
parametrize_values_type: types::ParametrizeValuesType::Tuple,
@ -69,7 +69,7 @@ mod tests {
"PT007_1"
)]
#[test_case(
CheckCode::PT007,
RuleCode::PT007,
Path::new("PT007.py"),
Settings {
parametrize_values_type: types::ParametrizeValuesType::Tuple,
@ -80,7 +80,7 @@ mod tests {
"PT007_2"
)]
#[test_case(
CheckCode::PT007,
RuleCode::PT007,
Path::new("PT007.py"),
Settings {
parametrize_values_row_type: types::ParametrizeValuesRowType::List,
@ -90,29 +90,29 @@ mod tests {
"PT007_3"
)]
#[test_case(
CheckCode::PT008,
RuleCode::PT008,
Path::new("PT008.py"),
Settings::default(),
"PT008";
"PT008"
)]
#[test_case(
CheckCode::PT009,
RuleCode::PT009,
Path::new("PT009.py"),
Settings::default(),
"PT009";
"PT009"
)]
#[test_case(CheckCode::PT010, Path::new("PT010.py"), Settings::default(), "PT010"; "PT0010")]
#[test_case(RuleCode::PT010, Path::new("PT010.py"), Settings::default(), "PT010"; "PT0010")]
#[test_case(
CheckCode::PT011,
RuleCode::PT011,
Path::new("PT011.py"),
Settings::default(),
"PT011_default";
"PT011_0"
)]
#[test_case(
CheckCode::PT011,
RuleCode::PT011,
Path::new("PT011.py"),
Settings {
raises_extend_require_match_for: vec!["ZeroDivisionError".to_string()],
@ -122,7 +122,7 @@ mod tests {
"PT011_1"
)]
#[test_case(
CheckCode::PT011,
RuleCode::PT011,
Path::new("PT011.py"),
Settings {
raises_require_match_for: vec!["ZeroDivisionError".to_string()],
@ -132,84 +132,84 @@ mod tests {
"PT011_2"
)]
#[test_case(
CheckCode::PT012,
RuleCode::PT012,
Path::new("PT012.py"),
Settings::default(),
"PT012";
"PT012"
)]
#[test_case(
CheckCode::PT013,
RuleCode::PT013,
Path::new("PT013.py"),
Settings::default(),
"PT013";
"PT013"
)]
#[test_case(
CheckCode::PT015,
RuleCode::PT015,
Path::new("PT015.py"),
Settings::default(),
"PT015";
"PT015"
)]
#[test_case(
CheckCode::PT016,
RuleCode::PT016,
Path::new("PT016.py"),
Settings::default(),
"PT016";
"PT016"
)]
#[test_case(
CheckCode::PT017,
RuleCode::PT017,
Path::new("PT017.py"),
Settings::default(),
"PT017";
"PT017"
)]
#[test_case(
CheckCode::PT018,
RuleCode::PT018,
Path::new("PT018.py"),
Settings::default(),
"PT018";
"PT018"
)]
#[test_case(
CheckCode::PT019,
RuleCode::PT019,
Path::new("PT019.py"),
Settings::default(),
"PT019";
"PT019"
)]
#[test_case(
CheckCode::PT020,
RuleCode::PT020,
Path::new("PT020.py"),
Settings::default(),
"PT020";
"PT020"
)]
#[test_case(
CheckCode::PT021,
RuleCode::PT021,
Path::new("PT021.py"),
Settings::default(),
"PT021";
"PT021"
)]
#[test_case(
CheckCode::PT022,
RuleCode::PT022,
Path::new("PT022.py"),
Settings::default(),
"PT022";
"PT022"
)]
#[test_case(
CheckCode::PT023,
RuleCode::PT023,
Path::new("PT023.py"),
Settings::default(),
"PT023_default";
"PT023_0"
)]
#[test_case(
CheckCode::PT023,
RuleCode::PT023,
Path::new("PT023.py"),
Settings {
mark_parentheses: false,
@ -219,43 +219,43 @@ mod tests {
"PT023_1"
)]
#[test_case(
CheckCode::PT024,
RuleCode::PT024,
Path::new("PT024.py"),
Settings::default(),
"PT024";
"PT024"
)]
#[test_case(
CheckCode::PT025,
RuleCode::PT025,
Path::new("PT025.py"),
Settings::default(),
"PT025";
"PT025"
)]
#[test_case(
CheckCode::PT026,
RuleCode::PT026,
Path::new("PT026.py"),
Settings::default(),
"PT026";
"PT026"
)]
fn test_pytest_style(
check_code: CheckCode,
rule_code: RuleCode,
path: &Path,
plugin_settings: Settings,
name: &str,
) -> Result<()> {
let mut checks = test_path(
let mut diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_pytest_style")
.join(path)
.as_path(),
&settings::Settings {
flake8_pytest_style: plugin_settings,
..settings::Settings::for_rule(check_code)
..settings::Settings::for_rule(rule_code)
},
)?;
checks.sort_by_key(|check| check.location);
insta::assert_yaml_snapshot!(name, checks);
diagnostics.sort_by_key(|diagnostic| diagnostic.location);
insta::assert_yaml_snapshot!(name, diagnostics);
Ok(())
}
}

22
src/flake8_pytest_style/plugins/assertion.rs
View File

@ -10,7 +10,7 @@ use crate::ast::visitor;
use crate::ast::visitor::Visitor;
use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
/// Visitor that tracks assert statements and checks if they reference
@ -18,7 +18,7 @@ use crate::violations;
struct ExceptionHandlerVisitor<'a> {
exception_name: &'a str,
current_assert: Option<&'a Stmt>,
errors: Vec<Check>,
errors: Vec<Diagnostic>,
}
impl<'a> ExceptionHandlerVisitor<'a> {
@ -51,7 +51,7 @@ where
ExprKind::Name { id, .. } => {
if let Some(current_assert) = self.current_assert {
if id.as_str() == self.exception_name {
self.errors.push(Check::new(
self.errors.push(Diagnostic::new(
violations::AssertInExcept(id.to_string()),
Range::from_located(current_assert),
));
@ -79,7 +79,7 @@ fn is_composite_condition(test: &Expr) -> bool {
}
}
fn check_assert_in_except(name: &str, body: &[Stmt]) -> Vec<Check> {
fn check_assert_in_except(name: &str, body: &[Stmt]) -> Vec<Diagnostic> {
// Walk body to find assert statements that reference the exception name
let mut visitor = ExceptionHandlerVisitor::new(name);
for stmt in body {
@ -95,11 +95,11 @@ pub fn unittest_assertion(
func: &Expr,
args: &[Expr],
keywords: &[Keyword],
) -> Option<Check> {
) -> Option<Diagnostic> {
match &func.node {
ExprKind::Attribute { attr, .. } => {
if let Ok(unittest_assert) = UnittestAssert::try_from(attr.as_str()) {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UnittestAssertion(unittest_assert.to_string()),
Range::from_located(func),
);
@ -122,9 +122,9 @@ pub fn unittest_assertion(
}
/// PT015
pub fn assert_falsy(assert_stmt: &Stmt, test_expr: &Expr) -> Option<Check> {
pub fn assert_falsy(assert_stmt: &Stmt, test_expr: &Expr) -> Option<Diagnostic> {
if is_falsy_constant(test_expr) {
Some(Check::new(
Some(Diagnostic::new(
violations::AssertAlwaysFalse,
Range::from_located(assert_stmt),
))
@ -134,7 +134,7 @@ pub fn assert_falsy(assert_stmt: &Stmt, test_expr: &Expr) -> Option<Check> {
}
/// PT017
pub fn assert_in_exception_handler(handlers: &[Excepthandler]) -> Vec<Check> {
pub fn assert_in_exception_handler(handlers: &[Excepthandler]) -> Vec<Diagnostic> {
handlers
.iter()
.flat_map(|handler| match &handler.node {
@ -150,9 +150,9 @@ pub fn assert_in_exception_handler(handlers: &[Excepthandler]) -> Vec<Check> {
}
/// PT018
pub fn composite_condition(assert_stmt: &Stmt, test_expr: &Expr) -> Option<Check> {
pub fn composite_condition(assert_stmt: &Stmt, test_expr: &Expr) -> Option<Diagnostic> {
if is_composite_condition(test_expr) {
Some(Check::new(
Some(Diagnostic::new(
violations::CompositeAssertion,
Range::from_located(assert_stmt),
))

6
src/flake8_pytest_style/plugins/fail.rs
View File

@ -4,7 +4,7 @@ use super::helpers::{is_empty_or_null_string, is_pytest_fail};
use crate::ast::helpers::SimpleCallArgs;
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
pub fn fail_call(checker: &mut Checker, call: &Expr, args: &[Expr], keywords: &[Keyword]) {
@ -14,13 +14,13 @@ pub fn fail_call(checker: &mut Checker, call: &Expr, args: &[Expr], keywords: &[
if let Some(msg) = msg {
if is_empty_or_null_string(msg) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::FailWithoutMessage,
Range::from_located(call),
));
}
} else {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::FailWithoutMessage,
Range::from_located(call),
));

68
src/flake8_pytest_style/plugins/fixture.rs
View File

@ -10,7 +10,7 @@ use crate::ast::visitor;
use crate::ast::visitor::Visitor;
use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::registry::{Check, CheckCode};
use crate::registry::{Diagnostic, RuleCode};
use crate::violations;
#[derive(Default)]
@ -79,14 +79,14 @@ fn pytest_fixture_parentheses(
preferred: &str,
actual: &str,
) {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::IncorrectFixtureParenthesesStyle(preferred.to_string(), actual.to_string()),
Range::from_located(decorator),
);
if checker.patch(check.kind.code()) {
check.amend(fix);
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
/// PT001, PT002, PT003
@ -98,7 +98,7 @@ fn check_fixture_decorator(checker: &mut Checker, func_name: &str, decorator: &E
keywords,
..
} => {
if checker.settings.enabled.contains(&CheckCode::PT001)
if checker.settings.enabled.contains(&RuleCode::PT001)
&& !checker.settings.flake8_pytest_style.fixture_parentheses
&& args.is_empty()
&& keywords.is_empty()
@ -111,21 +111,21 @@ fn check_fixture_decorator(checker: &mut Checker, func_name: &str, decorator: &E
pytest_fixture_parentheses(checker, decorator, fix, "", "()");
}
if checker.settings.enabled.contains(&CheckCode::PT002) && !args.is_empty() {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::PT002) && !args.is_empty() {
checker.diagnostics.push(Diagnostic::new(
violations::FixturePositionalArgs(func_name.to_string()),
Range::from_located(decorator),
));
}
if checker.settings.enabled.contains(&CheckCode::PT003) {
if checker.settings.enabled.contains(&RuleCode::PT003) {
let scope_keyword = keywords
.iter()
.find(|kw| kw.node.arg == Some("scope".to_string()));
if let Some(scope_keyword) = scope_keyword {
if keyword_is_literal(scope_keyword, "function") {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::ExtraneousScopeFunction,
Range::from_located(scope_keyword),
));
@ -134,7 +134,7 @@ fn check_fixture_decorator(checker: &mut Checker, func_name: &str, decorator: &E
}
}
_ => {
if checker.settings.enabled.contains(&CheckCode::PT001)
if checker.settings.enabled.contains(&RuleCode::PT001)
&& checker.settings.flake8_pytest_style.fixture_parentheses
{
let fix = Fix::insertion("()".to_string(), decorator.end_location.unwrap());
@ -152,31 +152,31 @@ fn check_fixture_returns(checker: &mut Checker, func: &Stmt, func_name: &str, bo
visitor.visit_stmt(stmt);
}
if checker.settings.enabled.contains(&CheckCode::PT005)
if checker.settings.enabled.contains(&RuleCode::PT005)
&& visitor.has_return_with_value
&& func_name.starts_with('_')
{
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::IncorrectFixtureNameUnderscore(func_name.to_string()),
Range::from_located(func),
));
} else if checker.settings.enabled.contains(&CheckCode::PT004)
} else if checker.settings.enabled.contains(&RuleCode::PT004)
&& !visitor.has_return_with_value
&& !visitor.has_yield_from
&& !func_name.starts_with('_')
{
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::MissingFixtureNameUnderscore(func_name.to_string()),
Range::from_located(func),
));
}
if checker.settings.enabled.contains(&CheckCode::PT022) {
if checker.settings.enabled.contains(&RuleCode::PT022) {
if let Some(stmt) = body.last() {
if let StmtKind::Expr { value, .. } = &stmt.node {
if let ExprKind::Yield { .. } = value.node {
if visitor.yield_statements.len() == 1 {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UselessYieldFixture(func_name.to_string()),
Range::from_located(stmt),
);
@ -190,7 +190,7 @@ fn check_fixture_returns(checker: &mut Checker, func: &Stmt, func_name: &str, bo
),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
}
@ -203,7 +203,7 @@ fn check_test_function_args(checker: &mut Checker, args: &Arguments) {
args.args.iter().chain(&args.kwonlyargs).for_each(|arg| {
let name = arg.node.arg.to_string();
if name.starts_with('_') {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::FixtureParamWithoutValue(name),
Range::from_located(arg),
));
@ -214,7 +214,7 @@ fn check_test_function_args(checker: &mut Checker, args: &Arguments) {
/// PT020
fn check_fixture_decorator_name(checker: &mut Checker, decorator: &Expr) {
if is_pytest_yield_fixture(decorator, checker) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::DeprecatedYieldFixture,
Range::from_located(decorator),
));
@ -234,7 +234,7 @@ fn check_fixture_addfinalizer(checker: &mut Checker, args: &Arguments, body: &[S
}
if let Some(addfinalizer) = visitor.addfinalizer_call {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::FixtureFinalizerCallback,
Range::from_located(addfinalizer),
));
@ -246,18 +246,18 @@ fn check_fixture_marks(checker: &mut Checker, decorators: &[Expr]) {
for mark in get_mark_decorators(decorators) {
let name = get_mark_name(mark);
if checker.settings.enabled.contains(&CheckCode::PT024) {
if checker.settings.enabled.contains(&RuleCode::PT024) {
if name == "asyncio" {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::UnnecessaryAsyncioMarkOnFixture,
Range::from_located(mark),
));
}
}
if checker.settings.enabled.contains(&CheckCode::PT025) {
if checker.settings.enabled.contains(&RuleCode::PT025) {
if name == "usefixtures" {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::ErroneousUseFixturesOnFixture,
Range::from_located(mark),
));
@ -276,39 +276,39 @@ pub fn fixture(
) {
let decorator = get_fixture_decorator(checker, decorators);
if let Some(decorator) = decorator {
if checker.settings.enabled.contains(&CheckCode::PT001)
|| checker.settings.enabled.contains(&CheckCode::PT002)
|| checker.settings.enabled.contains(&CheckCode::PT003)
if checker.settings.enabled.contains(&RuleCode::PT001)
|| checker.settings.enabled.contains(&RuleCode::PT002)
|| checker.settings.enabled.contains(&RuleCode::PT003)
{
check_fixture_decorator(checker, func_name, decorator);
}
if checker.settings.enabled.contains(&CheckCode::PT020)
if checker.settings.enabled.contains(&RuleCode::PT020)
&& checker.settings.flake8_pytest_style.fixture_parentheses
{
check_fixture_decorator_name(checker, decorator);
}
if (checker.settings.enabled.contains(&CheckCode::PT004)
|| checker.settings.enabled.contains(&CheckCode::PT005)
|| checker.settings.enabled.contains(&CheckCode::PT022))
if (checker.settings.enabled.contains(&RuleCode::PT004)
|| checker.settings.enabled.contains(&RuleCode::PT005)
|| checker.settings.enabled.contains(&RuleCode::PT022))
&& !has_abstractmethod_decorator(decorators, checker)
{
check_fixture_returns(checker, func, func_name, body);
}
if checker.settings.enabled.contains(&CheckCode::PT021) {
if checker.settings.enabled.contains(&RuleCode::PT021) {
check_fixture_addfinalizer(checker, args, body);
}
if checker.settings.enabled.contains(&CheckCode::PT024)
|| checker.settings.enabled.contains(&CheckCode::PT025)
if checker.settings.enabled.contains(&RuleCode::PT024)
|| checker.settings.enabled.contains(&RuleCode::PT025)
{
check_fixture_marks(checker, decorators);
}
}
if checker.settings.enabled.contains(&CheckCode::PT019) && func_name.starts_with("test_") {
if checker.settings.enabled.contains(&RuleCode::PT019) && func_name.starts_with("test_") {
check_test_function_args(checker, args);
}
}

10
src/flake8_pytest_style/plugins/imports.rs
View File

@ -1,7 +1,7 @@
use rustpython_ast::Stmt;
use crate::ast::types::Range;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
fn is_pytest_or_subpackage(imported_name: &str) -> bool {
@ -9,11 +9,11 @@ fn is_pytest_or_subpackage(imported_name: &str) -> bool {
}
/// PT013
pub fn import(import_from: &Stmt, name: &str, asname: Option<&str>) -> Option<Check> {
pub fn import(import_from: &Stmt, name: &str, asname: Option<&str>) -> Option<Diagnostic> {
if is_pytest_or_subpackage(name) {
if let Some(alias) = asname {
if alias != name {
return Some(Check::new(
return Some(Diagnostic::new(
violations::IncorrectPytestImport,
Range::from_located(import_from),
));
@ -28,7 +28,7 @@ pub fn import_from(
import_from: &Stmt,
module: Option<&str>,
level: Option<&usize>,
) -> Option<Check> {
) -> Option<Diagnostic> {
// If level is not zero or module is none, return
if let Some(level) = level {
if *level != 0 {
@ -38,7 +38,7 @@ pub fn import_from(
if let Some(module) = module {
if is_pytest_or_subpackage(module) {
return Some(Check::new(
return Some(Diagnostic::new(
violations::IncorrectPytestImport,
Range::from_located(import_from),
));

14
src/flake8_pytest_style/plugins/marks.rs
View File

@ -4,7 +4,7 @@ use super::helpers::{get_mark_decorators, get_mark_name};
use crate::ast::types::Range;
use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::registry::{Check, CheckCode};
use crate::registry::{Diagnostic, RuleCode};
use crate::violations;
fn pytest_mark_parentheses(
@ -14,7 +14,7 @@ fn pytest_mark_parentheses(
preferred: &str,
actual: &str,
) {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::IncorrectMarkParenthesesStyle(
get_mark_name(decorator).to_string(),
preferred.to_string(),
@ -25,7 +25,7 @@ fn pytest_mark_parentheses(
if checker.patch(check.kind.code()) {
check.amend(fix);
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
fn check_mark_parentheses(checker: &mut Checker, decorator: &Expr) {
@ -71,7 +71,7 @@ fn check_useless_usefixtures(checker: &mut Checker, decorator: &Expr) {
}
if !has_parameters {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::UseFixturesWithoutParameters,
Range::from_located(decorator),
);
@ -79,13 +79,13 @@ fn check_useless_usefixtures(checker: &mut Checker, decorator: &Expr) {
let at_start = Location::new(decorator.location.row(), decorator.location.column() - 1);
check.amend(Fix::deletion(at_start, decorator.end_location.unwrap()));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
pub fn marks(checker: &mut Checker, decorators: &[Expr]) {
let enforce_parentheses = checker.settings.enabled.contains(&CheckCode::PT023);
let enforce_useless_usefixtures = checker.settings.enabled.contains(&CheckCode::PT026);
let enforce_parentheses = checker.settings.enabled.contains(&RuleCode::PT023);
let enforce_useless_usefixtures = checker.settings.enabled.contains(&RuleCode::PT026);
for mark in get_mark_decorators(decorators) {
if enforce_parentheses {

42
src/flake8_pytest_style/plugins/parametrize.rs
View File

@ -6,7 +6,7 @@ use crate::ast::types::Range;
use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::flake8_pytest_style::types;
use crate::registry::{Check, CheckCode};
use crate::registry::{Diagnostic, RuleCode};
use crate::source_code_generator::SourceCodeGenerator;
use crate::violations;
@ -80,7 +80,7 @@ fn check_names(checker: &mut Checker, expr: &Expr) {
if names.len() > 1 {
match names_type {
types::ParametrizeNameType::Tuple => {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::ParametrizeNamesWrongType(names_type),
Range::from_located(expr),
);
@ -107,10 +107,10 @@ fn check_names(checker: &mut Checker, expr: &Expr) {
expr.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
types::ParametrizeNameType::List => {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::ParametrizeNamesWrongType(names_type),
Range::from_located(expr),
);
@ -137,7 +137,7 @@ fn check_names(checker: &mut Checker, expr: &Expr) {
expr.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
types::ParametrizeNameType::CSV => {}
}
@ -152,7 +152,7 @@ fn check_names(checker: &mut Checker, expr: &Expr) {
match names_type {
types::ParametrizeNameType::Tuple => {}
types::ParametrizeNameType::List => {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::ParametrizeNamesWrongType(names_type),
Range::from_located(expr),
);
@ -171,10 +171,10 @@ fn check_names(checker: &mut Checker, expr: &Expr) {
expr.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
types::ParametrizeNameType::CSV => {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::ParametrizeNamesWrongType(names_type),
Range::from_located(expr),
);
@ -187,7 +187,7 @@ fn check_names(checker: &mut Checker, expr: &Expr) {
));
}
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
};
@ -201,7 +201,7 @@ fn check_names(checker: &mut Checker, expr: &Expr) {
match names_type {
types::ParametrizeNameType::List => {}
types::ParametrizeNameType::Tuple => {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::ParametrizeNamesWrongType(names_type),
Range::from_located(expr),
);
@ -220,10 +220,10 @@ fn check_names(checker: &mut Checker, expr: &Expr) {
expr.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
types::ParametrizeNameType::CSV => {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::ParametrizeNamesWrongType(names_type),
Range::from_located(expr),
);
@ -236,7 +236,7 @@ fn check_names(checker: &mut Checker, expr: &Expr) {
));
}
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
};
@ -257,7 +257,7 @@ fn check_values(checker: &mut Checker, expr: &Expr) {
match &expr.node {
ExprKind::List { elts, .. } => {
if values_type != types::ParametrizeValuesType::List {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::ParametrizeValuesWrongType(values_type, values_row_type),
Range::from_located(expr),
));
@ -266,7 +266,7 @@ fn check_values(checker: &mut Checker, expr: &Expr) {
}
ExprKind::Tuple { elts, .. } => {
if values_type != types::ParametrizeValuesType::Tuple {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::ParametrizeValuesWrongType(values_type, values_row_type),
Range::from_located(expr),
));
@ -278,7 +278,7 @@ fn check_values(checker: &mut Checker, expr: &Expr) {
}
fn handle_single_name(checker: &mut Checker, expr: &Expr, value: &Expr) {
let mut check = Check::new(
let mut check = Diagnostic::new(
violations::ParametrizeNamesWrongType(types::ParametrizeNameType::CSV),
Range::from_located(expr),
);
@ -292,7 +292,7 @@ fn handle_single_name(checker: &mut Checker, expr: &Expr, value: &Expr) {
expr.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
fn handle_value_rows(
@ -305,7 +305,7 @@ fn handle_value_rows(
match &elt.node {
ExprKind::Tuple { .. } => {
if values_row_type != types::ParametrizeValuesRowType::Tuple {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::ParametrizeValuesWrongType(values_type, values_row_type),
Range::from_located(elt),
));
@ -313,7 +313,7 @@ fn handle_value_rows(
}
ExprKind::List { .. } => {
if values_row_type != types::ParametrizeValuesRowType::List {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::ParametrizeValuesWrongType(values_type, values_row_type),
Range::from_located(elt),
));
@ -328,12 +328,12 @@ pub fn parametrize(checker: &mut Checker, decorators: &[Expr]) {
let decorator = get_parametrize_decorator(checker, decorators);
if let Some(decorator) = decorator {
if let ExprKind::Call { args, .. } = &decorator.node {
if checker.settings.enabled.contains(&CheckCode::PT006) {
if checker.settings.enabled.contains(&RuleCode::PT006) {
if let Some(arg) = args.get(0) {
check_names(checker, arg);
}
}
if checker.settings.enabled.contains(&CheckCode::PT007) {
if checker.settings.enabled.contains(&RuleCode::PT007) {
if let Some(arg) = args.get(1) {
check_values(checker, arg);
}

8
src/flake8_pytest_style/plugins/patch.rs
View File

@ -5,7 +5,7 @@ use crate::ast::helpers::{collect_arg_names, compose_call_path, SimpleCallArgs};
use crate::ast::types::Range;
use crate::ast::visitor;
use crate::ast::visitor::Visitor;
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::violations;
const PATCH_NAMES: &[&str] = &[
@ -56,7 +56,7 @@ fn check_patch_call(
args: &[Expr],
keywords: &[Keyword],
new_arg_number: usize,
) -> Option<Check> {
) -> Option<Diagnostic> {
let simple_args = SimpleCallArgs::new(args, keywords);
if simple_args.get_argument("return_value", None).is_some() {
return None;
@ -72,7 +72,7 @@ fn check_patch_call(
visitor.visit_expr(body);
if !visitor.uses_args {
return Some(Check::new(
return Some(Diagnostic::new(
violations::PatchWithLambda,
Range::from_located(call),
));
@ -82,7 +82,7 @@ fn check_patch_call(
None
}
pub fn patch_with_lambda(call: &Expr, args: &[Expr], keywords: &[Keyword]) -> Option<Check> {
pub fn patch_with_lambda(call: &Expr, args: &[Expr], keywords: &[Keyword]) -> Option<Diagnostic> {
if let Some(call_path) = compose_call_path(call) {
if PATCH_NAMES.contains(&call_path.as_str()) {
check_patch_call(call, args, keywords, 1)

12
src/flake8_pytest_style/plugins/raises.rs
View File

@ -8,7 +8,7 @@ use crate::ast::helpers::{
};
use crate::ast::types::Range;
use crate::checkers::ast::Checker;
use crate::registry::{Check, CheckCode};
use crate::registry::{Diagnostic, RuleCode};
use crate::violations;
fn is_pytest_raises(
@ -31,16 +31,16 @@ fn is_non_trivial_with_body(body: &[Stmt]) -> bool {
pub fn raises_call(checker: &mut Checker, func: &Expr, args: &[Expr], keywords: &[Keyword]) {
if is_pytest_raises(func, &checker.from_imports, &checker.import_aliases) {
if checker.settings.enabled.contains(&CheckCode::PT010) {
if checker.settings.enabled.contains(&RuleCode::PT010) {
if args.is_empty() && keywords.is_empty() {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::RaisesWithoutException,
Range::from_located(func),
));
}
}
if checker.settings.enabled.contains(&CheckCode::PT011) {
if checker.settings.enabled.contains(&RuleCode::PT011) {
let match_keyword = keywords
.iter()
.find(|kw| kw.node.arg == Some("match".to_string()));
@ -91,7 +91,7 @@ pub fn complex_raises(checker: &mut Checker, stmt: &Stmt, items: &[Withitem], bo
}
if is_too_complex {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::RaisesWithMultipleStatements,
Range::from_located(stmt),
));
@ -118,7 +118,7 @@ fn exception_needs_match(checker: &mut Checker, exception: &Expr) {
.any(|(module, member)| match_call_path(&call_path, module, member, &checker.from_imports));
if is_broad_exception {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::RaisesTooBroad(call_path.join(".")),
Range::from_located(exception),
));

12
src/flake8_quotes/checks.rs
View File

@ -2,7 +2,7 @@ use rustpython_ast::Location;
use crate::ast::types::Range;
use crate::flake8_quotes::settings::{Quote, Settings};
use crate::registry::Check;
use crate::registry::Diagnostic;
use crate::source_code_locator::SourceCodeLocator;
use crate::violations;
@ -47,7 +47,7 @@ pub fn quotes(
end: Location,
is_docstring: bool,
settings: &Settings,
) -> Option<Check> {
) -> Option<Diagnostic> {
let text = locator.slice_source_code_range(&Range::new(start, end));
// Remove any prefixes (e.g., remove `u` from `u"foo"`).
@ -72,7 +72,7 @@ pub fn quotes(
return None;
}
Some(Check::new(
Some(Diagnostic::new(
violations::BadQuotesDocstring(settings.docstring_quotes.clone()),
Range::new(start, end),
))
@ -87,7 +87,7 @@ pub fn quotes(
return None;
}
Some(Check::new(
Some(Diagnostic::new(
violations::BadQuotesMultilineString(settings.multiline_quotes.clone()),
Range::new(start, end),
))
@ -102,7 +102,7 @@ pub fn quotes(
if string_contents.contains(good_single(&settings.inline_quotes))
&& !string_contents.contains(bad_single(&settings.inline_quotes))
{
return Some(Check::new(
return Some(Diagnostic::new(
violations::AvoidQuoteEscape,
Range::new(start, end),
));
@ -112,7 +112,7 @@ pub fn quotes(
// If we're not using the preferred type, only allow use to avoid escapes.
if !string_contents.contains(good_single(&settings.inline_quotes)) {
return Some(Check::new(
return Some(Diagnostic::new(
violations::BadQuotesInlineString(settings.inline_quotes.clone()),
Range::new(start, end),
));

50
src/flake8_quotes/mod.rs
View File

@ -10,7 +10,7 @@ mod tests {
use crate::flake8_quotes::settings::Quote;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::{flake8_quotes, Settings};
#[test_case(Path::new("doubles.py"))]
@ -20,7 +20,7 @@ mod tests {
#[test_case(Path::new("doubles_wrapped.py"))]
fn doubles(path: &Path) -> Result<()> {
let snapshot = format!("doubles_{}", path.to_string_lossy());
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_quotes")
.join(path)
.as_path(),
@ -32,14 +32,14 @@ mod tests {
avoid_escape: true,
},
..Settings::for_rules(vec![
CheckCode::Q000,
CheckCode::Q001,
CheckCode::Q002,
CheckCode::Q003,
RuleCode::Q000,
RuleCode::Q001,
RuleCode::Q002,
RuleCode::Q003,
])
},
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
@ -50,7 +50,7 @@ mod tests {
#[test_case(Path::new("singles_wrapped.py"))]
fn singles(path: &Path) -> Result<()> {
let snapshot = format!("singles_{}", path.to_string_lossy());
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_quotes")
.join(path)
.as_path(),
@ -62,14 +62,14 @@ mod tests {
avoid_escape: true,
},
..Settings::for_rules(vec![
CheckCode::Q000,
CheckCode::Q001,
CheckCode::Q002,
CheckCode::Q003,
RuleCode::Q000,
RuleCode::Q001,
RuleCode::Q002,
RuleCode::Q003,
])
},
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
@ -85,7 +85,7 @@ mod tests {
#[test_case(Path::new("docstring_singles_function.py"))]
fn double_docstring(path: &Path) -> Result<()> {
let snapshot = format!("double_docstring_{}", path.to_string_lossy());
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_quotes")
.join(path)
.as_path(),
@ -97,14 +97,14 @@ mod tests {
avoid_escape: true,
},
..Settings::for_rules(vec![
CheckCode::Q000,
CheckCode::Q001,
CheckCode::Q002,
CheckCode::Q003,
RuleCode::Q000,
RuleCode::Q001,
RuleCode::Q002,
RuleCode::Q003,
])
},
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
@ -120,7 +120,7 @@ mod tests {
#[test_case(Path::new("docstring_singles_function.py"))]
fn single_docstring(path: &Path) -> Result<()> {
let snapshot = format!("single_docstring_{}", path.to_string_lossy());
let checks = test_path(
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_quotes")
.join(path)
.as_path(),
@ -132,14 +132,14 @@ mod tests {
avoid_escape: true,
},
..Settings::for_rules(vec![
CheckCode::Q000,
CheckCode::Q001,
CheckCode::Q002,
CheckCode::Q003,
RuleCode::Q000,
RuleCode::Q001,
RuleCode::Q002,
RuleCode::Q003,
])
},
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

28
src/flake8_return/mod.rs
View File

@ -10,26 +10,26 @@ mod tests {
use test_case::test_case;
use crate::linter::test_path;
use crate::registry::CheckCode;
use crate::registry::RuleCode;
use crate::Settings;
#[test_case(CheckCode::RET501, Path::new("RET501.py"); "RET501")]
#[test_case(CheckCode::RET502, Path::new("RET502.py"); "RET502")]
#[test_case(CheckCode::RET503, Path::new("RET503.py"); "RET503")]
#[test_case(CheckCode::RET504, Path::new("RET504.py"); "RET504")]
#[test_case(CheckCode::RET505, Path::new("RET505.py"); "RET505")]
#[test_case(CheckCode::RET506, Path::new("RET506.py"); "RET506")]
#[test_case(CheckCode::RET507, Path::new("RET507.py"); "RET507")]
#[test_case(CheckCode::RET508, Path::new("RET508.py"); "RET508")]
fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
let checks = test_path(
#[test_case(RuleCode::RET501, Path::new("RET501.py"); "RET501")]
#[test_case(RuleCode::RET502, Path::new("RET502.py"); "RET502")]
#[test_case(RuleCode::RET503, Path::new("RET503.py"); "RET503")]
#[test_case(RuleCode::RET504, Path::new("RET504.py"); "RET504")]
#[test_case(RuleCode::RET505, Path::new("RET505.py"); "RET505")]
#[test_case(RuleCode::RET506, Path::new("RET506.py"); "RET506")]
#[test_case(RuleCode::RET507, Path::new("RET507.py"); "RET507")]
#[test_case(RuleCode::RET508, Path::new("RET508.py"); "RET508")]
fn diagnostics(rule_code: RuleCode, path: &Path) -> Result<()> {
let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
let diagnostics = test_path(
Path::new("./resources/test/fixtures/flake8_return")
.join(path)
.as_path(),
&Settings::for_rule(check_code),
&Settings::for_rule(rule_code),
)?;
insta::assert_yaml_snapshot!(snapshot, checks);
insta::assert_yaml_snapshot!(snapshot, diagnostics);
Ok(())
}
}

62
src/flake8_return/plugins.rs
View File

@ -8,8 +8,8 @@ use crate::autofix::Fix;
use crate::checkers::ast::Checker;
use crate::flake8_return::helpers::result_exists;
use crate::flake8_return::visitor::{ReturnVisitor, Stack};
use crate::registry::{Branch, CheckCode};
use crate::{violations, Check};
use crate::registry::{Branch, RuleCode};
use crate::{violations, Diagnostic};
/// RET501
fn unnecessary_return_none(checker: &mut Checker, stack: &Stack) {
@ -26,15 +26,16 @@ fn unnecessary_return_none(checker: &mut Checker, stack: &Stack) {
) {
continue;
}
let mut check = Check::new(violations::UnnecessaryReturnNone, Range::from_located(stmt));
if checker.patch(&CheckCode::RET501) {
let mut check =
Diagnostic::new(violations::UnnecessaryReturnNone, Range::from_located(stmt));
if checker.patch(&RuleCode::RET501) {
check.amend(Fix::replacement(
"return".to_string(),
stmt.location,
stmt.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
@ -44,15 +45,15 @@ fn implicit_return_value(checker: &mut Checker, stack: &Stack) {
if expr.is_some() {
continue;
}
let mut check = Check::new(violations::ImplicitReturnValue, Range::from_located(stmt));
if checker.patch(&CheckCode::RET502) {
let mut check = Diagnostic::new(violations::ImplicitReturnValue, Range::from_located(stmt));
if checker.patch(&RuleCode::RET502) {
check.amend(Fix::replacement(
"return None".to_string(),
stmt.location,
stmt.end_location.unwrap(),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
@ -61,7 +62,7 @@ fn implicit_return(checker: &mut Checker, last_stmt: &Stmt) {
match &last_stmt.node {
StmtKind::If { body, orelse, .. } => {
if body.is_empty() || orelse.is_empty() {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::ImplicitReturn,
Range::from_located(last_stmt),
));
@ -100,8 +101,9 @@ fn implicit_return(checker: &mut Checker, last_stmt: &Stmt) {
| StmtKind::Raise { .. }
| StmtKind::Try { .. } => {}
_ => {
let mut check = Check::new(violations::ImplicitReturn, Range::from_located(last_stmt));
if checker.patch(&CheckCode::RET503) {
let mut check =
Diagnostic::new(violations::ImplicitReturn, Range::from_located(last_stmt));
if checker.patch(&RuleCode::RET503) {
let mut content = String::new();
content.push_str(&indentation(checker, last_stmt));
content.push_str("return None");
@ -111,7 +113,7 @@ fn implicit_return(checker: &mut Checker, last_stmt: &Stmt) {
Location::new(last_stmt.end_location.unwrap().row() + 1, 0),
));
}
checker.checks.push(check);
checker.diagnostics.push(check);
}
}
}
@ -190,7 +192,7 @@ fn unnecessary_assign(checker: &mut Checker, stack: &Stack, expr: &Expr) {
}
if !stack.refs.contains_key(id.as_str()) {
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::UnnecessaryAssign,
Range::from_located(expr),
));
@ -207,7 +209,7 @@ fn unnecessary_assign(checker: &mut Checker, stack: &Stack, expr: &Expr) {
return;
}
checker.checks.push(Check::new(
checker.diagnostics.push(Diagnostic::new(
violations::UnnecessaryAssign,
Range::from_located(expr),
));
@ -221,8 +223,8 @@ fn superfluous_else_node(checker: &mut Checker, stmt: &Stmt, branch: Branch) ->
};
for child in body {
if matches!(child.node, StmtKind::Return { .. }) {
if checker.settings.enabled.contains(&CheckCode::RET505) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::RET505) {
checker.diagnostics.push(Diagnostic::new(
violations::SuperfluousElseReturn(branch),
Range::from_located(stmt),
));
@ -230,8 +232,8 @@ fn superfluous_else_node(checker: &mut Checker, stmt: &Stmt, branch: Branch) ->
return true;
}
if matches!(child.node, StmtKind::Break) {
if checker.settings.enabled.contains(&CheckCode::RET508) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::RET508) {
checker.diagnostics.push(Diagnostic::new(
violations::SuperfluousElseBreak(branch),
Range::from_located(stmt),
));
@ -239,8 +241,8 @@ fn superfluous_else_node(checker: &mut Checker, stmt: &Stmt, branch: Branch) ->
return true;
}
if matches!(child.node, StmtKind::Raise { .. }) {
if checker.settings.enabled.contains(&CheckCode::RET506) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::RET506) {
checker.diagnostics.push(Diagnostic::new(
violations::SuperfluousElseRaise(branch),
Range::from_located(stmt),
));
@ -248,8 +250,8 @@ fn superfluous_else_node(checker: &mut Checker, stmt: &Stmt, branch: Branch) ->
return true;
}
if matches!(child.node, StmtKind::Continue) {
if checker.settings.enabled.contains(&CheckCode::RET507) {
checker.checks.push(Check::new(
if checker.settings.enabled.contains(&RuleCode::RET507) {
checker.diagnostics.push(Diagnostic::new(
violations::SuperfluousElseContinue(branch),
Range::from_located(stmt),
));
@ -310,10 +312,10 @@ pub fn function(checker: &mut Checker, body: &[Stmt]) {
visitor.stack
};
if checker.settings.enabled.contains(&CheckCode::RET505)
|| checker.settings.enabled.contains(&CheckCode::RET506)
|| checker.settings.enabled.contains(&CheckCode::RET507)
|| checker.settings.enabled.contains(&CheckCode::RET508)
if checker.settings.enabled.contains(&RuleCode::RET505)
|| checker.settings.enabled.contains(&RuleCode::RET506)
|| checker.settings.enabled.contains(&RuleCode::RET507)
|| checker.settings.enabled.contains(&RuleCode::RET508)
{
if superfluous_elif(checker, &stack) {
return;
@ -329,20 +331,20 @@ pub fn function(checker: &mut Checker, body: &[Stmt]) {
}
if !result_exists(&stack.returns) {
if checker.settings.enabled.contains(&CheckCode::RET501) {
if checker.settings.enabled.contains(&RuleCode::RET501) {
unnecessary_return_none(checker, &stack);
}
return;
}
if checker.settings.enabled.contains(&CheckCode::RET502) {
if checker.settings.enabled.contains(&RuleCode::RET502) {
implicit_return_value(checker, &stack);
}
if checker.settings.enabled.contains(&CheckCode::RET503) {
if checker.settings.enabled.contains(&RuleCode::RET503) {
implicit_return(checker, last_stmt);
}
if checker.settings.enabled.contains(&CheckCode::RET504) {
if checker.settings.enabled.contains(&RuleCode::RET504) {
for (_, expr) in &stack.returns {
if let Some(expr) = expr {
unnecessary_assign(checker, &stack, expr);

Some files were not shown because too many files have changed in this diff Show More