[pylint] invalid-characters-* (#3552)

astral-sh · Mar 17, 2023 · 1dd3cbd · 1dd3cbd
1 parent bd935cb
commit 1dd3cbd
Show file tree

Hide file tree

Showing 14 changed files with 437 additions and 51 deletions.
diff --git a/crates/ruff/resources/test/fixtures/pylint/invalid_characters.py b/crates/ruff/resources/test/fixtures/pylint/invalid_characters.py
diff --git a/crates/ruff/src/checkers/tokens.rs b/crates/ruff/src/checkers/tokens.rs
@@ -8,7 +8,7 @@ use crate::registry::{AsRule, Rule};
 use crate::rules::ruff::rules::Context;
 use crate::rules::{
     eradicate, flake8_commas, flake8_implicit_str_concat, flake8_pyi, flake8_quotes, pycodestyle,
-    pyupgrade, ruff,
+    pylint, pyupgrade, ruff,
 };
 use crate::settings::{flags, Settings};
 use ruff_diagnostics::Diagnostic;
@@ -23,39 +23,41 @@ pub fn check_tokens(
 ) -> Vec<Diagnostic> {
     let mut diagnostics: Vec<Diagnostic> = vec![];
 
-    let enforce_ambiguous_unicode_character = settings
-        .rules
-        .enabled(Rule::AmbiguousUnicodeCharacterString)
-        || settings
-            .rules
-            .enabled(Rule::AmbiguousUnicodeCharacterDocstring)
-        || settings
-            .rules
-            .enabled(Rule::AmbiguousUnicodeCharacterComment);
-    let enforce_quotes = settings.rules.enabled(Rule::BadQuotesInlineString)
-        || settings.rules.enabled(Rule::BadQuotesMultilineString)
-        || settings.rules.enabled(Rule::BadQuotesDocstring)
-        || settings.rules.enabled(Rule::AvoidableEscapedQuote);
+    let enforce_ambiguous_unicode_character = settings.rules.any_enabled(&[
+        Rule::AmbiguousUnicodeCharacterString,
+        Rule::AmbiguousUnicodeCharacterDocstring,
+        Rule::AmbiguousUnicodeCharacterComment,
+    ]);
+    let enforce_invalid_string_character = settings.rules.any_enabled(&[
+        Rule::InvalidCharacterBackspace,
+        Rule::InvalidCharacterSub,
+        Rule::InvalidCharacterEsc,
+        Rule::InvalidCharacterNul,
+        Rule::InvalidCharacterZeroWidthSpace,
+    ]);
+    let enforce_quotes = settings.rules.any_enabled(&[
+        Rule::BadQuotesInlineString,
+        Rule::BadQuotesMultilineString,
+        Rule::BadQuotesDocstring,
+        Rule::AvoidableEscapedQuote,
+    ]);
     let enforce_commented_out_code = settings.rules.enabled(Rule::CommentedOutCode);
-    let enforce_compound_statements = settings
-        .rules
-        .enabled(Rule::MultipleStatementsOnOneLineColon)
-        || settings
-            .rules
-            .enabled(Rule::MultipleStatementsOnOneLineSemicolon)
-        || settings.rules.enabled(Rule::UselessSemicolon);
+    let enforce_compound_statements = settings.rules.any_enabled(&[
+        Rule::MultipleStatementsOnOneLineColon,
+        Rule::MultipleStatementsOnOneLineSemicolon,
+        Rule::UselessSemicolon,
+    ]);
     let enforce_invalid_escape_sequence = settings.rules.enabled(Rule::InvalidEscapeSequence);
-    let enforce_implicit_string_concatenation = settings
-        .rules
-        .enabled(Rule::SingleLineImplicitStringConcatenation)
-        || settings
-            .rules
-            .enabled(Rule::MultiLineImplicitStringConcatenation);
-    let enforce_trailing_comma = settings.rules.enabled(Rule::TrailingCommaMissing)
-        || settings
-            .rules
-            .enabled(Rule::TrailingCommaOnBareTupleProhibited)
-        || settings.rules.enabled(Rule::TrailingCommaProhibited);
+    let enforce_implicit_string_concatenation = settings.rules.any_enabled(&[
+        Rule::SingleLineImplicitStringConcatenation,
+        Rule::MultiLineImplicitStringConcatenation,
+    ]);
+
+    let enforce_trailing_comma = settings.rules.any_enabled(&[
+        Rule::TrailingCommaMissing,
+        Rule::TrailingCommaOnBareTupleProhibited,
+        Rule::TrailingCommaProhibited,
+    ]);
     let enforce_extraneous_parenthesis = settings.rules.enabled(Rule::ExtraneousParentheses);
     let enforce_type_comment_in_stub = settings.rules.enabled(Rule::TypeCommentInStub);
 
@@ -116,6 +118,18 @@ pub fn check_tokens(
             }
         }
     }
