Bump version to 0.0.86

Cargo.lock

@@ -2045,7 +2045,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.84"
+version = "0.0.86"
 dependencies = [
  "anyhow",
  "assert_cmd",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.84"
+version = "0.0.86"
 edition = "2021"
 
 [lib]

README.md

@@ -77,7 +77,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.84
+    rev: v0.0.86
     hooks:
       - id: lint
 ```
@@ -95,6 +95,10 @@ select = [
     "F401",
     "F403",
 ]
+per-file-ignores = [
+    "__init__.py:F401",
+    "path/to/file.py:F401"
+]
 ```
 
 Alternatively, on the command-line:
@@ -257,7 +261,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | F841 | UnusedVariable | Local variable `...` is assigned to but never used |  |
 | F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` |  |
 
-### pycodestyle
+### pycodestyle (error)
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
@@ -275,7 +279,13 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | E743 | AmbiguousFunctionName | Ambiguous function name: `...` |  |
 | E902 | IOError | IOError: `...` |  |
 | E999 | SyntaxError | SyntaxError: `...` |  |
+
+### pycodestyle (warning)
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
 | W292 | NoNewLineAtEndOfFile | No newline at end of file |  |
+| W605 | InvalidEscapeSequence | Invalid escape sequence: '\c' |  |
 
 ### pydocstyle
 

resources/test/fixtures/F401_5.py

@@ -0,0 +1,5 @@
+"""Test: removal of multi-segment and aliases imports."""
+from a.b import c
+from d.e import f as g
+import h.i
+import j.k as l

resources/test/fixtures/W605.py

@@ -0,0 +1,35 @@
+#: W605:1:10
+regex = '\.png$'
+
+#: W605:2:1
+regex = '''
+\.png$
+'''
+
+#: W605:2:6
+f(
+    '\_'
+)
+
+#: W605:4:6
+"""
+multi-line
+literal
+with \_ somewhere
+in the middle
+"""
+
+#: Okay
+regex = r'\.png$'
+regex = '\\.png$'
+regex = r'''
+\.png$
+'''
+regex = r'''
+\\.png$
+'''
+s = '\\'
+regex = '\w'  # noqa
+regex = '''
+\w
+'''  # noqa

resources/test/fixtures/__init__.py

@@ -1,3 +1,5 @@
+import os
+
 print(__path__)
 
 __all__ = ["a", "b", "c"]

resources/test/fixtures/pyproject.toml

@@ -5,3 +5,6 @@ extend-exclude = [
     "migrations",
     "directory/also_excluded.py",
 ]
+per-file-ignores = [
+    "__init__.py:F401",
+]

src/check_ast.rs

@@ -1,3 +1,5 @@
+//! Lint rules based on AST traversal.
+
 use std::collections::{BTreeMap, BTreeSet};
 use std::ops::Deref;
 use std::path::Path;
@@ -2113,15 +2115,27 @@ impl<'a> Checker<'a> {
                         None
                     };
 
-                    let mut check = Check::new(
-                        CheckKind::UnusedImport(full_names.into_iter().map(String::from).collect()),
-                        self.locate_check(Range::from_located(child)),
-                    );
-                    if let Some(fix) = fix {
-                        check.amend(fix);
+                    if self.path.ends_with("__init__.py") {
+                        self.checks.push(Check::new(
+                            CheckKind::UnusedImport(
+                                full_names.into_iter().map(String::from).collect(),
+                                true,
+                            ),
+                            self.locate_check(Range::from_located(child)),
+                        ));
+                    } else {
+                        let mut check = Check::new(
+                            CheckKind::UnusedImport(
+                                full_names.into_iter().map(String::from).collect(),
+                                false,
+                            ),
+                            self.locate_check(Range::from_located(child)),
+                        );
+                        if let Some(fix) = fix {
+                            check.amend(fix);
+                        }
+                        self.checks.push(check);
                     }
-
-                    self.checks.push(check);
                 }
             }
         }

src/check_lines.rs

@@ -1,3 +1,5 @@
+//! Lint rules based on checking raw physical lines.
+
 use std::collections::BTreeMap;
 
 use rustpython_parser::ast::Location;

src/check_tokens.rs

@@ -0,0 +1,124 @@
+//! Lint rules based on token traversal.
+
+use rustpython_ast::Location;
+use rustpython_parser::lexer::{LexResult, Tok};
+
+use crate::ast::operations::SourceCodeLocator;
+use crate::ast::types::Range;
+use crate::checks::{Check, CheckCode, CheckKind};
+use crate::Settings;
+
+// See: https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals
+const VALID_ESCAPE_SEQUENCES: &[char; 23] = &[
+    '\n', '\\', '\'', '"', 'a', 'b', 'f', 'n', 'r', 't', 'v', '0', '1', '2', '3', '4', '5', '6',
+    '7', 'x', // Escape sequences only recognized in string literals
+    'N', 'u', 'U',
+];
+
+/// Return the quotation markers used for a String token.
+fn extract_quote(text: &str) -> &str {
+    if text.len() >= 3 {
+        let triple = &text[text.len() - 3..];
+        if triple == "'''" || triple == "\"\"\"" {
+            return triple;
+        }
+    }
+
+    if !text.is_empty() {
+        let single = &text[text.len() - 1..];
+        if single == "'" || single == "\"" {
+            return single;
+        }
+    }
+
+    panic!("Unable to find quotation mark for String token.")
+}
+
+/// W605
+fn invalid_escape_sequence(
+    locator: &SourceCodeLocator,
+    start: &Location,
+    end: &Location,
+) -> Vec<Check> {
+    let mut checks = vec![];
+
+    let text = locator.slice_source_code_range(&Range {
+        location: *start,
+        end_location: *end,
+    });
+
+    // Determine whether the string is single- or triple-quoted.
+    let quote = extract_quote(text);
+    let quote_pos = text.find(quote).unwrap();
+    let prefix = text[..quote_pos].to_lowercase();
+    let body = &text[(quote_pos + quote.len())..(text.len() - quote.len())];
+
+    if !prefix.contains('r') {
+        let mut col_offset = 0;
+        let mut row_offset = 0;
+        let mut in_escape = false;
+        let mut chars = body.chars();
+        let mut current = chars.next();
+        let mut next = chars.next();
+        while let (Some(current_char), Some(next_char)) = (current, next) {
+            // If we see an escaped backslash, avoid treating the character _after_ the
+            // escaped backslash as itself an escaped character.
+            if in_escape {
+                in_escape = false;
+            } else {
+                in_escape = current_char == '\\' && next_char == '\\';
+                if current_char == '\\' && !VALID_ESCAPE_SEQUENCES.contains(&next_char) {
+                    // Compute the location of the escape sequence by offsetting the location of the
+                    // string token by the characters we've seen thus far.
+                    let location = if row_offset == 0 {
+                        Location::new(
+                            start.row() + row_offset,
+                            start.column() + prefix.len() + quote.len() + col_offset,
+                        )
+                    } else {
+                        Location::new(start.row() + row_offset, col_offset + 1)
+                    };
+                    let end_location = Location::new(location.row(), location.column() + 1);
+                    checks.push(Check::new(
+                        CheckKind::InvalidEscapeSequence(next_char),
+                        Range {
+                            location,
+                            end_location,
+                        },
+                    ))
+                }
+            }
+
+            // Track the offset from the start position as we iterate over the body.
+            if current_char == '\n' {
+                col_offset = 0;
+                row_offset += 1;
+            } else {
+                col_offset += 1;
+            }
+
+            current = next;
+            next = chars.next();
+        }
+    }
+
+    checks
+}
+
+pub fn check_tokens(
+    checks: &mut Vec<Check>,
+    contents: &str,
+    tokens: &[LexResult],
+    settings: &Settings,
+) {
+    // TODO(charlie): Use a shared SourceCodeLocator between this site and the AST traversal.
+    let locator = SourceCodeLocator::new(contents);
+    let enforce_invalid_escape_sequence = settings.enabled.contains(&CheckCode::W605);
+    for (start, tok, end) in tokens.iter().flatten() {
+        if enforce_invalid_escape_sequence {
+            if matches!(tok, Tok::String { .. }) {
+                checks.extend(invalid_escape_sequence(&locator, start, end));
+            }
+        }
+    }
+}

src/checks.rs

@@ -41,6 +41,7 @@ pub enum CheckCode {
     E999,
     // pycodestyle warnings
     W292,
+    W605,
     // pyflakes
     F401,
     F402,
@@ -174,7 +175,8 @@ pub enum CheckCode {
 #[derive(EnumIter, Debug, PartialEq, Eq)]
 pub enum CheckCategory {
     Pyflakes,
-    Pycodestyle,
+    PycodestyleError,
+    PycodestyleWarning,
     Pydocstyle,
     Pyupgrade,
     PEP8Naming,
@@ -188,7 +190,8 @@ pub enum CheckCategory {
 impl CheckCategory {
     pub fn title(&self) -> &'static str {
         match self {
-            CheckCategory::Pycodestyle => "pycodestyle",
+            CheckCategory::PycodestyleError => "pycodestyle (error)",
+            CheckCategory::PycodestyleWarning => "pycodestyle (warning)",
             CheckCategory::Pyflakes => "Pyflakes",
             CheckCategory::Flake8Builtins => "flake8-builtins",
             CheckCategory::Flake8Bugbear => "flake8-bugbear",
@@ -205,8 +208,9 @@ impl CheckCategory {
 #[allow(clippy::upper_case_acronyms)]
 pub enum LintSource {
     AST,
-    Lines,
     FileSystem,
+    Lines,
+    Tokens,
 }
 
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -234,6 +238,7 @@ pub enum CheckKind {
     TypeComparison,
     // pycodestyle warnings
     NoNewLineAtEndOfFile,
+    InvalidEscapeSequence(char),
     // pyflakes
     AssertTuple,
     BreakOutsideLoop,
@@ -260,7 +265,7 @@ pub enum CheckKind {
     UndefinedExport(String),
     UndefinedLocal(String),
     UndefinedName(String),
-    UnusedImport(Vec<String>),
+    UnusedImport(Vec<String>, bool),
     UnusedVariable(String),
     YieldOutsideFunction,
     // flake8-builtins
@@ -369,6 +374,7 @@ impl CheckCode {
     pub fn lint_source(&self) -> &'static LintSource {
         match self {
             CheckCode::E501 | CheckCode::W292 | CheckCode::M001 => &LintSource::Lines,
+            CheckCode::W605 => &LintSource::Tokens,
             CheckCode::E902 => &LintSource::FileSystem,
             _ => &LintSource::AST,
         }
@@ -394,8 +400,9 @@ impl CheckCode {
             CheckCode::E999 => CheckKind::SyntaxError("`...`".to_string()),
             // pycodestyle warnings
             CheckCode::W292 => CheckKind::NoNewLineAtEndOfFile,
+            CheckCode::W605 => CheckKind::InvalidEscapeSequence('c'),
             // pyflakes
-            CheckCode::F401 => CheckKind::UnusedImport(vec!["...".to_string()]),
+            CheckCode::F401 => CheckKind::UnusedImport(vec!["...".to_string()], false),
             CheckCode::F402 => CheckKind::ImportShadowedByLoopVar("...".to_string(), 1),
             CheckCode::F403 => CheckKind::ImportStarUsed("...".to_string()),
             CheckCode::F404 => CheckKind::LateFutureImport,
@@ -561,21 +568,22 @@ impl CheckCode {
 
     pub fn category(&self) -> CheckCategory {
         match self {
-            CheckCode::E402 => CheckCategory::Pycodestyle,
-            CheckCode::E501 => CheckCategory::Pycodestyle,
-            CheckCode::E711 => CheckCategory::Pycodestyle,
-            CheckCode::E712 => CheckCategory::Pycodestyle,
-            CheckCode::E713 => CheckCategory::Pycodestyle,
-            CheckCode::E714 => CheckCategory::Pycodestyle,
-            CheckCode::E721 => CheckCategory::Pycodestyle,
-            CheckCode::E722 => CheckCategory::Pycodestyle,
-            CheckCode::E731 => CheckCategory::Pycodestyle,
-            CheckCode::E741 => CheckCategory::Pycodestyle,
-            CheckCode::E742 => CheckCategory::Pycodestyle,
-            CheckCode::E743 => CheckCategory::Pycodestyle,
-            CheckCode::E902 => CheckCategory::Pycodestyle,
-            CheckCode::E999 => CheckCategory::Pycodestyle,
-            CheckCode::W292 => CheckCategory::Pycodestyle,
+            CheckCode::E402 => CheckCategory::PycodestyleError,
+            CheckCode::E501 => CheckCategory::PycodestyleError,
+            CheckCode::E711 => CheckCategory::PycodestyleError,
+            CheckCode::E712 => CheckCategory::PycodestyleError,
+            CheckCode::E713 => CheckCategory::PycodestyleError,
+            CheckCode::E714 => CheckCategory::PycodestyleError,
+            CheckCode::E721 => CheckCategory::PycodestyleError,
+            CheckCode::E722 => CheckCategory::PycodestyleError,
+            CheckCode::E731 => CheckCategory::PycodestyleError,
+            CheckCode::E741 => CheckCategory::PycodestyleError,
+            CheckCode::E742 => CheckCategory::PycodestyleError,
+            CheckCode::E743 => CheckCategory::PycodestyleError,
+            CheckCode::E902 => CheckCategory::PycodestyleError,
+            CheckCode::E999 => CheckCategory::PycodestyleError,
+            CheckCode::W292 => CheckCategory::PycodestyleWarning,
+            CheckCode::W605 => CheckCategory::PycodestyleWarning,
             CheckCode::F401 => CheckCategory::Pyflakes,
             CheckCode::F402 => CheckCategory::Pyflakes,
             CheckCode::F403 => CheckCategory::Pyflakes,
@@ -743,11 +751,12 @@ impl CheckKind {
             CheckKind::UndefinedExport(_) => &CheckCode::F822,
             CheckKind::UndefinedLocal(_) => &CheckCode::F823,
             CheckKind::UndefinedName(_) => &CheckCode::F821,
-            CheckKind::UnusedImport(_) => &CheckCode::F401,
+            CheckKind::UnusedImport(_, _) => &CheckCode::F401,
             CheckKind::UnusedVariable(_) => &CheckCode::F841,
             CheckKind::YieldOutsideFunction => &CheckCode::F704,
             // pycodestyle warnings
             CheckKind::NoNewLineAtEndOfFile => &CheckCode::W292,
+            CheckKind::InvalidEscapeSequence(_) => &CheckCode::W605,
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(_) => &CheckCode::A001,
             CheckKind::BuiltinArgumentShadowing(_) => &CheckCode::A002,
@@ -971,9 +980,13 @@ impl CheckKind {
             CheckKind::UndefinedName(name) => {
                 format!("Undefined name `{name}`")
             }
-            CheckKind::UnusedImport(names) => {
+            CheckKind::UnusedImport(names, in_init_py) => {
                 let names = names.iter().map(|name| format!("`{name}`")).join(", ");
-                format!("{names} imported but unused")
+                if *in_init_py {
+                    format!("{names} imported but unused and missing from `__all__`")
+                } else {
+                    format!("{names} imported but unused")
+                }
             }
             CheckKind::UnusedVariable(name) => {
                 format!("Local variable `{name}` is assigned to but never used")
@@ -983,6 +996,7 @@ impl CheckKind {
             }
             // pycodestyle warnings
             CheckKind::NoNewLineAtEndOfFile => "No newline at end of file".to_string(),
+            CheckKind::InvalidEscapeSequence(char) => format!("Invalid escape sequence: '\\{char}'"),
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(name) => {
                 format!("Variable `{name}` is shadowing a python builtin")
@@ -1328,7 +1342,7 @@ impl CheckKind {
                 | CheckKind::SuperCallWithParameters
                 | CheckKind::TypeOfPrimitive(_)
                 | CheckKind::UnnecessaryAbspath
-                | CheckKind::UnusedImport(_)
+                | CheckKind::UnusedImport(_, false)
                 | CheckKind::UnusedLoopControlVariable(_)
                 | CheckKind::UnusedNOQA(_)
                 | CheckKind::UsePEP585Annotation(_)

src/cli.rs

@@ -21,11 +21,14 @@ pub struct Cli {
     #[arg(long)]
     pub config: Option<PathBuf>,
     /// Enable verbose logging.
-    #[arg(short, long)]
+    #[arg(short, long, group = "verbosity")]
     pub verbose: bool,
-    /// Disable all logging (but still exit with status code "1" upon detecting errors).
-    #[arg(short, long)]
+    /// Only log errors.
+    #[arg(short, long, group = "verbosity")]
     pub quiet: bool,
+    /// Disable all logging (but still exit with status code "1" upon detecting errors).
+    #[arg(short, long, group = "verbosity")]
+    pub silent: bool,
     /// Exit with status code "0", even upon detecting errors.
     #[arg(short, long)]
     pub exit_zero: bool,

src/cst/helpers.rs

@@ -0,0 +1,42 @@
+use libcst_native::{Expression, NameOrAttribute};
+
+fn compose_call_path_inner<'a>(expr: &'a Expression, parts: &mut Vec<&'a str>) {
+    match &expr {
+        Expression::Call(expr) => {
+            compose_call_path_inner(&expr.func, parts);
+        }
+        Expression::Attribute(expr) => {
+            compose_call_path_inner(&expr.value, parts);
+            parts.push(expr.attr.value);
+        }
+        Expression::Name(expr) => {
+            parts.push(expr.value);
+        }
+        _ => {}
+    }
+}
+
+pub fn compose_call_path(expr: &Expression) -> Option<String> {
+    let mut segments = vec![];
+    compose_call_path_inner(expr, &mut segments);
+    if segments.is_empty() {
+        None
+    } else {
+        Some(segments.join("."))
+    }
+}
+
+pub fn compose_module_path(module: &NameOrAttribute) -> String {
+    match module {
+        NameOrAttribute::N(name) => name.value.to_string(),
+        NameOrAttribute::A(attr) => {
+            let name = attr.attr.value;
+            let prefix = compose_call_path(&attr.value);
+            if let Some(prefix) = prefix {
+                format!("{prefix}.{name}")
+            } else {
+                name.to_string()
+            }
+        }
+    }
+}

src/cst/mod.rs

@@ -0,0 +1 @@
+pub mod helpers;

src/flake8_comprehensions/checks.rs

@@ -37,7 +37,7 @@ fn first_argument_with_matching_function<'a>(
     Some(&args.first()?.node)
 }
 
-/// Check `list(generator)` compliance.
+/// C400 (`list(generator)`)
 pub fn unnecessary_generator_list(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
     let argument = exactly_one_argument_with_matching_function("list", func, args)?;
     if let ExprKind::GeneratorExp { .. } = argument {
@@ -49,7 +49,7 @@ pub fn unnecessary_generator_list(expr: &Expr, func: &Expr, args: &[Expr]) -> Op
     None
 }
 
-/// Check `set(generator)` compliance.
+/// C401 (`set(generator)`)
 pub fn unnecessary_generator_set(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
     let argument = exactly_one_argument_with_matching_function("set", func, args)?;
     if let ExprKind::GeneratorExp { .. } = argument {
@@ -61,7 +61,7 @@ pub fn unnecessary_generator_set(expr: &Expr, func: &Expr, args: &[Expr]) -> Opt
     None
 }
 
-/// Check `dict((x, y) for x, y in iterable)` compliance.
+/// C402 (`dict((x, y) for x, y in iterable)`)
 pub fn unnecessary_generator_dict(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
     let argument = exactly_one_argument_with_matching_function("dict", func, args)?;
     if let ExprKind::GeneratorExp { elt, .. } = argument {
@@ -78,7 +78,7 @@ pub fn unnecessary_generator_dict(expr: &Expr, func: &Expr, args: &[Expr]) -> Op
     None
 }
 
-/// Check `set([...])` compliance.
+/// C403 (`set([...])`)
 pub fn unnecessary_list_comprehension_set(
     expr: &Expr,
     func: &Expr,
@@ -94,7 +94,7 @@ pub fn unnecessary_list_comprehension_set(
     None
 }
 
-/// Check `dict([...])` compliance.
+/// C404 (`dict([...])`)
 pub fn unnecessary_list_comprehension_dict(
     expr: &Expr,
     func: &Expr,
@@ -115,7 +115,7 @@ pub fn unnecessary_list_comprehension_dict(
     None
 }
 
-/// Check `set([1, 2])` compliance.
+/// C405 (`set([1, 2])`)
 pub fn unnecessary_literal_set(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
     let argument = exactly_one_argument_with_matching_function("set", func, args)?;
     let kind = match argument {
@@ -129,7 +129,7 @@ pub fn unnecessary_literal_set(expr: &Expr, func: &Expr, args: &[Expr]) -> Optio
     ))
 }
 
-/// Check `dict([(1, 2)])` compliance.
+/// C406 (`dict([(1, 2)])`)
 pub fn unnecessary_literal_dict(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
     let argument = exactly_one_argument_with_matching_function("dict", func, args)?;
     let (kind, elts) = match argument {
@@ -151,6 +151,7 @@ pub fn unnecessary_literal_dict(expr: &Expr, func: &Expr, args: &[Expr]) -> Opti
     ))
 }
 
+/// C408
 pub fn unnecessary_collection_call(
     expr: &Expr,
     func: &Expr,
@@ -162,10 +163,10 @@ pub fn unnecessary_collection_call(
     }
     let id = function_name(func)?;
     match id {
+        "dict" if keywords.is_empty() || keywords.iter().all(|kw| kw.node.arg.is_some()) => (),
         "list" | "tuple" => {
             // list() or tuple()
         }
-        "dict" if keywords.is_empty() || keywords.iter().all(|kw| kw.node.arg.is_some()) => (),
         _ => return None,
     };
     Some(Check::new(
@@ -174,6 +175,7 @@ pub fn unnecessary_collection_call(
     ))
 }
 
+/// C409
 pub fn unnecessary_literal_within_tuple_call(
     expr: &Expr,
     func: &Expr,
@@ -191,6 +193,7 @@ pub fn unnecessary_literal_within_tuple_call(
     ))
 }
 
+/// C410
 pub fn unnecessary_literal_within_list_call(
     expr: &Expr,
     func: &Expr,
@@ -208,6 +211,7 @@ pub fn unnecessary_literal_within_list_call(
     ))
 }
 
+/// C411
 pub fn unnecessary_list_call(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
     let argument = first_argument_with_matching_function("list", func, args)?;
     if let ExprKind::ListComp { .. } = argument {
@@ -219,6 +223,7 @@ pub fn unnecessary_list_call(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<
     None
 }
 
+/// C413
 pub fn unnecessary_call_around_sorted(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
     let outer = function_name(func)?;
     if !(outer == "list" || outer == "reversed") {
@@ -235,6 +240,7 @@ pub fn unnecessary_call_around_sorted(expr: &Expr, func: &Expr, args: &[Expr]) -
     None
 }
 
+/// C414
 pub fn unnecessary_double_cast_or_process(
     expr: &Expr,
     func: &Expr,
@@ -274,6 +280,7 @@ pub fn unnecessary_double_cast_or_process(
     None
 }
 
+/// C415
 pub fn unnecessary_subscript_reversal(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
     let first_arg = args.first()?;
     let id = function_name(func)?;
@@ -309,6 +316,7 @@ pub fn unnecessary_subscript_reversal(expr: &Expr, func: &Expr, args: &[Expr]) -
     None
 }
 
+/// C416
 pub fn unnecessary_comprehension(
     expr: &Expr,
     elt: &Expr,
@@ -337,6 +345,7 @@ pub fn unnecessary_comprehension(
     ))
 }
 
+/// C417
 pub fn unnecessary_map(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
     fn new_check(kind: &str, expr: &Expr) -> Check {
         Check::new(

src/lib.rs

@@ -16,9 +16,11 @@ mod autofix;
 pub mod cache;
 pub mod check_ast;
 mod check_lines;
+mod check_tokens;
 pub mod checks;
 pub mod cli;
 pub mod code_gen;
+mod cst;
 mod docstrings;
 mod flake8_bugbear;
 mod flake8_builtins;
@@ -41,7 +43,7 @@ pub mod settings;
 pub mod visibility;
 
 /// Run ruff over Python source code directly.
-pub fn check(path: &Path, contents: &str) -> Result<Vec<Message>> {
+pub fn check(path: &Path, contents: &str, quiet: bool) -> Result<Vec<Message>> {
     // Find the project root and pyproject.toml.
     let project_root = pyproject::find_project_root(&[path.to_path_buf()]);
     match &project_root {
@@ -54,7 +56,11 @@ pub fn check(path: &Path, contents: &str) -> Result<Vec<Message>> {
         None => debug!("Unable to find pyproject.toml; using default settings..."),
     };
 
-    let settings = Settings::from_raw(RawSettings::from_pyproject(&pyproject, &project_root)?);
+    let settings = Settings::from_raw(RawSettings::from_pyproject(
+        &pyproject,
+        &project_root,
+        quiet,
+    )?);
 
     // Tokenize once.
     let tokens: Vec<LexResult> = tokenize(contents);

src/linter.rs

@@ -14,6 +14,7 @@ use crate::autofix::fixer;
 use crate::autofix::fixer::fix_file;
 use crate::check_ast::check_ast;
 use crate::check_lines::check_lines;
+use crate::check_tokens::check_tokens;
 use crate::checks::{Check, CheckCode, CheckKind, LintSource};
 use crate::code_gen::SourceGenerator;
 use crate::message::Message;
@@ -45,6 +46,15 @@ pub(crate) fn check_path(
     // Aggregate all checks.
     let mut checks: Vec<Check> = vec![];
 
+    // Run the token-based checks.
+    if settings
+        .enabled
+        .iter()
+        .any(|check_code| matches!(check_code.lint_source(), LintSource::Tokens))
+    {
+        check_tokens(&mut checks, contents, &tokens, settings);
+    }
+
     // Run the AST-based checks.
     if settings
         .enabled
@@ -330,6 +340,7 @@ mod tests {
     #[test_case(CheckCode::F401, Path::new("F401_2.py"); "F401_2")]
     #[test_case(CheckCode::F401, Path::new("F401_3.py"); "F401_3")]
     #[test_case(CheckCode::F401, Path::new("F401_4.py"); "F401_4")]
+    #[test_case(CheckCode::F401, Path::new("F401_5.py"); "F401_5")]
     #[test_case(CheckCode::F402, Path::new("F402.py"); "F402")]
     #[test_case(CheckCode::F403, Path::new("F403.py"); "F403")]
     #[test_case(CheckCode::F404, Path::new("F404.py"); "F404")]
@@ -380,6 +391,7 @@ mod tests {
     #[test_case(CheckCode::W292, Path::new("W292_0.py"); "W292_0")]
     #[test_case(CheckCode::W292, Path::new("W292_1.py"); "W292_1")]
     #[test_case(CheckCode::W292, Path::new("W292_2.py"); "W292_2")]
+    #[test_case(CheckCode::W605, Path::new("W605.py"); "W605")]
     fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
         let mut checks = check_path(

src/main.rs

@@ -220,7 +220,8 @@ fn autoformat(files: &[PathBuf], settings: &Settings) -> Result<usize> {
 }
 
 fn inner_main() -> Result<ExitCode> {
-    let cli = Cli::parse();
+    let mut cli = Cli::parse();
+    cli.quiet |= cli.silent;
 
     set_up_logging(cli.verbose)?;
 
@@ -255,7 +256,7 @@ fn inner_main() -> Result<ExitCode> {
         .map(|pair| PerFileIgnore::new(pair, &project_root))
         .collect();
 
-    let mut settings = RawSettings::from_pyproject(&pyproject, &project_root)?;
+    let mut settings = RawSettings::from_pyproject(&pyproject, &project_root, cli.quiet)?;
     if !exclude.is_empty() {
         settings.exclude = exclude;
     }
@@ -342,7 +343,7 @@ fn inner_main() -> Result<ExitCode> {
         tell_user!("Starting linter in watch mode...\n");
 
         let messages = run_once(&cli.files, &settings, !cli.no_cache, false)?;
-        if !cli.quiet {
+        if !cli.silent {
             printer.write_continuously(&messages)?;
         }
 
@@ -362,7 +363,7 @@ fn inner_main() -> Result<ExitCode> {
                             tell_user!("File change detected...\n");
 
                             let messages = run_once(&cli.files, &settings, !cli.no_cache, false)?;
-                            if !cli.quiet {
+                            if !cli.silent {
                                 printer.write_continuously(&messages)?;
                             }
                         }
@@ -388,13 +389,13 @@ fn inner_main() -> Result<ExitCode> {
                 let path = Path::new(&filename);
                 (
                     run_once_stdin(&settings, path, cli.fix)?,
-                    !cli.quiet && !cli.fix,
+                    !cli.silent && !cli.fix,
                     false,
                 )
             } else {
                 (
                     run_once(&cli.files, &settings, !cli.no_cache, cli.fix)?,
-                    !cli.quiet,
+                    !cli.silent,
                     !cli.quiet,
                 )
             };

src/pycodestyle/checks.rs

@@ -8,7 +8,7 @@ fn is_ambiguous_name(name: &str) -> bool {
     name == "l" || name == "I" || name == "O"
 }
 
-/// Check AmbiguousVariableName compliance.
+/// E741
 pub fn ambiguous_variable_name(name: &str, location: Range) -> Option<Check> {
     if is_ambiguous_name(name) {
         Some(Check::new(
@@ -20,7 +20,7 @@ pub fn ambiguous_variable_name(name: &str, location: Range) -> Option<Check> {
     }
 }
 
-/// Check AmbiguousClassName compliance.
+/// E742
 pub fn ambiguous_class_name(name: &str, location: Range) -> Option<Check> {
     if is_ambiguous_name(name) {
         Some(Check::new(
@@ -32,7 +32,7 @@ pub fn ambiguous_class_name(name: &str, location: Range) -> Option<Check> {
     }
 }
 
-/// Check AmbiguousFunctionName compliance.
+/// E743
 pub fn ambiguous_function_name(name: &str, location: Range) -> Option<Check> {
     if is_ambiguous_name(name) {
         Some(Check::new(
@@ -44,7 +44,7 @@ pub fn ambiguous_function_name(name: &str, location: Range) -> Option<Check> {
     }
 }
 
-/// Check DoNotAssignLambda compliance.
+/// E731
 pub fn do_not_assign_lambda(value: &Expr, location: Range) -> Option<Check> {
     if let ExprKind::Lambda { .. } = &value.node {
         Some(Check::new(CheckKind::DoNotAssignLambda, location))
@@ -53,7 +53,7 @@ pub fn do_not_assign_lambda(value: &Expr, location: Range) -> Option<Check> {
     }
 }
 
-/// Check NotInTest and NotIsTest compliance.
+/// E713, E714
 pub fn not_tests(
     op: &Unaryop,
     operand: &Expr,
@@ -92,7 +92,7 @@ pub fn not_tests(
     checks
 }
 
-/// Check TrueFalseComparison and NoneComparison compliance.
+/// E711, E712
 pub fn literal_comparisons(
     left: &Expr,
     ops: &[Cmpop],
@@ -201,7 +201,7 @@ pub fn literal_comparisons(
     checks
 }
 
-/// Check TypeComparison compliance.
+/// E721
 pub fn type_comparison(ops: &[Cmpop], comparators: &[Expr], location: Range) -> Vec<Check> {
     let mut checks: Vec<Check> = vec![];
 

src/pyflakes/checks.rs

@@ -10,7 +10,7 @@ use rustpython_parser::ast::{
 use crate::ast::types::{BindingKind, CheckLocator, FunctionScope, Range, Scope, ScopeKind};
 use crate::checks::{Check, CheckKind};
 
-/// Check IfTuple compliance.
+/// F634
 pub fn if_tuple(test: &Expr, location: Range) -> Option<Check> {
     if let ExprKind::Tuple { elts, .. } = &test.node {
         if !elts.is_empty() {
@@ -20,7 +20,7 @@ pub fn if_tuple(test: &Expr, location: Range) -> Option<Check> {
     None
 }
 
-/// Check AssertTuple compliance.
+/// F631
 pub fn assert_tuple(test: &Expr, location: Range) -> Option<Check> {
     if let ExprKind::Tuple { elts, .. } = &test.node {
         if !elts.is_empty() {
@@ -30,7 +30,7 @@ pub fn assert_tuple(test: &Expr, location: Range) -> Option<Check> {
     None
 }
 
-/// Check UnusedVariable compliance.
+/// F841
 pub fn unused_variables(
     scope: &Scope,
     locator: &dyn CheckLocator,
@@ -63,7 +63,7 @@ pub fn unused_variables(
     checks
 }
 
-/// Check DefaultExceptNotLast compliance.
+/// F707
 pub fn default_except_not_last(handlers: &[Excepthandler]) -> Option<Check> {
     for (idx, handler) in handlers.iter().enumerate() {
         let ExcepthandlerKind::ExceptHandler { type_, .. } = &handler.node;
@@ -78,7 +78,7 @@ pub fn default_except_not_last(handlers: &[Excepthandler]) -> Option<Check> {
     None
 }
 
-/// Check RaiseNotImplemented compliance.
+/// F901
 pub fn raise_not_implemented(expr: &Expr) -> Option<Check> {
     match &expr.node {
         ExprKind::Call { func, .. } => {
@@ -105,7 +105,7 @@ pub fn raise_not_implemented(expr: &Expr) -> Option<Check> {
     None
 }
 
-/// Check DuplicateArgumentName compliance.
+/// F831
 pub fn duplicate_arguments(arguments: &Arguments) -> Vec<Check> {
     let mut checks: Vec<Check> = vec![];
 
@@ -153,7 +153,7 @@ fn convert_to_value(expr: &Expr) -> Option<DictionaryKey> {
     }
 }
 
-/// Check MultiValueRepeatedKeyLiteral and MultiValueRepeatedKeyVariable compliance.
+/// F601, F602
 pub fn repeated_keys(
     keys: &[Expr],
     check_repeated_literals: bool,
@@ -215,7 +215,7 @@ fn is_constant_non_singleton(expr: &Expr) -> bool {
     is_constant(expr) && !is_singleton(expr)
 }
 
-/// Check IsLiteral compliance.
+/// F632
 pub fn is_literal(left: &Expr, ops: &[Cmpop], comparators: &[Expr], location: Range) -> Vec<Check> {
     let mut checks: Vec<Check> = vec![];
 
@@ -232,7 +232,7 @@ pub fn is_literal(left: &Expr, ops: &[Cmpop], comparators: &[Expr], location: Ra
     checks
 }
 
-/// Check TwoStarredExpressions and TooManyExpressionsInStarredAssignment compliance.
+/// F621, F622
 pub fn starred_expressions(
     elts: &[Expr],
     check_too_many_expressions: bool,
@@ -262,7 +262,7 @@ pub fn starred_expressions(
     None
 }
 
-/// Check BreakOutsideLoop compliance.
+/// F701
 pub fn break_outside_loop(
     stmt: &Stmt,
     parents: &[&Stmt],
@@ -303,7 +303,7 @@ pub fn break_outside_loop(
     }
 }
 
-/// Check ContinueOutsideLoop compliance.
+/// F702
 pub fn continue_outside_loop(
     stmt: &Stmt,
     parents: &[&Stmt],

src/pyflakes/fixes.rs

@@ -1,11 +1,11 @@
-use libcst_native::ImportNames::Aliases;
-use libcst_native::NameOrAttribute::N;
-use libcst_native::{Codegen, SmallStatement, Statement};
+use anyhow::Result;
+use libcst_native::{Codegen, ImportNames, NameOrAttribute, SmallStatement, Statement};
 use rustpython_ast::Stmt;
 
 use crate::ast::operations::SourceCodeLocator;
 use crate::ast::types::Range;
 use crate::autofix::{helpers, Fix};
+use crate::cst::helpers::compose_module_path;
 
 /// Generate a Fix to remove any unused imports from an `import` statement.
 pub fn remove_unused_imports(
@@ -14,7 +14,7 @@ pub fn remove_unused_imports(
     stmt: &Stmt,
     parent: Option<&Stmt>,
     deleted: &[&Stmt],
-) -> anyhow::Result<Fix> {
+) -> Result<Fix> {
     let mut tree = match libcst_native::parse_module(
         locator.slice_source_code_range(&Range::from_located(stmt)),
         None,
@@ -40,13 +40,11 @@ pub fn remove_unused_imports(
     // Preserve the trailing comma (or not) from the last entry.
     let trailing_comma = aliases.last().and_then(|alias| alias.comma.clone());
 
-    // Identify unused imports from within the `import from`.
+    // Identify unused imports from within the `import`.
     let mut removable = vec![];
     for (index, alias) in aliases.iter().enumerate() {
-        if let N(import_name) = &alias.name {
-            if full_names.contains(&import_name.value) {
-                removable.push(index);
-            }
+        if full_names.contains(&compose_module_path(&alias.name).as_str()) {
+            removable.push(index);
         }
     }
     // TODO(charlie): This is quadratic.
@@ -79,7 +77,7 @@ pub fn remove_unused_import_froms(
     stmt: &Stmt,
     parent: Option<&Stmt>,
     deleted: &[&Stmt],
-) -> anyhow::Result<Fix> {
+) -> Result<Fix> {
     let mut tree = match libcst_native::parse_module(
         locator.slice_source_code_range(&Range::from_located(stmt)),
         None,
@@ -100,7 +98,8 @@ pub fn remove_unused_import_froms(
             "Expected node to be: SmallStatement::ImportFrom."
         ));
     };
-    let aliases = if let Aliases(aliases) = &mut body.names {
+
+    let aliases = if let ImportNames::Aliases(aliases) = &mut body.names {
         aliases
     } else {
         return Err(anyhow::anyhow!("Expected node to be: Aliases."));
@@ -112,13 +111,16 @@ pub fn remove_unused_import_froms(
     // Identify unused imports from within the `import from`.
     let mut removable = vec![];
     for (index, alias) in aliases.iter().enumerate() {
-        if let N(name) = &alias.name {
-            let import_name = if let Some(N(module_name)) = &body.module {
-                format!("{}.{}", module_name.value, name.value)
-            } else {
-                name.value.to_string()
-            };
-            if full_names.contains(&import_name.as_str()) {
+        if let NameOrAttribute::N(name) = &alias.name {
+            let import_name = name.value.to_string();
+            let full_name = body
+                .module
+                .as_ref()
+                .map(compose_module_path)
+                .map(|module_name| format!("{module_name}.{import_name}"))
+                .unwrap_or(import_name);
+
+            if full_names.contains(&full_name.as_str()) {
                 removable.push(index);
             }
         }

src/pyproject.rs

@@ -11,15 +11,17 @@ use crate::checks::CheckCode;
 use crate::fs;
 use crate::settings::PythonVersion;
 
-pub fn load_config(pyproject: &Option<PathBuf>) -> Result<Config> {
+pub fn load_config(pyproject: &Option<PathBuf>, quiet: bool) -> Result<Config> {
     match pyproject {
         Some(pyproject) => Ok(parse_pyproject_toml(pyproject)?
             .tool
             .and_then(|tool| tool.ruff)
             .unwrap_or_default()),
         None => {
-            eprintln!("No pyproject.toml found.");
-            eprintln!("Falling back to default configuration...");
+            if !quiet {
+                eprintln!("No pyproject.toml found.");
+                eprintln!("Falling back to default configuration...");
+            }
             Ok(Default::default())
         }
     }
@@ -79,7 +81,7 @@ impl FromStr for StrCheckCodePair {
             if tokens.len() != 2 {
                 return Err(anyhow!("Expected {}", Self::EXPECTED_PATTERN));
             }
-            (tokens[0], tokens[1])
+            (tokens[0].trim(), tokens[1].trim())
         };
         let code = CheckCode::from_str(code_string)?;
         let pattern = pattern_str.into();
@@ -360,7 +362,10 @@ other-attribute = 1
                 extend_select: vec![],
                 ignore: vec![],
                 extend_ignore: vec![],
-                per_file_ignores: vec![],
+                per_file_ignores: vec![StrCheckCodePair {
+                    pattern: "__init__.py".to_string(),
+                    code: CheckCode::F401
+                }],
                 dummy_variable_rgx: None,
                 target_version: None,
             }
@@ -373,6 +378,8 @@ other-attribute = 1
     fn str_check_code_pair_strings() {
         let result = StrCheckCodePair::from_str("foo:E501");
         assert!(result.is_ok());
+        let result = StrCheckCodePair::from_str("foo: E501");
+        assert!(result.is_ok());
         let result = StrCheckCodePair::from_str("E501:foo");
         assert!(result.is_err());
         let result = StrCheckCodePair::from_str("E501");

src/pyupgrade/checks.rs

@@ -5,7 +5,7 @@ use crate::ast::types::{Binding, BindingKind, Range, Scope, ScopeKind};
 use crate::checks::{Check, CheckKind};
 use crate::pyupgrade::types::Primitive;
 
-/// Check that `super()` has no args
+/// U008
 pub fn super_args(
     scope: &Scope,
     parents: &[&Stmt],
@@ -70,7 +70,7 @@ pub fn super_args(
     None
 }
 
-/// Check UselessMetaclassType compliance.
+/// U001
 pub fn useless_metaclass_type(targets: &[Expr], value: &Expr, location: Range) -> Option<Check> {
     if targets.len() == 1 {
         if let ExprKind::Name { id, .. } = targets.first().map(|expr| &expr.node).unwrap() {
@@ -86,7 +86,7 @@ pub fn useless_metaclass_type(targets: &[Expr], value: &Expr, location: Range) -
     None
 }
 
-/// Check UnnecessaryAbspath compliance.
+/// U002
 pub fn unnecessary_abspath(func: &Expr, args: &[Expr], location: Range) -> Option<Check> {
     // Validate the arguments.
     if args.len() == 1 {
@@ -106,7 +106,7 @@ pub fn unnecessary_abspath(func: &Expr, args: &[Expr], location: Range) -> Optio
     None
 }
 
-/// Check UselessObjectInheritance compliance.
+/// U004
 pub fn useless_object_inheritance(name: &str, bases: &[Expr], scope: &Scope) -> Option<Check> {
     for expr in bases {
         if let ExprKind::Name { id, .. } = &expr.node {
@@ -131,7 +131,7 @@ pub fn useless_object_inheritance(name: &str, bases: &[Expr], scope: &Scope) ->
     None
 }
 
-/// Check TypeOfPrimitive compliance.
+/// U003
 pub fn type_of_primitive(func: &Expr, args: &[Expr], location: Range) -> Option<Check> {
     // Validate the arguments.
     if args.len() == 1 {

src/settings.rs

@@ -130,8 +130,9 @@ impl RawSettings {
     pub fn from_pyproject(
         pyproject: &Option<PathBuf>,
         project_root: &Option<PathBuf>,
+        quiet: bool,
     ) -> Result<Self> {
-        let config = load_config(pyproject)?;
+        let config = load_config(pyproject, quiet)?;
         Ok(RawSettings {
             dummy_variable_rgx: match config.dummy_variable_rgx {
                 Some(pattern) => Regex::new(&pattern)
@@ -159,7 +160,7 @@ impl RawSettings {
                     .filter(|code| {
                         matches!(
                             code.category(),
-                            CheckCategory::Pycodestyle | CheckCategory::Pyflakes
+                            CheckCategory::PycodestyleError | CheckCategory::Pyflakes
                         )
                     })
                     .collect()

src/snapshots/ruff__linter__tests__F401_F401_0.py.snap

@@ -4,7 +4,8 @@ expression: checks
 ---
 - kind:
     UnusedImport:
-      - functools
+      - - functools
+      - false
   location:
     row: 2
     column: 1
@@ -23,7 +24,8 @@ expression: checks
     applied: false
 - kind:
     UnusedImport:
-      - collections.OrderedDict
+      - - collections.OrderedDict
+      - false
   location:
     row: 4
     column: 1
@@ -42,7 +44,8 @@ expression: checks
     applied: false
 - kind:
     UnusedImport:
-      - logging.handlers
+      - - logging.handlers
+      - false
   location:
     row: 12
     column: 1
@@ -51,17 +54,18 @@ expression: checks
     column: 24
   fix:
     patch:
-      content: import logging.handlers
+      content: ""
       location:
         row: 12
         column: 1
       end_location:
-        row: 12
-        column: 24
+        row: 13
+        column: 1
     applied: false
 - kind:
     UnusedImport:
-      - shelve
+      - - shelve
+      - false
   location:
     row: 33
     column: 5
@@ -80,7 +84,8 @@ expression: checks
     applied: false
 - kind:
     UnusedImport:
-      - importlib
+      - - importlib
+      - false
   location:
     row: 34
     column: 5
@@ -99,7 +104,8 @@ expression: checks
     applied: false
 - kind:
     UnusedImport:
-      - pathlib
+      - - pathlib
+      - false
   location:
     row: 38
     column: 5
@@ -118,7 +124,8 @@ expression: checks
     applied: false
 - kind:
     UnusedImport:
-      - pickle
+      - - pickle
+      - false
   location:
     row: 53
     column: 9

src/snapshots/ruff__linter__tests__F401_F401_5.py.snap

@@ -0,0 +1,85 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UnusedImport:
+      - - a.b.c
+      - false
+  location:
+    row: 2
+    column: 1
+  end_location:
+    row: 2
+    column: 18
+  fix:
+    patch:
+      content: ""
+      location:
+        row: 2
+        column: 1
+      end_location:
+        row: 3
+        column: 1
+    applied: false
+- kind:
+    UnusedImport:
+      - - d.e.f
+      - false
+  location:
+    row: 3
+    column: 1
+  end_location:
+    row: 3
+    column: 23
+  fix:
+    patch:
+      content: ""
+      location:
+        row: 3
+        column: 1
+      end_location:
+        row: 4
+        column: 1
+    applied: false
+- kind:
+    UnusedImport:
+      - - h.i
+      - false
+  location:
+    row: 4
+    column: 1
+  end_location:
+    row: 4
+    column: 11
+  fix:
+    patch:
+      content: ""
+      location:
+        row: 4
+        column: 1
+      end_location:
+        row: 5
+        column: 1
+    applied: false
+- kind:
+    UnusedImport:
+      - - j.k
+      - false
+  location:
+    row: 5
+    column: 1
+  end_location:
+    row: 5
+    column: 16
+  fix:
+    patch:
+      content: ""
+      location:
+        row: 5
+        column: 1
+      end_location:
+        row: 6
+        column: 1
+    applied: false
+

src/snapshots/ruff__linter__tests__W605_W605.py.snap

@@ -0,0 +1,41 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    InvalidEscapeSequence: "."
+  location:
+    row: 2
+    column: 10
+  end_location:
+    row: 2
+    column: 11
+  fix: ~
+- kind:
+    InvalidEscapeSequence: "."
+  location:
+    row: 6
+    column: 1
+  end_location:
+    row: 6
+    column: 2
+  fix: ~
+- kind:
+    InvalidEscapeSequence: _
+  location:
+    row: 11
+    column: 6
+  end_location:
+    row: 11
+    column: 7
+  fix: ~
+- kind:
+    InvalidEscapeSequence: _
+  location:
+    row: 18
+    column: 6
+  end_location:
+    row: 18
+    column: 7
+  fix: ~
+

src/snapshots/ruff__linter__tests__future_annotations.snap

@@ -4,7 +4,8 @@ expression: checks
 ---
 - kind:
     UnusedImport:
-      - models.Nut
+      - - models.Nut
+      - false
   location:
     row: 5
     column: 1