Bump version to 0.0.252 (#3142)

Fix isort no-lines-before preceded by an empty section

Fix #3138.

.gitattributes

@@ -0,0 +1,6 @@
+* text=auto eol=lf
+
+crates/ruff/resources/test/fixtures/isort/line_ending_crlf.py text eol=crlf
+crates/ruff/resources/test/fixtures/pycodestyle/W605_1.py text eol=crlf
+
+ruff.schema.json linguist-generated=true text=auto eol=lf

.pre-commit-config.yaml

@@ -1,3 +1,4 @@
+fail_fast: true
 repos:
   - repo: https://github.com/abravalheri/validate-pyproject
     rev: v0.10.1
@@ -12,6 +13,7 @@ repos:
           - --disable
           - MD013 # line-length
           - MD033 # no-inline-html
+          - MD041 # first-line-h1
           - --
 
   - repo: local
@@ -28,11 +30,15 @@ repos:
         pass_filenames: false
       - id: ruff
         name: ruff
-        entry: cargo run -- --no-cache --fix
+        entry: cargo run -p ruff_cli -- check --no-cache --force-exclude --fix --exit-non-zero-on-fix
         language: rust
         types_or: [python, pyi]
         require_serial: true
-        exclude: ^crates/ruff/resources
+        exclude: |
+          (?x)^(
+            crates/ruff/resources/.*|
+            crates/ruff_python_formatter/resources/.*
+          )$
       - id: dev-generate-all
         name: dev-generate-all
         entry: cargo dev generate-all

CODE_OF_CONDUCT.md

@@ -1,16 +1,16 @@
 # Contributor Covenant Code of Conduct
 
-- [Our Pledge](#our-pledge)
-- [Our Standards](#our-standards)
-- [Enforcement Responsibilities](#enforcement-responsibilities)
-- [Scope](#scope)
-- [Enforcement](#enforcement)
-- [Enforcement Guidelines](#enforcement-guidelines)
-  - [1. Correction](#1-correction)
-  - [2. Warning](#2-warning)
-  - [3. Temporary Ban](#3-temporary-ban)
-  - [4. Permanent Ban](#4-permanent-ban)
-- [Attribution](#attribution)
+* [Our Pledge](#our-pledge)
+* [Our Standards](#our-standards)
+* [Enforcement Responsibilities](#enforcement-responsibilities)
+* [Scope](#scope)
+* [Enforcement](#enforcement)
+* [Enforcement Guidelines](#enforcement-guidelines)
+  * [1. Correction](#1-correction)
+  * [2. Warning](#2-warning)
+  * [3. Temporary Ban](#3-temporary-ban)
+  * [4. Permanent Ban](#4-permanent-ban)
+* [Attribution](#attribution)
 
 ## Our Pledge
 

CONTRIBUTING.md

@@ -2,16 +2,16 @@
 
 Welcome! We're happy to have you here. Thank you in advance for your contribution to Ruff.
 
-- [The Basics](#the-basics)
-  - [Prerequisites](#prerequisites)
-  - [Development](#development)
-  - [Project Structure](#project-structure)
-  - [Example: Adding a new lint rule](#example-adding-a-new-lint-rule)
-    - [Rule naming convention](#rule-naming-convention)
-  - [Example: Adding a new configuration option](#example-adding-a-new-configuration-option)
-- [MkDocs](#mkdocs)
-- [Release Process](#release-process)
-- [Benchmarks](#benchmarks)
+* [The Basics](#the-basics)
+  * [Prerequisites](#prerequisites)
+  * [Development](#development)
+  * [Project Structure](#project-structure)
+  * [Example: Adding a new lint rule](#example-adding-a-new-lint-rule)
+    * [Rule naming convention](#rule-naming-convention)
+  * [Example: Adding a new configuration option](#example-adding-a-new-configuration-option)
+* [MkDocs](#mkdocs)
+* [Release Process](#release-process)
+* [Benchmarks](#benchmarks)
 
 ## The Basics
 
@@ -29,13 +29,10 @@ If you're looking for a place to start, we recommend implementing a new lint rul
 pattern-match against the examples in the existing codebase. Many lint rules are inspired by
 existing Python plugins, which can be used as a reference implementation.
 
-As a concrete example: consider taking on one of the rules from the [`tryceratops`](https://github.com/charliermarsh/ruff/issues/2056)
-plugin, and looking to the originating [Python source](https://github.com/guilatrova/tryceratops)
+As a concrete example: consider taking on one of the rules from the [`flake8-pyi`](https://github.com/charliermarsh/ruff/issues/848)
+plugin, and looking to the originating [Python source](https://github.com/PyCQA/flake8-pyi)
 for guidance.
 
-Alternatively, we've started work on the [`flake8-pyi`](https://github.com/charliermarsh/ruff/issues/848)
-plugin (see the [Python source](https://github.com/PyCQA/flake8-pyi)) -- another good place to start.
-
 ### Prerequisites
 
 Ruff is written in Rust. You'll need to install the
@@ -52,7 +49,7 @@ cargo install cargo-insta
 After cloning the repository, run Ruff locally with:
 
 ```shell
-cargo run check /path/to/file.py --no-cache
+cargo run -p ruff_cli -- check /path/to/file.py --no-cache
 ```
 
 Prior to opening a pull request, ensure that your code has been auto-formatted,
@@ -94,12 +91,12 @@ The vast majority of the code, including all lint rules, lives in the `ruff` cra
 
 At time of writing, the repository includes the following crates:
 
-- `crates/ruff`: library crate containing all lint rules and the core logic for running them.
-- `crates/ruff_cli`: binary crate containing Ruff's command-line interface.
-- `crates/ruff_dev`: binary crate containing utilities used in the development of Ruff itself (e.g., `cargo dev generate-all`).
-- `crates/ruff_macros`: library crate containing macros used by Ruff.
-- `crates/ruff_python`: library crate implementing Python-specific functionality (e.g., lists of standard library modules by versionb).
-- `crates/flake8_to_ruff`: binary crate for generating Ruff configuration from Flake8 configuration.
+* `crates/ruff`: library crate containing all lint rules and the core logic for running them.
+* `crates/ruff_cli`: binary crate containing Ruff's command-line interface.
+* `crates/ruff_dev`: binary crate containing utilities used in the development of Ruff itself (e.g., `cargo dev generate-all`).
+* `crates/ruff_macros`: library crate containing macros used by Ruff.
+* `crates/ruff_python`: library crate implementing Python-specific functionality (e.g., lists of standard library modules by versionb).
+* `crates/flake8_to_ruff`: binary crate for generating Ruff configuration from Flake8 configuration.
 
 ### Example: Adding a new lint rule
 
@@ -135,7 +132,7 @@ contain a variety of violations and non-violations designed to evaluate and demo
 of your lint rule.
 
 Run `cargo dev generate-all` to generate the code for your new fixture. Then run Ruff
-locally with (e.g.) `cargo run check crates/ruff/resources/test/fixtures/pycodestyle/E402.py --no-cache --select E402`.
+locally with (e.g.) `cargo run -p ruff_cli -- check crates/ruff/resources/test/fixtures/pycodestyle/E402.py --no-cache --select E402`.
 
 Once you're satisfied with the output, codify the behavior as a snapshot test by adding a new
 `test_case` macro in the relevant `crates/ruff/src/[linter]/mod.rs` file. Then, run `cargo test --all`.
@@ -146,7 +143,7 @@ Finally, regenerate the documentation and generated code with `cargo dev generat
 
 #### Rule naming convention
 
-The rule name should make sense when read as "allow *rule-name*" or "allow *rule-name* items".
+The rule name should make sense when read as "allow _rule-name_" or "allow _rule-name_ items".
 
 This implies that rule names:
 
@@ -186,14 +183,19 @@ Finally, regenerate the documentation and generated code with `cargo dev generat
 To preview any changes to the documentation locally:
 
 1. Install MkDocs and Material for MkDocs with:
+
    ```shell
    pip install -r docs/requirements.txt
    ```
+
 2. Generate the MkDocs site with:
+
    ```shell
    python scripts/generate_mkdocs.py
    ```
+
 3. Run the development server with:
+
    ```shell
    mkdocs serve
    ```

Cargo.toml

@@ -1,6 +1,9 @@
 [workspace]
 members = ["crates/*"]
-default-members = ["crates/ruff", "crates/ruff_cli"]
+
+[workspace.package]
+edition = "2021"
+rust-version = "1.67.0"
 
 [workspace.dependencies]
 anyhow = { version = "1.0.66" }
@@ -10,8 +13,8 @@ libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a87
 once_cell = { version = "1.16.0" }
 regex = { version = "1.6.0" }
 rustc-hash = { version = "1.1.0" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "61b48f108982d865524f86624a9d5bc2ae3bccef" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "61b48f108982d865524f86624a9d5bc2ae3bccef" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "edf5995a1e4c366976304ca05432dd27c913054e" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "edf5995a1e4c366976304ca05432dd27c913054e" }
 schemars = { version = "0.8.11" }
 serde = { version = "1.0.147", features = ["derive"] }
 serde_json = { version = "1.0.87" }

_typos.toml

@@ -4,3 +4,4 @@ extend-exclude = ["snapshots", "black"]
 [default.extend-words]
 trivias = "trivias"
 hel = "hel"
+whos = "whos"

crates/flake8_to_ruff/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.247"
-edition = "2021"
+version = "0.0.252"
+edition = { workspace = true }
+rust-version = { workspace = true }
 
 [dependencies]
 anyhow = { workspace = true }

crates/ruff/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "ruff"
-version = "0.0.247"
+version = "0.0.252"
 authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
-edition = "2021"
-rust-version = "1.65.0"
+edition = { workspace = true }
+rust-version = { workspace = true }
 documentation = "https://github.com/charliermarsh/ruff"
 homepage = "https://github.com/charliermarsh/ruff"
 repository = "https://github.com/charliermarsh/ruff"
@@ -57,7 +57,6 @@ titlecase = { version = "2.2.1" }
 toml = { workspace = true }
 
 # https://docs.rs/getrandom/0.2.7/getrandom/#webassembly-support
-# For (future) wasm-pack support
 [target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
 getrandom = { version = "0.2.7", features = ["js"] }
 console_error_panic_hook = { version = "0.1.7" }
@@ -66,9 +65,6 @@ serde-wasm-bindgen = { version = "0.4" }
 js-sys = { version = "0.3.60" }
 wasm-bindgen = { version = "0.2.83" }
 
-[target.'cfg(not(target_family = "wasm"))'.dependencies]
-is_executable = "1.0.1"
-
 [dev-dependencies]
 insta = { version = "1.19.0", features = ["yaml", "redactions"] }
 test-case = { version = "2.2.2" }

crates/ruff/resources/test/fixtures/flake8_boolean_trap/FBT.py

@@ -57,6 +57,8 @@ dict.fromkeys(("world",), True)
 {}.deploy(True, False)
 getattr(someobj, attrname, False)
 mylist.index(True)
+int(True)
+str(int(False))
 
 
 class Registry:
@@ -66,3 +68,11 @@ class Registry:
     # FBT001: Boolean positional arg in function definition
     def __setitem__(self, switch: Switch, value: bool) -> None:
         self._switches[switch.value] = value
+
+    @foo.setter
+    def foo(self, value: bool) -> None:
+        pass
+
+    # FBT001: Boolean positional arg in function definition
+    def foo(self, value: bool) -> None:
+        pass

crates/ruff/resources/test/fixtures/flake8_bugbear/B005.py

@@ -20,6 +20,8 @@ s.rstrip(r"\n\t ")  # warning
 s.strip("a")  # no warning
 s.strip("あ")  # no warning
 s.strip("ああ")  # warning
+s.strip("\ufeff")  # no warning
+s.strip("\u0074\u0065\u0073\u0074")  # warning
 
 from somewhere import other_type, strip
 

crates/ruff/resources/test/fixtures/flake8_bugbear/B012.py

@@ -105,3 +105,25 @@ while True:
         pass
     finally:
         break  # warning
+
+
+while True:
+    try:
+        pass
+    finally:
+        match *0, 1, *2:
+            case 0,:
+                y = 0
+            case 0, *x:
+                break  # warning
+
+
+while True:
+    try:
+        pass
+    finally:
+        match *0, 1, *2:
+            case 0,:
+                y = 0
+            case 0, *x:
+                pass  # no warning

crates/ruff/resources/test/fixtures/flake8_bugbear/B027.pyi

@@ -0,0 +1,101 @@
+"""
+Should emit:
+B027 - on lines 13, 16, 19, 23
+"""
+import abc
+from abc import ABC
+from abc import abstractmethod, abstractproperty
+from abc import abstractmethod as notabstract
+from abc import abstractproperty as notabstract_property
+
+
+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 abstract_0(self):
+        ...
+
+    @abstractmethod
+    def abstract_1(self):
+        ...
+
+    @abstractmethod
+    def abstract_2(self):
+        pass
+
+    @abc.abstractmethod
+    def abstract_3(self):
+        ...
+
+    @abc.abstractproperty
+    def abstract_4(self):
+        ...
+
+    @abstractproperty
+    def abstract_5(self):
+        ...
+
+    @notabstract_property
+    def abstract_6(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]):
+        ...

crates/ruff/resources/test/fixtures/flake8_bugbear/B029.py

@@ -0,0 +1,14 @@
+"""
+Should emit:
+B029 - on lines 8 and 13
+"""
+
+try:
+    pass
+except ():
+    pass
+
+try:
+    pass
+except () as e:
+    pass

crates/ruff/resources/test/fixtures/flake8_bugbear/B032.py

@@ -0,0 +1,29 @@
+"""
+Should emit:
+B032 - on lines 9, 10, 12, 13, 16-19
+"""
+
+# Flag these
+dct = {"a": 1}
+
+dct["b"]: 2
+dct.b: 2
+
+dct["b"]: "test"
+dct.b: "test"
+
+test = "test"
+dct["b"]: test
+dct["b"]: test.lower()
+dct.b: test
+dct.b: test.lower()
+
+# Do not flag below
+typed_dct: dict[str, int] = {"a": 1}
+typed_dct["b"] = 2
+typed_dct.b = 2
+
+
+class TestClass:
+    def test_self(self):
+        self.test: int

crates/ruff/resources/test/fixtures/flake8_bugbear/B904.py

@@ -62,3 +62,11 @@ except Exception as e:
         raise RuntimeError("boom!")
     else:
         raise RuntimeError("bang!")
+
+
+try:
+    ...
+except Exception as e:
+    match 0:
+        case 0:
+            raise RuntimeError("boom!")

crates/ruff/resources/test/fixtures/flake8_pie/PIE807.py

@@ -18,3 +18,10 @@ class Foo:
 
 class FooTable(BaseTable):
     bar = fields.ListField(list)
+
+
+lambda *args, **kwargs: []
+
+lambda *args: []
+
+lambda **kwargs: []

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT009.py

@@ -17,6 +17,12 @@ class Test(unittest.TestCase):
         self.assertTrue(**{"expr": expr, "msg": msg})  # Error, unfixable
         self.assertTrue(msg=msg, expr=expr, unexpected_arg=False)  # Error, unfixable
         self.assertTrue(msg=msg)  # Error, unfixable
+        (
+            self.assertIsNotNone(value)  # Error, unfixable
+            if expect_condition
+            else self.assertIsNone(value)  # Error, unfixable
+        )
+        return self.assertEqual(True,  False)  # Error, unfixable
 
     def test_assert_false(self):
         self.assertFalse(True)  # Error

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT018.py

@@ -6,6 +6,8 @@ def test_ok():
     assert something or something_else
     assert something or something_else and something_third
     assert not (something and something_else)
+    assert something, "something message"
+    assert something or something_else and something_third, "another message"
 
 
 def test_error():
@@ -13,6 +15,27 @@ def test_error():
     assert something and something_else and something_third
     assert something and not something_else
     assert something and (something_else or something_third)
+    assert not something and something_else
     assert not (something or something_else)
     assert not (something or something_else or something_third)
+    assert something and something_else == """error
+    message
+    """
+
+    # recursive case
+    assert not (a or not (b or c))  # note that we only reduce once here
+    assert not (a or not (b and c))
+
+    # detected, but no autofix for messages
+    assert something and something_else, "error message"
+    assert not (something or something_else and something_third), "with message"
+    # detected, but no autofix for mixed conditions (e.g. `a or b and c`)
     assert not (something or something_else and something_third)
+    # detected, but no autofix for parenthesized conditions
+    assert (
+        something
+        and something_else
+        == """error
+message
+"""
+    )

crates/ruff/resources/test/fixtures/flake8_return/RET503.py

@@ -3,6 +3,8 @@ import os
 import posix
 from posix import abort
 import sys as std_sys
+import typing
+import typing_extensions
 import _thread
 import _winapi
 
@@ -77,7 +79,7 @@ def x(y):
 
 # last line in while loop
 def x(y):
-    while True:
+    while i > 0:
         if y > 0:
             return 1
         y += 1
@@ -211,6 +213,18 @@ def noreturn_sys_exit():
     std_sys.exit(0)
 
 
+def noreturn_typing_assert_never():
+    if x > 0:
+        return 1
+    typing.assert_never(0)
+
+
+def noreturn_typing_extensions_assert_never():
+    if x > 0:
+        return 1
+    typing_extensions.assert_never(0)
+
+
 def noreturn__thread_exit():
     if x > 0:
         return 1
@@ -251,3 +265,31 @@ def noreturn_pytest_xfail_2():
     if x > 0:
         return 1
     py_xfail("oof")
+
+
+def nested(values):
+    if not values:
+        return False
+
+    for value in values:
+        print(value)
+
+
+def while_true():
+    while True:
+        if y > 0:
+            return 1
+        y += 1
+
+
+# match
+def x(y):
+    match y:
+        case 0:
+            return 1
+        case 1:
+            print()  # error
+
+
+def foo(baz: str) -> str:
+    return baz

crates/ruff/resources/test/fixtures/flake8_self/SLF001.py

@@ -56,12 +56,6 @@ class Foo(metaclass=BazMeta):
 
 foo = Foo()
 
-print(foo.public_thing)
-print(foo.public_func())
-print(foo.__dict__)
-print(foo.__str__())
-print(foo().__class__)
-
 print(foo._private_thing)  # SLF001
 print(foo.__really_private_thing)  # SLF001
 print(foo._private_func())  # SLF001
@@ -69,3 +63,10 @@ print(foo.__really_private_func(1))  # SLF001
 print(foo.bar._private)  # SLF001
 print(foo()._private_thing)  # SLF001
 print(foo()._private_thing__)  # SLF001
+
+print(foo.public_thing)
+print(foo.public_func())
+print(foo.__dict__)
+print(foo.__str__())
+print(foo().__class__)
+print(foo._asdict())

crates/ruff/resources/test/fixtures/flake8_simplify/SIM116.py

@@ -0,0 +1,76 @@
+# Errors
+a = "hello"
+
+# SIM116
+if a == "foo":
+    return "bar"
+elif a == "bar":
+    return "baz"
+elif a == "boo":
+    return "ooh"
+else:
+    return 42
+
+# SIM116
+if a == 1:
+    return (1, 2, 3)
+elif a == 2:
+    return (4, 5, 6)
+elif a == 3:
+    return (7, 8, 9)
+else:
+    return (10, 11, 12)
+
+# SIM116
+if a == 1:
+    return (1, 2, 3)
+elif a == 2:
+    return (4, 5, 6)
+elif a == 3:
+    return (7, 8, 9)
+
+# SIM116
+if a == "hello 'sir'":
+    return (1, 2, 3)
+elif a == 'goodbye "mam"':
+    return (4, 5, 6)
+elif a == """Fairwell 'mister'""":
+    return (7, 8, 9)
+else:
+    return (10, 11, 12)
+
+# SIM116
+if a == b"one":
+    return 1
+elif a == b"two":
+    return 2
+elif a == b"three":
+    return 3
+
+# SIM116
+if a == "hello 'sir'":
+    return ("hello'", 'hi"', 3)
+elif a == 'goodbye "mam"':
+    return (4, 5, 6)
+elif a == """Fairwell 'mister'""":
+    return (7, 8, 9)
+else:
+    return (10, 11, 12)
+
+# OK
+if a == "foo":
+    return "bar"
+elif a == "bar":
+    return baz()
+elif a == "boo":
+    return "ooh"
+else:
+    return 42
+
+# OK
+if a == b"one":
+    return 1
+elif b == b"two":
+    return 2
+elif a == b"three":
+    return 3

crates/ruff/resources/test/fixtures/flake8_tidy_imports/TID252/my_package/sublib/api/application.py

@@ -4,4 +4,5 @@ import attrs
 
 from ..protocol import commands, definitions, responses
 from ..server import example
+from .. import server
 from . import logger, models

crates/ruff/resources/test/fixtures/isort/force_to_top.py

@@ -0,0 +1,23 @@
+import lib6
+import lib2
+import lib5
+import lib1
+import lib3
+import lib4
+
+import foo
+import z
+from foo import bar
+from lib1 import foo
+from lib2 import foo
+from lib1.lib2 import foo
+from foo.lib1.bar import baz
+from lib4 import lib1
+from lib5 import lib2
+from lib4 import lib2
+from lib5 import lib1
+
+import lib3.lib4
+import lib3.lib4.lib5
+from lib3.lib4 import foo
+from lib3.lib4.lib5 import foo

crates/ruff/resources/test/fixtures/isort/line_ending_crlf.py

@@ -1,2 +1,2 @@
-from long_module_name import member_one, member_two, member_three, member_four, member_five
+from long_module_name import member_one, member_two, member_three, member_four, member_five
 

crates/ruff/resources/test/fixtures/isort/no_lines_before_with_empty_sections.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+from typing import Any
+from . import my_local_folder_object

crates/ruff/resources/test/fixtures/isort/pyproject.toml

@@ -5,3 +5,4 @@ line-length = 88
 lines-after-imports = 3
 lines-between-types = 2
 known-local-folder = ["ruff"]
+force-to-top = ["lib1", "lib3", "lib5", "lib3.lib4", "z"]

crates/ruff/resources/test/fixtures/isort/required_imports/multiline_docstring.py

@@ -0,0 +1,4 @@
+"""a
+b"""
+# b
+import os

crates/ruff/resources/test/fixtures/numpy/NPY002.py

@@ -0,0 +1,62 @@
+# Do this (new version)
+from numpy.random import default_rng
+rng = default_rng()
+vals = rng.standard_normal(10)
+more_vals = rng.standard_normal(10)
+numbers = rng.integers(high, size=5)
+
+# instead of this (legacy version)
+from numpy import random
+vals = random.standard_normal(10)
+more_vals = random.standard_normal(10)
+numbers = random.integers(high, size=5)
+
+import numpy
+numpy.random.seed()
+numpy.random.get_state()
+numpy.random.set_state()
+numpy.random.rand()
+numpy.random.randn()
+numpy.random.randint()
+numpy.random.random_integers()
+numpy.random.random_sample()
+numpy.random.choice()
+numpy.random.bytes()
+numpy.random.shuffle()
+numpy.random.permutation()
+numpy.random.beta()
+numpy.random.binomial()
+numpy.random.chisquare()
+numpy.random.dirichlet()
+numpy.random.exponential()
+numpy.random.f()
+numpy.random.gamma()
+numpy.random.geometric()
+numpy.random.get_state()
+numpy.random.gumbel()
+numpy.random.hypergeometric()
+numpy.random.laplace()
+numpy.random.logistic()
+numpy.random.lognormal()
+numpy.random.logseries()
+numpy.random.multinomial()
+numpy.random.multivariate_normal()
+numpy.random.negative_binomial()
+numpy.random.noncentral_chisquare()
+numpy.random.noncentral_f()
+numpy.random.normal()
+numpy.random.pareto()
+numpy.random.poisson()
+numpy.random.power()
+numpy.random.rayleigh()
+numpy.random.standard_cauchy()
+numpy.random.standard_exponential()
+numpy.random.standard_gamma()
+numpy.random.standard_normal()
+numpy.random.standard_t()
+numpy.random.triangular()
+numpy.random.uniform()
+numpy.random.vonmises()
+numpy.random.wald()
+numpy.random.weibull()
+numpy.random.zipf()

crates/ruff/resources/test/fixtures/pycodestyle/E70.py

@@ -54,3 +54,9 @@ def f(): ...
 class C: ...; x = 1
 #: E701:1:8 E702:1:13
 class C: ...; ...
+#: E701:2:12
+match *0, 1, *2:
+    case 0,: y = 0
+#:
+class Foo:
+    match: Optional[Match] = None

crates/ruff/resources/test/fixtures/pycodestyle/E731.py

@@ -9,6 +9,9 @@ while False:
 f = lambda: (yield 1)
 #: E731
 f = lambda: (yield from g())
+#: E731
+class F:
+    f = lambda x: 2 * x
 
 f = object()
 f.method = lambda: "Method"

crates/ruff/resources/test/fixtures/pycodestyle/W605_1.py

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

crates/ruff/resources/test/fixtures/pyflakes/F401_0.py

@@ -85,3 +85,10 @@ else:
 
 
 CustomInt: TypeAlias = "np.int8 | np.int16"
+
+
+# Test: match statements.
+match *0, 1, *2:
+    case 0,:
+        import x
+        import y

crates/ruff/resources/test/fixtures/pyflakes/F404.py

@@ -4,3 +4,5 @@ from __future__ import absolute_import
 from collections import namedtuple
 
 from __future__ import print_function
+
+import __future__

crates/ruff/resources/test/fixtures/pyflakes/F541.py

@@ -33,3 +33,11 @@ f"{f'{v:0.2f}'}"
 # Errors
 f"{v:{f'0.2f'}}"
 f"{f''}"
+f"{{test}}"
+f'{{ 40 }}'
+f"{{a {{x}}"
+f"{{{{x}}}}"
+
+# To be fixed
+# Error: f-string: single '}' is not allowed at line 41 column 8
+# f"\{{x}}"  

crates/ruff/resources/test/fixtures/pyflakes/F811_20.py

@@ -1,7 +1,7 @@
 """
- Test that shadowing a global with a class attribute does not produce a
- warning.
- """
+Test that shadowing a global with a class attribute does not produce a
+warning.
+"""
 
 import fu
 

crates/ruff/resources/test/fixtures/pyflakes/F821_9.py

@@ -0,0 +1,26 @@
+"""Test: match statements."""
+from dataclasses import dataclass
+
+
+@dataclass
+class Car:
+    make: str
+    model: str
+
+
+def f():
+    match Car("Toyota", "Corolla"):
+        case Car("Toyota", model):
+            print(model)
+        case Car(make, "Corolla"):
+            print(make)
+
+
+def f(provided: int) -> int:
+    match provided:
+        case True:
+            return captured  # F821
+        case [captured, *_]:
+            return captured
+        case captured:
+            return captured

crates/ruff/resources/test/fixtures/pyflakes/F841_0.py

@@ -71,7 +71,7 @@ def f():
     def connect():
         return None, None
 
-    with (connect() as (connection, cursor)):
+    with connect() as (connection, cursor):
         cursor.execute("SELECT * FROM users")
 
 
@@ -94,3 +94,30 @@ def f():
         (exponential := (exponential * base_multiplier) % 3): i + 1 for i in range(2)
     }
     return hash_map
+
+
+def f(x: int):
+    msg1 = "Hello, world!"
+    msg2 = "Hello, world!"
+    msg3 = "Hello, world!"
+    match x:
+        case 1:
+            print(msg1)
+        case 2:
+            print(msg2)
+
+
+def f(x: int):
+    import enum
+
+    Foo = enum.Enum("Foo", "A B")
+    Bar = enum.Enum("Bar", "A B")
+    Baz = enum.Enum("Baz", "A B")
+
+    match x:
+        case (Foo.A):
+            print("A")
+        case [Bar.A, *_]:
+            print("A")
+        case y:
+            pass

crates/ruff/resources/test/fixtures/pylint/logging_too_few_args.py

@@ -0,0 +1,12 @@
+import logging
+
+logging.warning("Hello %s %s", "World!")  # [logging-too-few-args]
+
+# do not handle calls with kwargs (like pylint)
+logging.warning("Hello %s", "World!", "again", something="else")
+
+logging.warning("Hello %s", "World!")
+
+import warning
+
+warning.warning("Hello %s %s", "World!")

crates/ruff/resources/test/fixtures/pylint/logging_too_many_args.py

@@ -0,0 +1,12 @@
+import logging
+
+logging.warning("Hello %s", "World!", "again")  # [logging-too-many-args]
+
+# do not handle calls with kwargs (like pylint)
+logging.warning("Hello %s", "World!", "again", something="else")
+
+logging.warning("Hello %s", "World!")
+
+import warning
+
+warning.warning("Hello %s", "World!", "again")

crates/ruff/resources/test/fixtures/pylint/redefined_loop_name.py

@@ -0,0 +1,155 @@
+# For -> for, variable reused
+for i in []:
+    for i in []:  # error
+        pass
+
+# With -> for, variable reused
+with None as i:
+    for i in []:  # error
+        pass
+
+# For -> with, variable reused
+for i in []:
+    with None as i:  # error
+        pass
+
+# With -> with, variable reused
+with None as i:
+    with None as i:  # error
+        pass
+
+# For -> for, different variable
+for i in []:
+    for j in []:  # ok
+        pass
+
+# With -> with, different variable
+with None as i:
+    with None as j:  # ok
+        pass
+
+# For -> for -> for, doubly nested variable reuse
+for i in []:
+    for j in []:
+        for i in []:  # error
+            pass
+
+# For -> for -> for -> for, doubly nested variable reuse x2
+for i in []:
+    for j in []:
+        for i in []:  # error
+            for j in []:  # error
+                pass
+
+# For -> assignment
+for i in []:
+    i = 5  # error
+
+# For -> augmented assignment
+for i in []:
+    i += 5  # error
+
+# For -> annotated assignment
+for i in []:
+    i: int = 5  # error
+
+# Async for -> for, variable reused
+async for i in []:
+    for i in []:  # error
+        pass
+
+# For -> async for, variable reused
+for i in []:
+    async for i in []:  # error
+        pass
+
+# For -> for, outer loop unpacks tuple
+for i, j in enumerate([]):
+    for i in []:  # error
+        pass
+
+# For -> for, inner loop unpacks tuple
+for i in []:
+    for i, j in enumerate([]):  # error
+        pass
+
+# For -> for, both loops unpack tuple
+for (i, (j, k)) in []:
+    for i, j in enumerate([]):  # two errors
+        pass
+
+# For else -> for, variable reused in else
+for i in []:
+    pass
+else:
+    for i in []:  # no error
+        pass
+
+# For -> for, ignore dummy variables
+for _ in []:
+    for _ in []:  # no error
+        pass
+
+# For -> for, outer loop unpacks with asterisk
+for i, *j in []:
+    for j in []:  # error
+        pass
+
+# For -> function definition
+for i in []:
+    def f():
+        i = 2  # no error
+
+# For -> class definition
+for i in []:
+    class A:
+        i = 2  # no error
+
+# For -> function definition -> for -> assignment
+for i in []:
+    def f():
+        for i in []:  # no error
+            i = 2  # error
+
+# For -> class definition -> for -> for
+for i in []:
+    class A:
+        for i in []:  # no error
+            for i in []:  # error
+                pass
+
+# For -> use in assignment target without actual assignment; subscript
+for i in []:
+    a[i] = 2  # no error
+    i[a] = 2  # no error
+
+# For -> use in assignment target without actual assignment; attribute
+for i in []:
+    a.i = 2  # no error
+    i.a = 2  # no error
+
+# For target with subscript -> assignment
+for a[0] in []:
+    a[0] = 2  # error
+    a[1] = 2  # no error
+
+# For target with subscript -> assignment
+for a['i'] in []:
+    a['i'] = 2  # error
+    a['j'] = 2  # no error
+
+# For target with attribute -> assignment
+for a.i in []:
+    a.i = 2  # error
+    a.j = 2  # no error
+
+# For target with double nested attribute -> assignment
+for a.i.j in []:
+    a.i.j = 2  # error
+    a.j.i = 2  # no error
+
+# For target with attribute -> assignment with different spacing
+for a.i in []:
+    a. i = 2  # error
+for a. i in []:
+    a.i = 2  # error

crates/ruff/resources/test/fixtures/pylint/return_in_init.py

@@ -0,0 +1,41 @@
+def a():
+    return
+
+def __init__():
+    return
+
+class A:
+    def __init__(self):
+        return
+
+
+class B:
+    def __init__(self):
+        return 3
+
+    def gen(self):
+        return 5
+
+class MyClass:
+
+    def __init__(self):
+        return 1
+
+class MyClass2:
+    """dummy class"""
+
+    def __init__(self):
+        return
+
+
+class MyClass3:
+    """dummy class"""
+
+    def __init__(self):
+        return None
+
+class MyClass5:
+    """dummy class"""
+
+    def __init__(self):
+        self.callable = lambda: (yield None)

crates/ruff/resources/test/fixtures/pylint/useless_else_on_loop.py

@@ -113,3 +113,25 @@ def test_break_in_if_orelse():
     else:
         return True
     return False
+
+
+def test_break_in_with():
+    """no false positive for break in with"""
+    for name in ["demo"]:
+        with open(__file__) as f:
+            if name in f.read():
+                break
+    else:
+        return True
+    return False
+
+
+def test_break_in_match():
+    """no false positive for break in match"""
+    for name in ["demo"]:
+        match name:
+            case "demo":
+                break
+    else:
+        return True
+    return False

crates/ruff/resources/test/fixtures/ruff/RUF006.py

@@ -6,6 +6,11 @@ def f():
     asyncio.create_task(coordinator.ws_connect())  # Error
 
 
+# Error
+def f():
+    asyncio.ensure_future(coordinator.ws_connect())  # Error
+
+
 # OK
 def f():
     background_tasks = set()
@@ -22,6 +27,22 @@ def f():
         task.add_done_callback(background_tasks.discard)
 
 
+# OK
+def f():
+    background_tasks = set()
+
+    for i in range(10):
+        task = asyncio.ensure_future(some_coro(param=i))
+
+        # Add task to the set. This creates a strong reference.
+        background_tasks.add(task)
+
+        # To prevent keeping references to finished tasks forever,
+        # make each task remove its own reference from the set after
+        # completion:
+        task.add_done_callback(background_tasks.discard)
+
+
 # OK
 def f():
     ctx.task = asyncio.create_task(make_request())

crates/ruff/resources/test/fixtures/ruff/ruff_targeted_noqa.py

@@ -0,0 +1,8 @@
+# ruff: noqa: F401
+
+import os
+import foo
+
+
+def f():
+    x = 1

crates/ruff/resources/test/fixtures/tryceratops/TRY301.py

@@ -20,6 +20,24 @@ def bad():
         logger.exception("something failed")
 
 
+def bad():
+    try:
+        a = process()
+        if not a:
+            raise MyException(a)
+
+        raise MyException(a)
+
+        try:
+            b = process()
+            if not b:
+                raise MyException(b)
+        except* Exception:
+            logger.exception("something failed")
+    except* Exception:
+        logger.exception("something failed")
+
+
 def good():
     try:
         a = process()  # This throws the exception now

crates/ruff/resources/test/fixtures/tryceratops/TRY401.py

@@ -0,0 +1,64 @@
+# Errors
+def main_function():
+    try:
+        process()
+        handle()
+        finish()
+    except Exception as ex:
+        logger.exception(f"Found an error: {ex}")  # TRY401
+
+
+def main_function():
+    try:
+        process()
+        handle()
+        finish()
+    except ValueError as bad:
+        if True is False:
+            for i in range(10):
+                logger.exception(f"Found an error: {bad} {good}")  # TRY401
+    except IndexError as bad:
+        logger.exception(f"Found an error: {bad} {bad}")  # TRY401
+    except Exception as bad:
+        logger.exception(f"Found an error: {bad}")  # TRY401
+        logger.exception(f"Found an error: {bad}")  # TRY401
+
+        if True:
+            logger.exception(f"Found an error: {bad}")  # TRY401
+
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def func_fstr():
+    try:
+        ...
+    except Exception as ex:
+        logger.exception(f"Logging an error: {ex}")  # TRY401
+
+
+def func_concat():
+    try:
+        ...
+    except Exception as ex:
+        logger.exception("Logging an error: " + str(ex))  # TRY401
+
+
+def func_comma():
+    try:
+        ...
+    except Exception as ex:
+        logger.exception("Logging an error:", ex)  # TRY401
+
+
+# OK
+def main_function():
+    try:
+        process()
+        handle()
+        finish()
+    except Exception as ex:
+        logger.exception(f"Found an error: {er}")
+        logger.exception(f"Found an error: {ex.field}")

crates/ruff/resources/test/project/README.md

@@ -8,14 +8,14 @@ behaviors.
 Running from the repo root should pick up and enforce the appropriate settings for each package:
 
 ```console
-∴ cargo run resources/test/project/
-resources/test/project/examples/.dotfiles/script.py:1:1: I001 Import block is un-sorted or un-formatted
-resources/test/project/examples/.dotfiles/script.py:1:8: F401 `numpy` imported but unused
-resources/test/project/examples/.dotfiles/script.py:2:17: F401 `app.app_file` imported but unused
-resources/test/project/examples/docs/docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
-resources/test/project/examples/docs/docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
-resources/test/project/project/file.py:1:8: F401 `os` imported but unused
-resources/test/project/project/import_file.py:1:1: I001 Import block is un-sorted or un-formatted
+∴ cargo run -p ruff_cli -- check crates/ruff/resources/test/project/
+crates/ruff/resources/test/project/examples/.dotfiles/script.py:1:1: I001 Import block is un-sorted or un-formatted
+crates/ruff/resources/test/project/examples/.dotfiles/script.py:1:8: F401 `numpy` imported but unused
+crates/ruff/resources/test/project/examples/.dotfiles/script.py:2:17: F401 `app.app_file` imported but unused
+crates/ruff/resources/test/project/examples/docs/docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
+crates/ruff/resources/test/project/examples/docs/docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
+crates/ruff/resources/test/project/project/file.py:1:8: F401 `os` imported but unused
+crates/ruff/resources/test/project/project/import_file.py:1:1: I001 Import block is un-sorted or un-formatted
 Found 7 errors.
 7 potentially fixable with the --fix option.
 ```
@@ -23,7 +23,7 @@ Found 7 errors.
 Running from the project directory itself should exhibit the same behavior:
 
 ```console
-∴ (cd resources/test/project/ && cargo run .)
+∴ (cd crates/ruff/resources/test/project/ && cargo run -p ruff_cli -- check .)
 examples/.dotfiles/script.py:1:1: I001 Import block is un-sorted or un-formatted
 examples/.dotfiles/script.py:1:8: F401 `numpy` imported but unused
 examples/.dotfiles/script.py:2:17: F401 `app.app_file` imported but unused
@@ -39,7 +39,7 @@ Running from the sub-package directory should exhibit the same behavior, but omi
 files:
 
 ```console
-∴ (cd resources/test/project/examples/docs && cargo run .)
+∴ (cd crates/ruff/resources/test/project/examples/docs && cargo run -p ruff_cli -- check .)
 docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
 docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
 Found 2 errors.
@@ -50,16 +50,16 @@ Found 2 errors.
 file paths from the current working directory:
 
 ```console
-∴ (cargo run -- --config=resources/test/project/pyproject.toml resources/test/project/)
-resources/test/project/examples/.dotfiles/script.py:1:8: F401 `numpy` imported but unused
-resources/test/project/examples/.dotfiles/script.py:2:17: F401 `app.app_file` imported but unused
-resources/test/project/examples/docs/docs/concepts/file.py:1:8: F401 `os` imported but unused
-resources/test/project/examples/docs/docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
-resources/test/project/examples/docs/docs/file.py:1:8: F401 `os` imported but unused
-resources/test/project/examples/docs/docs/file.py:3:8: F401 `numpy` imported but unused
-resources/test/project/examples/docs/docs/file.py:4:27: F401 `docs.concepts.file` imported but unused
-resources/test/project/examples/excluded/script.py:1:8: F401 `os` imported but unused
-resources/test/project/project/file.py:1:8: F401 `os` imported but unused
+∴ (cargo run -p ruff_cli -- check --config=crates/ruff/resources/test/project/pyproject.toml crates/ruff/resources/test/project/)
+crates/ruff/resources/test/project/examples/.dotfiles/script.py:1:8: F401 `numpy` imported but unused
+crates/ruff/resources/test/project/examples/.dotfiles/script.py:2:17: F401 `app.app_file` imported but unused
+crates/ruff/resources/test/project/examples/docs/docs/concepts/file.py:1:8: F401 `os` imported but unused
+crates/ruff/resources/test/project/examples/docs/docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
+crates/ruff/resources/test/project/examples/docs/docs/file.py:1:8: F401 `os` imported but unused
+crates/ruff/resources/test/project/examples/docs/docs/file.py:3:8: F401 `numpy` imported but unused
+crates/ruff/resources/test/project/examples/docs/docs/file.py:4:27: F401 `docs.concepts.file` imported but unused
+crates/ruff/resources/test/project/examples/excluded/script.py:1:8: F401 `os` imported but unused
+crates/ruff/resources/test/project/project/file.py:1:8: F401 `os` imported but unused
 Found 9 errors.
 9 potentially fixable with the --fix option.
 ```
@@ -68,7 +68,7 @@ Running from a parent directory should "ignore" the `exclude` (hence, `concepts/
 included in the output):
 
 ```console
-∴ (cd resources/test/project/examples && cargo run -- --config=docs/ruff.toml .)
+∴ (cd crates/ruff/resources/test/project/examples && cargo run -p ruff_cli -- check --config=docs/ruff.toml .)
 docs/docs/concepts/file.py:5:5: F841 Local variable `x` is assigned to but never used
 docs/docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
 docs/docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
@@ -80,8 +80,8 @@ Found 4 errors.
 Passing an excluded directory directly should report errors in the contained files:
 
 ```console
-∴ cargo run resources/test/project/examples/excluded/
-resources/test/project/examples/excluded/script.py:1:8: F401 `os` imported but unused
+∴ cargo run -p ruff_cli -- check crates/ruff/resources/test/project/examples/excluded/
+crates/ruff/resources/test/project/examples/excluded/script.py:1:8: F401 `os` imported but unused
 Found 1 error.
 1 potentially fixable with the --fix option.
 ```
@@ -89,8 +89,8 @@ Found 1 error.
 Unless we `--force-exclude`:
 
 ```console
-∴ cargo run resources/test/project/examples/excluded/ --force-exclude
+∴ cargo run -p ruff_cli -- check crates/ruff/resources/test/project/examples/excluded/ --force-exclude
 warning: No Python files found under the given path(s)
-∴ cargo run resources/test/project/examples/excluded/script.py --force-exclude
+∴ cargo run -p ruff_cli -- check crates/ruff/resources/test/project/examples/excluded/script.py --force-exclude
 warning: No Python files found under the given path(s)
 ```

crates/ruff/src/assert_yaml_snapshot.rs

@@ -1,18 +0,0 @@
-/// Platform-independent snapshot assertion
-#[macro_export]
-macro_rules! assert_yaml_snapshot {
-    ( $($args: expr),+) => {
-        let line_sep = if cfg!(windows) { "\r\n" } else { "\n" };
-
-        // adjust snapshot file for platform
-        let mut settings = insta::Settings::clone_current();
-        settings.add_redaction("[].fix.content", insta::dynamic_redaction(move |value, _path| {
-            insta::internals::Content::Seq(
-                value.as_str().unwrap().split(line_sep).map(|line| line.into()).collect()
-            )
-        }));
-        settings.bind(|| {
-            insta::assert_yaml_snapshot!($($args),+);
-        });
-    };
-}

crates/ruff/src/ast/branch_detection.rs

@@ -59,6 +59,12 @@ fn alternatives<'a>(stmt: &'a RefEquality<'a, Stmt>) -> Vec<Vec<RefEquality<'a,
             handlers,
             orelse,
             ..
+        }
+        | StmtKind::TryStar {
+            body,
+            handlers,
+            orelse,
+            ..
         } => vec![body.iter().chain(orelse.iter()).map(RefEquality).collect()]
             .into_iter()
             .chain(handlers.iter().map(|handler| {

crates/ruff/src/ast/comparable.rs

@@ -4,8 +4,8 @@
 use num_bigint::BigInt;
 use rustpython_parser::ast::{
     Alias, Arg, Arguments, Boolop, Cmpop, Comprehension, Constant, Excepthandler,
-    ExcepthandlerKind, Expr, ExprContext, ExprKind, Keyword, Operator, Stmt, StmtKind, Unaryop,
-    Withitem,
+    ExcepthandlerKind, Expr, ExprContext, ExprKind, Keyword, MatchCase, Operator, Pattern,
+    PatternKind, Stmt, StmtKind, Unaryop, Withitem,
 };
 
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -157,6 +157,110 @@ impl<'a> From<&'a Withitem> for ComparableWithitem<'a> {
     }
 }
 
+#[allow(clippy::enum_variant_names)]
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub enum ComparablePattern<'a> {
+    MatchValue {
+        value: ComparableExpr<'a>,
+    },
+    MatchSingleton {
+        value: ComparableConstant<'a>,
+    },
+    MatchSequence {
+        patterns: Vec<ComparablePattern<'a>>,
+    },
+    MatchMapping {
+        keys: Vec<ComparableExpr<'a>>,
+        patterns: Vec<ComparablePattern<'a>>,
+        rest: Option<&'a str>,
+    },
+    MatchClass {
+        cls: ComparableExpr<'a>,
+        patterns: Vec<ComparablePattern<'a>>,
+        kwd_attrs: Vec<&'a str>,
+        kwd_patterns: Vec<ComparablePattern<'a>>,
+    },
+    MatchStar {
+        name: Option<&'a str>,
+    },
+    MatchAs {
+        pattern: Option<Box<ComparablePattern<'a>>>,
+        name: Option<&'a str>,
+    },
+    MatchOr {
+        patterns: Vec<ComparablePattern<'a>>,
+    },
+}
+
+impl<'a> From<&'a Pattern> for ComparablePattern<'a> {
+    fn from(pattern: &'a Pattern) -> Self {
+        match &pattern.node {
+            PatternKind::MatchValue { value } => Self::MatchValue {
+                value: value.into(),
+            },
+            PatternKind::MatchSingleton { value } => Self::MatchSingleton {
+                value: value.into(),
+            },
+            PatternKind::MatchSequence { patterns } => Self::MatchSequence {
+                patterns: patterns.iter().map(Into::into).collect(),
+            },
+            PatternKind::MatchMapping {
+                keys,
+                patterns,
+                rest,
+            } => Self::MatchMapping {
+                keys: keys.iter().map(Into::into).collect(),
+                patterns: patterns.iter().map(Into::into).collect(),
+                rest: rest.as_deref(),
+            },
+            PatternKind::MatchClass {
+                cls,
+                patterns,
+                kwd_attrs,
+                kwd_patterns,
+            } => Self::MatchClass {
+                cls: cls.into(),
+                patterns: patterns.iter().map(Into::into).collect(),
+                kwd_attrs: kwd_attrs.iter().map(String::as_str).collect(),
+                kwd_patterns: kwd_patterns.iter().map(Into::into).collect(),
+            },
+            PatternKind::MatchStar { name } => Self::MatchStar {
+                name: name.as_deref(),
+            },
+            PatternKind::MatchAs { pattern, name } => Self::MatchAs {
+                pattern: pattern.as_ref().map(Into::into),
+                name: name.as_deref(),
+            },
+            PatternKind::MatchOr { patterns } => Self::MatchOr {
+                patterns: patterns.iter().map(Into::into).collect(),
+            },
+        }
+    }
+}
+
+impl<'a> From<&'a Box<Pattern>> for Box<ComparablePattern<'a>> {
+    fn from(pattern: &'a Box<Pattern>) -> Self {
+        Box::new((&**pattern).into())
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct ComparableMatchCase<'a> {
+    pub pattern: ComparablePattern<'a>,
+    pub guard: Option<ComparableExpr<'a>>,
+    pub body: Vec<ComparableStmt<'a>>,
+}
+
+impl<'a> From<&'a MatchCase> for ComparableMatchCase<'a> {
+    fn from(match_case: &'a MatchCase) -> Self {
+        Self {
+            pattern: (&match_case.pattern).into(),
+            guard: match_case.guard.as_ref().map(Into::into),
+            body: match_case.body.iter().map(Into::into).collect(),
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub enum ComparableConstant<'a> {
     None,
@@ -644,6 +748,10 @@ pub enum ComparableStmt<'a> {
         body: Vec<ComparableStmt<'a>>,
         type_comment: Option<&'a str>,
     },
+    Match {
+        subject: ComparableExpr<'a>,
+        cases: Vec<ComparableMatchCase<'a>>,
+    },
     Raise {
         exc: Option<ComparableExpr<'a>>,
         cause: Option<ComparableExpr<'a>>,
@@ -654,6 +762,12 @@ pub enum ComparableStmt<'a> {
         orelse: Vec<ComparableStmt<'a>>,
         finalbody: Vec<ComparableStmt<'a>>,
     },
+    TryStar {
+        body: Vec<ComparableStmt<'a>>,
+        handlers: Vec<ComparableExcepthandler<'a>>,
+        orelse: Vec<ComparableStmt<'a>>,
+        finalbody: Vec<ComparableStmt<'a>>,
+    },
     Assert {
         test: ComparableExpr<'a>,
         msg: Option<ComparableExpr<'a>>,
@@ -811,7 +925,10 @@ impl<'a> From<&'a Stmt> for ComparableStmt<'a> {
                 body: body.iter().map(Into::into).collect(),
                 type_comment: type_comment.as_ref().map(String::as_str),
             },
-            StmtKind::Match { .. } => unreachable!("StmtKind::Match is not supported"),
+            StmtKind::Match { subject, cases } => Self::Match {
+                subject: subject.into(),
+                cases: cases.iter().map(Into::into).collect(),
+            },
             StmtKind::Raise { exc, cause } => Self::Raise {
                 exc: exc.as_ref().map(Into::into),
                 cause: cause.as_ref().map(Into::into),
@@ -827,6 +944,17 @@ impl<'a> From<&'a Stmt> for ComparableStmt<'a> {
                 orelse: orelse.iter().map(Into::into).collect(),
                 finalbody: finalbody.iter().map(Into::into).collect(),
             },
+            StmtKind::TryStar {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+            } => Self::TryStar {
+                body: body.iter().map(Into::into).collect(),
+                handlers: handlers.iter().map(Into::into).collect(),
+                orelse: orelse.iter().map(Into::into).collect(),
+                finalbody: finalbody.iter().map(Into::into).collect(),
+            },
             StmtKind::Assert { test, msg } => Self::Assert {
                 test: test.into(),
                 msg: msg.as_ref().map(Into::into),

crates/ruff/src/ast/helpers.rs

@@ -7,11 +7,9 @@ use regex::Regex;
 use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_parser::ast::{
     Arguments, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprKind, Keyword, KeywordData,
-    Located, Location, Stmt, StmtKind,
+    Located, Location, MatchCase, Pattern, PatternKind, Stmt, StmtKind,
 };
-use rustpython_parser::lexer;
-use rustpython_parser::lexer::Tok;
-use rustpython_parser::token::StringKind;
+use rustpython_parser::{lexer, Mode, StringKind, Tok};
 use smallvec::{smallvec, SmallVec};
 
 use crate::ast::types::{Binding, BindingKind, CallPath, Range};
@@ -249,6 +247,46 @@ where
     }
 }
 
+pub fn any_over_pattern<F>(pattern: &Pattern, func: &F) -> bool
+where
+    F: Fn(&Expr) -> bool,
+{
+    match &pattern.node {
+        PatternKind::MatchValue { value } => any_over_expr(value, func),
+        PatternKind::MatchSingleton { .. } => false,
+        PatternKind::MatchSequence { patterns } => patterns
+            .iter()
+            .any(|pattern| any_over_pattern(pattern, func)),
+        PatternKind::MatchMapping { keys, patterns, .. } => {
+            keys.iter().any(|key| any_over_expr(key, func))
+                || patterns
+                    .iter()
+                    .any(|pattern| any_over_pattern(pattern, func))
+        }
+        PatternKind::MatchClass {
+            cls,
+            patterns,
+            kwd_patterns,
+            ..
+        } => {
+            any_over_expr(cls, func)
+                || patterns
+                    .iter()
+                    .any(|pattern| any_over_pattern(pattern, func))
+                || kwd_patterns
+                    .iter()
+                    .any(|pattern| any_over_pattern(pattern, func))
+        }
+        PatternKind::MatchStar { .. } => false,
+        PatternKind::MatchAs { pattern, .. } => pattern
+            .as_ref()
+            .map_or(false, |pattern| any_over_pattern(pattern, func)),
+        PatternKind::MatchOr { patterns } => patterns
+            .iter()
+            .any(|pattern| any_over_pattern(pattern, func)),
+    }
+}
+
 pub fn any_over_stmt<F>(stmt: &Stmt, func: &F) -> bool
 where
     F: Fn(&Expr) -> bool,
@@ -391,6 +429,12 @@ where
             handlers,
             orelse,
             finalbody,
+        }
+        | StmtKind::TryStar {
+            body,
+            handlers,
+            orelse,
+            finalbody,
         } => {
             any_over_body(body, func)
                 || handlers.iter().any(|handler| {
@@ -409,8 +453,21 @@ where
                     .as_ref()
                     .map_or(false, |value| any_over_expr(value, func))
         }
-        // TODO(charlie): Handle match statements.
-        StmtKind::Match { .. } => false,
+        StmtKind::Match { subject, cases } => {
+            any_over_expr(subject, func)
+                || cases.iter().any(|case| {
+                    let MatchCase {
+                        pattern,
+                        guard,
+                        body,
+                    } = case;
+                    any_over_pattern(pattern, func)
+                        || guard
+                            .as_ref()
+                            .map_or(false, |expr| any_over_expr(expr, func))
+                        || any_over_body(body, func)
+                })
+        }
         StmtKind::Import { .. } => false,
         StmtKind::ImportFrom { .. } => false,
         StmtKind::Global { .. } => false,
@@ -596,7 +653,7 @@ pub fn has_comments<T>(located: &Located<T>, locator: &Locator) -> bool {
 
 /// Returns `true` if a [`Range`] includes at least one comment.
 pub fn has_comments_in(range: Range, locator: &Locator) -> bool {
-    for tok in lexer::make_tokenizer(locator.slice(&range)) {
+    for tok in lexer::lex_located(locator.slice(&range), Mode::Module, range.location) {
         match tok {
             Ok((_, tok, _)) => {
                 if matches!(tok, Tok::Comment(..)) {
@@ -811,7 +868,7 @@ pub fn match_parens(start: Location, locator: &Locator) -> Option<Range> {
     let mut fix_start = None;
     let mut fix_end = None;
     let mut count: usize = 0;
-    for (start, tok, end) in lexer::make_tokenizer_located(contents, start).flatten() {
+    for (start, tok, end) in lexer::lex_located(contents, Mode::Module, start).flatten() {
         if matches!(tok, Tok::Lpar) {
             if count == 0 {
                 fix_start = Some(start);
@@ -843,7 +900,8 @@ pub fn identifier_range(stmt: &Stmt, locator: &Locator) -> Range {
             | StmtKind::AsyncFunctionDef { .. }
     ) {
         let contents = locator.slice(&Range::from_located(stmt));
-        for (start, tok, end) in lexer::make_tokenizer_located(contents, stmt.location).flatten() {
+        for (start, tok, end) in lexer::lex_located(contents, Mode::Module, stmt.location).flatten()
+        {
             if matches!(tok, Tok::Name { .. }) {
                 return Range::new(start, end);
             }
@@ -869,16 +927,18 @@ pub fn binding_range(binding: &Binding, locator: &Locator) -> Range {
 }
 
 // Return the ranges of `Name` tokens within a specified node.
-pub fn find_names<T>(located: &Located<T>, locator: &Locator) -> Vec<Range> {
+pub fn find_names<'a, T, U>(
+    located: &'a Located<T, U>,
+    locator: &'a Locator,
+) -> impl Iterator<Item = Range> + 'a {
     let contents = locator.slice(&Range::from_located(located));
-    lexer::make_tokenizer_located(contents, located.location)
+    lexer::lex_located(contents, Mode::Module, located.location)
         .flatten()
         .filter(|(_, tok, _)| matches!(tok, Tok::Name { .. }))
         .map(|(start, _, end)| Range {
             location: start,
             end_location: end,
         })
-        .collect()
 }
 
 /// Return the `Range` of `name` in `Excepthandler`.
@@ -890,7 +950,7 @@ pub fn excepthandler_name_range(handler: &Excepthandler, locator: &Locator) -> O
         (Some(_), Some(type_)) => {
             let type_end_location = type_.end_location.unwrap();
             let contents = locator.slice(&Range::new(type_end_location, body[0].location));
-            let range = lexer::make_tokenizer_located(contents, type_end_location)
+            let range = lexer::lex_located(contents, Mode::Module, type_end_location)
                 .flatten()
                 .tuple_windows()
                 .find(|(tok, next_tok)| {
@@ -917,7 +977,7 @@ pub fn except_range(handler: &Excepthandler, locator: &Locator) -> Range {
         location: handler.location,
         end_location: end,
     });
-    let range = lexer::make_tokenizer_located(contents, handler.location)
+    let range = lexer::lex_located(contents, Mode::Module, handler.location)
         .flatten()
         .find(|(_, kind, _)| matches!(kind, Tok::Except { .. }))
         .map(|(location, _, end_location)| Range {
@@ -931,7 +991,7 @@ pub fn except_range(handler: &Excepthandler, locator: &Locator) -> Range {
 /// Find f-strings that don't contain any formatted values in a `JoinedStr`.
 pub fn find_useless_f_strings(expr: &Expr, locator: &Locator) -> Vec<(Range, Range)> {
     let contents = locator.slice(&Range::from_located(expr));
-    lexer::make_tokenizer_located(contents, expr.location)
+    lexer::lex_located(contents, Mode::Module, expr.location)
         .flatten()
         .filter_map(|(location, tok, end_location)| match tok {
             Tok::String {
@@ -985,7 +1045,7 @@ pub fn else_range(stmt: &Stmt, locator: &Locator) -> Option<Range> {
                     .expect("Expected orelse to be non-empty")
                     .location,
             });
-            let range = lexer::make_tokenizer_located(contents, body_end)
+            let range = lexer::lex_located(contents, Mode::Module, body_end)
                 .flatten()
                 .find(|(_, kind, _)| matches!(kind, Tok::Else))
                 .map(|(location, _, end_location)| Range {
@@ -1001,7 +1061,7 @@ pub fn else_range(stmt: &Stmt, locator: &Locator) -> Option<Range> {
 /// Return the `Range` of the first `Tok::Colon` token in a `Range`.
 pub fn first_colon_range(range: Range, locator: &Locator) -> Option<Range> {
     let contents = locator.slice(&range);
-    let range = lexer::make_tokenizer_located(contents, range.location)
+    let range = lexer::lex_located(contents, Mode::Module, range.location)
         .flatten()
         .find(|(_, kind, _)| matches!(kind, Tok::Colon))
         .map(|(location, _, end_location)| Range {
@@ -1031,7 +1091,7 @@ pub fn elif_else_range(stmt: &Stmt, locator: &Locator) -> Option<Range> {
         _ => return None,
     };
     let contents = locator.slice(&Range::new(start, end));
-    let range = lexer::make_tokenizer_located(contents, start)
+    let range = lexer::lex_located(contents, Mode::Module, start)
         .flatten()
         .find(|(_, kind, _)| matches!(kind, Tok::Elif | Tok::Else))
         .map(|(location, _, end_location)| Range {
@@ -1147,8 +1207,8 @@ pub fn is_logger_candidate(func: &Expr) -> bool {
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
+    use rustpython_parser as parser;
     use rustpython_parser::ast::Location;
-    use rustpython_parser::parser;
 
     use crate::ast::helpers::{
         elif_else_range, else_range, first_colon_range, identifier_range, match_trailing_content,

crates/ruff/src/ast/logging.rs

@@ -0,0 +1,24 @@
+pub enum LoggingLevel {
+    Debug,
+    Critical,
+    Error,
+    Exception,
+    Info,
+    Warn,
+    Warning,
+}
+
+impl LoggingLevel {
+    pub fn from_str(level: &str) -> Option<Self> {
+        match level {
+            "debug" => Some(LoggingLevel::Debug),
+            "critical" => Some(LoggingLevel::Critical),
+            "error" => Some(LoggingLevel::Error),
+            "exception" => Some(LoggingLevel::Exception),
+            "info" => Some(LoggingLevel::Info),
+            "warn" => Some(LoggingLevel::Warn),
+            "warning" => Some(LoggingLevel::Warning),
+            _ => None,
+        }
+    }
+}

crates/ruff/src/ast/mod.rs

@@ -4,6 +4,7 @@ pub mod comparable;
 pub mod function_type;
 pub mod hashable;
 pub mod helpers;
+pub mod logging;
 pub mod operations;
 pub mod relocate;
 pub mod types;

crates/ruff/src/ast/operations.rs

@@ -1,8 +1,7 @@
 use bitflags::bitflags;
 use rustc_hash::FxHashMap;
 use rustpython_parser::ast::{Cmpop, Constant, Expr, ExprKind, Located, Stmt, StmtKind};
-use rustpython_parser::lexer;
-use rustpython_parser::lexer::Tok;
+use rustpython_parser::{lexer, Mode, Tok};
 
 use crate::ast::helpers::any_over_expr;
 use crate::ast::types::{BindingKind, Scope};
@@ -181,7 +180,10 @@ pub fn extract_globals(body: &[Stmt]) -> FxHashMap<&str, &Stmt> {
 /// Check if a node is parent of a conditional branch.
 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 { .. }) {
+        if matches!(
+            parent.node,
+            StmtKind::If { .. } | StmtKind::While { .. } | StmtKind::Match { .. }
+        ) {
             return true;
         }
         if let StmtKind::Expr { value } = &parent.node {
@@ -198,7 +200,11 @@ pub fn in_nested_block<'a>(mut parents: impl Iterator<Item = &'a Stmt>) -> bool
     parents.any(|parent| {
         matches!(
             parent.node,
-            StmtKind::Try { .. } | StmtKind::If { .. } | StmtKind::With { .. }
+            StmtKind::Try { .. }
+                | StmtKind::TryStar { .. }
+                | StmtKind::If { .. }
+                | StmtKind::With { .. }
+                | StmtKind::Match { .. }
         )
     })
 }
@@ -277,7 +283,7 @@ pub type LocatedCmpop<U = ()> = Located<Cmpop, U>;
 /// `CPython` doesn't either. This method iterates over the token stream and
 /// re-identifies [`Cmpop`] nodes, annotating them with valid ranges.
 pub fn locate_cmpops(contents: &str) -> Vec<LocatedCmpop> {
-    let mut tok_iter = lexer::make_tokenizer(contents).flatten().peekable();
+    let mut tok_iter = lexer::lex(contents, Mode::Module).flatten().peekable();
     let mut ops: Vec<LocatedCmpop> = vec![];
     let mut count: usize = 0;
     loop {
@@ -304,13 +310,14 @@ pub fn locate_cmpops(contents: &str) -> Vec<LocatedCmpop> {
                     ops.push(LocatedCmpop::new(start, end, Cmpop::In));
                 }
                 Tok::Is => {
-                    if let Some((_, _, end)) =
+                    let op = if let Some((_, _, end)) =
                         tok_iter.next_if(|(_, tok, _)| matches!(tok, Tok::Not))
                     {
-                        ops.push(LocatedCmpop::new(start, end, Cmpop::IsNot));
+                        LocatedCmpop::new(start, end, Cmpop::IsNot)
                     } else {
-                        ops.push(LocatedCmpop::new(start, end, Cmpop::Is));
-                    }
+                        LocatedCmpop::new(start, end, Cmpop::Is)
+                    };
+                    ops.push(op);
                 }
                 Tok::NotEqual => {
                     ops.push(LocatedCmpop::new(start, end, Cmpop::NotEq));

crates/ruff/src/ast/types.rs

@@ -29,7 +29,7 @@ impl Range {
         }
     }
 
-    pub fn from_located<T>(located: &Located<T>) -> Self {
+    pub fn from_located<T, U>(located: &Located<T, U>) -> Self {
         Range::new(located.location, located.end_location.unwrap())
     }
 

crates/ruff/src/ast/visitor.rs

@@ -205,7 +205,6 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
             visitor.visit_body(body);
         }
         StmtKind::Match { subject, cases } => {
-            // TODO(charlie): Handle `cases`.
             visitor.visit_expr(subject);
             for match_case in cases {
                 visitor.visit_match_case(match_case);
@@ -232,6 +231,19 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
             visitor.visit_body(orelse);
             visitor.visit_body(finalbody);
         }
+        StmtKind::TryStar {
+            body,
+            handlers,
+            orelse,
+            finalbody,
+        } => {
+            visitor.visit_body(body);
+            for excepthandler in handlers {
+                visitor.visit_excepthandler(excepthandler);
+            }
+            visitor.visit_body(orelse);
+            visitor.visit_body(finalbody);
+        }
         StmtKind::Assert { test, msg } => {
             visitor.visit_expr(test);
             if let Some(expr) = msg {

crates/ruff/src/autofix/helpers.rs

@@ -4,8 +4,7 @@ use libcst_native::{
     Codegen, CodegenState, ImportNames, ParenthesizableWhitespace, SmallStatement, Statement,
 };
 use rustpython_parser::ast::{ExcepthandlerKind, Expr, Keyword, Location, Stmt, StmtKind};
-use rustpython_parser::lexer;
-use rustpython_parser::lexer::Tok;
+use rustpython_parser::{lexer, Mode, Tok};
 
 use crate::ast::helpers;
 use crate::ast::helpers::to_absolute;
@@ -53,6 +52,12 @@ fn is_lone_child(child: &Stmt, parent: &Stmt, deleted: &[&Stmt]) -> Result<bool>
             handlers,
             orelse,
             finalbody,
+        }
+        | StmtKind::TryStar {
+            body,
+            handlers,
+            orelse,
+            finalbody,
         } => {
             if body.iter().contains(child) {
                 Ok(has_single_child(body, deleted))
@@ -74,6 +79,19 @@ fn is_lone_child(child: &Stmt, parent: &Stmt, deleted: &[&Stmt]) -> Result<bool>
                 bail!("Unable to find child in parent body")
             }
         }
+        StmtKind::Match { cases, .. } => {
+            if let Some(body) = cases.iter().find_map(|case| {
+                if case.body.iter().contains(child) {
+                    Some(&case.body)
+                } else {
+                    None
+                }
+            }) {
+                Ok(has_single_child(body, deleted))
+            } else {
+                bail!("Unable to find child in parent body")
+            }
+        }
         _ => bail!("Unable to find child in parent body"),
     }
 }
@@ -352,7 +370,7 @@ pub fn remove_argument(
     if n_arguments == 1 {
         // Case 1: there is only one argument.
         let mut count: usize = 0;
-        for (start, tok, end) in lexer::make_tokenizer_located(contents, stmt_at).flatten() {
+        for (start, tok, end) in lexer::lex_located(contents, Mode::Module, stmt_at).flatten() {
             if matches!(tok, Tok::Lpar) {
                 if count == 0 {
                     fix_start = Some(if remove_parentheses {
@@ -384,7 +402,7 @@ pub fn remove_argument(
     {
         // Case 2: argument or keyword is _not_ the last node.
         let mut seen_comma = false;
-        for (start, tok, end) in lexer::make_tokenizer_located(contents, stmt_at).flatten() {
+        for (start, tok, end) in lexer::lex_located(contents, Mode::Module, stmt_at).flatten() {
             if seen_comma {
                 if matches!(tok, Tok::NonLogicalNewline) {
                     // Also delete any non-logical newlines after the comma.
@@ -407,7 +425,7 @@ pub fn remove_argument(
     } else {
         // Case 3: argument or keyword is the last node, so we have to find the last
         // comma in the stmt.
-        for (start, tok, _) in lexer::make_tokenizer_located(contents, stmt_at).flatten() {
+        for (start, tok, _) in lexer::lex_located(contents, Mode::Module, stmt_at).flatten() {
             if start == expr_at {
                 fix_end = Some(expr_end);
                 break;
@@ -429,8 +447,8 @@ pub fn remove_argument(
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
+    use rustpython_parser as parser;
     use rustpython_parser::ast::Location;
-    use rustpython_parser::parser;
 
     use crate::autofix::helpers::{next_stmt_break, trailing_semicolon};
     use crate::source_code::Locator;

crates/ruff/src/checkers/ast.rs

@@ -6,17 +6,17 @@ use std::path::Path;
 use itertools::Itertools;
 use log::error;
 use nohash_hasher::IntMap;
-use rustc_hash::{FxHashMap, FxHashSet};
-use rustpython_common::cformat::{CFormatError, CFormatErrorType};
-use rustpython_parser::ast::{
-    Arg, Arguments, Comprehension, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprContext,
-    ExprKind, KeywordData, Located, Location, Operator, Stmt, StmtKind, Suite,
-};
-use rustpython_parser::parser;
-use smallvec::smallvec;
-
 use ruff_python::builtins::{BUILTINS, MAGIC_GLOBALS};
 use ruff_python::typing::TYPING_EXTENSIONS;
+use rustc_hash::{FxHashMap, FxHashSet};
+use rustpython_common::cformat::{CFormatError, CFormatErrorType};
+use rustpython_parser as parser;
+use rustpython_parser::ast::{
+    Arg, Arguments, Comprehension, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprContext,
+    ExprKind, KeywordData, Located, Location, Operator, Pattern, PatternKind, Stmt, StmtKind,
+    Suite,
+};
+use smallvec::smallvec;
 
 use crate::ast::helpers::{
     binding_range, collect_call_path, extract_handler_names, from_relative_import, to_module_path,
@@ -28,10 +28,11 @@ use crate::ast::types::{
     RefEquality, Scope, ScopeKind,
 };
 use crate::ast::typing::{match_annotated_subscript, Callable, SubscriptKind};
-use crate::ast::visitor::{walk_excepthandler, Visitor};
+use crate::ast::visitor::{walk_excepthandler, walk_pattern, Visitor};
 use crate::ast::{branch_detection, cast, helpers, operations, typing, visitor};
 use crate::docstrings::definition::{Definition, DefinitionKind, Docstring, Documentable};
 use crate::registry::{Diagnostic, Rule};
+use crate::resolver::is_interface_definition_path;
 use crate::rules::{
     flake8_2020, flake8_annotations, flake8_bandit, flake8_blind_except, flake8_boolean_trap,
     flake8_bugbear, flake8_builtins, flake8_comprehensions, flake8_datetimez, flake8_debugger,
@@ -58,6 +59,7 @@ pub struct Checker<'a> {
     pub(crate) path: &'a Path,
     module_path: Option<Vec<String>>,
     package: Option<&'a Path>,
+    is_interface_definition: bool,
     autofix: flags::Autofix,
     noqa: flags::Noqa,
     pub(crate) settings: &'a Settings,
@@ -126,6 +128,7 @@ impl<'a> Checker<'a> {
         style: &'a Stylist,
         indexer: &'a Indexer,
     ) -> Checker<'a> {
+        let is_interface_definition = is_interface_definition_path(path);
         Checker {
             settings,
             noqa_line_for,
@@ -134,6 +137,7 @@ impl<'a> Checker<'a> {
             path,
             package,
             module_path,
+            is_interface_definition,
             locator,
             stylist: style,
             indexer,
@@ -173,7 +177,7 @@ impl<'a> Checker<'a> {
             in_type_checking_block: false,
             seen_import_boundary: false,
             futures_allowed: true,
-            annotations_future_enabled: path.extension().map_or(false, |ext| ext == "pyi"),
+            annotations_future_enabled: is_interface_definition,
             except_handlers: vec![],
             // Check-specific state.
             flake8_bugbear_seen: vec![],
@@ -235,51 +239,51 @@ impl<'a> Checker<'a> {
         'b: 'a,
     {
         let call_path = collect_call_path(value);
-        if let Some(head) = call_path.first() {
-            if let Some(binding) = self.find_binding(head) {
-                match &binding.kind {
-                    BindingKind::Importation(.., name)
-                    | BindingKind::SubmoduleImportation(name, ..) => {
-                        return if name.starts_with('.') {
-                            if let Some(module) = &self.module_path {
-                                let mut source_path = from_relative_import(module, name);
-                                source_path.extend(call_path.into_iter().skip(1));
-                                Some(source_path)
-                            } else {
-                                None
-                            }
-                        } else {
-                            let mut source_path: CallPath = name.split('.').collect();
-                            source_path.extend(call_path.into_iter().skip(1));
-                            Some(source_path)
-                        };
+        let Some(head) = call_path.first() else {
+            return None;
+        };
+        let Some(binding) = self.find_binding(head) else {
+            return None;
+        };
+        match &binding.kind {
+            BindingKind::Importation(.., name) | BindingKind::SubmoduleImportation(name, ..) => {
+                if name.starts_with('.') {
+                    if let Some(module) = &self.module_path {
+                        let mut source_path = from_relative_import(module, name);
+                        source_path.extend(call_path.into_iter().skip(1));
+                        Some(source_path)
+                    } else {
+                        None
                     }
-                    BindingKind::FromImportation(.., name) => {
-                        return if name.starts_with('.') {
-                            if let Some(module) = &self.module_path {
-                                let mut source_path = from_relative_import(module, name);
-                                source_path.extend(call_path.into_iter().skip(1));
-                                Some(source_path)
-                            } else {
-                                None
-                            }
-                        } else {
-                            let mut source_path: CallPath = name.split('.').collect();
-                            source_path.extend(call_path.into_iter().skip(1));
-                            Some(source_path)
-                        };
-                    }
-                    BindingKind::Builtin => {
-                        let mut source_path: CallPath = smallvec![];
-                        source_path.push("");
-                        source_path.extend(call_path);
-                        return Some(source_path);
-                    }
-                    _ => {}
+                } else {
+                    let mut source_path: CallPath = name.split('.').collect();
+                    source_path.extend(call_path.into_iter().skip(1));
+                    Some(source_path)
                 }
             }
+            BindingKind::FromImportation(.., name) => {
+                if name.starts_with('.') {
+                    if let Some(module) = &self.module_path {
+                        let mut source_path = from_relative_import(module, name);
+                        source_path.extend(call_path.into_iter().skip(1));
+                        Some(source_path)
+                    } else {
+                        None
+                    }
+                } else {
+                    let mut source_path: CallPath = name.split('.').collect();
+                    source_path.extend(call_path.into_iter().skip(1));
+                    Some(source_path)
+                }
+            }
+            BindingKind::Builtin => {
+                let mut source_path: CallPath = smallvec![];
+                source_path.push("");
+                source_path.extend(call_path);
+                Some(source_path)
+            }
+            _ => None,
         }
-        None
     }
 
     /// Return `true` if a `Rule` is disabled by a `noqa` directive.
@@ -337,7 +341,7 @@ where
         match &stmt.node {
             StmtKind::Global { names } => {
                 let scope_index = *self.scope_stack.last().expect("No current scope found");
-                let ranges = helpers::find_names(stmt, self.locator);
+                let ranges: Vec<Range> = helpers::find_names(stmt, self.locator).collect();
                 if scope_index != GLOBAL_SCOPE_INDEX {
                     // Add the binding to the current scope.
                     let context = self.execution_context();
@@ -367,7 +371,7 @@ where
             }
             StmtKind::Nonlocal { names } => {
                 let scope_index = *self.scope_stack.last().expect("No current scope found");
-                let ranges = helpers::find_names(stmt, self.locator);
+                let ranges: Vec<Range> = helpers::find_names(stmt, self.locator).collect();
                 if scope_index != GLOBAL_SCOPE_INDEX {
                     let context = self.execution_context();
                     let scope = &mut self.scopes[scope_index];
@@ -702,7 +706,12 @@ where
                     .rules
                     .enabled(&Rule::BooleanPositionalArgInFunctionDefinition)
                 {
-                    flake8_boolean_trap::rules::check_positional_boolean_in_def(self, name, args);
+                    flake8_boolean_trap::rules::check_positional_boolean_in_def(
+                        self,
+                        name,
+                        decorator_list,
+                        args,
+                    );
                 }
 
                 if self
@@ -711,7 +720,10 @@ where
                     .enabled(&Rule::BooleanDefaultValueInFunctionDefinition)
                 {
                     flake8_boolean_trap::rules::check_boolean_default_value_in_function_definition(
-                        self, name, args,
+                        self,
+                        name,
+                        decorator_list,
+                        args,
                     );
                 }
 
@@ -775,6 +787,9 @@ where
                 if self.settings.rules.enabled(&Rule::ReturnOutsideFunction) {
                     pyflakes::rules::return_outside_function(self, stmt);
                 }
+                if self.settings.rules.enabled(&Rule::ReturnInInit) {
+                    pylint::rules::return_in_init(self, stmt);
+                }
             }
             StmtKind::ClassDef {
                 name,
@@ -835,18 +850,20 @@ where
                     flake8_bugbear::rules::useless_expression(self, body);
                 }
 
-                if self
-                    .settings
-                    .rules
-                    .enabled(&Rule::AbstractBaseClassWithoutAbstractMethod)
-                    || self
+                if !self.is_interface_definition {
+                    if self
                         .settings
                         .rules
-                        .enabled(&Rule::EmptyMethodWithoutAbstractDecorator)
-                {
-                    flake8_bugbear::rules::abstract_base_class(
-                        self, stmt, name, bases, keywords, body,
-                    );
+                        .enabled(&Rule::AbstractBaseClassWithoutAbstractMethod)
+                        || self
+                            .settings
+                            .rules
+                            .enabled(&Rule::EmptyMethodWithoutAbstractDecorator)
+                    {
+                        flake8_bugbear::rules::abstract_base_class(
+                            self, stmt, name, bases, keywords, body,
+                        );
+                    }
                 }
 
                 if self
@@ -900,7 +917,38 @@ where
                 }
 
                 for alias in names {
-                    if alias.node.name.contains('.') && alias.node.asname.is_none() {
+                    if alias.node.name == "__future__" {
+                        let name = alias.node.asname.as_ref().unwrap_or(&alias.node.name);
+                        self.add_binding(
+                            name,
+                            Binding {
+                                kind: BindingKind::FutureImportation,
+                                runtime_usage: None,
+                                // Always mark `__future__` imports as used.
+                                synthetic_usage: Some((
+                                    self.scopes[*(self
+                                        .scope_stack
+                                        .last()
+                                        .expect("No current scope found"))]
+                                    .id,
+                                    Range::from_located(alias),
+                                )),
+                                typing_usage: None,
+                                range: Range::from_located(alias),
+                                source: Some(self.current_stmt().clone()),
+                                context: self.execution_context(),
+                            },
+                        );
+
+                        if self.settings.rules.enabled(&Rule::LateFutureImport)
+                            && !self.futures_allowed
+                        {
+                            self.diagnostics.push(Diagnostic::new(
+                                pyflakes::rules::LateFutureImport,
+                                Range::from_located(stmt),
+                            ));
+                        }
+                    } else if alias.node.name.contains('.') && alias.node.asname.is_none() {
                         // Given `import foo.bar`, `name` would be "foo", and `full_name` would be
                         // "foo.bar".
                         let name = alias.node.name.split('.').next().unwrap();
@@ -918,10 +966,6 @@ where
                             },
                         );
                     } else {
-                        if let Some(asname) = &alias.node.asname {
-                            self.check_builtin_shadowing(asname, stmt, false);
-                        }
-
                         // Given `import foo`, `name` and `full_name` would both be `foo`.
                         // Given `import foo as bar`, `name` would be `bar` and `full_name` would
                         // be `foo`.
@@ -957,6 +1001,10 @@ where
                                 context: self.execution_context(),
                             },
                         );
+
+                        if let Some(asname) = &alias.node.asname {
+                            self.check_builtin_shadowing(asname, stmt, false);
+                        }
                     }
 
                     // flake8-debugger
@@ -1525,6 +1573,9 @@ where
                 if self.settings.rules.enabled(&Rule::NeedlessBool) {
                     flake8_simplify::rules::return_bool_condition_directly(self, stmt);
                 }
+                if self.settings.rules.enabled(&Rule::ManualDictLookup) {
+                    flake8_simplify::rules::manual_dict_lookup(self, stmt, test, body, orelse);
+                }
                 if self.settings.rules.enabled(&Rule::UseTernaryOperator) {
                     flake8_simplify::rules::use_ternary_operator(
                         self,
@@ -1572,11 +1623,12 @@ where
                     }
                 }
                 if self.settings.rules.enabled(&Rule::CompositeAssertion) {
-                    if let Some(diagnostic) =
-                        flake8_pytest_style::rules::composite_condition(stmt, test)
-                    {
-                        self.diagnostics.push(diagnostic);
-                    }
+                    flake8_pytest_style::rules::composite_condition(
+                        self,
+                        stmt,
+                        test,
+                        msg.as_deref(),
+                    );
                 }
             }
             StmtKind::With { items, body, .. } => {
@@ -1598,6 +1650,9 @@ where
                         self.current_stmt_parent().map(Into::into),
                     );
                 }
+                if self.settings.rules.enabled(&Rule::RedefinedLoopName) {
+                    pylint::rules::redefined_loop_name(self, &Node::Stmt(stmt));
+                }
             }
             StmtKind::While { body, orelse, .. } => {
                 if self.settings.rules.enabled(&Rule::FunctionUsesLoopVariable) {
@@ -1642,10 +1697,11 @@ where
                 if self.settings.rules.enabled(&Rule::UselessElseOnLoop) {
                     pylint::rules::useless_else_on_loop(self, stmt, body, orelse);
                 }
+                if self.settings.rules.enabled(&Rule::RedefinedLoopName) {
+                    pylint::rules::redefined_loop_name(self, &Node::Stmt(stmt));
+                }
                 if matches!(stmt.node, StmtKind::For { .. }) {
-                    if self.settings.rules.enabled(&Rule::ConvertLoopToAny)
-                        || self.settings.rules.enabled(&Rule::ConvertLoopToAll)
-                    {
+                    if self.settings.rules.enabled(&Rule::ReimplementedBuiltin) {
                         flake8_simplify::rules::convert_for_loop_to_any_all(
                             self,
                             stmt,
@@ -1663,6 +1719,13 @@ where
                 orelse,
                 finalbody,
                 ..
+            }
+            | StmtKind::TryStar {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+                ..
             } => {
                 if self.settings.rules.enabled(&Rule::DefaultExceptNotLast) {
                     if let Some(diagnostic) =
@@ -1713,6 +1776,9 @@ where
                 if self.settings.rules.enabled(&Rule::VerboseRaise) {
                     tryceratops::rules::verbose_raise(self, handlers);
                 }
+                if self.settings.rules.enabled(&Rule::VerboseLogMessage) {
+                    tryceratops::rules::verbose_log_message(self, handlers);
+                }
                 if self.settings.rules.enabled(&Rule::RaiseWithinTry) {
                     tryceratops::rules::raise_within_try(self, body);
                 }
@@ -1739,8 +1805,8 @@ where
                     }
                 }
 
-                if self.settings.rules.enabled(&Rule::PrefixTypeParams) {
-                    if self.path.extension().map_or(false, |ext| ext == "pyi") {
+                if self.is_interface_definition {
+                    if self.settings.rules.enabled(&Rule::PrefixTypeParams) {
                         flake8_pyi::rules::prefix_type_params(self, value, targets);
                     }
                 }
@@ -1782,6 +1848,18 @@ where
                         pycodestyle::rules::lambda_assignment(self, target, value, stmt);
                     }
                 }
+                if self
+                    .settings
+                    .rules
+                    .enabled(&Rule::UnintentionalTypeAnnotation)
+                {
+                    flake8_bugbear::rules::unintentional_type_annotation(
+                        self,
+                        target,
+                        value.as_deref(),
+                        stmt,
+                    );
+                }
             }
             StmtKind::Delete { .. } => {}
             StmtKind::Expr { value, .. } => {
@@ -1947,6 +2025,12 @@ where
                 handlers,
                 orelse,
                 finalbody,
+            }
+            | StmtKind::TryStar {
+                body,
+                handlers,
+                orelse,
+                finalbody,
             } => {
                 // TODO(charlie): The use of `smallvec` here leads to a lifetime issue.
                 let handler_names = extract_handler_names(handlers)
@@ -1975,8 +2059,8 @@ where
                 value,
                 ..
             } => {
-                // If we're in a class or module scope, then the annotation needs to be available
-                // at runtime.
+                // If we're in a class or module scope, then the annotation needs to be
+                // available at runtime.
                 // See: https://docs.python.org/3/reference/simple_stmts.html#annotated-assignment-statements
                 if !self.annotations_future_enabled
                     && matches!(
@@ -2526,7 +2610,12 @@ where
                     .enabled(&Rule::UnnecessaryCollectionCall)
                 {
                     flake8_comprehensions::rules::unnecessary_collection_call(
-                        self, expr, func, args, keywords,
+                        self,
+                        expr,
+                        func,
+                        args,
+                        keywords,
+                        &self.settings.flake8_comprehensions,
                     );
                 }
                 if self
@@ -2811,6 +2900,11 @@ where
                     flake8_use_pathlib::helpers::replaceable_by_pathlib(self, func);
                 }
 
+                // numpy
+                if self.settings.rules.enabled(&Rule::NumpyLegacyRandom) {
+                    numpy::rules::numpy_legacy_random(self, func);
+                }
+
                 // flake8-logging-format
                 if self.settings.rules.enabled(&Rule::LoggingStringFormat)
                     || self.settings.rules.enabled(&Rule::LoggingPercentFormat)
@@ -2823,6 +2917,13 @@ where
                 {
                     flake8_logging_format::rules::logging_call(self, func, args, keywords);
                 }
+
+                // pylint logging checker
+                if self.settings.rules.enabled(&Rule::LoggingTooFewArgs)
+                    || self.settings.rules.enabled(&Rule::LoggingTooManyArgs)
+                {
+                    pylint::rules::logging_call(self, func, args, keywords);
+                }
             }
             ExprKind::Dict { keys, values } => {
                 if self
@@ -3174,13 +3275,13 @@ where
                     flake8_simplify::rules::yoda_conditions(self, expr, left, ops, comparators);
                 }
 
-                if self
-                    .settings
-                    .rules
-                    .enabled(&Rule::UnrecognizedPlatformCheck)
-                    || self.settings.rules.enabled(&Rule::UnrecognizedPlatformName)
-                {
-                    if self.path.extension().map_or(false, |ext| ext == "pyi") {
+                if self.is_interface_definition {
+                    if self
+                        .settings
+                        .rules
+                        .enabled(&Rule::UnrecognizedPlatformCheck)
+                        || self.settings.rules.enabled(&Rule::UnrecognizedPlatformName)
+                    {
                         flake8_pyi::rules::unrecognized_platform(
                             self,
                             expr,
@@ -3653,6 +3754,9 @@ where
                         self.settings.flake8_bandit.check_typed_exception,
                     );
                 }
+                if self.settings.rules.enabled(&Rule::ExceptWithEmptyTuple) {
+                    flake8_bugbear::rules::except_with_empty_tuple(self, excepthandler);
+                }
                 if self.settings.rules.enabled(&Rule::ReraiseNoCause) {
                     tryceratops::rules::reraise_no_cause(self, body);
                 }
@@ -3749,6 +3853,28 @@ where
         }
     }
 
+    fn visit_pattern(&mut self, pattern: &'b Pattern) {
+        if let PatternKind::MatchAs {
+            name: Some(name), ..
+        } = &pattern.node
+        {
+            self.add_binding(
+                name,
+                Binding {
+                    kind: BindingKind::Assignment,
+                    runtime_usage: None,
+                    synthetic_usage: None,
+                    typing_usage: None,
+                    range: Range::from_located(pattern),
+                    source: Some(self.current_stmt().clone()),
+                    context: self.execution_context(),
+                },
+            );
+        }
+
+        walk_pattern(self, pattern);
+    }
+
     fn visit_format_spec(&mut self, format_spec: &'b Expr) {
         match &format_spec.node {
             ExprKind::JoinedStr { values } => {
@@ -4120,146 +4246,147 @@ impl<'a> Checker<'a> {
     }
 
     fn handle_node_load(&mut self, expr: &Expr) {
-        if let ExprKind::Name { id, .. } = &expr.node {
-            let scope_id = self.current_scope().id;
+        let ExprKind::Name { id, .. } = &expr.node else {
+            return;
+        };
+        let scope_id = self.current_scope().id;
 
-            let mut first_iter = true;
-            let mut in_generator = false;
-            let mut import_starred = false;
+        let mut first_iter = true;
+        let mut in_generator = false;
+        let mut import_starred = false;
 
-            for scope_index in self.scope_stack.iter().rev() {
-                let scope = &self.scopes[*scope_index];
-
-                if matches!(scope.kind, ScopeKind::Class(_)) {
-                    if id == "__class__" {
-                        return;
-                    } else if !first_iter && !in_generator {
-                        continue;
-                    }
-                }
-
-                if let Some(index) = scope.bindings.get(&id.as_str()) {
-                    // Mark the binding as used.
-                    let context = self.execution_context();
-                    self.bindings[*index].mark_used(scope_id, Range::from_located(expr), context);
-
-                    if matches!(self.bindings[*index].kind, BindingKind::Annotation)
-                        && !self.in_deferred_string_type_definition
-                        && !self.in_deferred_type_definition
-                    {
-                        continue;
-                    }
-
-                    // If the name of the sub-importation is the same as an alias of another
-                    // importation and the alias is used, that sub-importation should be
-                    // marked as used too.
-                    //
-                    // This handles code like:
-                    //   import pyarrow as pa
-                    //   import pyarrow.csv
-                    //   print(pa.csv.read_csv("test.csv"))
-                    match &self.bindings[*index].kind {
-                        BindingKind::Importation(name, full_name)
-                        | BindingKind::SubmoduleImportation(name, full_name) => {
-                            let has_alias = full_name
-                                .split('.')
-                                .last()
-                                .map(|segment| &segment != name)
-                                .unwrap_or_default();
-                            if has_alias {
-                                // Mark the sub-importation as used.
-                                if let Some(index) = scope.bindings.get(full_name) {
-                                    self.bindings[*index].mark_used(
-                                        scope_id,
-                                        Range::from_located(expr),
-                                        context,
-                                    );
-                                }
-                            }
-                        }
-                        BindingKind::FromImportation(name, full_name) => {
-                            let has_alias = full_name
-                                .split('.')
-                                .last()
-                                .map(|segment| &segment != name)
-                                .unwrap_or_default();
-                            if has_alias {
-                                // Mark the sub-importation as used.
-                                if let Some(index) = scope.bindings.get(full_name.as_str()) {
-                                    self.bindings[*index].mark_used(
-                                        scope_id,
-                                        Range::from_located(expr),
-                                        context,
-                                    );
-                                }
-                            }
-                        }
-                        _ => {}
-                    }
+        for scope_index in self.scope_stack.iter().rev() {
+            let scope = &self.scopes[*scope_index];
 
+            if matches!(scope.kind, ScopeKind::Class(_)) {
+                if id == "__class__" {
                     return;
+                } else if !first_iter && !in_generator {
+                    continue;
                 }
-
-                first_iter = false;
-                in_generator = matches!(scope.kind, ScopeKind::Generator);
-                import_starred = import_starred || scope.import_starred;
             }
 
-            if import_starred {
-                if self.settings.rules.enabled(&Rule::ImportStarUsage) {
-                    let mut from_list = vec![];
-                    for scope_index in self.scope_stack.iter().rev() {
-                        let scope = &self.scopes[*scope_index];
-                        for binding in scope.bindings.values().map(|index| &self.bindings[*index]) {
-                            if let BindingKind::StarImportation(level, module) = &binding.kind {
-                                from_list.push(helpers::format_import_from(
-                                    level.as_ref(),
-                                    module.as_deref(),
-                                ));
+            if let Some(index) = scope.bindings.get(&id.as_str()) {
+                // Mark the binding as used.
+                let context = self.execution_context();
+                self.bindings[*index].mark_used(scope_id, Range::from_located(expr), context);
+
+                if matches!(self.bindings[*index].kind, BindingKind::Annotation)
+                    && !self.in_deferred_string_type_definition
+                    && !self.in_deferred_type_definition
+                {
+                    continue;
+                }
+
+                // If the name of the sub-importation is the same as an alias of another
+                // importation and the alias is used, that sub-importation should be
+                // marked as used too.
+                //
+                // This handles code like:
+                //   import pyarrow as pa
+                //   import pyarrow.csv
+                //   print(pa.csv.read_csv("test.csv"))
+                match &self.bindings[*index].kind {
+                    BindingKind::Importation(name, full_name)
+                    | BindingKind::SubmoduleImportation(name, full_name) => {
+                        let has_alias = full_name
+                            .split('.')
+                            .last()
+                            .map(|segment| &segment != name)
+                            .unwrap_or_default();
+                        if has_alias {
+                            // Mark the sub-importation as used.
+                            if let Some(index) = scope.bindings.get(full_name) {
+                                self.bindings[*index].mark_used(
+                                    scope_id,
+                                    Range::from_located(expr),
+                                    context,
+                                );
                             }
                         }
                     }
-                    from_list.sort();
-
-                    self.diagnostics.push(Diagnostic::new(
-                        pyflakes::rules::ImportStarUsage {
-                            name: id.to_string(),
-                            sources: from_list,
-                        },
-                        Range::from_located(expr),
-                    ));
+                    BindingKind::FromImportation(name, full_name) => {
+                        let has_alias = full_name
+                            .split('.')
+                            .last()
+                            .map(|segment| &segment != name)
+                            .unwrap_or_default();
+                        if has_alias {
+                            // Mark the sub-importation as used.
+                            if let Some(index) = scope.bindings.get(full_name.as_str()) {
+                                self.bindings[*index].mark_used(
+                                    scope_id,
+                                    Range::from_located(expr),
+                                    context,
+                                );
+                            }
+                        }
+                    }
+                    _ => {}
                 }
+
                 return;
             }
 
-            if self.settings.rules.enabled(&Rule::UndefinedName) {
-                // Allow __path__.
-                if self.path.ends_with("__init__.py") && id == "__path__" {
-                    return;
-                }
+            first_iter = false;
+            in_generator = matches!(scope.kind, ScopeKind::Generator);
+            import_starred = import_starred || scope.import_starred;
+        }
 
-                // Allow "__module__" and "__qualname__" in class scopes.
-                if (id == "__module__" || id == "__qualname__")
-                    && matches!(self.current_scope().kind, ScopeKind::Class(..))
-                {
-                    return;
-                }
-
-                // Avoid flagging if NameError is handled.
-                if let Some(handler_names) = self.except_handlers.last() {
-                    if handler_names
-                        .iter()
-                        .any(|call_path| call_path.as_slice() == ["NameError"])
-                    {
-                        return;
+        if import_starred {
+            if self.settings.rules.enabled(&Rule::ImportStarUsage) {
+                let mut from_list = vec![];
+                for scope_index in self.scope_stack.iter().rev() {
+                    let scope = &self.scopes[*scope_index];
+                    for binding in scope.bindings.values().map(|index| &self.bindings[*index]) {
+                        if let BindingKind::StarImportation(level, module) = &binding.kind {
+                            from_list.push(helpers::format_import_from(
+                                level.as_ref(),
+                                module.as_deref(),
+                            ));
+                        }
                     }
                 }
+                from_list.sort();
 
                 self.diagnostics.push(Diagnostic::new(
-                    pyflakes::rules::UndefinedName { name: id.clone() },
+                    pyflakes::rules::ImportStarUsage {
+                        name: id.to_string(),
+                        sources: from_list,
+                    },
                     Range::from_located(expr),
                 ));
             }
+            return;
+        }
+
+        if self.settings.rules.enabled(&Rule::UndefinedName) {
+            // Allow __path__.
+            if self.path.ends_with("__init__.py") && id == "__path__" {
+                return;
+            }
+
+            // Allow "__module__" and "__qualname__" in class scopes.
+            if (id == "__module__" || id == "__qualname__")
+                && matches!(self.current_scope().kind, ScopeKind::Class(..))
+            {
+                return;
+            }
+
+            // Avoid flagging if NameError is handled.
+            if let Some(handler_names) = self.except_handlers.last() {
+                if handler_names
+                    .iter()
+                    .any(|call_path| call_path.as_slice() == ["NameError"])
+                {
+                    return;
+                }
+            }
+
+            self.diagnostics.push(Diagnostic::new(
+                pyflakes::rules::UndefinedName { name: id.clone() },
+                Range::from_located(expr),
+            ));
         }
     }
 
@@ -4457,26 +4584,29 @@ impl<'a> Checker<'a> {
     where
         'b: 'a,
     {
-        if let ExprKind::Name { id, .. } = &expr.node {
-            if operations::on_conditional_branch(
-                &mut self.parents.iter().rev().map(std::convert::Into::into),
-            ) {
-                return;
-            }
-
-            let scope =
-                &mut self.scopes[*(self.scope_stack.last().expect("No current scope found"))];
-            if scope.bindings.remove(&id.as_str()).is_none()
-                && self.settings.rules.enabled(&Rule::UndefinedName)
-            {
-                self.diagnostics.push(Diagnostic::new(
-                    pyflakes::rules::UndefinedName {
-                        name: id.to_string(),
-                    },
-                    Range::from_located(expr),
-                ));
-            }
+        let ExprKind::Name { id, .. } = &expr.node else {
+            return;
+        };
+        if operations::on_conditional_branch(
+            &mut self.parents.iter().rev().map(std::convert::Into::into),
+        ) {
+            return;
         }
+
+        let scope = &mut self.scopes[*(self.scope_stack.last().expect("No current scope found"))];
+        if scope.bindings.remove(&id.as_str()).is_some() {
+            return;
+        }
+        if !self.settings.rules.enabled(&Rule::UndefinedName) {
+            return;
+        }
+
+        self.diagnostics.push(Diagnostic::new(
+            pyflakes::rules::UndefinedName {
+                name: id.to_string(),
+            },
+            Range::from_located(expr),
+        ));
     }
 
     fn visit_docstring<'b>(&mut self, python_ast: &'b Suite) -> bool

crates/ruff/src/checkers/filesystem.rs

@@ -2,6 +2,7 @@ use std::path::Path;
 
 use crate::registry::{Diagnostic, Rule};
 use crate::rules::flake8_no_pep420::rules::implicit_namespace_package;
+use crate::rules::pep8_naming::rules::invalid_module_name;
 use crate::settings::Settings;
 
 pub fn check_file_path(
@@ -20,5 +21,12 @@ pub fn check_file_path(
         }
     }
 
+    // pep8-naming
+    if settings.rules.enabled(&Rule::InvalidModuleName) {
+        if let Some(diagnostic) = invalid_module_name(path, package) {
+            diagnostics.push(diagnostic);
+        }
+    }
+
     diagnostics
 }

crates/ruff/src/checkers/logical_lines.rs

@@ -152,8 +152,8 @@ pub fn check_logical_lines(
 
 #[cfg(test)]
 mod tests {
-    use rustpython_parser::lexer;
     use rustpython_parser::lexer::LexResult;
+    use rustpython_parser::{lexer, Mode};
 
     use crate::checkers::logical_lines::iter_logical_lines;
     use crate::source_code::Locator;
@@ -164,7 +164,7 @@ mod tests {
 x = 1
 y = 2
 z = x + 1"#;
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         let locator = Locator::new(contents);
         let actual: Vec<String> = iter_logical_lines(&lxr, &locator)
             .into_iter()
@@ -185,7 +185,7 @@ x = [
 ]
 y = 2
 z = x + 1"#;
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         let locator = Locator::new(contents);
         let actual: Vec<String> = iter_logical_lines(&lxr, &locator)
             .into_iter()
@@ -199,7 +199,7 @@ z = x + 1"#;
         assert_eq!(actual, expected);
 
         let contents = "x = 'abc'";
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         let locator = Locator::new(contents);
         let actual: Vec<String> = iter_logical_lines(&lxr, &locator)
             .into_iter()
@@ -212,7 +212,7 @@ z = x + 1"#;
 def f():
   x = 1
 f()"#;
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         let locator = Locator::new(contents);
         let actual: Vec<String> = iter_logical_lines(&lxr, &locator)
             .into_iter()
@@ -227,7 +227,7 @@ def f():
   # Comment goes here.
   x = 1
 f()"#;
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         let locator = Locator::new(contents);
         let actual: Vec<String> = iter_logical_lines(&lxr, &locator)
             .into_iter()

crates/ruff/src/checkers/noqa.rs

@@ -1,5 +1,6 @@
 //! `NoQA` enforcement and validation.
 
+use log::warn;
 use nohash_hasher::IntMap;
 use rustpython_parser::ast::Location;
 
@@ -7,7 +8,7 @@ use crate::ast::types::Range;
 use crate::codes::NoqaCode;
 use crate::fix::Fix;
 use crate::noqa;
-use crate::noqa::{is_file_exempt, Directive};
+use crate::noqa::{extract_file_exemption, Directive, Exemption};
 use crate::registry::{Diagnostic, DiagnosticKind, Rule};
 use crate::rule_redirects::get_redirect_target;
 use crate::rules::ruff::rules::{UnusedCodes, UnusedNOQA};
@@ -21,17 +22,38 @@ pub fn check_noqa(
     settings: &Settings,
     autofix: flags::Autofix,
 ) {
-    let mut noqa_directives: IntMap<usize, (Directive, Vec<NoqaCode>)> = IntMap::default();
-    let mut ignored = vec![];
-
     let enforce_noqa = settings.rules.enabled(&Rule::UnusedNOQA);
 
+    // Whether the file is exempted from all checks.
+    let mut file_exempted = false;
+
+    // Codes that are globally exempted (within the current file).
+    let mut file_exemptions: Vec<NoqaCode> = vec![];
+
+    // Map from line number to `noqa` directive on that line, along with any codes
+    // that were matched by the directive.
+    let mut noqa_directives: IntMap<usize, (Directive, Vec<NoqaCode>)> = IntMap::default();
+
+    // Indices of diagnostics that were ignored by a `noqa` directive.
+    let mut ignored_diagnostics = vec![];
+
     let lines: Vec<&str> = contents.lines().collect();
     for lineno in commented_lines {
-        // If we hit an exemption for the entire file, bail.
-        if is_file_exempt(lines[lineno - 1]) {
-            diagnostics.drain(..);
-            return;
+        match extract_file_exemption(lines[lineno - 1]) {
+            Exemption::All => {
+                file_exempted = true;
+            }
+            Exemption::Codes(codes) => {
+                file_exemptions.extend(codes.into_iter().filter_map(|code| {
+                    if let Ok(rule) = Rule::from_code(get_redirect_target(code).unwrap_or(code)) {
+                        Some(rule.noqa_code())
+                    } else {
+                        warn!("Invalid code provided to `# ruff: noqa`: {}", code);
+                        None
+                    }
+                }));
+            }
+            Exemption::None => {}
         }
 
         if enforce_noqa {
@@ -47,6 +69,20 @@ pub fn check_noqa(
             continue;
         }
 
+        // If the file is exempted, ignore all diagnostics.
+        if file_exempted {
+            ignored_diagnostics.push(index);
+            continue;
+        }
+
+        // If the diagnostic is ignored by a global exemption, ignore it.
+        if !file_exemptions.is_empty() {
+            if file_exemptions.contains(&diagnostic.kind.rule().noqa_code()) {
+                ignored_diagnostics.push(index);
+                continue;
+            }
+        }
+
         // Is the violation ignored by a `noqa` directive on the parent line?
         if let Some(parent_lineno) = diagnostic.parent.map(|location| location.row()) {
             let noqa_lineno = noqa_line_for.get(&parent_lineno).unwrap_or(&parent_lineno);
@@ -57,13 +93,13 @@ pub fn check_noqa(
                 match noqa {
                     (Directive::All(..), matches) => {
                         matches.push(diagnostic.kind.rule().noqa_code());
-                        ignored.push(index);
+                        ignored_diagnostics.push(index);
                         continue;
                     }
                     (Directive::Codes(.., codes), matches) => {
                         if noqa::includes(diagnostic.kind.rule(), codes) {
                             matches.push(diagnostic.kind.rule().noqa_code());
-                            ignored.push(index);
+                            ignored_diagnostics.push(index);
                             continue;
                         }
                     }
@@ -84,12 +120,14 @@ pub fn check_noqa(
             match noqa {
                 (Directive::All(..), matches) => {
                     matches.push(diagnostic.kind.rule().noqa_code());
-                    ignored.push(index);
+                    ignored_diagnostics.push(index);
+                    continue;
                 }
                 (Directive::Codes(.., codes), matches) => {
                     if noqa::includes(diagnostic.kind.rule(), codes) {
                         matches.push(diagnostic.kind.rule().noqa_code());
-                        ignored.push(index);
+                        ignored_diagnostics.push(index);
+                        continue;
                     }
                 }
                 (Directive::None, ..) => {}
@@ -203,8 +241,8 @@ pub fn check_noqa(
         }
     }
 
-    ignored.sort_unstable();
-    for index in ignored.iter().rev() {
+    ignored_diagnostics.sort_unstable();
+    for index in ignored_diagnostics.iter().rev() {
         diagnostics.swap_remove(*index);
     }
 }

crates/ruff/src/checkers/tokens.rs

@@ -1,6 +1,7 @@
 //! Lint rules based on token traversal.
 
-use rustpython_parser::lexer::{LexResult, Tok};
+use rustpython_parser::lexer::LexResult;
+use rustpython_parser::Tok;
 
 use crate::lex::docstring_detection::StateMachine;
 use crate::registry::{Diagnostic, Rule};
@@ -117,7 +118,7 @@ pub fn check_tokens(
     // E701, E702, E703
     if enforce_compound_statements {
         diagnostics.extend(
-            pycodestyle::rules::compound_statements(tokens)
+            pycodestyle::rules::compound_statements(tokens, settings, autofix)
                 .into_iter()
                 .filter(|diagnostic| settings.rules.enabled(diagnostic.kind.rule())),
         );

crates/ruff/src/codes.rs

@@ -123,8 +123,11 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<Rule> {
 
         // pylint
         (Pylint, "E0100") => Rule::YieldInInit,
+        (Pylint, "E0101") => Rule::ReturnInInit,
         (Pylint, "E0604") => Rule::InvalidAllObject,
         (Pylint, "E0605") => Rule::InvalidAllFormat,
+        (Pylint, "E1205") => Rule::LoggingTooManyArgs,
+        (Pylint, "E1206") => Rule::LoggingTooFewArgs,
         (Pylint, "E1307") => Rule::BadStringFormatType,
         (Pylint, "E2502") => Rule::BidirectionalUnicode,
         (Pylint, "E1310") => Rule::BadStrStripCall,
@@ -145,6 +148,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<Rule> {
         (Pylint, "R0913") => Rule::TooManyArguments,
         (Pylint, "R0912") => Rule::TooManyBranches,
         (Pylint, "R0915") => Rule::TooManyStatements,
+        (Pylint, "W2901") => Rule::RedefinedLoopName,
 
         // flake8-builtins
         (Flake8Builtins, "001") => Rule::BuiltinVariableShadowing,
@@ -178,6 +182,8 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<Rule> {
         (Flake8Bugbear, "025") => Rule::DuplicateTryBlockException,
         (Flake8Bugbear, "026") => Rule::StarArgUnpackingAfterKeywordArg,
         (Flake8Bugbear, "027") => Rule::EmptyMethodWithoutAbstractDecorator,
+        (Flake8Bugbear, "029") => Rule::ExceptWithEmptyTuple,
+        (Flake8Bugbear, "032") => Rule::UnintentionalTypeAnnotation,
         (Flake8Bugbear, "904") => Rule::RaiseWithoutFromInsideExcept,
         (Flake8Bugbear, "905") => Rule::ZipWithoutExplicitStrict,
 
@@ -270,11 +276,12 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<Rule> {
         (Flake8Simplify, "107") => Rule::ReturnInTryExceptFinally,
         (Flake8Simplify, "108") => Rule::UseTernaryOperator,
         (Flake8Simplify, "109") => Rule::CompareWithTuple,
-        (Flake8Simplify, "110") => Rule::ConvertLoopToAny,
-        (Flake8Simplify, "111") => Rule::ConvertLoopToAll,
+        (Flake8Simplify, "110") => Rule::ReimplementedBuiltin,
+        // (Flake8Simplify, "111") => Rule::ReimplementedBuiltin,
         (Flake8Simplify, "112") => Rule::UseCapitalEnvironmentVariables,
         (Flake8Simplify, "114") => Rule::IfWithSameArms,
         (Flake8Simplify, "115") => Rule::OpenFileWithContextHandler,
+        (Flake8Simplify, "116") => Rule::ManualDictLookup,
         (Flake8Simplify, "117") => Rule::MultipleWithStatements,
         (Flake8Simplify, "118") => Rule::KeyInDict,
         (Flake8Simplify, "201") => Rule::NegateEqualOp,
@@ -391,6 +398,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<Rule> {
         (PEP8Naming, "816") => Rule::MixedCaseVariableInGlobalScope,
         (PEP8Naming, "817") => Rule::CamelcaseImportedAsAcronym,
         (PEP8Naming, "818") => Rule::ErrorSuffixOnExceptionName,
+        (PEP8Naming, "999") => Rule::InvalidModuleName,
 
         // isort
         (Isort, "001") => Rule::UnsortedImports,
@@ -543,6 +551,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<Rule> {
         (Tryceratops, "300") => Rule::TryConsiderElse,
         (Tryceratops, "301") => Rule::RaiseWithinTry,
         (Tryceratops, "400") => Rule::ErrorInsteadOfException,
+        (Tryceratops, "401") => Rule::VerboseLogMessage,
 
         // flake8-use-pathlib
         (Flake8UsePathlib, "100") => Rule::PathlibAbspath,
@@ -589,6 +598,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<Rule> {
 
         // numpy
         (Numpy, "001") => Rule::NumpyDeprecatedTypeAlias,
+        (Numpy, "002") => Rule::NumpyLegacyRandom,
 
         // ruff
         (Ruff, "001") => Rule::AmbiguousUnicodeCharacterString,

crates/ruff/src/directives.rs

@@ -3,7 +3,8 @@
 use bitflags::bitflags;
 use nohash_hasher::{IntMap, IntSet};
 use rustpython_parser::ast::Location;
-use rustpython_parser::lexer::{LexResult, Tok};
+use rustpython_parser::lexer::LexResult;
+use rustpython_parser::Tok;
 
 use crate::registry::LintSource;
 use crate::settings::Settings;
@@ -150,56 +151,61 @@ pub fn extract_isort_directives(lxr: &[LexResult]) -> IsortDirectives {
 #[cfg(test)]
 mod tests {
     use nohash_hasher::{IntMap, IntSet};
-    use rustpython_parser::lexer;
     use rustpython_parser::lexer::LexResult;
+    use rustpython_parser::{lexer, Mode};
 
     use crate::directives::{extract_isort_directives, extract_noqa_line_for};
 
     #[test]
     fn noqa_extraction() {
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+        let lxr: Vec<LexResult> = lexer::lex(
             "x = 1
 y = 2
 z = x + 1",
+            Mode::Module,
         )
         .collect();
         assert_eq!(extract_noqa_line_for(&lxr), IntMap::default());
 
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+        let lxr: Vec<LexResult> = lexer::lex(
             "
 x = 1
 y = 2
 z = x + 1",
+            Mode::Module,
         )
         .collect();
         assert_eq!(extract_noqa_line_for(&lxr), IntMap::default());
 
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+        let lxr: Vec<LexResult> = lexer::lex(
             "x = 1
 y = 2
 z = x + 1
         ",
+            Mode::Module,
         )
         .collect();
         assert_eq!(extract_noqa_line_for(&lxr), IntMap::default());
 
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+        let lxr: Vec<LexResult> = lexer::lex(
             "x = 1
 
 y = 2
 z = x + 1
         ",
+            Mode::Module,
         )
         .collect();
         assert_eq!(extract_noqa_line_for(&lxr), IntMap::default());
 
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+        let lxr: Vec<LexResult> = lexer::lex(
             "x = '''abc
 def
 ghi
 '''
 y = 2
 z = x + 1",
+            Mode::Module,
         )
         .collect();
         assert_eq!(
@@ -207,13 +213,14 @@ z = x + 1",
             IntMap::from_iter([(1, 4), (2, 4), (3, 4)])
         );
 
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+        let lxr: Vec<LexResult> = lexer::lex(
             "x = 1
 y = '''abc
 def
 ghi
 '''
 z = 2",
+            Mode::Module,
         )
         .collect();
         assert_eq!(
@@ -221,12 +228,13 @@ z = 2",
             IntMap::from_iter([(2, 5), (3, 5), (4, 5)])
         );
 
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+        let lxr: Vec<LexResult> = lexer::lex(
             "x = 1
 y = '''abc
 def
 ghi
 '''",
+            Mode::Module,
         )
         .collect();
         assert_eq!(
@@ -234,17 +242,19 @@ ghi
             IntMap::from_iter([(2, 5), (3, 5), (4, 5)])
         );
 
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+        let lxr: Vec<LexResult> = lexer::lex(
             r#"x = \
     1"#,
+            Mode::Module,
         )
         .collect();
         assert_eq!(extract_noqa_line_for(&lxr), IntMap::from_iter([(1, 2)]));
 
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+        let lxr: Vec<LexResult> = lexer::lex(
             r#"from foo import \
     bar as baz, \
     qux as quux"#,
+            Mode::Module,
         )
         .collect();
         assert_eq!(
@@ -252,7 +262,7 @@ ghi
             IntMap::from_iter([(1, 3), (2, 3)])
         );
 
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+        let lxr: Vec<LexResult> = lexer::lex(
             r#"
 # Foo
 from foo import \
@@ -262,6 +272,7 @@ x = \
     1
 y = \
     2"#,
+            Mode::Module,
         )
         .collect();
         assert_eq!(
@@ -275,7 +286,7 @@ y = \
         let contents = "x = 1
 y = 2
 z = x + 1";
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         assert_eq!(extract_isort_directives(&lxr).exclusions, IntSet::default());
 
         let contents = "# isort: off
@@ -283,7 +294,7 @@ x = 1
 y = 2
 # isort: on
 z = x + 1";
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         assert_eq!(
             extract_isort_directives(&lxr).exclusions,
             IntSet::from_iter([2, 3, 4])
@@ -296,7 +307,7 @@ y = 2
 # isort: on
 z = x + 1
 # isort: on";
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         assert_eq!(
             extract_isort_directives(&lxr).exclusions,
             IntSet::from_iter([2, 3, 4, 5])
@@ -306,7 +317,7 @@ z = x + 1
 x = 1
 y = 2
 z = x + 1";
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         assert_eq!(
             extract_isort_directives(&lxr).exclusions,
             IntSet::from_iter([2, 3, 4])
@@ -316,7 +327,7 @@ z = x + 1";
 x = 1
 y = 2
 z = x + 1";
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         assert_eq!(extract_isort_directives(&lxr).exclusions, IntSet::default());
 
         let contents = "# isort: off
@@ -325,7 +336,7 @@ x = 1
 y = 2
 # isort: skip_file
 z = x + 1";
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         assert_eq!(extract_isort_directives(&lxr).exclusions, IntSet::default());
     }
 
@@ -334,20 +345,20 @@ z = x + 1";
         let contents = "x = 1
 y = 2
 z = x + 1";
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         assert_eq!(extract_isort_directives(&lxr).splits, Vec::<usize>::new());
 
         let contents = "x = 1
 y = 2
 # isort: split
 z = x + 1";
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         assert_eq!(extract_isort_directives(&lxr).splits, vec![3]);
 
         let contents = "x = 1
 y = 2  # isort: split
 z = x + 1";
-        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let lxr: Vec<LexResult> = lexer::lex(contents, Mode::Module).collect();
         assert_eq!(extract_isort_directives(&lxr).splits, vec![2]);
     }
 }

crates/ruff/src/doc_lines.rs

@@ -1,34 +1,62 @@
 //! Doc line extraction. In this context, a doc line is a line consisting of a
 //! standalone comment or a constant string statement.
 
+use std::iter::FusedIterator;
+
 use rustpython_parser::ast::{Constant, ExprKind, Stmt, StmtKind, Suite};
-use rustpython_parser::lexer::{LexResult, Tok};
+use rustpython_parser::lexer::LexResult;
+use rustpython_parser::Tok;
 
 use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
 
 /// Extract doc lines (standalone comments) from a token sequence.
-pub fn doc_lines_from_tokens(lxr: &[LexResult]) -> Vec<usize> {
-    let mut doc_lines: Vec<usize> = Vec::default();
-    let mut prev: Option<usize> = None;
-    for (start, tok, end) in lxr.iter().flatten() {
-        if matches!(tok, Tok::Indent | Tok::Dedent | Tok::Newline) {
-            continue;
-        }
-        if matches!(tok, Tok::Comment(..)) {
-            if let Some(prev) = prev {
-                if start.row() > prev {
-                    doc_lines.push(start.row());
-                }
-            } else {
-                doc_lines.push(start.row());
-            }
-        }
-        prev = Some(end.row());
-    }
-    doc_lines
+pub fn doc_lines_from_tokens(lxr: &[LexResult]) -> DocLines {
+    DocLines::new(lxr)
 }
 
+pub struct DocLines<'a> {
+    inner: std::iter::Flatten<core::slice::Iter<'a, LexResult>>,
+    prev: Option<usize>,
+}
+
+impl<'a> DocLines<'a> {
+    fn new(lxr: &'a [LexResult]) -> Self {
+        Self {
+            inner: lxr.iter().flatten(),
+            prev: None,
+        }
+    }
+}
+
+impl Iterator for DocLines<'_> {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let (start, tok, end) = self.inner.next()?;
+
+            match tok {
+                Tok::Indent | Tok::Dedent | Tok::Newline => continue,
+                Tok::Comment(..) => {
+                    if let Some(prev) = self.prev {
+                        if start.row() > prev {
+                            break Some(start.row());
+                        }
+                    } else {
+                        break Some(start.row());
+                    }
+                }
+                _ => {}
+            }
+
+            self.prev = Some(end.row());
+        }
+    }
+}
+
+impl FusedIterator for DocLines<'_> {}
+
 #[derive(Default)]
 struct StringLinesVisitor {
     string_lines: Vec<usize>,

crates/ruff/src/fs.rs

@@ -1,5 +1,3 @@
-use std::fs::File;
-use std::io::{BufReader, Read};
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 
@@ -88,12 +86,3 @@ pub fn relativize_path(path: impl AsRef<Path>) -> String {
     }
     format!("{}", path.display())
 }
-
-/// Read a file's contents from disk.
-pub fn read_file<P: AsRef<Path>>(path: P) -> Result<String> {
-    let file = File::open(path)?;
-    let mut buf_reader = BufReader::new(file);
-    let mut contents = String::new();
-    buf_reader.read_to_string(&mut contents)?;
-    Ok(contents)
-}

crates/ruff/src/lex/docstring_detection.rs

@@ -4,7 +4,7 @@
 //!
 //! TODO(charlie): Consolidate with the existing AST-based docstring extraction.
 
-use rustpython_parser::lexer::Tok;
+use rustpython_parser::Tok;
 
 #[derive(Default)]
 enum State {

crates/ruff/src/lib.rs

@@ -5,12 +5,12 @@
 //!
 //! [Ruff]: https://github.com/charliermarsh/ruff
 
+pub use ast::types::Range;
 use cfg_if::cfg_if;
 pub use rule_selector::RuleSelector;
 pub use rules::pycodestyle::rules::IOError;
 pub use violation::{AutofixKind, Availability as AutofixAvailability};
 
-mod assert_yaml_snapshot;
 mod ast;
 mod autofix;
 pub mod cache;

crates/ruff/src/lib_wasm.rs

@@ -9,10 +9,10 @@ use crate::directives;
 use crate::linter::{check_path, LinterResult};
 use crate::registry::Rule;
 use crate::rules::{
-    flake8_annotations, flake8_bandit, flake8_bugbear, flake8_builtins, flake8_errmsg,
-    flake8_implicit_str_concat, flake8_import_conventions, flake8_pytest_style, flake8_quotes,
-    flake8_tidy_imports, flake8_type_checking, flake8_unused_arguments, isort, mccabe, pep8_naming,
-    pycodestyle, pydocstyle, pylint, pyupgrade,
+    flake8_annotations, flake8_bandit, flake8_bugbear, flake8_builtins, flake8_comprehensions,
+    flake8_errmsg, flake8_implicit_str_concat, flake8_import_conventions, flake8_pytest_style,
+    flake8_quotes, flake8_self, flake8_tidy_imports, flake8_type_checking, flake8_unused_arguments,
+    isort, mccabe, pep8_naming, pycodestyle, pydocstyle, pylint, pyupgrade,
 };
 use crate::rustpython_helpers::tokenize;
 use crate::settings::configuration::Configuration;
@@ -139,9 +139,11 @@ pub fn defaultSettings() -> Result<JsValue, JsValue> {
         flake8_bandit: Some(flake8_bandit::settings::Settings::default().into()),
         flake8_bugbear: Some(flake8_bugbear::settings::Settings::default().into()),
         flake8_builtins: Some(flake8_builtins::settings::Settings::default().into()),
+        flake8_comprehensions: Some(flake8_comprehensions::settings::Settings::default().into()),
         flake8_errmsg: Some(flake8_errmsg::settings::Settings::default().into()),
         flake8_pytest_style: Some(flake8_pytest_style::settings::Settings::default().into()),
         flake8_quotes: Some(flake8_quotes::settings::Settings::default().into()),
+        flake8_self: Some(flake8_self::settings::Settings::default().into()),
         flake8_implicit_str_concat: Some(
             flake8_implicit_str_concat::settings::Settings::default().into(),
         ),

crates/ruff/src/linter.rs

@@ -5,8 +5,8 @@ use anyhow::{anyhow, Result};
 use colored::Colorize;
 use log::error;
 use rustc_hash::FxHashMap;
-use rustpython_parser::error::ParseError;
 use rustpython_parser::lexer::LexResult;
+use rustpython_parser::ParseError;
 
 use crate::autofix::fix_file;
 use crate::checkers::ast::check_ast;
@@ -223,7 +223,7 @@ const MAX_ITERATIONS: usize = 100;
 /// Add any missing `# noqa` pragmas to the source code at the given `Path`.
 pub fn add_noqa_to_path(path: &Path, package: Option<&Path>, settings: &Settings) -> Result<usize> {
     // Read the file from disk.
-    let contents = fs::read_file(path)?;
+    let contents = std::fs::read_to_string(path)?;
 
     // Tokenize once.
     let tokens: Vec<LexResult> = rustpython_helpers::tokenize(&contents);

crates/ruff/src/noqa.rs

@@ -4,6 +4,7 @@ use std::path::Path;
 
 use anyhow::Result;
 use itertools::Itertools;
+use log::warn;
 use nohash_hasher::IntMap;
 use once_cell::sync::Lazy;
 use regex::Regex;
@@ -11,6 +12,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_parser::ast::Location;
 
 use crate::ast::types::Range;
+use crate::codes::NoqaCode;
 use crate::registry::{Diagnostic, Rule};
 use crate::rule_redirects::get_redirect_target;
 use crate::source_code::{LineEnding, Locator};
@@ -23,16 +25,47 @@ static NOQA_LINE_REGEX: Lazy<Regex> = Lazy::new(|| {
 });
 static SPLIT_COMMA_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"[,\s]").unwrap());
 
+#[derive(Debug)]
+pub enum Exemption<'a> {
+    None,
+    All,
+    Codes(Vec<&'a str>),
+}
+
 /// Return `true` if a file is exempt from checking based on the contents of the
 /// given line.
-pub fn is_file_exempt(line: &str) -> bool {
+pub fn extract_file_exemption(line: &str) -> Exemption {
     let line = line.trim_start();
-    line.starts_with("# flake8: noqa")
+
+    if line.starts_with("# flake8: noqa")
         || line.starts_with("# flake8: NOQA")
         || line.starts_with("# flake8: NoQA")
-        || line.starts_with("# ruff: noqa")
-        || line.starts_with("# ruff: NOQA")
-        || line.starts_with("# ruff: NoQA")
+    {
+        return Exemption::All;
+    }
+
+    if let Some(remainder) = line
+        .strip_prefix("# ruff: noqa")
+        .or_else(|| line.strip_prefix("# ruff: NOQA"))
+        .or_else(|| line.strip_prefix("# ruff: NoQA"))
+    {
+        if remainder.is_empty() {
+            return Exemption::All;
+        } else if let Some(codes) = remainder.strip_prefix(':') {
+            let codes: Vec<&str> = SPLIT_COMMA_REGEX
+                .split(codes.trim())
+                .map(str::trim)
+                .filter(|code| !code.is_empty())
+                .collect();
+            if codes.is_empty() {
+                warn!("Expected rule codes on `noqa` directive: \"{line}\"");
+            }
+            return Exemption::Codes(codes);
+        }
+        warn!("Unexpected suffix on `noqa` directive: \"{line}\"");
+    }
+
+    Exemption::None
 }
 
 #[derive(Debug)]
@@ -48,16 +81,22 @@ pub fn extract_noqa_directive(line: &str) -> Directive {
         Some(caps) => match caps.name("spaces") {
             Some(spaces) => match caps.name("noqa") {
                 Some(noqa) => match caps.name("codes") {
-                    Some(codes) => Directive::Codes(
-                        spaces.as_str().chars().count(),
-                        noqa.start(),
-                        noqa.end(),
-                        SPLIT_COMMA_REGEX
-                            .split(codes.as_str())
+                    Some(codes) => {
+                        let codes: Vec<&str> = SPLIT_COMMA_REGEX
+                            .split(codes.as_str().trim())
                             .map(str::trim)
                             .filter(|code| !code.is_empty())
-                            .collect(),
-                    ),
+                            .collect();
+                        if codes.is_empty() {
+                            warn!("Expected rule codes on `noqa` directive: \"{line}\"");
+                        }
+                        Directive::Codes(
+                            spaces.as_str().chars().count(),
+                            noqa.start(),
+                            noqa.end(),
+                            codes,
+                        )
+                    }
                     None => {
                         Directive::All(spaces.as_str().chars().count(), noqa.start(), noqa.end())
                     }
@@ -124,68 +163,93 @@ fn add_noqa_inner(
     noqa_line_for: &IntMap<usize, usize>,
     line_ending: &LineEnding,
 ) -> (usize, String) {
+    // Map of line number to set of (non-ignored) diagnostic codes that are triggered on that line.
     let mut matches_by_line: FxHashMap<usize, FxHashSet<&Rule>> = FxHashMap::default();
+
+    // Whether the file is exempted from all checks.
+    let mut file_exempted = false;
+
+    // Codes that are globally exempted (within the current file).
+    let mut file_exemptions: Vec<NoqaCode> = vec![];
+
     let lines: Vec<&str> = contents.lines().collect();
-    for (lineno, line) in lines.iter().enumerate() {
-        // If we hit an exemption for the entire file, bail.
-        if is_file_exempt(line) {
-            return (0, contents.to_string());
+    for lineno in commented_lines {
+        match extract_file_exemption(lines[lineno - 1]) {
+            Exemption::All => {
+                file_exempted = true;
+            }
+            Exemption::Codes(codes) => {
+                file_exemptions.extend(codes.into_iter().filter_map(|code| {
+                    if let Ok(rule) = Rule::from_code(get_redirect_target(code).unwrap_or(code)) {
+                        Some(rule.noqa_code())
+                    } else {
+                        warn!("Invalid code provided to `# ruff: noqa`: {}", code);
+                        None
+                    }
+                }));
+            }
+            Exemption::None => {}
+        }
+    }
+
+    // Mark any non-ignored diagnostics.
+    for diagnostic in diagnostics {
+        // If the file is exempted, don't add any noqa directives.
+        if file_exempted {
+            continue;
         }
 
-        // Grab the noqa (logical) line number for the current (physical) line.
-        let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
-
-        let mut codes: FxHashSet<&Rule> = FxHashSet::default();
-        for diagnostic in diagnostics {
-            if diagnostic.location.row() == lineno + 1 {
-                // Is the violation ignored by a `noqa` directive on the parent line?
-                if let Some(parent_lineno) = diagnostic.parent.map(|location| location.row()) {
-                    let noqa_lineno = noqa_line_for.get(&parent_lineno).unwrap_or(&parent_lineno);
-                    if commented_lines.contains(noqa_lineno) {
-                        match extract_noqa_directive(lines[noqa_lineno - 1]) {
-                            Directive::All(..) => {
-                                continue;
-                            }
-                            Directive::Codes(.., codes) => {
-                                if includes(diagnostic.kind.rule(), &codes) {
-                                    continue;
-                                }
-                            }
-                            Directive::None => {}
-                        }
-                    }
-                }
-
-                // Is the diagnostic ignored by a `noqa` directive on the same line?
-                let diagnostic_lineno = diagnostic.location.row();
-                let noqa_lineno = noqa_line_for
-                    .get(&diagnostic_lineno)
-                    .unwrap_or(&diagnostic_lineno);
-                if commented_lines.contains(noqa_lineno) {
-                    match extract_noqa_directive(lines[noqa_lineno - 1]) {
-                        Directive::All(..) => {
-                            continue;
-                        }
-                        Directive::Codes(.., codes) => {
-                            if includes(diagnostic.kind.rule(), &codes) {
-                                continue;
-                            }
-                        }
-                        Directive::None => {}
-                    }
-                }
-
-                // The diagnostic is not ignored by any `noqa` directive; add it to the list.
-                codes.insert(diagnostic.kind.rule());
+        // If the diagnostic is ignored by a global exemption, don't add a noqa directive.
+        if !file_exemptions.is_empty() {
+            if file_exemptions.contains(&diagnostic.kind.rule().noqa_code()) {
+                continue;
             }
         }
 
-        if !codes.is_empty() {
-            matches_by_line
-                .entry(noqa_lineno)
-                .or_default()
-                .extend(codes);
+        // Is the violation ignored by a `noqa` directive on the parent line?
+        if let Some(parent_lineno) = diagnostic.parent.map(|location| location.row()) {
+            let noqa_lineno = noqa_line_for.get(&parent_lineno).unwrap_or(&parent_lineno);
+            if commented_lines.contains(noqa_lineno) {
+                match extract_noqa_directive(lines[noqa_lineno - 1]) {
+                    Directive::All(..) => {
+                        continue;
+                    }
+                    Directive::Codes(.., codes) => {
+                        if includes(diagnostic.kind.rule(), &codes) {
+                            continue;
+                        }
+                    }
+                    Directive::None => {}
+                }
+            }
         }
+
+        // Is the diagnostic ignored by a `noqa` directive on the same line?
+        let diagnostic_lineno = diagnostic.location.row();
+        let noqa_lineno = noqa_line_for
+            .get(&diagnostic_lineno)
+            .unwrap_or(&diagnostic_lineno);
+        if commented_lines.contains(noqa_lineno) {
+            match extract_noqa_directive(lines[noqa_lineno - 1]) {
+                Directive::All(..) => {
+                    continue;
+                }
+                Directive::Codes(.., codes) => {
+                    if includes(diagnostic.kind.rule(), &codes) {
+                        continue;
+                    }
+                }
+                Directive::None => {}
+            }
+        }
+
+        // The diagnostic is not ignored by any `noqa` directive; add it to the list.
+        let lineno = diagnostic.location.row() - 1;
+        let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
+        matches_by_line
+            .entry(noqa_lineno)
+            .or_default()
+            .insert(diagnostic.kind.rule());
     }
 
     let mut count: usize = 0;
@@ -258,7 +322,7 @@ fn push_codes<I: Display>(str: &mut String, codes: impl Iterator<Item = I>) {
         if !first {
             str.push_str(", ");
         }
-        let _ = write!(str, "{}", code);
+        let _ = write!(str, "{code}");
         first = false;
     }
 }

crates/ruff/src/registry.rs

@@ -137,6 +137,7 @@ ruff_macros::register_rules!(
     rules::pylint::rules::UsedPriorGlobalDeclaration,
     rules::pylint::rules::AwaitOutsideAsync,
     rules::pylint::rules::PropertyWithParameters,
+    rules::pylint::rules::ReturnInInit,
     rules::pylint::rules::ConsiderUsingFromImport,
     rules::pylint::rules::ComparisonOfConstant,
     rules::pylint::rules::ConsiderMergingIsinstance,
@@ -148,6 +149,9 @@ ruff_macros::register_rules!(
     rules::pylint::rules::TooManyArguments,
     rules::pylint::rules::TooManyBranches,
     rules::pylint::rules::TooManyStatements,
+    rules::pylint::rules::RedefinedLoopName,
+    rules::pylint::rules::LoggingTooFewArgs,
+    rules::pylint::rules::LoggingTooManyArgs,
     // flake8-builtins
     rules::flake8_builtins::rules::BuiltinVariableShadowing,
     rules::flake8_builtins::rules::BuiltinArgumentShadowing,
@@ -181,6 +185,8 @@ ruff_macros::register_rules!(
     rules::flake8_bugbear::rules::EmptyMethodWithoutAbstractDecorator,
     rules::flake8_bugbear::rules::RaiseWithoutFromInsideExcept,
     rules::flake8_bugbear::rules::ZipWithoutExplicitStrict,
+    rules::flake8_bugbear::rules::ExceptWithEmptyTuple,
+    rules::flake8_bugbear::rules::UnintentionalTypeAnnotation,
     // flake8-blind-except
     rules::flake8_blind_except::rules::BlindExcept,
     // flake8-comprehensions
@@ -252,6 +258,7 @@ ruff_macros::register_rules!(
     rules::flake8_2020::rules::SysVersionCmpStr10,
     rules::flake8_2020::rules::SysVersionSlice1Referenced,
     // flake8-simplify
+    rules::flake8_simplify::rules::ManualDictLookup,
     rules::flake8_simplify::rules::DuplicateIsinstanceCall,
     rules::flake8_simplify::rules::CollapsibleIf,
     rules::flake8_simplify::rules::NeedlessBool,
@@ -259,8 +266,7 @@ ruff_macros::register_rules!(
     rules::flake8_simplify::rules::ReturnInTryExceptFinally,
     rules::flake8_simplify::rules::UseTernaryOperator,
     rules::flake8_simplify::rules::CompareWithTuple,
-    rules::flake8_simplify::rules::ConvertLoopToAny,
-    rules::flake8_simplify::rules::ConvertLoopToAll,
+    rules::flake8_simplify::rules::ReimplementedBuiltin,
     rules::flake8_simplify::rules::UseCapitalEnvironmentVariables,
     rules::flake8_simplify::rules::IfWithSameArms,
     rules::flake8_simplify::rules::OpenFileWithContextHandler,
@@ -377,6 +383,7 @@ ruff_macros::register_rules!(
     rules::pep8_naming::rules::MixedCaseVariableInGlobalScope,
     rules::pep8_naming::rules::CamelcaseImportedAsAcronym,
     rules::pep8_naming::rules::ErrorSuffixOnExceptionName,
+    rules::pep8_naming::rules::InvalidModuleName,
     // isort
     rules::isort::rules::UnsortedImports,
     rules::isort::rules::MissingRequiredImport,
@@ -511,6 +518,7 @@ ruff_macros::register_rules!(
     rules::tryceratops::rules::TryConsiderElse,
     rules::tryceratops::rules::RaiseWithinTry,
     rules::tryceratops::rules::ErrorInsteadOfException,
+    rules::tryceratops::rules::VerboseLogMessage,
     // flake8-use-pathlib
     rules::flake8_use_pathlib::violations::PathlibAbspath,
     rules::flake8_use_pathlib::violations::PathlibChmod,
@@ -552,6 +560,7 @@ ruff_macros::register_rules!(
     rules::flake8_self::rules::PrivateMemberAccess,
     // numpy
     rules::numpy::rules::NumpyDeprecatedTypeAlias,
+    rules::numpy::rules::NumpyLegacyRandom,
     // ruff
     rules::ruff::rules::AmbiguousUnicodeCharacterString,
     rules::ruff::rules::AmbiguousUnicodeCharacterDocstring,
@@ -797,7 +806,7 @@ impl Rule {
             | Rule::TrailingCommaProhibited => &LintSource::Tokens,
             Rule::IOError => &LintSource::Io,
             Rule::UnsortedImports | Rule::MissingRequiredImport => &LintSource::Imports,
-            Rule::ImplicitNamespacePackage => &LintSource::Filesystem,
+            Rule::ImplicitNamespacePackage | Rule::InvalidModuleName => &LintSource::Filesystem,
             #[cfg(feature = "logical_lines")]
             Rule::IndentationWithInvalidMultiple
             | Rule::IndentationWithInvalidMultipleComment

crates/ruff/src/resolver.rs

@@ -203,6 +203,11 @@ fn is_python_path(path: &Path) -> bool {
         .map_or(false, |ext| ext == "py" || ext == "pyi")
 }
 
+/// Return `true` if the `Path` appears to be that of a Python interface definition file (`.pyi`).
+pub fn is_interface_definition_path(path: &Path) -> bool {
+    path.extension().map_or(false, |ext| ext == "pyi")
+}
+
 /// Return `true` if the `Entry` appears to be that of a Python file.
 pub fn is_python_entry(entry: &DirEntry) -> bool {
     is_python_path(entry.path())

crates/ruff/src/rule_redirects.rs

@@ -15,6 +15,9 @@ pub(crate) fn get_redirect(code: &str) -> Option<(&'static str, &'static str)> {
 
 static REDIRECTS: Lazy<HashMap<&'static str, &'static str>> = Lazy::new(|| {
     HashMap::from_iter([
+        // The following are here because we don't yet have the many-to-one mapping enabled.
+        ("SIM111", "SIM110"),
+        // The following are deprecated.
         ("C", "C4"),
         ("C9", "C90"),
         ("T", "T10"),

crates/ruff/src/rules/eradicate/detection.rs

@@ -1,6 +1,7 @@
 /// See: [eradicate.py](https://github.com/myint/eradicate/blob/98f199940979c94447a461d50d27862b118b282d/eradicate.py)
 use once_cell::sync::Lazy;
 use regex::Regex;
+use rustpython_parser as parser;
 
 static ALLOWLIST_REGEX: Lazy<Regex> = Lazy::new(|| {
     Regex::new(
@@ -77,7 +78,7 @@ pub fn comment_contains_code(line: &str, task_tags: &[String]) -> bool {
     }
 
     // Finally, compile the source code.
-    rustpython_parser::parser::parse_program(&line, "<filename>").is_ok()
+    parser::parse_program(&line, "<filename>").is_ok()
 }
 
 /// Returns `true` if a line is probably part of some multiline code.

crates/ruff/src/rules/eradicate/mod.rs

@@ -7,11 +7,12 @@ mod tests {
     use std::path::Path;
 
     use anyhow::Result;
+    use insta::assert_yaml_snapshot;
     use test_case::test_case;
 
     use crate::registry::Rule;
+    use crate::settings;
     use crate::test::test_path;
-    use crate::{assert_yaml_snapshot, settings};
 
     #[test_case(Rule::CommentedOutCode, Path::new("ERA001.py"); "ERA001")]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {

crates/ruff/src/rules/eradicate/snapshots/ruff__rules__eradicate__tests__ERA001_ERA001.py.snap

@@ -1,5 +1,5 @@
 ---
-source: src/rules/eradicate/mod.rs
+source: crates/ruff/src/rules/eradicate/mod.rs
 expression: diagnostics
 ---
 - kind:
@@ -11,8 +11,7 @@ expression: diagnostics
     row: 1
     column: 10
   fix:
-    content:
-      - ""
+    content: ""
     location:
       row: 1
       column: 0
@@ -29,8 +28,7 @@ expression: diagnostics
     row: 2
     column: 22
   fix:
-    content:
-      - ""
+    content: ""
     location:
       row: 2
       column: 0
@@ -47,8 +45,7 @@ expression: diagnostics
     row: 3
     column: 6
   fix:
-    content:
-      - ""
+    content: ""
     location:
       row: 3
       column: 0
@@ -65,8 +62,7 @@ expression: diagnostics
     row: 5
     column: 13
   fix:
-    content:
-      - ""
+    content: ""
     location:
       row: 5
       column: 0
@@ -83,8 +79,7 @@ expression: diagnostics
     row: 12
     column: 16
   fix:
-    content:
-      - ""
+    content: ""
     location:
       row: 12
       column: 0

crates/ruff/src/rules/flake8_2020/mod.rs

@@ -6,11 +6,12 @@ mod tests {
     use std::path::Path;
 
     use anyhow::Result;
+    use insta::assert_yaml_snapshot;
     use test_case::test_case;
 
     use crate::registry::Rule;
+    use crate::settings;
     use crate::test::test_path;
-    use crate::{assert_yaml_snapshot, settings};
 
     #[test_case(Rule::SysVersionSlice3Referenced, Path::new("YTT101.py"); "YTT101")]
     #[test_case(Rule::SysVersion2Referenced, Path::new("YTT102.py"); "YTT102")]

crates/ruff/src/rules/flake8_annotations/fixes.rs

@@ -1,7 +1,6 @@
 use anyhow::{bail, Result};
 use rustpython_parser::ast::Stmt;
-use rustpython_parser::lexer;
-use rustpython_parser::lexer::Tok;
+use rustpython_parser::{lexer, Mode, Tok};
 
 use crate::ast::types::Range;
 use crate::fix::Fix;
@@ -16,7 +15,7 @@ pub fn add_return_none_annotation(locator: &Locator, stmt: &Stmt) -> Result<Fix>
     let mut seen_lpar = false;
     let mut seen_rpar = false;
     let mut count: usize = 0;
-    for (start, tok, ..) in lexer::make_tokenizer_located(contents, range.location).flatten() {
+    for (start, tok, ..) in lexer::lex_located(contents, Mode::Module, range.location).flatten() {
         if seen_lpar && seen_rpar {
             if matches!(tok, Tok::Colon) {
                 return Ok(Fix::insertion(" -> None".to_string(), start));

crates/ruff/src/rules/flake8_annotations/mod.rs

@@ -9,8 +9,8 @@ mod tests {
     use std::path::Path;
 
     use anyhow::Result;
+    use insta::assert_yaml_snapshot;
 
-    use crate::assert_yaml_snapshot;
     use crate::registry::Rule;
     use crate::settings::Settings;
     use crate::test::test_path;

crates/ruff/src/rules/flake8_bandit/mod.rs

@@ -8,9 +8,9 @@ mod tests {
     use std::path::Path;
 
     use anyhow::Result;
+    use insta::assert_yaml_snapshot;
     use test_case::test_case;
 
-    use crate::assert_yaml_snapshot;
     use crate::registry::Rule;
     use crate::settings::Settings;
     use crate::test::test_path;

crates/ruff/src/rules/flake8_blind_except/mod.rs

@@ -6,11 +6,12 @@ mod tests {
     use std::path::Path;
 
     use anyhow::Result;
+    use insta::assert_yaml_snapshot;
     use test_case::test_case;
 
     use crate::registry::Rule;
+    use crate::settings;
     use crate::test::test_path;
-    use crate::{assert_yaml_snapshot, settings};
 
     #[test_case(Rule::BlindExcept, Path::new("BLE.py"); "BLE001")]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {

crates/ruff/src/rules/flake8_boolean_trap/mod.rs

@@ -6,11 +6,12 @@ mod tests {
     use std::path::Path;
 
     use anyhow::Result;
+    use insta::assert_yaml_snapshot;
     use test_case::test_case;
 
     use crate::registry::Rule;
+    use crate::settings;
     use crate::test::test_path;
-    use crate::{assert_yaml_snapshot, settings};
 
     #[test_case(Rule::BooleanPositionalArgInFunctionDefinition, Path::new("FBT.py"); "FBT001")]
     #[test_case(Rule::BooleanDefaultValueInFunctionDefinition, Path::new("FBT.py"); "FBT002")]

crates/ruff/src/rules/flake8_boolean_trap/rules.rs

@@ -1,6 +1,8 @@
-use ruff_macros::{define_violation, derive_message_formats};
 use rustpython_parser::ast::{Arguments, Constant, Expr, ExprKind};
 
+use ruff_macros::{define_violation, derive_message_formats};
+
+use crate::ast::helpers::collect_call_path;
 use crate::ast::types::Range;
 use crate::checkers::ast::Checker;
 use crate::registry::{Diagnostic, DiagnosticKind};
@@ -50,6 +52,10 @@ const FUNC_CALL_NAME_ALLOWLIST: &[&str] = &[
     "pop",
     "setattr",
     "setdefault",
+    "str",
+    "bytes",
+    "int",
+    "float",
 ];
 
 const FUNC_DEF_NAME_ALLOWLIST: &[&str] = &["__setitem__"];
@@ -87,10 +93,23 @@ fn add_if_boolean(checker: &mut Checker, arg: &Expr, kind: DiagnosticKind) {
     }
 }
 
-pub fn check_positional_boolean_in_def(checker: &mut Checker, name: &str, arguments: &Arguments) {
+pub fn check_positional_boolean_in_def(
+    checker: &mut Checker,
+    name: &str,
+    decorator_list: &[Expr],
+    arguments: &Arguments,
+) {
     if FUNC_DEF_NAME_ALLOWLIST.contains(&name) {
         return;
     }
+
+    if decorator_list.iter().any(|expr| {
+        let call_path = collect_call_path(expr);
+        call_path.as_slice() == [name, "setter"]
+    }) {
+        return;
+    }
+
     for arg in arguments.posonlyargs.iter().chain(arguments.args.iter()) {
         if arg.node.annotation.is_none() {
             continue;
@@ -121,11 +140,20 @@ pub fn check_positional_boolean_in_def(checker: &mut Checker, name: &str, argume
 pub fn check_boolean_default_value_in_function_definition(
     checker: &mut Checker,
     name: &str,
+    decorator_list: &[Expr],
     arguments: &Arguments,
 ) {
     if FUNC_DEF_NAME_ALLOWLIST.contains(&name) {
         return;
     }
+
+    if decorator_list.iter().any(|expr| {
+        let call_path = collect_call_path(expr);
+        call_path.as_slice() == [name, "setter"]
+    }) {
+        return;
+    }
+
     for arg in &arguments.defaults {
         add_if_boolean(checker, arg, BooleanDefaultValueInFunctionDefinition.into());
     }

crates/ruff/src/rules/flake8_boolean_trap/snapshots/ruff__rules__flake8_boolean_trap__tests__FBT001_FBT.py.snap

@@ -1,5 +1,5 @@
 ---
-source: src/rules/flake8_boolean_trap/mod.rs
+source: crates/ruff/src/rules/flake8_boolean_trap/mod.rs
 expression: diagnostics
 ---
 - kind:
@@ -82,4 +82,14 @@ expression: diagnostics
     column: 45
   fix: ~
   parent: ~
+- kind:
+    BooleanPositionalArgInFunctionDefinition: ~
+  location:
+    row: 77
+    column: 18
+  end_location:
+    row: 77
+    column: 29
+  fix: ~
+  parent: ~