Merge branch 'main' into github-2923

Implement PYI006 "bad version info comparison"

## What it does

Ensures that you only `<` and `>=` for version info comparisons with
`sys.version_info` in `.pyi` files. All other comparisons such as
`<`, `<=` and `==` are banned.

## Why is this bad?

```python
>>> import sys
>>> print(sys.version_info)
sys.version_info(major=3, minor=8, micro=10, releaselevel='final', serial=0)
>>> print(sys.version_info > (3, 8))
True
>>> print(sys.version_info == (3, 8))
False
>>> print(sys.version_info <= (3, 8))
False
>>> print(sys.version_info in (3, 8))
False
```

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

.github/workflows/ci.yaml

@@ -29,7 +29,7 @@ jobs:
       - run: ./target/debug/ruff_dev generate-all
       - run: git diff --quiet README.md || echo "::error file=README.md::This file is outdated. Run 'cargo dev generate-all'."
       - run: git diff --quiet ruff.schema.json || echo "::error file=ruff.schema.json::This file is outdated. Run 'cargo dev generate-all'."
-      - run: git diff --exit-code -- README.md ruff.schema.json
+      - run: git diff --exit-code -- README.md ruff.schema.json docs
 
   cargo-fmt:
     name: "cargo fmt"

.pre-commit-config.yaml

@@ -1,9 +1,18 @@
+fail_fast: true
 repos:
   - repo: https://github.com/abravalheri/validate-pyproject
     rev: v0.10.1
     hooks:
       - id: validate-pyproject
 
+  - repo: https://github.com/executablebooks/mdformat
+    rev: 0.7.16
+    hooks:
+      - id: mdformat
+        additional_dependencies:
+          - mdformat-black
+          - black==23.1.0 # Must be the latest version of Black
+
   - repo: https://github.com/igorshubovych/markdownlint-cli
     rev: v0.33.0
     hooks:
@@ -28,11 +37,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 +53,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]

BREAKING_CHANGES.md

@@ -20,8 +20,7 @@ the intention of adding a stable public API in the future.
 ### `select`, `extend-select`, `ignore`, and `extend-ignore` have new semantics ([#2312](https://github.com/charliermarsh/ruff/pull/2312))
 
 Previously, the interplay between `select` and its related options could lead to unexpected
