Bump version to 0.0.253 (#3245)

This prevents the UP034 autofix simultaneously stripping the
parentheses from generators in the same linter pass, which causes
a SyntaxError.

Closes #3234.

With this fix:

```python
$ cat test.py
the_first_one = next(
    (i for i in range(10) if i // 2 == 0)
)

$ cargo run --bin ruff check test.py --no-cache --select UP034,COM812 --fix
    Finished dev [unoptimized + debuginfo] target(s) in 0.08s
     Running `target/debug/ruff check test.py --no-cache --select UP034,COM812 --fix`
Found 1 error (1 fixed, 0 remaining).

$ cat test.py
the_first_one = next(
    i for i in range(10) if i // 2 == 0
)
```

* Use format

---------

Co-authored-by: Charlie Marsh <charlie.r.marsh@gmail.com>

.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
@@ -28,11 +29,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
@@ -40,5 +45,16 @@ repos:
         pass_filenames: false
         exclude: target
 
+  # Black
+  - repo: https://github.com/psf/black
+    rev: 23.1.0
+    hooks:
+      - id: black
+        exclude: |
+          (?x)^(
+            crates/ruff/resources/.*|
+            crates/ruff_python_formatter/resources/.*
+          )$
+
 ci:
   skip: [cargo-fmt, clippy, 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,16 +49,16 @@ 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,
 and that it passes both the lint and test validation checks:
 
 ```shell
-cargo fmt --all  # Auto-formatting...
+cargo fmt  # Auto-formatting...
 cargo clippy --fix --workspace --all-targets --all-features  # Linting...
-cargo test --all  # Testing...
+cargo test  # Testing...
 ```
 
 These checks will run on GitHub Actions when you open your Pull Request, but running them locally
@@ -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,10 +132,10 @@ 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`.
+`test_case` macro in the relevant `crates/ruff/src/[linter]/mod.rs` file. Then, run `cargo test`.
 Your test will fail, but you'll be prompted to follow-up with `cargo insta review`. Accept the
 generated snapshot, then commit the snapshot file alongside the rest of your changes.
 
@@ -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:
 
@@ -155,6 +152,9 @@ This implies that rule names:
 * should not contain instructions on what you what you should use instead
   (these belong in the rule documentation and the `autofix_title` for rules that have autofix)
 
+When re-implementing rules from other linters, this convention is given more importance than
+preserving the original rule name.
+
 ### Example: Adding a new configuration option
 
 Ruff's user-facing settings live in a few different places.
@@ -186,14 +186,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,17 +1,21 @@
 [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" }
 clap = { version = "4.0.1", features = ["derive"] }
 itertools = { version = "0.10.5" }
-libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a8725d161fe8b3ed73a6758b21e177" }
+is-macro = { version = "0.2.2" }
+libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "80e4c1399f95e5beb532fdd1e209ad2dbb470438" }
 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 = "c4b67896662b16b5699a779c0e52aa0ca2587fec" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "c4b67896662b16b5699a779c0e52aa0ca2587fec" }
 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.253"
+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.253"
 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"
@@ -16,6 +16,10 @@ crate-type = ["cdylib", "rlib"]
 doctest = false
 
 [dependencies]
+ruff_macros = { path = "../ruff_macros" }
+ruff_python = { path = "../ruff_python" }
+ruff_rustpython = { path = "../ruff_rustpython" }
+
 anyhow = { workspace = true }
 bisection = { version = "0.1.0" }
 bitflags = { version = "1.3.2" }
@@ -23,12 +27,14 @@ cfg-if = { version = "1.0.0" }
 chrono = { version = "0.4.21", default-features = false, features = ["clock"] }
 clap = { workspace = true, features = ["derive", "env", "string"] }
 colored = { version = "2.0.0" }
+derivative = { version = "2.2.0" }
 dirs = { version = "4.0.0" }
 fern = { version = "0.6.1" }
 glob = { version = "0.3.0" }
 globset = { version = "0.4.9" }
 ignore = { version = "0.4.18" }
 imperative = { version = "1.0.3" }
+is-macro = { workspace = true }
 itertools = { workspace = true }
 libcst = { workspace = true }
 log = { version = "0.4.17" }
@@ -39,8 +45,7 @@ num-traits = "0.2.15"
 once_cell = { workspace = true }
 path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
 regex = { workspace = true }
-ruff_macros = { path = "../ruff_macros" }
-ruff_python = { path = "../ruff_python" }
+result-like = "0.4.6"
 rustc-hash = { workspace = true }
 rustpython-common = { workspace = true }
 rustpython-parser = { workspace = true }
@@ -57,7 +62,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 +70,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_annotations/annotation_presence.py

@@ -107,3 +107,7 @@ class Foo:
     # ANN101
     def foo(self, /, a: int, b: int) -> int:
         pass
+
+
+# OK
+def f(*args: *tuple[int]) -> None: ...

crates/ruff/resources/test/fixtures/flake8_bandit/S105.py

@@ -61,3 +61,13 @@ if token == "3\t4":
 
 if token == "5\r6":
     pass
+
+
+# These should not be flagged
+passed_msg = "You have passed!"
+compassion = "Please don't match!"
+impassable = "You shall not pass!"
+passwords = ""
+passphrases = ""
+tokens = ""
+secrets = ""

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

@@ -57,6 +57,12 @@ dict.fromkeys(("world",), True)
 {}.deploy(True, False)
 getattr(someobj, attrname, False)
 mylist.index(True)
+int(True)
+str(int(False))
+cfg.get("hello", True)
+cfg.getint("hello", True)
+cfg.getfloat("hello", True)
+cfg.getboolean("hello", True)
 
 
 class Registry:
@@ -66,3 +72,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_commas/COM81.py

@@ -626,3 +626,8 @@ result = function(
     bar,
     **{'ham': spam}
 )
+
+# Make sure the COM812 and UP034 rules don't autofix simultaneously and cause a syntax error.
+the_first_one = next(
+    (i for i in range(10) if i // 2 == 0)  # COM812 fix should include the final bracket
+)

crates/ruff/resources/test/fixtures/flake8_django/DJ003.py

@@ -0,0 +1,21 @@
+from django.shortcuts import render
+
+
+def test_view1(request):
+    return render(request, "index.html", locals())
+
+
+def test_view2(request):
+    return render(request, "index.html", context=locals())
+
+
+def test_view3(request):
+    return render(request, "index.html")
+
+
+def test_view4(request):
+    return render(request, "index.html", {})
+
+
+def test_view5(request):
+    return render(request, "index.html", context={})

crates/ruff/resources/test/fixtures/flake8_django/DJ006.py

@@ -0,0 +1,11 @@
+from django import forms
+
+
+class TestModelForm1(forms.ModelForm):
+    class Meta:
+        exclude = ["bar"]
+
+
+class TestModelForm2(forms.ModelForm):
+    class Meta:
+        fields = ["foo"]

crates/ruff/resources/test/fixtures/flake8_django/DJ007.py

@@ -0,0 +1,16 @@
+from django import forms
+
+
+class TestModelForm1(forms.ModelForm):
+    class Meta:
+        fields = "__all__"
+
+
+class TestModelForm2(forms.ModelForm):
+    class Meta:
+        fields = b"__all__"
+
+
+class TestModelForm3(forms.ModelForm):
+    class Meta:
+        fields = ["foo"]

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

@@ -0,0 +1,10 @@
+# no error
+all((x.id for x in bar))
+all(x.id for x in bar)
+all(x.id for x in bar)
+any(x.id for x in bar)
+any({x.id for x in bar})
+
+# PIE 802
+any([x.id for x in bar])
+all([x.id for x in bar])

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_pyi/PYI009.py

@@ -0,0 +1,14 @@
+def bar():
+    ...  # OK
+
+
+def foo():
+    pass  # OK, since we're not in a stub file
+
+
+class Bar:
+    ...  # OK
+
+
+class Foo:
+    pass  # OK, since we're not in a stub file

crates/ruff/resources/test/fixtures/flake8_pyi/PYI009.pyi

@@ -0,0 +1,8 @@
+def bar(): ...  # OK
+def foo():
+    pass  # ERROR PYI009, since we're in a stub file
+
+class Bar: ...  # OK
+
+class Foo:
+    pass  # ERROR PYI009, since we're in a stub file

crates/ruff/resources/test/fixtures/flake8_pyi/PYI010.py

@@ -0,0 +1,18 @@
+def bar():
+    ...  # OK
+
+
+def foo():
+    """foo"""  # OK
+
+
+def buzz():
+    print("buzz")  # OK, not in stub file
+
+
+def foo2():
+    123  # OK, not in a stub file
+
+
+def bizz():
+    x = 123  # OK, not in a stub file

crates/ruff/resources/test/fixtures/flake8_pyi/PYI010.pyi

@@ -0,0 +1,12 @@
+def bar(): ...  # OK
+def foo():
+    """foo"""  # OK, strings are handled by another rule
+
+def buzz():
+    print("buzz")  # ERROR PYI010
+
+def foo2():
+    123  # ERROR PYI010
+
+def bizz():
+    x = 123  # ERROR PYI010

crates/ruff/resources/test/fixtures/flake8_pyi/PYI011.py

@@ -0,0 +1,79 @@
+def f12(
+    x,
+    y: str = os.pathsep,  # OK
+) -> None:
+    ...
+
+
+def f11(*, x: str = "x") -> None:  # OK
+    ...
+
+
+def f13(
+    x: list[str] = [
+        "foo",
+        "bar",
+        "baz",
+    ]  # OK
+) -> None:
+    ...
+
+
+def f14(
+    x: tuple[str, ...] = (
+        "foo",
+        "bar",
+        "baz",
+    )  # OK
+) -> None:
+    ...
+
+
+def f15(
+    x: set[str] = {
+        "foo",
+        "bar",
+        "baz",
+    }  # OK
+) -> None:
+    ...
+
+
+def f16(x: frozenset[bytes] = frozenset({b"foo", b"bar", b"baz"})) -> None:  # OK
+    ...
+
+
+def f17(
+    x: str = "foo" + "bar",  # OK
+) -> None:
+    ...
+
+
+def f18(
+    x: str = b"foo" + b"bar",  # OK
+) -> None:
+    ...
+
+
+def f19(
+    x: object = "foo" + 4,  # OK
+) -> None:
+    ...
+
+
+def f20(
+    x: int = 5 + 5,  # OK
+) -> None:
+    ...
+
+
+def f21(
+    x: complex = 3j - 3j,  # OK
+) -> None:
+    ...
+
+
+def f22(
+    x: complex = -42.5j + 4.3j,  # OK
+) -> None:
+    ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI011.pyi

@@ -0,0 +1,63 @@
+def f12(
+    x,
+    y: str = os.pathsep,  # Error PYI011 Only simple default values allowed for typed arguments
+) -> None: ...
+def f11(*, x: str = "x") -> None: ...  # OK
+def f13(
+    x: list[
+        str
+    ] = [  # Error PYI011 Only simple default values allowed for typed arguments
+        "foo",
+        "bar",
+        "baz",
+    ]
+) -> None: ...
+def f14(
+    x: tuple[
+        str, ...
+    ] = (  # Error PYI011 Only simple default values allowed for typed arguments
+        "foo",
+        "bar",
+        "baz",
+    )
+) -> None: ...
+def f15(
+    x: set[
+        str
+    ] = {  # Error PYI011 Only simple default values allowed for typed arguments
+        "foo",
+        "bar",
+        "baz",
+    }
+) -> None: ...
+def f16(
+    x: frozenset[
+        bytes
+    ] = frozenset(  # Error PYI011 Only simple default values allowed for typed arguments
+        {b"foo", b"bar", b"baz"}
+    )
+) -> None: ...
+def f17(
+    x: str = "foo"  # Error PYI011 Only simple default values allowed for typed arguments
+    + "bar",
+) -> None: ...
+def f18(
+    x: str = b"foo"  # Error PYI011 Only simple default values allowed for typed arguments
+    + b"bar",
+) -> None: ...
+def f19(
+    x: object = "foo"  # Error PYI011 Only simple default values allowed for typed arguments
+    + 4,
+) -> None: ...
+def f20(
+    x: int = 5
+    + 5,  # Error PYI011 Only simple default values allowed for typed arguments
+) -> None: ...
+def f21(
+    x: complex = 3j
+    - 3j,  # Error PYI011 Only simple default values allowed for typed arguments
+) -> None: ...
+def f22(
+    x: complex = -42.5j  # Error PYI011 Only simple default values allowed for typed arguments
+    + 4.3j,
+) -> None: ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI014.py

@@ -0,0 +1,79 @@
+def f12(
+    x,
+    y=os.pathsep,  # OK
+) -> None:
+    ...
+
+
+def f11(*, x="x") -> None:
+    ...  # OK
+
+
+def f13(
+    x=[  # OK
+        "foo",
+        "bar",
+        "baz",
+    ]
+) -> None:
+    ...
+
+
+def f14(
+    x=(  # OK
+        "foo",
+        "bar",
+        "baz",
+    )
+) -> None:
+    ...
+
+
+def f15(
+    x={  # OK
+        "foo",
+        "bar",
+        "baz",
+    }
+) -> None:
+    ...
+
+
+def f16(x=frozenset({b"foo", b"bar", b"baz"})) -> None:
+    ...  # OK
+
+
+def f17(
+    x="foo" + "bar",  # OK
+) -> None:
+    ...
+
+
+def f18(
+    x=b"foo" + b"bar",  # OK
+) -> None:
+    ...
+
+
+def f19(
+    x="foo" + 4,  # OK
+) -> None:
+    ...
+
+
+def f20(
+    x=5 + 5,  # OK
+) -> None:
+    ...
+
+
+def f21(
+    x=3j - 3j,  # OK
+) -> None:
+    ...
+
+
+def f22(
+    x=-42.5j + 4.3j,  # OK
+) -> None:
+    ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI014.pyi

@@ -0,0 +1,45 @@
+def f12(
+    x,
+    y=os.pathsep,  # Error PYI014
+) -> None: ...
+def f11(*, x="x") -> None: ...  # OK
+def f13(
+    x=[  # Error PYI014
+        "foo",
+        "bar",
+        "baz",
+    ]
+) -> None: ...
+def f14(
+    x=(  # Error PYI014
+        "foo",
+        "bar",
+        "baz",
+    )
+) -> None: ...
+def f15(
+    x={  # Error PYI014
+        "foo",
+        "bar",
+        "baz",
+    }
+) -> None: ...
+def f16(x=frozenset({b"foo", b"bar", b"baz"})) -> None: ...  # Error PYI014
+def f17(
+    x="foo" + "bar",  # Error PYI014
+) -> None: ...
+def f18(
+    x=b"foo" + b"bar",  # Error PYI014
+) -> None: ...
+def f19(
+    x="foo" + 4,  # Error PYI014
+) -> None: ...
+def f20(
+    x=5 + 5,  # Error PYI014
+) -> None: ...
+def f21(
+    x=3j - 3j,  # Error PYI014
+) -> None: ...
+def f22(
+    x=-42.5j + 4.3j,  # Error PYI014
+) -> None: ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI021.py

@@ -0,0 +1,14 @@
+"""foo"""  # OK, not in stub
+
+
+def foo():
+    """foo"""  # OK, doc strings are allowed in non-stubs
+
+
+class Bar:
+    """bar"""  # OK, doc strings are allowed in non-stubs
+
+
+def bar():
+    x = 1
+    """foo"""  # OK, not a doc string

crates/ruff/resources/test/fixtures/flake8_pyi/PYI021.pyi

@@ -0,0 +1,11 @@
+"""foo"""  # ERROR PYI021
+
+def foo():
+    """foo"""  # ERROR PYI021
+
+class Bar:
+    """bar"""  # ERROR PYI021
+
+def bar():
+    x = 1
+    """foo"""  # OK, not a doc string

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))
+    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/as_imports_comments.py

@@ -0,0 +1,15 @@
+from foo import (  # Comment on `foo`
+    Member as Alias,  # Comment on `Alias`
+)
+
+from bar import (  # Comment on `bar`
+    Member,  # Comment on `Member`
+)
+
+from baz import (  # Comment on `baz`
+    Member as Alias  # Comment on `Alias`
+)
+
+from bop import (  # Comment on `bop`
+    Member  # Comment on `Member`
+)

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

@@ -0,0 +1,26 @@
+#: Okay
+# 情
+#: W291:1:6
+print 
+#: W293:2:1
+class Foo(object):
+    
+    bang = 12
+#: W291:2:35
+'''multiline
+string with trailing whitespace'''   
+#: W291 W292 noeol
+x = 1   
+#: W191 W292 noeol
+if False:
+	pass  # indented with tabs
+#: W292:1:36 noeol
+# This line doesn't have a linefeed
+#: W292:1:5 E225:1:2 noeol
+1+ 1
+#: W292:1:27 E261:1:12 noeol
+import this # no line feed
+#: W292:3:22 noeol
+class Test(object):
+    def __repr__(self):
+        return 'test'

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/pycodestyle/constant_literals.py

@@ -16,21 +16,17 @@ if False == None:  # E711, E712 (fix)
 if None == False:  # E711, E712 (fix)
     pass
 
-###
-# Unfixable errors
-###
-if "abc" == None:  # E711
-    pass
-if None == "abc":  # E711
-    pass
-if "abc" == False:  # E712
-    pass
-if False == "abc":  # E712
-    pass
-
 ###
 # Non-errors
 ###
+if "abc" == None:
+    pass
+if None == "abc":
+    pass
+if "abc" == False:
+    pass
+if False == "abc":
+    pass
 if "def" == "abc":
     pass
 if False is None:

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_10.py

@@ -0,0 +1,4 @@
+try:
+    pass
+except ExceptionGroup:
+    pass

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

@@ -0,0 +1,46 @@
+"""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
+
+
+def f(provided: int) -> int:
+    match provided:
+        case captured:
+            return captured
+
+
+def f(provided: int) -> int:
+    match provided:
+        case [captured, *_]:
+            return captured
+
+
+def f(provided: int) -> int:
+    match provided:
+        case [*captured]:
+            return captured
+
+
+def f(provided: int) -> int:
+    match provided:
+        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/collapsible_else_if.py

@@ -0,0 +1,49 @@
+"""
+Test for else-if-used
+"""
+
+
+def ok0():
+    """Should not trigger on elif"""
+    if 1:
+        pass
+    elif 2:
+        pass
+
+
+def ok1():
+    """If the orelse has more than 1 item in it, shouldn't trigger"""
+    if 1:
+        pass
+    else:
+        print()
+        if 1:
+            pass
+
+
+def ok2():
+    """If the orelse has more than 1 item in it, shouldn't trigger"""
+    if 1:
+        pass
+    else:
+        if 1:
+            pass
+        print()
+
+
+def not_ok0():
+    if 1:
+        pass
+    else:
+        if 2:
+            pass
+
+
+def not_ok1():
+    if 1:
+        pass
+    else:
+        if 2:
+            pass
+        else:
+            pass

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

@@ -0,0 +1,75 @@
+# Adapted from:
+#   https://github.com/PyCQA/pylint/blob/b70d2abd7fabe9bfd735a30b593b9cd5eaa36194/tests/functional/g/globals.py
+
+CONSTANT = 1
+
+
+def FUNC():
+    pass
+
+
+class CLASS:
+    pass
+
+
+def fix_constant(value):
+    """All this is ok, but try not to use `global` ;)"""
+    global CONSTANT  # [global-statement]
+    print(CONSTANT)
+    CONSTANT = value
+
+
+def global_with_import():
+    """Should only warn for global-statement when using `Import` node"""
+    global sys  # [global-statement]
+    import sys
+
+
+def global_with_import_from():
+    """Should only warn for global-statement when using `ImportFrom` node"""
+    global namedtuple  # [global-statement]
+    from collections import namedtuple
+
+
+def global_del():
+    """Deleting the global name prevents `global-variable-not-assigned`"""
+    global CONSTANT  # [global-statement]
+    print(CONSTANT)
+    del CONSTANT
+
+
+def global_operator_assign():
+    """Operator assigns should only throw a global statement error"""
+    global CONSTANT  # [global-statement]
+    print(CONSTANT)
+    CONSTANT += 1
+
+
+def global_function_assign():
+    """Function assigns should only throw a global statement error"""
+    global CONSTANT  # [global-statement]
+
+    def CONSTANT():
+        pass
+
+    CONSTANT()
+
+
+def override_func():
+    """Overriding a function should only throw a global statement error"""
+    global FUNC  # [global-statement]
+
+    def FUNC():
+        pass
+
+    FUNC()
+
+
+def override_class():
+    """Overriding a class should only throw a global statement error"""
+    global CLASS  # [global-statement]
+
+    class CLASS:
+        pass
+
+    CLASS()

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

@@ -0,0 +1,21 @@
+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!")
+
+# do not handle calls without any args
+logging.info("100% dynamic")
+
+# do not handle calls with *args
+logging.error("Example log %s, %s", "foo", "bar", "baz", *args)
+
+# do not handle calls with **kwargs
+logging.error("Example log %s, %s", "foo", "bar", "baz", **kwargs)
+
+import warning
+
+warning.warning("Hello %s %s", "World!")

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

@@ -0,0 +1,17 @@
+import logging
+
+logging.warning("Hello %s", "World!", "again")  # [logging-too-many-args]
+
+logging.warning("Hello %s", "World!", "again", something="else")
+
+logging.warning("Hello %s", "World!")
+
+# do not handle calls with *args
+logging.error("Example log %s, %s", "foo", "bar", "baz", *args)
+
+# do not handle calls with **kwargs
+logging.error("Example log %s, %s", "foo", "bar", "baz", **kwargs)
+
+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/pyupgrade/UP007.py

@@ -41,3 +41,8 @@ def f(x: Union["str", int]) -> None:
 
 def f(x: Union[("str", "int"), float]) -> None:
     ...
+
+
+def f() -> None:
+    x: Optional[str]
+    x = Optional[str]

crates/ruff/resources/test/fixtures/pyupgrade/UP013.py

@@ -2,36 +2,36 @@ from typing import TypedDict, NotRequired, Literal
 import typing
 
 # dict literal
-MyType1 = TypedDict("MyType1", {"a": int, "b": str})
+MyType = TypedDict("MyType", {"a": int, "b": str})
 
 # dict call
-MyType2 = TypedDict("MyType2", dict(a=int, b=str))
+MyType = TypedDict("MyType", dict(a=int, b=str))
 
 # kwargs
-MyType3 = TypedDict("MyType3", a=int, b=str)
+MyType = TypedDict("MyType", a=int, b=str)
 
 # Empty TypedDict
-MyType4 = TypedDict("MyType4")
+MyType = TypedDict("MyType")
 
 # Literal values
-MyType5 = TypedDict("MyType5", {"a": "hello"})
-MyType6 = TypedDict("MyType6", a="hello")
+MyType = TypedDict("MyType", {"a": "hello"})
+MyType = TypedDict("MyType", a="hello")
 
 # NotRequired
-MyType7 = TypedDict("MyType7", {"a": NotRequired[dict]})
+MyType = TypedDict("MyType", {"a": NotRequired[dict]})
 
 # total
-MyType8 = TypedDict("MyType8", {"x": int, "y": int}, total=False)
-
-# invalid identifiers
-MyType9 = TypedDict("MyType9", {"in": int, "x-y": int})
+MyType = TypedDict("MyType", {"x": int, "y": int}, total=False)
 
 # using Literal type
-MyType10 = TypedDict("MyType10", {"key": Literal["value"]})
+MyType = TypedDict("MyType", {"key": Literal["value"]})
 
 # using namespace TypedDict
-MyType11 = typing.TypedDict("MyType11", {"key": int})
+MyType = typing.TypedDict("MyType", {"key": int})
 
-# unpacking
+# invalid identifiers (OK)
+MyType = TypedDict("MyType", {"in": int, "x-y": int})
+
+# unpacking (OK)
 c = {"c": float}
-MyType12 = TypedDict("MyType1", {"a": int, "b": str, **c})
+MyType = TypedDict("MyType", {"a": int, "b": str, **c})

crates/ruff/resources/test/fixtures/pyupgrade/UP014.py

@@ -2,21 +2,24 @@ from typing import NamedTuple
 import typing
 
 # with complex annotations
-NT1 = NamedTuple("NT1", [("a", int), ("b", tuple[str, ...])])
+MyType = NamedTuple("MyType", [("a", int), ("b", tuple[str, ...])])
 
 # with default values as list
-NT2 = NamedTuple(
-    "NT2",
+MyType = NamedTuple(
+    "MyType",
     [("a", int), ("b", str), ("c", list[bool])],
     defaults=["foo", [True]],
 )
 
 # with namespace
-NT3 = typing.NamedTuple("NT3", [("a", int), ("b", str)])
+MyType = typing.NamedTuple("MyType", [("a", int), ("b", str)])
 
-# with too many default values
-NT4 = NamedTuple(
-    "NT4",
+# too many default values (OK)
+MyType = NamedTuple(
+    "MyType",
     [("a", int), ("b", str)],
     defaults=[1, "bar", "baz"],
 )
+
+# invalid identifiers (OK)
+MyType = NamedTuple("MyType", [("x-y", int), ("b", tuple[str, ...])])

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())
     }
 
@@ -124,7 +124,7 @@ impl<'a> Scope<'a> {
 //        StarImportation
 //        FutureImportation
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, is_macro::Is)]
 pub enum BindingKind<'a> {
     Annotation,
     Argument,

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;