From 272211a3baa8bdc087cc1d0686fc571e0d3fa301 Mon Sep 17 00:00:00 2001 From: messense Date: Thu, 5 Jan 2023 12:06:26 +0800 Subject: [PATCH 1/3] Move configuration derive to a separate module --- ruff_macros/src/config.rs | 203 +++++++++++++++++++++++++++++++++++++ ruff_macros/src/lib.rs | 208 +------------------------------------- 2 files changed, 207 insertions(+), 204 deletions(-) create mode 100644 ruff_macros/src/config.rs diff --git a/ruff_macros/src/config.rs b/ruff_macros/src/config.rs new file mode 100644 index 0000000000000..b23935ea99d95 --- /dev/null +++ b/ruff_macros/src/config.rs @@ -0,0 +1,203 @@ +use quote::{quote, quote_spanned}; +use syn::parse::{Parse, ParseStream}; +use syn::spanned::Spanned; +use syn::token::Comma; +use syn::{ + AngleBracketedGenericArguments, Attribute, Data, DataStruct, DeriveInput, Field, Fields, Lit, + LitStr, Path, PathArguments, PathSegment, Token, Type, TypePath, +}; + +pub fn derive_impl(input: DeriveInput) -> syn::Result { + let DeriveInput { ident, data, .. } = input; + + match data { + Data::Struct(DataStruct { + fields: Fields::Named(fields), + .. + }) => { + let mut output = vec![]; + + for field in fields.named.iter() { + let docs: Vec<&Attribute> = field + .attrs + .iter() + .filter(|attr| attr.path.is_ident("doc")) + .collect(); + + if docs.is_empty() { + return Err(syn::Error::new( + field.span(), + "Missing documentation for field", + )); + } + + if let Some(attr) = field.attrs.iter().find(|attr| attr.path.is_ident("option")) { + output.push(handle_option(field, attr, docs)?); + }; + + if field + .attrs + .iter() + .any(|attr| attr.path.is_ident("option_group")) + { + output.push(handle_option_group(field)?); + }; + } + + Ok(quote! { + use crate::settings::options_base::{OptionEntry, OptionField, OptionGroup, ConfigurationOptions}; + + #[automatically_derived] + impl ConfigurationOptions for #ident { + fn get_available_options() -> Vec { + vec![#(#output),*] + } + } + }) + } + _ => Err(syn::Error::new( + ident.span(), + "Can only derive ConfigurationOptions from structs with named fields.", + )), + } +} + +/// For a field with type `Option` where `Foobar` itself is a struct +/// deriving `ConfigurationOptions`, create code that calls retrieves options +/// from that group: `Foobar::get_available_options()` +fn handle_option_group(field: &Field) -> syn::Result { + let ident = field + .ident + .as_ref() + .expect("Expected to handle named fields"); + + match &field.ty { + Type::Path(TypePath { + path: Path { segments, .. }, + .. + }) => match segments.first() { + Some(PathSegment { + ident: type_ident, + arguments: + PathArguments::AngleBracketed(AngleBracketedGenericArguments { args, .. }), + .. + }) if type_ident == "Option" => { + let path = &args[0]; + let kebab_name = LitStr::new(&ident.to_string().replace('_', "-"), ident.span()); + + Ok(quote_spanned!( + ident.span() => OptionEntry::Group(OptionGroup { + name: #kebab_name, + fields: #path::get_available_options(), + }) + )) + } + _ => Err(syn::Error::new( + ident.span(), + "Expected `Option<_>` as type.", + )), + }, + _ => Err(syn::Error::new(ident.span(), "Expected type.")), + } +} + +/// Parse a `doc` attribute into it a string literal. +fn parse_doc(doc: &Attribute) -> syn::Result { + let doc = doc + .parse_meta() + .map_err(|e| syn::Error::new(doc.span(), e))?; + + match doc { + syn::Meta::NameValue(syn::MetaNameValue { + lit: Lit::Str(lit_str), + .. + }) => Ok(lit_str.value()), + _ => Err(syn::Error::new(doc.span(), "Expected doc attribute.")), + } +} + +/// Parse an `#[option(doc="...", default="...", value_type="...", +/// example="...")]` attribute and return data in the form of an `OptionField`. +fn handle_option( + field: &Field, + attr: &Attribute, + docs: Vec<&Attribute>, +) -> syn::Result { + // Convert the list of `doc` attributes into a single string. + let doc = textwrap::dedent( + &docs + .into_iter() + .map(parse_doc) + .collect::>>()? + .join("\n"), + ) + .trim_matches('\n') + .to_string(); + + let ident = field + .ident + .as_ref() + .expect("Expected to handle named fields"); + + let FieldAttributes { + default, + value_type, + example, + .. + } = attr.parse_args::()?; + let kebab_name = LitStr::new(&ident.to_string().replace('_', "-"), ident.span()); + + Ok(quote_spanned!( + ident.span() => OptionEntry::Field(OptionField { + name: #kebab_name, + doc: &#doc, + default: &#default, + value_type: &#value_type, + example: &#example, + }) + )) +} + +#[derive(Debug)] +struct FieldAttributes { + default: String, + value_type: String, + example: String, +} + +impl Parse for FieldAttributes { + fn parse(input: ParseStream) -> syn::Result { + let default = _parse_key_value(input, "default")?; + input.parse::()?; + let value_type = _parse_key_value(input, "value_type")?; + input.parse::()?; + let example = _parse_key_value(input, "example")?; + if !input.is_empty() { + input.parse::()?; + } + + Ok(FieldAttributes { + default, + value_type, + example: textwrap::dedent(&example).trim_matches('\n').to_string(), + }) + } +} + +fn _parse_key_value(input: ParseStream, name: &str) -> syn::Result { + let ident: proc_macro2::Ident = input.parse()?; + if ident != name { + return Err(syn::Error::new( + ident.span(), + format!("Expected `{name}` name"), + )); + } + + input.parse::()?; + let value: Lit = input.parse()?; + + match &value { + Lit::Str(v) => Ok(v.value()), + _ => Err(syn::Error::new(value.span(), "Expected literal string")), + } +} diff --git a/ruff_macros/src/lib.rs b/ruff_macros/src/lib.rs index 2ef22a5aad0b2..eed0bec1f2821 100644 --- a/ruff_macros/src/lib.rs +++ b/ruff_macros/src/lib.rs @@ -11,215 +11,15 @@ clippy::too_many_lines )] -use quote::{quote, quote_spanned}; -use syn::parse::{Parse, ParseStream}; -use syn::spanned::Spanned; -use syn::token::Comma; -use syn::{ - parse_macro_input, AngleBracketedGenericArguments, Attribute, Data, DataStruct, DeriveInput, - Field, Fields, Lit, LitStr, Path, PathArguments, PathSegment, Token, Type, TypePath, -}; +use syn::{parse_macro_input, DeriveInput}; + +mod config; #[proc_macro_derive(ConfigurationOptions, attributes(option, doc, option_group))] pub fn derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream { let input = parse_macro_input!(input as DeriveInput); - derive_impl(input) + config::derive_impl(input) .unwrap_or_else(syn::Error::into_compile_error) .into() } - -fn derive_impl(input: DeriveInput) -> syn::Result { - let DeriveInput { ident, data, .. } = input; - - match data { - Data::Struct(DataStruct { - fields: Fields::Named(fields), - .. - }) => { - let mut output = vec![]; - - for field in fields.named.iter() { - let docs: Vec<&Attribute> = field - .attrs - .iter() - .filter(|attr| attr.path.is_ident("doc")) - .collect(); - - if docs.is_empty() { - return Err(syn::Error::new( - field.span(), - "Missing documentation for field", - )); - } - - if let Some(attr) = field.attrs.iter().find(|attr| attr.path.is_ident("option")) { - output.push(handle_option(field, attr, docs)?); - }; - - if field - .attrs - .iter() - .any(|attr| attr.path.is_ident("option_group")) - { - output.push(handle_option_group(field)?); - }; - } - - Ok(quote! { - use crate::settings::options_base::{OptionEntry, OptionField, OptionGroup, ConfigurationOptions}; - - #[automatically_derived] - impl ConfigurationOptions for #ident { - fn get_available_options() -> Vec { - vec![#(#output),*] - } - } - }) - } - _ => Err(syn::Error::new( - ident.span(), - "Can only derive ConfigurationOptions from structs with named fields.", - )), - } -} - -/// For a field with type `Option` where `Foobar` itself is a struct -/// deriving `ConfigurationOptions`, create code that calls retrieves options -/// from that group: `Foobar::get_available_options()` -fn handle_option_group(field: &Field) -> syn::Result { - let ident = field - .ident - .as_ref() - .expect("Expected to handle named fields"); - - match &field.ty { - Type::Path(TypePath { - path: Path { segments, .. }, - .. - }) => match segments.first() { - Some(PathSegment { - ident: type_ident, - arguments: - PathArguments::AngleBracketed(AngleBracketedGenericArguments { args, .. }), - .. - }) if type_ident == "Option" => { - let path = &args[0]; - let kebab_name = LitStr::new(&ident.to_string().replace('_', "-"), ident.span()); - - Ok(quote_spanned!( - ident.span() => OptionEntry::Group(OptionGroup { - name: #kebab_name, - fields: #path::get_available_options(), - }) - )) - } - _ => Err(syn::Error::new( - ident.span(), - "Expected `Option<_>` as type.", - )), - }, - _ => Err(syn::Error::new(ident.span(), "Expected type.")), - } -} - -/// Parse a `doc` attribute into it a string literal. -fn parse_doc(doc: &Attribute) -> syn::Result { - let doc = doc - .parse_meta() - .map_err(|e| syn::Error::new(doc.span(), e))?; - - match doc { - syn::Meta::NameValue(syn::MetaNameValue { - lit: Lit::Str(lit_str), - .. - }) => Ok(lit_str.value()), - _ => Err(syn::Error::new(doc.span(), "Expected doc attribute.")), - } -} - -/// Parse an `#[option(doc="...", default="...", value_type="...", -/// example="...")]` attribute and return data in the form of an `OptionField`. -fn handle_option( - field: &Field, - attr: &Attribute, - docs: Vec<&Attribute>, -) -> syn::Result { - // Convert the list of `doc` attributes into a single string. - let doc = textwrap::dedent( - &docs - .into_iter() - .map(parse_doc) - .collect::>>()? - .join("\n"), - ) - .trim_matches('\n') - .to_string(); - - let ident = field - .ident - .as_ref() - .expect("Expected to handle named fields"); - - let FieldAttributes { - default, - value_type, - example, - .. - } = attr.parse_args::()?; - let kebab_name = LitStr::new(&ident.to_string().replace('_', "-"), ident.span()); - - Ok(quote_spanned!( - ident.span() => OptionEntry::Field(OptionField { - name: #kebab_name, - doc: &#doc, - default: &#default, - value_type: &#value_type, - example: &#example, - }) - )) -} - -#[derive(Debug)] -struct FieldAttributes { - default: String, - value_type: String, - example: String, -} - -impl Parse for FieldAttributes { - fn parse(input: ParseStream) -> syn::Result { - let default = _parse_key_value(input, "default")?; - input.parse::()?; - let value_type = _parse_key_value(input, "value_type")?; - input.parse::()?; - let example = _parse_key_value(input, "example")?; - if !input.is_empty() { - input.parse::()?; - } - - Ok(FieldAttributes { - default, - value_type, - example: textwrap::dedent(&example).trim_matches('\n').to_string(), - }) - } -} - -fn _parse_key_value(input: ParseStream, name: &str) -> syn::Result { - let ident: proc_macro2::Ident = input.parse()?; - if ident != name { - return Err(syn::Error::new( - ident.span(), - format!("Expected `{name}` name"), - )); - } - - input.parse::()?; - let value: Lit = input.parse()?; - - match &value { - Lit::Str(v) => Ok(v.value()), - _ => Err(syn::Error::new(value.span(), "Expected literal string")), - } -} From 465ed6922bd92cc6def6af771ab559637757ada0 Mon Sep 17 00:00:00 2001 From: messense Date: Thu, 5 Jan 2023 14:13:57 +0800 Subject: [PATCH 2/3] Add proc-macro to derive `CheckCodePrefix` --- .github/workflows/ci.yaml | 3 +- Cargo.lock | 15 +- flake8_to_ruff/src/converter.rs | 4 +- flake8_to_ruff/src/parser.rs | 5 +- flake8_to_ruff/src/plugin.rs | 2 +- ruff_dev/Cargo.toml | 1 - ruff_dev/src/generate_all.rs | 8 +- ruff_dev/src/generate_check_code_prefix.rs | 221 -- ruff_dev/src/lib.rs | 1 - ruff_dev/src/main.rs | 7 +- ruff_macros/Cargo.toml | 1 + ruff_macros/src/check_code_prefix.rs | 289 ++ ruff_macros/src/lib.rs | 12 +- src/cli.rs | 3 +- src/lib.rs | 1 - src/lib_wasm.rs | 3 +- src/pandas_vet/mod.rs | 3 +- src/pydocstyle/settings.rs | 2 +- src/pyflakes/mod.rs | 3 +- src/registry.rs | 79 +- src/registry_gen.rs | 3797 -------------------- src/settings/configuration.rs | 2 +- src/settings/mod.rs | 6 +- src/settings/options.rs | 2 +- src/settings/pyproject.rs | 2 +- src/settings/types.rs | 3 +- 26 files changed, 326 insertions(+), 4149 deletions(-) delete mode 100644 ruff_dev/src/generate_check_code_prefix.rs create mode 100644 ruff_macros/src/check_code_prefix.rs delete mode 100644 src/registry_gen.rs diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 42eadd38830b9..8628e9cf6c0e3 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -42,9 +42,8 @@ jobs: - run: cargo build --all --release - run: ./target/release/ruff_dev generate-all - run: git diff --quiet README.md || echo "::error file=README.md::This file is outdated. Run 'cargo +nightly dev generate-all'." - - run: git diff --quiet src/registry_gen.rs || echo "::error file=src/registry_gen.rs::This file is outdated. Run 'cargo +nightly dev generate-all'." - run: git diff --quiet ruff.schema.json || echo "::error file=ruff.schema.json::This file is outdated. Run 'cargo +nightly dev generate-all'." - - run: git diff --exit-code -- README.md src/registry_gen.rs ruff.schema.json + - run: git diff --exit-code -- README.md ruff.schema.json cargo-fmt: name: "cargo fmt" diff --git a/Cargo.lock b/Cargo.lock index e1f6593cbc3a8..073e45a4433ef 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -367,15 +367,6 @@ dependencies = [ "winapi", ] -[[package]] -name = "codegen" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff61280aed771c3070e7dcc9e050c66f1eb1e3b96431ba66f9f74641d02fc41d" -dependencies = [ - "indexmap", -] - [[package]] name = "codespan-reporting" version = "0.11.1" @@ -1365,9 +1356,9 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.16.0" +version = "1.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860" +checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66" [[package]] name = "oorandom" @@ -1945,7 +1936,6 @@ version = "0.0.211" dependencies = [ "anyhow", "clap 4.0.32", - "codegen", "itertools", "libcst", "once_cell", @@ -1964,6 +1954,7 @@ dependencies = [ name = "ruff_macros" version = "0.0.211" dependencies = [ + "once_cell", "proc-macro2", "quote", "syn", diff --git a/flake8_to_ruff/src/converter.rs b/flake8_to_ruff/src/converter.rs index a8c3913d1224c..50aa571b8beca 100644 --- a/flake8_to_ruff/src/converter.rs +++ b/flake8_to_ruff/src/converter.rs @@ -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_gen::CheckCodePrefix; +use ruff::registry::CheckCodePrefix; use ruff::settings::options::Options; use ruff::settings::pyproject::Pyproject; use ruff::{ @@ -345,7 +345,7 @@ mod tests { use anyhow::Result; use ruff::pydocstyle::settings::Convention; - use ruff::registry_gen::CheckCodePrefix; + use ruff::registry::CheckCodePrefix; use ruff::settings::options::Options; use ruff::settings::pyproject::Pyproject; use ruff::{flake8_quotes, pydocstyle}; diff --git a/flake8_to_ruff/src/parser.rs b/flake8_to_ruff/src/parser.rs index a812506700a02..257f1c0348cf8 100644 --- a/flake8_to_ruff/src/parser.rs +++ b/flake8_to_ruff/src/parser.rs @@ -3,8 +3,7 @@ use std::str::FromStr; use anyhow::{bail, Result}; use once_cell::sync::Lazy; use regex::Regex; -use ruff::registry::PREFIX_REDIRECTS; -use ruff::registry_gen::CheckCodePrefix; +use ruff::registry::{CheckCodePrefix, PREFIX_REDIRECTS}; use ruff::settings::types::PatternPrefixPair; use rustc_hash::FxHashMap; @@ -201,7 +200,7 @@ pub fn collect_per_file_ignores( #[cfg(test)] mod tests { use anyhow::Result; - use ruff::registry_gen::CheckCodePrefix; + use ruff::registry::CheckCodePrefix; use ruff::settings::types::PatternPrefixPair; use crate::parser::{parse_files_to_codes_mapping, parse_prefix_codes, parse_strings}; diff --git a/flake8_to_ruff/src/plugin.rs b/flake8_to_ruff/src/plugin.rs index e3517c0b96200..4fdfc2bd3e6d3 100644 --- a/flake8_to_ruff/src/plugin.rs +++ b/flake8_to_ruff/src/plugin.rs @@ -3,7 +3,7 @@ use std::fmt; use std::str::FromStr; use anyhow::anyhow; -use ruff::registry_gen::CheckCodePrefix; +use ruff::registry::CheckCodePrefix; #[derive(Clone, Ord, PartialOrd, Eq, PartialEq)] pub enum Plugin { diff --git a/ruff_dev/Cargo.toml b/ruff_dev/Cargo.toml index 348fea6434d49..b69e3ae04ad64 100644 --- a/ruff_dev/Cargo.toml +++ b/ruff_dev/Cargo.toml @@ -6,7 +6,6 @@ edition = "2021" [dependencies] anyhow = { version = "1.0.66" } clap = { version = "4.0.1", features = ["derive"] } -codegen = { version = "0.2.0" } itertools = { version = "0.10.5" } libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a8725d161fe8b3ed73a6758b21e177" } once_cell = { version = "1.16.0" } diff --git a/ruff_dev/src/generate_all.rs b/ruff_dev/src/generate_all.rs index 97cf3a82d6f61..5ebd728e67351 100644 --- a/ruff_dev/src/generate_all.rs +++ b/ruff_dev/src/generate_all.rs @@ -3,10 +3,7 @@ use anyhow::Result; use clap::Args; -use crate::{ - generate_check_code_prefix, generate_cli_help, generate_json_schema, generate_options, - generate_rules_table, -}; +use crate::{generate_cli_help, generate_json_schema, generate_options, generate_rules_table}; #[derive(Args)] pub struct Cli { @@ -16,9 +13,6 @@ pub struct Cli { } pub fn main(cli: &Cli) -> Result<()> { - generate_check_code_prefix::main(&generate_check_code_prefix::Cli { - dry_run: cli.dry_run, - })?; generate_json_schema::main(&generate_json_schema::Cli { dry_run: cli.dry_run, })?; diff --git a/ruff_dev/src/generate_check_code_prefix.rs b/ruff_dev/src/generate_check_code_prefix.rs deleted file mode 100644 index df7449831f00c..0000000000000 --- a/ruff_dev/src/generate_check_code_prefix.rs +++ /dev/null @@ -1,221 +0,0 @@ -//! Generate the `CheckCodePrefix` enum. - -use std::collections::{BTreeMap, BTreeSet}; -use std::fs; -use std::io::Write; -use std::path::PathBuf; -use std::process::{Command, Output, Stdio}; - -use anyhow::{ensure, Result}; -use clap::Parser; -use codegen::{Scope, Type, Variant}; -use itertools::Itertools; -use ruff::registry::{CheckCode, PREFIX_REDIRECTS}; -use strum::IntoEnumIterator; - -const ALL: &str = "ALL"; - -#[derive(Parser)] -#[command(author, version, about, long_about = None)] -pub struct Cli { - /// Write the generated source code to stdout (rather than to - /// `src/registry_gen.rs`). - #[arg(long)] - pub(crate) dry_run: bool, -} - -pub fn main(cli: &Cli) -> Result<()> { - // Build up a map from prefix to matching CheckCodes. - let mut prefix_to_codes: BTreeMap> = BTreeMap::default(); - for check_code in CheckCode::iter() { - let code_str: String = check_code.as_ref().to_string(); - let code_prefix_len = code_str - .chars() - .take_while(|char| char.is_alphabetic()) - .count(); - let code_suffix_len = code_str.len() - code_prefix_len; - for i in 0..=code_suffix_len { - let prefix = code_str[..code_prefix_len + i].to_string(); - prefix_to_codes - .entry(prefix) - .or_default() - .insert(check_code.clone()); - } - prefix_to_codes - .entry(ALL.to_string()) - .or_default() - .insert(check_code.clone()); - } - - // Add any prefix aliases (e.g., "U" to "UP"). - for (alias, check_code) in PREFIX_REDIRECTS.iter() { - prefix_to_codes.insert( - (*alias).to_string(), - prefix_to_codes - .get(&check_code.as_ref().to_string()) - .unwrap_or_else(|| panic!("Unknown CheckCode: {alias:?}")) - .clone(), - ); - } - - let mut scope = Scope::new(); - - // Create the `CheckCodePrefix` definition. - let mut gen = scope - .new_enum("CheckCodePrefix") - .vis("pub") - .derive("EnumString") - .derive("AsRefStr") - .derive("Debug") - .derive("PartialEq") - .derive("Eq") - .derive("PartialOrd") - .derive("Ord") - .derive("Clone") - .derive("Serialize") - .derive("Deserialize") - .derive("JsonSchema"); - for prefix in prefix_to_codes.keys() { - gen = gen.push_variant(Variant::new(prefix.to_string())); - } - - // Create the `SuffixLength` definition. - scope - .new_enum("SuffixLength") - .vis("pub") - .derive("PartialEq") - .derive("Eq") - .derive("PartialOrd") - .derive("Ord") - .push_variant(Variant::new("None")) - .push_variant(Variant::new("Zero")) - .push_variant(Variant::new("One")) - .push_variant(Variant::new("Two")) - .push_variant(Variant::new("Three")) - .push_variant(Variant::new("Four")); - - // Create the `match` statement, to map from definition to relevant codes. - let mut gen = scope - .new_impl("CheckCodePrefix") - .new_fn("codes") - .arg_ref_self() - .ret(Type::new("Vec")) - .vis("pub") - .line("#[allow(clippy::match_same_arms)]") - .line("match self {"); - for (prefix, codes) in &prefix_to_codes { - if let Some(target) = PREFIX_REDIRECTS.get(&prefix.as_str()) { - gen = gen.line(format!( - "CheckCodePrefix::{prefix} => {{ one_time_warning!(\"{{}}{{}} {{}}\", \ - \"warning\".yellow().bold(), \":\".bold(), \"`{}` has been remapped to \ - `{}`\".bold()); \n vec![{}] }}", - prefix, - target.as_ref(), - codes - .iter() - .map(|code| format!("CheckCode::{}", code.as_ref())) - .join(", ") - )); - } else { - gen = gen.line(format!( - "CheckCodePrefix::{prefix} => vec![{}],", - codes - .iter() - .map(|code| format!("CheckCode::{}", code.as_ref())) - .join(", ") - )); - } - } - gen.line("}"); - - // Create the `match` statement, to map from definition to specificity. - let mut gen = scope - .new_impl("CheckCodePrefix") - .new_fn("specificity") - .arg_ref_self() - .ret(Type::new("SuffixLength")) - .vis("pub") - .line("#[allow(clippy::match_same_arms)]") - .line("match self {"); - for prefix in prefix_to_codes.keys() { - let specificity = if prefix == "ALL" { - "None" - } else { - let num_numeric = prefix.chars().filter(|char| char.is_numeric()).count(); - match num_numeric { - 0 => "Zero", - 1 => "One", - 2 => "Two", - 3 => "Three", - 4 => "Four", - _ => panic!("Invalid prefix: {prefix}"), - } - }; - gen = gen.line(format!( - "CheckCodePrefix::{prefix} => SuffixLength::{specificity}," - )); - } - gen.line("}"); - - // Construct the output contents. - let mut output = String::new(); - output - .push_str("//! File automatically generated by `examples/generate_check_code_prefix.rs`."); - output.push('\n'); - output.push('\n'); - output.push_str("use colored::Colorize;"); - output.push('\n'); - output.push_str("use schemars::JsonSchema;"); - output.push('\n'); - output.push_str("use serde::{Deserialize, Serialize};"); - output.push('\n'); - output.push_str("use strum_macros::{AsRefStr, EnumString};"); - output.push('\n'); - output.push('\n'); - output.push_str("use crate::registry::CheckCode;"); - output.push('\n'); - output.push_str("use crate::one_time_warning;"); - output.push('\n'); - output.push('\n'); - output.push_str(&scope.to_string()); - output.push('\n'); - output.push('\n'); - - // Add the list of output categories (not generated). - output.push_str("pub const CATEGORIES: &[CheckCodePrefix] = &["); - output.push('\n'); - for prefix in prefix_to_codes.keys() { - if prefix.chars().all(char::is_alphabetic) - && !PREFIX_REDIRECTS.contains_key(&prefix.as_str()) - { - output.push_str(&format!("CheckCodePrefix::{prefix},")); - output.push('\n'); - } - } - output.push_str("];"); - output.push('\n'); - output.push('\n'); - - let rustfmt = Command::new("rustfmt") - .stdin(Stdio::piped()) - .stdout(Stdio::piped()) - .spawn()?; - write!(rustfmt.stdin.as_ref().unwrap(), "{output}")?; - let Output { status, stdout, .. } = rustfmt.wait_with_output()?; - ensure!(status.success(), "rustfmt failed with {status}"); - - // Write the output to `src/registry_gen.rs` (or stdout). - if cli.dry_run { - println!("{}", String::from_utf8(stdout)?); - } else { - let file = PathBuf::from(env!("CARGO_MANIFEST_DIR")) - .parent() - .expect("Failed to find root directory") - .join("src/registry_gen.rs"); - if fs::read(&file).map_or(true, |old| old != stdout) { - fs::write(&file, stdout)?; - } - } - - Ok(()) -} diff --git a/ruff_dev/src/lib.rs b/ruff_dev/src/lib.rs index 819c90885d001..9ade6b299d80a 100644 --- a/ruff_dev/src/lib.rs +++ b/ruff_dev/src/lib.rs @@ -12,7 +12,6 @@ )] pub mod generate_all; -pub mod generate_check_code_prefix; pub mod generate_cli_help; pub mod generate_json_schema; pub mod generate_options; diff --git a/ruff_dev/src/main.rs b/ruff_dev/src/main.rs index 83f4eac643b4d..598491af78664 100644 --- a/ruff_dev/src/main.rs +++ b/ruff_dev/src/main.rs @@ -14,8 +14,8 @@ use anyhow::Result; use clap::{Parser, Subcommand}; use ruff_dev::{ - generate_all, generate_check_code_prefix, generate_cli_help, generate_json_schema, - generate_options, generate_rules_table, print_ast, print_cst, print_tokens, round_trip, + generate_all, generate_cli_help, generate_json_schema, generate_options, generate_rules_table, + print_ast, print_cst, print_tokens, round_trip, }; #[derive(Parser)] @@ -30,8 +30,6 @@ struct Cli { enum Commands { /// Run all code and documentation generation steps. GenerateAll(generate_all::Cli), - /// Generate the `CheckCodePrefix` enum. - GenerateCheckCodePrefix(generate_check_code_prefix::Cli), /// Generate JSON schema for the TOML configuration file. GenerateJSONSchema(generate_json_schema::Cli), /// Generate a Markdown-compatible table of supported lint rules. @@ -54,7 +52,6 @@ fn main() -> Result<()> { let cli = Cli::parse(); match &cli.command { Commands::GenerateAll(args) => generate_all::main(args)?, - Commands::GenerateCheckCodePrefix(args) => generate_check_code_prefix::main(args)?, Commands::GenerateJSONSchema(args) => generate_json_schema::main(args)?, Commands::GenerateRulesTable(args) => generate_rules_table::main(args)?, Commands::GenerateOptions(args) => generate_options::main(args)?, diff --git a/ruff_macros/Cargo.toml b/ruff_macros/Cargo.toml index 82018b8ee545d..76146195b0f9d 100644 --- a/ruff_macros/Cargo.toml +++ b/ruff_macros/Cargo.toml @@ -7,6 +7,7 @@ edition = "2021" proc-macro = true [dependencies] +once_cell = "1.17.0" proc-macro2 = { version = "1.0.47" } quote = { version = "1.0.21" } syn = { version = "1.0.103", features = ["derive", "parsing"] } diff --git a/ruff_macros/src/check_code_prefix.rs b/ruff_macros/src/check_code_prefix.rs new file mode 100644 index 0000000000000..608391a971867 --- /dev/null +++ b/ruff_macros/src/check_code_prefix.rs @@ -0,0 +1,289 @@ +use std::collections::{BTreeMap, BTreeSet, HashMap}; + +use once_cell::sync::Lazy; +use proc_macro2::Span; +use quote::quote; +use syn::punctuated::Punctuated; +use syn::token::Comma; +use syn::{DataEnum, DeriveInput, Ident, Variant}; + +const ALL: &str = "ALL"; + +/// A hash map from deprecated `CheckCodePrefix` to latest `CheckCodePrefix`. +pub static PREFIX_REDIRECTS: Lazy> = Lazy::new(|| { + HashMap::from_iter([ + // TODO(charlie): Remove by 2023-01-01. + ("U001", "UP001"), + ("U003", "UP003"), + ("U004", "UP004"), + ("U005", "UP005"), + ("U006", "UP006"), + ("U007", "UP007"), + ("U008", "UP008"), + ("U009", "UP009"), + ("U010", "UP010"), + ("U011", "UP011"), + ("U012", "UP012"), + ("U013", "UP013"), + ("U014", "UP014"), + ("U015", "UP015"), + ("U016", "UP016"), + ("U017", "UP017"), + ("U019", "UP019"), + // TODO(charlie): Remove by 2023-02-01. + ("I252", "TID252"), + ("M001", "RUF100"), + // TODO(charlie): Remove by 2023-02-01. + ("PDV002", "PD002"), + ("PDV003", "PD003"), + ("PDV004", "PD004"), + ("PDV007", "PD007"), + ("PDV008", "PD008"), + ("PDV009", "PD009"), + ("PDV010", "PD010"), + ("PDV011", "PD011"), + ("PDV012", "PD012"), + ("PDV013", "PD013"), + ("PDV015", "PD015"), + ("PDV901", "PD901"), + // TODO(charlie): Remove by 2023-02-01. + ("R501", "RET501"), + ("R502", "RET502"), + ("R503", "RET503"), + ("R504", "RET504"), + ("R505", "RET505"), + ("R506", "RET506"), + ("R507", "RET507"), + ("R508", "RET508"), + ("IC001", "ICN001"), + ("IC002", "ICN001"), + ("IC003", "ICN001"), + ("IC004", "ICN001"), + // TODO(charlie): Remove by 2023-01-01. + ("U", "UP"), + ("U0", "UP0"), + ("U00", "UP00"), + ("U01", "UP01"), + // TODO(charlie): Remove by 2023-02-01. + ("I2", "TID2"), + ("I25", "TID25"), + ("M", "RUF100"), + ("M0", "RUF100"), + // TODO(charlie): Remove by 2023-02-01. + ("PDV", "PD"), + ("PDV0", "PD0"), + ("PDV01", "PD01"), + ("PDV9", "PD9"), + ("PDV90", "PD90"), + // TODO(charlie): Remove by 2023-02-01. + ("R", "RET"), + ("R5", "RET5"), + ("R50", "RET50"), + // TODO(charlie): Remove by 2023-02-01. + ("IC", "ICN"), + ("IC0", "ICN0"), + ]) +}); + +pub fn derive_impl(input: DeriveInput) -> syn::Result { + let DeriveInput { ident, data, .. } = input; + let syn::Data::Enum(DataEnum { variants, .. }) = data else { + return Err(syn::Error::new( + ident.span(), + "Can only derive `CheckCodePrefix` from enums.", + )); + }; + + let prefix_ident = Ident::new(&format!("{ident}Prefix"), ident.span()); + let prefix = expand(&ident, &prefix_ident, &variants); + let expanded = quote! { + #[derive(PartialEq, Eq, PartialOrd, Ord)] + pub enum SuffixLength { + None, + Zero, + One, + Two, + Three, + Four, + } + + #prefix + }; + Ok(expanded) +} + +fn expand( + ident: &Ident, + prefix_ident: &Ident, + variants: &Punctuated, +) -> proc_macro2::TokenStream { + // Build up a map from prefix to matching CheckCodes. + let mut prefix_to_codes: BTreeMap> = BTreeMap::default(); + for variant in variants { + let span = variant.ident.span(); + let code_str = variant.ident.to_string(); + let code_prefix_len = code_str + .chars() + .take_while(|char| char.is_alphabetic()) + .count(); + let code_suffix_len = code_str.len() - code_prefix_len; + for i in 0..=code_suffix_len { + let prefix = code_str[..code_prefix_len + i].to_string(); + prefix_to_codes + .entry(Ident::new(&prefix, span)) + .or_default() + .insert(code_str.clone()); + } + prefix_to_codes + .entry(Ident::new(ALL, span)) + .or_default() + .insert(code_str.clone()); + } + + // Add any prefix aliases (e.g., "U" to "UP"). + for (alias, check_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:?}")) + .clone(), + ); + } + + let prefix_variants = prefix_to_codes.keys().map(|prefix| { + quote! { + #prefix + } + }); + + 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()); + quote! { + (#alias, #prefix_ident::#code) + } + }); + + quote! { + #[derive( + ::strum_macros::EnumString, + ::strum_macros::AsRefStr, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Clone, + ::serde::Serialize, + ::serde::Deserialize, + ::schemars::JsonSchema, + )] + pub enum #prefix_ident { + #(#prefix_variants,)* + } + + #prefix_impl + + /// A hash map from deprecated `CheckCodePrefix` to latest `CheckCodePrefix`. + 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),* + ]) + }); + } +} + +fn generate_impls( + ident: &Ident, + prefix_ident: &Ident, + prefix_to_codes: &BTreeMap>, +) -> proc_macro2::TokenStream { + let codes_match_arms = prefix_to_codes.iter().map(|(prefix, codes)| { + let codes = codes.iter().map(|code| { + let code = Ident::new(code, Span::call_site()); + quote! { + #ident::#code + } + }); + let prefix_str = prefix.to_string(); + if let Some(target) = PREFIX_REDIRECTS.get(prefix_str.as_str()) { + quote! { + #prefix_ident::#prefix => { + crate::one_time_warning!( + "{}{} {}", + "warning".yellow().bold(), + ":".bold(), + format!("`{}` has been remapped to `{}`", #prefix_str, #target).bold() + ); + vec![#(#codes),*] + } + } + } else { + quote! { + #prefix_ident::#prefix => vec![#(#codes),*], + } + } + }); + + let specificity_match_arms = prefix_to_codes.keys().map(|prefix| { + if *prefix == ALL { + quote! { + #prefix_ident::#prefix => SuffixLength::None, + } + } else { + let num_numeric = prefix + .to_string() + .chars() + .filter(|char| char.is_numeric()) + .count(); + let suffix_len = match num_numeric { + 0 => quote! { SuffixLength::Zero }, + 1 => quote! { SuffixLength::One }, + 2 => quote! { SuffixLength::Two }, + 3 => quote! { SuffixLength::Three }, + 4 => quote! { SuffixLength::Four }, + _ => panic!("Invalid prefix: {prefix}"), + }; + quote! { + #prefix_ident::#prefix => #suffix_len, + } + } + }); + + let categories = prefix_to_codes.keys().map(|prefix| { + let prefix_str = prefix.to_string(); + if prefix_str.chars().all(char::is_alphabetic) + && !PREFIX_REDIRECTS.contains_key(&prefix_str.as_str()) + { + quote! { + #prefix_ident::#prefix, + } + } else { + quote! {} + } + }); + + quote! { + impl #prefix_ident { + pub fn codes(&self) -> Vec<#ident> { + use colored::Colorize; + + #[allow(clippy::match_same_arms)] + match self { + #(#codes_match_arms)* + } + } + + pub fn specificity(&self) -> SuffixLength { + #[allow(clippy::match_same_arms)] + match self { + #(#specificity_match_arms)* + } + } + } + + pub const CATEGORIES: &[#prefix_ident] = &[#(#categories)*]; + } +} diff --git a/ruff_macros/src/lib.rs b/ruff_macros/src/lib.rs index eed0bec1f2821..ea5cbdb5db4f4 100644 --- a/ruff_macros/src/lib.rs +++ b/ruff_macros/src/lib.rs @@ -13,13 +13,23 @@ use syn::{parse_macro_input, DeriveInput}; +mod check_code_prefix; mod config; #[proc_macro_derive(ConfigurationOptions, attributes(option, doc, option_group))] -pub fn derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream { +pub fn derive_config(input: proc_macro::TokenStream) -> proc_macro::TokenStream { let input = parse_macro_input!(input as DeriveInput); config::derive_impl(input) .unwrap_or_else(syn::Error::into_compile_error) .into() } + +#[proc_macro_derive(CheckCodePrefix)] +pub fn derive_check_code_prefix(input: proc_macro::TokenStream) -> proc_macro::TokenStream { + let input = parse_macro_input!(input as DeriveInput); + + check_code_prefix::derive_impl(input) + .unwrap_or_else(syn::Error::into_compile_error) + .into() +} diff --git a/src/cli.rs b/src/cli.rs index 04ba0441b7d18..4c3a051686cf2 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -6,8 +6,7 @@ use rustc_hash::FxHashMap; use crate::fs; use crate::logging::LogLevel; -use crate::registry::CheckCode; -use crate::registry_gen::CheckCodePrefix; +use crate::registry::{CheckCode, CheckCodePrefix}; use crate::settings::types::{ FilePattern, PatternPrefixPair, PerFileIgnore, PythonVersion, SerializationFormat, }; diff --git a/src/lib.rs b/src/lib.rs index 8a062a97f52ae..e1821fc21aab8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -66,7 +66,6 @@ mod pylint; mod python; mod pyupgrade; pub mod registry; -pub mod registry_gen; pub mod resolver; mod ruff; mod rustpython_helpers; diff --git a/src/lib_wasm.rs b/src/lib_wasm.rs index bf9257f926714..d1a3901d4b18b 100644 --- a/src/lib_wasm.rs +++ b/src/lib_wasm.rs @@ -6,8 +6,7 @@ use serde::Serialize; use wasm_bindgen::prelude::*; use crate::linter::check_path; -use crate::registry::CheckCode; -use crate::registry_gen::CheckCodePrefix; +use crate::registry::{CheckCode, CheckCodePrefix}; use crate::rustpython_helpers::tokenize; use crate::settings::configuration::Configuration; use crate::settings::options::Options; diff --git a/src/pandas_vet/mod.rs b/src/pandas_vet/mod.rs index 0055f89ee0b78..3ca6d8affc2de 100644 --- a/src/pandas_vet/mod.rs +++ b/src/pandas_vet/mod.rs @@ -10,8 +10,7 @@ mod tests { use textwrap::dedent; use crate::linter::check_path; - use crate::registry::CheckCode; - use crate::registry_gen::CheckCodePrefix; + use crate::registry::{CheckCode, CheckCodePrefix}; use crate::settings::flags; use crate::source_code_locator::SourceCodeLocator; use crate::source_code_style::SourceCodeStyleDetector; diff --git a/src/pydocstyle/settings.rs b/src/pydocstyle/settings.rs index 48745a3207572..e679c75203d0d 100644 --- a/src/pydocstyle/settings.rs +++ b/src/pydocstyle/settings.rs @@ -4,7 +4,7 @@ use ruff_macros::ConfigurationOptions; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use crate::registry_gen::CheckCodePrefix; +use crate::registry::CheckCodePrefix; #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash, JsonSchema)] #[serde(deny_unknown_fields, rename_all = "kebab-case")] diff --git a/src/pyflakes/mod.rs b/src/pyflakes/mod.rs index 0bfcb8cdb4f43..8aba28c67dda0 100644 --- a/src/pyflakes/mod.rs +++ b/src/pyflakes/mod.rs @@ -16,8 +16,7 @@ mod tests { use textwrap::dedent; use crate::linter::{check_path, test_path}; - use crate::registry::CheckCode; - use crate::registry_gen::CheckCodePrefix; + use crate::registry::{CheckCode, CheckCodePrefix}; use crate::settings::flags; use crate::source_code_locator::SourceCodeLocator; use crate::source_code_style::SourceCodeStyleDetector; diff --git a/src/registry.rs b/src/registry.rs index c651c6186de91..39c963d60ca0c 100644 --- a/src/registry.rs +++ b/src/registry.rs @@ -4,6 +4,7 @@ use std::fmt; use itertools::Itertools; use once_cell::sync::Lazy; +use ruff_macros::CheckCodePrefix; use rustc_hash::FxHashMap; use rustpython_ast::Cmpop; use rustpython_parser::ast::Location; @@ -19,10 +20,10 @@ use crate::flake8_pytest_style::types::{ use crate::flake8_quotes::settings::Quote; use crate::flake8_tidy_imports::settings::Strictness; use crate::pyupgrade::types::Primitive; -use crate::registry_gen::CheckCodePrefix; #[derive( AsRefStr, + CheckCodePrefix, EnumIter, EnumString, Debug, @@ -4026,82 +4027,6 @@ pub const INCOMPATIBLE_CODES: &[(CheckCode, CheckCode, &str)] = &[( Consider adding `D203` to `ignore`.", )]; -/// A hash map from deprecated `CheckCodePrefix` to latest `CheckCodePrefix`. -pub static PREFIX_REDIRECTS: Lazy> = Lazy::new(|| { - FxHashMap::from_iter([ - // TODO(charlie): Remove by 2023-01-01. - ("U001", CheckCodePrefix::UP001), - ("U003", CheckCodePrefix::UP003), - ("U004", CheckCodePrefix::UP004), - ("U005", CheckCodePrefix::UP005), - ("U006", CheckCodePrefix::UP006), - ("U007", CheckCodePrefix::UP007), - ("U008", CheckCodePrefix::UP008), - ("U009", CheckCodePrefix::UP009), - ("U010", CheckCodePrefix::UP010), - ("U011", CheckCodePrefix::UP011), - ("U012", CheckCodePrefix::UP012), - ("U013", CheckCodePrefix::UP013), - ("U014", CheckCodePrefix::UP014), - ("U015", CheckCodePrefix::UP015), - ("U016", CheckCodePrefix::UP016), - ("U017", CheckCodePrefix::UP017), - ("U019", CheckCodePrefix::UP019), - // TODO(charlie): Remove by 2023-02-01. - ("I252", CheckCodePrefix::TID252), - ("M001", CheckCodePrefix::RUF100), - // TODO(charlie): Remove by 2023-02-01. - ("PDV002", CheckCodePrefix::PD002), - ("PDV003", CheckCodePrefix::PD003), - ("PDV004", CheckCodePrefix::PD004), - ("PDV007", CheckCodePrefix::PD007), - ("PDV008", CheckCodePrefix::PD008), - ("PDV009", CheckCodePrefix::PD009), - ("PDV010", CheckCodePrefix::PD010), - ("PDV011", CheckCodePrefix::PD011), - ("PDV012", CheckCodePrefix::PD012), - ("PDV013", CheckCodePrefix::PD013), - ("PDV015", CheckCodePrefix::PD015), - ("PDV901", CheckCodePrefix::PD901), - // TODO(charlie): Remove by 2023-02-01. - ("R501", CheckCodePrefix::RET501), - ("R502", CheckCodePrefix::RET502), - ("R503", CheckCodePrefix::RET503), - ("R504", CheckCodePrefix::RET504), - ("R505", CheckCodePrefix::RET505), - ("R506", CheckCodePrefix::RET506), - ("R507", CheckCodePrefix::RET507), - ("R508", CheckCodePrefix::RET508), - ("IC001", CheckCodePrefix::ICN001), - ("IC002", CheckCodePrefix::ICN001), - ("IC003", CheckCodePrefix::ICN001), - ("IC004", CheckCodePrefix::ICN001), - // TODO(charlie): Remove by 2023-01-01. - ("U", CheckCodePrefix::UP), - ("U0", CheckCodePrefix::UP0), - ("U00", CheckCodePrefix::UP00), - ("U01", CheckCodePrefix::UP01), - // TODO(charlie): Remove by 2023-02-01. - ("I2", CheckCodePrefix::TID2), - ("I25", CheckCodePrefix::TID25), - ("M", CheckCodePrefix::RUF100), - ("M0", CheckCodePrefix::RUF100), - // TODO(charlie): Remove by 2023-02-01. - ("PDV", CheckCodePrefix::PD), - ("PDV0", CheckCodePrefix::PD0), - ("PDV01", CheckCodePrefix::PD01), - ("PDV9", CheckCodePrefix::PD9), - ("PDV90", CheckCodePrefix::PD90), - // TODO(charlie): Remove by 2023-02-01. - ("R", CheckCodePrefix::RET), - ("R5", CheckCodePrefix::RET5), - ("R50", CheckCodePrefix::RET50), - // TODO(charlie): Remove by 2023-02-01. - ("IC", CheckCodePrefix::ICN), - ("IC0", CheckCodePrefix::ICN0), - ]) -}); - /// A hash map from deprecated to latest `CheckCode`. pub static CODE_REDIRECTS: Lazy> = Lazy::new(|| { FxHashMap::from_iter([ diff --git a/src/registry_gen.rs b/src/registry_gen.rs deleted file mode 100644 index 77f1803884b3a..0000000000000 --- a/src/registry_gen.rs +++ /dev/null @@ -1,3797 +0,0 @@ -//! File automatically generated by `examples/generate_check_code_prefix.rs`. - -use colored::Colorize; -use schemars::JsonSchema; -use serde::{Deserialize, Serialize}; -use strum_macros::{AsRefStr, EnumString}; - -use crate::one_time_warning; -use crate::registry::CheckCode; - -#[derive( - EnumString, - AsRefStr, - Debug, - PartialEq, - Eq, - PartialOrd, - Ord, - Clone, - Serialize, - Deserialize, - JsonSchema, -)] -pub enum CheckCodePrefix { - A, - A0, - A00, - A001, - A002, - A003, - ALL, - ANN, - ANN0, - ANN00, - ANN001, - ANN002, - ANN003, - ANN1, - ANN10, - ANN101, - ANN102, - ANN2, - ANN20, - ANN201, - ANN202, - ANN204, - ANN205, - ANN206, - ANN4, - ANN40, - ANN401, - ARG, - ARG0, - ARG00, - ARG001, - ARG002, - ARG003, - ARG004, - ARG005, - B, - B0, - B00, - B002, - B003, - B004, - B005, - B006, - B007, - B008, - B009, - B01, - B010, - B011, - B012, - B013, - B014, - B015, - B016, - B017, - B018, - B019, - B02, - B020, - B021, - B022, - B023, - B024, - B025, - B026, - B027, - B9, - B90, - B904, - B905, - BLE, - BLE0, - BLE00, - BLE001, - C, - C4, - C40, - C400, - C401, - C402, - C403, - C404, - C405, - C406, - C408, - C409, - C41, - C410, - C411, - C413, - C414, - C415, - C416, - C417, - C9, - C90, - C901, - D, - D1, - D10, - D100, - D101, - D102, - D103, - D104, - D105, - D106, - D107, - D2, - D20, - D200, - D201, - D202, - D203, - D204, - D205, - D206, - D207, - D208, - D209, - D21, - D210, - D211, - D212, - D213, - D214, - D215, - D3, - D30, - D300, - D301, - D4, - D40, - D400, - D402, - D403, - D404, - D405, - D406, - D407, - D408, - D409, - D41, - D410, - D411, - D412, - D413, - D414, - D415, - D416, - D417, - D418, - D419, - DTZ, - DTZ0, - DTZ00, - DTZ001, - DTZ002, - DTZ003, - DTZ004, - DTZ005, - DTZ006, - DTZ007, - DTZ01, - DTZ011, - DTZ012, - E, - E4, - E40, - E401, - E402, - E5, - E50, - E501, - E7, - E71, - E711, - E712, - E713, - E714, - E72, - E721, - E722, - E73, - E731, - E74, - E741, - E742, - E743, - E9, - E90, - E902, - E99, - E999, - EM, - EM1, - EM10, - EM101, - EM102, - EM103, - ERA, - ERA0, - ERA00, - ERA001, - F, - F4, - F40, - F401, - F402, - F403, - F404, - F405, - F406, - F407, - F5, - F50, - F501, - F502, - F503, - F504, - F505, - F506, - F507, - F508, - F509, - F52, - F521, - F522, - F523, - F524, - F525, - F54, - F541, - F6, - F60, - F601, - F602, - F62, - F621, - F622, - F63, - F631, - F632, - F633, - F634, - F7, - F70, - F701, - F702, - F704, - F706, - F707, - F72, - F722, - F8, - F81, - F811, - F82, - F821, - F822, - F823, - F84, - F841, - F842, - F9, - F90, - F901, - FBT, - FBT0, - FBT00, - FBT001, - FBT002, - FBT003, - I, - I0, - I00, - I001, - I2, - I25, - I252, - IC, - IC0, - IC001, - IC002, - IC003, - IC004, - ICN, - ICN0, - ICN00, - ICN001, - ISC, - ISC0, - ISC00, - ISC001, - ISC002, - ISC003, - M, - M0, - M001, - N, - N8, - N80, - N801, - N802, - N803, - N804, - N805, - N806, - N807, - N81, - N811, - N812, - N813, - N814, - N815, - N816, - N817, - N818, - PD, - PD0, - PD00, - PD002, - PD003, - PD004, - PD007, - PD008, - PD009, - PD01, - PD010, - PD011, - PD012, - PD013, - PD015, - PD9, - PD90, - PD901, - PDV, - PDV0, - PDV002, - PDV003, - PDV004, - PDV007, - PDV008, - PDV009, - PDV01, - PDV010, - PDV011, - PDV012, - PDV013, - PDV015, - PDV9, - PDV90, - PDV901, - PGH, - PGH0, - PGH00, - PGH001, - PGH002, - PGH003, - PGH004, - PIE, - PIE7, - PIE79, - PIE790, - PIE794, - PIE8, - PIE80, - PIE807, - PLC, - PLC0, - PLC04, - PLC041, - PLC0414, - PLC2, - PLC22, - PLC220, - PLC2201, - PLC3, - PLC30, - PLC300, - PLC3002, - PLE, - PLE0, - PLE01, - PLE011, - PLE0117, - PLE0118, - PLE1, - PLE11, - PLE114, - PLE1142, - PLR, - PLR0, - PLR02, - PLR020, - PLR0206, - PLR04, - PLR040, - PLR0402, - PLR1, - PLR17, - PLR170, - PLR1701, - PLR172, - PLR1722, - PLW, - PLW0, - PLW01, - PLW012, - PLW0120, - PLW06, - PLW060, - PLW0602, - PT, - PT0, - PT00, - PT001, - PT002, - PT003, - PT004, - PT005, - PT006, - PT007, - PT008, - PT009, - PT01, - PT010, - PT011, - PT012, - PT013, - PT015, - PT016, - PT017, - PT018, - PT019, - PT02, - PT020, - PT021, - PT022, - PT023, - PT024, - PT025, - PT026, - Q, - Q0, - Q00, - Q000, - Q001, - Q002, - Q003, - R, - R5, - R50, - R501, - R502, - R503, - R504, - R505, - R506, - R507, - R508, - RET, - RET5, - RET50, - RET501, - RET502, - RET503, - RET504, - RET505, - RET506, - RET507, - RET508, - RUF, - RUF0, - RUF00, - RUF001, - RUF002, - RUF003, - RUF004, - RUF1, - RUF10, - RUF100, - S, - S1, - S10, - S101, - S102, - S103, - S104, - S105, - S106, - S107, - S108, - SIM, - SIM1, - SIM10, - SIM102, - SIM105, - SIM107, - SIM11, - SIM110, - SIM111, - SIM117, - SIM118, - SIM2, - SIM22, - SIM220, - SIM221, - SIM222, - SIM223, - SIM3, - SIM30, - SIM300, - T, - T1, - T10, - T100, - T2, - T20, - T201, - T203, - TID, - TID2, - TID25, - TID251, - TID252, - U, - U0, - U00, - U001, - U003, - U004, - U005, - U006, - U007, - U008, - U009, - U01, - U010, - U011, - U012, - U013, - U014, - U015, - U016, - U017, - U019, - UP, - UP0, - UP00, - UP001, - UP003, - UP004, - UP005, - UP006, - UP007, - UP008, - UP009, - UP01, - UP010, - UP011, - UP012, - UP013, - UP014, - UP015, - UP016, - UP017, - UP018, - UP019, - UP02, - UP020, - UP021, - UP022, - UP023, - UP024, - UP025, - UP026, - UP027, - UP028, - UP029, - W, - W2, - W29, - W292, - W6, - W60, - W605, - YTT, - YTT1, - YTT10, - YTT101, - YTT102, - YTT103, - YTT2, - YTT20, - YTT201, - YTT202, - YTT203, - YTT204, - YTT3, - YTT30, - YTT301, - YTT302, - YTT303, -} - -#[derive(PartialEq, Eq, PartialOrd, Ord)] -pub enum SuffixLength { - None, - Zero, - One, - Two, - Three, - Four, -} - -impl CheckCodePrefix { - pub fn codes(&self) -> Vec { - #[allow(clippy::match_same_arms)] - match self { - CheckCodePrefix::A => vec![CheckCode::A001, CheckCode::A002, CheckCode::A003], - CheckCodePrefix::A0 => vec![CheckCode::A001, CheckCode::A002, CheckCode::A003], - CheckCodePrefix::A00 => vec![CheckCode::A001, CheckCode::A002, CheckCode::A003], - CheckCodePrefix::A001 => vec![CheckCode::A001], - CheckCodePrefix::A002 => vec![CheckCode::A002], - CheckCodePrefix::A003 => vec![CheckCode::A003], - CheckCodePrefix::ALL => vec![ - CheckCode::E401, - CheckCode::E402, - CheckCode::E501, - CheckCode::E711, - CheckCode::E712, - CheckCode::E713, - CheckCode::E714, - CheckCode::E721, - CheckCode::E722, - CheckCode::E731, - CheckCode::E741, - CheckCode::E742, - CheckCode::E743, - CheckCode::E902, - CheckCode::E999, - CheckCode::W292, - CheckCode::W605, - CheckCode::F401, - CheckCode::F402, - CheckCode::F403, - CheckCode::F404, - CheckCode::F405, - CheckCode::F406, - CheckCode::F407, - CheckCode::F501, - CheckCode::F502, - CheckCode::F503, - CheckCode::F504, - CheckCode::F505, - CheckCode::F506, - CheckCode::F507, - CheckCode::F508, - CheckCode::F509, - CheckCode::F521, - CheckCode::F522, - CheckCode::F523, - CheckCode::F524, - CheckCode::F525, - CheckCode::F541, - CheckCode::F601, - CheckCode::F602, - CheckCode::F621, - CheckCode::F622, - CheckCode::F631, - CheckCode::F632, - CheckCode::F633, - CheckCode::F634, - CheckCode::F701, - CheckCode::F702, - CheckCode::F704, - CheckCode::F706, - CheckCode::F707, - CheckCode::F722, - CheckCode::F811, - CheckCode::F821, - CheckCode::F822, - CheckCode::F823, - CheckCode::F841, - CheckCode::F842, - CheckCode::F901, - CheckCode::PLC0414, - CheckCode::PLC2201, - CheckCode::PLC3002, - CheckCode::PLE0117, - CheckCode::PLE0118, - CheckCode::PLE1142, - CheckCode::PLR0206, - CheckCode::PLR0402, - CheckCode::PLR1701, - CheckCode::PLR1722, - CheckCode::PLW0120, - CheckCode::PLW0602, - CheckCode::A001, - CheckCode::A002, - CheckCode::A003, - CheckCode::B002, - CheckCode::B003, - CheckCode::B004, - CheckCode::B005, - CheckCode::B006, - CheckCode::B007, - CheckCode::B008, - CheckCode::B009, - CheckCode::B010, - CheckCode::B011, - CheckCode::B012, - CheckCode::B013, - CheckCode::B014, - CheckCode::B015, - CheckCode::B016, - CheckCode::B017, - CheckCode::B018, - CheckCode::B019, - CheckCode::B020, - CheckCode::B021, - CheckCode::B022, - CheckCode::B023, - CheckCode::B024, - CheckCode::B025, - CheckCode::B026, - CheckCode::B027, - CheckCode::B904, - CheckCode::B905, - CheckCode::BLE001, - CheckCode::C400, - CheckCode::C401, - CheckCode::C402, - CheckCode::C403, - CheckCode::C404, - CheckCode::C405, - CheckCode::C406, - CheckCode::C408, - CheckCode::C409, - CheckCode::C410, - CheckCode::C411, - CheckCode::C413, - CheckCode::C414, - CheckCode::C415, - CheckCode::C416, - CheckCode::C417, - CheckCode::T100, - CheckCode::C901, - CheckCode::TID251, - CheckCode::TID252, - CheckCode::RET501, - CheckCode::RET502, - CheckCode::RET503, - CheckCode::RET504, - CheckCode::RET505, - CheckCode::RET506, - CheckCode::RET507, - CheckCode::RET508, - CheckCode::ISC001, - CheckCode::ISC002, - CheckCode::ISC003, - CheckCode::T201, - CheckCode::T203, - CheckCode::Q000, - CheckCode::Q001, - CheckCode::Q002, - CheckCode::Q003, - CheckCode::ANN001, - CheckCode::ANN002, - CheckCode::ANN003, - CheckCode::ANN101, - CheckCode::ANN102, - CheckCode::ANN201, - CheckCode::ANN202, - CheckCode::ANN204, - CheckCode::ANN205, - CheckCode::ANN206, - CheckCode::ANN401, - CheckCode::YTT101, - CheckCode::YTT102, - CheckCode::YTT103, - CheckCode::YTT201, - CheckCode::YTT202, - CheckCode::YTT203, - CheckCode::YTT204, - CheckCode::YTT301, - CheckCode::YTT302, - CheckCode::YTT303, - CheckCode::SIM102, - CheckCode::SIM105, - CheckCode::SIM107, - CheckCode::SIM110, - CheckCode::SIM111, - CheckCode::SIM117, - CheckCode::SIM118, - CheckCode::SIM220, - CheckCode::SIM221, - CheckCode::SIM222, - CheckCode::SIM223, - CheckCode::SIM300, - CheckCode::UP001, - CheckCode::UP003, - CheckCode::UP004, - CheckCode::UP005, - CheckCode::UP006, - CheckCode::UP007, - CheckCode::UP008, - CheckCode::UP009, - CheckCode::UP010, - CheckCode::UP011, - CheckCode::UP012, - CheckCode::UP013, - CheckCode::UP014, - CheckCode::UP015, - CheckCode::UP016, - CheckCode::UP017, - CheckCode::UP018, - CheckCode::UP019, - CheckCode::UP020, - CheckCode::UP021, - CheckCode::UP022, - CheckCode::UP023, - CheckCode::UP024, - CheckCode::UP025, - CheckCode::UP026, - CheckCode::UP027, - CheckCode::UP028, - CheckCode::UP029, - CheckCode::D100, - CheckCode::D101, - CheckCode::D102, - CheckCode::D103, - CheckCode::D104, - CheckCode::D105, - CheckCode::D106, - CheckCode::D107, - CheckCode::D200, - CheckCode::D201, - CheckCode::D202, - CheckCode::D203, - CheckCode::D204, - CheckCode::D205, - CheckCode::D206, - CheckCode::D207, - CheckCode::D208, - CheckCode::D209, - CheckCode::D210, - CheckCode::D211, - CheckCode::D212, - CheckCode::D213, - CheckCode::D214, - CheckCode::D215, - CheckCode::D300, - CheckCode::D301, - CheckCode::D400, - CheckCode::D402, - CheckCode::D403, - CheckCode::D404, - CheckCode::D405, - CheckCode::D406, - CheckCode::D407, - CheckCode::D408, - CheckCode::D409, - CheckCode::D410, - CheckCode::D411, - CheckCode::D412, - CheckCode::D413, - CheckCode::D414, - CheckCode::D415, - CheckCode::D416, - CheckCode::D417, - CheckCode::D418, - CheckCode::D419, - CheckCode::N801, - CheckCode::N802, - CheckCode::N803, - CheckCode::N804, - CheckCode::N805, - CheckCode::N806, - CheckCode::N807, - CheckCode::N811, - CheckCode::N812, - CheckCode::N813, - CheckCode::N814, - CheckCode::N815, - CheckCode::N816, - CheckCode::N817, - CheckCode::N818, - CheckCode::I001, - CheckCode::ERA001, - CheckCode::S101, - CheckCode::S102, - CheckCode::S103, - CheckCode::S104, - CheckCode::S105, - CheckCode::S106, - CheckCode::S107, - CheckCode::S108, - CheckCode::FBT001, - CheckCode::FBT002, - CheckCode::FBT003, - CheckCode::ARG001, - CheckCode::ARG002, - CheckCode::ARG003, - CheckCode::ARG004, - CheckCode::ARG005, - CheckCode::ICN001, - CheckCode::DTZ001, - CheckCode::DTZ002, - CheckCode::DTZ003, - CheckCode::DTZ004, - CheckCode::DTZ005, - CheckCode::DTZ006, - CheckCode::DTZ007, - CheckCode::DTZ011, - CheckCode::DTZ012, - CheckCode::PGH001, - CheckCode::PGH002, - CheckCode::PGH003, - CheckCode::PGH004, - CheckCode::PD002, - CheckCode::PD003, - CheckCode::PD004, - CheckCode::PD007, - CheckCode::PD008, - CheckCode::PD009, - CheckCode::PD010, - CheckCode::PD011, - CheckCode::PD012, - CheckCode::PD013, - CheckCode::PD015, - CheckCode::PD901, - CheckCode::EM101, - CheckCode::EM102, - CheckCode::EM103, - CheckCode::PT001, - CheckCode::PT002, - CheckCode::PT003, - CheckCode::PT004, - CheckCode::PT005, - CheckCode::PT006, - CheckCode::PT007, - CheckCode::PT008, - CheckCode::PT009, - CheckCode::PT010, - CheckCode::PT011, - CheckCode::PT012, - CheckCode::PT013, - CheckCode::PT015, - CheckCode::PT016, - CheckCode::PT017, - CheckCode::PT018, - CheckCode::PT019, - CheckCode::PT020, - CheckCode::PT021, - CheckCode::PT022, - CheckCode::PT023, - CheckCode::PT024, - CheckCode::PT025, - CheckCode::PT026, - CheckCode::PIE790, - CheckCode::PIE794, - CheckCode::PIE807, - CheckCode::RUF001, - CheckCode::RUF002, - CheckCode::RUF003, - CheckCode::RUF004, - CheckCode::RUF100, - ], - CheckCodePrefix::ANN => vec![ - CheckCode::ANN001, - CheckCode::ANN002, - CheckCode::ANN003, - CheckCode::ANN101, - CheckCode::ANN102, - CheckCode::ANN201, - CheckCode::ANN202, - CheckCode::ANN204, - CheckCode::ANN205, - CheckCode::ANN206, - CheckCode::ANN401, - ], - CheckCodePrefix::ANN0 => vec![CheckCode::ANN001, CheckCode::ANN002, CheckCode::ANN003], - CheckCodePrefix::ANN00 => vec![CheckCode::ANN001, CheckCode::ANN002, CheckCode::ANN003], - CheckCodePrefix::ANN001 => vec![CheckCode::ANN001], - CheckCodePrefix::ANN002 => vec![CheckCode::ANN002], - CheckCodePrefix::ANN003 => vec![CheckCode::ANN003], - CheckCodePrefix::ANN1 => vec![CheckCode::ANN101, CheckCode::ANN102], - CheckCodePrefix::ANN10 => vec![CheckCode::ANN101, CheckCode::ANN102], - CheckCodePrefix::ANN101 => vec![CheckCode::ANN101], - CheckCodePrefix::ANN102 => vec![CheckCode::ANN102], - CheckCodePrefix::ANN2 => vec![ - CheckCode::ANN201, - CheckCode::ANN202, - CheckCode::ANN204, - CheckCode::ANN205, - CheckCode::ANN206, - ], - CheckCodePrefix::ANN20 => vec![ - CheckCode::ANN201, - CheckCode::ANN202, - CheckCode::ANN204, - CheckCode::ANN205, - CheckCode::ANN206, - ], - CheckCodePrefix::ANN201 => vec![CheckCode::ANN201], - CheckCodePrefix::ANN202 => vec![CheckCode::ANN202], - CheckCodePrefix::ANN204 => vec![CheckCode::ANN204], - CheckCodePrefix::ANN205 => vec![CheckCode::ANN205], - CheckCodePrefix::ANN206 => vec![CheckCode::ANN206], - CheckCodePrefix::ANN4 => vec![CheckCode::ANN401], - CheckCodePrefix::ANN40 => vec![CheckCode::ANN401], - CheckCodePrefix::ANN401 => vec![CheckCode::ANN401], - CheckCodePrefix::ARG => vec![ - CheckCode::ARG001, - CheckCode::ARG002, - CheckCode::ARG003, - CheckCode::ARG004, - CheckCode::ARG005, - ], - CheckCodePrefix::ARG0 => vec![ - CheckCode::ARG001, - CheckCode::ARG002, - CheckCode::ARG003, - CheckCode::ARG004, - CheckCode::ARG005, - ], - CheckCodePrefix::ARG00 => vec![ - CheckCode::ARG001, - CheckCode::ARG002, - CheckCode::ARG003, - CheckCode::ARG004, - CheckCode::ARG005, - ], - CheckCodePrefix::ARG001 => vec![CheckCode::ARG001], - CheckCodePrefix::ARG002 => vec![CheckCode::ARG002], - CheckCodePrefix::ARG003 => vec![CheckCode::ARG003], - CheckCodePrefix::ARG004 => vec![CheckCode::ARG004], - CheckCodePrefix::ARG005 => vec![CheckCode::ARG005], - CheckCodePrefix::B => vec![ - CheckCode::B002, - CheckCode::B003, - CheckCode::B004, - CheckCode::B005, - CheckCode::B006, - CheckCode::B007, - CheckCode::B008, - CheckCode::B009, - CheckCode::B010, - CheckCode::B011, - CheckCode::B012, - CheckCode::B013, - CheckCode::B014, - CheckCode::B015, - CheckCode::B016, - CheckCode::B017, - CheckCode::B018, - CheckCode::B019, - CheckCode::B020, - CheckCode::B021, - CheckCode::B022, - CheckCode::B023, - CheckCode::B024, - CheckCode::B025, - CheckCode::B026, - CheckCode::B027, - CheckCode::B904, - CheckCode::B905, - ], - CheckCodePrefix::B0 => vec![ - CheckCode::B002, - CheckCode::B003, - CheckCode::B004, - CheckCode::B005, - CheckCode::B006, - CheckCode::B007, - CheckCode::B008, - CheckCode::B009, - CheckCode::B010, - CheckCode::B011, - CheckCode::B012, - CheckCode::B013, - CheckCode::B014, - CheckCode::B015, - CheckCode::B016, - CheckCode::B017, - CheckCode::B018, - CheckCode::B019, - CheckCode::B020, - CheckCode::B021, - CheckCode::B022, - CheckCode::B023, - CheckCode::B024, - CheckCode::B025, - CheckCode::B026, - CheckCode::B027, - ], - CheckCodePrefix::B00 => vec![ - CheckCode::B002, - CheckCode::B003, - CheckCode::B004, - CheckCode::B005, - CheckCode::B006, - CheckCode::B007, - CheckCode::B008, - CheckCode::B009, - ], - CheckCodePrefix::B002 => vec![CheckCode::B002], - CheckCodePrefix::B003 => vec![CheckCode::B003], - CheckCodePrefix::B004 => vec![CheckCode::B004], - CheckCodePrefix::B005 => vec![CheckCode::B005], - CheckCodePrefix::B006 => vec![CheckCode::B006], - CheckCodePrefix::B007 => vec![CheckCode::B007], - CheckCodePrefix::B008 => vec![CheckCode::B008], - CheckCodePrefix::B009 => vec![CheckCode::B009], - CheckCodePrefix::B01 => vec![ - CheckCode::B010, - CheckCode::B011, - CheckCode::B012, - CheckCode::B013, - CheckCode::B014, - CheckCode::B015, - CheckCode::B016, - CheckCode::B017, - CheckCode::B018, - CheckCode::B019, - ], - CheckCodePrefix::B010 => vec![CheckCode::B010], - CheckCodePrefix::B011 => vec![CheckCode::B011], - CheckCodePrefix::B012 => vec![CheckCode::B012], - CheckCodePrefix::B013 => vec![CheckCode::B013], - CheckCodePrefix::B014 => vec![CheckCode::B014], - CheckCodePrefix::B015 => vec![CheckCode::B015], - CheckCodePrefix::B016 => vec![CheckCode::B016], - CheckCodePrefix::B017 => vec![CheckCode::B017], - CheckCodePrefix::B018 => vec![CheckCode::B018], - CheckCodePrefix::B019 => vec![CheckCode::B019], - CheckCodePrefix::B02 => vec![ - CheckCode::B020, - CheckCode::B021, - CheckCode::B022, - CheckCode::B023, - CheckCode::B024, - CheckCode::B025, - CheckCode::B026, - CheckCode::B027, - ], - CheckCodePrefix::B020 => vec![CheckCode::B020], - CheckCodePrefix::B021 => vec![CheckCode::B021], - CheckCodePrefix::B022 => vec![CheckCode::B022], - CheckCodePrefix::B023 => vec![CheckCode::B023], - CheckCodePrefix::B024 => vec![CheckCode::B024], - CheckCodePrefix::B025 => vec![CheckCode::B025], - CheckCodePrefix::B026 => vec![CheckCode::B026], - CheckCodePrefix::B027 => vec![CheckCode::B027], - CheckCodePrefix::B9 => vec![CheckCode::B904, CheckCode::B905], - CheckCodePrefix::B90 => vec![CheckCode::B904, CheckCode::B905], - CheckCodePrefix::B904 => vec![CheckCode::B904], - CheckCodePrefix::B905 => vec![CheckCode::B905], - CheckCodePrefix::BLE => vec![CheckCode::BLE001], - CheckCodePrefix::BLE0 => vec![CheckCode::BLE001], - CheckCodePrefix::BLE00 => vec![CheckCode::BLE001], - CheckCodePrefix::BLE001 => vec![CheckCode::BLE001], - CheckCodePrefix::C => vec![ - CheckCode::C400, - CheckCode::C401, - CheckCode::C402, - CheckCode::C403, - CheckCode::C404, - CheckCode::C405, - CheckCode::C406, - CheckCode::C408, - CheckCode::C409, - CheckCode::C410, - CheckCode::C411, - CheckCode::C413, - CheckCode::C414, - CheckCode::C415, - CheckCode::C416, - CheckCode::C417, - CheckCode::C901, - ], - CheckCodePrefix::C4 => vec![ - CheckCode::C400, - CheckCode::C401, - CheckCode::C402, - CheckCode::C403, - CheckCode::C404, - CheckCode::C405, - CheckCode::C406, - CheckCode::C408, - CheckCode::C409, - CheckCode::C410, - CheckCode::C411, - CheckCode::C413, - CheckCode::C414, - CheckCode::C415, - CheckCode::C416, - CheckCode::C417, - ], - CheckCodePrefix::C40 => vec![ - CheckCode::C400, - CheckCode::C401, - CheckCode::C402, - CheckCode::C403, - CheckCode::C404, - CheckCode::C405, - CheckCode::C406, - CheckCode::C408, - CheckCode::C409, - ], - CheckCodePrefix::C400 => vec![CheckCode::C400], - CheckCodePrefix::C401 => vec![CheckCode::C401], - CheckCodePrefix::C402 => vec![CheckCode::C402], - CheckCodePrefix::C403 => vec![CheckCode::C403], - CheckCodePrefix::C404 => vec![CheckCode::C404], - CheckCodePrefix::C405 => vec![CheckCode::C405], - CheckCodePrefix::C406 => vec![CheckCode::C406], - CheckCodePrefix::C408 => vec![CheckCode::C408], - CheckCodePrefix::C409 => vec![CheckCode::C409], - CheckCodePrefix::C41 => vec![ - CheckCode::C410, - CheckCode::C411, - CheckCode::C413, - CheckCode::C414, - CheckCode::C415, - CheckCode::C416, - CheckCode::C417, - ], - CheckCodePrefix::C410 => vec![CheckCode::C410], - CheckCodePrefix::C411 => vec![CheckCode::C411], - CheckCodePrefix::C413 => vec![CheckCode::C413], - CheckCodePrefix::C414 => vec![CheckCode::C414], - CheckCodePrefix::C415 => vec![CheckCode::C415], - CheckCodePrefix::C416 => vec![CheckCode::C416], - CheckCodePrefix::C417 => vec![CheckCode::C417], - CheckCodePrefix::C9 => vec![CheckCode::C901], - CheckCodePrefix::C90 => vec![CheckCode::C901], - CheckCodePrefix::C901 => vec![CheckCode::C901], - CheckCodePrefix::D => vec![ - CheckCode::D100, - CheckCode::D101, - CheckCode::D102, - CheckCode::D103, - CheckCode::D104, - CheckCode::D105, - CheckCode::D106, - CheckCode::D107, - CheckCode::D200, - CheckCode::D201, - CheckCode::D202, - CheckCode::D203, - CheckCode::D204, - CheckCode::D205, - CheckCode::D206, - CheckCode::D207, - CheckCode::D208, - CheckCode::D209, - CheckCode::D210, - CheckCode::D211, - CheckCode::D212, - CheckCode::D213, - CheckCode::D214, - CheckCode::D215, - CheckCode::D300, - CheckCode::D301, - CheckCode::D400, - CheckCode::D402, - CheckCode::D403, - CheckCode::D404, - CheckCode::D405, - CheckCode::D406, - CheckCode::D407, - CheckCode::D408, - CheckCode::D409, - CheckCode::D410, - CheckCode::D411, - CheckCode::D412, - CheckCode::D413, - CheckCode::D414, - CheckCode::D415, - CheckCode::D416, - CheckCode::D417, - CheckCode::D418, - CheckCode::D419, - ], - CheckCodePrefix::D1 => vec![ - CheckCode::D100, - CheckCode::D101, - CheckCode::D102, - CheckCode::D103, - CheckCode::D104, - CheckCode::D105, - CheckCode::D106, - CheckCode::D107, - ], - CheckCodePrefix::D10 => vec![ - CheckCode::D100, - CheckCode::D101, - CheckCode::D102, - CheckCode::D103, - CheckCode::D104, - CheckCode::D105, - CheckCode::D106, - CheckCode::D107, - ], - CheckCodePrefix::D100 => vec![CheckCode::D100], - CheckCodePrefix::D101 => vec![CheckCode::D101], - CheckCodePrefix::D102 => vec![CheckCode::D102], - CheckCodePrefix::D103 => vec![CheckCode::D103], - CheckCodePrefix::D104 => vec![CheckCode::D104], - CheckCodePrefix::D105 => vec![CheckCode::D105], - CheckCodePrefix::D106 => vec![CheckCode::D106], - CheckCodePrefix::D107 => vec![CheckCode::D107], - CheckCodePrefix::D2 => vec![ - CheckCode::D200, - CheckCode::D201, - CheckCode::D202, - CheckCode::D203, - CheckCode::D204, - CheckCode::D205, - CheckCode::D206, - CheckCode::D207, - CheckCode::D208, - CheckCode::D209, - CheckCode::D210, - CheckCode::D211, - CheckCode::D212, - CheckCode::D213, - CheckCode::D214, - CheckCode::D215, - ], - CheckCodePrefix::D20 => vec![ - CheckCode::D200, - CheckCode::D201, - CheckCode::D202, - CheckCode::D203, - CheckCode::D204, - CheckCode::D205, - CheckCode::D206, - CheckCode::D207, - CheckCode::D208, - CheckCode::D209, - ], - CheckCodePrefix::D200 => vec![CheckCode::D200], - CheckCodePrefix::D201 => vec![CheckCode::D201], - CheckCodePrefix::D202 => vec![CheckCode::D202], - CheckCodePrefix::D203 => vec![CheckCode::D203], - CheckCodePrefix::D204 => vec![CheckCode::D204], - CheckCodePrefix::D205 => vec![CheckCode::D205], - CheckCodePrefix::D206 => vec![CheckCode::D206], - CheckCodePrefix::D207 => vec![CheckCode::D207], - CheckCodePrefix::D208 => vec![CheckCode::D208], - CheckCodePrefix::D209 => vec![CheckCode::D209], - CheckCodePrefix::D21 => vec![ - CheckCode::D210, - CheckCode::D211, - CheckCode::D212, - CheckCode::D213, - CheckCode::D214, - CheckCode::D215, - ], - CheckCodePrefix::D210 => vec![CheckCode::D210], - CheckCodePrefix::D211 => vec![CheckCode::D211], - CheckCodePrefix::D212 => vec![CheckCode::D212], - CheckCodePrefix::D213 => vec![CheckCode::D213], - CheckCodePrefix::D214 => vec![CheckCode::D214], - CheckCodePrefix::D215 => vec![CheckCode::D215], - CheckCodePrefix::D3 => vec![CheckCode::D300, CheckCode::D301], - CheckCodePrefix::D30 => vec![CheckCode::D300, CheckCode::D301], - CheckCodePrefix::D300 => vec![CheckCode::D300], - CheckCodePrefix::D301 => vec![CheckCode::D301], - CheckCodePrefix::D4 => vec![ - CheckCode::D400, - CheckCode::D402, - CheckCode::D403, - CheckCode::D404, - CheckCode::D405, - CheckCode::D406, - CheckCode::D407, - CheckCode::D408, - CheckCode::D409, - CheckCode::D410, - CheckCode::D411, - CheckCode::D412, - CheckCode::D413, - CheckCode::D414, - CheckCode::D415, - CheckCode::D416, - CheckCode::D417, - CheckCode::D418, - CheckCode::D419, - ], - CheckCodePrefix::D40 => vec![ - CheckCode::D400, - CheckCode::D402, - CheckCode::D403, - CheckCode::D404, - CheckCode::D405, - CheckCode::D406, - CheckCode::D407, - CheckCode::D408, - CheckCode::D409, - ], - CheckCodePrefix::D400 => vec![CheckCode::D400], - CheckCodePrefix::D402 => vec![CheckCode::D402], - CheckCodePrefix::D403 => vec![CheckCode::D403], - CheckCodePrefix::D404 => vec![CheckCode::D404], - CheckCodePrefix::D405 => vec![CheckCode::D405], - CheckCodePrefix::D406 => vec![CheckCode::D406], - CheckCodePrefix::D407 => vec![CheckCode::D407], - CheckCodePrefix::D408 => vec![CheckCode::D408], - CheckCodePrefix::D409 => vec![CheckCode::D409], - CheckCodePrefix::D41 => vec![ - CheckCode::D410, - CheckCode::D411, - CheckCode::D412, - CheckCode::D413, - CheckCode::D414, - CheckCode::D415, - CheckCode::D416, - CheckCode::D417, - CheckCode::D418, - CheckCode::D419, - ], - CheckCodePrefix::D410 => vec![CheckCode::D410], - CheckCodePrefix::D411 => vec![CheckCode::D411], - CheckCodePrefix::D412 => vec![CheckCode::D412], - CheckCodePrefix::D413 => vec![CheckCode::D413], - CheckCodePrefix::D414 => vec![CheckCode::D414], - CheckCodePrefix::D415 => vec![CheckCode::D415], - CheckCodePrefix::D416 => vec![CheckCode::D416], - CheckCodePrefix::D417 => vec![CheckCode::D417], - CheckCodePrefix::D418 => vec![CheckCode::D418], - CheckCodePrefix::D419 => vec![CheckCode::D419], - CheckCodePrefix::DTZ => vec![ - CheckCode::DTZ001, - CheckCode::DTZ002, - CheckCode::DTZ003, - CheckCode::DTZ004, - CheckCode::DTZ005, - CheckCode::DTZ006, - CheckCode::DTZ007, - CheckCode::DTZ011, - CheckCode::DTZ012, - ], - CheckCodePrefix::DTZ0 => vec![ - CheckCode::DTZ001, - CheckCode::DTZ002, - CheckCode::DTZ003, - CheckCode::DTZ004, - CheckCode::DTZ005, - CheckCode::DTZ006, - CheckCode::DTZ007, - CheckCode::DTZ011, - CheckCode::DTZ012, - ], - CheckCodePrefix::DTZ00 => vec![ - CheckCode::DTZ001, - CheckCode::DTZ002, - CheckCode::DTZ003, - CheckCode::DTZ004, - CheckCode::DTZ005, - CheckCode::DTZ006, - CheckCode::DTZ007, - ], - CheckCodePrefix::DTZ001 => vec![CheckCode::DTZ001], - CheckCodePrefix::DTZ002 => vec![CheckCode::DTZ002], - CheckCodePrefix::DTZ003 => vec![CheckCode::DTZ003], - CheckCodePrefix::DTZ004 => vec![CheckCode::DTZ004], - CheckCodePrefix::DTZ005 => vec![CheckCode::DTZ005], - CheckCodePrefix::DTZ006 => vec![CheckCode::DTZ006], - CheckCodePrefix::DTZ007 => vec![CheckCode::DTZ007], - CheckCodePrefix::DTZ01 => vec![CheckCode::DTZ011, CheckCode::DTZ012], - CheckCodePrefix::DTZ011 => vec![CheckCode::DTZ011], - CheckCodePrefix::DTZ012 => vec![CheckCode::DTZ012], - CheckCodePrefix::E => vec![ - CheckCode::E401, - CheckCode::E402, - CheckCode::E501, - CheckCode::E711, - CheckCode::E712, - CheckCode::E713, - CheckCode::E714, - CheckCode::E721, - CheckCode::E722, - CheckCode::E731, - CheckCode::E741, - CheckCode::E742, - CheckCode::E743, - CheckCode::E902, - CheckCode::E999, - ], - CheckCodePrefix::E4 => vec![CheckCode::E401, CheckCode::E402], - CheckCodePrefix::E40 => vec![CheckCode::E401, CheckCode::E402], - CheckCodePrefix::E401 => vec![CheckCode::E401], - CheckCodePrefix::E402 => vec![CheckCode::E402], - CheckCodePrefix::E5 => vec![CheckCode::E501], - CheckCodePrefix::E50 => vec![CheckCode::E501], - CheckCodePrefix::E501 => vec![CheckCode::E501], - CheckCodePrefix::E7 => vec![ - CheckCode::E711, - CheckCode::E712, - CheckCode::E713, - CheckCode::E714, - CheckCode::E721, - CheckCode::E722, - CheckCode::E731, - CheckCode::E741, - CheckCode::E742, - CheckCode::E743, - ], - CheckCodePrefix::E71 => vec![ - CheckCode::E711, - CheckCode::E712, - CheckCode::E713, - CheckCode::E714, - ], - CheckCodePrefix::E711 => vec![CheckCode::E711], - CheckCodePrefix::E712 => vec![CheckCode::E712], - CheckCodePrefix::E713 => vec![CheckCode::E713], - CheckCodePrefix::E714 => vec![CheckCode::E714], - CheckCodePrefix::E72 => vec![CheckCode::E721, CheckCode::E722], - CheckCodePrefix::E721 => vec![CheckCode::E721], - CheckCodePrefix::E722 => vec![CheckCode::E722], - CheckCodePrefix::E73 => vec![CheckCode::E731], - CheckCodePrefix::E731 => vec![CheckCode::E731], - CheckCodePrefix::E74 => vec![CheckCode::E741, CheckCode::E742, CheckCode::E743], - CheckCodePrefix::E741 => vec![CheckCode::E741], - CheckCodePrefix::E742 => vec![CheckCode::E742], - CheckCodePrefix::E743 => vec![CheckCode::E743], - CheckCodePrefix::E9 => vec![CheckCode::E902, CheckCode::E999], - CheckCodePrefix::E90 => vec![CheckCode::E902], - CheckCodePrefix::E902 => vec![CheckCode::E902], - CheckCodePrefix::E99 => vec![CheckCode::E999], - CheckCodePrefix::E999 => vec![CheckCode::E999], - CheckCodePrefix::EM => vec![CheckCode::EM101, CheckCode::EM102, CheckCode::EM103], - CheckCodePrefix::EM1 => vec![CheckCode::EM101, CheckCode::EM102, CheckCode::EM103], - CheckCodePrefix::EM10 => vec![CheckCode::EM101, CheckCode::EM102, CheckCode::EM103], - CheckCodePrefix::EM101 => vec![CheckCode::EM101], - CheckCodePrefix::EM102 => vec![CheckCode::EM102], - CheckCodePrefix::EM103 => vec![CheckCode::EM103], - CheckCodePrefix::ERA => vec![CheckCode::ERA001], - CheckCodePrefix::ERA0 => vec![CheckCode::ERA001], - CheckCodePrefix::ERA00 => vec![CheckCode::ERA001], - CheckCodePrefix::ERA001 => vec![CheckCode::ERA001], - CheckCodePrefix::F => vec![ - CheckCode::F401, - CheckCode::F402, - CheckCode::F403, - CheckCode::F404, - CheckCode::F405, - CheckCode::F406, - CheckCode::F407, - CheckCode::F501, - CheckCode::F502, - CheckCode::F503, - CheckCode::F504, - CheckCode::F505, - CheckCode::F506, - CheckCode::F507, - CheckCode::F508, - CheckCode::F509, - CheckCode::F521, - CheckCode::F522, - CheckCode::F523, - CheckCode::F524, - CheckCode::F525, - CheckCode::F541, - CheckCode::F601, - CheckCode::F602, - CheckCode::F621, - CheckCode::F622, - CheckCode::F631, - CheckCode::F632, - CheckCode::F633, - CheckCode::F634, - CheckCode::F701, - CheckCode::F702, - CheckCode::F704, - CheckCode::F706, - CheckCode::F707, - CheckCode::F722, - CheckCode::F811, - CheckCode::F821, - CheckCode::F822, - CheckCode::F823, - CheckCode::F841, - CheckCode::F842, - CheckCode::F901, - ], - CheckCodePrefix::F4 => vec![ - CheckCode::F401, - CheckCode::F402, - CheckCode::F403, - CheckCode::F404, - CheckCode::F405, - CheckCode::F406, - CheckCode::F407, - ], - CheckCodePrefix::F40 => vec![ - CheckCode::F401, - CheckCode::F402, - CheckCode::F403, - CheckCode::F404, - CheckCode::F405, - CheckCode::F406, - CheckCode::F407, - ], - CheckCodePrefix::F401 => vec![CheckCode::F401], - CheckCodePrefix::F402 => vec![CheckCode::F402], - CheckCodePrefix::F403 => vec![CheckCode::F403], - CheckCodePrefix::F404 => vec![CheckCode::F404], - CheckCodePrefix::F405 => vec![CheckCode::F405], - CheckCodePrefix::F406 => vec![CheckCode::F406], - CheckCodePrefix::F407 => vec![CheckCode::F407], - CheckCodePrefix::F5 => vec![ - CheckCode::F501, - CheckCode::F502, - CheckCode::F503, - CheckCode::F504, - CheckCode::F505, - CheckCode::F506, - CheckCode::F507, - CheckCode::F508, - CheckCode::F509, - CheckCode::F521, - CheckCode::F522, - CheckCode::F523, - CheckCode::F524, - CheckCode::F525, - CheckCode::F541, - ], - CheckCodePrefix::F50 => vec![ - CheckCode::F501, - CheckCode::F502, - CheckCode::F503, - CheckCode::F504, - CheckCode::F505, - CheckCode::F506, - CheckCode::F507, - CheckCode::F508, - CheckCode::F509, - ], - CheckCodePrefix::F501 => vec![CheckCode::F501], - CheckCodePrefix::F502 => vec![CheckCode::F502], - CheckCodePrefix::F503 => vec![CheckCode::F503], - CheckCodePrefix::F504 => vec![CheckCode::F504], - CheckCodePrefix::F505 => vec![CheckCode::F505], - CheckCodePrefix::F506 => vec![CheckCode::F506], - CheckCodePrefix::F507 => vec![CheckCode::F507], - CheckCodePrefix::F508 => vec![CheckCode::F508], - CheckCodePrefix::F509 => vec![CheckCode::F509], - CheckCodePrefix::F52 => vec![ - CheckCode::F521, - CheckCode::F522, - CheckCode::F523, - CheckCode::F524, - CheckCode::F525, - ], - CheckCodePrefix::F521 => vec![CheckCode::F521], - CheckCodePrefix::F522 => vec![CheckCode::F522], - CheckCodePrefix::F523 => vec![CheckCode::F523], - CheckCodePrefix::F524 => vec![CheckCode::F524], - CheckCodePrefix::F525 => vec![CheckCode::F525], - CheckCodePrefix::F54 => vec![CheckCode::F541], - CheckCodePrefix::F541 => vec![CheckCode::F541], - CheckCodePrefix::F6 => vec![ - CheckCode::F601, - CheckCode::F602, - CheckCode::F621, - CheckCode::F622, - CheckCode::F631, - CheckCode::F632, - CheckCode::F633, - CheckCode::F634, - ], - CheckCodePrefix::F60 => vec![CheckCode::F601, CheckCode::F602], - CheckCodePrefix::F601 => vec![CheckCode::F601], - CheckCodePrefix::F602 => vec![CheckCode::F602], - CheckCodePrefix::F62 => vec![CheckCode::F621, CheckCode::F622], - CheckCodePrefix::F621 => vec![CheckCode::F621], - CheckCodePrefix::F622 => vec![CheckCode::F622], - CheckCodePrefix::F63 => vec![ - CheckCode::F631, - CheckCode::F632, - CheckCode::F633, - CheckCode::F634, - ], - CheckCodePrefix::F631 => vec![CheckCode::F631], - CheckCodePrefix::F632 => vec![CheckCode::F632], - CheckCodePrefix::F633 => vec![CheckCode::F633], - CheckCodePrefix::F634 => vec![CheckCode::F634], - CheckCodePrefix::F7 => vec![ - CheckCode::F701, - CheckCode::F702, - CheckCode::F704, - CheckCode::F706, - CheckCode::F707, - CheckCode::F722, - ], - CheckCodePrefix::F70 => vec![ - CheckCode::F701, - CheckCode::F702, - CheckCode::F704, - CheckCode::F706, - CheckCode::F707, - ], - CheckCodePrefix::F701 => vec![CheckCode::F701], - CheckCodePrefix::F702 => vec![CheckCode::F702], - CheckCodePrefix::F704 => vec![CheckCode::F704], - CheckCodePrefix::F706 => vec![CheckCode::F706], - CheckCodePrefix::F707 => vec![CheckCode::F707], - CheckCodePrefix::F72 => vec![CheckCode::F722], - CheckCodePrefix::F722 => vec![CheckCode::F722], - CheckCodePrefix::F8 => vec![ - CheckCode::F811, - CheckCode::F821, - CheckCode::F822, - CheckCode::F823, - CheckCode::F841, - CheckCode::F842, - ], - CheckCodePrefix::F81 => vec![CheckCode::F811], - CheckCodePrefix::F811 => vec![CheckCode::F811], - CheckCodePrefix::F82 => vec![CheckCode::F821, CheckCode::F822, CheckCode::F823], - CheckCodePrefix::F821 => vec![CheckCode::F821], - CheckCodePrefix::F822 => vec![CheckCode::F822], - CheckCodePrefix::F823 => vec![CheckCode::F823], - CheckCodePrefix::F84 => vec![CheckCode::F841, CheckCode::F842], - CheckCodePrefix::F841 => vec![CheckCode::F841], - CheckCodePrefix::F842 => vec![CheckCode::F842], - CheckCodePrefix::F9 => vec![CheckCode::F901], - CheckCodePrefix::F90 => vec![CheckCode::F901], - CheckCodePrefix::F901 => vec![CheckCode::F901], - CheckCodePrefix::FBT => vec![CheckCode::FBT001, CheckCode::FBT002, CheckCode::FBT003], - CheckCodePrefix::FBT0 => vec![CheckCode::FBT001, CheckCode::FBT002, CheckCode::FBT003], - CheckCodePrefix::FBT00 => vec![CheckCode::FBT001, CheckCode::FBT002, CheckCode::FBT003], - CheckCodePrefix::FBT001 => vec![CheckCode::FBT001], - CheckCodePrefix::FBT002 => vec![CheckCode::FBT002], - CheckCodePrefix::FBT003 => vec![CheckCode::FBT003], - CheckCodePrefix::I => vec![CheckCode::I001], - CheckCodePrefix::I0 => vec![CheckCode::I001], - CheckCodePrefix::I00 => vec![CheckCode::I001], - CheckCodePrefix::I001 => vec![CheckCode::I001], - CheckCodePrefix::I2 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`I2` has been remapped to `TID2`".bold() - ); - vec![CheckCode::TID251, CheckCode::TID252] - } - CheckCodePrefix::I25 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`I25` has been remapped to `TID25`".bold() - ); - vec![CheckCode::TID251, CheckCode::TID252] - } - CheckCodePrefix::I252 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`I252` has been remapped to `TID252`".bold() - ); - vec![CheckCode::TID252] - } - CheckCodePrefix::IC => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`IC` has been remapped to `ICN`".bold() - ); - vec![CheckCode::ICN001] - } - CheckCodePrefix::IC0 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`IC0` has been remapped to `ICN0`".bold() - ); - vec![CheckCode::ICN001] - } - CheckCodePrefix::IC001 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`IC001` has been remapped to `ICN001`".bold() - ); - vec![CheckCode::ICN001] - } - CheckCodePrefix::IC002 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`IC002` has been remapped to `ICN001`".bold() - ); - vec![CheckCode::ICN001] - } - CheckCodePrefix::IC003 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`IC003` has been remapped to `ICN001`".bold() - ); - vec![CheckCode::ICN001] - } - CheckCodePrefix::IC004 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`IC004` has been remapped to `ICN001`".bold() - ); - vec![CheckCode::ICN001] - } - CheckCodePrefix::ICN => vec![CheckCode::ICN001], - CheckCodePrefix::ICN0 => vec![CheckCode::ICN001], - CheckCodePrefix::ICN00 => vec![CheckCode::ICN001], - CheckCodePrefix::ICN001 => vec![CheckCode::ICN001], - CheckCodePrefix::ISC => vec![CheckCode::ISC001, CheckCode::ISC002, CheckCode::ISC003], - CheckCodePrefix::ISC0 => vec![CheckCode::ISC001, CheckCode::ISC002, CheckCode::ISC003], - CheckCodePrefix::ISC00 => vec![CheckCode::ISC001, CheckCode::ISC002, CheckCode::ISC003], - CheckCodePrefix::ISC001 => vec![CheckCode::ISC001], - CheckCodePrefix::ISC002 => vec![CheckCode::ISC002], - CheckCodePrefix::ISC003 => vec![CheckCode::ISC003], - CheckCodePrefix::M => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`M` has been remapped to `RUF100`".bold() - ); - vec![CheckCode::RUF100] - } - CheckCodePrefix::M0 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`M0` has been remapped to `RUF100`".bold() - ); - vec![CheckCode::RUF100] - } - CheckCodePrefix::M001 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`M001` has been remapped to `RUF100`".bold() - ); - vec![CheckCode::RUF100] - } - CheckCodePrefix::N => vec![ - CheckCode::N801, - CheckCode::N802, - CheckCode::N803, - CheckCode::N804, - CheckCode::N805, - CheckCode::N806, - CheckCode::N807, - CheckCode::N811, - CheckCode::N812, - CheckCode::N813, - CheckCode::N814, - CheckCode::N815, - CheckCode::N816, - CheckCode::N817, - CheckCode::N818, - ], - CheckCodePrefix::N8 => vec![ - CheckCode::N801, - CheckCode::N802, - CheckCode::N803, - CheckCode::N804, - CheckCode::N805, - CheckCode::N806, - CheckCode::N807, - CheckCode::N811, - CheckCode::N812, - CheckCode::N813, - CheckCode::N814, - CheckCode::N815, - CheckCode::N816, - CheckCode::N817, - CheckCode::N818, - ], - CheckCodePrefix::N80 => vec![ - CheckCode::N801, - CheckCode::N802, - CheckCode::N803, - CheckCode::N804, - CheckCode::N805, - CheckCode::N806, - CheckCode::N807, - ], - CheckCodePrefix::N801 => vec![CheckCode::N801], - CheckCodePrefix::N802 => vec![CheckCode::N802], - CheckCodePrefix::N803 => vec![CheckCode::N803], - CheckCodePrefix::N804 => vec![CheckCode::N804], - CheckCodePrefix::N805 => vec![CheckCode::N805], - CheckCodePrefix::N806 => vec![CheckCode::N806], - CheckCodePrefix::N807 => vec![CheckCode::N807], - CheckCodePrefix::N81 => vec![ - CheckCode::N811, - CheckCode::N812, - CheckCode::N813, - CheckCode::N814, - CheckCode::N815, - CheckCode::N816, - CheckCode::N817, - CheckCode::N818, - ], - CheckCodePrefix::N811 => vec![CheckCode::N811], - CheckCodePrefix::N812 => vec![CheckCode::N812], - CheckCodePrefix::N813 => vec![CheckCode::N813], - CheckCodePrefix::N814 => vec![CheckCode::N814], - CheckCodePrefix::N815 => vec![CheckCode::N815], - CheckCodePrefix::N816 => vec![CheckCode::N816], - CheckCodePrefix::N817 => vec![CheckCode::N817], - CheckCodePrefix::N818 => vec![CheckCode::N818], - CheckCodePrefix::PD => vec![ - CheckCode::PD002, - CheckCode::PD003, - CheckCode::PD004, - CheckCode::PD007, - CheckCode::PD008, - CheckCode::PD009, - CheckCode::PD010, - CheckCode::PD011, - CheckCode::PD012, - CheckCode::PD013, - CheckCode::PD015, - CheckCode::PD901, - ], - CheckCodePrefix::PD0 => vec![ - CheckCode::PD002, - CheckCode::PD003, - CheckCode::PD004, - CheckCode::PD007, - CheckCode::PD008, - CheckCode::PD009, - CheckCode::PD010, - CheckCode::PD011, - CheckCode::PD012, - CheckCode::PD013, - CheckCode::PD015, - ], - CheckCodePrefix::PD00 => vec![ - CheckCode::PD002, - CheckCode::PD003, - CheckCode::PD004, - CheckCode::PD007, - CheckCode::PD008, - CheckCode::PD009, - ], - CheckCodePrefix::PD002 => vec![CheckCode::PD002], - CheckCodePrefix::PD003 => vec![CheckCode::PD003], - CheckCodePrefix::PD004 => vec![CheckCode::PD004], - CheckCodePrefix::PD007 => vec![CheckCode::PD007], - CheckCodePrefix::PD008 => vec![CheckCode::PD008], - CheckCodePrefix::PD009 => vec![CheckCode::PD009], - CheckCodePrefix::PD01 => vec![ - CheckCode::PD010, - CheckCode::PD011, - CheckCode::PD012, - CheckCode::PD013, - CheckCode::PD015, - ], - CheckCodePrefix::PD010 => vec![CheckCode::PD010], - CheckCodePrefix::PD011 => vec![CheckCode::PD011], - CheckCodePrefix::PD012 => vec![CheckCode::PD012], - CheckCodePrefix::PD013 => vec![CheckCode::PD013], - CheckCodePrefix::PD015 => vec![CheckCode::PD015], - CheckCodePrefix::PD9 => vec![CheckCode::PD901], - CheckCodePrefix::PD90 => vec![CheckCode::PD901], - CheckCodePrefix::PD901 => vec![CheckCode::PD901], - CheckCodePrefix::PDV => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV` has been remapped to `PD`".bold() - ); - vec![ - CheckCode::PD002, - CheckCode::PD003, - CheckCode::PD004, - CheckCode::PD007, - CheckCode::PD008, - CheckCode::PD009, - CheckCode::PD010, - CheckCode::PD011, - CheckCode::PD012, - CheckCode::PD013, - CheckCode::PD015, - CheckCode::PD901, - ] - } - CheckCodePrefix::PDV0 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV0` has been remapped to `PD0`".bold() - ); - vec![ - CheckCode::PD002, - CheckCode::PD003, - CheckCode::PD004, - CheckCode::PD007, - CheckCode::PD008, - CheckCode::PD009, - CheckCode::PD010, - CheckCode::PD011, - CheckCode::PD012, - CheckCode::PD013, - CheckCode::PD015, - ] - } - CheckCodePrefix::PDV002 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV002` has been remapped to `PD002`".bold() - ); - vec![CheckCode::PD002] - } - CheckCodePrefix::PDV003 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV003` has been remapped to `PD003`".bold() - ); - vec![CheckCode::PD003] - } - CheckCodePrefix::PDV004 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV004` has been remapped to `PD004`".bold() - ); - vec![CheckCode::PD004] - } - CheckCodePrefix::PDV007 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV007` has been remapped to `PD007`".bold() - ); - vec![CheckCode::PD007] - } - CheckCodePrefix::PDV008 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV008` has been remapped to `PD008`".bold() - ); - vec![CheckCode::PD008] - } - CheckCodePrefix::PDV009 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV009` has been remapped to `PD009`".bold() - ); - vec![CheckCode::PD009] - } - CheckCodePrefix::PDV01 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV01` has been remapped to `PD01`".bold() - ); - vec![ - CheckCode::PD010, - CheckCode::PD011, - CheckCode::PD012, - CheckCode::PD013, - CheckCode::PD015, - ] - } - CheckCodePrefix::PDV010 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV010` has been remapped to `PD010`".bold() - ); - vec![CheckCode::PD010] - } - CheckCodePrefix::PDV011 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV011` has been remapped to `PD011`".bold() - ); - vec![CheckCode::PD011] - } - CheckCodePrefix::PDV012 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV012` has been remapped to `PD012`".bold() - ); - vec![CheckCode::PD012] - } - CheckCodePrefix::PDV013 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV013` has been remapped to `PD013`".bold() - ); - vec![CheckCode::PD013] - } - CheckCodePrefix::PDV015 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV015` has been remapped to `PD015`".bold() - ); - vec![CheckCode::PD015] - } - CheckCodePrefix::PDV9 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV9` has been remapped to `PD9`".bold() - ); - vec![CheckCode::PD901] - } - CheckCodePrefix::PDV90 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV90` has been remapped to `PD90`".bold() - ); - vec![CheckCode::PD901] - } - CheckCodePrefix::PDV901 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`PDV901` has been remapped to `PD901`".bold() - ); - vec![CheckCode::PD901] - } - CheckCodePrefix::PGH => vec![ - CheckCode::PGH001, - CheckCode::PGH002, - CheckCode::PGH003, - CheckCode::PGH004, - ], - CheckCodePrefix::PGH0 => vec![ - CheckCode::PGH001, - CheckCode::PGH002, - CheckCode::PGH003, - CheckCode::PGH004, - ], - CheckCodePrefix::PGH00 => vec![ - CheckCode::PGH001, - CheckCode::PGH002, - CheckCode::PGH003, - CheckCode::PGH004, - ], - CheckCodePrefix::PGH001 => vec![CheckCode::PGH001], - CheckCodePrefix::PGH002 => vec![CheckCode::PGH002], - CheckCodePrefix::PGH003 => vec![CheckCode::PGH003], - CheckCodePrefix::PGH004 => vec![CheckCode::PGH004], - CheckCodePrefix::PIE => vec![CheckCode::PIE790, CheckCode::PIE794, CheckCode::PIE807], - CheckCodePrefix::PIE7 => vec![CheckCode::PIE790, CheckCode::PIE794], - CheckCodePrefix::PIE79 => vec![CheckCode::PIE790, CheckCode::PIE794], - CheckCodePrefix::PIE790 => vec![CheckCode::PIE790], - CheckCodePrefix::PIE794 => vec![CheckCode::PIE794], - CheckCodePrefix::PIE8 => vec![CheckCode::PIE807], - CheckCodePrefix::PIE80 => vec![CheckCode::PIE807], - CheckCodePrefix::PIE807 => vec![CheckCode::PIE807], - CheckCodePrefix::PLC => { - vec![CheckCode::PLC0414, CheckCode::PLC2201, CheckCode::PLC3002] - } - CheckCodePrefix::PLC0 => vec![CheckCode::PLC0414], - CheckCodePrefix::PLC04 => vec![CheckCode::PLC0414], - CheckCodePrefix::PLC041 => vec![CheckCode::PLC0414], - CheckCodePrefix::PLC0414 => vec![CheckCode::PLC0414], - CheckCodePrefix::PLC2 => vec![CheckCode::PLC2201], - CheckCodePrefix::PLC22 => vec![CheckCode::PLC2201], - CheckCodePrefix::PLC220 => vec![CheckCode::PLC2201], - CheckCodePrefix::PLC2201 => vec![CheckCode::PLC2201], - CheckCodePrefix::PLC3 => vec![CheckCode::PLC3002], - CheckCodePrefix::PLC30 => vec![CheckCode::PLC3002], - CheckCodePrefix::PLC300 => vec![CheckCode::PLC3002], - CheckCodePrefix::PLC3002 => vec![CheckCode::PLC3002], - CheckCodePrefix::PLE => { - vec![CheckCode::PLE0117, CheckCode::PLE0118, CheckCode::PLE1142] - } - CheckCodePrefix::PLE0 => vec![CheckCode::PLE0117, CheckCode::PLE0118], - CheckCodePrefix::PLE01 => vec![CheckCode::PLE0117, CheckCode::PLE0118], - CheckCodePrefix::PLE011 => vec![CheckCode::PLE0117, CheckCode::PLE0118], - CheckCodePrefix::PLE0117 => vec![CheckCode::PLE0117], - CheckCodePrefix::PLE0118 => vec![CheckCode::PLE0118], - CheckCodePrefix::PLE1 => vec![CheckCode::PLE1142], - CheckCodePrefix::PLE11 => vec![CheckCode::PLE1142], - CheckCodePrefix::PLE114 => vec![CheckCode::PLE1142], - CheckCodePrefix::PLE1142 => vec![CheckCode::PLE1142], - CheckCodePrefix::PLR => vec![ - CheckCode::PLR0206, - CheckCode::PLR0402, - CheckCode::PLR1701, - CheckCode::PLR1722, - ], - CheckCodePrefix::PLR0 => vec![CheckCode::PLR0206, CheckCode::PLR0402], - CheckCodePrefix::PLR02 => vec![CheckCode::PLR0206], - CheckCodePrefix::PLR020 => vec![CheckCode::PLR0206], - CheckCodePrefix::PLR0206 => vec![CheckCode::PLR0206], - CheckCodePrefix::PLR04 => vec![CheckCode::PLR0402], - CheckCodePrefix::PLR040 => vec![CheckCode::PLR0402], - CheckCodePrefix::PLR0402 => vec![CheckCode::PLR0402], - CheckCodePrefix::PLR1 => vec![CheckCode::PLR1701, CheckCode::PLR1722], - CheckCodePrefix::PLR17 => vec![CheckCode::PLR1701, CheckCode::PLR1722], - CheckCodePrefix::PLR170 => vec![CheckCode::PLR1701], - CheckCodePrefix::PLR1701 => vec![CheckCode::PLR1701], - CheckCodePrefix::PLR172 => vec![CheckCode::PLR1722], - CheckCodePrefix::PLR1722 => vec![CheckCode::PLR1722], - CheckCodePrefix::PLW => vec![CheckCode::PLW0120, CheckCode::PLW0602], - CheckCodePrefix::PLW0 => vec![CheckCode::PLW0120, CheckCode::PLW0602], - CheckCodePrefix::PLW01 => vec![CheckCode::PLW0120], - CheckCodePrefix::PLW012 => vec![CheckCode::PLW0120], - CheckCodePrefix::PLW0120 => vec![CheckCode::PLW0120], - CheckCodePrefix::PLW06 => vec![CheckCode::PLW0602], - CheckCodePrefix::PLW060 => vec![CheckCode::PLW0602], - CheckCodePrefix::PLW0602 => vec![CheckCode::PLW0602], - CheckCodePrefix::PT => vec![ - CheckCode::PT001, - CheckCode::PT002, - CheckCode::PT003, - CheckCode::PT004, - CheckCode::PT005, - CheckCode::PT006, - CheckCode::PT007, - CheckCode::PT008, - CheckCode::PT009, - CheckCode::PT010, - CheckCode::PT011, - CheckCode::PT012, - CheckCode::PT013, - CheckCode::PT015, - CheckCode::PT016, - CheckCode::PT017, - CheckCode::PT018, - CheckCode::PT019, - CheckCode::PT020, - CheckCode::PT021, - CheckCode::PT022, - CheckCode::PT023, - CheckCode::PT024, - CheckCode::PT025, - CheckCode::PT026, - ], - CheckCodePrefix::PT0 => vec![ - CheckCode::PT001, - CheckCode::PT002, - CheckCode::PT003, - CheckCode::PT004, - CheckCode::PT005, - CheckCode::PT006, - CheckCode::PT007, - CheckCode::PT008, - CheckCode::PT009, - CheckCode::PT010, - CheckCode::PT011, - CheckCode::PT012, - CheckCode::PT013, - CheckCode::PT015, - CheckCode::PT016, - CheckCode::PT017, - CheckCode::PT018, - CheckCode::PT019, - CheckCode::PT020, - CheckCode::PT021, - CheckCode::PT022, - CheckCode::PT023, - CheckCode::PT024, - CheckCode::PT025, - CheckCode::PT026, - ], - CheckCodePrefix::PT00 => vec![ - CheckCode::PT001, - CheckCode::PT002, - CheckCode::PT003, - CheckCode::PT004, - CheckCode::PT005, - CheckCode::PT006, - CheckCode::PT007, - CheckCode::PT008, - CheckCode::PT009, - ], - CheckCodePrefix::PT001 => vec![CheckCode::PT001], - CheckCodePrefix::PT002 => vec![CheckCode::PT002], - CheckCodePrefix::PT003 => vec![CheckCode::PT003], - CheckCodePrefix::PT004 => vec![CheckCode::PT004], - CheckCodePrefix::PT005 => vec![CheckCode::PT005], - CheckCodePrefix::PT006 => vec![CheckCode::PT006], - CheckCodePrefix::PT007 => vec![CheckCode::PT007], - CheckCodePrefix::PT008 => vec![CheckCode::PT008], - CheckCodePrefix::PT009 => vec![CheckCode::PT009], - CheckCodePrefix::PT01 => vec![ - CheckCode::PT010, - CheckCode::PT011, - CheckCode::PT012, - CheckCode::PT013, - CheckCode::PT015, - CheckCode::PT016, - CheckCode::PT017, - CheckCode::PT018, - CheckCode::PT019, - ], - CheckCodePrefix::PT010 => vec![CheckCode::PT010], - CheckCodePrefix::PT011 => vec![CheckCode::PT011], - CheckCodePrefix::PT012 => vec![CheckCode::PT012], - CheckCodePrefix::PT013 => vec![CheckCode::PT013], - CheckCodePrefix::PT015 => vec![CheckCode::PT015], - CheckCodePrefix::PT016 => vec![CheckCode::PT016], - CheckCodePrefix::PT017 => vec![CheckCode::PT017], - CheckCodePrefix::PT018 => vec![CheckCode::PT018], - CheckCodePrefix::PT019 => vec![CheckCode::PT019], - CheckCodePrefix::PT02 => vec![ - CheckCode::PT020, - CheckCode::PT021, - CheckCode::PT022, - CheckCode::PT023, - CheckCode::PT024, - CheckCode::PT025, - CheckCode::PT026, - ], - CheckCodePrefix::PT020 => vec![CheckCode::PT020], - CheckCodePrefix::PT021 => vec![CheckCode::PT021], - CheckCodePrefix::PT022 => vec![CheckCode::PT022], - CheckCodePrefix::PT023 => vec![CheckCode::PT023], - CheckCodePrefix::PT024 => vec![CheckCode::PT024], - CheckCodePrefix::PT025 => vec![CheckCode::PT025], - CheckCodePrefix::PT026 => vec![CheckCode::PT026], - CheckCodePrefix::Q => vec![ - CheckCode::Q000, - CheckCode::Q001, - CheckCode::Q002, - CheckCode::Q003, - ], - CheckCodePrefix::Q0 => vec![ - CheckCode::Q000, - CheckCode::Q001, - CheckCode::Q002, - CheckCode::Q003, - ], - CheckCodePrefix::Q00 => vec![ - CheckCode::Q000, - CheckCode::Q001, - CheckCode::Q002, - CheckCode::Q003, - ], - CheckCodePrefix::Q000 => vec![CheckCode::Q000], - CheckCodePrefix::Q001 => vec![CheckCode::Q001], - CheckCodePrefix::Q002 => vec![CheckCode::Q002], - CheckCodePrefix::Q003 => vec![CheckCode::Q003], - CheckCodePrefix::R => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`R` has been remapped to `RET`".bold() - ); - vec![ - CheckCode::RET501, - CheckCode::RET502, - CheckCode::RET503, - CheckCode::RET504, - CheckCode::RET505, - CheckCode::RET506, - CheckCode::RET507, - CheckCode::RET508, - ] - } - CheckCodePrefix::R5 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`R5` has been remapped to `RET5`".bold() - ); - vec![ - CheckCode::RET501, - CheckCode::RET502, - CheckCode::RET503, - CheckCode::RET504, - CheckCode::RET505, - CheckCode::RET506, - CheckCode::RET507, - CheckCode::RET508, - ] - } - CheckCodePrefix::R50 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`R50` has been remapped to `RET50`".bold() - ); - vec![ - CheckCode::RET501, - CheckCode::RET502, - CheckCode::RET503, - CheckCode::RET504, - CheckCode::RET505, - CheckCode::RET506, - CheckCode::RET507, - CheckCode::RET508, - ] - } - CheckCodePrefix::R501 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`R501` has been remapped to `RET501`".bold() - ); - vec![CheckCode::RET501] - } - CheckCodePrefix::R502 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`R502` has been remapped to `RET502`".bold() - ); - vec![CheckCode::RET502] - } - CheckCodePrefix::R503 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`R503` has been remapped to `RET503`".bold() - ); - vec![CheckCode::RET503] - } - CheckCodePrefix::R504 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`R504` has been remapped to `RET504`".bold() - ); - vec![CheckCode::RET504] - } - CheckCodePrefix::R505 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`R505` has been remapped to `RET505`".bold() - ); - vec![CheckCode::RET505] - } - CheckCodePrefix::R506 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`R506` has been remapped to `RET506`".bold() - ); - vec![CheckCode::RET506] - } - CheckCodePrefix::R507 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`R507` has been remapped to `RET507`".bold() - ); - vec![CheckCode::RET507] - } - CheckCodePrefix::R508 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`R508` has been remapped to `RET508`".bold() - ); - vec![CheckCode::RET508] - } - CheckCodePrefix::RET => vec![ - CheckCode::RET501, - CheckCode::RET502, - CheckCode::RET503, - CheckCode::RET504, - CheckCode::RET505, - CheckCode::RET506, - CheckCode::RET507, - CheckCode::RET508, - ], - CheckCodePrefix::RET5 => vec![ - CheckCode::RET501, - CheckCode::RET502, - CheckCode::RET503, - CheckCode::RET504, - CheckCode::RET505, - CheckCode::RET506, - CheckCode::RET507, - CheckCode::RET508, - ], - CheckCodePrefix::RET50 => vec![ - CheckCode::RET501, - CheckCode::RET502, - CheckCode::RET503, - CheckCode::RET504, - CheckCode::RET505, - CheckCode::RET506, - CheckCode::RET507, - CheckCode::RET508, - ], - CheckCodePrefix::RET501 => vec![CheckCode::RET501], - CheckCodePrefix::RET502 => vec![CheckCode::RET502], - CheckCodePrefix::RET503 => vec![CheckCode::RET503], - CheckCodePrefix::RET504 => vec![CheckCode::RET504], - CheckCodePrefix::RET505 => vec![CheckCode::RET505], - CheckCodePrefix::RET506 => vec![CheckCode::RET506], - CheckCodePrefix::RET507 => vec![CheckCode::RET507], - CheckCodePrefix::RET508 => vec![CheckCode::RET508], - CheckCodePrefix::RUF => vec![ - CheckCode::RUF001, - CheckCode::RUF002, - CheckCode::RUF003, - CheckCode::RUF004, - CheckCode::RUF100, - ], - CheckCodePrefix::RUF0 => vec![ - CheckCode::RUF001, - CheckCode::RUF002, - CheckCode::RUF003, - CheckCode::RUF004, - ], - CheckCodePrefix::RUF00 => vec![ - CheckCode::RUF001, - CheckCode::RUF002, - CheckCode::RUF003, - CheckCode::RUF004, - ], - CheckCodePrefix::RUF001 => vec![CheckCode::RUF001], - CheckCodePrefix::RUF002 => vec![CheckCode::RUF002], - CheckCodePrefix::RUF003 => vec![CheckCode::RUF003], - CheckCodePrefix::RUF004 => vec![CheckCode::RUF004], - CheckCodePrefix::RUF1 => vec![CheckCode::RUF100], - CheckCodePrefix::RUF10 => vec![CheckCode::RUF100], - CheckCodePrefix::RUF100 => vec![CheckCode::RUF100], - CheckCodePrefix::S => vec![ - CheckCode::S101, - CheckCode::S102, - CheckCode::S103, - CheckCode::S104, - CheckCode::S105, - CheckCode::S106, - CheckCode::S107, - CheckCode::S108, - ], - CheckCodePrefix::S1 => vec![ - CheckCode::S101, - CheckCode::S102, - CheckCode::S103, - CheckCode::S104, - CheckCode::S105, - CheckCode::S106, - CheckCode::S107, - CheckCode::S108, - ], - CheckCodePrefix::S10 => vec![ - CheckCode::S101, - CheckCode::S102, - CheckCode::S103, - CheckCode::S104, - CheckCode::S105, - CheckCode::S106, - CheckCode::S107, - CheckCode::S108, - ], - CheckCodePrefix::S101 => vec![CheckCode::S101], - CheckCodePrefix::S102 => vec![CheckCode::S102], - CheckCodePrefix::S103 => vec![CheckCode::S103], - CheckCodePrefix::S104 => vec![CheckCode::S104], - CheckCodePrefix::S105 => vec![CheckCode::S105], - CheckCodePrefix::S106 => vec![CheckCode::S106], - CheckCodePrefix::S107 => vec![CheckCode::S107], - CheckCodePrefix::S108 => vec![CheckCode::S108], - CheckCodePrefix::SIM => vec![ - CheckCode::SIM102, - CheckCode::SIM105, - CheckCode::SIM107, - CheckCode::SIM110, - CheckCode::SIM111, - CheckCode::SIM117, - CheckCode::SIM118, - CheckCode::SIM220, - CheckCode::SIM221, - CheckCode::SIM222, - CheckCode::SIM223, - CheckCode::SIM300, - ], - CheckCodePrefix::SIM1 => vec![ - CheckCode::SIM102, - CheckCode::SIM105, - CheckCode::SIM107, - CheckCode::SIM110, - CheckCode::SIM111, - CheckCode::SIM117, - CheckCode::SIM118, - ], - CheckCodePrefix::SIM10 => vec![CheckCode::SIM102, CheckCode::SIM105, CheckCode::SIM107], - CheckCodePrefix::SIM102 => vec![CheckCode::SIM102], - CheckCodePrefix::SIM105 => vec![CheckCode::SIM105], - CheckCodePrefix::SIM107 => vec![CheckCode::SIM107], - CheckCodePrefix::SIM11 => vec![ - CheckCode::SIM110, - CheckCode::SIM111, - CheckCode::SIM117, - CheckCode::SIM118, - ], - CheckCodePrefix::SIM110 => vec![CheckCode::SIM110], - CheckCodePrefix::SIM111 => vec![CheckCode::SIM111], - CheckCodePrefix::SIM117 => vec![CheckCode::SIM117], - CheckCodePrefix::SIM118 => vec![CheckCode::SIM118], - CheckCodePrefix::SIM2 => vec![ - CheckCode::SIM220, - CheckCode::SIM221, - CheckCode::SIM222, - CheckCode::SIM223, - ], - CheckCodePrefix::SIM22 => vec![ - CheckCode::SIM220, - CheckCode::SIM221, - CheckCode::SIM222, - CheckCode::SIM223, - ], - CheckCodePrefix::SIM220 => vec![CheckCode::SIM220], - CheckCodePrefix::SIM221 => vec![CheckCode::SIM221], - CheckCodePrefix::SIM222 => vec![CheckCode::SIM222], - CheckCodePrefix::SIM223 => vec![CheckCode::SIM223], - CheckCodePrefix::SIM3 => vec![CheckCode::SIM300], - CheckCodePrefix::SIM30 => vec![CheckCode::SIM300], - CheckCodePrefix::SIM300 => vec![CheckCode::SIM300], - CheckCodePrefix::T => vec![CheckCode::T100, CheckCode::T201, CheckCode::T203], - CheckCodePrefix::T1 => vec![CheckCode::T100], - CheckCodePrefix::T10 => vec![CheckCode::T100], - CheckCodePrefix::T100 => vec![CheckCode::T100], - CheckCodePrefix::T2 => vec![CheckCode::T201, CheckCode::T203], - CheckCodePrefix::T20 => vec![CheckCode::T201, CheckCode::T203], - CheckCodePrefix::T201 => vec![CheckCode::T201], - CheckCodePrefix::T203 => vec![CheckCode::T203], - CheckCodePrefix::TID => vec![CheckCode::TID251, CheckCode::TID252], - CheckCodePrefix::TID2 => vec![CheckCode::TID251, CheckCode::TID252], - CheckCodePrefix::TID25 => vec![CheckCode::TID251, CheckCode::TID252], - CheckCodePrefix::TID251 => vec![CheckCode::TID251], - CheckCodePrefix::TID252 => vec![CheckCode::TID252], - CheckCodePrefix::U => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U` has been remapped to `UP`".bold() - ); - vec![ - CheckCode::UP001, - CheckCode::UP003, - CheckCode::UP004, - CheckCode::UP005, - CheckCode::UP006, - CheckCode::UP007, - CheckCode::UP008, - CheckCode::UP009, - CheckCode::UP010, - CheckCode::UP011, - CheckCode::UP012, - CheckCode::UP013, - CheckCode::UP014, - CheckCode::UP015, - CheckCode::UP016, - CheckCode::UP017, - CheckCode::UP018, - CheckCode::UP019, - CheckCode::UP020, - CheckCode::UP021, - CheckCode::UP022, - CheckCode::UP023, - CheckCode::UP024, - CheckCode::UP025, - CheckCode::UP026, - CheckCode::UP027, - CheckCode::UP028, - CheckCode::UP029, - ] - } - CheckCodePrefix::U0 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U0` has been remapped to `UP0`".bold() - ); - vec![ - CheckCode::UP001, - CheckCode::UP003, - CheckCode::UP004, - CheckCode::UP005, - CheckCode::UP006, - CheckCode::UP007, - CheckCode::UP008, - CheckCode::UP009, - CheckCode::UP010, - CheckCode::UP011, - CheckCode::UP012, - CheckCode::UP013, - CheckCode::UP014, - CheckCode::UP015, - CheckCode::UP016, - CheckCode::UP017, - CheckCode::UP018, - CheckCode::UP019, - CheckCode::UP020, - CheckCode::UP021, - CheckCode::UP022, - CheckCode::UP023, - CheckCode::UP024, - CheckCode::UP025, - CheckCode::UP026, - CheckCode::UP027, - CheckCode::UP028, - CheckCode::UP029, - ] - } - CheckCodePrefix::U00 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U00` has been remapped to `UP00`".bold() - ); - vec![ - CheckCode::UP001, - CheckCode::UP003, - CheckCode::UP004, - CheckCode::UP005, - CheckCode::UP006, - CheckCode::UP007, - CheckCode::UP008, - CheckCode::UP009, - ] - } - CheckCodePrefix::U001 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U001` has been remapped to `UP001`".bold() - ); - vec![CheckCode::UP001] - } - CheckCodePrefix::U003 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U003` has been remapped to `UP003`".bold() - ); - vec![CheckCode::UP003] - } - CheckCodePrefix::U004 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U004` has been remapped to `UP004`".bold() - ); - vec![CheckCode::UP004] - } - CheckCodePrefix::U005 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U005` has been remapped to `UP005`".bold() - ); - vec![CheckCode::UP005] - } - CheckCodePrefix::U006 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U006` has been remapped to `UP006`".bold() - ); - vec![CheckCode::UP006] - } - CheckCodePrefix::U007 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U007` has been remapped to `UP007`".bold() - ); - vec![CheckCode::UP007] - } - CheckCodePrefix::U008 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U008` has been remapped to `UP008`".bold() - ); - vec![CheckCode::UP008] - } - CheckCodePrefix::U009 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U009` has been remapped to `UP009`".bold() - ); - vec![CheckCode::UP009] - } - CheckCodePrefix::U01 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U01` has been remapped to `UP01`".bold() - ); - vec![ - CheckCode::UP010, - CheckCode::UP011, - CheckCode::UP012, - CheckCode::UP013, - CheckCode::UP014, - CheckCode::UP015, - CheckCode::UP016, - CheckCode::UP017, - CheckCode::UP018, - CheckCode::UP019, - ] - } - CheckCodePrefix::U010 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U010` has been remapped to `UP010`".bold() - ); - vec![CheckCode::UP010] - } - CheckCodePrefix::U011 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U011` has been remapped to `UP011`".bold() - ); - vec![CheckCode::UP011] - } - CheckCodePrefix::U012 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U012` has been remapped to `UP012`".bold() - ); - vec![CheckCode::UP012] - } - CheckCodePrefix::U013 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U013` has been remapped to `UP013`".bold() - ); - vec![CheckCode::UP013] - } - CheckCodePrefix::U014 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U014` has been remapped to `UP014`".bold() - ); - vec![CheckCode::UP014] - } - CheckCodePrefix::U015 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U015` has been remapped to `UP015`".bold() - ); - vec![CheckCode::UP015] - } - CheckCodePrefix::U016 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U016` has been remapped to `UP016`".bold() - ); - vec![CheckCode::UP016] - } - CheckCodePrefix::U017 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U017` has been remapped to `UP017`".bold() - ); - vec![CheckCode::UP017] - } - CheckCodePrefix::U019 => { - one_time_warning!( - "{}{} {}", - "warning".yellow().bold(), - ":".bold(), - "`U019` has been remapped to `UP019`".bold() - ); - vec![CheckCode::UP019] - } - CheckCodePrefix::UP => vec![ - CheckCode::UP001, - CheckCode::UP003, - CheckCode::UP004, - CheckCode::UP005, - CheckCode::UP006, - CheckCode::UP007, - CheckCode::UP008, - CheckCode::UP009, - CheckCode::UP010, - CheckCode::UP011, - CheckCode::UP012, - CheckCode::UP013, - CheckCode::UP014, - CheckCode::UP015, - CheckCode::UP016, - CheckCode::UP017, - CheckCode::UP018, - CheckCode::UP019, - CheckCode::UP020, - CheckCode::UP021, - CheckCode::UP022, - CheckCode::UP023, - CheckCode::UP024, - CheckCode::UP025, - CheckCode::UP026, - CheckCode::UP027, - CheckCode::UP028, - CheckCode::UP029, - ], - CheckCodePrefix::UP0 => vec![ - CheckCode::UP001, - CheckCode::UP003, - CheckCode::UP004, - CheckCode::UP005, - CheckCode::UP006, - CheckCode::UP007, - CheckCode::UP008, - CheckCode::UP009, - CheckCode::UP010, - CheckCode::UP011, - CheckCode::UP012, - CheckCode::UP013, - CheckCode::UP014, - CheckCode::UP015, - CheckCode::UP016, - CheckCode::UP017, - CheckCode::UP018, - CheckCode::UP019, - CheckCode::UP020, - CheckCode::UP021, - CheckCode::UP022, - CheckCode::UP023, - CheckCode::UP024, - CheckCode::UP025, - CheckCode::UP026, - CheckCode::UP027, - CheckCode::UP028, - CheckCode::UP029, - ], - CheckCodePrefix::UP00 => vec![ - CheckCode::UP001, - CheckCode::UP003, - CheckCode::UP004, - CheckCode::UP005, - CheckCode::UP006, - CheckCode::UP007, - CheckCode::UP008, - CheckCode::UP009, - ], - CheckCodePrefix::UP001 => vec![CheckCode::UP001], - CheckCodePrefix::UP003 => vec![CheckCode::UP003], - CheckCodePrefix::UP004 => vec![CheckCode::UP004], - CheckCodePrefix::UP005 => vec![CheckCode::UP005], - CheckCodePrefix::UP006 => vec![CheckCode::UP006], - CheckCodePrefix::UP007 => vec![CheckCode::UP007], - CheckCodePrefix::UP008 => vec![CheckCode::UP008], - CheckCodePrefix::UP009 => vec![CheckCode::UP009], - CheckCodePrefix::UP01 => vec![ - CheckCode::UP010, - CheckCode::UP011, - CheckCode::UP012, - CheckCode::UP013, - CheckCode::UP014, - CheckCode::UP015, - CheckCode::UP016, - CheckCode::UP017, - CheckCode::UP018, - CheckCode::UP019, - ], - CheckCodePrefix::UP010 => vec![CheckCode::UP010], - CheckCodePrefix::UP011 => vec![CheckCode::UP011], - CheckCodePrefix::UP012 => vec![CheckCode::UP012], - CheckCodePrefix::UP013 => vec![CheckCode::UP013], - CheckCodePrefix::UP014 => vec![CheckCode::UP014], - CheckCodePrefix::UP015 => vec![CheckCode::UP015], - CheckCodePrefix::UP016 => vec![CheckCode::UP016], - CheckCodePrefix::UP017 => vec![CheckCode::UP017], - CheckCodePrefix::UP018 => vec![CheckCode::UP018], - CheckCodePrefix::UP019 => vec![CheckCode::UP019], - CheckCodePrefix::UP02 => vec![ - CheckCode::UP020, - CheckCode::UP021, - CheckCode::UP022, - CheckCode::UP023, - CheckCode::UP024, - CheckCode::UP025, - CheckCode::UP026, - CheckCode::UP027, - CheckCode::UP028, - CheckCode::UP029, - ], - CheckCodePrefix::UP020 => vec![CheckCode::UP020], - CheckCodePrefix::UP021 => vec![CheckCode::UP021], - CheckCodePrefix::UP022 => vec![CheckCode::UP022], - CheckCodePrefix::UP023 => vec![CheckCode::UP023], - CheckCodePrefix::UP024 => vec![CheckCode::UP024], - CheckCodePrefix::UP025 => vec![CheckCode::UP025], - CheckCodePrefix::UP026 => vec![CheckCode::UP026], - CheckCodePrefix::UP027 => vec![CheckCode::UP027], - CheckCodePrefix::UP028 => vec![CheckCode::UP028], - CheckCodePrefix::UP029 => vec![CheckCode::UP029], - CheckCodePrefix::W => vec![CheckCode::W292, CheckCode::W605], - CheckCodePrefix::W2 => vec![CheckCode::W292], - CheckCodePrefix::W29 => vec![CheckCode::W292], - CheckCodePrefix::W292 => vec![CheckCode::W292], - CheckCodePrefix::W6 => vec![CheckCode::W605], - CheckCodePrefix::W60 => vec![CheckCode::W605], - CheckCodePrefix::W605 => vec![CheckCode::W605], - CheckCodePrefix::YTT => vec![ - CheckCode::YTT101, - CheckCode::YTT102, - CheckCode::YTT103, - CheckCode::YTT201, - CheckCode::YTT202, - CheckCode::YTT203, - CheckCode::YTT204, - CheckCode::YTT301, - CheckCode::YTT302, - CheckCode::YTT303, - ], - CheckCodePrefix::YTT1 => vec![CheckCode::YTT101, CheckCode::YTT102, CheckCode::YTT103], - CheckCodePrefix::YTT10 => vec![CheckCode::YTT101, CheckCode::YTT102, CheckCode::YTT103], - CheckCodePrefix::YTT101 => vec![CheckCode::YTT101], - CheckCodePrefix::YTT102 => vec![CheckCode::YTT102], - CheckCodePrefix::YTT103 => vec![CheckCode::YTT103], - CheckCodePrefix::YTT2 => vec![ - CheckCode::YTT201, - CheckCode::YTT202, - CheckCode::YTT203, - CheckCode::YTT204, - ], - CheckCodePrefix::YTT20 => vec![ - CheckCode::YTT201, - CheckCode::YTT202, - CheckCode::YTT203, - CheckCode::YTT204, - ], - CheckCodePrefix::YTT201 => vec![CheckCode::YTT201], - CheckCodePrefix::YTT202 => vec![CheckCode::YTT202], - CheckCodePrefix::YTT203 => vec![CheckCode::YTT203], - CheckCodePrefix::YTT204 => vec![CheckCode::YTT204], - CheckCodePrefix::YTT3 => vec![CheckCode::YTT301, CheckCode::YTT302, CheckCode::YTT303], - CheckCodePrefix::YTT30 => vec![CheckCode::YTT301, CheckCode::YTT302, CheckCode::YTT303], - CheckCodePrefix::YTT301 => vec![CheckCode::YTT301], - CheckCodePrefix::YTT302 => vec![CheckCode::YTT302], - CheckCodePrefix::YTT303 => vec![CheckCode::YTT303], - } - } -} - -impl CheckCodePrefix { - pub fn specificity(&self) -> SuffixLength { - #[allow(clippy::match_same_arms)] - match self { - CheckCodePrefix::A => SuffixLength::Zero, - CheckCodePrefix::A0 => SuffixLength::One, - CheckCodePrefix::A00 => SuffixLength::Two, - CheckCodePrefix::A001 => SuffixLength::Three, - CheckCodePrefix::A002 => SuffixLength::Three, - CheckCodePrefix::A003 => SuffixLength::Three, - CheckCodePrefix::ALL => SuffixLength::None, - CheckCodePrefix::ANN => SuffixLength::Zero, - CheckCodePrefix::ANN0 => SuffixLength::One, - CheckCodePrefix::ANN00 => SuffixLength::Two, - CheckCodePrefix::ANN001 => SuffixLength::Three, - CheckCodePrefix::ANN002 => SuffixLength::Three, - CheckCodePrefix::ANN003 => SuffixLength::Three, - CheckCodePrefix::ANN1 => SuffixLength::One, - CheckCodePrefix::ANN10 => SuffixLength::Two, - CheckCodePrefix::ANN101 => SuffixLength::Three, - CheckCodePrefix::ANN102 => SuffixLength::Three, - CheckCodePrefix::ANN2 => SuffixLength::One, - CheckCodePrefix::ANN20 => SuffixLength::Two, - CheckCodePrefix::ANN201 => SuffixLength::Three, - CheckCodePrefix::ANN202 => SuffixLength::Three, - CheckCodePrefix::ANN204 => SuffixLength::Three, - CheckCodePrefix::ANN205 => SuffixLength::Three, - CheckCodePrefix::ANN206 => SuffixLength::Three, - CheckCodePrefix::ANN4 => SuffixLength::One, - CheckCodePrefix::ANN40 => SuffixLength::Two, - CheckCodePrefix::ANN401 => SuffixLength::Three, - CheckCodePrefix::ARG => SuffixLength::Zero, - CheckCodePrefix::ARG0 => SuffixLength::One, - CheckCodePrefix::ARG00 => SuffixLength::Two, - CheckCodePrefix::ARG001 => SuffixLength::Three, - CheckCodePrefix::ARG002 => SuffixLength::Three, - CheckCodePrefix::ARG003 => SuffixLength::Three, - CheckCodePrefix::ARG004 => SuffixLength::Three, - CheckCodePrefix::ARG005 => SuffixLength::Three, - CheckCodePrefix::B => SuffixLength::Zero, - CheckCodePrefix::B0 => SuffixLength::One, - CheckCodePrefix::B00 => SuffixLength::Two, - CheckCodePrefix::B002 => SuffixLength::Three, - CheckCodePrefix::B003 => SuffixLength::Three, - CheckCodePrefix::B004 => SuffixLength::Three, - CheckCodePrefix::B005 => SuffixLength::Three, - CheckCodePrefix::B006 => SuffixLength::Three, - CheckCodePrefix::B007 => SuffixLength::Three, - CheckCodePrefix::B008 => SuffixLength::Three, - CheckCodePrefix::B009 => SuffixLength::Three, - CheckCodePrefix::B01 => SuffixLength::Two, - CheckCodePrefix::B010 => SuffixLength::Three, - CheckCodePrefix::B011 => SuffixLength::Three, - CheckCodePrefix::B012 => SuffixLength::Three, - CheckCodePrefix::B013 => SuffixLength::Three, - CheckCodePrefix::B014 => SuffixLength::Three, - CheckCodePrefix::B015 => SuffixLength::Three, - CheckCodePrefix::B016 => SuffixLength::Three, - CheckCodePrefix::B017 => SuffixLength::Three, - CheckCodePrefix::B018 => SuffixLength::Three, - CheckCodePrefix::B019 => SuffixLength::Three, - CheckCodePrefix::B02 => SuffixLength::Two, - CheckCodePrefix::B020 => SuffixLength::Three, - CheckCodePrefix::B021 => SuffixLength::Three, - CheckCodePrefix::B022 => SuffixLength::Three, - CheckCodePrefix::B023 => SuffixLength::Three, - CheckCodePrefix::B024 => SuffixLength::Three, - CheckCodePrefix::B025 => SuffixLength::Three, - CheckCodePrefix::B026 => SuffixLength::Three, - CheckCodePrefix::B027 => SuffixLength::Three, - CheckCodePrefix::B9 => SuffixLength::One, - CheckCodePrefix::B90 => SuffixLength::Two, - CheckCodePrefix::B904 => SuffixLength::Three, - CheckCodePrefix::B905 => SuffixLength::Three, - CheckCodePrefix::BLE => SuffixLength::Zero, - CheckCodePrefix::BLE0 => SuffixLength::One, - CheckCodePrefix::BLE00 => SuffixLength::Two, - CheckCodePrefix::BLE001 => SuffixLength::Three, - CheckCodePrefix::C => SuffixLength::Zero, - CheckCodePrefix::C4 => SuffixLength::One, - CheckCodePrefix::C40 => SuffixLength::Two, - CheckCodePrefix::C400 => SuffixLength::Three, - CheckCodePrefix::C401 => SuffixLength::Three, - CheckCodePrefix::C402 => SuffixLength::Three, - CheckCodePrefix::C403 => SuffixLength::Three, - CheckCodePrefix::C404 => SuffixLength::Three, - CheckCodePrefix::C405 => SuffixLength::Three, - CheckCodePrefix::C406 => SuffixLength::Three, - CheckCodePrefix::C408 => SuffixLength::Three, - CheckCodePrefix::C409 => SuffixLength::Three, - CheckCodePrefix::C41 => SuffixLength::Two, - CheckCodePrefix::C410 => SuffixLength::Three, - CheckCodePrefix::C411 => SuffixLength::Three, - CheckCodePrefix::C413 => SuffixLength::Three, - CheckCodePrefix::C414 => SuffixLength::Three, - CheckCodePrefix::C415 => SuffixLength::Three, - CheckCodePrefix::C416 => SuffixLength::Three, - CheckCodePrefix::C417 => SuffixLength::Three, - CheckCodePrefix::C9 => SuffixLength::One, - CheckCodePrefix::C90 => SuffixLength::Two, - CheckCodePrefix::C901 => SuffixLength::Three, - CheckCodePrefix::D => SuffixLength::Zero, - CheckCodePrefix::D1 => SuffixLength::One, - CheckCodePrefix::D10 => SuffixLength::Two, - CheckCodePrefix::D100 => SuffixLength::Three, - CheckCodePrefix::D101 => SuffixLength::Three, - CheckCodePrefix::D102 => SuffixLength::Three, - CheckCodePrefix::D103 => SuffixLength::Three, - CheckCodePrefix::D104 => SuffixLength::Three, - CheckCodePrefix::D105 => SuffixLength::Three, - CheckCodePrefix::D106 => SuffixLength::Three, - CheckCodePrefix::D107 => SuffixLength::Three, - CheckCodePrefix::D2 => SuffixLength::One, - CheckCodePrefix::D20 => SuffixLength::Two, - CheckCodePrefix::D200 => SuffixLength::Three, - CheckCodePrefix::D201 => SuffixLength::Three, - CheckCodePrefix::D202 => SuffixLength::Three, - CheckCodePrefix::D203 => SuffixLength::Three, - CheckCodePrefix::D204 => SuffixLength::Three, - CheckCodePrefix::D205 => SuffixLength::Three, - CheckCodePrefix::D206 => SuffixLength::Three, - CheckCodePrefix::D207 => SuffixLength::Three, - CheckCodePrefix::D208 => SuffixLength::Three, - CheckCodePrefix::D209 => SuffixLength::Three, - CheckCodePrefix::D21 => SuffixLength::Two, - CheckCodePrefix::D210 => SuffixLength::Three, - CheckCodePrefix::D211 => SuffixLength::Three, - CheckCodePrefix::D212 => SuffixLength::Three, - CheckCodePrefix::D213 => SuffixLength::Three, - CheckCodePrefix::D214 => SuffixLength::Three, - CheckCodePrefix::D215 => SuffixLength::Three, - CheckCodePrefix::D3 => SuffixLength::One, - CheckCodePrefix::D30 => SuffixLength::Two, - CheckCodePrefix::D300 => SuffixLength::Three, - CheckCodePrefix::D301 => SuffixLength::Three, - CheckCodePrefix::D4 => SuffixLength::One, - CheckCodePrefix::D40 => SuffixLength::Two, - CheckCodePrefix::D400 => SuffixLength::Three, - CheckCodePrefix::D402 => SuffixLength::Three, - CheckCodePrefix::D403 => SuffixLength::Three, - CheckCodePrefix::D404 => SuffixLength::Three, - CheckCodePrefix::D405 => SuffixLength::Three, - CheckCodePrefix::D406 => SuffixLength::Three, - CheckCodePrefix::D407 => SuffixLength::Three, - CheckCodePrefix::D408 => SuffixLength::Three, - CheckCodePrefix::D409 => SuffixLength::Three, - CheckCodePrefix::D41 => SuffixLength::Two, - CheckCodePrefix::D410 => SuffixLength::Three, - CheckCodePrefix::D411 => SuffixLength::Three, - CheckCodePrefix::D412 => SuffixLength::Three, - CheckCodePrefix::D413 => SuffixLength::Three, - CheckCodePrefix::D414 => SuffixLength::Three, - CheckCodePrefix::D415 => SuffixLength::Three, - CheckCodePrefix::D416 => SuffixLength::Three, - CheckCodePrefix::D417 => SuffixLength::Three, - CheckCodePrefix::D418 => SuffixLength::Three, - CheckCodePrefix::D419 => SuffixLength::Three, - CheckCodePrefix::DTZ => SuffixLength::Zero, - CheckCodePrefix::DTZ0 => SuffixLength::One, - CheckCodePrefix::DTZ00 => SuffixLength::Two, - CheckCodePrefix::DTZ001 => SuffixLength::Three, - CheckCodePrefix::DTZ002 => SuffixLength::Three, - CheckCodePrefix::DTZ003 => SuffixLength::Three, - CheckCodePrefix::DTZ004 => SuffixLength::Three, - CheckCodePrefix::DTZ005 => SuffixLength::Three, - CheckCodePrefix::DTZ006 => SuffixLength::Three, - CheckCodePrefix::DTZ007 => SuffixLength::Three, - CheckCodePrefix::DTZ01 => SuffixLength::Two, - CheckCodePrefix::DTZ011 => SuffixLength::Three, - CheckCodePrefix::DTZ012 => SuffixLength::Three, - CheckCodePrefix::E => SuffixLength::Zero, - CheckCodePrefix::E4 => SuffixLength::One, - CheckCodePrefix::E40 => SuffixLength::Two, - CheckCodePrefix::E401 => SuffixLength::Three, - CheckCodePrefix::E402 => SuffixLength::Three, - CheckCodePrefix::E5 => SuffixLength::One, - CheckCodePrefix::E50 => SuffixLength::Two, - CheckCodePrefix::E501 => SuffixLength::Three, - CheckCodePrefix::E7 => SuffixLength::One, - CheckCodePrefix::E71 => SuffixLength::Two, - CheckCodePrefix::E711 => SuffixLength::Three, - CheckCodePrefix::E712 => SuffixLength::Three, - CheckCodePrefix::E713 => SuffixLength::Three, - CheckCodePrefix::E714 => SuffixLength::Three, - CheckCodePrefix::E72 => SuffixLength::Two, - CheckCodePrefix::E721 => SuffixLength::Three, - CheckCodePrefix::E722 => SuffixLength::Three, - CheckCodePrefix::E73 => SuffixLength::Two, - CheckCodePrefix::E731 => SuffixLength::Three, - CheckCodePrefix::E74 => SuffixLength::Two, - CheckCodePrefix::E741 => SuffixLength::Three, - CheckCodePrefix::E742 => SuffixLength::Three, - CheckCodePrefix::E743 => SuffixLength::Three, - CheckCodePrefix::E9 => SuffixLength::One, - CheckCodePrefix::E90 => SuffixLength::Two, - CheckCodePrefix::E902 => SuffixLength::Three, - CheckCodePrefix::E99 => SuffixLength::Two, - CheckCodePrefix::E999 => SuffixLength::Three, - CheckCodePrefix::EM => SuffixLength::Zero, - CheckCodePrefix::EM1 => SuffixLength::One, - CheckCodePrefix::EM10 => SuffixLength::Two, - CheckCodePrefix::EM101 => SuffixLength::Three, - CheckCodePrefix::EM102 => SuffixLength::Three, - CheckCodePrefix::EM103 => SuffixLength::Three, - CheckCodePrefix::ERA => SuffixLength::Zero, - CheckCodePrefix::ERA0 => SuffixLength::One, - CheckCodePrefix::ERA00 => SuffixLength::Two, - CheckCodePrefix::ERA001 => SuffixLength::Three, - CheckCodePrefix::F => SuffixLength::Zero, - CheckCodePrefix::F4 => SuffixLength::One, - CheckCodePrefix::F40 => SuffixLength::Two, - CheckCodePrefix::F401 => SuffixLength::Three, - CheckCodePrefix::F402 => SuffixLength::Three, - CheckCodePrefix::F403 => SuffixLength::Three, - CheckCodePrefix::F404 => SuffixLength::Three, - CheckCodePrefix::F405 => SuffixLength::Three, - CheckCodePrefix::F406 => SuffixLength::Three, - CheckCodePrefix::F407 => SuffixLength::Three, - CheckCodePrefix::F5 => SuffixLength::One, - CheckCodePrefix::F50 => SuffixLength::Two, - CheckCodePrefix::F501 => SuffixLength::Three, - CheckCodePrefix::F502 => SuffixLength::Three, - CheckCodePrefix::F503 => SuffixLength::Three, - CheckCodePrefix::F504 => SuffixLength::Three, - CheckCodePrefix::F505 => SuffixLength::Three, - CheckCodePrefix::F506 => SuffixLength::Three, - CheckCodePrefix::F507 => SuffixLength::Three, - CheckCodePrefix::F508 => SuffixLength::Three, - CheckCodePrefix::F509 => SuffixLength::Three, - CheckCodePrefix::F52 => SuffixLength::Two, - CheckCodePrefix::F521 => SuffixLength::Three, - CheckCodePrefix::F522 => SuffixLength::Three, - CheckCodePrefix::F523 => SuffixLength::Three, - CheckCodePrefix::F524 => SuffixLength::Three, - CheckCodePrefix::F525 => SuffixLength::Three, - CheckCodePrefix::F54 => SuffixLength::Two, - CheckCodePrefix::F541 => SuffixLength::Three, - CheckCodePrefix::F6 => SuffixLength::One, - CheckCodePrefix::F60 => SuffixLength::Two, - CheckCodePrefix::F601 => SuffixLength::Three, - CheckCodePrefix::F602 => SuffixLength::Three, - CheckCodePrefix::F62 => SuffixLength::Two, - CheckCodePrefix::F621 => SuffixLength::Three, - CheckCodePrefix::F622 => SuffixLength::Three, - CheckCodePrefix::F63 => SuffixLength::Two, - CheckCodePrefix::F631 => SuffixLength::Three, - CheckCodePrefix::F632 => SuffixLength::Three, - CheckCodePrefix::F633 => SuffixLength::Three, - CheckCodePrefix::F634 => SuffixLength::Three, - CheckCodePrefix::F7 => SuffixLength::One, - CheckCodePrefix::F70 => SuffixLength::Two, - CheckCodePrefix::F701 => SuffixLength::Three, - CheckCodePrefix::F702 => SuffixLength::Three, - CheckCodePrefix::F704 => SuffixLength::Three, - CheckCodePrefix::F706 => SuffixLength::Three, - CheckCodePrefix::F707 => SuffixLength::Three, - CheckCodePrefix::F72 => SuffixLength::Two, - CheckCodePrefix::F722 => SuffixLength::Three, - CheckCodePrefix::F8 => SuffixLength::One, - CheckCodePrefix::F81 => SuffixLength::Two, - CheckCodePrefix::F811 => SuffixLength::Three, - CheckCodePrefix::F82 => SuffixLength::Two, - CheckCodePrefix::F821 => SuffixLength::Three, - CheckCodePrefix::F822 => SuffixLength::Three, - CheckCodePrefix::F823 => SuffixLength::Three, - CheckCodePrefix::F84 => SuffixLength::Two, - CheckCodePrefix::F841 => SuffixLength::Three, - CheckCodePrefix::F842 => SuffixLength::Three, - CheckCodePrefix::F9 => SuffixLength::One, - CheckCodePrefix::F90 => SuffixLength::Two, - CheckCodePrefix::F901 => SuffixLength::Three, - CheckCodePrefix::FBT => SuffixLength::Zero, - CheckCodePrefix::FBT0 => SuffixLength::One, - CheckCodePrefix::FBT00 => SuffixLength::Two, - CheckCodePrefix::FBT001 => SuffixLength::Three, - CheckCodePrefix::FBT002 => SuffixLength::Three, - CheckCodePrefix::FBT003 => SuffixLength::Three, - CheckCodePrefix::I => SuffixLength::Zero, - CheckCodePrefix::I0 => SuffixLength::One, - CheckCodePrefix::I00 => SuffixLength::Two, - CheckCodePrefix::I001 => SuffixLength::Three, - CheckCodePrefix::I2 => SuffixLength::One, - CheckCodePrefix::I25 => SuffixLength::Two, - CheckCodePrefix::I252 => SuffixLength::Three, - CheckCodePrefix::IC => SuffixLength::Zero, - CheckCodePrefix::IC0 => SuffixLength::One, - CheckCodePrefix::IC001 => SuffixLength::Three, - CheckCodePrefix::IC002 => SuffixLength::Three, - CheckCodePrefix::IC003 => SuffixLength::Three, - CheckCodePrefix::IC004 => SuffixLength::Three, - CheckCodePrefix::ICN => SuffixLength::Zero, - CheckCodePrefix::ICN0 => SuffixLength::One, - CheckCodePrefix::ICN00 => SuffixLength::Two, - CheckCodePrefix::ICN001 => SuffixLength::Three, - CheckCodePrefix::ISC => SuffixLength::Zero, - CheckCodePrefix::ISC0 => SuffixLength::One, - CheckCodePrefix::ISC00 => SuffixLength::Two, - CheckCodePrefix::ISC001 => SuffixLength::Three, - CheckCodePrefix::ISC002 => SuffixLength::Three, - CheckCodePrefix::ISC003 => SuffixLength::Three, - CheckCodePrefix::M => SuffixLength::Zero, - CheckCodePrefix::M0 => SuffixLength::One, - CheckCodePrefix::M001 => SuffixLength::Three, - CheckCodePrefix::N => SuffixLength::Zero, - CheckCodePrefix::N8 => SuffixLength::One, - CheckCodePrefix::N80 => SuffixLength::Two, - CheckCodePrefix::N801 => SuffixLength::Three, - CheckCodePrefix::N802 => SuffixLength::Three, - CheckCodePrefix::N803 => SuffixLength::Three, - CheckCodePrefix::N804 => SuffixLength::Three, - CheckCodePrefix::N805 => SuffixLength::Three, - CheckCodePrefix::N806 => SuffixLength::Three, - CheckCodePrefix::N807 => SuffixLength::Three, - CheckCodePrefix::N81 => SuffixLength::Two, - CheckCodePrefix::N811 => SuffixLength::Three, - CheckCodePrefix::N812 => SuffixLength::Three, - CheckCodePrefix::N813 => SuffixLength::Three, - CheckCodePrefix::N814 => SuffixLength::Three, - CheckCodePrefix::N815 => SuffixLength::Three, - CheckCodePrefix::N816 => SuffixLength::Three, - CheckCodePrefix::N817 => SuffixLength::Three, - CheckCodePrefix::N818 => SuffixLength::Three, - CheckCodePrefix::PD => SuffixLength::Zero, - CheckCodePrefix::PD0 => SuffixLength::One, - CheckCodePrefix::PD00 => SuffixLength::Two, - CheckCodePrefix::PD002 => SuffixLength::Three, - CheckCodePrefix::PD003 => SuffixLength::Three, - CheckCodePrefix::PD004 => SuffixLength::Three, - CheckCodePrefix::PD007 => SuffixLength::Three, - CheckCodePrefix::PD008 => SuffixLength::Three, - CheckCodePrefix::PD009 => SuffixLength::Three, - CheckCodePrefix::PD01 => SuffixLength::Two, - CheckCodePrefix::PD010 => SuffixLength::Three, - CheckCodePrefix::PD011 => SuffixLength::Three, - CheckCodePrefix::PD012 => SuffixLength::Three, - CheckCodePrefix::PD013 => SuffixLength::Three, - CheckCodePrefix::PD015 => SuffixLength::Three, - CheckCodePrefix::PD9 => SuffixLength::One, - CheckCodePrefix::PD90 => SuffixLength::Two, - CheckCodePrefix::PD901 => SuffixLength::Three, - CheckCodePrefix::PDV => SuffixLength::Zero, - CheckCodePrefix::PDV0 => SuffixLength::One, - CheckCodePrefix::PDV002 => SuffixLength::Three, - CheckCodePrefix::PDV003 => SuffixLength::Three, - CheckCodePrefix::PDV004 => SuffixLength::Three, - CheckCodePrefix::PDV007 => SuffixLength::Three, - CheckCodePrefix::PDV008 => SuffixLength::Three, - CheckCodePrefix::PDV009 => SuffixLength::Three, - CheckCodePrefix::PDV01 => SuffixLength::Two, - CheckCodePrefix::PDV010 => SuffixLength::Three, - CheckCodePrefix::PDV011 => SuffixLength::Three, - CheckCodePrefix::PDV012 => SuffixLength::Three, - CheckCodePrefix::PDV013 => SuffixLength::Three, - CheckCodePrefix::PDV015 => SuffixLength::Three, - CheckCodePrefix::PDV9 => SuffixLength::One, - CheckCodePrefix::PDV90 => SuffixLength::Two, - CheckCodePrefix::PDV901 => SuffixLength::Three, - CheckCodePrefix::PGH => SuffixLength::Zero, - CheckCodePrefix::PGH0 => SuffixLength::One, - CheckCodePrefix::PGH00 => SuffixLength::Two, - CheckCodePrefix::PGH001 => SuffixLength::Three, - CheckCodePrefix::PGH002 => SuffixLength::Three, - CheckCodePrefix::PGH003 => SuffixLength::Three, - CheckCodePrefix::PGH004 => SuffixLength::Three, - CheckCodePrefix::PIE => SuffixLength::Zero, - CheckCodePrefix::PIE7 => SuffixLength::One, - CheckCodePrefix::PIE79 => SuffixLength::Two, - CheckCodePrefix::PIE790 => SuffixLength::Three, - CheckCodePrefix::PIE794 => SuffixLength::Three, - CheckCodePrefix::PIE8 => SuffixLength::One, - CheckCodePrefix::PIE80 => SuffixLength::Two, - CheckCodePrefix::PIE807 => SuffixLength::Three, - CheckCodePrefix::PLC => SuffixLength::Zero, - CheckCodePrefix::PLC0 => SuffixLength::One, - CheckCodePrefix::PLC04 => SuffixLength::Two, - CheckCodePrefix::PLC041 => SuffixLength::Three, - CheckCodePrefix::PLC0414 => SuffixLength::Four, - CheckCodePrefix::PLC2 => SuffixLength::One, - CheckCodePrefix::PLC22 => SuffixLength::Two, - CheckCodePrefix::PLC220 => SuffixLength::Three, - CheckCodePrefix::PLC2201 => SuffixLength::Four, - CheckCodePrefix::PLC3 => SuffixLength::One, - CheckCodePrefix::PLC30 => SuffixLength::Two, - CheckCodePrefix::PLC300 => SuffixLength::Three, - CheckCodePrefix::PLC3002 => SuffixLength::Four, - CheckCodePrefix::PLE => SuffixLength::Zero, - CheckCodePrefix::PLE0 => SuffixLength::One, - CheckCodePrefix::PLE01 => SuffixLength::Two, - CheckCodePrefix::PLE011 => SuffixLength::Three, - CheckCodePrefix::PLE0117 => SuffixLength::Four, - CheckCodePrefix::PLE0118 => SuffixLength::Four, - CheckCodePrefix::PLE1 => SuffixLength::One, - CheckCodePrefix::PLE11 => SuffixLength::Two, - CheckCodePrefix::PLE114 => SuffixLength::Three, - CheckCodePrefix::PLE1142 => SuffixLength::Four, - CheckCodePrefix::PLR => SuffixLength::Zero, - CheckCodePrefix::PLR0 => SuffixLength::One, - CheckCodePrefix::PLR02 => SuffixLength::Two, - CheckCodePrefix::PLR020 => SuffixLength::Three, - CheckCodePrefix::PLR0206 => SuffixLength::Four, - CheckCodePrefix::PLR04 => SuffixLength::Two, - CheckCodePrefix::PLR040 => SuffixLength::Three, - CheckCodePrefix::PLR0402 => SuffixLength::Four, - CheckCodePrefix::PLR1 => SuffixLength::One, - CheckCodePrefix::PLR17 => SuffixLength::Two, - CheckCodePrefix::PLR170 => SuffixLength::Three, - CheckCodePrefix::PLR1701 => SuffixLength::Four, - CheckCodePrefix::PLR172 => SuffixLength::Three, - CheckCodePrefix::PLR1722 => SuffixLength::Four, - CheckCodePrefix::PLW => SuffixLength::Zero, - CheckCodePrefix::PLW0 => SuffixLength::One, - CheckCodePrefix::PLW01 => SuffixLength::Two, - CheckCodePrefix::PLW012 => SuffixLength::Three, - CheckCodePrefix::PLW0120 => SuffixLength::Four, - CheckCodePrefix::PLW06 => SuffixLength::Two, - CheckCodePrefix::PLW060 => SuffixLength::Three, - CheckCodePrefix::PLW0602 => SuffixLength::Four, - CheckCodePrefix::PT => SuffixLength::Zero, - CheckCodePrefix::PT0 => SuffixLength::One, - CheckCodePrefix::PT00 => SuffixLength::Two, - CheckCodePrefix::PT001 => SuffixLength::Three, - CheckCodePrefix::PT002 => SuffixLength::Three, - CheckCodePrefix::PT003 => SuffixLength::Three, - CheckCodePrefix::PT004 => SuffixLength::Three, - CheckCodePrefix::PT005 => SuffixLength::Three, - CheckCodePrefix::PT006 => SuffixLength::Three, - CheckCodePrefix::PT007 => SuffixLength::Three, - CheckCodePrefix::PT008 => SuffixLength::Three, - CheckCodePrefix::PT009 => SuffixLength::Three, - CheckCodePrefix::PT01 => SuffixLength::Two, - CheckCodePrefix::PT010 => SuffixLength::Three, - CheckCodePrefix::PT011 => SuffixLength::Three, - CheckCodePrefix::PT012 => SuffixLength::Three, - CheckCodePrefix::PT013 => SuffixLength::Three, - CheckCodePrefix::PT015 => SuffixLength::Three, - CheckCodePrefix::PT016 => SuffixLength::Three, - CheckCodePrefix::PT017 => SuffixLength::Three, - CheckCodePrefix::PT018 => SuffixLength::Three, - CheckCodePrefix::PT019 => SuffixLength::Three, - CheckCodePrefix::PT02 => SuffixLength::Two, - CheckCodePrefix::PT020 => SuffixLength::Three, - CheckCodePrefix::PT021 => SuffixLength::Three, - CheckCodePrefix::PT022 => SuffixLength::Three, - CheckCodePrefix::PT023 => SuffixLength::Three, - CheckCodePrefix::PT024 => SuffixLength::Three, - CheckCodePrefix::PT025 => SuffixLength::Three, - CheckCodePrefix::PT026 => SuffixLength::Three, - CheckCodePrefix::Q => SuffixLength::Zero, - CheckCodePrefix::Q0 => SuffixLength::One, - CheckCodePrefix::Q00 => SuffixLength::Two, - CheckCodePrefix::Q000 => SuffixLength::Three, - CheckCodePrefix::Q001 => SuffixLength::Three, - CheckCodePrefix::Q002 => SuffixLength::Three, - CheckCodePrefix::Q003 => SuffixLength::Three, - CheckCodePrefix::R => SuffixLength::Zero, - CheckCodePrefix::R5 => SuffixLength::One, - CheckCodePrefix::R50 => SuffixLength::Two, - CheckCodePrefix::R501 => SuffixLength::Three, - CheckCodePrefix::R502 => SuffixLength::Three, - CheckCodePrefix::R503 => SuffixLength::Three, - CheckCodePrefix::R504 => SuffixLength::Three, - CheckCodePrefix::R505 => SuffixLength::Three, - CheckCodePrefix::R506 => SuffixLength::Three, - CheckCodePrefix::R507 => SuffixLength::Three, - CheckCodePrefix::R508 => SuffixLength::Three, - CheckCodePrefix::RET => SuffixLength::Zero, - CheckCodePrefix::RET5 => SuffixLength::One, - CheckCodePrefix::RET50 => SuffixLength::Two, - CheckCodePrefix::RET501 => SuffixLength::Three, - CheckCodePrefix::RET502 => SuffixLength::Three, - CheckCodePrefix::RET503 => SuffixLength::Three, - CheckCodePrefix::RET504 => SuffixLength::Three, - CheckCodePrefix::RET505 => SuffixLength::Three, - CheckCodePrefix::RET506 => SuffixLength::Three, - CheckCodePrefix::RET507 => SuffixLength::Three, - CheckCodePrefix::RET508 => SuffixLength::Three, - CheckCodePrefix::RUF => SuffixLength::Zero, - CheckCodePrefix::RUF0 => SuffixLength::One, - CheckCodePrefix::RUF00 => SuffixLength::Two, - CheckCodePrefix::RUF001 => SuffixLength::Three, - CheckCodePrefix::RUF002 => SuffixLength::Three, - CheckCodePrefix::RUF003 => SuffixLength::Three, - CheckCodePrefix::RUF004 => SuffixLength::Three, - CheckCodePrefix::RUF1 => SuffixLength::One, - CheckCodePrefix::RUF10 => SuffixLength::Two, - CheckCodePrefix::RUF100 => SuffixLength::Three, - CheckCodePrefix::S => SuffixLength::Zero, - CheckCodePrefix::S1 => SuffixLength::One, - CheckCodePrefix::S10 => SuffixLength::Two, - CheckCodePrefix::S101 => SuffixLength::Three, - CheckCodePrefix::S102 => SuffixLength::Three, - CheckCodePrefix::S103 => SuffixLength::Three, - CheckCodePrefix::S104 => SuffixLength::Three, - CheckCodePrefix::S105 => SuffixLength::Three, - CheckCodePrefix::S106 => SuffixLength::Three, - CheckCodePrefix::S107 => SuffixLength::Three, - CheckCodePrefix::S108 => SuffixLength::Three, - CheckCodePrefix::SIM => SuffixLength::Zero, - CheckCodePrefix::SIM1 => SuffixLength::One, - CheckCodePrefix::SIM10 => SuffixLength::Two, - CheckCodePrefix::SIM102 => SuffixLength::Three, - CheckCodePrefix::SIM105 => SuffixLength::Three, - CheckCodePrefix::SIM107 => SuffixLength::Three, - CheckCodePrefix::SIM11 => SuffixLength::Two, - CheckCodePrefix::SIM110 => SuffixLength::Three, - CheckCodePrefix::SIM111 => SuffixLength::Three, - CheckCodePrefix::SIM117 => SuffixLength::Three, - CheckCodePrefix::SIM118 => SuffixLength::Three, - CheckCodePrefix::SIM2 => SuffixLength::One, - CheckCodePrefix::SIM22 => SuffixLength::Two, - CheckCodePrefix::SIM220 => SuffixLength::Three, - CheckCodePrefix::SIM221 => SuffixLength::Three, - CheckCodePrefix::SIM222 => SuffixLength::Three, - CheckCodePrefix::SIM223 => SuffixLength::Three, - CheckCodePrefix::SIM3 => SuffixLength::One, - CheckCodePrefix::SIM30 => SuffixLength::Two, - CheckCodePrefix::SIM300 => SuffixLength::Three, - CheckCodePrefix::T => SuffixLength::Zero, - CheckCodePrefix::T1 => SuffixLength::One, - CheckCodePrefix::T10 => SuffixLength::Two, - CheckCodePrefix::T100 => SuffixLength::Three, - CheckCodePrefix::T2 => SuffixLength::One, - CheckCodePrefix::T20 => SuffixLength::Two, - CheckCodePrefix::T201 => SuffixLength::Three, - CheckCodePrefix::T203 => SuffixLength::Three, - CheckCodePrefix::TID => SuffixLength::Zero, - CheckCodePrefix::TID2 => SuffixLength::One, - CheckCodePrefix::TID25 => SuffixLength::Two, - CheckCodePrefix::TID251 => SuffixLength::Three, - CheckCodePrefix::TID252 => SuffixLength::Three, - CheckCodePrefix::U => SuffixLength::Zero, - CheckCodePrefix::U0 => SuffixLength::One, - CheckCodePrefix::U00 => SuffixLength::Two, - CheckCodePrefix::U001 => SuffixLength::Three, - CheckCodePrefix::U003 => SuffixLength::Three, - CheckCodePrefix::U004 => SuffixLength::Three, - CheckCodePrefix::U005 => SuffixLength::Three, - CheckCodePrefix::U006 => SuffixLength::Three, - CheckCodePrefix::U007 => SuffixLength::Three, - CheckCodePrefix::U008 => SuffixLength::Three, - CheckCodePrefix::U009 => SuffixLength::Three, - CheckCodePrefix::U01 => SuffixLength::Two, - CheckCodePrefix::U010 => SuffixLength::Three, - CheckCodePrefix::U011 => SuffixLength::Three, - CheckCodePrefix::U012 => SuffixLength::Three, - CheckCodePrefix::U013 => SuffixLength::Three, - CheckCodePrefix::U014 => SuffixLength::Three, - CheckCodePrefix::U015 => SuffixLength::Three, - CheckCodePrefix::U016 => SuffixLength::Three, - CheckCodePrefix::U017 => SuffixLength::Three, - CheckCodePrefix::U019 => SuffixLength::Three, - CheckCodePrefix::UP => SuffixLength::Zero, - CheckCodePrefix::UP0 => SuffixLength::One, - CheckCodePrefix::UP00 => SuffixLength::Two, - CheckCodePrefix::UP001 => SuffixLength::Three, - CheckCodePrefix::UP003 => SuffixLength::Three, - CheckCodePrefix::UP004 => SuffixLength::Three, - CheckCodePrefix::UP005 => SuffixLength::Three, - CheckCodePrefix::UP006 => SuffixLength::Three, - CheckCodePrefix::UP007 => SuffixLength::Three, - CheckCodePrefix::UP008 => SuffixLength::Three, - CheckCodePrefix::UP009 => SuffixLength::Three, - CheckCodePrefix::UP01 => SuffixLength::Two, - CheckCodePrefix::UP010 => SuffixLength::Three, - CheckCodePrefix::UP011 => SuffixLength::Three, - CheckCodePrefix::UP012 => SuffixLength::Three, - CheckCodePrefix::UP013 => SuffixLength::Three, - CheckCodePrefix::UP014 => SuffixLength::Three, - CheckCodePrefix::UP015 => SuffixLength::Three, - CheckCodePrefix::UP016 => SuffixLength::Three, - CheckCodePrefix::UP017 => SuffixLength::Three, - CheckCodePrefix::UP018 => SuffixLength::Three, - CheckCodePrefix::UP019 => SuffixLength::Three, - CheckCodePrefix::UP02 => SuffixLength::Two, - CheckCodePrefix::UP020 => SuffixLength::Three, - CheckCodePrefix::UP021 => SuffixLength::Three, - CheckCodePrefix::UP022 => SuffixLength::Three, - CheckCodePrefix::UP023 => SuffixLength::Three, - CheckCodePrefix::UP024 => SuffixLength::Three, - CheckCodePrefix::UP025 => SuffixLength::Three, - CheckCodePrefix::UP026 => SuffixLength::Three, - CheckCodePrefix::UP027 => SuffixLength::Three, - CheckCodePrefix::UP028 => SuffixLength::Three, - CheckCodePrefix::UP029 => SuffixLength::Three, - CheckCodePrefix::W => SuffixLength::Zero, - CheckCodePrefix::W2 => SuffixLength::One, - CheckCodePrefix::W29 => SuffixLength::Two, - CheckCodePrefix::W292 => SuffixLength::Three, - CheckCodePrefix::W6 => SuffixLength::One, - CheckCodePrefix::W60 => SuffixLength::Two, - CheckCodePrefix::W605 => SuffixLength::Three, - CheckCodePrefix::YTT => SuffixLength::Zero, - CheckCodePrefix::YTT1 => SuffixLength::One, - CheckCodePrefix::YTT10 => SuffixLength::Two, - CheckCodePrefix::YTT101 => SuffixLength::Three, - CheckCodePrefix::YTT102 => SuffixLength::Three, - CheckCodePrefix::YTT103 => SuffixLength::Three, - CheckCodePrefix::YTT2 => SuffixLength::One, - CheckCodePrefix::YTT20 => SuffixLength::Two, - CheckCodePrefix::YTT201 => SuffixLength::Three, - CheckCodePrefix::YTT202 => SuffixLength::Three, - CheckCodePrefix::YTT203 => SuffixLength::Three, - CheckCodePrefix::YTT204 => SuffixLength::Three, - CheckCodePrefix::YTT3 => SuffixLength::One, - CheckCodePrefix::YTT30 => SuffixLength::Two, - CheckCodePrefix::YTT301 => SuffixLength::Three, - CheckCodePrefix::YTT302 => SuffixLength::Three, - CheckCodePrefix::YTT303 => SuffixLength::Three, - } - } -} - -pub const CATEGORIES: &[CheckCodePrefix] = &[ - CheckCodePrefix::A, - CheckCodePrefix::ALL, - CheckCodePrefix::ANN, - CheckCodePrefix::ARG, - CheckCodePrefix::B, - CheckCodePrefix::BLE, - CheckCodePrefix::C, - CheckCodePrefix::D, - CheckCodePrefix::DTZ, - CheckCodePrefix::E, - CheckCodePrefix::EM, - CheckCodePrefix::ERA, - CheckCodePrefix::F, - CheckCodePrefix::FBT, - CheckCodePrefix::I, - CheckCodePrefix::ICN, - CheckCodePrefix::ISC, - CheckCodePrefix::N, - CheckCodePrefix::PD, - CheckCodePrefix::PGH, - CheckCodePrefix::PIE, - CheckCodePrefix::PLC, - CheckCodePrefix::PLE, - CheckCodePrefix::PLR, - CheckCodePrefix::PLW, - CheckCodePrefix::PT, - CheckCodePrefix::Q, - CheckCodePrefix::RET, - CheckCodePrefix::RUF, - CheckCodePrefix::S, - CheckCodePrefix::SIM, - CheckCodePrefix::T, - CheckCodePrefix::TID, - CheckCodePrefix::UP, - CheckCodePrefix::W, - CheckCodePrefix::YTT, -]; diff --git a/src/settings/configuration.rs b/src/settings/configuration.rs index e6464b3a79796..dc262eed4e8d8 100644 --- a/src/settings/configuration.rs +++ b/src/settings/configuration.rs @@ -13,7 +13,7 @@ use shellexpand; use shellexpand::LookupError; use crate::cli::{collect_per_file_ignores, Overrides}; -use crate::registry_gen::CheckCodePrefix; +use crate::registry::CheckCodePrefix; use crate::settings::options::Options; use crate::settings::pyproject::load_options; use crate::settings::types::{ diff --git a/src/settings/mod.rs b/src/settings/mod.rs index f44e0f4c66405..fd39791ab33bf 100644 --- a/src/settings/mod.rs +++ b/src/settings/mod.rs @@ -17,8 +17,7 @@ use regex::Regex; use rustc_hash::FxHashSet; use crate::cache::cache_dir; -use crate::registry::{CheckCode, INCOMPATIBLE_CODES}; -use crate::registry_gen::{CheckCodePrefix, SuffixLength, CATEGORIES}; +use crate::registry::{CheckCode, CheckCodePrefix, SuffixLength, CATEGORIES, INCOMPATIBLE_CODES}; use crate::settings::configuration::Configuration; use crate::settings::types::{ FilePattern, PerFileIgnore, PythonVersion, SerializationFormat, Version, @@ -471,8 +470,7 @@ fn validate_enabled(enabled: FxHashSet) -> FxHashSet { mod tests { use rustc_hash::FxHashSet; - use crate::registry::CheckCode; - use crate::registry_gen::CheckCodePrefix; + use crate::registry::{CheckCode, CheckCodePrefix}; use crate::settings::{resolve_codes, CheckCodeSpec}; #[test] diff --git a/src/settings/options.rs b/src/settings/options.rs index 2a64ce1564a14..620dd963682cd 100644 --- a/src/settings/options.rs +++ b/src/settings/options.rs @@ -5,7 +5,7 @@ use rustc_hash::FxHashMap; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use crate::registry_gen::CheckCodePrefix; +use crate::registry::CheckCodePrefix; use crate::settings::types::{PythonVersion, SerializationFormat, Version}; use crate::{ flake8_annotations, flake8_bandit, flake8_bugbear, flake8_errmsg, flake8_import_conventions, diff --git a/src/settings/pyproject.rs b/src/settings/pyproject.rs index d6c0b70a4693c..a6d9a40648a12 100644 --- a/src/settings/pyproject.rs +++ b/src/settings/pyproject.rs @@ -131,7 +131,7 @@ mod tests { use crate::flake8_quotes::settings::Quote; use crate::flake8_tidy_imports::settings::{BannedApi, Strictness}; - use crate::registry_gen::CheckCodePrefix; + use crate::registry::CheckCodePrefix; use crate::settings::pyproject::{ find_settings_toml, parse_pyproject_toml, Options, Pyproject, Tools, }; diff --git a/src/settings/types.rs b/src/settings/types.rs index 938cb482cba0e..3379a3f17962d 100644 --- a/src/settings/types.rs +++ b/src/settings/types.rs @@ -12,8 +12,7 @@ use schemars::JsonSchema; use serde::{de, Deserialize, Deserializer, Serialize}; use crate::fs; -use crate::registry::CheckCode; -use crate::registry_gen::CheckCodePrefix; +use crate::registry::{CheckCode, CheckCodePrefix}; #[derive( Clone, Copy, Debug, PartialOrd, Ord, PartialEq, Eq, Serialize, Deserialize, Hash, JsonSchema, From 1b6f05c026608040f617f86f23fa10ea5fa41938 Mon Sep 17 00:00:00 2001 From: Charlie Marsh Date: Thu, 5 Jan 2023 11:38:53 -0500 Subject: [PATCH 3/3] Add version --- ruff_macros/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ruff_macros/Cargo.toml b/ruff_macros/Cargo.toml index 76146195b0f9d..128a9536e2e17 100644 --- a/ruff_macros/Cargo.toml +++ b/ruff_macros/Cargo.toml @@ -7,7 +7,7 @@ edition = "2021" proc-macro = true [dependencies] -once_cell = "1.17.0" +once_cell = { version = "1.17.0" } proc-macro2 = { version = "1.0.47" } quote = { version = "1.0.21" } syn = { version = "1.0.103", features = ["derive", "parsing"] }