-behavior. For example, `ruff --select E501 --ignore ALL` and `ruff --select E501 --extend-ignore
-ALL` behaved differently. (See [#2312](https://github.com/charliermarsh/ruff/pull/2312) for more
+behavior. For example, `ruff --select E501 --ignore ALL` and `ruff --select E501 --extend-ignore ALL` behaved differently. (See [#2312](https://github.com/charliermarsh/ruff/pull/2312) for more
 examples.)
 
 When Ruff determines the enabled rule set, it has to reconcile `select` and `ignore` from a variety
@@ -74,7 +73,7 @@ ruff rule E402   --format json      # Works! (And preferred.)
 This change is largely backwards compatible -- most users should experience
 no change in behavior. However, please note the following exceptions:
 
-* Subcommands will now fail when invoked with unsupported arguments, instead
+- Subcommands will now fail when invoked with unsupported arguments, instead
   of silently ignoring them. For example, the following will now fail:
 
   ```console
@@ -83,16 +82,16 @@ no change in behavior. However, please note the following exceptions:
 
   (the `clean` command doesn't support `--respect-gitignore`.)
 
-* The semantics of `ruff <arg>` have changed slightly when `<arg>` is a valid subcommand.
+- The semantics of `ruff <arg>` have changed slightly when `<arg>` is a valid subcommand.
   For example, prior to this release, running `ruff rule` would run `ruff` over a file or
   directory called `rule`. Now, `ruff rule` would invoke the `rule` subcommand. This should
   only impact projects with files or directories named `rule`, `check`, `explain`, `clean`,
   or `generate-shell-completion`.
 
-* Scripts that invoke ruff should supply `--` before any positional arguments.
+- Scripts that invoke ruff should supply `--` before any positional arguments.
   (The semantics of `ruff -- <arg>` have not changed.)
 
-* `--explain` previously treated `--format grouped` as a synonym for `--format text`.
+- `--explain` previously treated `--format grouped` as a synonym for `--format text`.
   This is no longer supported; instead, use `--format text`.
 
 ## 0.0.226

CODE_OF_CONDUCT.md

@@ -29,23 +29,23 @@ diverse, inclusive, and healthy community.
 Examples of behavior that contributes to a positive environment for our
 community include:
 
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
   and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
+- Focusing on what is best not just for us as individuals, but for the
   overall community
 
 Examples of unacceptable behavior include:
 
-* The use of sexualized language or imagery, and sexual attention or
+- The use of sexualized language or imagery, and sexual attention or
   advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email
   address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
+- Other conduct which could reasonably be considered inappropriate in a
   professional setting
 
 ## Enforcement Responsibilities
@@ -132,7 +132,7 @@ version 2.0, available [here](https://www.contributor-covenant.org/version/2/0/c
 Community Impact Guidelines were inspired by [Mozilla's code of conduct
 enforcement ladder](https://github.com/mozilla/diversity).
 
-[homepage]: https://www.contributor-covenant.org
-
 For answers to common questions about this code of conduct, see the [FAQ](https://www.contributor-covenant.org/faq).
 Translations are available [here](https://www.contributor-covenant.org/translations).
+
+[homepage]: https://www.contributor-covenant.org

CONTRIBUTING.md

@@ -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
@@ -106,15 +103,15 @@ At time of writing, the repository includes the following crates:
 At a high level, the steps involved in adding a new lint rule are as follows:
 
 1. Determine a name for the new rule as per our [rule naming convention](#rule-naming-convention).
-2. Create a file for your rule (e.g., `crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs`).
-3. In that file, define a violation struct. You can grep for `define_violation!` to see examples.
-4. Map the violation struct to a rule code in `crates/ruff/src/registry.rs` (e.g., `E402`).
-5. Define the logic for triggering the violation in `crates/ruff/src/checkers/ast.rs` (for AST-based
+1. Create a file for your rule (e.g., `crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs`).
+1. In that file, define a violation struct. You can grep for `define_violation!` to see examples.
+1. Map the violation struct to a rule code in `crates/ruff/src/registry.rs` (e.g., `E402`).
+1. Define the logic for triggering the violation in `crates/ruff/src/checkers/ast.rs` (for AST-based
    checks), `crates/ruff/src/checkers/tokens.rs` (for token-based checks), `crates/ruff/src/checkers/lines.rs`
    (for text-based checks), or `crates/ruff/src/checkers/filesystem.rs` (for filesystem-based
    checks).
-6. Add a test fixture.
-7. Update the generated files (documentation and generated code).
+1. Add a test fixture.
+1. Update the generated files (documentation and generated code).
 
 To define the violation, start by creating a dedicated file for your rule under the appropriate
 rule linter (e.g., `crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs`). That file should
@@ -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,15 +143,18 @@ 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:
 
-* should state the bad thing being checked for
+- should state the bad thing being checked for
 
-* should not contain instructions on what you what you should use instead
+- 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:
+
+1. Generate the MkDocs site with:
+
    ```shell
    python scripts/generate_mkdocs.py
    ```
-3. Run the development server with:
+
+1. 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 = "aa8336ee94492b52458ed8e1517238e5c6c2914c" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "aa8336ee94492b52458ed8e1517238e5c6c2914c" }
 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/flake8_to_ruff/README.md

@@ -84,7 +84,7 @@ flake8-to-ruff path/to/.flake8 --plugin flake8-builtins --plugin flake8-quotes
 1. Ruff only supports a subset of the Flake configuration options. `flake8-to-ruff` will warn on and
    ignore unsupported options in the `.flake8` file (or equivalent). (Similarly, Ruff has a few
    configuration options that don't exist in Flake8.)
-2. Ruff will omit any rule codes that are unimplemented or unsupported by Ruff, including rule
+1. Ruff will omit any rule codes that are unimplemented or unsupported by Ruff, including rule
    codes from unsupported plugins. (See the [Ruff README](https://github.com/charliermarsh/ruff#user-content-how-does-ruff-compare-to-flake8)
    for the complete list of supported plugins.)
 

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

@@ -19,6 +19,8 @@ token = "s3cr3t"
 secrete = "s3cr3t"
 safe = password = "s3cr3t"
 password = safe = "s3cr3t"
+PASSWORD = "s3cr3t"
+PassWord = "s3cr3t"
 
 d["password"] = "s3cr3t"
 d["pass"] = "s3cr3t"
@@ -61,3 +63,15 @@ 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 = ""
+PASSWORDS = ""
+passphrases = ""
+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/PYI006.py

@@ -0,0 +1,14 @@
+import sys
+from sys import version_info as python_version
+
+if sys.version_info < (3, 9): ...  # OK
+
+if sys.version_info >= (3, 9): ...  # OK
+
+if sys.version_info == (3, 9): ...  # OK
+
+if sys.version_info <= (3, 10): ...  # OK
+
+if sys.version_info > (3, 10): ...  # OK
+
+if python_version > (3, 10): ...  # OK

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

@@ -0,0 +1,18 @@
+import sys
+from sys import version_info as python_version
+
+if sys.version_info < (3, 9): ...  # OK
+
+if sys.version_info >= (3, 9): ...  # OK
+
+if sys.version_info == (3, 9): ...  # OK
+
+if sys.version_info == (3, 9): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons
+
+if sys.version_info <= (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons
+
+if sys.version_info <= (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons
+
+if sys.version_info > (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons
+
+if python_version > (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons

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,86 @@
+# 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
+
+# SIM116
+if func_name == "create":
+    return "A"
+elif func_name == "modify":
+    return "M"
+elif func_name == "remove":
+    return "D"
+elif func_name == "move":
+    return "MV"

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

@@ -11,6 +11,7 @@ YODA > age  # SIM300
 YODA >= age  # SIM300
 JediOrder.YODA == age  # SIM300
 0 < (number - 100)  # SIM300
+SomeClass().settings.SOME_CONSTANT_VALUE > (60 * 60)  # SIM300
 
 # OK
 compare == "yoda"

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

@@ -0,0 +1,50 @@
+#: E251 E251
+def foo(bar = False):
+    '''Test function with an error in declaration'''
+    pass
+#: E251
+foo(bar= True)
+#: E251
+foo(bar =True)
+#: E251 E251
+foo(bar = True)
+#: E251
+y = bar(root= "sdasd")
+#: E251:2:29
+parser.add_argument('--long-option',
+                    default=
+                    "/rather/long/filesystem/path/here/blah/blah/blah")
+#: E251:1:45
+parser.add_argument('--long-option', default
+                    ="/rather/long/filesystem/path/here/blah/blah/blah")
+#: E251:3:8 E251:3:10
+foo(True,
+    baz=(1, 2),
+    biz = 'foo'
+    )
+#: Okay
+foo(bar=(1 == 1))
+foo(bar=(1 != 1))
+foo(bar=(1 >= 1))
+foo(bar=(1 <= 1))
+(options, args) = parser.parse_args()
+d[type(None)] = _deepcopy_atomic
+
+# Annotated Function Definitions
+#: Okay
+def munge(input: AnyStr, sep: AnyStr = None, limit=1000,
+          extra: Union[str, dict] = None) -> AnyStr:
+    pass
+#: Okay
+async def add(a: int = 0, b: int = 0) -> int:
+    return a + b
+# Previously E251 four times
+#: E271:1:6
+async  def add(a: int = 0, b: int = 0) -> int:
+    return a + b
+#: E252:1:15 E252:1:16 E252:1:27 E252:1:36
+def add(a: int=0, b: int =0, c: int= 0) -> int:
+    return a + b + c
+#: Okay
+def add(a: int = _default(name='f')):
+    return a

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

@@ -0,0 +1,145 @@
+#: W191
+if False:
+	print  # indented with 1 tab
+#:
+
+
+#: W191
+y = x == 2 \
+	or x == 3
+#: E101 W191 W504
+if (
+        x == (
+            3
+        ) or
+        y == 4):
+	pass
+#: E101 W191
+if x == 2 \
+    or y > 1 \
+        or x == 3:
+	pass
+#: E101 W191
+if x == 2 \
+        or y > 1 \
+        or x == 3:
+	pass
+#:
+
+#: E101 W191 W504
+if (foo == bar and
+        baz == bop):
+	pass
+#: E101 W191 W504
+if (
+    foo == bar and
+    baz == bop
+):
+	pass
+#:
+
+#: E101 E101 W191 W191
+if start[1] > end_col and not (
+        over_indent == 4 and indent_next):
+	return (0, "E121 continuation line over-"
+	        "indented for visual indent")
+#:
+
+#: E101 W191
+
+
+def long_function_name(
+        var_one, var_two, var_three,
+        var_four):
+	print(var_one)
+#: E101 W191 W504
+if ((row < 0 or self.moduleCount <= row or
+     col < 0 or self.moduleCount <= col)):
+	raise Exception("%s,%s - %s" % (row, col, self.moduleCount))
+#: E101 E101 E101 E101 W191 W191 W191 W191 W191 W191
+if bar:
+	return (
+	    start, 'E121 lines starting with a '
+	    'closing bracket should be indented '
+	    "to match that of the opening "
+	    "bracket's line"
+	)
+#
+#: E101 W191 W504
+# you want vertical alignment, so use a parens
+if ((foo.bar("baz") and
+     foo.bar("bop")
+     )):
+	print "yes"
+#: E101 W191 W504
+# also ok, but starting to look like LISP
+if ((foo.bar("baz") and
+     foo.bar("bop"))):
+	print "yes"
+#: E101 W191 W504
+if (a == 2 or
+    b == "abc def ghi"
+         "jkl mno"):
+	return True
+#: E101 W191 W504
+if (a == 2 or
+    b == """abc def ghi
+jkl mno"""):
+	return True
+#: W191:2:1 W191:3:1 E101:3:2
+if length > options.max_line_length:
+	return options.max_line_length, \
+	    "E501 line too long (%d characters)" % length
+
+
+#
+#: E101 W191 W191 W504
+if os.path.exists(os.path.join(path, PEP8_BIN)):
+	cmd = ([os.path.join(path, PEP8_BIN)] +
+	       self._pep8_options(targetfile))
+#: W191
+'''
+	multiline string with tab in it'''
+#: E101 W191
+'''multiline string
+	with tabs
+   and spaces
+'''
+#: Okay
+'''sometimes, you just need to go nuts in a multiline string
+	and allow all sorts of crap
+  like mixed tabs and spaces
+
+or trailing whitespace
+or long long long long long long long long long long long long long long long long long lines
+'''  # nopep8
+#: Okay
+'''this one
+	will get no warning
+even though the noqa comment is not immediately after the string
+''' + foo  # noqa
+#
+#: E101 W191
+if foo is None and bar is "bop" and \
+        blah == 'yeah':
+	blah = 'yeahnah'
+
+
+#
+#: W191 W191 W191
+if True:
+	foo(
+		1,
+		2)
+#: W191 W191 W191 W191 W191
+def test_keys(self):
+	"""areas.json - All regions are accounted for."""
+	expected = set([
+		u'Norrbotten',
+		u'V\xe4sterbotten',
+	])
+#: W191
+x = [
+	'abc'
+]
+#:

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

@@ -0,0 +1,10 @@
+"""Test: imports within `ModuleNotFoundError` handlers."""
+
+
+def check_orjson():
+    try:
+        import orjson
+
+        return True
+    except ModuleNotFoundError:
+        return False

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,24 @@
+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)
+
+# do not handle keyword arguments
+logging.error("%(objects)d modifications: %(modifications)d errors: %(errors)d")
+
+import warning
+
+warning.warning("Hello %s %s", "World!")

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

@@ -0,0 +1,20 @@
+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)
+
+# do not handle keyword arguments
+logging.error("%(objects)d modifications: %(modifications)d errors: %(errors)d", {"objects": 1, "modifications": 1, "errors": 1})
+
+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/UP006.py

@@ -28,3 +28,10 @@ def f(x: IList[str]) -> None:
 
 def f(x: "List[str]") -> None:
     ...
+
+
+list = "abc"
+
+
+def f(x: List[str]) -> None:
+    ...

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,42 @@ 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})
+
+# Empty dict literal
+MyType = TypedDict("MyType", {})
+
+# Empty dict call
+MyType = TypedDict("MyType", dict())

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

@@ -2,21 +2,30 @@ 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, ...])])
+
+# no fields
+MyType = typing.NamedTuple("MyType")
+
+# empty fields
+MyType = typing.NamedTuple("MyType", [])

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

@@ -0,0 +1,7 @@
+isinstance(1, (int, float))  # UP038
+issubclass("yes", (int, float, str))  # UP038
+
+isinstance(1, int)  # OK
+issubclass("yes", int)  # OK
+isinstance(1, int | float)  # OK
+issubclass("yes", int | str)  # OK

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

@@ -1,15 +0,0 @@
-def f(*args, **kwargs):
-    pass
-
-
-a = (1, 2)
-b = (3, 4)
-c = (5, 6)
-d = (7, 8)
-
-f(a, b)
-f(a, kw=b)
-f(*a, kw=b)
-f(kw=a, *b)
-f(kw=a, *b, *c)
-f(*a, kw=b, *c, kw1=d)

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

@@ -30,3 +30,11 @@ def good():
         raise e  # This is verbose violation, shouldn't trigger no cause
     except Exception:
         raise  # Just re-raising don't need 'from'
+
+
+def good():
+    try:
+        from mod import f
+    except ImportError:
+        def f():
+            raise MyException()  # Raising within a new scope is fine

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