+    // PLE2510, PLE2512, PLE2513
+    if enforce_invalid_string_character {
+        for (start, tok, end) in tokens.iter().flatten() {
+            if matches!(tok, Tok::String { .. }) {
+                diagnostics.extend(
+                    pylint::rules::invalid_string_characters(locator, *start, *end, autofix.into())
+                        .into_iter()
+                        .filter(|diagnostic| settings.rules.enabled(diagnostic.kind.rule())),
+                );
+            }
+        }
+    }
 
     // E701, E702, E703
     if enforce_compound_statements {

diff --git a/crates/ruff/src/codes.rs b/crates/ruff/src/codes.rs
@@ -176,9 +176,14 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<Rule> {
         (Pylint, "E1205") => Rule::LoggingTooManyArgs,
         (Pylint, "E1206") => Rule::LoggingTooFewArgs,
         (Pylint, "E1307") => Rule::BadStringFormatType,
+        (Pylint, "E2502") => Rule::BidirectionalUnicode,
+        (Pylint, "E2510") => Rule::InvalidCharacterBackspace,
+        (Pylint, "E2512") => Rule::InvalidCharacterSub,
+        (Pylint, "E2513") => Rule::InvalidCharacterEsc,
+        (Pylint, "E2514") => Rule::InvalidCharacterNul,
+        (Pylint, "E2515") => Rule::InvalidCharacterZeroWidthSpace,
         (Pylint, "E1310") => Rule::BadStrStripCall,
         (Pylint, "E1507") => Rule::InvalidEnvvarValue,
-        (Pylint, "E2502") => Rule::BidirectionalUnicode,
         (Pylint, "R0133") => Rule::ComparisonOfConstant,
         (Pylint, "R0206") => Rule::PropertyWithParameters,
         (Pylint, "R0402") => Rule::ConsiderUsingFromImport,

diff --git a/crates/ruff/src/registry.rs b/crates/ruff/src/registry.rs
@@ -150,6 +150,11 @@ ruff_macros::register_rules!(
     rules::pylint::rules::InvalidEnvvarValue,
     rules::pylint::rules::BadStringFormatType,
     rules::pylint::rules::BidirectionalUnicode,
+    rules::pylint::rules::InvalidCharacterBackspace,
+    rules::pylint::rules::InvalidCharacterSub,
+    rules::pylint::rules::InvalidCharacterEsc,
+    rules::pylint::rules::InvalidCharacterNul,
+    rules::pylint::rules::InvalidCharacterZeroWidthSpace,
     rules::pylint::rules::BadStrStripCall,
     rules::pylint::rules::CollapsibleElseIf,
     rules::pylint::rules::ContinueInFinally,
@@ -855,6 +860,11 @@ impl Rule {
             | Rule::BadQuotesMultilineString
             | Rule::CommentedOutCode
             | Rule::MultiLineImplicitStringConcatenation
+            | Rule::InvalidCharacterBackspace
+            | Rule::InvalidCharacterSub
+            | Rule::InvalidCharacterEsc
+            | Rule::InvalidCharacterNul
+            | Rule::InvalidCharacterZeroWidthSpace
             | Rule::ExtraneousParentheses
             | Rule::InvalidEscapeSequence
             | Rule::SingleLineImplicitStringConcatenation

diff --git a/crates/ruff/src/rules/pylint/mod.rs b/crates/ruff/src/rules/pylint/mod.rs
@@ -18,19 +18,15 @@ mod tests {
     use crate::settings::Settings;
     use crate::test::test_path;
 
-    #[test_case(Rule::LoggingTooManyArgs, Path::new("logging_too_many_args.py"); "PLE1205")]
-    #[test_case(Rule::LoggingTooFewArgs, Path::new("logging_too_few_args.py"); "PLE1206")]
-    #[test_case(Rule::ReturnInInit, Path::new("return_in_init.py"); "PLE0101")]
-    #[test_case(Rule::UselessImportAlias, Path::new("import_aliasing.py"); "PLC0414")]
-    #[test_case(Rule::UnnecessaryDirectLambdaCall, Path::new("unnecessary_direct_lambda_call.py"); "PLC3002")]
-    #[test_case(Rule::NonlocalWithoutBinding, Path::new("nonlocal_without_binding.py"); "PLE0117")]
-    #[test_case(Rule::UsedPriorGlobalDeclaration, Path::new("used_prior_global_declaration.py"); "PLE0118")]
     #[test_case(Rule::AwaitOutsideAsync, Path::new("await_outside_async.py"); "PLE1142")]
+    #[test_case(Rule::BadStrStripCall, Path::new("bad_str_strip_call.py"); "PLE01310")]
+    #[test_case(Rule::BadStringFormatType, Path::new("bad_string_format_type.py"); "PLE1307")]
+    #[test_case(Rule::BidirectionalUnicode, Path::new("bidirectional_unicode.py"); "PLE2502")]
+    #[test_case(Rule::CollapsibleElseIf, Path::new("collapsible_else_if.py"); "PLR5501")]
     #[test_case(Rule::CompareToEmptyString, Path::new("compare_to_empty_string.py"); "PLC1901")]
     #[test_case(Rule::ComparisonOfConstant, Path::new("comparison_of_constant.py"); "PLR0133")]
-    #[test_case(Rule::PropertyWithParameters, Path::new("property_with_parameters.py"); "PLR0206")]
-    #[test_case(Rule::ConsiderUsingFromImport, Path::new("import_aliasing.py"); "PLR0402")]
     #[test_case(Rule::ConsiderMergingIsinstance, Path::new("consider_merging_isinstance.py"); "PLR1701")]
+    #[test_case(Rule::ConsiderUsingFromImport, Path::new("import_aliasing.py"); "PLR0402")]
     #[test_case(Rule::ConsiderUsingSysExit, Path::new("consider_using_sys_exit_0.py"); "PLR1722_0")]
     #[test_case(Rule::ConsiderUsingSysExit, Path::new("consider_using_sys_exit_1.py"); "PLR1722_1")]
     #[test_case(Rule::ConsiderUsingSysExit, Path::new("consider_using_sys_exit_2.py"); "PLR1722_2")]
@@ -39,24 +35,33 @@ mod tests {
     #[test_case(Rule::ConsiderUsingSysExit, Path::new("consider_using_sys_exit_5.py"); "PLR1722_5")]
     #[test_case(Rule::ConsiderUsingSysExit, Path::new("consider_using_sys_exit_6.py"); "PLR1722_6")]
     #[test_case(Rule::ContinueInFinally, Path::new("continue_in_finally.py"); "PLE0116")]
-    #[test_case(Rule::MagicValueComparison, Path::new("magic_value_comparison.py"); "PLR2004")]
-    #[test_case(Rule::UselessElseOnLoop, Path::new("useless_else_on_loop.py"); "PLW0120")]
-    #[test_case(Rule::GlobalVariableNotAssigned, Path::new("global_variable_not_assigned.py"); "PLW0602")]
     #[test_case(Rule::GlobalStatement, Path::new("global_statement.py"); "PLW0603")]
+    #[test_case(Rule::GlobalVariableNotAssigned, Path::new("global_variable_not_assigned.py"); "PLW0602")]
     #[test_case(Rule::InvalidAllFormat, Path::new("invalid_all_format.py"); "PLE0605")]
     #[test_case(Rule::InvalidAllObject, Path::new("invalid_all_object.py"); "PLE0604")]
+    #[test_case(Rule::InvalidCharacterBackspace, Path::new("invalid_characters.py"); "PLE2510")]
+    #[test_case(Rule::InvalidCharacterEsc, Path::new("invalid_characters.py"); "PLE2513")]
+    #[test_case(Rule::InvalidCharacterNul, Path::new("invalid_characters.py"); "PLE2514")]
+    #[test_case(Rule::InvalidCharacterSub, Path::new("invalid_characters.py"); "PLE2512")]
+    #[test_case(Rule::InvalidCharacterZeroWidthSpace, Path::new("invalid_characters.py"); "PLE2515")]
     #[test_case(Rule::InvalidEnvvarDefault, Path::new("invalid_envvar_default.py"); "PLW1508")]
     #[test_case(Rule::InvalidEnvvarValue, Path::new("invalid_envvar_value.py"); "PLE1507")]
-    #[test_case(Rule::TooManyReturnStatements, Path::new("too_many_return_statements.py"); "PLR0911")]
+    #[test_case(Rule::LoggingTooFewArgs, Path::new("logging_too_few_args.py"); "PLE1206")]
+    #[test_case(Rule::LoggingTooManyArgs, Path::new("logging_too_many_args.py"); "PLE1205")]
+    #[test_case(Rule::MagicValueComparison, Path::new("magic_value_comparison.py"); "PLR2004")]
+    #[test_case(Rule::NonlocalWithoutBinding, Path::new("nonlocal_without_binding.py"); "PLE0117")]
+    #[test_case(Rule::PropertyWithParameters, Path::new("property_with_parameters.py"); "PLR0206")]
+    #[test_case(Rule::RedefinedLoopName, Path::new("redefined_loop_name.py"); "PLW2901")]
+    #[test_case(Rule::ReturnInInit, Path::new("return_in_init.py"); "PLE0101")]
     #[test_case(Rule::TooManyArguments, Path::new("too_many_arguments.py"); "PLR0913")]
     #[test_case(Rule::TooManyBranches, Path::new("too_many_branches.py"); "PLR0912")]
+    #[test_case(Rule::TooManyReturnStatements, Path::new("too_many_return_statements.py"); "PLR0911")]
     #[test_case(Rule::TooManyStatements, Path::new("too_many_statements.py"); "PLR0915")]
-    #[test_case(Rule::CollapsibleElseIf, Path::new("collapsible_else_if.py"); "PLR5501")]
-    #[test_case(Rule::BadStringFormatType, Path::new("bad_string_format_type.py"); "PLE1307")]
-    #[test_case(Rule::BidirectionalUnicode, Path::new("bidirectional_unicode.py"); "PLE2502")]
-    #[test_case(Rule::BadStrStripCall, Path::new("bad_str_strip_call.py"); "PLE01310")]
+    #[test_case(Rule::UnnecessaryDirectLambdaCall, Path::new("unnecessary_direct_lambda_call.py"); "PLC3002")]
+    #[test_case(Rule::UsedPriorGlobalDeclaration, Path::new("used_prior_global_declaration.py"); "PLE0118")]
+    #[test_case(Rule::UselessElseOnLoop, Path::new("useless_else_on_loop.py"); "PLW0120")]
+    #[test_case(Rule::UselessImportAlias, Path::new("import_aliasing.py"); "PLC0414")]
     #[test_case(Rule::YieldInInit, Path::new("yield_in_init.py"); "PLE0100")]
-    #[test_case(Rule::RedefinedLoopName, Path::new("redefined_loop_name.py"); "PLW2901")]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());
         let diagnostics = test_path(