Bump version to 0.0.118

.github/workflows/ci.yaml

@@ -77,7 +77,7 @@ jobs:
             ${{ runner.os }}-build-${{ env.cache-name }}-
             ${{ runner.os }}-build-
             ${{ runner.os }}-
-      - run: cargo clippy --all -- -D warnings
+      - run: cargo clippy --workspace --all-targets --all-features -- -D warnings
 
   cargo_test:
     name: "cargo test"

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.115
+    rev: v0.0.118
     hooks:
       - id: ruff
 

Cargo.lock

@@ -930,11 +930,12 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.115-dev.0"
+version = "0.0.118-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.22",
  "configparser",
+ "fnv",
  "once_cell",
  "regex",
  "ruff",
@@ -2237,7 +2238,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.115"
+version = "0.0.118"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2285,7 +2286,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.115"
+version = "0.0.118"
 dependencies = [
  "anyhow",
  "clap 4.0.22",

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.115"
+version = "0.0.118"
 edition = "2021"
 
 [lib]

README.md

@@ -36,8 +36,8 @@ faster than any individual tool.
 automatically convert your existing configuration.)
 
 Ruff is actively developed and used in major open-source projects
-like [Zulip](https://github.com/zulip/zulip), [pydantic](https://github.com/pydantic/pydantic),
-and [Saleor](https://github.com/saleor/saleor).
+like [FastAPI](https://github.com/tiangolo/fastapi), [Zulip](https://github.com/zulip/zulip),
+[pydantic](https://github.com/pydantic/pydantic), and [Saleor](https://github.com/saleor/saleor).
 
 Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).
 
@@ -99,7 +99,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.115
+    rev: v0.0.116
     hooks:
       - id: ruff
 ```
@@ -335,7 +335,7 @@ For more, see [Pyflakes](https://pypi.org/project/pyflakes/2.5.0/) on PyPI.
 | F702 | ContinueOutsideLoop | `continue` not properly in loop |  |
 | F704 | YieldOutsideFunction | `yield` or `yield from` statement outside of a function |  |
 | F706 | ReturnOutsideFunction | `return` statement outside of a function/method |  |
-| F707 | DefaultExceptNotLast | An `except:` block as not the last exception handler |  |
+| F707 | DefaultExceptNotLast | An `except` block as not the last exception handler |  |
 | F722 | ForwardAnnotationSyntaxError | Syntax error in forward annotation: `...` |  |
 | F821 | UndefinedName | Undefined name `...` |  |
 | F822 | UndefinedExport | Undefined name `...` in `__all__` |  |
@@ -409,7 +409,7 @@ For more, see [pydocstyle](https://pypi.org/project/pydocstyle/6.1.1/) on PyPI.
 | D400 | EndsInPeriod | First line should end with a period |  |
 | D402 | NoSignature | First line should not be the function's signature |  |
 | D403 | FirstLineCapitalized | First word of the first line should be properly capitalized |  |
-| D404 | NoThisPrefix | First word of the docstring should not be 'This' |  |
+| D404 | NoThisPrefix | First word of the docstring should not be "This" |  |
 | D405 | CapitalizeSectionName | Section name should be properly capitalized ("returns") | 🛠 |
 | D406 | NewLineAfterSectionName | Section name should end with a newline ("Returns") | 🛠 |
 | D407 | DashedUnderlineAfterSection | Missing dashed underline after section ("Returns") | 🛠 |
@@ -440,7 +440,7 @@ For more, see [pyupgrade](https://pypi.org/project/pyupgrade/3.2.0/) on PyPI.
 | U006 | UsePEP585Annotation | Use `list` instead of `List` for type annotations | 🛠 |
 | U007 | UsePEP604Annotation | Use `X \| Y` for type annotations | 🛠 |
 | U008 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` | 🛠 |
-| U009 | PEP3120UnnecessaryCodingComment | utf-8 encoding declaration is unnecessary | 🛠 |
+| U009 | PEP3120UnnecessaryCodingComment | UTF-8 encoding declaration is unnecessary | 🛠 |
 | U010 | UnnecessaryFutureImport | Unnecessary `__future__` import `...` for target Python version | 🛠 |
 | U011 | UnnecessaryLRUCacheParams | Unnecessary parameters to `functools.lru_cache` | 🛠 |
 | U012 | UnnecessaryEncodeUTF8 | Unnecessary call to `encode` as UTF-8 | 🛠 |
@@ -476,9 +476,9 @@ For more, see [flake8-bandit](https://pypi.org/project/flake8-bandit/4.1.1/) on
 | S101 | AssertUsed | Use of `assert` detected |  |
 | S102 | ExecUsed | Use of `exec` detected |  |
 | S104 | HardcodedBindAllInterfaces | Possible binding to all interfaces |  |
-| S105 | HardcodedPasswordString | Possible hardcoded password: `'...'` |  |
-| S106 | HardcodedPasswordFuncArg | Possible hardcoded password: `'...'` |  |
-| S107 | HardcodedPasswordDefault | Possible hardcoded password: `'...'` |  |
+| S105 | HardcodedPasswordString | Possible hardcoded password: `"..."` |  |
+| S106 | HardcodedPasswordFuncArg | Possible hardcoded password: `"..."` |  |
+| S107 | HardcodedPasswordDefault | Possible hardcoded password: `"..."` |  |
 
 ### flake8-comprehensions
 
@@ -509,25 +509,30 @@ For more, see [flake8-bugbear](https://pypi.org/project/flake8-bugbear/22.10.27/
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| B002 | UnaryPrefixIncrement | Python does not support the unary prefix increment. |  |
-| B003 | AssignmentToOsEnviron | Assigning to `os.environ` doesn't clear the environment. |  |
+| B002 | UnaryPrefixIncrement | Python does not support the unary prefix increment |  |
+| B003 | AssignmentToOsEnviron | Assigning to `os.environ` doesn't clear the environment |  |
 | B004 | UnreliableCallableCheck |  Using `hasattr(x, '__call__')` to test if x is callable is unreliable. Use `callable(x)` for consistent results. |  |
-| B005 | StripWithMultiCharacters | Using `.strip()` with multi-character strings is misleading the reader. |  |
-| B006 | MutableArgumentDefault | Do not use mutable data structures for argument defaults. |  |
-| B007 | UnusedLoopControlVariable | Loop control variable `i` not used within the loop body. | 🛠 |
-| B008 | FunctionCallArgumentDefault | Do not perform function calls in argument defaults. |  |
-| B009 | GetAttrWithConstant | Do not call `getattr` with a constant attribute value, it is not any safer than normal property access. | 🛠 |
-| B010 | SetAttrWithConstant | Do not call `setattr` with a constant attribute value, it is not any safer than normal property access. |  |
+| B005 | StripWithMultiCharacters | Using `.strip()` with multi-character strings is misleading the reader |  |
+| B006 | MutableArgumentDefault | Do not use mutable data structures for argument defaults |  |
+| B007 | UnusedLoopControlVariable | Loop control variable `i` not used within the loop body | 🛠 |
+| B008 | FunctionCallArgumentDefault | Do not perform function call in argument defaults |  |
+| B009 | GetAttrWithConstant | Do not call `getattr` with a constant attribute value. It is not any safer than normal property access. | 🛠 |
+| B010 | SetAttrWithConstant | Do not call `setattr` with a constant attribute value. It is not any safer than normal property access. |  |
 | 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,):`. |  |
+| B012 | JumpStatementInFinally | `return/continue/break` inside finally blocks cause exceptions to be silenced |  |
+| B013 | RedundantTupleInExceptionHandler | A length-one tuple literal is redundant. Write `except ValueError` instead of `except (ValueError,)`. |  |
 | B014 | DuplicateHandlerException | Exception handler with duplicate exception: `ValueError` | 🛠 |
 | B015 | UselessComparison | Pointless comparison. This comparison does nothing but waste CPU instructions. Either prepend `assert` or remove it. |  |
 | B016 | CannotRaiseLiteral | Cannot raise a literal. Did you intend to return it or raise an Exception? |  |
-| B017 | NoAssertRaisesException | `assertRaises(Exception):` should be considered evil. |  |
+| B017 | NoAssertRaisesException | `assertRaises(Exception)` should be considered evil |  |
 | B018 | UselessExpression | Found useless expression. Either assign it to a variable or remove it. |  |
-| B019 | CachedInstanceMethod | Use of `functools.lru_cache` or `functools.cache` on methods can lead to memory leaks. |  |
+| B019 | CachedInstanceMethod | Use of `functools.lru_cache` or `functools.cache` on methods can lead to memory leaks |  |
+| B021 | FStringDocstring | f-string used as docstring. This will be interpreted by python as a joined string rather than a docstring. |  |
+| B022 | UselessContextlibSuppress | No arguments passed to `contextlib.suppress`. No exceptions will be suppressed and therefore this context manager is redundant |  |
+| B024 | AbstractBaseClassWithoutAbstractMethod | `...` is an abstract base class, but it has no abstract methods |  |
 | B025 | DuplicateTryBlockException | try-except block with duplicate exception `Exception` |  |
-| B026 | StarArgUnpackingAfterKeywordArg | Star-arg unpacking after a keyword argument is strongly discouraged. |  |
+| B026 | StarArgUnpackingAfterKeywordArg | Star-arg unpacking after a keyword argument is strongly discouraged |  |
+| B027 | EmptyMethodWithoutAbstractDecorator | `...` is an empty method in an abstract base class, but has no abstract decorator |  |
 
 ### flake8-builtins
 
@@ -700,7 +705,7 @@ including:
 - [`flake8-annotations`](https://pypi.org/project/flake8-annotations/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
 - [`flake8-bandit`](https://pypi.org/project/flake8-bandit/) (6/40)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (21/32)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (25/32)
 - [`flake8-2020`](https://pypi.org/project/flake8-2020/)
 - [`pyupgrade`](https://pypi.org/project/pyupgrade/) (15/34)
 - [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
@@ -725,7 +730,7 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 - [`flake8-annotations`](https://pypi.org/project/flake8-annotations/)
 - [`flake8-bandit`](https://pypi.org/project/flake8-bandit/) (6/40)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (21/32)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (25/32)
 - [`flake8-2020`](https://pypi.org/project/flake8-2020/)
 
 Ruff can also replace [`isort`](https://pypi.org/project/isort/), [`yesqa`](https://github.com/asottile/yesqa),
@@ -751,9 +756,8 @@ project. See [#283](https://github.com/charliermarsh/ruff/issues/283) for more.
 
 ### How does Ruff's import sorting compare to [`isort`](https://pypi.org/project/isort/)?
 
-Ruff's import sorting is intended to be equivalent to `isort` when used `profile = "black"`, and a
-few other settings (`combine_as_imports = true`, `order_by_type = false`, and
-`case_sensitive` = true`).
+Ruff's import sorting is intended to be nearly equivalent to `isort` when used `profile = "black"`.
+(There are some minor differences in how Ruff and isort break ties between similar imports.)
 
 Like `isort`, Ruff's import sorting is compatible with Black.
 

benches/source_code_locator.rs

@@ -1,11 +1,11 @@
+use std::fs;
 use std::path::Path;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use ropey::Rope;
-use ruff::fs;
 
 fn criterion_benchmark(c: &mut Criterion) {
-    let contents = fs::read_file(Path::new("resources/test/fixtures/D.py")).unwrap();
+    let contents = fs::read_to_string(Path::new("resources/test/fixtures/D.py")).unwrap();
     c.bench_function("rope", |b| {
         b.iter(|| {
             let rope = Rope::from_str(black_box(&contents));

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.115"
+version = "0.0.118"
 dependencies = [
  "anyhow",
  "clap",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.115"
+version = "0.0.118"
 dependencies = [
  "anyhow",
  "bincode",

flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.115-dev.0"
+version = "0.0.118-dev.0"
 edition = "2021"
 
 [lib]
@@ -10,6 +10,7 @@ name = "flake8_to_ruff"
 anyhow = { version = "1.0.66" }
 clap = { version = "4.0.1", features = ["derive"] }
 configparser = { version = "3.0.2" }
+fnv = { version = "1.0.7" }
 once_cell = { version = "1.16.0" }
 regex = { version = "1.6.0" }
 ruff = { path = "..", default-features = false }

flake8_to_ruff/src/parser.rs

@@ -1,7 +1,7 @@
-use std::collections::BTreeMap;
 use std::str::FromStr;
 
 use anyhow::Result;
+use fnv::FnvHashMap;
 use once_cell::sync::Lazy;
 use regex::Regex;
 use ruff::checks_gen::CheckCodePrefix;
@@ -179,8 +179,8 @@ pub fn parse_files_to_codes_mapping(value: &str) -> Result<Vec<PatternPrefixPair
 /// Collect a list of `PatternPrefixPair` structs as a `BTreeMap`.
 pub fn collect_per_file_ignores(
     pairs: Vec<PatternPrefixPair>,
-) -> BTreeMap<String, Vec<CheckCodePrefix>> {
-    let mut per_file_ignores: BTreeMap<String, Vec<CheckCodePrefix>> = BTreeMap::new();
+) -> FnvHashMap<String, Vec<CheckCodePrefix>> {
+    let mut per_file_ignores: FnvHashMap<String, Vec<CheckCodePrefix>> = FnvHashMap::default();
     for pair in pairs {
         per_file_ignores
             .entry(pair.pattern)

resources/test/fixtures/B012.py

@@ -0,0 +1,107 @@
+def a():
+    try:
+        pass
+    finally:
+        return  # warning
+
+
+def b():
+    try:
+        pass
+    finally:
+        if 1 + 0 == 2 - 1:
+            return  # warning
+
+
+def c():
+    try:
+        pass
+    finally:
+        try:
+            return  # warning
+        except Exception:
+            pass
+
+
+def d():
+    try:
+        try:
+            pass
+        finally:
+            return  # warning
+    finally:
+        pass
+
+
+def e():
+    if 1 == 2 - 1:
+        try:
+
+            def f():
+                try:
+                    pass
+                finally:
+                    return  # warning
+
+        finally:
+            pass
+
+
+def g():
+    try:
+        pass
+    finally:
+
+        def h():
+            return  # no warning
+
+        e()
+
+
+def i():
+    while True:
+        try:
+            pass
+        finally:
+            break  # warning
+
+            def j():
+                while True:
+                    break  # no warning
+
+
+def h():
+    while True:
+        try:
+            pass
+        finally:
+            continue  # warning
+
+            def j():
+                while True:
+                    continue  # no warning
+
+
+def k():
+    try:
+        pass
+    finally:
+        while True:
+            break  # no warning
+        while True:
+            continue  # no warning
+        while True:
+            return  # warning
+
+
+while True:
+    try:
+        pass
+    finally:
+        continue  # warning
+
+while True:
+    try:
+        pass
+    finally:
+        break  # warning

resources/test/fixtures/B021.py

@@ -0,0 +1,76 @@
+f"""
+Should emit:
+B021 - on lines 14, 22, 30, 38, 46, 54, 62, 70, 73
+"""
+
+VARIABLE = "world"
+
+
+def foo1():
+    """hello world!"""
+
+
+def foo2():
+    f"""hello {VARIABLE}!"""
+
+
+class bar1:
+    """hello world!"""
+
+
+class bar2:
+    f"""hello {VARIABLE}!"""
+
+
+def foo1():
+    """hello world!"""
+
+
+def foo2():
+    f"""hello {VARIABLE}!"""
+
+
+class bar1:
+    """hello world!"""
+
+
+class bar2:
+    f"""hello {VARIABLE}!"""
+
+
+def foo1():
+    "hello world!"
+
+
+def foo2():
+    f"hello {VARIABLE}!"
+
+
+class bar1:
+    "hello world!"
+
+
+class bar2:
+    f"hello {VARIABLE}!"
+
+
+def foo1():
+    "hello world!"
+
+
+def foo2():
+    f"hello {VARIABLE}!"
+
+
+class bar1:
+    "hello world!"
+
+
+class bar2:
+    f"hello {VARIABLE}!"
+
+
+def baz():
+    f"""I'm probably a docstring: {VARIABLE}!"""
+    print(f"""I'm a normal string""")
+    f"""Don't detect me!"""

resources/test/fixtures/B022.py

@@ -0,0 +1,23 @@
+"""
+Should emit:
+B022 - on lines 8
+"""
+
+import contextlib
+from contextlib import suppress
+
+with contextlib.suppress():
+    raise ValueError
+
+with suppress():
+    raise ValueError
+
+with contextlib.suppress(ValueError):
+    raise ValueError
+
+exceptions_to_suppress = []
+if True:
+    exceptions_to_suppress.append(ValueError)
+
+with contextlib.suppress(*exceptions_to_suppress):
+    raise

resources/test/fixtures/B024.py

@@ -0,0 +1,129 @@
+"""
+Should emit:
+B024 - on lines 17, 34, 52, 58, 69, 74, 84, 89
+"""
+
+import abc
+import abc as notabc
+from abc import ABC, ABCMeta
+from abc import abstractmethod
+from abc import abstractmethod as abstract
+from abc import abstractmethod as abstractaoeuaoeuaoeu
+from abc import abstractmethod as notabstract
+
+import foo
+
+
+class Base_1(ABC):  # error
+    def method(self):
+        foo()
+
+
+class Base_2(ABC):
+    @abstractmethod
+    def method(self):
+        foo()
+
+
+class Base_3(ABC):
+    @abc.abstractmethod
+    def method(self):
+        foo()
+
+
+class Base_4(ABC):
+    @notabc.abstractmethod
+    def method(self):
+        foo()
+
+
+class Base_5(ABC):
+    @abstract
+    def method(self):
+        foo()
+
+
+class Base_6(ABC):
+    @abstractaoeuaoeuaoeu
+    def method(self):
+        foo()
+
+
+class Base_7(ABC):  # error
+    @notabstract
+    def method(self):
+        foo()
+
+
+class MetaBase_1(metaclass=ABCMeta):  # error
+    def method(self):
+        foo()
+
+
+class MetaBase_2(metaclass=ABCMeta):
+    @abstractmethod
+    def method(self):
+        foo()
+
+
+class abc_Base_1(abc.ABC):  # error
+    def method(self):
+        foo()
+
+
+class abc_Base_2(metaclass=abc.ABCMeta):  # error
+    def method(self):
+        foo()
+
+
+class notabc_Base_1(notabc.ABC):  # safe
+    def method(self):
+        foo()
+
+
+class multi_super_1(notabc.ABC, abc.ABCMeta):  # safe
+    def method(self):
+        foo()
+
+
+class multi_super_2(notabc.ABC, metaclass=abc.ABCMeta):  # safe
+    def method(self):
+        foo()
+
+
+class non_keyword_abcmeta_1(ABCMeta):  # safe
+    def method(self):
+        foo()
+
+
+class non_keyword_abcmeta_2(abc.ABCMeta):  # safe
+    def method(self):
+        foo()
+
+
+# very invalid code, but that's up to mypy et al to check
+class keyword_abc_1(metaclass=ABC):  # safe
+    def method(self):
+        foo()
+
+
+class keyword_abc_2(metaclass=abc.ABC):  # safe
+    def method(self):
+        foo()
+
+
+class abc_set_class_variable_1(ABC):  # safe
+    foo: int
+
+
+class abc_set_class_variable_2(ABC):  # safe
+    foo = 2
+
+
+class abc_set_class_variable_3(ABC):  # safe
+    foo: int = 2
+
+
+# this doesn't actually declare a class variable, it's just an expression
+class abc_set_class_variable_4(ABC):  # error
+    foo

resources/test/fixtures/B027.py

@@ -0,0 +1,89 @@
+"""
+Should emit:
+B027 - on lines 12, 15, 18, 22, 30
+"""
+
+import abc
+from abc import ABC
+from abc import abstractmethod
+from abc import abstractmethod as notabstract
+
+
+class AbstractClass(ABC):
+    def empty_1(self):  # error
+        ...
+
+    def empty_2(self):  # error
+        pass
+
+    def empty_3(self):  # error
+        """docstring"""
+        ...
+
+    def empty_4(self):  # error
+        """multiple ellipsis/pass"""
+        ...
+        pass
+        ...
+        pass
+
+    @notabstract
+    def empty_5(self):  # error
+        ...
+
+    @abstractmethod
+    def abstract_1(self):
+        ...
+
+    @abstractmethod
+    def abstract_2(self):
+        pass
+
+    @abc.abstractmethod
+    def abstract_3(self):
+        ...
+
+    def body_1(self):
+        print("foo")
+        ...
+
+    def body_2(self):
+        self.body_1()
+
+
+class NonAbstractClass:
+    def empty_1(self):  # safe
+        ...
+
+    def empty_2(self):  # safe
+        pass
+
+
+# ignore @overload, fixes issue #304
+# ignore overload with other imports, fixes #308
+import typing
+import typing as t
+import typing as anything
+from typing import Union, overload
+
+
+class AbstractClass(ABC):
+    @overload
+    def empty_1(self, foo: str):
+        ...
+
+    @typing.overload
+    def empty_1(self, foo: int):
+        ...
+
+    @t.overload
+    def empty_1(self, foo: list):
+        ...
+
+    @anything.overload
+    def empty_1(self, foo: float):
+        ...
+
+    @abstractmethod
+    def empty_1(self, foo: Union[str, int, list, float]):
+        ...

resources/test/fixtures/F401_6.py

@@ -0,0 +1,20 @@
+"""Test: explicit re-export."""
+
+# OK
+from .applications import FastAPI as FastAPI
+
+# F401 `background.BackgroundTasks` imported but unused
+from .background import BackgroundTasks
+
+# F401 `datastructures.UploadFile` imported but unused
+from .datastructures import UploadFile as FileUpload
+
+
+# OK
+import applications as applications
+
+# F401 `background` imported but unused
+import background
+
+# F401 `datastructures` imported but unused
+import datastructures as structures

resources/test/fixtures/N806.py

@@ -1,5 +1,11 @@
+import collections
+from collections import namedtuple
+
+
 def f():
     lower = 0
     Camel = 0
     CONSTANT = 0
     _ = 0
+    MyObj1 = collections.namedtuple("MyObj1", ["a", "b"])
+    MyObj2 = namedtuple("MyObj12", ["a", "b"])

resources/test/fixtures/N815.py

@@ -1,6 +1,12 @@
+import collections
+from collections import namedtuple
+
+
 class C:
     lower = 0
     CONSTANT = 0
     mixedCase = 0
     _mixedCase = 0
     mixed_Case = 0
+    myObj1 = collections.namedtuple("MyObj1", ["a", "b"])
+    myObj2 = namedtuple("MyObj2", ["a", "b"])

resources/test/fixtures/N816.py

@@ -1,5 +1,10 @@
+import collections
+from collections import namedtuple
+
 lower = 0
 CONSTANT = 0
 mixedCase = 0
 _mixedCase = 0
 mixed_Case = 0
+myObj1 = collections.namedtuple("MyObj1", ["a", "b"])
+myObj2 = namedtuple("MyObj2", ["a", "b"])

resources/test/fixtures/isort/sort_similar_imports.py

@@ -0,0 +1,26 @@
+from a import b
+from a import BAD as DEF
+from a import B
+from a import Boo as DEF
+from a import B as Abc
+from a import B as A
+from a import B as DEF
+from a import b as a
+from a import b as x
+from a import b as c
+from b import c
+from a import b as d
+from a import b as y
+from b import C
+from b import c as d
+
+import A
+import a
+import b
+import B
+
+import x as y
+import x as A
+import x as Y
+import x
+import x as a

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.115"
+version = "0.0.118"
 edition = "2021"
 
 [dependencies]

src/ast/helpers.rs

@@ -1,4 +1,4 @@
-use fnv::FnvHashSet;
+use fnv::{FnvHashMap, FnvHashSet};
 use once_cell::sync::Lazy;
 use regex::Regex;
 use rustpython_ast::{Excepthandler, ExcepthandlerKind, Expr, ExprKind, Location, StmtKind};
@@ -19,6 +19,7 @@ fn compose_call_path_inner<'a>(expr: &'a Expr, parts: &mut Vec<&'a str>) {
     }
 }
 
+/// Convert an `Expr` to its call path (like `List`, or `typing.List`).
 pub fn compose_call_path(expr: &Expr) -> Option<String> {
     let mut segments = vec![];
     compose_call_path_inner(expr, &mut segments);
@@ -38,31 +39,6 @@ pub fn match_name_or_attr(expr: &Expr, target: &str) -> bool {
     }
 }
 
-/// Return `true` if the `Expr` is a reference to `${module}.${target}`.
-///
-/// Useful for, e.g., ensuring that a `Union` reference represents
-/// `typing.Union`.
-pub fn match_name_or_attr_from_module(
-    expr: &Expr,
-    target: &str,
-    module: &str,
-    imports: Option<&FnvHashSet<&str>>,
-) -> bool {
-    match &expr.node {
-        ExprKind::Attribute { value, attr, .. } => match &value.node {
-            ExprKind::Name { id, .. } => id == module && target == attr,
-            _ => false,
-        },
-        ExprKind::Name { id, .. } => {
-            target == id
-                && imports
-                    .map(|imports| imports.contains(&id.as_str()))
-                    .unwrap_or_default()
-        }
-        _ => false,
-    }
-}
-
 static DUNDER_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"__[^\s]+__").unwrap());
 
 pub fn is_assignment_to_a_dunder(node: &StmtKind) -> bool {
@@ -140,3 +116,145 @@ pub fn to_absolute(relative: &Location, base: &Location) -> Location {
         Location::new(relative.row() + base.row() - 1, relative.column())
     }
 }
+
+/// Return `true` if the `Expr` is a reference to `${module}.${target}`.
+///
+/// Useful for, e.g., ensuring that a `Union` reference represents
+/// `typing.Union`.
+pub fn match_module_member(
+    expr: &Expr,
+    target: &str,
+    from_imports: &FnvHashMap<&str, FnvHashSet<&str>>,
+) -> bool {
+    compose_call_path(expr)
+        .map(|expr| match_call_path(&expr, target, from_imports))
+        .unwrap_or(false)
+}
+
+/// Return `true` if the `call_path` is a reference to `${module}.${target}`.
+///
+/// Optimized version of `match_module_member` for pre-computed call paths.
+pub fn match_call_path(
+    call_path: &str,
+    target: &str,
+    from_imports: &FnvHashMap<&str, FnvHashSet<&str>>,
+) -> bool {
+    // Case (1a): it's the same call path (`import typing`, `typing.re.Match`).
+    // Case (1b): it's the same call path (`import typing.re`, `typing.re.Match`).
+    if call_path == target {
+        return true;
+    }
+
+    if let Some((parent, member)) = target.rsplit_once('.') {
+        // Case (2): We imported star from the parent (`from typing.re import *`,
+        // `Match`).
+        if call_path == member
+            && from_imports
+                .get(parent)
+                .map(|imports| imports.contains("*"))
+                .unwrap_or(false)
+        {
+            return true;
+        }
+
+        // Case (3): We imported from the parent (`from typing.re import Match`,
+        // `Match`)
+        if call_path == member
+            && from_imports
+                .get(parent)
+                .map(|imports| imports.contains(member))
+                .unwrap_or(false)
+        {
+            return true;
+        }
+    }
+
+    // Case (4): We imported from the grandparent (`from typing import re`,
+    // `re.Match`)
+    let mut parts = target.rsplitn(3, '.');
+    let member = parts.next();
+    let parent = parts.next();
+    let grandparent = parts.next();
+    if let (Some(member), Some(parent), Some(grandparent)) = (member, parent, grandparent) {
+        if call_path == format!("{parent}.{member}")
+            && from_imports
+                .get(grandparent)
+                .map(|imports| imports.contains(parent))
+                .unwrap_or(false)
+        {
+            return true;
+        }
+    }
+
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use anyhow::Result;
+    use fnv::{FnvHashMap, FnvHashSet};
+    use rustpython_parser::parser;
+
+    use crate::ast::helpers::match_module_member;
+
+    #[test]
+    fn fully_qualified() -> Result<()> {
+        let expr = parser::parse_expression("typing.re.Match", "<filename>")?;
+        assert!(match_module_member(
+            &expr,
+            "typing.re.Match",
+            &FnvHashMap::default()
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn unimported() -> Result<()> {
+        let expr = parser::parse_expression("Match", "<filename>")?;
+        assert!(!match_module_member(
+            &expr,
+            "typing.re.Match",
+            &FnvHashMap::default(),
+        ));
+        let expr = parser::parse_expression("re.Match", "<filename>")?;
+        assert!(!match_module_member(
+            &expr,
+            "typing.re.Match",
+            &FnvHashMap::default(),
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn from_star() -> Result<()> {
+        let expr = parser::parse_expression("Match", "<filename>")?;
+        assert!(match_module_member(
+            &expr,
+            "typing.re.Match",
+            &FnvHashMap::from_iter([("typing.re", FnvHashSet::from_iter(["*"]))])
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn from_parent() -> Result<()> {
+        let expr = parser::parse_expression("Match", "<filename>")?;
+        assert!(match_module_member(
+            &expr,
+            "typing.re.Match",
+            &FnvHashMap::from_iter([("typing.re", FnvHashSet::from_iter(["Match"]))])
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn from_grandparent() -> Result<()> {
+        let expr = parser::parse_expression("re.Match", "<filename>")?;
+        assert!(match_module_member(
+            &expr,
+            "typing.re.Match",
+            &FnvHashMap::from_iter([("typing", FnvHashSet::from_iter(["re"]))])
+        ));
+        Ok(())
+    }
+}

src/ast/operations.rs

@@ -67,9 +67,8 @@ pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
 }
 
 /// Check if a node is parent of a conditional branch.
-pub fn on_conditional_branch(parent_stack: &[usize], parents: &[&Stmt]) -> bool {
-    for index in parent_stack.iter().rev() {
-        let parent = parents[*index];
+pub fn on_conditional_branch<'a>(parents: &mut impl Iterator<Item = &'a Stmt>) -> bool {
+    parents.any(|parent| {
         if matches!(parent.node, StmtKind::If { .. } | StmtKind::While { .. }) {
             return true;
         }
@@ -78,24 +77,18 @@ pub fn on_conditional_branch(parent_stack: &[usize], parents: &[&Stmt]) -> bool
                 return true;
             }
         }
-    }
-
-    false
+        false
+    })
 }
 
 /// Check if a node is in a nested block.
-pub fn in_nested_block(parent_stack: &[usize], parents: &[&Stmt]) -> bool {
-    for index in parent_stack.iter().rev() {
-        let parent = parents[*index];
-        if matches!(
+pub fn in_nested_block<'a>(parents: &mut impl Iterator<Item = &'a Stmt>) -> bool {
+    parents.any(|parent| {
+        matches!(
             parent.node,
             StmtKind::Try { .. } | StmtKind::If { .. } | StmtKind::With { .. }
-        ) {
-            return true;
-        }
-    }
-
-    false
+        )
+    })
 }
 
 /// Check if a node represents an unpacking assignment.

src/autofix/fixer.rs

@@ -61,7 +61,7 @@ fn apply_fixes<'a>(
 ) -> Cow<'a, str> {
     let mut output = RopeBuilder::new();
     let mut last_pos: Location = Location::new(1, 0);
-    let mut applied: BTreeSet<&Patch> = BTreeSet::new();
+    let mut applied: BTreeSet<&Patch> = BTreeSet::default();
 
     for fix in fixes.sorted_by_key(|fix| fix.patch.location) {
         // If we already applied an identical fix as part of another correction, skip

src/check_ast.rs

@@ -12,7 +12,7 @@ use rustpython_parser::ast::{
 };
 use rustpython_parser::parser;
 
-use crate::ast::helpers::{extract_handler_names, match_name_or_attr_from_module};
+use crate::ast::helpers::{extract_handler_names, match_module_member};
 use crate::ast::operations::extract_all_names;
 use crate::ast::relocate::relocate_expr;
 use crate::ast::types::{
@@ -155,13 +155,12 @@ impl<'a> Checker<'a> {
 
     /// Return `true` if the `Expr` is a reference to `typing.${target}`.
     pub fn match_typing_module(&self, expr: &Expr, target: &str) -> bool {
-        match_name_or_attr_from_module(expr, target, "typing", self.from_imports.get("typing"))
+        match_module_member(expr, &format!("typing.{target}"), &self.from_imports)
             || (typing::in_extensions(target)
-                && match_name_or_attr_from_module(
+                && match_module_member(
                     expr,
-                    target,
-                    "typing_extensions",
-                    self.from_imports.get("typing_extensions"),
+                    &format!("typing_extensions.{target}"),
+                    &self.from_imports,
                 ))
     }
 }
@@ -192,7 +191,13 @@ where
                 self.futures_allowed = false;
                 if !self.seen_import_boundary
                     && !helpers::is_assignment_to_a_dunder(node)
-                    && !operations::in_nested_block(&self.parent_stack, &self.parents)
+                    && !operations::in_nested_block(
+                        &mut self
+                            .parent_stack
+                            .iter()
+                            .rev()
+                            .map(|index| self.parents[*index]),
+                    )
                 {
                     self.seen_import_boundary = true;
                 }
@@ -447,6 +452,14 @@ where
                     flake8_bugbear::plugins::useless_expression(self, body);
                 }
 
+                if self.settings.enabled.contains(&CheckCode::B024)
+                    || self.settings.enabled.contains(&CheckCode::B027)
+                {
+                    flake8_bugbear::plugins::abstract_base_class(
+                        self, stmt, name, bases, keywords, body,
+                    );
+                }
+
                 self.check_builtin_shadowing(name, Range::from_located(stmt), false);
 
                 for expr in bases {
@@ -511,7 +524,26 @@ where
                                     full_name.to_string(),
                                     self.binding_context(),
                                 ),
-                                used: None,
+                                // Treat explicit re-export as usage (e.g., `import applications
+                                // as applications`).
+                                used: if alias
+                                    .node
+                                    .asname
+                                    .as_ref()
+                                    .map(|asname| asname == &alias.node.name)
+                                    .unwrap_or(false)
+                                {
+                                    Some((
+                                        self.scopes[*(self
+                                            .scope_stack
+                                            .last()
+                                            .expect("No current scope found."))]
+                                        .id,
+                                        Range::from_located(stmt),
+                                    ))
+                                } else {
+                                    None
+                                },
                                 range: Range::from_located(stmt),
                             },
                         )
@@ -610,6 +642,7 @@ where
                             name.to_string(),
                             Binding {
                                 kind: BindingKind::FutureImportation,
+                                // Always mark `__future__` imports as used.
                                 used: Some((
                                     self.scopes[*(self
                                         .scope_stack
@@ -702,7 +735,26 @@ where
                                     full_name,
                                     self.binding_context(),
                                 ),
-                                used: None,
+                                // Treat explicit re-export as usage (e.g., `from .applications
+                                // import FastAPI as FastAPI`).
+                                used: if alias
+                                    .node
+                                    .asname
+                                    .as_ref()
+                                    .map(|asname| asname == &alias.node.name)
+                                    .unwrap_or(false)
+                                {
+                                    Some((
+                                        self.scopes[*(self
+                                            .scope_stack
+                                            .last()
+                                            .expect("No current scope found."))]
+                                        .id,
+                                        Range::from_located(stmt),
+                                    ))
+                                } else {
+                                    None
+                                },
                                 range: Range::from_located(stmt),
                             },
                         )
@@ -870,6 +922,9 @@ where
         let prev_visible_scope = self.visible_scope.clone();
         match &stmt.node {
             StmtKind::FunctionDef { body, .. } | StmtKind::AsyncFunctionDef { body, .. } => {
+                if self.settings.enabled.contains(&CheckCode::B021) {
+                    flake8_bugbear::plugins::f_string_docstring(self, body);
+                }
                 let definition = docstrings::extraction::extract(
                     &self.visible_scope,
                     stmt,
@@ -889,6 +944,9 @@ where
                 ));
             }
             StmtKind::ClassDef { body, .. } => {
+                if self.settings.enabled.contains(&CheckCode::B021) {
+                    flake8_bugbear::plugins::f_string_docstring(self, body);
+                }
                 let definition = docstrings::extraction::extract(
                     &self.visible_scope,
                     stmt,
@@ -911,6 +969,9 @@ where
                 finalbody,
             } => {
                 self.except_handlers.push(extract_handler_names(handlers));
+                if self.settings.enabled.contains(&CheckCode::B012) {
+                    flake8_bugbear::plugins::jump_statement_in_finally(self, finalbody);
+                }
                 for stmt in body {
                     self.visit_stmt(stmt);
                 }
@@ -1019,7 +1080,7 @@ where
                         // Ex) List[...]
                         if self.settings.enabled.contains(&CheckCode::U006)
                             && self.settings.target_version >= PythonVersion::Py39
-                            && typing::is_pep585_builtin(expr, self.from_imports.get("typing"))
+                            && typing::is_pep585_builtin(expr, &self.from_imports)
                         {
                             pyupgrade::plugins::use_pep585_annotation(self, expr, id);
                         }
@@ -1051,7 +1112,7 @@ where
                 // Ex) typing.List[...]
                 if self.settings.enabled.contains(&CheckCode::U006)
                     && self.settings.target_version >= PythonVersion::Py39
-                    && typing::is_pep585_builtin(expr, self.from_imports.get("typing"))
+                    && typing::is_pep585_builtin(expr, &self.from_imports)
                 {
                     pyupgrade::plugins::use_pep585_annotation(self, expr, attr);
                 }
@@ -1104,6 +1165,9 @@ where
                         flake8_bugbear::plugins::setattr_with_constant(self, expr, func, args);
                     }
                 }
+                if self.settings.enabled.contains(&CheckCode::B022) {
+                    flake8_bugbear::plugins::useless_contextlib_suppress(self, expr, args);
+                }
                 if self.settings.enabled.contains(&CheckCode::B026) {
                     flake8_bugbear::plugins::star_arg_unpacking_after_keyword_arg(
                         self, args, keywords,
@@ -2110,32 +2174,22 @@ impl<'a> Checker<'a> {
             }
 
             if self.settings.enabled.contains(&CheckCode::N806) {
-                let current =
-                    &self.scopes[*(self.scope_stack.last().expect("No current scope found."))];
-                if let Some(check) =
-                    pep8_naming::checks::non_lowercase_variable_in_function(current, expr, id)
-                {
-                    self.add_check(check);
+                if matches!(self.current_scope().kind, ScopeKind::Function(..)) {
+                    pep8_naming::plugins::non_lowercase_variable_in_function(self, expr, parent, id)
                 }
             }
 
             if self.settings.enabled.contains(&CheckCode::N815) {
-                let current =
-                    &self.scopes[*(self.scope_stack.last().expect("No current scope found."))];
-                if let Some(check) =
-                    pep8_naming::checks::mixed_case_variable_in_class_scope(current, expr, id)
-                {
-                    self.add_check(check);
+                if matches!(self.current_scope().kind, ScopeKind::Class(..)) {
+                    pep8_naming::plugins::mixed_case_variable_in_class_scope(self, expr, parent, id)
                 }
             }
 
             if self.settings.enabled.contains(&CheckCode::N816) {
-                let current =
-                    &self.scopes[*(self.scope_stack.last().expect("No current scope found."))];
-                if let Some(check) =
-                    pep8_naming::checks::mixed_case_variable_in_global_scope(current, expr, id)
-                {
-                    self.add_check(check);
+                if matches!(self.current_scope().kind, ScopeKind::Module) {
+                    pep8_naming::plugins::mixed_case_variable_in_global_scope(
+                        self, expr, parent, id,
+                    )
                 }
             }
 
@@ -2214,7 +2268,13 @@ impl<'a> Checker<'a> {
 
     fn handle_node_delete(&mut self, expr: &Expr) {
         if let ExprKind::Name { id, .. } = &expr.node {
-            if operations::on_conditional_branch(&self.parent_stack, &self.parents) {
+            if operations::on_conditional_branch(
+                &mut self
+                    .parent_stack
+                    .iter()
+                    .rev()
+                    .map(|index| self.parents[*index]),
+            ) {
                 return;
             }
 
@@ -2234,6 +2294,9 @@ impl<'a> Checker<'a> {
     where
         'b: 'a,
     {
+        if self.settings.enabled.contains(&CheckCode::B021) {
+            flake8_bugbear::plugins::f_string_docstring(self, python_ast);
+        }
         let docstring = docstrings::extraction::docstring_from(python_ast);
         self.definitions.push((
             Definition {

src/check_lines.rs

@@ -283,7 +283,7 @@ mod tests {
                 },
                 &fixer::Mode::Generate,
             );
-            return checks;
+            checks
         };
         assert!(!check_with_max_line_length(6).is_empty());
         assert!(check_with_max_line_length(7).is_empty());

src/checks.rs

@@ -87,6 +87,7 @@ pub enum CheckCode {
     B009,
     B010,
     B011,
+    B012,
     B013,
     B014,
     B015,
@@ -94,8 +95,12 @@ pub enum CheckCode {
     B017,
     B018,
     B019,
+    B021,
+    B022,
+    B024,
     B025,
     B026,
+    B027,
     // flake8-comprehensions
     C400,
     C401,
@@ -382,10 +387,11 @@ pub enum CheckKind {
     StripWithMultiCharacters,
     MutableArgumentDefault,
     UnusedLoopControlVariable(String),
-    FunctionCallArgumentDefault,
+    FunctionCallArgumentDefault(Option<String>),
     GetAttrWithConstant,
     SetAttrWithConstant,
     DoNotAssertFalse,
+    JumpStatementInFinally(String),
     RedundantTupleInExceptionHandler(String),
     DuplicateHandlerException(Vec<String>),
     UselessComparison,
@@ -393,8 +399,12 @@ pub enum CheckKind {
     NoAssertRaisesException,
     UselessExpression,
     CachedInstanceMethod,
+    FStringDocstring,
+    UselessContextlibSuppress,
+    AbstractBaseClassWithoutAbstractMethod(String),
     DuplicateTryBlockException(String),
     StarArgUnpackingAfterKeywordArg,
+    EmptyMethodWithoutAbstractDecorator(String),
     // flake8-comprehensions
     UnnecessaryGeneratorList,
     UnnecessaryGeneratorSet,
@@ -619,10 +629,13 @@ impl CheckCode {
             CheckCode::B005 => CheckKind::StripWithMultiCharacters,
             CheckCode::B006 => CheckKind::MutableArgumentDefault,
             CheckCode::B007 => CheckKind::UnusedLoopControlVariable("i".to_string()),
-            CheckCode::B008 => CheckKind::FunctionCallArgumentDefault,
+            CheckCode::B008 => CheckKind::FunctionCallArgumentDefault(None),
             CheckCode::B009 => CheckKind::GetAttrWithConstant,
             CheckCode::B010 => CheckKind::SetAttrWithConstant,
             CheckCode::B011 => CheckKind::DoNotAssertFalse,
+            CheckCode::B012 => {
+                CheckKind::JumpStatementInFinally("return/continue/break".to_string())
+            }
             CheckCode::B013 => {
                 CheckKind::RedundantTupleInExceptionHandler("ValueError".to_string())
             }
@@ -632,8 +645,12 @@ impl CheckCode {
             CheckCode::B017 => CheckKind::NoAssertRaisesException,
             CheckCode::B018 => CheckKind::UselessExpression,
             CheckCode::B019 => CheckKind::CachedInstanceMethod,
+            CheckCode::B021 => CheckKind::FStringDocstring,
+            CheckCode::B022 => CheckKind::UselessContextlibSuppress,
+            CheckCode::B024 => CheckKind::AbstractBaseClassWithoutAbstractMethod("...".to_string()),
             CheckCode::B025 => CheckKind::DuplicateTryBlockException("Exception".to_string()),
             CheckCode::B026 => CheckKind::StarArgUnpackingAfterKeywordArg,
+            CheckCode::B027 => CheckKind::EmptyMethodWithoutAbstractDecorator("...".to_string()),
             // flake8-comprehensions
             CheckCode::C400 => CheckKind::UnnecessaryGeneratorList,
             CheckCode::C401 => CheckKind::UnnecessaryGeneratorSet,
@@ -865,6 +882,7 @@ impl CheckCode {
             CheckCode::B009 => CheckCategory::Flake8Bugbear,
             CheckCode::B010 => CheckCategory::Flake8Bugbear,
             CheckCode::B011 => CheckCategory::Flake8Bugbear,
+            CheckCode::B012 => CheckCategory::Flake8Bugbear,
             CheckCode::B013 => CheckCategory::Flake8Bugbear,
             CheckCode::B014 => CheckCategory::Flake8Bugbear,
             CheckCode::B015 => CheckCategory::Flake8Bugbear,
@@ -872,8 +890,12 @@ impl CheckCode {
             CheckCode::B017 => CheckCategory::Flake8Bugbear,
             CheckCode::B018 => CheckCategory::Flake8Bugbear,
             CheckCode::B019 => CheckCategory::Flake8Bugbear,
+            CheckCode::B021 => CheckCategory::Flake8Bugbear,
+            CheckCode::B022 => CheckCategory::Flake8Bugbear,
+            CheckCode::B024 => CheckCategory::Flake8Bugbear,
             CheckCode::B025 => CheckCategory::Flake8Bugbear,
             CheckCode::B026 => CheckCategory::Flake8Bugbear,
+            CheckCode::B027 => CheckCategory::Flake8Bugbear,
             CheckCode::C400 => CheckCategory::Flake8Comprehensions,
             CheckCode::C401 => CheckCategory::Flake8Comprehensions,
             CheckCode::C402 => CheckCategory::Flake8Comprehensions,
@@ -1064,10 +1086,11 @@ impl CheckKind {
             CheckKind::StripWithMultiCharacters => &CheckCode::B005,
             CheckKind::MutableArgumentDefault => &CheckCode::B006,
             CheckKind::UnusedLoopControlVariable(_) => &CheckCode::B007,
-            CheckKind::FunctionCallArgumentDefault => &CheckCode::B008,
+            CheckKind::FunctionCallArgumentDefault(_) => &CheckCode::B008,
             CheckKind::GetAttrWithConstant => &CheckCode::B009,
             CheckKind::SetAttrWithConstant => &CheckCode::B010,
             CheckKind::DoNotAssertFalse => &CheckCode::B011,
+            CheckKind::JumpStatementInFinally(_) => &CheckCode::B012,
             CheckKind::RedundantTupleInExceptionHandler(_) => &CheckCode::B013,
             CheckKind::DuplicateHandlerException(_) => &CheckCode::B014,
             CheckKind::UselessComparison => &CheckCode::B015,
@@ -1075,8 +1098,12 @@ impl CheckKind {
             CheckKind::NoAssertRaisesException => &CheckCode::B017,
             CheckKind::UselessExpression => &CheckCode::B018,
             CheckKind::CachedInstanceMethod => &CheckCode::B019,
+            CheckKind::FStringDocstring => &CheckCode::B021,
+            CheckKind::UselessContextlibSuppress => &CheckCode::B022,
+            CheckKind::AbstractBaseClassWithoutAbstractMethod(_) => &CheckCode::B024,
             CheckKind::DuplicateTryBlockException(_) => &CheckCode::B025,
             CheckKind::StarArgUnpackingAfterKeywordArg => &CheckCode::B026,
+            CheckKind::EmptyMethodWithoutAbstractDecorator(_) => &CheckCode::B027,
             // flake8-comprehensions
             CheckKind::UnnecessaryGeneratorList => &CheckCode::C400,
             CheckKind::UnnecessaryGeneratorSet => &CheckCode::C401,
@@ -1236,7 +1263,7 @@ impl CheckKind {
             CheckKind::BreakOutsideLoop => "`break` outside loop".to_string(),
             CheckKind::ContinueOutsideLoop => "`continue` not properly in loop".to_string(),
             CheckKind::DefaultExceptNotLast => {
-                "An `except:` block as not the last exception handler".to_string()
+                "An `except` block as not the last exception handler".to_string()
             }
             CheckKind::DoNotAssignLambda => {
                 "Do not assign a lambda expression, use a def".to_string()
@@ -1373,40 +1400,47 @@ impl CheckKind {
                                                 `+(+(n))`, which equals `n`. You meant `n += 1`."
                 .to_string(),
             CheckKind::AssignmentToOsEnviron => {
-                "Assigning to `os.environ` doesn't clear the environment.".to_string()
+                "Assigning to `os.environ` doesn't clear the environment".to_string()
             }
             CheckKind::UnreliableCallableCheck => " Using `hasattr(x, '__call__')` to test if x \
                                                    is callable is unreliable. Use `callable(x)` \
                                                    for consistent results."
                 .to_string(),
-            CheckKind::StripWithMultiCharacters => "Using `.strip()` with multi-character strings \
-                                                    is misleading the reader."
-                .to_string(),
+            CheckKind::StripWithMultiCharacters => {
+                "Using `.strip()` with multi-character strings is misleading the reader".to_string()
+            }
             CheckKind::MutableArgumentDefault => {
-                "Do not use mutable data structures for argument defaults.".to_string()
+                "Do not use mutable data structures for argument defaults".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::FunctionCallArgumentDefault => {
-                "Do not perform function calls in argument defaults.".to_string()
+            CheckKind::FunctionCallArgumentDefault(name) => {
+                if let Some(name) = name {
+                    format!("Do not perform function call `{name}` in argument defaults")
+                } else {
+                    "Do not perform function call in argument defaults".to_string()
+                }
             }
             CheckKind::GetAttrWithConstant => "Do not call `getattr` with a constant attribute \
-                                               value, it is not any safer than normal property \
+                                               value. It is not any safer than normal property \
                                                access."
                 .to_string(),
             CheckKind::SetAttrWithConstant => "Do not call `setattr` with a constant attribute \
-                                               value, it is not any safer than normal property \
+                                               value. It is not any safer than normal property \
                                                access."
                 .to_string(),
             CheckKind::DoNotAssertFalse => "Do not `assert False` (`python -O` removes these \
                                             calls), raise `AssertionError()`"
                 .to_string(),
+            CheckKind::JumpStatementInFinally(name) => {
+                format!("`{name}` inside finally blocks cause exceptions to be silenced")
+            }
             CheckKind::RedundantTupleInExceptionHandler(name) => {
                 format!(
-                    "A length-one tuple literal is redundant. Write `except {name}:` instead of \
-                     `except ({name},):`."
+                    "A length-one tuple literal is redundant. Write `except {name}` instead of \
+                     `except ({name},)`."
                 )
             }
             CheckKind::UselessComparison => "Pointless comparison. This comparison does nothing \
@@ -1426,7 +1460,7 @@ impl CheckKind {
                 }
             }
             CheckKind::NoAssertRaisesException => {
-                "`assertRaises(Exception):` should be considered evil. It can lead to your test \
+                "`assertRaises(Exception)` should be considered evil. It can lead to your test \
                  passing even if the code being tested is never executed due to a typo. Either \
                  assert for a more specific exception (builtin or custom), use \
                  `assertRaisesRegex`, or use the context manager form of `assertRaises`."
@@ -1436,18 +1470,34 @@ impl CheckKind {
                 "Found useless expression. Either assign it to a variable or remove it.".to_string()
             }
             CheckKind::CachedInstanceMethod => "Use of `functools.lru_cache` or `functools.cache` \
-                                                on methods can lead to memory leaks."
+                                                on methods can lead to memory leaks"
                 .to_string(),
+            CheckKind::FStringDocstring => "f-string used as docstring. This will be interpreted \
+                                            by python as a joined string rather than a docstring."
+                .to_string(),
+            CheckKind::UselessContextlibSuppress => {
+                "No arguments passed to `contextlib.suppress`. No exceptions will be suppressed \
+                 and therefore this context manager is redundant"
+                    .to_string()
+            }
+            CheckKind::AbstractBaseClassWithoutAbstractMethod(name) => {
+                format!("`{name}` is an abstract base class, but it has no abstract methods")
+            }
             CheckKind::DuplicateTryBlockException(name) => {
                 format!("try-except block with duplicate exception `{name}`")
             }
             CheckKind::StarArgUnpackingAfterKeywordArg => {
-                "Star-arg unpacking after a keyword argument is strongly discouraged, because it \
-                 only works when the keyword parameter is declared after all parameters supplied \
-                 by the unpacked sequence, and this change of ordering can surprise and mislead \
-                 readers."
+                "Star-arg unpacking after a keyword argument is strongly discouraged. It only \
+                 works when the keyword parameter is declared after all parameters supplied by the \
+                 unpacked sequence, and this change of ordering can surprise and mislead readers."
                     .to_string()
             }
+            CheckKind::EmptyMethodWithoutAbstractDecorator(name) => {
+                format!(
+                    "`{name}` is an empty method in an abstract base class, but has no abstract \
+                     decorator"
+                )
+            }
             // flake8-comprehensions
             CheckKind::UnnecessaryGeneratorList => {
                 "Unnecessary generator (rewrite as a `list` comprehension)".to_string()
@@ -1703,7 +1753,7 @@ impl CheckKind {
             CheckKind::PublicNestedClass => "Missing docstring in public nested class".to_string(),
             CheckKind::PublicInit => "Missing docstring in `__init__`".to_string(),
             CheckKind::NoThisPrefix => {
-                "First word of the docstring should not be 'This'".to_string()
+                "First word of the docstring should not be \"This\"".to_string()
             }
             CheckKind::SkipDocstring => {
                 "Function decorated with `@overload` shouldn't contain a docstring".to_string()
@@ -1811,7 +1861,7 @@ impl CheckKind {
                 format!("Exception name `{name}` should be named with an Error suffix")
             }
             CheckKind::PEP3120UnnecessaryCodingComment => {
-                "utf-8 encoding declaration is unnecessary".to_string()
+                "UTF-8 encoding declaration is unnecessary".to_string()
             }
             // isort
             CheckKind::UnsortedImports => "Import block is un-sorted or un-formatted".to_string(),
@@ -1822,13 +1872,13 @@ impl CheckKind {
                 "Possible binding to all interfaces".to_string()
             }
             CheckKind::HardcodedPasswordString(string) => {
-                format!("Possible hardcoded password: `'{string}'`")
+                format!("Possible hardcoded password: `\"{string}\"`")
             }
             CheckKind::HardcodedPasswordFuncArg(string) => {
-                format!("Possible hardcoded password: `'{string}'`")
+                format!("Possible hardcoded password: `\"{string}\"`")
             }
             CheckKind::HardcodedPasswordDefault(string) => {
-                format!("Possible hardcoded password: `'{string}'`")
+                format!("Possible hardcoded password: `\"{string}\"`")
             }
             // Ruff
             CheckKind::AmbiguousUnicodeCharacterString(confusable, representant) => {
@@ -1874,16 +1924,16 @@ impl CheckKind {
     pub fn summary(&self) -> String {
         match self {
             CheckKind::UnaryPrefixIncrement => {
-                "Python does not support the unary prefix increment.".to_string()
+                "Python does not support the unary prefix increment".to_string()
             }
             CheckKind::UnusedLoopControlVariable(name) => {
-                format!("Loop control variable `{name}` not used within the loop body.")
+                format!("Loop control variable `{name}` not used within the loop body")
             }
             CheckKind::NoAssertRaisesException => {
-                "`assertRaises(Exception):` should be considered evil.".to_string()
+                "`assertRaises(Exception)` should be considered evil".to_string()
             }
             CheckKind::StarArgUnpackingAfterKeywordArg => {
-                "Star-arg unpacking after a keyword argument is strongly discouraged.".to_string()
+                "Star-arg unpacking after a keyword argument is strongly discouraged".to_string()
             }
             _ => self.body(),
         }

src/checks_gen.rs

@@ -47,6 +47,7 @@ pub enum CheckCodePrefix {
     B01,
     B010,
     B011,
+    B012,
     B013,
     B014,
     B015,
@@ -55,8 +56,12 @@ pub enum CheckCodePrefix {
     B018,
     B019,
     B02,
+    B021,
+    B022,
+    B024,
     B025,
     B026,
+    B027,
     C,
     C4,
     C40,
@@ -373,6 +378,7 @@ impl CheckCodePrefix {
                 CheckCode::B009,
                 CheckCode::B010,
                 CheckCode::B011,
+                CheckCode::B012,
                 CheckCode::B013,
                 CheckCode::B014,
                 CheckCode::B015,
@@ -380,8 +386,12 @@ impl CheckCodePrefix {
                 CheckCode::B017,
                 CheckCode::B018,
                 CheckCode::B019,
+                CheckCode::B021,
+                CheckCode::B022,
+                CheckCode::B024,
                 CheckCode::B025,
                 CheckCode::B026,
+                CheckCode::B027,
             ],
             CheckCodePrefix::B0 => vec![
                 CheckCode::B002,
@@ -394,6 +404,7 @@ impl CheckCodePrefix {
                 CheckCode::B009,
                 CheckCode::B010,
                 CheckCode::B011,
+                CheckCode::B012,
                 CheckCode::B013,
                 CheckCode::B014,
                 CheckCode::B015,
@@ -401,8 +412,12 @@ impl CheckCodePrefix {
                 CheckCode::B017,
                 CheckCode::B018,
                 CheckCode::B019,
+                CheckCode::B021,
+                CheckCode::B022,
+                CheckCode::B024,
                 CheckCode::B025,
                 CheckCode::B026,
+                CheckCode::B027,
             ],
             CheckCodePrefix::B00 => vec![
                 CheckCode::B002,
@@ -425,6 +440,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::B01 => vec![
                 CheckCode::B010,
                 CheckCode::B011,
+                CheckCode::B012,
                 CheckCode::B013,
                 CheckCode::B014,
                 CheckCode::B015,
@@ -435,6 +451,7 @@ impl CheckCodePrefix {
             ],
             CheckCodePrefix::B010 => vec![CheckCode::B010],
             CheckCodePrefix::B011 => vec![CheckCode::B011],
+            CheckCodePrefix::B012 => vec![CheckCode::B012],
             CheckCodePrefix::B013 => vec![CheckCode::B013],
             CheckCodePrefix::B014 => vec![CheckCode::B014],
             CheckCodePrefix::B015 => vec![CheckCode::B015],
@@ -442,9 +459,20 @@ impl CheckCodePrefix {
             CheckCodePrefix::B017 => vec![CheckCode::B017],
             CheckCodePrefix::B018 => vec![CheckCode::B018],
             CheckCodePrefix::B019 => vec![CheckCode::B019],
-            CheckCodePrefix::B02 => vec![CheckCode::B025, CheckCode::B026],
+            CheckCodePrefix::B02 => vec![
+                CheckCode::B021,
+                CheckCode::B022,
+                CheckCode::B024,
+                CheckCode::B025,
+                CheckCode::B026,
+                CheckCode::B027,
+            ],
+            CheckCodePrefix::B021 => vec![CheckCode::B021],
+            CheckCodePrefix::B022 => vec![CheckCode::B022],
+            CheckCodePrefix::B024 => vec![CheckCode::B024],
             CheckCodePrefix::B025 => vec![CheckCode::B025],
             CheckCodePrefix::B026 => vec![CheckCode::B026],
+            CheckCodePrefix::B027 => vec![CheckCode::B027],
             CheckCodePrefix::C => vec![
                 CheckCode::C400,
                 CheckCode::C401,
@@ -1176,6 +1204,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::B01 => PrefixSpecificity::Tens,
             CheckCodePrefix::B010 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B011 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B012 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B013 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B014 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B015 => PrefixSpecificity::Explicit,
@@ -1184,8 +1213,12 @@ impl CheckCodePrefix {
             CheckCodePrefix::B018 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B019 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B02 => PrefixSpecificity::Tens,
+            CheckCodePrefix::B021 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B022 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B024 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B025 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B026 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B027 => PrefixSpecificity::Explicit,
             CheckCodePrefix::C => PrefixSpecificity::Category,
             CheckCodePrefix::C4 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::C40 => PrefixSpecificity::Tens,
@@ -1338,15 +1371,6 @@ impl CheckCodePrefix {
             CheckCodePrefix::I0 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::I00 => PrefixSpecificity::Tens,
             CheckCodePrefix::I001 => PrefixSpecificity::Explicit,
-            CheckCodePrefix::S => PrefixSpecificity::Category,
-            CheckCodePrefix::S1 => PrefixSpecificity::Hundreds,
-            CheckCodePrefix::S10 => PrefixSpecificity::Tens,
-            CheckCodePrefix::S101 => PrefixSpecificity::Explicit,
-            CheckCodePrefix::S102 => PrefixSpecificity::Explicit,
-            CheckCodePrefix::S104 => PrefixSpecificity::Explicit,
-            CheckCodePrefix::S105 => PrefixSpecificity::Explicit,
-            CheckCodePrefix::S106 => PrefixSpecificity::Explicit,
-            CheckCodePrefix::S107 => PrefixSpecificity::Explicit,
             CheckCodePrefix::M => PrefixSpecificity::Category,
             CheckCodePrefix::M0 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::M00 => PrefixSpecificity::Tens,
@@ -1383,6 +1407,15 @@ impl CheckCodePrefix {
             CheckCodePrefix::RUF001 => PrefixSpecificity::Explicit,
             CheckCodePrefix::RUF002 => PrefixSpecificity::Explicit,
             CheckCodePrefix::RUF003 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::S => PrefixSpecificity::Category,
+            CheckCodePrefix::S1 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::S10 => PrefixSpecificity::Tens,
+            CheckCodePrefix::S101 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::S102 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::S104 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::S105 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::S106 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::S107 => PrefixSpecificity::Explicit,
             CheckCodePrefix::T => PrefixSpecificity::Category,
             CheckCodePrefix::T2 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::T20 => PrefixSpecificity::Tens,

src/cli.rs

@@ -1,8 +1,8 @@
-use std::collections::BTreeMap;
 use std::fmt;
 use std::path::PathBuf;
 
 use clap::{command, Parser};
+use fnv::FnvHashMap;
 use log::warn;
 use regex::Regex;
 
@@ -188,7 +188,7 @@ pub fn collect_per_file_ignores(
     pairs: Vec<PatternPrefixPair>,
     project_root: &Option<PathBuf>,
 ) -> Vec<PerFileIgnore> {
-    let mut per_file_ignores: BTreeMap<String, Vec<CheckCodePrefix>> = BTreeMap::new();
+    let mut per_file_ignores: FnvHashMap<String, Vec<CheckCodePrefix>> = FnvHashMap::default();
     for pair in pairs {
         per_file_ignores
             .entry(pair.pattern)

src/docstrings/google.rs

@@ -1,11 +1,10 @@
 //! Abstractions for Google-style docstrings.
 
-use std::collections::BTreeSet;
-
+use fnv::FnvHashSet;
 use once_cell::sync::Lazy;
 
-pub(crate) static GOOGLE_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
-    BTreeSet::from([
+pub(crate) static GOOGLE_SECTION_NAMES: Lazy<FnvHashSet<&'static str>> = Lazy::new(|| {
+    FnvHashSet::from_iter([
         "Args",
         "Arguments",
         "Attention",
@@ -37,35 +36,36 @@ pub(crate) static GOOGLE_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new
     ])
 });
 
-pub(crate) static LOWERCASE_GOOGLE_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
-    BTreeSet::from([
-        "args",
-        "arguments",
-        "attention",
-        "attributes",
-        "caution",
-        "danger",
-        "error",
-        "example",
-        "examples",
-        "hint",
-        "important",
-        "keyword args",
-        "keyword arguments",
-        "methods",
-        "note",
-        "notes",
-        "return",
-        "returns",
-        "raises",
-        "references",
-        "see also",
-        "tip",
-        "todo",
-        "warning",
-        "warnings",
-        "warns",
-        "yield",
-        "yields",
-    ])
-});
+pub(crate) static LOWERCASE_GOOGLE_SECTION_NAMES: Lazy<FnvHashSet<&'static str>> =
+    Lazy::new(|| {
+        FnvHashSet::from_iter([
+            "args",
+            "arguments",
+            "attention",
+            "attributes",
+            "caution",
+            "danger",
+            "error",
+            "example",
+            "examples",
+            "hint",
+            "important",
+            "keyword args",
+            "keyword arguments",
+            "methods",
+            "note",
+            "notes",
+            "return",
+            "returns",
+            "raises",
+            "references",
+            "see also",
+            "tip",
+            "todo",
+            "warning",
+            "warnings",
+            "warns",
+            "yield",
+            "yields",
+        ])
+    });

src/docstrings/numpy.rs

@@ -1,11 +1,10 @@
 //! Abstractions for NumPy-style docstrings.
 
-use std::collections::BTreeSet;
-
+use fnv::FnvHashSet;
 use once_cell::sync::Lazy;
 
-pub(crate) static LOWERCASE_NUMPY_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
-    BTreeSet::from([
+pub(crate) static LOWERCASE_NUMPY_SECTION_NAMES: Lazy<FnvHashSet<&'static str>> = Lazy::new(|| {
+    FnvHashSet::from_iter([
         "short summary",
         "extended summary",
         "parameters",
@@ -22,8 +21,8 @@ pub(crate) static LOWERCASE_NUMPY_SECTION_NAMES: Lazy<BTreeSet<&'static str>> =
     ])
 });
 
-pub(crate) static NUMPY_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
-    BTreeSet::from([
+pub(crate) static NUMPY_SECTION_NAMES: Lazy<FnvHashSet<&'static str>> = Lazy::new(|| {
+    FnvHashSet::from_iter([
         "Short Summary",
         "Extended Summary",
         "Parameters",

src/docstrings/styles.rs

@@ -1,5 +1,4 @@
-use std::collections::BTreeSet;
-
+use fnv::FnvHashSet;
 use once_cell::sync::Lazy;
 
 use crate::docstrings::google::{GOOGLE_SECTION_NAMES, LOWERCASE_GOOGLE_SECTION_NAMES};
@@ -11,14 +10,14 @@ pub(crate) enum SectionStyle {
 }
 
 impl SectionStyle {
-    pub(crate) fn section_names(&self) -> &Lazy<BTreeSet<&'static str>> {
+    pub(crate) fn section_names(&self) -> &Lazy<FnvHashSet<&'static str>> {
         match self {
             SectionStyle::NumPy => &NUMPY_SECTION_NAMES,
             SectionStyle::Google => &GOOGLE_SECTION_NAMES,
         }
     }
 
-    pub(crate) fn lowercase_section_names(&self) -> &Lazy<BTreeSet<&'static str>> {
+    pub(crate) fn lowercase_section_names(&self) -> &Lazy<FnvHashSet<&'static str>> {
         match self {
             SectionStyle::NumPy => &LOWERCASE_NUMPY_SECTION_NAMES,
             SectionStyle::Google => &LOWERCASE_GOOGLE_SECTION_NAMES,

src/flake8_2020/plugins.rs

@@ -1,13 +1,13 @@
 use num_bigint::BigInt;
 use rustpython_ast::{Cmpop, Constant, Expr, ExprKind, Located};
 
-use crate::ast::helpers::match_name_or_attr_from_module;
+use crate::ast::helpers::match_module_member;
 use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckCode, CheckKind};
 
 fn is_sys(checker: &Checker, expr: &Expr, target: &str) -> bool {
-    match_name_or_attr_from_module(expr, target, "sys", checker.from_imports.get("sys"))
+    match_module_member(expr, &format!("sys.{target}"), &checker.from_imports)
 }
 
 /// YTT101, YTT102, YTT301, YTT303
@@ -181,9 +181,7 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
 
 /// YTT202
 pub fn name_or_attribute(checker: &mut Checker, expr: &Expr) {
-    if match_name_or_attr_from_module(expr, "PY3", "six", checker.from_imports.get("six"))
-        && checker.settings.enabled.contains(&CheckCode::YTT202)
-    {
+    if match_module_member(expr, "six.PY3", &checker.from_imports) {
         checker.add_check(Check::new(
             CheckKind::SixPY3Referenced,
             Range::from_located(expr),

src/flake8_bugbear/plugins/abstract_base_class.rs

@@ -0,0 +1,111 @@
+use fnv::{FnvHashMap, FnvHashSet};
+use rustpython_ast::{Constant, Expr, ExprKind, Keyword, Stmt, StmtKind};
+
+use crate::ast::helpers::{compose_call_path, match_call_path};
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+fn is_abc_class(
+    bases: &[Expr],
+    keywords: &[Keyword],
+    from_imports: &FnvHashMap<&str, FnvHashSet<&str>>,
+) -> bool {
+    keywords.iter().any(|keyword| {
+        keyword
+            .node
+            .arg
+            .as_ref()
+            .map(|a| a == "metaclass")
+            .unwrap_or(false)
+            && compose_call_path(&keyword.node.value)
+                .map(|call_path| match_call_path(&call_path, "abc.ABCMeta", from_imports))
+                .unwrap_or(false)
+    }) || bases.iter().any(|base| {
+        compose_call_path(base)
+            .map(|call_path| match_call_path(&call_path, "abc.ABC", from_imports))
+            .unwrap_or(false)
+    })
+}
+
+fn is_empty_body(body: &[Stmt]) -> bool {
+    body.iter().all(|stmt| match &stmt.node {
+        StmtKind::Pass => true,
+        StmtKind::Expr { value } => match &value.node {
+            ExprKind::Constant { value, .. } => {
+                matches!(value, Constant::Str(..) | Constant::Ellipsis)
+            }
+            _ => false,
+        },
+        _ => false,
+    })
+}
+
+fn is_abstractmethod(expr: &Expr, from_imports: &FnvHashMap<&str, FnvHashSet<&str>>) -> bool {
+    compose_call_path(expr)
+        .map(|call_path| match_call_path(&call_path, "abc.abstractmethod", from_imports))
+        .unwrap_or(false)
+}
+
+fn is_overload(expr: &Expr, from_imports: &FnvHashMap<&str, FnvHashSet<&str>>) -> bool {
+    compose_call_path(expr)
+        .map(|call_path| match_call_path(&call_path, "typing.overload", from_imports))
+        .unwrap_or(false)
+}
+
+pub fn abstract_base_class(
+    checker: &mut Checker,
+    stmt: &Stmt,
+    name: &str,
+    bases: &[Expr],
+    keywords: &[Keyword],
+    body: &[Stmt],
+) {
+    if bases.len() + keywords.len() == 1 && is_abc_class(bases, keywords, &checker.from_imports) {
+        let mut has_abstract_method = false;
+        for stmt in body {
+            // https://github.com/PyCQA/flake8-bugbear/issues/293
+            // Ignore abc's that declares a class attribute that must be set
+            if let StmtKind::AnnAssign { .. } | StmtKind::Assign { .. } = &stmt.node {
+                has_abstract_method = true;
+                continue;
+            }
+
+            if let StmtKind::FunctionDef {
+                decorator_list,
+                body,
+                ..
+            }
+            | StmtKind::AsyncFunctionDef {
+                decorator_list,
+                body,
+                ..
+            } = &stmt.node
+            {
+                let has_abstract_decorator = decorator_list
+                    .iter()
+                    .any(|d| is_abstractmethod(d, &checker.from_imports));
+
+                has_abstract_method |= has_abstract_decorator;
+
+                if !has_abstract_decorator
+                    && is_empty_body(body)
+                    && !decorator_list
+                        .iter()
+                        .any(|d| is_overload(d, &checker.from_imports))
+                {
+                    checker.add_check(Check::new(
+                        CheckKind::EmptyMethodWithoutAbstractDecorator(name.to_string()),
+                        Range::from_located(stmt),
+                    ));
+                }
+            }
+        }
+        if !has_abstract_method {
+            checker.add_check(Check::new(
+                CheckKind::AbstractBaseClassWithoutAbstractMethod(name.to_string()),
+                Range::from_located(stmt),
+            ));
+        }
+    }
+}

src/flake8_bugbear/plugins/cached_instance_method.rs

@@ -1,22 +1,13 @@
 use rustpython_ast::{Expr, ExprKind};
 
-use crate::ast::helpers::{compose_call_path, match_name_or_attr_from_module};
+use crate::ast::helpers::{compose_call_path, match_module_member};
 use crate::ast::types::{Range, ScopeKind};
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 fn is_cache_func(checker: &Checker, expr: &Expr) -> bool {
-    match_name_or_attr_from_module(
-        expr,
-        "lru_cache",
-        "functools",
-        checker.from_imports.get("functools"),
-    ) || match_name_or_attr_from_module(
-        expr,
-        "cache",
-        "functools",
-        checker.from_imports.get("functools"),
-    )
+    match_module_member(expr, "functools.lru_cache", &checker.from_imports)
+        || match_module_member(expr, "functools.cache", &checker.from_imports)
 }
 
 /// B019

src/flake8_bugbear/plugins/f_string_docstring.rs

@@ -0,0 +1,19 @@
+use rustpython_ast::{ExprKind, Stmt, StmtKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B021
+pub fn f_string_docstring(checker: &mut Checker, body: &[Stmt]) {
+    if let Some(stmt) = body.first() {
+        if let StmtKind::Expr { value } = &stmt.node {
+            if let ExprKind::JoinedStr { .. } = value.node {
+                checker.add_check(Check::new(
+                    CheckKind::FStringDocstring,
+                    Range::from_located(stmt),
+                ));
+            }
+        }
+    }
+}

src/flake8_bugbear/plugins/function_call_argument_default.rs

@@ -1,7 +1,7 @@
 use fnv::{FnvHashMap, FnvHashSet};
 use rustpython_ast::{Arguments, Constant, Expr, ExprKind};
 
-use crate::ast::helpers::compose_call_path;
+use crate::ast::helpers::{compose_call_path, match_call_path};
 use crate::ast::types::Range;
 use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
@@ -24,37 +24,14 @@ fn is_immutable_func(
     extend_immutable_calls: &[&str],
     from_imports: &FnvHashMap<&str, FnvHashSet<&str>>,
 ) -> bool {
-    compose_call_path(expr).map_or_else(
-        || false,
-        |call_path| {
-            // It matches the call path exactly (`operator.methodcaller`).
-            for target in IMMUTABLE_FUNCS.iter().chain(extend_immutable_calls) {
-                if &call_path == target {
-                    return true;
-                }
-            }
-
-            // It matches the member name, and was imported from that module (`methodcaller`
-            // following `from operator import methodcaller`).
-            if !call_path.contains('.') {
-                for target in IMMUTABLE_FUNCS.iter().chain(extend_immutable_calls) {
-                    let mut splitter = target.rsplit('.');
-                    if let (Some(member), Some(module)) = (splitter.next(), splitter.next()) {
-                        if call_path == member
-                            && from_imports
-                                .get(module)
-                                .map(|module| module.contains(member))
-                                .unwrap_or(false)
-                        {
-                            return true;
-                        }
-                    }
-                }
-            }
-
-            false
-        },
-    )
+    compose_call_path(expr)
+        .map(|call_path| {
+            IMMUTABLE_FUNCS
+                .iter()
+                .chain(extend_immutable_calls)
+                .any(|target| match_call_path(&call_path, target, from_imports))
+        })
+        .unwrap_or(false)
 }
 
 struct ArgumentDefaultVisitor<'a> {
@@ -75,7 +52,7 @@ where
                     && !is_nan_or_infinity(func, args)
                 {
                     self.checks.push((
-                        CheckKind::FunctionCallArgumentDefault,
+                        CheckKind::FunctionCallArgumentDefault(compose_call_path(expr)),
                         Range::from_located(expr),
                     ))
                 }

src/flake8_bugbear/plugins/jump_statement_in_finally.rs

@@ -0,0 +1,49 @@
+use rustpython_ast::{Stmt, StmtKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+fn walk_stmt(checker: &mut Checker, body: &[Stmt], f: fn(&Stmt) -> bool) {
+    for stmt in body {
+        if f(stmt) {
+            checker.add_check(Check::new(
+                CheckKind::JumpStatementInFinally(match &stmt.node {
+                    StmtKind::Break { .. } => "break".to_string(),
+                    StmtKind::Continue { .. } => "continue".to_string(),
+                    StmtKind::Return { .. } => "return".to_string(),
+                    _ => unreachable!(
+                        "Expected StmtKind::Break | StmtKind::Continue | StmtKind::Return"
+                    ),
+                }),
+                Range::from_located(stmt),
+            ));
+        }
+        match &stmt.node {
+            StmtKind::While { body, .. }
+            | StmtKind::For { body, .. }
+            | StmtKind::AsyncFor { body, .. } => {
+                walk_stmt(checker, body, |stmt| {
+                    matches!(stmt.node, StmtKind::Return { .. })
+                });
+            }
+            StmtKind::If { body, .. }
+            | StmtKind::Try { body, .. }
+            | StmtKind::With { body, .. }
+            | StmtKind::AsyncWith { body, .. } => {
+                walk_stmt(checker, body, f);
+            }
+            _ => {}
+        }
+    }
+}
+
+/// B012
+pub fn jump_statement_in_finally(checker: &mut Checker, finalbody: &[Stmt]) {
+    walk_stmt(checker, finalbody, |stmt| {
+        matches!(
+            stmt.node,
+            StmtKind::Break | StmtKind::Continue | StmtKind::Return { .. }
+        )
+    });
+}

src/flake8_bugbear/plugins/mod.rs

@@ -1,11 +1,14 @@
+pub use abstract_base_class::abstract_base_class;
 pub use assert_false::assert_false;
 pub use assert_raises_exception::assert_raises_exception;
 pub use assignment_to_os_environ::assignment_to_os_environ;
 pub use cached_instance_method::cached_instance_method;
 pub use cannot_raise_literal::cannot_raise_literal;
 pub use duplicate_exceptions::{duplicate_exceptions, duplicate_handler_exceptions};
+pub use f_string_docstring::f_string_docstring;
 pub use function_call_argument_default::function_call_argument_default;
 pub use getattr_with_constant::getattr_with_constant;
+pub use jump_statement_in_finally::jump_statement_in_finally;
 pub use mutable_argument_default::mutable_argument_default;
 pub use redundant_tuple_in_exception_handler::redundant_tuple_in_exception_handler;
 pub use setattr_with_constant::setattr_with_constant;
@@ -15,16 +18,20 @@ pub use unary_prefix_increment::unary_prefix_increment;
 pub use unreliable_callable_check::unreliable_callable_check;
 pub use unused_loop_control_variable::unused_loop_control_variable;
 pub use useless_comparison::useless_comparison;
+pub use useless_contextlib_suppress::useless_contextlib_suppress;
 pub use useless_expression::useless_expression;
 
+mod abstract_base_class;
 mod assert_false;
 mod assert_raises_exception;
 mod assignment_to_os_environ;
 mod cached_instance_method;
 mod cannot_raise_literal;
 mod duplicate_exceptions;
+mod f_string_docstring;
 mod function_call_argument_default;
 mod getattr_with_constant;
+mod jump_statement_in_finally;
 mod mutable_argument_default;
 mod redundant_tuple_in_exception_handler;
 mod setattr_with_constant;
@@ -34,4 +41,5 @@ mod unary_prefix_increment;
 mod unreliable_callable_check;
 mod unused_loop_control_variable;
 mod useless_comparison;
+mod useless_contextlib_suppress;
 mod useless_expression;

src/flake8_bugbear/plugins/mutable_argument_default.rs

@@ -1,7 +1,7 @@
 use fnv::{FnvHashMap, FnvHashSet};
 use rustpython_ast::{Arguments, Expr, ExprKind};
 
-use crate::ast::helpers::compose_call_path;
+use crate::ast::helpers::{compose_call_path, match_call_path};
 use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
@@ -17,37 +17,13 @@ const MUTABLE_FUNCS: [&str; 7] = [
 ];
 
 pub fn is_mutable_func(expr: &Expr, from_imports: &FnvHashMap<&str, FnvHashSet<&str>>) -> bool {
-    compose_call_path(expr).map_or_else(
-        || false,
-        |call_path| {
-            // It matches the call path exactly (`collections.Counter`).
-            for target in MUTABLE_FUNCS {
-                if call_path == target {
-                    return true;
-                }
-            }
-
-            // It matches the member name, and was imported from that module (`Counter`
-            // following `from collections import Counter`).
-            if !call_path.contains('.') {
-                for target in MUTABLE_FUNCS {
-                    let mut splitter = target.rsplit('.');
-                    if let (Some(member), Some(module)) = (splitter.next(), splitter.next()) {
-                        if call_path == member
-                            && from_imports
-                                .get(module)
-                                .map(|module| module.contains(member))
-                                .unwrap_or(false)
-                        {
-                            return true;
-                        }
-                    }
-                }
-            }
-
-            false
-        },
-    )
+    compose_call_path(expr)
+        .map(|call_path| {
+            MUTABLE_FUNCS
+                .iter()
+                .any(|target| match_call_path(&call_path, target, from_imports))
+        })
+        .unwrap_or(false)
 }
 
 /// B006

src/flake8_bugbear/plugins/useless_contextlib_suppress.rs

@@ -0,0 +1,20 @@
+use rustpython_ast::Expr;
+
+use crate::ast::helpers::{compose_call_path, match_call_path};
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B005
+pub fn useless_contextlib_suppress(checker: &mut Checker, expr: &Expr, args: &[Expr]) {
+    if compose_call_path(expr)
+        .map(|call_path| match_call_path(&call_path, "contextlib.suppress", &checker.from_imports))
+        .unwrap_or(false)
+        && args.is_empty()
+    {
+        checker.add_check(Check::new(
+            CheckKind::UselessContextlibSuppress,
+            Range::from_located(expr),
+        ));
+    }
+}

src/flake8_bugbear/snapshots/ruff__flake8_bugbear__tests__extend_immutable_calls.snap

@@ -2,7 +2,8 @@
 source: src/flake8_bugbear/mod.rs
 expression: checks
 ---
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: Depends
   location:
     row: 19
     column: 50

src/fs.rs

@@ -1,11 +1,11 @@
 use std::borrow::Cow;
-use std::collections::BTreeSet;
 use std::fs::File;
 use std::io::{BufReader, Read};
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 
 use anyhow::{anyhow, Result};
+use fnv::FnvHashSet;
 use log::debug;
 use path_absolutize::{path_dedot, Absolutize};
 use walkdir::{DirEntry, WalkDir};
@@ -121,7 +121,7 @@ pub fn iter_python_files<'a>(
 pub(crate) fn ignores_from_path<'a>(
     path: &Path,
     pattern_code_pairs: &'a [PerFileIgnore],
-) -> Result<BTreeSet<&'a CheckCode>> {
+) -> Result<FnvHashSet<&'a CheckCode>> {
     let (file_path, file_basename) = extract_path_names(path)?;
     Ok(pattern_code_pairs
         .iter()

src/isort/categorize.rs

@@ -1,9 +1,7 @@
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::BTreeSet;
 use std::fs;
 use std::path::PathBuf;
 
-use once_cell::sync::Lazy;
-
 use crate::python::sys::KNOWN_STANDARD_LIBRARY;
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)]
@@ -31,8 +29,8 @@ pub fn categorize(
         ImportType::ThirdParty
     } else if extra_standard_library.contains(module_base) {
         ImportType::StandardLibrary
-    } else if let Some(import_type) = STATIC_CLASSIFICATIONS.get(module_base) {
-        import_type.clone()
+    } else if module_base == "__future__" {
+        ImportType::Future
     } else if KNOWN_STANDARD_LIBRARY.contains(module_base) {
         ImportType::StandardLibrary
     } else if find_local(src, module_base) {
@@ -42,14 +40,6 @@ pub fn categorize(
     }
 }
 
-static STATIC_CLASSIFICATIONS: Lazy<BTreeMap<&'static str, ImportType>> = Lazy::new(|| {
-    BTreeMap::from([
-        ("__future__", ImportType::Future),
-        // Relative imports (e.g., `from . import module`).
-        ("", ImportType::FirstParty),
-    ])
-});
-
 fn find_local(paths: &[PathBuf], base: &str) -> bool {
     for path in paths {
         if let Ok(metadata) = fs::metadata(path.join(base)) {

src/isort/mod.rs

@@ -1,6 +1,7 @@
 use std::collections::{BTreeMap, BTreeSet};
 use std::path::PathBuf;
 
+use fnv::FnvHashSet;
 use itertools::Itertools;
 use ropey::RopeBuilder;
 use rustpython_ast::{Stmt, StmtKind};
@@ -36,15 +37,25 @@ fn normalize_imports<'a>(imports: &'a [&'a Stmt]) -> ImportBlock<'a> {
                 names,
                 level,
             } => {
-                let targets = block
-                    .import_from
-                    .entry(ImportFromData { module, level })
-                    .or_default();
                 for name in names {
-                    targets.insert(AliasData {
-                        name: &name.node.name,
-                        asname: &name.node.asname,
-                    });
+                    if name.node.asname.is_none() {
+                        block
+                            .import_from
+                            .entry(ImportFromData { module, level })
+                            .or_default()
+                            .insert(AliasData {
+                                name: &name.node.name,
+                                asname: &name.node.asname,
+                            });
+                    } else {
+                        block.import_from_as.insert((
+                            ImportFromData { module, level },
+                            AliasData {
+                                name: &name.node.name,
+                                asname: &name.node.asname,
+                            },
+                        ));
+                    }
                 }
             }
             _ => unreachable!("Expected StmtKind::Import | StmtKind::ImportFrom"),
@@ -77,7 +88,7 @@ fn categorize_imports<'a>(
             .import
             .insert(alias);
     }
-    // Categorize `StmtKind::ImportFrom`.
+    // Categorize `StmtKind::ImportFrom` (without re-export).
     for (import_from, aliases) in block.import_from {
         let classification = categorize(
             &import_from.module_base(),
@@ -93,36 +104,74 @@ fn categorize_imports<'a>(
             .import_from
             .insert(import_from, aliases);
     }
+    // Categorize `StmtKind::ImportFrom` (with re-export).
+    for (import_from, alias) in block.import_from_as {
+        let classification = categorize(
+            &import_from.module_base(),
+            import_from.level,
+            src,
+            known_first_party,
+            known_third_party,
+            extra_standard_library,
+        );
+        block_by_type
+            .entry(classification)
+            .or_default()
+            .import_from_as
+            .insert((import_from, alias));
+    }
     block_by_type
 }
 
 fn sort_imports(block: ImportBlock) -> OrderedImportBlock {
     let mut ordered: OrderedImportBlock = Default::default();
+
     // Sort `StmtKind::Import`.
-    for import in block
-        .import
-        .into_iter()
-        .sorted_by_cached_key(|alias| module_key(alias.name))
-    {
-        ordered.import.push(import);
-    }
+    ordered.import.extend(
+        block
+            .import
+            .into_iter()
+            .sorted_by_cached_key(|alias| module_key(alias.name, alias.asname)),
+    );
+
     // Sort `StmtKind::ImportFrom`.
-    for (import_from, aliases) in
+    ordered.import_from.extend(
+        // Include all non-re-exports.
         block
             .import_from
             .into_iter()
-            .sorted_by_cached_key(|(import_from, _)| {
-                import_from.module.as_ref().map(|module| module_key(module))
+            .chain(
+                // Include all re-exports.
+                block
+                    .import_from_as
+                    .into_iter()
+                    .map(|(import_from, alias)| (import_from, FnvHashSet::from_iter([alias]))),
+            )
+            .map(|(import_from, aliases)| {
+                // Within each `StmtKind::ImportFrom`, sort the members.
+                (
+                    import_from,
+                    aliases
+                        .into_iter()
+                        .sorted_by_cached_key(|alias| member_key(alias.name, alias.asname))
+                        .collect::<Vec<AliasData>>(),
+                )
             })
-    {
-        ordered.import_from.push((
-            import_from,
-            aliases
-                .into_iter()
-                .sorted_by_cached_key(|alias| member_key(alias.name))
-                .collect(),
-        ));
-    }
+            .sorted_by_cached_key(|(import_from, aliases)| {
+                // Sort each `StmtKind::ImportFrom` by module key, breaking ties based on
+                // members.
+                (
+                    import_from
+                        .module
+                        .as_ref()
+                        .map(|module| module_key(module, &None)),
+                    aliases
+                        .first()
+                        .map(|alias| member_key(alias.name, alias.asname)),
+                )
+            }),
+    );
+
     ordered
 }
 
@@ -252,6 +301,7 @@ mod tests {
     #[test_case(Path::new("separate_local_folder_imports.py"))]
     #[test_case(Path::new("separate_third_party_imports.py"))]
     #[test_case(Path::new("skip.py"))]
+    #[test_case(Path::new("sort_similar_imports.py"))]
     #[test_case(Path::new("trailing_suffix.py"))]
     fn isort(path: &Path) -> Result<()> {
         let snapshot = format!("{}", path.to_string_lossy());

src/isort/snapshots/ruff__isort__tests__sort_similar_imports.py.snap

@@ -0,0 +1,22 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+- kind: UnsortedImports
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 27
+    column: 0
+  fix:
+    patch:
+      content: "import A\nimport a\nimport B\nimport b\nimport x\nimport x as A\nimport x as Y\nimport x as a\nimport x as y\nfrom a import BAD as DEF\nfrom a import B, b\nfrom a import B as A\nfrom a import B as Abc\nfrom a import B as DEF\nfrom a import Boo as DEF\nfrom a import b as a\nfrom a import b as c\nfrom a import b as d\nfrom a import b as x\nfrom a import b as y\nfrom b import C, c\nfrom b import c as d\n"
+      location:
+        row: 1
+        column: 0
+      end_location:
+        row: 27
+        column: 0
+    applied: false
+

src/isort/sorting.rs

@@ -8,16 +8,22 @@ pub enum Prefix {
     Variables,
 }
 
-pub fn module_key(module_name: &str) -> String {
-    module_name.to_lowercase()
+pub fn module_key<'a>(
+    name: &'a str,
+    asname: &'a Option<String>,
+) -> (String, &'a str, &'a Option<String>) {
+    (name.to_lowercase(), name, asname)
 }
 
-pub fn member_key(member_name: &str) -> (Prefix, String) {
+pub fn member_key<'a>(
+    name: &'a str,
+    asname: &'a Option<String>,
+) -> (Prefix, String, &'a Option<String>) {
     (
-        if member_name.len() > 1 && string::is_upper(member_name) {
+        if name.len() > 1 && string::is_upper(name) {
             // Ex) `CONSTANT`
             Prefix::Constants
-        } else if member_name
+        } else if name
             .chars()
             .next()
             .map(|char| char.is_uppercase())
@@ -29,6 +35,7 @@ pub fn member_key(member_name: &str) -> (Prefix, String) {
             // Ex) `variable`
             Prefix::Variables
         },
-        member_name.to_lowercase(),
+        name.to_lowercase(),
+        asname,
     )
 }

src/isort/types.rs

@@ -1,4 +1,4 @@
-use std::collections::{BTreeMap, BTreeSet};
+use fnv::{FnvHashMap, FnvHashSet};
 
 #[derive(Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
 pub struct ImportFromData<'a> {
@@ -48,16 +48,19 @@ impl Importable for ImportFromData<'_> {
 
 #[derive(Debug, Default)]
 pub struct ImportBlock<'a> {
-    // Map from (module, level) to `AliasData`.
-    pub import_from: BTreeMap<ImportFromData<'a>, BTreeSet<AliasData<'a>>>,
-    // Set of (name, asname).
-    pub import: BTreeSet<AliasData<'a>>,
+    // Set of (name, asname), used to track regular imports.
+    // Ex) `import module`
+    pub import: FnvHashSet<AliasData<'a>>,
+    // Map from (module, level) to `AliasData`, used to track 'from' imports.
+    // Ex) `from module import member`
+    pub import_from: FnvHashMap<ImportFromData<'a>, FnvHashSet<AliasData<'a>>>,
+    // Set of (module, level, name, asname), used to track re-exported 'from' imports.
+    // Ex) `from module import member as member`
+    pub import_from_as: FnvHashSet<(ImportFromData<'a>, AliasData<'a>)>,
 }
 
 #[derive(Debug, Default)]
 pub struct OrderedImportBlock<'a> {
-    // Map from (module, level) to `AliasData`.
-    pub import_from: Vec<(ImportFromData<'a>, Vec<AliasData<'a>>)>,
-    // Set of (name, asname).
     pub import: Vec<AliasData<'a>>,
+    pub import_from: Vec<(ImportFromData<'a>, Vec<AliasData<'a>>)>,
 }

src/linter.rs

@@ -336,6 +336,7 @@ mod tests {
     #[test_case(CheckCode::B009, Path::new("B009_B010.py"); "B009")]
     #[test_case(CheckCode::B010, Path::new("B009_B010.py"); "B010")]
     #[test_case(CheckCode::B011, Path::new("B011.py"); "B011")]
+    #[test_case(CheckCode::B012, Path::new("B012.py"); "B012")]
     #[test_case(CheckCode::B013, Path::new("B013.py"); "B013")]
     #[test_case(CheckCode::B014, Path::new("B014.py"); "B014")]
     #[test_case(CheckCode::B015, Path::new("B015.py"); "B015")]
@@ -343,8 +344,12 @@ mod tests {
     #[test_case(CheckCode::B017, Path::new("B017.py"); "B017")]
     #[test_case(CheckCode::B018, Path::new("B018.py"); "B018")]
     #[test_case(CheckCode::B019, Path::new("B019.py"); "B019")]
+    #[test_case(CheckCode::B021, Path::new("B021.py"); "B021")]
+    #[test_case(CheckCode::B022, Path::new("B022.py"); "B022")]
+    #[test_case(CheckCode::B024, Path::new("B024.py"); "B024")]
     #[test_case(CheckCode::B025, Path::new("B025.py"); "B025")]
     #[test_case(CheckCode::B026, Path::new("B026.py"); "B026")]
+    #[test_case(CheckCode::B027, Path::new("B027.py"); "B027")]
     #[test_case(CheckCode::C400, Path::new("C400.py"); "C400")]
     #[test_case(CheckCode::C401, Path::new("C401.py"); "C401")]
     #[test_case(CheckCode::C402, Path::new("C402.py"); "C402")]
@@ -425,6 +430,7 @@ mod tests {
     #[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::F401, Path::new("F401_6.py"); "F401_6")]
     #[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")]
@@ -515,7 +521,7 @@ mod tests {
         let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
         let mut checks = test_path(
             Path::new("./resources/test/fixtures").join(path).as_path(),
-            &settings::Settings::for_rule(check_code.clone()),
+            &settings::Settings::for_rule(check_code),
             &fixer::Mode::Generate,
         )?;
         checks.sort_by_key(|check| check.location);

src/noqa.rs

@@ -10,7 +10,7 @@ use regex::Regex;
 use crate::checks::{Check, CheckCode};
 
 static NO_QA_REGEX: Lazy<Regex> = Lazy::new(|| {
-    Regex::new(r"(?P<noqa>\s*# noqa(?::\s?(?P<codes>([A-Z]+[0-9]+(?:[,\s]+)?)+))?)")
+    Regex::new(r"(?P<noqa>\s*(?i:# noqa)(?::\s?(?P<codes>([A-Z]+[0-9]+(?:[,\s]+)?)+))?)")
         .expect("Invalid regex")
 });
 static SPLIT_COMMA_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"[,\s]").expect("Invalid regex"));
@@ -118,7 +118,21 @@ mod tests {
 
     use crate::ast::types::Range;
     use crate::checks::{Check, CheckKind};
-    use crate::noqa::add_noqa_inner;
+    use crate::noqa::{add_noqa_inner, NO_QA_REGEX};
+
+    #[test]
+    fn regex() {
+        assert!(NO_QA_REGEX.is_match("# noqa"));
+        assert!(NO_QA_REGEX.is_match("# NoQA"));
+
+        assert!(NO_QA_REGEX.is_match("# noqa: F401"));
+        assert!(NO_QA_REGEX.is_match("# NoQA: F401"));
+        assert!(NO_QA_REGEX.is_match("# noqa: F401, E501"));
+
+        assert!(NO_QA_REGEX.is_match("# noqa:F401"));
+        assert!(NO_QA_REGEX.is_match("# NoQA:F401"));
+        assert!(NO_QA_REGEX.is_match("# noqa:F401, E501"));
+    }
 
     #[test]
     fn modification() -> Result<()> {

src/pep8_naming/checks.rs

@@ -1,11 +1,11 @@
 use rustpython_ast::{Arguments, Expr, ExprKind, Stmt};
 
-use crate::ast::types::{FunctionScope, Range, Scope, ScopeKind};
+use crate::ast::types::{Range, Scope, ScopeKind};
 use crate::checks::{Check, CheckKind};
 use crate::pep8_naming::helpers;
 use crate::pep8_naming::helpers::FunctionType;
 use crate::pep8_naming::settings::Settings;
-use crate::python::string;
+use crate::python::string::{self};
 
 /// N801
 pub fn invalid_class_name(class_def: &Stmt, name: &str) -> Option<Check> {
@@ -100,20 +100,6 @@ pub fn invalid_first_argument_name_for_method(
     None
 }
 
-/// N806
-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 name.to_lowercase() != name {
-        return Some(Check::new(
-            CheckKind::NonLowercaseVariableInFunction(name.to_string()),
-            Range::from_located(expr),
-        ));
-    }
-    None
-}
-
 /// N807
 pub fn dunder_function_name(scope: &Scope, stmt: &Stmt, name: &str) -> Option<Check> {
     if matches!(scope.kind, ScopeKind::Class(_)) {
@@ -192,38 +178,6 @@ pub fn camelcase_imported_as_constant(
     None
 }
 
-/// N815
-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 helpers::is_mixed_case(name) {
-        return Some(Check::new(
-            CheckKind::MixedCaseVariableInClassScope(name.to_string()),
-            Range::from_located(expr),
-        ));
-    }
-    None
-}
-
-/// N816
-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 helpers::is_mixed_case(name) {
-        return Some(Check::new(
-            CheckKind::MixedCaseVariableInGlobalScope(name.to_string()),
-            Range::from_located(expr),
-        ));
-    }
-    None
-}
-
 /// N817
 pub fn camelcase_imported_as_acronym(
     import_from: &Stmt,

src/pep8_naming/helpers.rs

@@ -1,7 +1,8 @@
+use fnv::{FnvHashMap, FnvHashSet};
 use itertools::Itertools;
-use rustpython_ast::{Expr, ExprKind};
+use rustpython_ast::{Expr, ExprKind, Stmt, StmtKind};
 
-use crate::ast::helpers::match_name_or_attr;
+use crate::ast::helpers::{compose_call_path, match_call_path, match_name_or_attr};
 use crate::ast::types::{Scope, ScopeKind};
 use crate::pep8_naming::settings::Settings;
 use crate::python::string::{is_lower, is_upper};
@@ -78,12 +79,25 @@ pub fn is_acronym(name: &str, asname: &str) -> bool {
     name.chars().filter(|c| c.is_uppercase()).join("") == asname
 }
 
+pub fn is_namedtuple_assignment(
+    stmt: &Stmt,
+    from_imports: &FnvHashMap<&str, FnvHashSet<&str>>,
+) -> bool {
+    if let StmtKind::Assign { value, .. } = &stmt.node {
+        compose_call_path(value)
+            .map(|call_path| match_call_path(&call_path, "collections.namedtuple", from_imports))
+            .unwrap_or(false)
+    } else {
+        false
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::pep8_naming::helpers::{is_acronym, is_camelcase, is_mixed_case};
 
     #[test]
-    fn test_is_camelcase() -> () {
+    fn test_is_camelcase() {
         assert!(is_camelcase("Camel"));
         assert!(is_camelcase("CamelCase"));
         assert!(!is_camelcase("camel"));
@@ -93,7 +107,7 @@ mod tests {
     }
 
     #[test]
-    fn test_is_mixed_case() -> () {
+    fn test_is_mixed_case() {
         assert!(is_mixed_case("mixedCase"));
         assert!(is_mixed_case("mixed_Case"));
         assert!(is_mixed_case("_mixed_Case"));
@@ -104,7 +118,7 @@ mod tests {
     }
 
     #[test]
-    fn test_is_acronym() -> () {
+    fn test_is_acronym() {
         assert!(is_acronym("AB", "AB"));
         assert!(is_acronym("AbcDef", "AD"));
         assert!(!is_acronym("AbcDef", "Ad"));

src/pep8_naming/mod.rs

@@ -1,3 +1,4 @@
 pub mod checks;
 mod helpers;
+pub mod plugins;
 pub mod settings;

src/pep8_naming/plugins.rs

@@ -0,0 +1,58 @@
+use rustpython_ast::{Expr, Stmt};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::CheckKind;
+use crate::pep8_naming::helpers;
+use crate::Check;
+
+/// N806
+pub fn non_lowercase_variable_in_function(
+    checker: &mut Checker,
+    expr: &Expr,
+    stmt: &Stmt,
+    name: &str,
+) {
+    if name.to_lowercase() != name
+        && !helpers::is_namedtuple_assignment(stmt, &checker.from_imports)
+    {
+        checker.add_check(Check::new(
+            CheckKind::NonLowercaseVariableInFunction(name.to_string()),
+            Range::from_located(expr),
+        ));
+    }
+}
+
+/// N815
+pub fn mixed_case_variable_in_class_scope(
+    checker: &mut Checker,
+    expr: &Expr,
+    stmt: &Stmt,
+    name: &str,
+) {
+    if helpers::is_mixed_case(name)
+        && !helpers::is_namedtuple_assignment(stmt, &checker.from_imports)
+    {
+        checker.add_check(Check::new(
+            CheckKind::MixedCaseVariableInClassScope(name.to_string()),
+            Range::from_located(expr),
+        ));
+    }
+}
+
+/// N816
+pub fn mixed_case_variable_in_global_scope(
+    checker: &mut Checker,
+    expr: &Expr,
+    stmt: &Stmt,
+    name: &str,
+) {
+    if helpers::is_mixed_case(name)
+        && !helpers::is_namedtuple_assignment(stmt, &checker.from_imports)
+    {
+        checker.add_check(Check::new(
+            CheckKind::MixedCaseVariableInGlobalScope(name.to_string()),
+            Range::from_located(expr),
+        ));
+    }
+}

src/pydocstyle/plugins.rs

@@ -1,5 +1,6 @@
 use std::collections::BTreeSet;
 
+use fnv::FnvHashSet;
 use itertools::Itertools;
 use once_cell::sync::Lazy;
 use regex::Regex;
@@ -696,7 +697,7 @@ pub fn ends_with_period(checker: &mut Checker, definition: &Definition) {
             ..
         } = &docstring.node
         {
-            if let Some(string) = string.lines().next() {
+            if let Some(string) = string.trim().lines().next() {
                 if !string.ends_with('.') {
                     checker.add_check(Check::new(
                         CheckKind::EndsInPeriod,
@@ -806,7 +807,7 @@ pub fn ends_with_punctuation(checker: &mut Checker, definition: &Definition) {
             ..
         } = &docstring.node
         {
-            if let Some(string) = string.lines().next() {
+            if let Some(string) = string.trim().lines().next() {
                 if !(string.ends_with('.') || string.ends_with('!') || string.ends_with('?')) {
                     checker.add_check(Check::new(
                         CheckKind::EndsInPunctuation,
@@ -1287,7 +1288,11 @@ fn common_section(
     blanks_and_section_underline(checker, definition, context);
 }
 
-fn missing_args(checker: &mut Checker, definition: &Definition, docstrings_args: &BTreeSet<&str>) {
+fn missing_args(
+    checker: &mut Checker,
+    definition: &Definition,
+    docstrings_args: &FnvHashSet<&str>,
+) {
     if let DefinitionKind::Function(parent)
     | DefinitionKind::NestedFunction(parent)
     | DefinitionKind::Method(parent) = definition.kind
@@ -1377,7 +1382,7 @@ fn args_section(checker: &mut Checker, definition: &Definition, context: &Sectio
         checker,
         definition,
         // Collect the list of arguments documented in the docstring.
-        &BTreeSet::from_iter(args_sections.iter().filter_map(|section| {
+        &FnvHashSet::from_iter(args_sections.iter().filter_map(|section| {
             match GOOGLE_ARGS_REGEX.captures(section.as_str()) {
                 Some(caps) => caps.get(1).map(|arg_name| arg_name.as_str()),
                 None => None,
@@ -1388,7 +1393,7 @@ fn args_section(checker: &mut Checker, definition: &Definition, context: &Sectio
 
 fn parameters_section(checker: &mut Checker, definition: &Definition, context: &SectionContext) {
     // Collect the list of arguments documented in the docstring.
-    let mut docstring_args: BTreeSet<&str> = Default::default();
+    let mut docstring_args: FnvHashSet<&str> = FnvHashSet::default();
     let section_level_indent = helpers::leading_space(context.line);
     for i in 1..context.following_lines.len() {
         let current_line = context.following_lines[i - 1];

src/pyflakes/checks.rs

@@ -1,5 +1,4 @@
-use std::collections::BTreeSet;
-
+use fnv::FnvHashSet;
 use regex::Regex;
 use rustpython_parser::ast::{
     Arg, Arguments, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprKind, Stmt, StmtKind,
@@ -113,7 +112,7 @@ pub fn duplicate_arguments(arguments: &Arguments) -> Vec<Check> {
     }
 
     // Search for duplicates.
-    let mut idents: BTreeSet<&str> = BTreeSet::new();
+    let mut idents: FnvHashSet<&str> = FnvHashSet::default();
     for arg in all_arguments {
         let ident = &arg.node.arg;
         if idents.contains(ident.as_str()) {

src/python/string.rs

@@ -27,7 +27,7 @@ mod tests {
     use crate::python::string::{is_lower, is_upper};
 
     #[test]
-    fn test_is_lower() -> () {
+    fn test_is_lower() {
         assert!(is_lower("abc"));
         assert!(is_lower("a_b_c"));
         assert!(is_lower("a2c"));
@@ -38,7 +38,7 @@ mod tests {
     }
 
     #[test]
-    fn test_is_upper() -> () {
+    fn test_is_upper() {
         assert!(is_upper("ABC"));
         assert!(is_upper("A_B_C"));
         assert!(is_upper("A2C"));

src/python/sys.rs

@@ -1,10 +1,9 @@
-use std::collections::BTreeSet;
-
+use fnv::FnvHashSet;
 use once_cell::sync::Lazy;
 
 // See: https://pycqa.github.io/isort/docs/configuration/options.html#known-standard-library
-pub static KNOWN_STANDARD_LIBRARY: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
-    BTreeSet::from([
+pub static KNOWN_STANDARD_LIBRARY: Lazy<FnvHashSet<&'static str>> = Lazy::new(|| {
+    FnvHashSet::from_iter([
         "_ast",
         "_dummy_thread",
         "_thread",

src/python/typing.rs

@@ -209,7 +209,7 @@ pub enum SubscriptKind {
 
 pub fn match_annotated_subscript(
     expr: &Expr,
-    imports: &FnvHashMap<&str, FnvHashSet<&str>>,
+    from_imports: &FnvHashMap<&str, FnvHashSet<&str>>,
 ) -> Option<SubscriptKind> {
     match &expr.node {
         ExprKind::Attribute { attr, value, .. } => {
@@ -238,9 +238,9 @@ pub fn match_annotated_subscript(
             // Verify that, e.g., `Union` is a reference to `typing.Union`.
             if let Some(modules) = IMPORTED_SUBSCRIPTS.get(&id.as_str()) {
                 for module in modules {
-                    if imports
+                    if from_imports
                         .get(module)
-                        .map(|imports| imports.contains(&id.as_str()))
+                        .map(|imports| imports.contains(&id.as_str()) || imports.contains("*"))
                         .unwrap_or_default()
                     {
                         return if is_pep593_annotated_subscript(id) {
@@ -260,7 +260,7 @@ pub fn match_annotated_subscript(
 /// Returns `true` if `Expr` represents a reference to a typing object with a
 /// PEP 585 built-in. Note that none of the PEP 585 built-ins are in
 /// `typing_extensions`.
-pub fn is_pep585_builtin(expr: &Expr, typing_imports: Option<&FnvHashSet<&str>>) -> bool {
+pub fn is_pep585_builtin(expr: &Expr, from_imports: &FnvHashMap<&str, FnvHashSet<&str>>) -> bool {
     match &expr.node {
         ExprKind::Attribute { attr, value, .. } => {
             if let ExprKind::Name { id, .. } = &value.node {
@@ -270,8 +270,9 @@ pub fn is_pep585_builtin(expr: &Expr, typing_imports: Option<&FnvHashSet<&str>>)
             }
         }
         ExprKind::Name { id, .. } => {
-            typing_imports
-                .map(|imports| imports.contains(&id.as_str()))
+            from_imports
+                .get("typing")
+                .map(|imports| imports.contains(&id.as_str()) || imports.contains("*"))
                 .unwrap_or_default()
                 && PEP_585_BUILTINS_ELIGIBLE.contains(&id.as_str())
         }

src/pyupgrade/checks.rs

@@ -1,4 +1,4 @@
-use fnv::FnvHashSet;
+use fnv::{FnvHashMap, FnvHashSet};
 use rustpython_ast::{Constant, KeywordData};
 use rustpython_parser::ast::{ArgData, Expr, ExprKind, Stmt, StmtKind};
 
@@ -163,7 +163,7 @@ pub fn type_of_primitive(func: &Expr, args: &[Expr], location: Range) -> Option<
 pub fn unnecessary_lru_cache_params(
     decorator_list: &[Expr],
     target_version: PythonVersion,
-    imports: Option<&FnvHashSet<&str>>,
+    imports: &FnvHashMap<&str, FnvHashSet<&str>>,
 ) -> Option<Check> {
     for expr in decorator_list.iter() {
         if let ExprKind::Call {
@@ -172,8 +172,7 @@ pub fn unnecessary_lru_cache_params(
             keywords,
         } = &expr.node
         {
-            if args.is_empty()
-                && helpers::match_name_or_attr_from_module(func, "lru_cache", "functools", imports)
+            if args.is_empty() && helpers::match_module_member(func, "functools.lru_cache", imports)
             {
                 // Ex) `functools.lru_cache()`
                 if keywords.is_empty() {

src/pyupgrade/plugins/unnecessary_lru_cache_params.rs

@@ -8,7 +8,7 @@ pub fn unnecessary_lru_cache_params(checker: &mut Checker, decorator_list: &[Exp
     if let Some(mut check) = checks::unnecessary_lru_cache_params(
         decorator_list,
         checker.settings.target_version,
-        checker.from_imports.get("functools"),
+        &checker.from_imports,
     ) {
         if checker.patch() {
             if let Some(fix) =

src/settings/mod.rs

@@ -114,6 +114,7 @@ impl Hash for Settings {
         self.target_version.hash(state);
         // Add plugin properties in alphabetical order.
         self.flake8_annotations.hash(state);
+        self.flake8_bugbear.hash(state);
         self.flake8_quotes.hash(state);
         self.isort.hash(state);
         self.pep8_naming.hash(state);

src/settings/options.rs

@@ -1,7 +1,6 @@
 //! Options that the user can provide via pyproject.toml.
 
-use std::collections::BTreeMap;
-
+use fnv::FnvHashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::checks_gen::CheckCodePrefix;
@@ -29,5 +28,5 @@ pub struct Options {
     pub isort: Option<isort::settings::Options>,
     pub pep8_naming: Option<pep8_naming::settings::Options>,
     // Tables are required to go last.
-    pub per_file_ignores: Option<BTreeMap<String, Vec<CheckCodePrefix>>>,
+    pub per_file_ignores: Option<FnvHashMap<String, Vec<CheckCodePrefix>>>,
 }

src/settings/pyproject.rs

@@ -96,12 +96,12 @@ pub fn load_options(pyproject: &Option<PathBuf>) -> Result<Options> {
 
 #[cfg(test)]
 mod tests {
-    use std::collections::BTreeMap;
     use std::env::current_dir;
     use std::path::PathBuf;
     use std::str::FromStr;
 
     use anyhow::Result;
+    use fnv::FnvHashMap;
 
     use crate::checks_gen::CheckCodePrefix;
     use crate::flake8_quotes::settings::Quote;
@@ -346,7 +346,7 @@ other-attribute = 1
                 extend_select: None,
                 ignore: None,
                 extend_ignore: None,
-                per_file_ignores: Some(BTreeMap::from([(
+                per_file_ignores: Some(FnvHashMap::from_iter([(
                     "__init__.py".to_string(),
                     vec![CheckCodePrefix::F401]
                 ),])),

src/snapshots/ruff__linter__tests__B008_B006_B008.py.snap

@@ -2,7 +2,8 @@
 source: src/linter.rs
 expression: checks
 ---
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: range
   location:
     row: 85
     column: 60
@@ -10,7 +11,8 @@ expression: checks
     row: 85
     column: 68
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: range
   location:
     row: 89
     column: 63
@@ -18,7 +20,8 @@ expression: checks
     row: 89
     column: 71
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: range
   location:
     row: 93
     column: 59
@@ -26,7 +29,8 @@ expression: checks
     row: 93
     column: 67
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: time.time
   location:
     row: 109
     column: 38
@@ -34,7 +38,8 @@ expression: checks
     row: 109
     column: 49
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: dt.datetime.now
   location:
     row: 113
     column: 11
@@ -42,7 +47,8 @@ expression: checks
     row: 113
     column: 28
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: dt.timedelta
   location:
     row: 113
     column: 31
@@ -50,7 +56,8 @@ expression: checks
     row: 113
     column: 51
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: ~
   location:
     row: 117
     column: 29
@@ -58,7 +65,8 @@ expression: checks
     row: 117
     column: 44
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: float
   location:
     row: 155
     column: 33
@@ -66,7 +74,8 @@ expression: checks
     row: 155
     column: 47
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: float
   location:
     row: 160
     column: 29
@@ -74,7 +83,8 @@ expression: checks
     row: 160
     column: 37
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: float
   location:
     row: 164
     column: 44
@@ -82,7 +92,8 @@ expression: checks
     row: 164
     column: 57
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: float
   location:
     row: 170
     column: 20
@@ -90,7 +101,8 @@ expression: checks
     row: 170
     column: 28
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: dt.datetime.now
   location:
     row: 170
     column: 30
@@ -98,7 +110,8 @@ expression: checks
     row: 170
     column: 47
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: map
   location:
     row: 176
     column: 21
@@ -106,7 +119,8 @@ expression: checks
     row: 176
     column: 62
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: random.randint
   location:
     row: 181
     column: 18
@@ -114,7 +128,8 @@ expression: checks
     row: 181
     column: 59
   fix: ~
-- kind: FunctionCallArgumentDefault
+- kind:
+    FunctionCallArgumentDefault: dt.datetime.now
   location:
     row: 181
     column: 36

src/snapshots/ruff__linter__tests__B012_B012.py.snap

@@ -0,0 +1,95 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    JumpStatementInFinally: return
+  location:
+    row: 5
+    column: 8
+  end_location:
+    row: 5
+    column: 14
+  fix: ~
+- kind:
+    JumpStatementInFinally: return
+  location:
+    row: 13
+    column: 12
+  end_location:
+    row: 13
+    column: 18
+  fix: ~
+- kind:
+    JumpStatementInFinally: return
+  location:
+    row: 21
+    column: 12
+  end_location:
+    row: 21
+    column: 18
+  fix: ~
+- kind:
+    JumpStatementInFinally: return
+  location:
+    row: 31
+    column: 12
+  end_location:
+    row: 31
+    column: 18
+  fix: ~
+- kind:
+    JumpStatementInFinally: return
+  location:
+    row: 44
+    column: 20
+  end_location:
+    row: 44
+    column: 26
+  fix: ~
+- kind:
+    JumpStatementInFinally: break
+  location:
+    row: 66
+    column: 12
+  end_location:
+    row: 66
+    column: 17
+  fix: ~
+- kind:
+    JumpStatementInFinally: continue
+  location:
+    row: 78
+    column: 12
+  end_location:
+    row: 78
+    column: 20
+  fix: ~
+- kind:
+    JumpStatementInFinally: return
+  location:
+    row: 94
+    column: 12
+  end_location:
+    row: 94
+    column: 18
+  fix: ~
+- kind:
+    JumpStatementInFinally: continue
+  location:
+    row: 101
+    column: 8
+  end_location:
+    row: 101
+    column: 16
+  fix: ~
+- kind:
+    JumpStatementInFinally: break
+  location:
+    row: 107
+    column: 8
+  end_location:
+    row: 107
+    column: 13
+  fix: ~
+

src/snapshots/ruff__linter__tests__B021_B021.py.snap

@@ -0,0 +1,85 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: FStringDocstring
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 4
+    column: 3
+  fix: ~
+- kind: FStringDocstring
+  location:
+    row: 14
+    column: 4
+  end_location:
+    row: 14
+    column: 28
+  fix: ~
+- kind: FStringDocstring
+  location:
+    row: 22
+    column: 4
+  end_location:
+    row: 22
+    column: 28
+  fix: ~
+- kind: FStringDocstring
+  location:
+    row: 30
+    column: 4
+  end_location:
+    row: 30
+    column: 28
+  fix: ~
+- kind: FStringDocstring
+  location:
+    row: 38
+    column: 4
+  end_location:
+    row: 38
+    column: 28
+  fix: ~
+- kind: FStringDocstring
+  location:
+    row: 46
+    column: 4
+  end_location:
+    row: 46
+    column: 24
+  fix: ~
+- kind: FStringDocstring
+  location:
+    row: 54
+    column: 4
+  end_location:
+    row: 54
+    column: 24
+  fix: ~
+- kind: FStringDocstring
+  location:
+    row: 62
+    column: 4
+  end_location:
+    row: 62
+    column: 24
+  fix: ~
+- kind: FStringDocstring
+  location:
+    row: 70
+    column: 4
+  end_location:
+    row: 70
+    column: 24
+  fix: ~
+- kind: FStringDocstring
+  location:
+    row: 74
+    column: 4
+  end_location:
+    row: 74
+    column: 48
+  fix: ~
+

src/snapshots/ruff__linter__tests__B022_B022.py.snap

@@ -0,0 +1,21 @@
+---
+source: src/linter.r
+expression: checks
+---
+- kind: UselessContextlibSuppress
+  location:
+    row: 9
+    column: 5
+  end_location:
+    row: 9
+    column: 26
+  fix: ~
+- kind: UselessContextlibSuppress
+  location:
+    row: 12
+    column: 5
+  end_location:
+    row: 12
+    column: 15
+  fix: ~
+

src/snapshots/ruff__linter__tests__B024_B024.py.snap

@@ -0,0 +1,86 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    AbstractBaseClassWithoutAbstractMethod: Base_1
+  location:
+    row: 17
+    column: 0
+  end_location:
+    row: 22
+    column: 0
+  fix: ~
+- kind:
+    AbstractBaseClassWithoutAbstractMethod: Base_4
+  location:
+    row: 34
+    column: 0
+  end_location:
+    row: 40
+    column: 0
+  fix: ~
+- kind:
+    AbstractBaseClassWithoutAbstractMethod: Base_5
+  location:
+    row: 40
+    column: 0
+  end_location:
+    row: 46
+    column: 0
+  fix: ~
+- kind:
+    AbstractBaseClassWithoutAbstractMethod: Base_6
+  location:
+    row: 46
+    column: 0
+  end_location:
+    row: 52
+    column: 0
+  fix: ~
+- kind:
+    AbstractBaseClassWithoutAbstractMethod: Base_7
+  location:
+    row: 52
+    column: 0
+  end_location:
+    row: 58
+    column: 0
+  fix: ~
+- kind:
+    AbstractBaseClassWithoutAbstractMethod: MetaBase_1
+  location:
+    row: 58
+    column: 0
+  end_location:
+    row: 63
+    column: 0
+  fix: ~
+- kind:
+    AbstractBaseClassWithoutAbstractMethod: abc_Base_1
+  location:
+    row: 69
+    column: 0
+  end_location:
+    row: 74
+    column: 0
+  fix: ~
+- kind:
+    AbstractBaseClassWithoutAbstractMethod: abc_Base_2
+  location:
+    row: 74
+    column: 0
+  end_location:
+    row: 79
+    column: 0
+  fix: ~
+- kind:
+    AbstractBaseClassWithoutAbstractMethod: abc_set_class_variable_4
+  location:
+    row: 128
+    column: 0
+  end_location:
+    row: 130
+    column: 0
+  fix: ~
+

src/snapshots/ruff__linter__tests__B027_B027.py.snap

@@ -0,0 +1,68 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    EmptyMethodWithoutAbstractDecorator: AbstractClass
+  location:
+    row: 13
+    column: 4
+  end_location:
+    row: 16
+    column: 4
+  fix: ~
+- kind:
+    EmptyMethodWithoutAbstractDecorator: AbstractClass
+  location:
+    row: 16
+    column: 4
+  end_location:
+    row: 19
+    column: 4
+  fix: ~
+- kind:
+    EmptyMethodWithoutAbstractDecorator: AbstractClass
+  location:
+    row: 19
+    column: 4
+  end_location:
+    row: 23
+    column: 4
+  fix: ~
+- kind:
+    EmptyMethodWithoutAbstractDecorator: AbstractClass
+  location:
+    row: 23
+    column: 4
+  end_location:
+    row: 30
+    column: 4
+  fix: ~
+- kind:
+    EmptyMethodWithoutAbstractDecorator: AbstractClass
+  location:
+    row: 31
+    column: 4
+  end_location:
+    row: 34
+    column: 4
+  fix: ~
+- kind:
+    EmptyMethodWithoutAbstractDecorator: AbstractClass
+  location:
+    row: 80
+    column: 4
+  end_location:
+    row: 83
+    column: 4
+  fix: ~
+- kind:
+    EmptyMethodWithoutAbstractDecorator: AbstractClass
+  location:
+    row: 84
+    column: 4
+  end_location:
+    row: 87
+    column: 4
+  fix: ~
+

src/snapshots/ruff__linter__tests__D400_D.py.snap

@@ -2,30 +2,6 @@
 source: src/linter.rs
 expression: checks
 ---
-- kind: EndsInPeriod
-  location:
-    row: 124
-    column: 4
-  end_location:
-    row: 126
-    column: 7
-  fix: ~
-- kind: EndsInPeriod
-  location:
-    row: 283
-    column: 4
-  end_location:
-    row: 283
-    column: 33
-  fix: ~
-- kind: EndsInPeriod
-  location:
-    row: 288
-    column: 4
-  end_location:
-    row: 288
-    column: 37
-  fix: ~
 - kind: EndsInPeriod
   location:
     row: 350

src/snapshots/ruff__linter__tests__D415_D.py.snap

@@ -2,30 +2,6 @@
 source: src/linter.rs
 expression: checks
 ---
-- kind: EndsInPunctuation
-  location:
-    row: 124
-    column: 4
-  end_location:
-    row: 126
-    column: 7
-  fix: ~
-- kind: EndsInPunctuation
-  location:
-    row: 283
-    column: 4
-  end_location:
-    row: 283
-    column: 33
-  fix: ~
-- kind: EndsInPunctuation
-  location:
-    row: 288
-    column: 4
-  end_location:
-    row: 288
-    column: 37
-  fix: ~
 - kind: EndsInPunctuation
   location:
     row: 350

src/snapshots/ruff__linter__tests__F401_F401_6.py.snap

@@ -0,0 +1,85 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UnusedImport:
+      - - background.BackgroundTasks
+      - false
+  location:
+    row: 7
+    column: 0
+  end_location:
+    row: 7
+    column: 39
+  fix:
+    patch:
+      content: ""
+      location:
+        row: 7
+        column: 0
+      end_location:
+        row: 8
+        column: 0
+    applied: false
+- kind:
+    UnusedImport:
+      - - datastructures.UploadFile
+      - false
+  location:
+    row: 10
+    column: 0
+  end_location:
+    row: 10
+    column: 52
+  fix:
+    patch:
+      content: ""
+      location:
+        row: 10
+        column: 0
+      end_location:
+        row: 11
+        column: 0
+    applied: false
+- kind:
+    UnusedImport:
+      - - background
+      - false
+  location:
+    row: 17
+    column: 0
+  end_location:
+    row: 17
+    column: 17
+  fix:
+    patch:
+      content: ""
+      location:
+        row: 17
+        column: 0
+      end_location:
+        row: 18
+        column: 0
+    applied: false
+- kind:
+    UnusedImport:
+      - - datastructures
+      - false
+  location:
+    row: 20
+    column: 0
+  end_location:
+    row: 20
+    column: 35
+  fix:
+    patch:
+      content: ""
+      location:
+        row: 20
+        column: 0
+      end_location:
+        row: 21
+        column: 0
+    applied: false
+

src/snapshots/ruff__linter__tests__N806_N806.py.snap

@@ -5,19 +5,19 @@ expression: checks
 - kind:
     NonLowercaseVariableInFunction: Camel
   location:
-    row: 3
+    row: 7
     column: 4
   end_location:
-    row: 3
+    row: 7
     column: 9
   fix: ~
 - kind:
     NonLowercaseVariableInFunction: CONSTANT
   location:
-    row: 4
+    row: 8
     column: 4
   end_location:
-    row: 4
+    row: 8
     column: 12
   fix: ~
 

src/snapshots/ruff__linter__tests__N815_N815.py.snap

@@ -5,28 +5,28 @@ expression: checks
 - kind:
     MixedCaseVariableInClassScope: mixedCase
   location:
-    row: 4
+    row: 8
     column: 4
   end_location:
-    row: 4
+    row: 8
     column: 13
   fix: ~
 - kind:
     MixedCaseVariableInClassScope: _mixedCase
   location:
-    row: 5
+    row: 9
     column: 4
   end_location:
-    row: 5
+    row: 9
     column: 14
   fix: ~
 - kind:
     MixedCaseVariableInClassScope: mixed_Case
   location:
-    row: 6
+    row: 10
     column: 4
   end_location:
-    row: 6
+    row: 10
     column: 14
   fix: ~
 

src/snapshots/ruff__linter__tests__N816_N816.py.snap

@@ -5,28 +5,28 @@ expression: checks
 - kind:
     MixedCaseVariableInGlobalScope: mixedCase
   location:
-    row: 3
+    row: 6
     column: 0
   end_location:
-    row: 3
+    row: 6
     column: 9
   fix: ~
 - kind:
     MixedCaseVariableInGlobalScope: _mixedCase
   location:
-    row: 4
+    row: 7
     column: 0
   end_location:
-    row: 4
+    row: 7
     column: 10
   fix: ~
 - kind:
     MixedCaseVariableInGlobalScope: mixed_Case
   location:
-    row: 5
+    row: 8
     column: 0
   end_location:
-    row: 5
+    row: 8
     column: 10
   fix: ~
 

tests/integration_test.rs

@@ -6,7 +6,7 @@ use assert_cmd::{crate_name, Command};
 #[test]
 fn test_stdin_success() -> Result<()> {
     let mut cmd = Command::cargo_bin(crate_name!())?;
-    cmd.args(&["-"]).write_stdin("").assert().success();
+    cmd.args(["-"]).write_stdin("").assert().success();
     Ok(())
 }
 
@@ -14,7 +14,7 @@ fn test_stdin_success() -> Result<()> {
 fn test_stdin_error() -> Result<()> {
     let mut cmd = Command::cargo_bin(crate_name!())?;
     let output = cmd
-        .args(&["-"])
+        .args(["-"])
         .write_stdin("import os\n")
         .assert()
         .failure();
@@ -26,7 +26,7 @@ fn test_stdin_error() -> Result<()> {
 fn test_stdin_filename() -> Result<()> {
     let mut cmd = Command::cargo_bin(crate_name!())?;
     let output = cmd
-        .args(&["-", "--stdin-filename", "F401.py"])
+        .args(["-", "--stdin-filename", "F401.py"])
         .write_stdin("import os\n")
         .assert()
         .failure();
@@ -38,7 +38,7 @@ fn test_stdin_filename() -> Result<()> {
 fn test_stdin_autofix() -> Result<()> {
     let mut cmd = Command::cargo_bin(crate_name!())?;
     let output = cmd
-        .args(&["-", "--fix"])
+        .args(["-", "--fix"])
         .write_stdin("import os\nimport sys\n\nprint(sys.version)\n")
         .assert()
         .success();
@@ -53,7 +53,7 @@ fn test_stdin_autofix() -> Result<()> {
 fn test_stdin_autofix_when_not_fixable_should_still_print_contents() -> Result<()> {
     let mut cmd = Command::cargo_bin(crate_name!())?;
     let output = cmd
-        .args(&["-", "--fix"])
+        .args(["-", "--fix"])
         .write_stdin("import os\nimport sys\n\nif (1, 2):\n     print(sys.version)\n")
         .assert()
         .failure();
@@ -68,7 +68,7 @@ fn test_stdin_autofix_when_not_fixable_should_still_print_contents() -> Result<(
 fn test_stdin_autofix_when_no_issues_should_still_print_contents() -> Result<()> {
     let mut cmd = Command::cargo_bin(crate_name!())?;
     let output = cmd
-        .args(&["-", "--fix"])
+        .args(["-", "--fix"])
         .write_stdin("import sys\n\nprint(sys.version)\n")
         .assert()
         .success();