Bump version to 0.0.89

.pre-commit-config.yaml

@@ -1,8 +1,8 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.40
+    rev: v0.0.89
     hooks:
-      - id: lint
+      - id: ruff
 
   - repo: https://github.com/abravalheri/validate-pyproject
     rev: v0.10.1

Cargo.lock

@@ -466,6 +466,15 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[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"
@@ -2045,7 +2054,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.83"
+version = "0.0.89"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2054,6 +2063,7 @@ dependencies = [
  "chrono",
  "clap",
  "clearscreen",
+ "codegen",
  "colored",
  "common-path",
  "dirs 4.0.0",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.83"
+version = "0.0.89"
 edition = "2021"
 
 [lib]
@@ -50,6 +50,7 @@ getrandom = { version = "0.2.7", features = ["js"] }
 
 [dev-dependencies]
 assert_cmd = { version = "2.0.4" }
+codegen = { version = "0.2.0" }
 insta = { version = "1.19.1", features = ["yaml"] }
 test-case = { version = "2.2.2" }
 

README.md

@@ -77,11 +77,14 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.83
+    rev: v0.0.89
     hooks:
-      - id: lint
+      - id: ruff
 ```
 
+<!-- TODO(charlie): Remove this message a few versions after v0.0.86. -->
+_Note: prior to `v0.0.86`, `ruff-pre-commit` used `lint` (rather than `ruff`) as the hook ID._
+
 ## Configuration
 
 Ruff is configurable both via `pyproject.toml` and the command line.
@@ -91,13 +94,25 @@ For example, you could configure Ruff to only enforce a subset of rules with:
 ```toml
 [tool.ruff]
 line-length = 88
-select = [
-    "F401",
-    "F403",
+select = ["E", "F"]
+ignore = ["E501"]
+per-file-ignores = [
+    "__init__.py:F401",
+    "path/to/file.py:F401"
 ]
 ```
 
-Alternatively, on the command-line:
+Plugin configurations should be expressed as subsections, e.g.:
+
+```toml
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.flake8-quotes]
+docstring-quotes = "double"
+```
+
+Alternatively, common configuration settings can be provided via the command-line:
 
 ```shell
 ruff path/to/code/ --select F401 --select F403
@@ -219,8 +234,7 @@ add `noqa` directives to all failing lines, with the appropriate error codes.**
 
 ## Supported Rules
 
-By default, Ruff enables all `E`, `W`, and `F` error codes, which correspond to those built-in to
-Flake8.
+By default, Ruff enables all `E` and `F` error codes, which correspond to those built-in to Flake8.
 
 The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` command-line option.
 
@@ -257,7 +271,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 +289,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
 
@@ -348,12 +368,16 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | N803 | InvalidArgumentName | Argument name `...` should be lowercase |  |
 | N804 | InvalidFirstArgumentNameForClassMethod | First argument of a class method should be named `cls` |  |
 | N805 | InvalidFirstArgumentNameForMethod | First argument of a method should be named `self` |  |
+| N806 | NonLowercaseVariableInFunction | Variable `...` in function should be lowercase |  |
 | N807 | DunderFunctionName | Function name should not start and end with `__` |  |
 | N811 | ConstantImportedAsNonConstant | Constant `...` imported as non-constant `...` |  |
 | N812 | LowercaseImportedAsNonLowercase | Lowercase `...` imported as non-lowercase `...` |  |
 | N813 | CamelcaseImportedAsLowercase | Camelcase `...` imported as lowercase `...` |  |
 | N814 | CamelcaseImportedAsConstant | Camelcase `...` imported as constant `...` |  |
+| N815 | MixedCaseVariableInClassScope | Variable `mixedCase` in class scope should not be mixedCase |  |
+| N816 | MixedCaseVariableInGlobalScope | Variable `mixedCase` in global scope should not be mixedCase |  |
 | N817 | CamelcaseImportedAsAcronym | Camelcase `...` imported as acronym `...` |  |
+| N818 | ErrorSuffixOnExceptionName | Exception name `...` should be named with an Error suffix |  |
 
 ### flake8-comprehensions
 
@@ -381,7 +405,9 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | B002 | UnaryPrefixIncrement | Python does not support the unary prefix increment. |  |
+| B007 | UnusedLoopControlVariable | Loop control variable `i` not used within the loop body. | 🛠 |
 | B011 | DoNotAssertFalse | Do not `assert False` (`python -O` removes these calls), raise `AssertionError()` | 🛠 |
+| B013 | RedundantTupleInExceptionHandler | A length-one tuple literal is redundant. Write `except ValueError:` instead of `except (ValueError,):`. |  |
 | B014 | DuplicateHandlerException | Exception handler with duplicate exception: `ValueError` | 🛠 |
 | B017 | NoAssertRaisesException | `assertRaises(Exception):` should be considered evil. |  |
 | B025 | DuplicateTryBlockException | try-except block with duplicate exception `Exception` |  |
@@ -401,6 +427,15 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | T201 | PrintFound | `print` found | 🛠 |
 | T203 | PPrintFound | `pprint` found | 🛠 |
 
+### flake8-quotes
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| Q000 | BadQuotesInlineString | Single quotes found but double quotes preferred |  |
+| Q001 | BadQuotesMultilineString | Single quote multiline found but double quotes preferred |  |
+| Q002 | BadQuotesDocstring | Single quote docstring found but double quotes preferred |  |
+| Q003 | AvoidQuoteEscape | Change outer quotes to avoid escaping inner quotes |  |
+
 ### Meta rules
 
 | Code | Name | Message | Fix |
@@ -467,13 +502,15 @@ Ruff re-implements some of the most popular Flake8 plugins and related code qual
 including:
 
 - [`pydocstyle`](https://pypi.org/project/pydocstyle/)
+- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
 - [`yesqa`](https://github.com/asottile/yesqa)
 - [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
 - [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
+- [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (6/32)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (10/32)
 - [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34)
 - [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
 
@@ -488,12 +525,14 @@ Beyond rule-set parity, Ruff suffers from the following limitations vis-à-vis F
 
 Today, Ruff can be used to replace Flake8 when used with any of the following plugins:
 
+- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
 - [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
 - [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
+- [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (6/32)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (9/32)
 
 Ruff also implements the functionality that you get from [`yesqa`](https://github.com/asottile/yesqa),
 and a subset of the rules implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34).
@@ -522,35 +561,55 @@ Yes! To enable a specific docstring convention, start by enabling all `pydocstyl
 then selectively disabling based on your [preferred convention](https://www.pydocstyle.org/en/latest/error_codes.html#default-conventions).
 
 For example, if you're coming from `flake8-docstrings`, the following configuration is equivalent to
-`--docstring-convention numpy`:
+`--docstring-convention=numpy`:
 
 ```toml
 [tool.ruff]
-extend-select = [
-    "D100",
-    "D101",
-    "D102",
-    "D103",
-    "D104",
-    "D105",
-    "D106",
-    "D200",
-    "D201",
-    "D202",
+extend-select = ["D"]
+extend-ignore = [
+    "D107",
+    "D203",
+    "D212",
+    "D213",
+    "D402",
+    "D413",
+    "D415",
+    "D416",
+    "D417",
+]
+```
+
+Similarly, the following is equivalent to `--docstring-convention=google`:
+
+```toml
+[tool.ruff]
+extend-select = ["D"]
+extend-ignore = [
+    "D203",
     "D204",
-    "D205",
-    "D206",
-    "D207",
-    "D208",
-    "D209",
-    "D210",
-    "D211",
+    "D213",
+    "D215",
+    "D400",
+    "D404",
+    "D406",
+    "D407",
+    "D408",
+    "D409",
+    "D413",
+]
+```
+
+Similarly, the following is equivalent to `--docstring-convention=pep8`:
+
+```toml
+[tool.ruff]
+extend-select = ["D"]
+extend-ignore = [
+    "D203",
+    "D212",
+    "D213",
     "D214",
     "D215",
-    "D300",
-    "D400",
-    "D402",
-    "D403",
     "D404",
     "D405",
     "D406",
@@ -559,51 +618,10 @@ extend-select = [
     "D409",
     "D410",
     "D411",
-    "D412",
     "D413",
-    "D418",
-    "D419",
-]
-```
-
-Similarly, the following is equivalent to `--docstring-convention google`:
-
-```toml
-[tool.ruff]
-extend-select = [
-    "D100",
-    "D101",
-    "D102",
-    "D103",
-    "D104",
-    "D105",
-    "D106",
-    "D107",
-    "D200",
-    "D201",
-    "D202",
-    "D205",
-    "D206",
-    "D207",
-    "D208",
-    "D209",
-    "D210",
-    "D211",
-    "D212",
-    "D214",
-    "D300",
-    "D402",
-    "D403",
-    "D405",
-    "D410",
-    "D411",
-    "D412",
-    "D414",
     "D415",
     "D416",
     "D417",
-    "D418",
-    "D419",
 ]
 ```
 

examples/generate_check_code_prefix.rs

@@ -0,0 +1,105 @@
+//! Generate the CheckCodePrefix enum.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use codegen::{Scope, Type, Variant};
+use itertools::Itertools;
+use strum::IntoEnumIterator;
+
+use ruff::checks::CheckCode;
+
+fn main() {
+    // Build up a map from prefix to matching CheckCodes.
+    let mut prefix_to_codes: BTreeMap<String, BTreeSet<CheckCode>> = Default::default();
+    for check_code in CheckCode::iter() {
+        let as_ref = check_code.as_ref().to_string();
+        for i in 1..=as_ref.len() {
+            let prefix = as_ref[..i].to_string();
+            let entry = prefix_to_codes
+                .entry(prefix)
+                .or_insert_with(|| Default::default());
+            entry.insert(check_code.clone());
+        }
+    }
+
+    let mut scope = Scope::new();
+
+    // Create the `CheckCodePrefix` definition.
+    let mut gen = scope
+        .new_enum("CheckCodePrefix")
+        .vis("pub")
+        .derive("EnumString")
+        .derive("Debug")
+        .derive("PartialEq")
+        .derive("Eq")
+        .derive("Clone")
+        .derive("Serialize")
+        .derive("Deserialize");
+    for (prefix, _) in &prefix_to_codes {
+        gen = gen.push_variant(Variant::new(prefix.to_string()));
+    }
+
+    // Create the `PrefixSpecificity` definition.
+    scope
+        .new_enum("PrefixSpecificity")
+        .vis("pub")
+        .derive("PartialEq")
+        .derive("Eq")
+        .derive("PartialOrd")
+        .derive("Ord")
+        .push_variant(Variant::new("Category"))
+        .push_variant(Variant::new("Hundreds"))
+        .push_variant(Variant::new("Tens"))
+        .push_variant(Variant::new("Explicit"));
+
+    // 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<CheckCode>"))
+        .vis("pub")
+        .line("match self {");
+    for (prefix, codes) in &prefix_to_codes {
+        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("PrefixSpecificity"))
+        .vis("pub")
+        .line("match self {");
+    for (prefix, _) in &prefix_to_codes {
+        let specificity = match prefix.len() {
+            4 => "Explicit",
+            3 => "Tens",
+            2 => "Hundreds",
+            1 => "Category",
+            _ => panic!("Invalid prefix: {}", prefix),
+        };
+        gen = gen.line(format!(
+            "CheckCodePrefix::{prefix} => PrefixSpecificity::{},",
+            specificity
+        ));
+    }
+    gen.line("}");
+
+    println!("//! File automatically generated by examples/generate_check_code_prefix.rs.");
+    println!();
+    println!("use serde::{{Deserialize, Serialize}};");
+    println!("use strum_macros::EnumString;");
+    println!();
+    println!("use crate::checks::CheckCode;");
+    println!();
+    println!("{}", scope.to_string());
+}

resources/test/fixtures/B007.py

@@ -0,0 +1,31 @@
+for i in range(10):
+    print(i)
+
+print(i)  # name no longer defined on Python 3; no warning yet
+
+for i in range(10):  # name not used within the loop; B007
+    print(10)
+
+print(i)  # name no longer defined on Python 3; no warning yet
+
+
+for _ in range(10):  # _ is okay for a throw-away variable
+    print(10)
+
+
+for i in range(10):
+    for j in range(10):
+        for k in range(10):  # k not used, i and j used transitively
+            print(i + j)
+
+
+def strange_generator():
+    for i in range(10):
+        for j in range(10):
+            for k in range(10):
+                for l in range(10):
+                    yield i, (j, (k, l))
+
+
+for i, (j, (k, l)) in strange_generator():  # i, k not used
+    print(j, l)

resources/test/fixtures/B013.py

@@ -0,0 +1,8 @@
+try:
+    pass
+except (ValueError,):
+    pass
+except AttributeError:
+    pass
+except (ImportError, TypeError):
+    pass

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/N802.py

@@ -1,3 +1,6 @@
+import unittest
+
+
 def Bad():
     pass
 
@@ -24,3 +27,15 @@ def _good():
 
 def good_func():
     pass
+
+
+def tearDownModule():
+    pass
+
+
+class Test(unittest.TestCase):
+    def tearDown(self):
+        return super().tearDown()
+
+    def testTest(self):
+        assert True

resources/test/fixtures/N806.py

@@ -0,0 +1,4 @@
+def f():
+    lower = 0
+    Camel = 0
+    CONSTANT = 0

resources/test/fixtures/N815.py

@@ -0,0 +1,6 @@
+class C:
+    lower = 0
+    CONSTANT = 0
+    mixedCase = 0
+    _mixedCase = 0
+    mixed_Case = 0

resources/test/fixtures/N816.py

@@ -0,0 +1,5 @@
+lower = 0
+CONSTANT = 0
+mixedCase = 0
+_mixedCase = 0
+mixed_Case = 0

resources/test/fixtures/N818.py

@@ -0,0 +1,10 @@
+class Error(Exception):
+    pass
+
+
+class AnotherError(Exception):
+    pass
+
+
+class C(Exception):
+    pass

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/flake8_quotes/docstring_doubles.py

@@ -0,0 +1,38 @@
+"""
+Double quotes multiline module docstring
+"""
+
+"""
+this is not a docstring
+"""
+
+l = []
+
+class Cls:
+    """
+    Double quotes multiline class docstring
+    """
+
+    """
+    this is not a docstring
+    """
+
+    # The colon in the list indexing below is an edge case for the docstring scanner
+    def f(self, bar="""
+        definitely not a docstring""",
+        val=l[Cls():3]):
+        """
+        Double quotes multiline function docstring
+        """
+
+        some_expression = 'hello world'
+
+        """
+        this is not a docstring
+        """
+
+        if l:
+            """
+            Looks like a docstring, but in reality it isn't - only modules, classes and functions
+            """
+            pass

resources/test/fixtures/flake8_quotes/docstring_doubles_class.py

@@ -0,0 +1,9 @@
+class SingleLineDocstrings():
+    """ Double quotes single line class docstring """
+    """ Not a docstring """
+
+    def foo(self, bar="""not a docstring"""):
+        """ Double quotes single line method docstring"""
+        pass
+
+    class Nested(foo()[:]): """ inline docstring """; pass

resources/test/fixtures/flake8_quotes/docstring_doubles_function.py

@@ -0,0 +1,22 @@
+def foo():
+    """function without params, single line docstring"""
+    """ not a docstring"""
+    return
+
+
+def foo2():
+    """
+        function without params, multiline docstring
+    """
+    """ not a docstring"""
+    return
+
+
+def fun_with_params_no_docstring(a, b="""
+    not a
+""" """docstring"""):
+    pass
+
+def fun_with_params_no_docstring2(a, b=c[foo():], c=\
+    """ not a docstring """):
+    pass

resources/test/fixtures/flake8_quotes/docstring_doubles_module_multiline.py

@@ -0,0 +1,11 @@
+"""
+Double quotes multiline module docstring
+"""
+"""
+this is not a docstring
+"""
+def foo():
+    pass
+"""
+this is not a docstring
+"""

resources/test/fixtures/flake8_quotes/docstring_doubles_module_singleline.py

@@ -0,0 +1,6 @@
+""" Double quotes singleline module docstring """
+""" this is not a docstring """
+
+def foo():
+    pass
+""" this is not a docstring """

resources/test/fixtures/flake8_quotes/docstring_singles.py

@@ -0,0 +1,40 @@
+'''
+Single quotes multiline module docstring
+'''
+
+'''
+this is not a docstring
+'''
+
+l = []
+
+class Cls(MakeKlass('''
+    class params \t not a docstring
+''')):
+    '''
+    Single quotes multiline class docstring
+    '''
+
+    '''
+    this is not a docstring
+    '''
+
+    # The colon in the list indexing below is an edge case for the docstring scanner
+    def f(self, bar='''
+        definitely not a docstring''',
+        val=l[Cls():3]):
+        '''
+        Single quotes multiline function docstring
+        '''
+
+        some_expression = 'hello world'
+
+        '''
+        this is not a docstring
+        '''
+
+        if l:
+            '''
+            Looks like a docstring, but in reality it isn't - only modules, classes and functions
+            '''
+            pass

resources/test/fixtures/flake8_quotes/docstring_singles_class.py

@@ -0,0 +1,9 @@
+class SingleLineDocstrings():
+    ''' Double quotes single line class docstring '''
+    ''' Not a docstring '''
+
+    def foo(self, bar='''not a docstring'''):
+        ''' Double quotes single line method docstring'''
+        pass
+
+    class Nested(foo()[:]): ''' inline docstring '''; pass

resources/test/fixtures/flake8_quotes/docstring_singles_function.py

@@ -0,0 +1,23 @@
+def foo():
+    '''function without params, single line docstring'''
+    ''' not a docstring'''
+    return
+
+
+def foo2():
+    '''
+        function without params, multiline docstring
+    '''
+    ''' not a docstring'''
+    return
+
+
+def fun_with_params_no_docstring(a, b='''
+    not a 
+''' '''docstring'''):
+    pass
+
+def fun_with_params_no_docstring2(a, b=c[foo():], c=\
+    ''' not a docstring '''):
+    pass
+

resources/test/fixtures/flake8_quotes/docstring_singles_module_multiline.py

@@ -0,0 +1,11 @@
+'''
+Double quotes multiline module docstring
+'''
+'''
+this is not a docstring
+'''
+def foo():
+    pass
+'''
+this is not a docstring
+'''

resources/test/fixtures/flake8_quotes/docstring_singles_module_singleline.py

@@ -0,0 +1,6 @@
+''' Double quotes singleline module docstring '''
+''' this is not a docstring '''
+
+def foo():
+    pass
+''' this is not a docstring '''

resources/test/fixtures/flake8_quotes/doubles.py

@@ -0,0 +1,2 @@
+this_should_be_linted = "double quote string"
+this_should_be_linted = u"double quote string"

resources/test/fixtures/flake8_quotes/doubles_escaped.py

@@ -0,0 +1,5 @@
+this_should_raise_Q003 = 'This is a \'string\''
+this_is_fine = '"This" is a \'string\''
+this_is_fine = "This is a 'string'"
+this_is_fine = "\"This\" is a 'string'"
+this_is_fine = r'This is a \'string\''

resources/test/fixtures/flake8_quotes/doubles_multiline_string.py

@@ -0,0 +1,9 @@
+s = """ This "should"
+be
+"linted" """
+
+s = ''' This "should"
+"not" be
+"linted" '''
+
+s = """'This should not be linted due to having would-be quadruple end quote'"""

resources/test/fixtures/flake8_quotes/doubles_noqa.py

@@ -0,0 +1 @@
+this_should_not_be_linted = "double quote string"  # noqa

resources/test/fixtures/flake8_quotes/doubles_wrapped.py

@@ -0,0 +1,2 @@
+s = 'double "quotes" wrapped in singles are ignored'
+s = "single 'quotes' wrapped in doubles are ignored"

resources/test/fixtures/flake8_quotes/singles.py

@@ -0,0 +1,2 @@
+this_should_be_linted = 'single quote string'
+this_should_be_linted = u'double quote string'

resources/test/fixtures/flake8_quotes/singles_escaped.py

@@ -0,0 +1,5 @@
+this_should_raise_Q003 = "This is a \"string\""
+this_is_fine = "'This' is a \"string\""
+this_is_fine = 'This is a "string"'
+this_is_fine = '\'This\' is a "string"'
+this_is_fine = r"This is a \"string\""

resources/test/fixtures/flake8_quotes/singles_multiline_string.py

@@ -0,0 +1,9 @@
+s = ''' This 'should'
+be
+'linted' '''
+
+s = """ This 'should'
+'not' be
+'linted' """
+
+s = '''"This should not be linted due to having would-be quadruple end quote"'''

resources/test/fixtures/flake8_quotes/singles_noqa.py

@@ -0,0 +1 @@
+this_should_not_be_linted = 'single quote string'  # noqa

resources/test/fixtures/flake8_quotes/singles_wrapped.py

@@ -0,0 +1,2 @@
+s = "single 'quotes' wrapped in doubles are ignored"
+s = 'double "quotes" wrapped in singles are ignored'

resources/test/fixtures/pyproject.toml

@@ -5,3 +5,12 @@ extend-exclude = [
     "migrations",
     "directory/also_excluded.py",
 ]
+per-file-ignores = [
+    "__init__.py:F401",
+]
+
+[tool.ruff.flake8-quotes]
+inline-quotes = "single"
+multiline-quotes = "double"
+docstring-quotes = "double"
+avoid-escape = true

src/ast/operations.rs

@@ -122,56 +122,50 @@ pub fn is_unpacking_assignment(stmt: &Stmt) -> bool {
 pub struct SourceCodeLocator<'a> {
     content: &'a str,
     offsets: Vec<Vec<usize>>,
-    initialized: bool,
 }
 
 impl<'a> SourceCodeLocator<'a> {
     pub fn new(content: &'a str) -> Self {
         SourceCodeLocator {
             content,
-            offsets: vec![],
-            initialized: false,
+            offsets: Self::compute_offsets(content),
         }
     }
 
-    fn init(&mut self) {
-        if !self.initialized {
-            let mut offset = 0;
-            for line in self.content.lines() {
-                let mut newline = 0;
-                let mut line_offsets: Vec<usize> = vec![];
-                for (i, _char) in line.char_indices() {
-                    line_offsets.push(offset + i);
-                    newline = i + 1;
-                }
-                line_offsets.push(offset + newline);
-                self.offsets.push(line_offsets);
-                offset += newline + 1;
+    fn compute_offsets(content: &str) -> Vec<Vec<usize>> {
+        let mut offsets = vec![];
+        let mut offset = 0;
+        for line in content.lines() {
+            let mut newline = 0;
+            let mut line_offsets: Vec<usize> = vec![];
+            for (i, char) in line.char_indices() {
+                line_offsets.push(offset + i);
+                newline = i + char.len_utf8();
             }
-            self.offsets.push(vec![offset]);
-            self.initialized = true;
+            line_offsets.push(offset + newline);
+            offsets.push(line_offsets);
+            offset += newline + 1;
         }
+        offsets.push(vec![offset]);
+        offsets
     }
 
-    pub fn slice_source_code_at(&mut self, location: &Location) -> &'a str {
-        self.init();
+    pub fn slice_source_code_at(&self, location: &Location) -> &'a str {
         let offset = self.offsets[location.row() - 1][location.column() - 1];
         &self.content[offset..]
     }
 
-    pub fn slice_source_code_range(&mut self, range: &Range) -> &'a str {
-        self.init();
+    pub fn slice_source_code_range(&self, range: &Range) -> &'a str {
         let start = self.offsets[range.location.row() - 1][range.location.column() - 1];
         let end = self.offsets[range.end_location.row() - 1][range.end_location.column() - 1];
         &self.content[start..end]
     }
 
     pub fn partition_source_code_at(
-        &mut self,
+        &self,
         outer: &Range,
         inner: &Range,
     ) -> (&'a str, &'a str, &'a str) {
-        self.init();
         let outer_start = self.offsets[outer.location.row() - 1][outer.location.column() - 1];
         let outer_end = self.offsets[outer.end_location.row() - 1][outer.end_location.column() - 1];
         let inner_start = self.offsets[inner.location.row() - 1][inner.location.column() - 1];
@@ -183,3 +177,22 @@ impl<'a> SourceCodeLocator<'a> {
         )
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::SourceCodeLocator;
+
+    #[test]
+    fn source_code_locator_init() {
+        let content = "# \u{4e9c}\nclass Foo:\n    \"\"\".\"\"\"";
+        let locator = SourceCodeLocator::new(content);
+        assert_eq!(locator.offsets.len(), 4);
+        assert_eq!(locator.offsets[0], [0, 1, 2, 5]);
+        assert_eq!(locator.offsets[1], [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+        assert_eq!(
+            locator.offsets[2],
+            [17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28]
+        );
+        assert_eq!(locator.offsets[3], [29]);
+    }
+}

src/autofix/fixer.rs

@@ -1,9 +1,10 @@
-use crate::autofix::Fix;
-use crate::autofix::Patch;
-use itertools::Itertools;
-use rustpython_parser::ast::Location;
 use std::collections::BTreeSet;
 
+use itertools::Itertools;
+use rustpython_parser::ast::Location;
+
+use crate::autofix::Fix;
+use crate::autofix::Patch;
 use crate::checks::Check;
 
 #[derive(Hash)]
@@ -13,6 +14,17 @@ pub enum Mode {
     None,
 }
 
+impl Mode {
+    /// Return `true` if a patch should be generated under the given `Mode`.
+    pub fn patch(&self) -> bool {
+        match &self {
+            Mode::Generate => true,
+            Mode::Apply => true,
+            Mode::None => false,
+        }
+    }
+}
+
 impl From<bool> for Mode {
     fn from(value: bool) -> Self {
         match value {

src/check_ast.rs

@@ -1,8 +1,11 @@
+//! Lint rules based on AST traversal.
+
 use std::collections::{BTreeMap, BTreeSet};
 use std::ops::Deref;
 use std::path::Path;
 
 use log::error;
+use once_cell::unsync::OnceCell;
 use rustpython_parser::ast::{
     Arg, Arguments, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind,
     KeywordData, Operator, Stmt, StmtKind, Suite,
@@ -23,7 +26,8 @@ use crate::checks::{Check, CheckCode, CheckKind};
 use crate::docstrings::definition::{Definition, DefinitionKind, Documentable};
 use crate::python::builtins::{BUILTINS, MAGIC_GLOBALS};
 use crate::python::future::ALL_FEATURE_NAMES;
-use crate::settings::{PythonVersion, Settings};
+use crate::settings::types::PythonVersion;
+use crate::settings::Settings;
 use crate::visibility::{module_visibility, transition_scope, Modifier, Visibility, VisibleScope};
 use crate::{
     docstrings, flake8_bugbear, flake8_builtins, flake8_comprehensions, flake8_print, pep8_naming,
@@ -34,12 +38,14 @@ pub const GLOBAL_SCOPE_INDEX: usize = 0;
 
 pub struct Checker<'a> {
     // Input data.
-    pub(crate) path: &'a Path,
-    pub(crate) locator: SourceCodeLocator<'a>,
+    path: &'a Path,
+    content: &'a str,
+    autofix: &'a fixer::Mode,
     pub(crate) settings: &'a Settings,
-    pub(crate) autofix: &'a fixer::Mode,
     // Computed checks.
     checks: Vec<Check>,
+    // Efficient source-code slicing.
+    locator: OnceCell<SourceCodeLocator<'a>>,
     // Docstring tracking.
     docstrings: Vec<(Definition<'a>, Visibility)>,
     // Edit tracking.
@@ -79,7 +85,8 @@ impl<'a> Checker<'a> {
             settings,
             autofix,
             path,
-            locator: SourceCodeLocator::new(content),
+            content,
+            locator: OnceCell::new(),
             checks: Default::default(),
             docstrings: Default::default(),
             deletions: Default::default(),
@@ -106,6 +113,17 @@ impl<'a> Checker<'a> {
             except_handlers: Default::default(),
         }
     }
+
+    /// Get access to a lazily-initialized `SourceCodeLocator` for the file contents.
+    pub fn get_locator(&self) -> &SourceCodeLocator {
+        self.locator
+            .get_or_init(|| SourceCodeLocator::new(self.content))
+    }
+
+    /// Return `true` if a patch should be generated under the given autofix `Mode`.
+    pub fn patch(&self) -> bool {
+        self.autofix.patch()
+    }
 }
 
 impl<'a, 'b> Visitor<'b> for Checker<'a>
@@ -345,6 +363,14 @@ where
                     }
                 }
 
+                if self.settings.enabled.contains(&CheckCode::N818) {
+                    if let Some(check) =
+                        pep8_naming::checks::error_suffix_on_exception_name(stmt, bases, name)
+                    {
+                        self.checks.push(check);
+                    }
+                }
+
                 self.check_builtin_shadowing(
                     name,
                     self.locate_check(Range::from_located(stmt)),
@@ -672,6 +698,11 @@ where
                     flake8_bugbear::plugins::assert_raises_exception(self, stmt, items);
                 }
             }
+            StmtKind::For { target, body, .. } => {
+                if self.settings.enabled.contains(&CheckCode::B007) {
+                    flake8_bugbear::plugins::unused_loop_control_variable(self, target, body);
+                }
+            }
             StmtKind::Try { handlers, .. } => {
                 if self.settings.enabled.contains(&CheckCode::F707) {
                     if let Some(check) = pyflakes::checks::default_except_not_last(handlers) {
@@ -683,6 +714,9 @@ where
                 {
                     flake8_bugbear::plugins::duplicate_exceptions(self, stmt, handlers);
                 }
+                if self.settings.enabled.contains(&CheckCode::B013) {
+                    flake8_bugbear::plugins::redundant_tuple_in_exception_handler(self, handlers);
+                }
             }
             StmtKind::Assign { targets, value, .. } => {
                 if self.settings.enabled.contains(&CheckCode::E731) {
@@ -1776,6 +1810,30 @@ impl<'a> Checker<'a> {
                 }
             }
 
+            if self.settings.enabled.contains(&CheckCode::N806) {
+                if let Some(check) =
+                    pep8_naming::checks::non_lowercase_variable_in_function(current, expr, id)
+                {
+                    self.checks.push(check);
+                }
+            }
+
+            if self.settings.enabled.contains(&CheckCode::N815) {
+                if let Some(check) =
+                    pep8_naming::checks::mixed_case_variable_in_class_scope(current, expr, id)
+                {
+                    self.checks.push(check);
+                }
+            }
+
+            if self.settings.enabled.contains(&CheckCode::N816) {
+                if let Some(check) =
+                    pep8_naming::checks::mixed_case_variable_in_global_scope(current, expr, id)
+                {
+                    self.checks.push(check);
+                }
+            }
+
             if matches!(parent.node, StmtKind::AnnAssign { value: None, .. }) {
                 self.add_binding(
                     id.to_string(),
@@ -2070,8 +2128,7 @@ impl<'a> Checker<'a> {
                     let child = self.parents[defined_by];
                     let parent = defined_in.map(|defined_in| self.parents[defined_in]);
 
-                    let fix = if matches!(self.autofix, fixer::Mode::Generate | fixer::Mode::Apply)
-                    {
+                    let fix = if self.patch() {
                         let deleted: Vec<&Stmt> = self
                             .deletions
                             .iter()
@@ -2083,7 +2140,7 @@ impl<'a> Checker<'a> {
                             ImportKind::ImportFrom => pyflakes::fixes::remove_unused_import_froms,
                         };
 
-                        match removal_fn(&mut self.locator, &full_names, child, parent, &deleted) {
+                        match removal_fn(self.get_locator(), &full_names, child, parent, &deleted) {
                             Ok(fix) => Some(fix),
                             Err(e) => {
                                 error!("Failed to fix unused imports: {}", e);
@@ -2094,15 +2151,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;
@@ -166,7 +168,7 @@ pub fn check_lines(
                                 end_location: Location::new(row + 1, end + 1),
                             },
                         );
-                        if matches!(autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                        if autofix.patch() {
                             check.amend(Fix::deletion(
                                 Location::new(row + 1, start + 1),
                                 Location::new(row + 1, lines[row].chars().count() + 1),
@@ -194,7 +196,7 @@ pub fn check_lines(
                                 end_location: Location::new(row + 1, end + 1),
                             },
                         );
-                        if matches!(autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                        if autofix.patch() {
                             if valid_codes.is_empty() {
                                 check.amend(Fix::deletion(
                                     Location::new(row + 1, start + 1),
@@ -227,7 +229,7 @@ pub fn check_lines(
 mod tests {
     use crate::autofix::fixer;
     use crate::checks::{Check, CheckCode};
-    use crate::settings;
+    use crate::settings::Settings;
 
     use super::check_lines;
 
@@ -241,9 +243,9 @@ mod tests {
                 &mut checks,
                 line,
                 &noqa_line_for,
-                &settings::Settings {
+                &Settings {
                     line_length,
-                    ..settings::Settings::for_rule(CheckCode::E501)
+                    ..Settings::for_rule(CheckCode::E501)
                 },
                 &fixer::Mode::Generate,
             );

src/check_tokens.rs

@@ -0,0 +1,54 @@
+//! Lint rules based on token traversal.
+
+use rustpython_parser::lexer::{LexResult, Tok};
+
+use crate::ast::operations::SourceCodeLocator;
+use crate::checks::{Check, CheckCode};
+use crate::flake8_quotes::docstring_detection::StateMachine;
+use crate::{flake8_quotes, pycodestyle, Settings};
+
+pub fn check_tokens(
+    checks: &mut Vec<Check>,
+    contents: &str,
+    tokens: &[LexResult],
+    settings: &Settings,
+) {
+    let enforce_invalid_escape_sequence = settings.enabled.contains(&CheckCode::W605);
+    let enforce_quotes = settings.enabled.contains(&CheckCode::Q000)
+        | settings.enabled.contains(&CheckCode::Q001)
+        | settings.enabled.contains(&CheckCode::Q002)
+        | settings.enabled.contains(&CheckCode::Q003);
+
+    // TODO(charlie): Use a shared SourceCodeLocator between this site and the AST traversal.
+    let locator = SourceCodeLocator::new(contents);
+
+    let mut state_machine = StateMachine::new();
+    for (start, tok, end) in tokens.iter().flatten() {
+        // W605
+        if enforce_invalid_escape_sequence {
+            if matches!(tok, Tok::String { .. }) {
+                checks.extend(pycodestyle::checks::invalid_escape_sequence(
+                    &locator, start, end,
+                ));
+            }
+        }
+
+        // flake8-quotes
+        if enforce_quotes {
+            let is_docstring = state_machine.consume(tok);
+            if matches!(tok, Tok::String { .. }) {
+                if let Some(check) = flake8_quotes::checks::quotes(
+                    &locator,
+                    start,
+                    end,
+                    is_docstring,
+                    &settings.flake8_quotes,
+                ) {
+                    if settings.enabled.contains(check.kind.code()) {
+                        checks.push(check);
+                    }
+                }
+            }
+        }
+    }
+}

src/checks.rs

@@ -7,6 +7,7 @@ use strum_macros::{AsRefStr, EnumIter, EnumString};
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
+use crate::flake8_quotes::settings::Quote;
 use crate::pyupgrade::types::Primitive;
 
 #[derive(
@@ -41,6 +42,7 @@ pub enum CheckCode {
     E999,
     // pycodestyle warnings
     W292,
+    W605,
     // pyflakes
     F401,
     F402,
@@ -76,7 +78,9 @@ pub enum CheckCode {
     A003,
     // flake8-bugbear
     B002,
+    B007,
     B011,
+    B013,
     B014,
     B017,
     B025,
@@ -100,6 +104,11 @@ pub enum CheckCode {
     // flake8-print
     T201,
     T203,
+    // flake8-quotes
+    Q000,
+    Q001,
+    Q002,
+    Q003,
     // pyupgrade
     U001,
     U002,
@@ -160,12 +169,16 @@ pub enum CheckCode {
     N803,
     N804,
     N805,
+    N806,
     N807,
     N811,
     N812,
     N813,
     N814,
+    N815,
+    N816,
     N817,
+    N818,
     // Meta
     M001,
 }
@@ -173,7 +186,8 @@ pub enum CheckCode {
 #[derive(EnumIter, Debug, PartialEq, Eq)]
 pub enum CheckCategory {
     Pyflakes,
-    Pycodestyle,
+    PycodestyleError,
+    PycodestyleWarning,
     Pydocstyle,
     Pyupgrade,
     PEP8Naming,
@@ -181,18 +195,21 @@ pub enum CheckCategory {
     Flake8Bugbear,
     Flake8Builtins,
     Flake8Print,
+    Flake8Quotes,
     Meta,
 }
 
 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",
             CheckCategory::Flake8Comprehensions => "flake8-comprehensions",
             CheckCategory::Flake8Print => "flake8-print",
+            CheckCategory::Flake8Quotes => "flake8-quotes",
             CheckCategory::Pyupgrade => "pyupgrade",
             CheckCategory::Pydocstyle => "pydocstyle",
             CheckCategory::PEP8Naming => "pep8-naming",
@@ -204,8 +221,9 @@ impl CheckCategory {
 #[allow(clippy::upper_case_acronyms)]
 pub enum LintSource {
     AST,
-    Lines,
     FileSystem,
+    Lines,
+    Tokens,
 }
 
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -233,6 +251,7 @@ pub enum CheckKind {
     TypeComparison,
     // pycodestyle warnings
     NoNewLineAtEndOfFile,
+    InvalidEscapeSequence(char),
     // pyflakes
     AssertTuple,
     BreakOutsideLoop,
@@ -259,7 +278,7 @@ pub enum CheckKind {
     UndefinedExport(String),
     UndefinedLocal(String),
     UndefinedName(String),
-    UnusedImport(Vec<String>),
+    UnusedImport(Vec<String>, bool),
     UnusedVariable(String),
     YieldOutsideFunction,
     // flake8-builtins
@@ -268,7 +287,9 @@ pub enum CheckKind {
     BuiltinAttributeShadowing(String),
     // flake8-bugbear
     UnaryPrefixIncrement,
+    UnusedLoopControlVariable(String),
     DoNotAssertFalse,
+    RedundantTupleInExceptionHandler(String),
     DuplicateHandlerException(Vec<String>),
     NoAssertRaisesException,
     DuplicateTryBlockException(String),
@@ -292,6 +313,11 @@ pub enum CheckKind {
     // flake8-print
     PrintFound,
     PPrintFound,
+    // flake8-quotes
+    BadQuotesInlineString(Quote),
+    BadQuotesMultilineString(Quote),
+    BadQuotesDocstring(Quote),
+    AvoidQuoteEscape,
     // pyupgrade
     TypeOfPrimitive(Primitive),
     UnnecessaryAbspath,
@@ -352,12 +378,16 @@ pub enum CheckKind {
     InvalidArgumentName(String),
     InvalidFirstArgumentNameForClassMethod,
     InvalidFirstArgumentNameForMethod,
+    NonLowercaseVariableInFunction(String),
     DunderFunctionName,
     ConstantImportedAsNonConstant(String, String),
     LowercaseImportedAsNonLowercase(String, String),
     CamelcaseImportedAsLowercase(String, String),
     CamelcaseImportedAsConstant(String, String),
+    MixedCaseVariableInClassScope(String),
+    MixedCaseVariableInGlobalScope(String),
     CamelcaseImportedAsAcronym(String, String),
+    ErrorSuffixOnExceptionName(String),
     // Meta
     UnusedNOQA(Option<Vec<String>>),
 }
@@ -367,6 +397,11 @@ impl CheckCode {
     pub fn lint_source(&self) -> &'static LintSource {
         match self {
             CheckCode::E501 | CheckCode::W292 | CheckCode::M001 => &LintSource::Lines,
+            CheckCode::W605
+            | CheckCode::Q000
+            | CheckCode::Q001
+            | CheckCode::Q002
+            | CheckCode::Q003 => &LintSource::Tokens,
             CheckCode::E902 => &LintSource::FileSystem,
             _ => &LintSource::AST,
         }
@@ -392,8 +427,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,
@@ -429,7 +465,11 @@ impl CheckCode {
             CheckCode::A003 => CheckKind::BuiltinAttributeShadowing("...".to_string()),
             // flake8-bugbear
             CheckCode::B002 => CheckKind::UnaryPrefixIncrement,
+            CheckCode::B007 => CheckKind::UnusedLoopControlVariable("i".to_string()),
             CheckCode::B011 => CheckKind::DoNotAssertFalse,
+            CheckCode::B013 => {
+                CheckKind::RedundantTupleInExceptionHandler("ValueError".to_string())
+            }
             CheckCode::B014 => CheckKind::DuplicateHandlerException(vec!["ValueError".to_string()]),
             CheckCode::B017 => CheckKind::NoAssertRaisesException,
             CheckCode::B025 => CheckKind::DuplicateTryBlockException("Exception".to_string()),
@@ -466,6 +506,11 @@ impl CheckCode {
             // flake8-print
             CheckCode::T201 => CheckKind::PrintFound,
             CheckCode::T203 => CheckKind::PPrintFound,
+            // flake8-quotes
+            CheckCode::Q000 => CheckKind::BadQuotesInlineString(Quote::Double),
+            CheckCode::Q001 => CheckKind::BadQuotesMultilineString(Quote::Double),
+            CheckCode::Q002 => CheckKind::BadQuotesDocstring(Quote::Double),
+            CheckCode::Q003 => CheckKind::AvoidQuoteEscape,
             // pyupgrade
             CheckCode::U001 => CheckKind::UselessMetaclassType,
             CheckCode::U002 => CheckKind::UnnecessaryAbspath,
@@ -535,6 +580,7 @@ impl CheckCode {
             CheckCode::N803 => CheckKind::InvalidArgumentName("...".to_string()),
             CheckCode::N804 => CheckKind::InvalidFirstArgumentNameForClassMethod,
             CheckCode::N805 => CheckKind::InvalidFirstArgumentNameForMethod,
+            CheckCode::N806 => CheckKind::NonLowercaseVariableInFunction("...".to_string()),
             CheckCode::N807 => CheckKind::DunderFunctionName,
             CheckCode::N811 => {
                 CheckKind::ConstantImportedAsNonConstant("...".to_string(), "...".to_string())
@@ -548,9 +594,12 @@ impl CheckCode {
             CheckCode::N814 => {
                 CheckKind::CamelcaseImportedAsConstant("...".to_string(), "...".to_string())
             }
+            CheckCode::N815 => CheckKind::MixedCaseVariableInClassScope("mixedCase".to_string()),
+            CheckCode::N816 => CheckKind::MixedCaseVariableInGlobalScope("mixedCase".to_string()),
             CheckCode::N817 => {
                 CheckKind::CamelcaseImportedAsAcronym("...".to_string(), "...".to_string())
             }
+            CheckCode::N818 => CheckKind::ErrorSuffixOnExceptionName("...".to_string()),
             // Meta
             CheckCode::M001 => CheckKind::UnusedNOQA(None),
         }
@@ -558,21 +607,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,
@@ -605,7 +655,9 @@ impl CheckCode {
             CheckCode::A002 => CheckCategory::Flake8Builtins,
             CheckCode::A003 => CheckCategory::Flake8Builtins,
             CheckCode::B002 => CheckCategory::Flake8Bugbear,
+            CheckCode::B007 => CheckCategory::Flake8Bugbear,
             CheckCode::B011 => CheckCategory::Flake8Bugbear,
+            CheckCode::B013 => CheckCategory::Flake8Bugbear,
             CheckCode::B014 => CheckCategory::Flake8Bugbear,
             CheckCode::B017 => CheckCategory::Flake8Bugbear,
             CheckCode::B025 => CheckCategory::Flake8Bugbear,
@@ -627,6 +679,10 @@ impl CheckCode {
             CheckCode::C417 => CheckCategory::Flake8Comprehensions,
             CheckCode::T201 => CheckCategory::Flake8Print,
             CheckCode::T203 => CheckCategory::Flake8Print,
+            CheckCode::Q000 => CheckCategory::Flake8Quotes,
+            CheckCode::Q001 => CheckCategory::Flake8Quotes,
+            CheckCode::Q002 => CheckCategory::Flake8Quotes,
+            CheckCode::Q003 => CheckCategory::Flake8Quotes,
             CheckCode::U001 => CheckCategory::Pyupgrade,
             CheckCode::U002 => CheckCategory::Pyupgrade,
             CheckCode::U003 => CheckCategory::Pyupgrade,
@@ -684,12 +740,16 @@ impl CheckCode {
             CheckCode::N803 => CheckCategory::PEP8Naming,
             CheckCode::N804 => CheckCategory::PEP8Naming,
             CheckCode::N805 => CheckCategory::PEP8Naming,
+            CheckCode::N806 => CheckCategory::PEP8Naming,
             CheckCode::N807 => CheckCategory::PEP8Naming,
             CheckCode::N811 => CheckCategory::PEP8Naming,
             CheckCode::N812 => CheckCategory::PEP8Naming,
             CheckCode::N813 => CheckCategory::PEP8Naming,
             CheckCode::N814 => CheckCategory::PEP8Naming,
+            CheckCode::N815 => CheckCategory::PEP8Naming,
+            CheckCode::N816 => CheckCategory::PEP8Naming,
             CheckCode::N817 => CheckCategory::PEP8Naming,
+            CheckCode::N818 => CheckCategory::PEP8Naming,
             CheckCode::M001 => CheckCategory::Meta,
         }
     }
@@ -739,18 +799,21 @@ 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,
             CheckKind::BuiltinAttributeShadowing(_) => &CheckCode::A003,
             // flake8-bugbear
             CheckKind::UnaryPrefixIncrement => &CheckCode::B002,
+            CheckKind::UnusedLoopControlVariable(_) => &CheckCode::B007,
             CheckKind::DoNotAssertFalse => &CheckCode::B011,
+            CheckKind::RedundantTupleInExceptionHandler(_) => &CheckCode::B013,
             CheckKind::DuplicateHandlerException(_) => &CheckCode::B014,
             CheckKind::NoAssertRaisesException => &CheckCode::B017,
             CheckKind::DuplicateTryBlockException(_) => &CheckCode::B025,
@@ -774,6 +837,11 @@ impl CheckKind {
             // flake8-print
             CheckKind::PrintFound => &CheckCode::T201,
             CheckKind::PPrintFound => &CheckCode::T203,
+            // flake8-quotes
+            CheckKind::BadQuotesInlineString(_) => &CheckCode::Q000,
+            CheckKind::BadQuotesMultilineString(_) => &CheckCode::Q001,
+            CheckKind::BadQuotesDocstring(_) => &CheckCode::Q002,
+            CheckKind::AvoidQuoteEscape => &CheckCode::Q003,
             // pyupgrade
             CheckKind::TypeOfPrimitive(_) => &CheckCode::U003,
             CheckKind::UnnecessaryAbspath => &CheckCode::U002,
@@ -834,12 +902,16 @@ impl CheckKind {
             CheckKind::InvalidArgumentName(_) => &CheckCode::N803,
             CheckKind::InvalidFirstArgumentNameForClassMethod => &CheckCode::N804,
             CheckKind::InvalidFirstArgumentNameForMethod => &CheckCode::N805,
+            CheckKind::NonLowercaseVariableInFunction(..) => &CheckCode::N806,
             CheckKind::DunderFunctionName => &CheckCode::N807,
             CheckKind::ConstantImportedAsNonConstant(..) => &CheckCode::N811,
             CheckKind::LowercaseImportedAsNonLowercase(..) => &CheckCode::N812,
             CheckKind::CamelcaseImportedAsLowercase(..) => &CheckCode::N813,
             CheckKind::CamelcaseImportedAsConstant(..) => &CheckCode::N814,
+            CheckKind::MixedCaseVariableInClassScope(..) => &CheckCode::N815,
+            CheckKind::MixedCaseVariableInGlobalScope(..) => &CheckCode::N816,
             CheckKind::CamelcaseImportedAsAcronym(..) => &CheckCode::N817,
+            CheckKind::ErrorSuffixOnExceptionName(..) => &CheckCode::N818,
             // Meta
             CheckKind::UnusedNOQA(_) => &CheckCode::M001,
         }
@@ -966,9 +1038,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")
@@ -978,6 +1054,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")
@@ -990,10 +1067,14 @@ impl CheckKind {
             }
             // flake8-bugbear
             CheckKind::UnaryPrefixIncrement => "Python does not support the unary prefix increment. Writing `++n` is equivalent to `+(+(n))`, which equals `n`. You meant `n += 1`.".to_string(),
+            CheckKind::UnusedLoopControlVariable(name) => format!("Loop control variable `{name}` not used within the loop body. If this is intended, start the name with an underscore."),
             CheckKind::DoNotAssertFalse => {
                 "Do not `assert False` (`python -O` removes these calls), raise `AssertionError()`"
                     .to_string()
             }
+            CheckKind::RedundantTupleInExceptionHandler(name) => {
+                format!("A length-one tuple literal is redundant. Write `except {name}:` instead of `except ({name},):`.")
+            }
             CheckKind::DuplicateHandlerException(names) => {
                 if names.len() == 1 {
                     let name = &names[0];
@@ -1081,6 +1162,26 @@ impl CheckKind {
             // flake8-print
             CheckKind::PrintFound => "`print` found".to_string(),
             CheckKind::PPrintFound => "`pprint` found".to_string(),
+            // flake8-quotes
+            CheckKind::BadQuotesInlineString(quote) => {
+                match quote {
+                    Quote::Single => "Double quotes found but single quotes preferred".to_string(),
+                    Quote::Double => "Single quotes found but double quotes preferred".to_string(),
+                }
+            },
+            CheckKind::BadQuotesMultilineString(quote) => {
+                match quote {
+                    Quote::Single => "Double quote multiline found but single quotes preferred".to_string(),
+                    Quote::Double => "Single quote multiline found but double quotes preferred".to_string(),
+                }
+            },
+            CheckKind::BadQuotesDocstring(quote) => {
+                match quote {
+                    Quote::Single => "Double quote docstring found but single quotes preferred".to_string(),
+                    Quote::Double => "Single quote docstring found but double quotes preferred".to_string(),
+                }
+            },
+            CheckKind::AvoidQuoteEscape => "Change outer quotes to avoid escaping inner quotes".to_string(),
             // pyupgrade
             CheckKind::TypeOfPrimitive(primitive) => {
                 format!("Use `{}` instead of `type(...)`", primitive.builtin())
@@ -1234,6 +1335,9 @@ impl CheckKind {
             CheckKind::InvalidFirstArgumentNameForMethod => {
                 "First argument of a method should be named `self`".to_string()
             }
+            CheckKind::NonLowercaseVariableInFunction(name) => {
+                format!("Variable `{name}` in function should be lowercase")
+            }
             CheckKind::DunderFunctionName => {
                 "Function name should not start and end with `__`".to_string()
             }
@@ -1249,9 +1353,18 @@ impl CheckKind {
             CheckKind::CamelcaseImportedAsConstant(name, asname) => {
                 format!("Camelcase `{name}` imported as constant `{asname}`")
             }
+            CheckKind::MixedCaseVariableInClassScope(name) => {
+                format!("Variable `{name}` in class scope should not be mixedCase")
+            }
+            CheckKind::MixedCaseVariableInGlobalScope(name) => {
+                format!("Variable `{name}` in global scope should not be mixedCase")
+            }
             CheckKind::CamelcaseImportedAsAcronym(name, asname) => {
                 format!("Camelcase `{name}` imported as acronym `{asname}`")
             }
+            CheckKind::ErrorSuffixOnExceptionName(name) => {
+                format!("Exception name `{name}` should be named with an Error suffix")
+            }
             // Meta
             CheckKind::UnusedNOQA(codes) => match codes {
                 None => "Unused `noqa` directive".to_string(),
@@ -1278,6 +1391,9 @@ impl CheckKind {
             CheckKind::UnaryPrefixIncrement => {
                 "Python does not support the unary prefix increment.".to_string()
             }
+            CheckKind::UnusedLoopControlVariable(name) => {
+                format!("Loop control variable `{name}` not used within the loop body.")
+            }
             CheckKind::NoAssertRaisesException => {
                 "`assertRaises(Exception):` should be considered evil.".to_string()
             }
@@ -1319,7 +1435,8 @@ impl CheckKind {
                 | CheckKind::SuperCallWithParameters
                 | CheckKind::TypeOfPrimitive(_)
                 | CheckKind::UnnecessaryAbspath
-                | CheckKind::UnusedImport(_)
+                | CheckKind::UnusedImport(_, false)
+                | CheckKind::UnusedLoopControlVariable(_)
                 | CheckKind::UnusedNOQA(_)
                 | CheckKind::UsePEP585Annotation(_)
                 | CheckKind::UsePEP604Annotation

src/cli.rs

@@ -5,11 +5,11 @@ use clap::{command, Parser};
 use log::warn;
 use regex::Regex;
 
-use crate::checks::CheckCode;
+use crate::checks_gen::CheckCodePrefix;
 use crate::printer::SerializationFormat;
-use crate::pyproject::StrCheckCodePair;
-use crate::settings::PythonVersion;
-use crate::RawSettings;
+use crate::settings::configuration::Configuration;
+use crate::settings::types::PythonVersion;
+use crate::settings::types::StrCheckCodePair;
 
 #[derive(Debug, Parser)]
 #[command(author, about = "ruff: An extremely fast Python linter.")]
@@ -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,
@@ -40,16 +43,16 @@ pub struct Cli {
     pub no_cache: bool,
     /// List of error codes to enable.
     #[arg(long, value_delimiter = ',')]
-    pub select: Vec<CheckCode>,
+    pub select: Vec<CheckCodePrefix>,
     /// Like --select, but adds additional error codes on top of the selected ones.
     #[arg(long, value_delimiter = ',')]
-    pub extend_select: Vec<CheckCode>,
+    pub extend_select: Vec<CheckCodePrefix>,
     /// List of error codes to ignore.
     #[arg(long, value_delimiter = ',')]
-    pub ignore: Vec<CheckCode>,
+    pub ignore: Vec<CheckCodePrefix>,
     /// Like --ignore, but adds additional error codes on top of the ignored ones.
     #[arg(long, value_delimiter = ',')]
-    pub extend_ignore: Vec<CheckCode>,
+    pub extend_ignore: Vec<CheckCodePrefix>,
     /// List of paths, used to exclude files and/or directories from checks.
     #[arg(long, value_delimiter = ',')]
     pub exclude: Vec<String>,
@@ -103,10 +106,10 @@ impl fmt::Display for Warnable {
 /// Warn the user if they attempt to enable a code that won't be respected.
 pub fn warn_on(
     flag: Warnable,
-    codes: &[CheckCode],
-    cli_ignore: &[CheckCode],
-    cli_extend_ignore: &[CheckCode],
-    pyproject_settings: &RawSettings,
+    codes: &[CheckCodePrefix],
+    cli_ignore: &[CheckCodePrefix],
+    cli_extend_ignore: &[CheckCodePrefix],
+    pyproject_configuration: &Configuration,
     pyproject_path: &Option<PathBuf>,
 ) {
     for code in codes {
@@ -114,7 +117,7 @@ pub fn warn_on(
             if cli_ignore.contains(code) {
                 warn!("{code:?} was passed to {flag}, but ignored via --ignore")
             }
-        } else if pyproject_settings.ignore.contains(code) {
+        } else if pyproject_configuration.ignore.contains(code) {
             if let Some(path) = pyproject_path {
                 warn!(
                     "{code:?} was passed to {flag}, but ignored by the `ignore` field in {}",
@@ -128,7 +131,7 @@ pub fn warn_on(
             if cli_extend_ignore.contains(code) {
                 warn!("{code:?} was passed to {flag}, but ignored via --extend-ignore")
             }
-        } else if pyproject_settings.extend_ignore.contains(code) {
+        } else if pyproject_configuration.extend_ignore.contains(code) {
             if let Some(path) = pyproject_path {
                 warn!(
                     "{code:?} was passed to {flag}, but ignored by the `extend_ignore` field in {}",

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/docstrings/helpers.rs

@@ -25,9 +25,9 @@ pub fn leading_space(line: &str) -> String {
 }
 
 /// Extract the leading indentation from a docstring.
-pub fn indentation<'a>(checker: &'a mut Checker, docstring: &Expr) -> &'a str {
+pub fn indentation<'a>(checker: &'a Checker, docstring: &Expr) -> &'a str {
     let range = Range::from_located(docstring);
-    checker.locator.slice_source_code_range(&Range {
+    checker.get_locator().slice_source_code_range(&Range {
         location: Location::new(range.location.row(), 1),
         end_location: Location::new(range.location.row(), range.location.column()),
     })

src/flake8_bugbear/plugins/assert_false.rs

@@ -1,7 +1,6 @@
 use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Stmt, StmtKind};
 
 use crate::ast::types::Range;
-use crate::autofix::fixer;
 use crate::autofix::Fix;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
@@ -44,7 +43,7 @@ pub fn assert_false(checker: &mut Checker, stmt: &Stmt, test: &Expr, msg: &Optio
     } = &test.node
     {
         let mut check = Check::new(CheckKind::DoNotAssertFalse, Range::from_located(test));
-        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+        if checker.patch() {
             let mut generator = SourceGenerator::new();
             if let Ok(()) = generator.unparse_stmt(&assertion_error(msg)) {
                 if let Ok(content) = generator.generate() {

src/flake8_bugbear/plugins/duplicate_exceptions.rs

@@ -5,7 +5,6 @@ use rustpython_ast::{Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKi
 
 use crate::ast::helpers;
 use crate::ast::types::{CheckLocator, Range};
-use crate::autofix::fixer;
 use crate::autofix::Fix;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckCode, CheckKind};
@@ -50,7 +49,7 @@ pub fn duplicate_handler_exceptions(
                 ),
                 checker.locate_check(Range::from_located(expr)),
             );
-            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+            if checker.patch() {
                 // TODO(charlie): If we have a single element, remove the tuple.
                 let mut generator = SourceGenerator::new();
                 if let Ok(()) = generator.unparse_expr(&type_pattern(unique_elts), 0) {

src/flake8_bugbear/plugins/mod.rs

@@ -2,9 +2,13 @@ pub use assert_false::assert_false;
 pub use assert_raises_exception::assert_raises_exception;
 pub use duplicate_exceptions::duplicate_exceptions;
 pub use duplicate_exceptions::duplicate_handler_exceptions;
+pub use redundant_tuple_in_exception_handler::redundant_tuple_in_exception_handler;
 pub use unary_prefix_increment::unary_prefix_increment;
+pub use unused_loop_control_variable::unused_loop_control_variable;
 
 mod assert_false;
 mod assert_raises_exception;
 mod duplicate_exceptions;
+mod redundant_tuple_in_exception_handler;
 mod unary_prefix_increment;
+mod unused_loop_control_variable;

src/flake8_bugbear/plugins/redundant_tuple_in_exception_handler.rs

@@ -0,0 +1,22 @@
+use rustpython_ast::{Excepthandler, ExcepthandlerKind, ExprKind};
+
+use crate::ast::types::{CheckLocator, Range};
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B013
+pub fn redundant_tuple_in_exception_handler(checker: &mut Checker, handlers: &[Excepthandler]) {
+    for handler in handlers {
+        let ExcepthandlerKind::ExceptHandler { type_, .. } = &handler.node;
+        if let Some(type_) = type_ {
+            if let ExprKind::Tuple { elts, .. } = &type_.node {
+                if elts.len() == 1 {
+                    checker.add_check(Check::new(
+                        CheckKind::RedundantTupleInExceptionHandler(elts[0].to_string()),
+                        checker.locate_check(Range::from_located(type_)),
+                    ));
+                }
+            }
+        }
+    }
+}

src/flake8_bugbear/plugins/unused_loop_control_variable.rs

@@ -0,0 +1,79 @@
+use std::collections::BTreeMap;
+
+use rustpython_ast::{Expr, ExprKind, Stmt};
+
+use crate::ast::types::Range;
+use crate::ast::visitor;
+use crate::ast::visitor::Visitor;
+use crate::autofix::Fix;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// Identify all `ExprKind::Name` nodes in an AST.
+struct NameFinder<'a> {
+    /// A map from identifier to defining expression.
+    names: BTreeMap<&'a str, &'a Expr>,
+}
+
+impl NameFinder<'_> {
+    fn new() -> Self {
+        NameFinder {
+            names: Default::default(),
+        }
+    }
+}
+
+impl<'a, 'b> Visitor<'b> for NameFinder<'a>
+where
+    'b: 'a,
+{
+    fn visit_expr(&mut self, expr: &'a Expr) {
+        if let ExprKind::Name { id, .. } = &expr.node {
+            self.names.insert(id, expr);
+        }
+        visitor::walk_expr(self, expr);
+    }
+}
+
+/// B007
+pub fn unused_loop_control_variable(checker: &mut Checker, target: &Expr, body: &[Stmt]) {
+    let control_names = {
+        let mut finder = NameFinder::new();
+        finder.visit_expr(target);
+        finder.names
+    };
+
+    let used_names = {
+        let mut finder = NameFinder::new();
+        for stmt in body {
+            finder.visit_stmt(stmt);
+        }
+        finder.names
+    };
+
+    for (name, expr) in control_names {
+        // Ignore names that are already underscore-prefixed.
+        if name.starts_with('_') {
+            continue;
+        }
+
+        // Ignore any names that are actually used in the loop body.
+        if used_names.contains_key(name) {
+            continue;
+        }
+
+        let mut check = Check::new(
+            CheckKind::UnusedLoopControlVariable(name.to_string()),
+            Range::from_located(expr),
+        );
+        if checker.patch() {
+            // Prefix the variable name with an underscore.
+            check.amend(Fix::replacement(
+                format!("_{name}"),
+                expr.location,
+                expr.end_location.unwrap(),
+            ))
+        }
+        checker.add_check(check);
+    }
+}

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/flake8_print/plugins/print_call.rs

@@ -1,7 +1,7 @@
 use log::error;
 use rustpython_ast::{Expr, Stmt, StmtKind};
 
-use crate::autofix::{fixer, helpers};
+use crate::autofix::helpers;
 use crate::check_ast::Checker;
 use crate::checks::CheckCode;
 use crate::flake8_print::checks;
@@ -13,7 +13,7 @@ pub fn print_call(checker: &mut Checker, expr: &Expr, func: &Expr) {
         checker.settings.enabled.contains(&CheckCode::T201),
         checker.settings.enabled.contains(&CheckCode::T203),
     ) {
-        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+        if checker.patch() {
             let context = checker.binding_context();
             if matches!(
                 checker.parents[context.defined_by].node,

src/flake8_quotes/checks.rs

@@ -0,0 +1,298 @@
+use rustpython_ast::Location;
+
+use crate::ast::operations::SourceCodeLocator;
+use crate::ast::types::Range;
+use crate::checks::{Check, CheckKind};
+use crate::flake8_quotes::settings::{Quote, Settings};
+
+fn good_single(quote: &Quote) -> char {
+    match quote {
+        Quote::Single => '\'',
+        Quote::Double => '"',
+    }
+}
+
+fn bad_single(quote: &Quote) -> char {
+    match quote {
+        Quote::Double => '\'',
+        Quote::Single => '"',
+    }
+}
+
+fn good_multiline(quote: &Quote) -> &str {
+    match quote {
+        Quote::Single => "'''",
+        Quote::Double => "\"\"\"",
+    }
+}
+
+fn good_multiline_ending(quote: &Quote) -> &str {
+    match quote {
+        Quote::Single => "'\"\"\"",
+        Quote::Double => "\"'''",
+    }
+}
+
+fn good_docstring(quote: &Quote) -> &str {
+    match quote {
+        Quote::Single => "'''",
+        Quote::Double => "\"\"\"",
+    }
+}
+
+pub fn quotes(
+    locator: &SourceCodeLocator,
+    start: &Location,
+    end: &Location,
+    is_docstring: bool,
+    settings: &Settings,
+) -> Option<Check> {
+    let text = locator.slice_source_code_range(&Range {
+        location: *start,
+        end_location: *end,
+    });
+
+    // Remove any prefixes (e.g., remove `u` from `u"foo"`).
+    let last_quote_char = text.chars().last().unwrap();
+    let first_quote_char = text.find(last_quote_char).unwrap();
+    let prefix = &text[..first_quote_char].to_lowercase();
+    let raw_text = &text[first_quote_char..];
+
+    // Determine if the string is multiline-based.
+    let is_multiline = if raw_text.len() >= 3 {
+        let mut chars = raw_text.chars();
+        let first = chars.next().unwrap();
+        let second = chars.next().unwrap();
+        let third = chars.next().unwrap();
+        first == second && second == third
+    } else {
+        false
+    };
+
+    if is_docstring {
+        if raw_text.contains(good_docstring(&settings.docstring_quotes)) {
+            return None;
+        }
+
+        return Some(Check::new(
+            CheckKind::BadQuotesDocstring(settings.docstring_quotes.clone()),
+            Range {
+                location: *start,
+                end_location: *end,
+            },
+        ));
+    } else if is_multiline {
+        // If our string is or contains a known good string, ignore it.
+        if raw_text.contains(good_multiline(&settings.multiline_quotes)) {
+            return None;
+        }
+
+        // If our string ends with a known good ending, then ignore it.
+        if raw_text.ends_with(good_multiline_ending(&settings.multiline_quotes)) {
+            return None;
+        }
+
+        return Some(Check::new(
+            CheckKind::BadQuotesMultilineString(settings.multiline_quotes.clone()),
+            Range {
+                location: *start,
+                end_location: *end,
+            },
+        ));
+    } else {
+        let string_contents = &raw_text[1..raw_text.len() - 1];
+
+        // If we're using the preferred quotation type, check for escapes.
+        if last_quote_char == good_single(&settings.inline_quotes) {
+            if !settings.avoid_escape || prefix.contains('r') {
+                return None;
+            }
+            if string_contents.contains(good_single(&settings.inline_quotes))
+                && !string_contents.contains(bad_single(&settings.inline_quotes))
+            {
+                return Some(Check::new(
+                    CheckKind::AvoidQuoteEscape,
+                    Range {
+                        location: *start,
+                        end_location: *end,
+                    },
+                ));
+            }
+            return None;
+        }
+
+        // If we're not using the preferred type, only allow use to avoid escapes.
+        if !string_contents.contains(good_single(&settings.inline_quotes)) {
+            return Some(Check::new(
+                CheckKind::BadQuotesInlineString(settings.inline_quotes.clone()),
+                Range {
+                    location: *start,
+                    end_location: *end,
+                },
+            ));
+        }
+    }
+
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use anyhow::Result;
+    use rustpython_parser::lexer::LexResult;
+    use test_case::test_case;
+
+    use crate::autofix::fixer;
+    use crate::checks::{Check, CheckCode};
+    use crate::flake8_quotes::settings::Quote;
+    use crate::linter::tokenize;
+    use crate::{flake8_quotes, linter, Settings};
+    use crate::{fs, noqa};
+
+    fn check_path(path: &Path, settings: &Settings, autofix: &fixer::Mode) -> Result<Vec<Check>> {
+        let contents = fs::read_file(path)?;
+        let tokens: Vec<LexResult> = tokenize(&contents);
+        let noqa_line_for = noqa::extract_noqa_line_for(&tokens);
+        linter::check_path(path, &contents, tokens, &noqa_line_for, settings, autofix)
+    }
+
+    #[test_case(Path::new("doubles.py"))]
+    #[test_case(Path::new("doubles_escaped.py"))]
+    #[test_case(Path::new("doubles_multiline_string.py"))]
+    #[test_case(Path::new("doubles_noqa.py"))]
+    #[test_case(Path::new("doubles_wrapped.py"))]
+    fn doubles(path: &Path) -> Result<()> {
+        let snapshot = format!("doubles_{}", path.to_string_lossy());
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_quotes")
+                .join(path)
+                .as_path(),
+            &Settings {
+                flake8_quotes: flake8_quotes::settings::Settings {
+                    inline_quotes: Quote::Single,
+                    multiline_quotes: Quote::Single,
+                    docstring_quotes: Quote::Single,
+                    avoid_escape: true,
+                },
+                ..Settings::for_rules(vec![
+                    CheckCode::Q000,
+                    CheckCode::Q001,
+                    CheckCode::Q002,
+                    CheckCode::Q003,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+
+    #[test_case(Path::new("singles.py"))]
+    #[test_case(Path::new("singles_escaped.py"))]
+    #[test_case(Path::new("singles_multiline_string.py"))]
+    #[test_case(Path::new("singles_noqa.py"))]
+    #[test_case(Path::new("singles_wrapped.py"))]
+    fn singles(path: &Path) -> Result<()> {
+        let snapshot = format!("singles_{}", path.to_string_lossy());
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_quotes")
+                .join(path)
+                .as_path(),
+            &Settings {
+                flake8_quotes: flake8_quotes::settings::Settings {
+                    inline_quotes: Quote::Double,
+                    multiline_quotes: Quote::Double,
+                    docstring_quotes: Quote::Double,
+                    avoid_escape: true,
+                },
+                ..Settings::for_rules(vec![
+                    CheckCode::Q000,
+                    CheckCode::Q001,
+                    CheckCode::Q002,
+                    CheckCode::Q003,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+
+    #[test_case(Path::new("docstring_doubles.py"))]
+    #[test_case(Path::new("docstring_doubles_module_multiline.py"))]
+    #[test_case(Path::new("docstring_doubles_module_singleline.py"))]
+    #[test_case(Path::new("docstring_doubles_class.py"))]
+    #[test_case(Path::new("docstring_doubles_function.py"))]
+    #[test_case(Path::new("docstring_singles.py"))]
+    #[test_case(Path::new("docstring_singles_module_multiline.py"))]
+    #[test_case(Path::new("docstring_singles_module_singleline.py"))]
+    #[test_case(Path::new("docstring_singles_class.py"))]
+    #[test_case(Path::new("docstring_singles_function.py"))]
+    fn double_docstring(path: &Path) -> Result<()> {
+        let snapshot = format!("double_docstring_{}", path.to_string_lossy());
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_quotes")
+                .join(path)
+                .as_path(),
+            &Settings {
+                flake8_quotes: flake8_quotes::settings::Settings {
+                    inline_quotes: Quote::Single,
+                    multiline_quotes: Quote::Single,
+                    docstring_quotes: Quote::Double,
+                    avoid_escape: true,
+                },
+                ..Settings::for_rules(vec![
+                    CheckCode::Q000,
+                    CheckCode::Q001,
+                    CheckCode::Q002,
+                    CheckCode::Q003,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+
+    #[test_case(Path::new("docstring_doubles.py"))]
+    #[test_case(Path::new("docstring_doubles_module_multiline.py"))]
+    #[test_case(Path::new("docstring_doubles_module_singleline.py"))]
+    #[test_case(Path::new("docstring_doubles_class.py"))]
+    #[test_case(Path::new("docstring_doubles_function.py"))]
+    #[test_case(Path::new("docstring_singles.py"))]
+    #[test_case(Path::new("docstring_singles_module_multiline.py"))]
+    #[test_case(Path::new("docstring_singles_module_singleline.py"))]
+    #[test_case(Path::new("docstring_singles_class.py"))]
+    #[test_case(Path::new("docstring_singles_function.py"))]
+    fn single_docstring(path: &Path) -> Result<()> {
+        let snapshot = format!("single_docstring_{}", path.to_string_lossy());
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_quotes")
+                .join(path)
+                .as_path(),
+            &Settings {
+                flake8_quotes: flake8_quotes::settings::Settings {
+                    inline_quotes: Quote::Single,
+                    multiline_quotes: Quote::Double,
+                    docstring_quotes: Quote::Single,
+                    avoid_escape: true,
+                },
+                ..Settings::for_rules(vec![
+                    CheckCode::Q000,
+                    CheckCode::Q001,
+                    CheckCode::Q002,
+                    CheckCode::Q003,
+                ])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+}

src/flake8_quotes/docstring_detection.rs

@@ -0,0 +1,118 @@
+//! Extract docstrings via tokenization.
+//!
+//! See: https://github.com/zheller/flake8-quotes/blob/ef0d9a90249a080e460b70ab62bf4b65e5aa5816/flake8_quotes/docstring_detection.py#L29
+//!
+//! TODO(charlie): Consolidate with the existing AST-based docstring extraction.
+
+use rustpython_parser::lexer::Tok;
+
+#[derive(Debug)]
+enum State {
+    // Start of the module: first string gets marked as a docstring.
+    ExpectModuleDocstring,
+    // After seeing a class definition, we're waiting for the block colon (and do bracket counting).
+    ExpectClassColon,
+    // After seeing the block colon in a class definition, we expect a docstring.
+    ExpectClassDocstring,
+    // Same as ExpectClassColon, but for function definitions.
+    ExpectFunctionColon,
+    // Same as ExpectClassDocstring, but for function definitions.
+    ExpectFunctionDocstring,
+    // Skip tokens until we observe a `class` or `def`.
+    Other,
+}
+
+pub struct StateMachine {
+    state: State,
+    bracket_count: usize,
+}
+
+impl StateMachine {
+    pub fn new() -> Self {
+        Self {
+            state: State::ExpectModuleDocstring,
+            bracket_count: 0,
+        }
+    }
+
+    pub fn consume(&mut self, tok: &Tok) -> bool {
+        if matches!(tok, Tok::Newline | Tok::Indent | Tok::Dedent) {
+            return false;
+        }
+
+        if matches!(tok, Tok::String { .. }) {
+            return if matches!(
+                self.state,
+                State::ExpectModuleDocstring
+                    | State::ExpectClassDocstring
+                    | State::ExpectFunctionDocstring
+            ) {
+                self.state = State::Other;
+                true
+            } else {
+                false
+            };
+        }
+
+        if matches!(tok, Tok::Class) {
+            self.state = State::ExpectClassColon;
+            self.bracket_count = 0;
+            return false;
+        }
+
+        if matches!(tok, Tok::Def) {
+            self.state = State::ExpectFunctionColon;
+            self.bracket_count = 0;
+            return false;
+        }
+
+        if matches!(tok, Tok::Colon) {
+            if self.bracket_count == 0 {
+                if matches!(self.state, State::ExpectClassColon) {
+                    self.state = State::ExpectClassDocstring;
+                } else if matches!(self.state, State::ExpectFunctionColon) {
+                    self.state = State::ExpectFunctionDocstring;
+                }
+            }
+            return false;
+        }
+
+        if matches!(tok, Tok::Lpar | Tok::Lbrace | Tok::Lsqb) {
+            self.bracket_count += 1;
+            if matches!(
+                self.state,
+                State::ExpectModuleDocstring
+                    | State::ExpectClassDocstring
+                    | State::ExpectFunctionDocstring
+            ) {
+                self.state = State::Other;
+            }
+            return false;
+        }
+
+        if matches!(tok, Tok::Rpar | Tok::Rbrace | Tok::Rsqb) {
+            self.bracket_count -= 1;
+            if matches!(
+                self.state,
+                State::ExpectModuleDocstring
+                    | State::ExpectClassDocstring
+                    | State::ExpectFunctionDocstring
+            ) {
+                self.state = State::Other;
+            }
+            return false;
+        }
+
+        if matches!(
+            self.state,
+            State::ExpectModuleDocstring
+                | State::ExpectClassDocstring
+                | State::ExpectFunctionDocstring
+        ) {
+            self.state = State::Other;
+            return false;
+        }
+
+        false
+    }
+}

src/flake8_quotes/mod.rs

@@ -0,0 +1,3 @@
+pub mod checks;
+pub mod docstring_detection;
+pub mod settings;

src/flake8_quotes/settings.rs

@@ -0,0 +1,49 @@
+//! Settings for the `flake_quotes` plugin.
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub enum Quote {
+    Single,
+    Double,
+}
+
+#[derive(Debug, PartialEq, Eq, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub struct Options {
+    pub inline_quotes: Option<Quote>,
+    pub multiline_quotes: Option<Quote>,
+    pub docstring_quotes: Option<Quote>,
+    pub avoid_escape: Option<bool>,
+}
+
+#[derive(Debug)]
+pub struct Settings {
+    pub inline_quotes: Quote,
+    pub multiline_quotes: Quote,
+    pub docstring_quotes: Quote,
+    pub avoid_escape: bool,
+}
+
+impl Settings {
+    pub fn from_config(config: Options) -> Self {
+        Self {
+            inline_quotes: config.inline_quotes.unwrap_or(Quote::Single),
+            multiline_quotes: config.multiline_quotes.unwrap_or(Quote::Double),
+            docstring_quotes: config.docstring_quotes.unwrap_or(Quote::Double),
+            avoid_escape: config.avoid_escape.unwrap_or(true),
+        }
+    }
+}
+
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            inline_quotes: Quote::Single,
+            multiline_quotes: Quote::Double,
+            docstring_quotes: Quote::Double,
+            avoid_escape: true,
+        }
+    }
+}

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__double_docstring_docstring_doubles.py.snap

@@ -0,0 +1,50 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 5
+    column: 1
+  end_location:
+    row: 7
+    column: 4
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 16
+    column: 5
+  end_location:
+    row: 18
+    column: 8
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 21
+    column: 21
+  end_location:
+    row: 22
+    column: 38
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 30
+    column: 9
+  end_location:
+    row: 32
+    column: 12
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 35
+    column: 13
+  end_location:
+    row: 37
+    column: 16
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__double_docstring_docstring_doubles_class.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 3
+    column: 5
+  end_location:
+    row: 3
+    column: 28
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 5
+    column: 23
+  end_location:
+    row: 5
+    column: 44
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__double_docstring_docstring_doubles_function.py.snap

@@ -0,0 +1,50 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 3
+    column: 5
+  end_location:
+    row: 3
+    column: 27
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 11
+    column: 5
+  end_location:
+    row: 11
+    column: 27
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 15
+    column: 39
+  end_location:
+    row: 17
+    column: 4
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 17
+    column: 5
+  end_location:
+    row: 17
+    column: 20
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 21
+    column: 5
+  end_location:
+    row: 21
+    column: 28
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__double_docstring_docstring_doubles_module_multiline.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 4
+    column: 1
+  end_location:
+    row: 6
+    column: 4
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 9
+    column: 1
+  end_location:
+    row: 11
+    column: 4
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__double_docstring_docstring_doubles_module_singleline.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 2
+    column: 1
+  end_location:
+    row: 2
+    column: 32
+  fix: ~
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 6
+    column: 1
+  end_location:
+    row: 6
+    column: 32
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__double_docstring_docstring_singles.py.snap

@@ -0,0 +1,32 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 1
+    column: 1
+  end_location:
+    row: 3
+    column: 4
+  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 14
+    column: 5
+  end_location:
+    row: 16
+    column: 8
+  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 26
+    column: 9
+  end_location:
+    row: 28
+    column: 12
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__double_docstring_docstring_singles_class.py.snap

@@ -0,0 +1,32 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 2
+    column: 5
+  end_location:
+    row: 2
+    column: 54
+  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 6
+    column: 9
+  end_location:
+    row: 6
+    column: 58
+  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 9
+    column: 29
+  end_location:
+    row: 9
+    column: 53
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__double_docstring_docstring_singles_function.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 2
+    column: 5
+  end_location:
+    row: 2
+    column: 57
+  fix: ~
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 8
+    column: 5
+  end_location:
+    row: 10
+    column: 8
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__double_docstring_docstring_singles_module_multiline.py.snap

@@ -0,0 +1,14 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 1
+    column: 1
+  end_location:
+    row: 3
+    column: 4
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__double_docstring_docstring_singles_module_singleline.py.snap

@@ -0,0 +1,14 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: double
+  location:
+    row: 1
+    column: 1
+  end_location:
+    row: 1
+    column: 50
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__doubles_doubles.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesInlineString: single
+  location:
+    row: 1
+    column: 25
+  end_location:
+    row: 1
+    column: 46
+  fix: ~
+- kind:
+    BadQuotesInlineString: single
+  location:
+    row: 2
+    column: 25
+  end_location:
+    row: 2
+    column: 47
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__doubles_doubles_escaped.py.snap

@@ -0,0 +1,13 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind: AvoidQuoteEscape
+  location:
+    row: 1
+    column: 26
+  end_location:
+    row: 1
+    column: 48
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__doubles_doubles_multiline_string.py.snap

@@ -0,0 +1,14 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: single
+  location:
+    row: 1
+    column: 5
+  end_location:
+    row: 3
+    column: 13
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__doubles_doubles_noqa.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+[]
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__doubles_doubles_wrapped.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+[]
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__single_docstring_docstring_doubles.py.snap

@@ -0,0 +1,32 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 1
+    column: 1
+  end_location:
+    row: 3
+    column: 4
+  fix: ~
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 12
+    column: 5
+  end_location:
+    row: 14
+    column: 8
+  fix: ~
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 24
+    column: 9
+  end_location:
+    row: 26
+    column: 12
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__single_docstring_docstring_doubles_class.py.snap

@@ -0,0 +1,32 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 2
+    column: 5
+  end_location:
+    row: 2
+    column: 54
+  fix: ~
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 6
+    column: 9
+  end_location:
+    row: 6
+    column: 58
+  fix: ~
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 9
+    column: 29
+  end_location:
+    row: 9
+    column: 53
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__single_docstring_docstring_doubles_function.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 2
+    column: 5
+  end_location:
+    row: 2
+    column: 57
+  fix: ~
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 8
+    column: 5
+  end_location:
+    row: 10
+    column: 8
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__single_docstring_docstring_doubles_module_multiline.py.snap

@@ -0,0 +1,14 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 1
+    column: 1
+  end_location:
+    row: 3
+    column: 4
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__single_docstring_docstring_doubles_module_singleline.py.snap

@@ -0,0 +1,14 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesDocstring: single
+  location:
+    row: 1
+    column: 1
+  end_location:
+    row: 1
+    column: 50
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__single_docstring_docstring_singles.py.snap

@@ -0,0 +1,59 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 5
+    column: 1
+  end_location:
+    row: 7
+    column: 4
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 11
+    column: 21
+  end_location:
+    row: 13
+    column: 4
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 18
+    column: 5
+  end_location:
+    row: 20
+    column: 8
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 23
+    column: 21
+  end_location:
+    row: 24
+    column: 38
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 32
+    column: 9
+  end_location:
+    row: 34
+    column: 12
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 37
+    column: 13
+  end_location:
+    row: 39
+    column: 16
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__single_docstring_docstring_singles_class.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 3
+    column: 5
+  end_location:
+    row: 3
+    column: 28
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 5
+    column: 23
+  end_location:
+    row: 5
+    column: 44
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__single_docstring_docstring_singles_function.py.snap

@@ -0,0 +1,50 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 3
+    column: 5
+  end_location:
+    row: 3
+    column: 27
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 11
+    column: 5
+  end_location:
+    row: 11
+    column: 27
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 15
+    column: 39
+  end_location:
+    row: 17
+    column: 4
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 17
+    column: 5
+  end_location:
+    row: 17
+    column: 20
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 21
+    column: 5
+  end_location:
+    row: 21
+    column: 28
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__single_docstring_docstring_singles_module_multiline.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 4
+    column: 1
+  end_location:
+    row: 6
+    column: 4
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 9
+    column: 1
+  end_location:
+    row: 11
+    column: 4
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__single_docstring_docstring_singles_module_singleline.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 2
+    column: 1
+  end_location:
+    row: 2
+    column: 32
+  fix: ~
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 6
+    column: 1
+  end_location:
+    row: 6
+    column: 32
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__singles_singles.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesInlineString: double
+  location:
+    row: 1
+    column: 25
+  end_location:
+    row: 1
+    column: 46
+  fix: ~
+- kind:
+    BadQuotesInlineString: double
+  location:
+    row: 2
+    column: 25
+  end_location:
+    row: 2
+    column: 47
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__singles_singles_escaped.py.snap

@@ -0,0 +1,13 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind: AvoidQuoteEscape
+  location:
+    row: 1
+    column: 26
+  end_location:
+    row: 1
+    column: 48
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__singles_singles_multiline_string.py.snap

@@ -0,0 +1,14 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+- kind:
+    BadQuotesMultilineString: double
+  location:
+    row: 1
+    column: 5
+  end_location:
+    row: 3
+    column: 13
+  fix: ~
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__singles_singles_noqa.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+[]
+

src/flake8_quotes/snapshots/ruff__flake8_quotes__checks__tests__singles_singles_wrapped.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/flake8_quotes/checks.rs
+expression: checks
+---
+[]
+

src/fs.rs

@@ -12,7 +12,7 @@ use path_absolutize::Absolutize;
 use walkdir::{DirEntry, WalkDir};
 
 use crate::checks::CheckCode;
-use crate::settings::{FilePattern, PerFileIgnore};
+use crate::settings::types::{FilePattern, PerFileIgnore};
 
 /// Extract the absolute path and basename (as strings) from a Path.
 fn extract_path_names(path: &Path) -> Result<(&str, &str)> {
@@ -133,7 +133,7 @@ pub fn ignores_from_path<'a>(
                 [&pattern_code_pair.pattern].into_iter(),
             )
         })
-        .map(|pattern_code_pair| &pattern_code_pair.code)
+        .flat_map(|pattern_code_pair| &pattern_code_pair.codes)
         .collect())
 }
 
@@ -178,7 +178,7 @@ mod tests {
     use path_absolutize::Absolutize;
 
     use crate::fs::{extract_path_names, is_excluded, is_included};
-    use crate::settings::FilePattern;
+    use crate::settings::types::FilePattern;
 
     #[test]
     fn inclusions() {

src/lib.rs

@@ -6,24 +6,31 @@ use anyhow::Result;
 use log::debug;
 use rustpython_parser::lexer::LexResult;
 
+use settings::pyproject;
+use settings::Settings;
+
 use crate::autofix::fixer::Mode;
 use crate::linter::{check_path, tokenize};
 use crate::message::Message;
-use crate::settings::{RawSettings, Settings};
+use crate::settings::configuration::Configuration;
 
 mod ast;
 mod autofix;
 pub mod cache;
 pub mod check_ast;
 mod check_lines;
+mod check_tokens;
 pub mod checks;
+mod checks_gen;
 pub mod cli;
 pub mod code_gen;
+mod cst;
 mod docstrings;
 mod flake8_bugbear;
 mod flake8_builtins;
 mod flake8_comprehensions;
 mod flake8_print;
+mod flake8_quotes;
 pub mod fs;
 pub mod linter;
 pub mod logging;
@@ -34,14 +41,13 @@ pub mod printer;
 mod pycodestyle;
 mod pydocstyle;
 mod pyflakes;
-pub mod pyproject;
 mod python;
 mod pyupgrade;
 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 +60,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_configuration(Configuration::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
@@ -226,16 +236,12 @@ mod tests {
 
     use crate::autofix::fixer;
     use crate::checks::{Check, CheckCode};
-    use crate::linter;
     use crate::linter::tokenize;
     use crate::settings;
     use crate::{fs, noqa};
+    use crate::{linter, Settings};
 
-    fn check_path(
-        path: &Path,
-        settings: &settings::Settings,
-        autofix: &fixer::Mode,
-    ) -> Result<Vec<Check>> {
+    fn check_path(path: &Path, settings: &Settings, autofix: &fixer::Mode) -> Result<Vec<Check>> {
         let contents = fs::read_file(path)?;
         let tokens: Vec<LexResult> = tokenize(&contents);
         let noqa_line_for = noqa::extract_noqa_line_for(&tokens);
@@ -246,7 +252,9 @@ mod tests {
     #[test_case(CheckCode::A002, Path::new("A002.py"); "A002")]
     #[test_case(CheckCode::A003, Path::new("A003.py"); "A003")]
     #[test_case(CheckCode::B002, Path::new("B002.py"); "B002")]
+    #[test_case(CheckCode::B007, Path::new("B007.py"); "B007")]
     #[test_case(CheckCode::B011, Path::new("B011.py"); "B011")]
+    #[test_case(CheckCode::B013, Path::new("B013.py"); "B013")]
     #[test_case(CheckCode::B014, Path::new("B014.py"); "B014")]
     #[test_case(CheckCode::B017, Path::new("B017.py"); "B017")]
     #[test_case(CheckCode::B025, Path::new("B025.py"); "B025")]
@@ -329,6 +337,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")]
@@ -360,12 +369,16 @@ mod tests {
     #[test_case(CheckCode::N803, Path::new("N803.py"); "N803")]
     #[test_case(CheckCode::N804, Path::new("N804.py"); "N804")]
     #[test_case(CheckCode::N805, Path::new("N805.py"); "N805")]
+    #[test_case(CheckCode::N806, Path::new("N806.py"); "N806")]
     #[test_case(CheckCode::N807, Path::new("N807.py"); "N807")]
     #[test_case(CheckCode::N811, Path::new("N811.py"); "N811")]
     #[test_case(CheckCode::N812, Path::new("N812.py"); "N812")]
     #[test_case(CheckCode::N813, Path::new("N813.py"); "N813")]
     #[test_case(CheckCode::N814, Path::new("N814.py"); "N814")]
+    #[test_case(CheckCode::N815, Path::new("N815.py"); "N815")]
+    #[test_case(CheckCode::N816, Path::new("N816.py"); "N816")]
     #[test_case(CheckCode::N817, Path::new("N817.py"); "N817")]
+    #[test_case(CheckCode::N818, Path::new("N818.py"); "N818")]
     #[test_case(CheckCode::T201, Path::new("T201.py"); "T201")]
     #[test_case(CheckCode::T203, Path::new("T203.py"); "T203")]
     #[test_case(CheckCode::U001, Path::new("U001.py"); "U001")]
@@ -379,6 +392,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

@@ -25,10 +25,11 @@ use ruff::linter::{lint_path, lint_stdin};
 use ruff::logging::set_up_logging;
 use ruff::message::Message;
 use ruff::printer::{Printer, SerializationFormat};
-use ruff::pyproject::{self};
-use ruff::settings::CurrentSettings;
-use ruff::settings::RawSettings;
-use ruff::settings::{FilePattern, PerFileIgnore, Settings};
+use ruff::settings::configuration::Configuration;
+use ruff::settings::pyproject;
+use ruff::settings::types::{FilePattern, PerFileIgnore};
+use ruff::settings::user::UserConfiguration;
+use ruff::settings::Settings;
 use ruff::tell_user;
 
 #[cfg(feature = "update-informer")]
@@ -73,10 +74,14 @@ fn check_for_updates() {
     }
 }
 
-fn show_settings(settings: RawSettings, project_root: Option<PathBuf>, pyproject: Option<PathBuf>) {
+fn show_settings(
+    configuration: Configuration,
+    project_root: Option<PathBuf>,
+    pyproject: Option<PathBuf>,
+) {
     println!(
         "{:#?}",
-        CurrentSettings::from_settings(settings, project_root, pyproject)
+        UserConfiguration::from_configuration(configuration, project_root, pyproject)
     );
 }
 
@@ -220,7 +225,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,15 +261,15 @@ fn inner_main() -> Result<ExitCode> {
         .map(|pair| PerFileIgnore::new(pair, &project_root))
         .collect();
 
-    let mut settings = RawSettings::from_pyproject(&pyproject, &project_root)?;
+    let mut configuration = Configuration::from_pyproject(&pyproject, &project_root, cli.quiet)?;
     if !exclude.is_empty() {
-        settings.exclude = exclude;
+        configuration.exclude = exclude;
     }
     if !extend_exclude.is_empty() {
-        settings.extend_exclude = extend_exclude;
+        configuration.extend_exclude = extend_exclude;
     }
     if !per_file_ignores.is_empty() {
-        settings.per_file_ignores = per_file_ignores;
+        configuration.per_file_ignores = per_file_ignores;
     }
     if !cli.select.is_empty() {
         warn_on(
@@ -271,10 +277,10 @@ fn inner_main() -> Result<ExitCode> {
             &cli.select,
             &cli.ignore,
             &cli.extend_ignore,
-            &settings,
+            &configuration,
             &pyproject,
         );
-        settings.select = cli.select;
+        configuration.select = cli.select;
     }
     if !cli.extend_select.is_empty() {
         warn_on(
@@ -282,22 +288,22 @@ fn inner_main() -> Result<ExitCode> {
             &cli.extend_select,
             &cli.ignore,
             &cli.extend_ignore,
-            &settings,
+            &configuration,
             &pyproject,
         );
-        settings.extend_select = cli.extend_select;
+        configuration.extend_select = cli.extend_select;
     }
     if !cli.ignore.is_empty() {
-        settings.ignore = cli.ignore;
+        configuration.ignore = cli.ignore;
     }
     if !cli.extend_ignore.is_empty() {
-        settings.extend_ignore = cli.extend_ignore;
+        configuration.extend_ignore = cli.extend_ignore;
     }
     if let Some(target_version) = cli.target_version {
-        settings.target_version = target_version;
+        configuration.target_version = target_version;
     }
     if let Some(dummy_variable_rgx) = cli.dummy_variable_rgx {
-        settings.dummy_variable_rgx = dummy_variable_rgx;
+        configuration.dummy_variable_rgx = dummy_variable_rgx;
     }
 
     if cli.show_settings && cli.show_files {
@@ -305,11 +311,11 @@ fn inner_main() -> Result<ExitCode> {
         return Ok(ExitCode::FAILURE);
     }
     if cli.show_settings {
-        show_settings(settings, project_root, pyproject);
+        show_settings(configuration, project_root, pyproject);
         return Ok(ExitCode::SUCCESS);
     }
 
-    let settings = Settings::from_raw(settings);
+    let settings = Settings::from_configuration(configuration);
 
     if cli.show_files {
         show_files(&cli.files, &settings);
@@ -342,7 +348,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 +368,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 +394,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/noqa.rs

@@ -169,7 +169,6 @@ y = 2
 z = x + 1",
         )
         .collect();
-        println!("{:?}", extract_noqa_line_for(&lxr));
         assert_eq!(extract_noqa_line_for(&lxr), empty);
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
@@ -179,7 +178,6 @@ y = 2
 z = x + 1",
         )
         .collect();
-        println!("{:?}", extract_noqa_line_for(&lxr));
         assert_eq!(extract_noqa_line_for(&lxr), empty);
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
@@ -189,7 +187,6 @@ z = x + 1
         ",
         )
         .collect();
-        println!("{:?}", extract_noqa_line_for(&lxr));
         assert_eq!(extract_noqa_line_for(&lxr), empty);
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
@@ -200,7 +197,6 @@ z = x + 1
         ",
         )
         .collect();
-        println!("{:?}", extract_noqa_line_for(&lxr));
         assert_eq!(extract_noqa_line_for(&lxr), empty);
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(

src/pep8_naming/checks.rs

@@ -1,7 +1,7 @@
 use itertools::Itertools;
 use rustpython_ast::{Arguments, Expr, ExprKind, Stmt};
 
-use crate::ast::types::{Range, Scope, ScopeKind};
+use crate::ast::types::{FunctionScope, Range, Scope, ScopeKind};
 use crate::checks::{Check, CheckKind};
 
 pub fn invalid_class_name(class_def: &Stmt, name: &str) -> Option<Check> {
@@ -21,8 +21,23 @@ pub fn invalid_class_name(class_def: &Stmt, name: &str) -> Option<Check> {
     None
 }
 
+const IGNORE_NAMES: &[&str] = &[
+    "setUp",
+    "tearDown",
+    "setUpClass",
+    "tearDownClass",
+    "setUpModule",
+    "tearDownModule",
+    "asyncSetUp",
+    "asyncTearDown",
+    "setUpTestData",
+    "failureException",
+    "longMessage",
+    "maxDiff",
+];
+
 pub fn invalid_function_name(func_def: &Stmt, name: &str) -> Option<Check> {
-    if name.chars().any(|c| c.is_uppercase()) {
+    if !is_lower(name) && !IGNORE_NAMES.contains(&name) {
         return Some(Check::new(
             CheckKind::InvalidFunctionName(name.to_string()),
             Range::from_located(func_def),
@@ -32,7 +47,7 @@ pub fn invalid_function_name(func_def: &Stmt, name: &str) -> Option<Check> {
 }
 
 pub fn invalid_argument_name(location: Range, name: &str) -> Option<Check> {
-    if name.chars().any(|c| c.is_uppercase()) {
+    if !is_lower(name) {
         return Some(Check::new(
             CheckKind::InvalidArgumentName(name.to_string()),
             location,
@@ -99,6 +114,49 @@ pub fn invalid_first_argument_name_for_method(
     None
 }
 
+pub fn non_lowercase_variable_in_function(scope: &Scope, expr: &Expr, name: &str) -> Option<Check> {
+    if !matches!(scope.kind, ScopeKind::Function(FunctionScope { .. })) {
+        return None;
+    }
+    if !is_lower(name) {
+        return Some(Check::new(
+            CheckKind::NonLowercaseVariableInFunction(name.to_string()),
+            Range::from_located(expr),
+        ));
+    }
+    None
+}
+
+pub fn mixed_case_variable_in_class_scope(scope: &Scope, expr: &Expr, name: &str) -> Option<Check> {
+    if !matches!(scope.kind, ScopeKind::Class) {
+        return None;
+    }
+    if is_mixed_case(name) {
+        return Some(Check::new(
+            CheckKind::MixedCaseVariableInClassScope(name.to_string()),
+            Range::from_located(expr),
+        ));
+    }
+    None
+}
+
+pub fn mixed_case_variable_in_global_scope(
+    scope: &Scope,
+    expr: &Expr,
+    name: &str,
+) -> Option<Check> {
+    if !matches!(scope.kind, ScopeKind::Module) {
+        return None;
+    }
+    if is_mixed_case(name) {
+        return Some(Check::new(
+            CheckKind::MixedCaseVariableInGlobalScope(name.to_string()),
+            Range::from_located(expr),
+        ));
+    }
+    None
+}
+
 pub fn dunder_function_name(func_def: &Stmt, scope: &Scope, name: &str) -> Option<Check> {
     if matches!(scope.kind, ScopeKind::Class) {
         return None;
@@ -169,6 +227,17 @@ pub fn lowercase_imported_as_non_lowercase(
 fn is_camelcase(name: &str) -> bool {
     !is_lower(name) && !is_upper(name) && !name.contains('_')
 }
+
+fn is_mixed_case(name: &str) -> bool {
+    !is_lower(name)
+        && name
+            .strip_prefix('_')
+            .unwrap_or(name)
+            .chars()
+            .next()
+            .map_or_else(|| false, |c| c.is_lowercase())
+}
+
 fn is_acronym(name: &str, asname: &str) -> bool {
     name.chars().filter(|c| c.is_uppercase()).join("") == asname
 }
@@ -215,9 +284,31 @@ pub fn camelcase_imported_as_acronym(
     None
 }
 
+pub fn error_suffix_on_exception_name(
+    class_def: &Stmt,
+    bases: &[Expr],
+    name: &str,
+) -> Option<Check> {
+    if bases.iter().any(|base| {
+        if let ExprKind::Name { id, .. } = &base.node {
+            id == "Exception"
+        } else {
+            false
+        }
+    }) {
+        if !name.ends_with("Error") {
+            return Some(Check::new(
+                CheckKind::ErrorSuffixOnExceptionName(name.to_string()),
+                Range::from_located(class_def),
+            ));
+        }
+    }
+    None
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{is_acronym, is_camelcase, is_lower, is_upper};
+    use super::{is_acronym, is_camelcase, is_lower, is_mixed_case, is_upper};
 
     #[test]
     fn test_is_lower() -> () {
@@ -251,6 +342,17 @@ mod tests {
         assert!(!is_camelcase("CAMEL_CASE"));
     }
 
+    #[test]
+    fn test_is_mixed_case() -> () {
+        assert!(is_mixed_case("mixedCase"));
+        assert!(is_mixed_case("mixed_Case"));
+        assert!(is_mixed_case("_mixed_Case"));
+        assert!(!is_mixed_case("mixed_case"));
+        assert!(!is_mixed_case("MIXED_CASE"));
+        assert!(!is_mixed_case(""));
+        assert!(!is_mixed_case("_"));
+    }
+
     #[test]
     fn test_is_acronym() -> () {
         assert!(is_acronym("AB", "AB"));

src/pycodestyle/checks.rs

@@ -1,6 +1,8 @@
 use itertools::izip;
+use rustpython_ast::Location;
 use rustpython_parser::ast::{Cmpop, Constant, Expr, ExprKind, Unaryop};
 
+use crate::ast::operations::SourceCodeLocator;
 use crate::ast::types::{CheckLocator, Range};
 use crate::checks::{Check, CheckKind, RejectedCmpop};
 
@@ -8,7 +10,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 +22,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 +34,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 +46,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 +55,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 +94,7 @@ pub fn not_tests(
     checks
 }
 
-/// Check TrueFalseComparison and NoneComparison compliance.
+/// E711, E712
 pub fn literal_comparisons(
     left: &Expr,
     ops: &[Cmpop],
@@ -201,7 +203,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![];
 
@@ -236,3 +238,92 @@ pub fn type_comparison(ops: &[Cmpop], comparators: &[Expr], location: Range) ->
 
     checks
 }
+
+// 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 {
+    for quote in ["'''", "\"\"\"", "'", "\""] {
+        if text.ends_with(quote) {
+            return quote;
+        }
+    }
+
+    panic!("Unable to find quotation mark for String token.")
+}
+
+/// W605
+pub 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
+}

src/pydocstyle/plugins.rs

@@ -6,7 +6,6 @@ use regex::Regex;
 use rustpython_ast::{Arg, Constant, ExprKind, Location, StmtKind};
 
 use crate::ast::types::Range;
-use crate::autofix::fixer;
 use crate::autofix::Fix;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckCode, CheckKind};
@@ -162,12 +161,12 @@ pub fn blank_before_after_function(checker: &mut Checker, definition: &Definitio
                 ..
             } = &docstring.node
             {
-                let (before, _, after) = checker.locator.partition_source_code_at(
-                    &Range::from_located(parent),
-                    &Range::from_located(docstring),
-                );
-
                 if checker.settings.enabled.contains(&CheckCode::D201) {
+                    let (before, _, _) = checker.get_locator().partition_source_code_at(
+                        &Range::from_located(parent),
+                        &Range::from_located(docstring),
+                    );
+
                     let blank_lines_before = before
                         .lines()
                         .rev()
@@ -179,7 +178,7 @@ pub fn blank_before_after_function(checker: &mut Checker, definition: &Definitio
                             CheckKind::NoBlankLineBeforeFunction(blank_lines_before),
                             Range::from_located(docstring),
                         );
-                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                        if checker.patch() {
                             // Delete the blank line before the docstring.
                             check.amend(Fix::deletion(
                                 Location::new(docstring.location.row() - blank_lines_before, 1),
@@ -191,6 +190,11 @@ pub fn blank_before_after_function(checker: &mut Checker, definition: &Definitio
                 }
 
                 if checker.settings.enabled.contains(&CheckCode::D202) {
+                    let (_, _, after) = checker.get_locator().partition_source_code_at(
+                        &Range::from_located(parent),
+                        &Range::from_located(docstring),
+                    );
+
                     let all_blank_after = after
                         .lines()
                         .skip(1)
@@ -217,7 +221,7 @@ pub fn blank_before_after_function(checker: &mut Checker, definition: &Definitio
                             CheckKind::NoBlankLineAfterFunction(blank_lines_after),
                             Range::from_located(docstring),
                         );
-                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                        if checker.patch() {
                             // Delete the blank line after the docstring.
                             check.amend(Fix::deletion(
                                 Location::new(
@@ -246,14 +250,14 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
                 ..
             } = &docstring.node
             {
-                let (before, _, after) = checker.locator.partition_source_code_at(
-                    &Range::from_located(parent),
-                    &Range::from_located(docstring),
-                );
-
                 if checker.settings.enabled.contains(&CheckCode::D203)
                     || checker.settings.enabled.contains(&CheckCode::D211)
                 {
+                    let (before, _, _) = checker.get_locator().partition_source_code_at(
+                        &Range::from_located(parent),
+                        &Range::from_located(docstring),
+                    );
+
                     let blank_lines_before = before
                         .lines()
                         .rev()
@@ -266,8 +270,7 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
                                 CheckKind::NoBlankLineBeforeClass(blank_lines_before),
                                 Range::from_located(docstring),
                             );
-                            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply)
-                            {
+                            if checker.patch() {
                                 // Delete the blank line before the class.
                                 check.amend(Fix::deletion(
                                     Location::new(docstring.location.row() - blank_lines_before, 1),
@@ -283,8 +286,7 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
                                 CheckKind::OneBlankLineBeforeClass(blank_lines_before),
                                 Range::from_located(docstring),
                             );
-                            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply)
-                            {
+                            if checker.patch() {
                                 // Insert one blank line before the class.
                                 check.amend(Fix::replacement(
                                     "\n".to_string(),
@@ -298,6 +300,11 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
                 }
 
                 if checker.settings.enabled.contains(&CheckCode::D204) {
+                    let (_, _, after) = checker.get_locator().partition_source_code_at(
+                        &Range::from_located(parent),
+                        &Range::from_located(docstring),
+                    );
+
                     let all_blank_after = after
                         .lines()
                         .skip(1)
@@ -316,7 +323,7 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
                             CheckKind::OneBlankLineAfterClass(blank_lines_after),
                             Range::from_located(docstring),
                         );
-                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                        if checker.patch() {
                             // Insert a blank line before the class (replacing any existing lines).
                             check.amend(Fix::replacement(
                                 "\n".to_string(),
@@ -358,7 +365,7 @@ pub fn blank_after_summary(checker: &mut Checker, definition: &Definition) {
                     CheckKind::BlankLineAfterSummary,
                     Range::from_located(docstring),
                 );
-                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                if checker.patch() {
                     // Insert one blank line after the summary (replacing any existing lines).
                     check.amend(Fix::replacement(
                         "\n".to_string(),
@@ -417,7 +424,7 @@ pub fn indent(checker: &mut Checker, definition: &Definition) {
                                 end_location: Location::new(docstring.location.row() + i, 1),
                             },
                         );
-                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                        if checker.patch() {
                             check.amend(Fix::replacement(
                                 helpers::clean(&docstring_indent),
                                 Location::new(docstring.location.row() + i, 1),
@@ -466,8 +473,7 @@ pub fn indent(checker: &mut Checker, definition: &Definition) {
                                     end_location: Location::new(docstring.location.row() + i, 1),
                                 },
                             );
-                            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply)
-                            {
+                            if checker.patch() {
                                 check.amend(Fix::replacement(
                                     helpers::clean(&docstring_indent),
                                     Location::new(docstring.location.row() + i, 1),
@@ -494,7 +500,7 @@ pub fn indent(checker: &mut Checker, definition: &Definition) {
                                 end_location: Location::new(docstring.location.row() + i, 1),
                             },
                         );
-                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                        if checker.patch() {
                             check.amend(Fix::replacement(
                                 helpers::clean(&docstring_indent),
                                 Location::new(docstring.location.row() + i, 1),
@@ -524,7 +530,7 @@ pub fn newline_after_last_paragraph(checker: &mut Checker, definition: &Definiti
                 }
                 if line_count > 1 {
                     let content = checker
-                        .locator
+                        .get_locator()
                         .slice_source_code_range(&Range::from_located(docstring));
                     if let Some(last_line) = content.lines().last().map(|line| line.trim()) {
                         if last_line != "\"\"\"" && last_line != "'''" {
@@ -532,8 +538,7 @@ pub fn newline_after_last_paragraph(checker: &mut Checker, definition: &Definiti
                                 CheckKind::NewLineAfterLastParagraph,
                                 Range::from_located(docstring),
                             );
-                            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply)
-                            {
+                            if checker.patch() {
                                 // Insert a newline just before the end-quote(s).
                                 let content = format!(
                                     "\n{}",
@@ -576,9 +581,9 @@ pub fn no_surrounding_whitespace(checker: &mut Checker, definition: &Definition)
                         CheckKind::NoSurroundingWhitespace,
                         Range::from_located(docstring),
                     );
-                    if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                    if checker.patch() {
                         if let Some(first_line) = checker
-                            .locator
+                            .get_locator()
                             .slice_source_code_range(&Range::from_located(docstring))
                             .lines()
                             .next()
@@ -624,7 +629,7 @@ pub fn multi_line_summary_start(checker: &mut Checker, definition: &Definition)
         {
             if string.lines().nth(1).is_some() {
                 if let Some(first_line) = checker
-                    .locator
+                    .get_locator()
                     .slice_source_code_range(&Range::from_located(docstring))
                     .lines()
                     .next()
@@ -660,7 +665,7 @@ pub fn triple_quotes(checker: &mut Checker, definition: &Definition) {
         } = &docstring.node
         {
             if let Some(first_line) = checker
-                .locator
+                .get_locator()
                 .slice_source_code_range(&Range::from_located(docstring))
                 .lines()
                 .next()
@@ -911,7 +916,7 @@ fn blanks_and_section_underline(
                 CheckKind::DashedUnderlineAfterSection(context.section_name.to_string()),
                 Range::from_located(docstring),
             );
-            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+            if checker.patch() {
                 // Add a dashed line (of the appropriate length) under the section header.
                 let content = format!(
                     "{}{}\n",
@@ -945,7 +950,7 @@ fn blanks_and_section_underline(
                 CheckKind::DashedUnderlineAfterSection(context.section_name.to_string()),
                 Range::from_located(docstring),
             );
-            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+            if checker.patch() {
                 // Add a dashed line (of the appropriate length) under the section header.
                 let content = format!(
                     "{}{}\n",
@@ -967,7 +972,7 @@ fn blanks_and_section_underline(
                     ),
                     Range::from_located(docstring),
                 );
-                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                if checker.patch() {
                     // Delete any blank lines between the header and content.
                     check.amend(Fix::deletion(
                         Location::new(docstring.location.row() + context.original_index + 1, 1),
@@ -990,7 +995,7 @@ fn blanks_and_section_underline(
                     CheckKind::SectionUnderlineAfterName(context.section_name.to_string()),
                     Range::from_located(docstring),
                 );
-                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                if checker.patch() {
                     // Delete any blank lines between the header and the underline.
                     check.amend(Fix::deletion(
                         Location::new(docstring.location.row() + context.original_index + 1, 1),
@@ -1021,7 +1026,7 @@ fn blanks_and_section_underline(
                     ),
                     Range::from_located(docstring),
                 );
-                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                if checker.patch() {
                     // Replace the existing underline with a line of the appropriate length.
                     let content = format!(
                         "{}{}\n",
@@ -1059,7 +1064,7 @@ fn blanks_and_section_underline(
                     CheckKind::SectionUnderlineNotOverIndented(context.section_name.to_string()),
                     Range::from_located(docstring),
                 );
-                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                if checker.patch() {
                     // Replace the existing indentation with whitespace of the appropriate length.
                     check.amend(Fix::replacement(
                         helpers::clean(&indentation),
@@ -1108,7 +1113,7 @@ fn blanks_and_section_underline(
                             ),
                             Range::from_located(docstring),
                         );
-                        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                        if checker.patch() {
                             // Delete any blank lines between the header and content.
                             check.amend(Fix::deletion(
                                 Location::new(
@@ -1167,7 +1172,7 @@ fn common_section(
                     CheckKind::CapitalizeSectionName(context.section_name.to_string()),
                     Range::from_located(docstring),
                 );
-                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                if checker.patch() {
                     // Replace the section title with the capitalized variant. This requires
                     // locating the start and end of the section name.
                     if let Some(index) = context.line.find(&context.section_name) {
@@ -1200,7 +1205,7 @@ fn common_section(
                 CheckKind::SectionNotOverIndented(context.section_name.to_string()),
                 Range::from_located(docstring),
             );
-            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+            if checker.patch() {
                 // Replace the existing indentation with whitespace of the appropriate length.
                 check.amend(Fix::replacement(
                     helpers::clean(&indentation),
@@ -1227,7 +1232,7 @@ fn common_section(
                     CheckKind::BlankLineAfterLastSection(context.section_name.to_string()),
                     Range::from_located(docstring),
                 );
-                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                if checker.patch() {
                     // Add a newline after the section.
                     check.amend(Fix::insertion(
                         "\n".to_string(),
@@ -1248,7 +1253,7 @@ fn common_section(
                     CheckKind::BlankLineAfterSection(context.section_name.to_string()),
                     Range::from_located(docstring),
                 );
-                if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                if checker.patch() {
                     // Add a newline after the section.
                     check.amend(Fix::insertion(
                         "\n".to_string(),
@@ -1272,7 +1277,7 @@ fn common_section(
                 CheckKind::BlankLineBeforeSection(context.section_name.to_string()),
                 Range::from_located(docstring),
             );
-            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+            if checker.patch() {
                 // Add a blank line before the section.
                 check.amend(Fix::insertion(
                     "\n".to_string(),
@@ -1432,7 +1437,7 @@ fn numpy_section(checker: &mut Checker, definition: &Definition, context: &Secti
                 CheckKind::NewLineAfterSectionName(context.section_name.to_string()),
                 Range::from_located(docstring),
             );
-            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+            if checker.patch() {
                 // Delete the suffix. This requires locating the end of the section name.
                 if let Some(index) = context.line.find(&context.section_name) {
                     // Map from bytes to characters.
@@ -1481,7 +1486,7 @@ fn google_section(checker: &mut Checker, definition: &Definition, context: &Sect
                 CheckKind::SectionNameEndsInColon(context.section_name.to_string()),
                 Range::from_located(docstring),
             );
-            if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+            if checker.patch() {
                 // Replace the suffix. This requires locating the end of the section name.
                 if let Some(index) = context.line.find(&context.section_name) {
                     // Map from bytes to characters.

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,20 +1,20 @@
-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(
-    locator: &mut SourceCodeLocator,
+    locator: &SourceCodeLocator,
     full_names: &[&str],
     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.
@@ -74,12 +72,12 @@ pub fn remove_unused_imports(
 
 /// Generate a Fix to remove any unused imports from an `import from` statement.
 pub fn remove_unused_import_froms(
-    locator: &mut SourceCodeLocator,
+    locator: &SourceCodeLocator,
     full_names: &[&str],
     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/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 {