2612 commits

Author	SHA1	Message	Date
Dan Parizher	b2501b45e0	[pylint] Detect indirect pathlib.Path usages for unspecified-encoding (PLW1514) (#19304) ... ## Summary Fixes #19294 --------- Co-authored-by: Brent Westbrook <36778786+ntBre@users.noreply.github.com>	2025-07-16 12:57:31 -04:00
Dan Parizher	291699b375	[refurb] FURB164 fix should validate arguments and should usually be marked unsafe (#19136) ... ## Summary Fixes #19076 An attempt at fixing #19076 where the rule could change program behavior by incorrectly converting from_float/from_decimal method calls to constructor calls. The fix implements argument validation using Ruff's existing type inference system (`ResolvedPythonType`, `typing::is_int`, `typing::is_float`) to determine when conversions are actually safe, adds logic to detect invalid method calls (wrong argument counts, incorrect keyword names) and suppress fixes for them, and changes the default fix applicability from `Safe` to `Unsafe` with safe fixes only offered when the argument type is known to be compatible and no problematic keywords are used. One uncertainty is whether the type inference catches all possible edge cases in complex codebases, but the new approach is significantly more conservative and safer than the previous implementation. ## Test Plan I updated the existing test fixtures with edge cases from the issue and manually verified behavior with temporary test files for valid/unsafe/invalid scenarios. --------- Co-authored-by: Brent Westbrook <brentrwestbrook@gmail.com>	2025-07-16 15:38:33 +00:00
Brent Westbrook	893f5727e5	[flake8-type-checking, pyupgrade, ruff] Add from __future__ import annotations when it would allow new fixes (TC001, TC002, TC003, UP037, RUF013) (#19100) ... ## Summary This is a second attempt at addressing https://github.com/astral-sh/ruff/issues/18502 instead of reusing `FA100` (#18919). This PR: - adds a new `lint.allow-importing-future-annotations` option - uses the option to add a `__future__` import when it would trigger `TC001`, `TC002`, or `TC003` - uses the option to add an import when it would allow unquoting more annotations in [quoted-annotation (UP037)](https://docs.astral.sh/ruff/rules/quoted-annotation/#quoted-annotation-up037) - uses the option to allow the `|` union syntax before 3.10 in [implicit-optional (RUF013)](https://docs.astral.sh/ruff/rules/implicit-optional/#implicit-optional-ruf013) I started adding a fix for [runtime-string-union (TC010)](https://docs.astral.sh/ruff/rules/runtime-string-union/#runtime-string-union-tc010) too, as mentioned in my previous [comment](https://github.com/astral-sh/ruff/issues/18502#issuecomment-3005238092), but some of the existing tests already imported `from __future__ import annotations`, so I think we intentionally flag these cases for the user to inspect. Adding the import is _a_ fix but probably not the best one. ## Test Plan Existing `TC` tests, new copies of them with the option enabled, and new tests based on ideas in https://github.com/astral-sh/ruff/pull/18919#discussion_r2166292705 and the following thread. For UP037 and RUF013, the new tests are also copies of the existing tests, with the new option enabled. The easiest way to review them is probably by their diffs from the existing snapshots: ### UP037 `UP037_0.py` and `UP037_2.pyi` have no diffs. The diff for `UP037_1.py` is below. It correctly unquotes an annotation in module scope that would otherwise be invalid. <details><summary>UP037_1.py</summary> ```diff 3d2 < snapshot_kind: text 23c22,42 < 12 12 | --- > 12 12 | > > UP037_1.py:14:4: UP037 [*] Remove quotes from type annotation > | > 13 | # OK > 14 | X: "Tuple[int, int]" = (0, 0) > | ^^^^^^^^^^^^^^^^^ UP037 > | > = help: Remove quotes > > ℹ Unsafe fix > 1 |+from __future__ import annotations > 1 2 | from typing import TYPE_CHECKING > 2 3 | > 3 4 | if TYPE_CHECKING: > -------------------------------------------------------------------------------- > 11 12 | > 12 13 | > 13 14 | # OK > 14 |-X: "Tuple[int, int]" = (0, 0) > 15 |+X: Tuple[int, int] = (0, 0) ``` </details> ### RUF013 The diffs here are mostly just the imports because the original snaps were on 3.13. So we're getting the same fixes now on 3.9. <details><summary>RUF013_0.py</summary> ```diff 3d2 < snapshot_kind: text 14,16c13,20 < 17 17 | pass < 18 18 | < 19 19 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 17 18 | pass > 18 19 | > 19 20 | 18,21c22,25 < 20 |+def f(arg: int | None = None): # RUF013 < 21 21 | pass < 22 22 | < 23 23 | --- > 21 |+def f(arg: int | None = None): # RUF013 > 21 22 | pass > 22 23 | > 23 24 | 32,34c36,43 < 21 21 | pass < 22 22 | < 23 23 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 21 22 | pass > 22 23 | > 23 24 | 36,39c45,48 < 24 |+def f(arg: str | None = None): # RUF013 < 25 25 | pass < 26 26 | < 27 27 | --- > 25 |+def f(arg: str | None = None): # RUF013 > 25 26 | pass > 26 27 | > 27 28 | 50,52c59,66 < 25 25 | pass < 26 26 | < 27 27 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 25 26 | pass > 26 27 | > 27 28 | 54,57c68,71 < 28 |+def f(arg: Tuple[str] | None = None): # RUF013 < 29 29 | pass < 30 30 | < 31 31 | --- > 29 |+def f(arg: Tuple[str] | None = None): # RUF013 > 29 30 | pass > 30 31 | > 31 32 | 68,70c82,89 < 55 55 | pass < 56 56 | < 57 57 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 55 56 | pass > 56 57 | > 57 58 | 72,75c91,94 < 58 |+def f(arg: Union | None = None): # RUF013 < 59 59 | pass < 60 60 | < 61 61 | --- > 59 |+def f(arg: Union | None = None): # RUF013 > 59 60 | pass > 60 61 | > 61 62 | 86,88c105,112 < 59 59 | pass < 60 60 | < 61 61 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 59 60 | pass > 60 61 | > 61 62 | 90,93c114,117 < 62 |+def f(arg: Union[int] | None = None): # RUF013 < 63 63 | pass < 64 64 | < 65 65 | --- > 63 |+def f(arg: Union[int] | None = None): # RUF013 > 63 64 | pass > 64 65 | > 65 66 | 104,106c128,135 < 63 63 | pass < 64 64 | < 65 65 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 63 64 | pass > 64 65 | > 65 66 | 108,111c137,140 < 66 |+def f(arg: Union[int, str] | None = None): # RUF013 < 67 67 | pass < 68 68 | < 69 69 | --- > 67 |+def f(arg: Union[int, str] | None = None): # RUF013 > 67 68 | pass > 68 69 | > 69 70 | 122,124c151,158 < 82 82 | pass < 83 83 | < 84 84 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 82 83 | pass > 83 84 | > 84 85 | 126,129c160,163 < 85 |+def f(arg: int | float | None = None): # RUF013 < 86 86 | pass < 87 87 | < 88 88 | --- > 86 |+def f(arg: int | float | None = None): # RUF013 > 86 87 | pass > 87 88 | > 88 89 | 140,142c174,181 < 86 86 | pass < 87 87 | < 88 88 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 86 87 | pass > 87 88 | > 88 89 | 144,147c183,186 < 89 |+def f(arg: int | float | str | bytes | None = None): # RUF013 < 90 90 | pass < 91 91 | < 92 92 | --- > 90 |+def f(arg: int | float | str | bytes | None = None): # RUF013 > 90 91 | pass > 91 92 | > 92 93 | 158,160c197,204 < 105 105 | pass < 106 106 | < 107 107 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 105 106 | pass > 106 107 | > 107 108 | 162,165c206,209 < 108 |+def f(arg: Literal[1] | None = None): # RUF013 < 109 109 | pass < 110 110 | < 111 111 | --- > 109 |+def f(arg: Literal[1] | None = None): # RUF013 > 109 110 | pass > 110 111 | > 111 112 | 176,178c220,227 < 109 109 | pass < 110 110 | < 111 111 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 109 110 | pass > 110 111 | > 111 112 | 180,183c229,232 < 112 |+def f(arg: Literal[1, "foo"] | None = None): # RUF013 < 113 113 | pass < 114 114 | < 115 115 | --- > 113 |+def f(arg: Literal[1, "foo"] | None = None): # RUF013 > 113 114 | pass > 114 115 | > 115 116 | 194,196c243,250 < 128 128 | pass < 129 129 | < 130 130 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 128 129 | pass > 129 130 | > 130 131 | 198,201c252,255 < 131 |+def f(arg: Annotated[int | None, ...] = None): # RUF013 < 132 132 | pass < 133 133 | < 134 134 | --- > 132 |+def f(arg: Annotated[int | None, ...] = None): # RUF013 > 132 133 | pass > 133 134 | > 134 135 | 212,214c266,273 < 132 132 | pass < 133 133 | < 134 134 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 132 133 | pass > 133 134 | > 134 135 | 216,219c275,278 < 135 |+def f(arg: Annotated[Annotated[int | str | None, ...], ...] = None): # RUF013 < 136 136 | pass < 137 137 | < 138 138 | --- > 136 |+def f(arg: Annotated[Annotated[int | str | None, ...], ...] = None): # RUF013 > 136 137 | pass > 137 138 | > 138 139 | 232,234c291,298 < 148 148 | < 149 149 | < 150 150 | def f( --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 148 149 | > 149 150 | > 150 151 | def f( 236,239c300,303 < 151 |+ arg1: int | None = None, # RUF013 < 152 152 | arg2: Union[int, float] = None, # RUF013 < 153 153 | arg3: Literal[1, 2, 3] = None, # RUF013 < 154 154 | ): --- > 152 |+ arg1: int | None = None, # RUF013 > 152 153 | arg2: Union[int, float] = None, # RUF013 > 153 154 | arg3: Literal[1, 2, 3] = None, # RUF013 > 154 155 | ): 253,255c317,324 < 149 149 | < 150 150 | def f( < 151 151 | arg1: int = None, # RUF013 --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 149 150 | > 150 151 | def f( > 151 152 | arg1: int = None, # RUF013 257,260c326,329 < 152 |+ arg2: Union[int, float] | None = None, # RUF013 < 153 153 | arg3: Literal[1, 2, 3] = None, # RUF013 < 154 154 | ): < 155 155 | pass --- > 153 |+ arg2: Union[int, float] | None = None, # RUF013 > 153 154 | arg3: Literal[1, 2, 3] = None, # RUF013 > 154 155 | ): > 155 156 | pass 274,276c343,350 < 150 150 | def f( < 151 151 | arg1: int = None, # RUF013 < 152 152 | arg2: Union[int, float] = None, # RUF013 --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 150 151 | def f( > 151 152 | arg1: int = None, # RUF013 > 152 153 | arg2: Union[int, float] = None, # RUF013 278,281c352,355 < 153 |+ arg3: Literal[1, 2, 3] | None = None, # RUF013 < 154 154 | ): < 155 155 | pass < 156 156 | --- > 154 |+ arg3: Literal[1, 2, 3] | None = None, # RUF013 > 154 155 | ): > 155 156 | pass > 156 157 | 292,294c366,373 < 178 178 | pass < 179 179 | < 180 180 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 178 179 | pass > 179 180 | > 180 181 | 296,299c375,378 < 181 |+def f(arg: Union[Annotated[int, ...], Union[str, bytes]] | None = None): # RUF013 < 182 182 | pass < 183 183 | < 184 184 | --- > 182 |+def f(arg: Union[Annotated[int, ...], Union[str, bytes]] | None = None): # RUF013 > 182 183 | pass > 183 184 | > 184 185 | 307c386 < = help: Convert to `T | None` --- > = help: Convert to `Optional[T]` 314c393 < 188 |+def f(arg: "int | None" = None): # RUF013 --- > 188 |+def f(arg: "Optional[int]" = None): # RUF013 325c404 < = help: Convert to `T | None` --- > = help: Convert to `Optional[T]` 332c411 < 192 |+def f(arg: "str | None" = None): # RUF013 --- > 192 |+def f(arg: "Optional[str]" = None): # RUF013 343c422 < = help: Convert to `T | None` --- > = help: Convert to `Optional[T]` 354,356c433,440 < 201 201 | pass < 202 202 | < 203 203 | --- > 1 |+from __future__ import annotations > 1 2 | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 201 202 | pass > 202 203 | > 203 204 | 358,361c442,445 < 204 |+def f(arg: Union["int", "str"] | None = None): # RUF013 < 205 205 | pass < 206 206 | < 207 207 | --- > 205 |+def f(arg: Union["int", "str"] | None = None): # RUF013 > 205 206 | pass > 206 207 | > 207 208 | ``` </details> <details><summary>RUF013_1.py</summary> ```diff 3d2 < snapshot_kind: text 15,16c14,16 < 2 2 | < 3 3 | --- > 2 |+from __future__ import annotations > 2 3 | > 3 4 | 18,19c18,19 < 4 |+def f(arg: int | None = None): # RUF013 < 5 5 | pass --- > 5 |+def f(arg: int | None = None): # RUF013 > 5 6 | pass ``` </details> <details><summary>RUF013_3.py</summary> ```diff 3d2 < snapshot_kind: text 14,16c13,16 < 1 1 | import typing < 2 2 | < 3 3 | --- > 1 |+from __future__ import annotations > 1 2 | import typing > 2 3 | > 3 4 | 18,21c18,21 < 4 |+def f(arg: typing.List[str] | None = None): # RUF013 < 5 5 | pass < 6 6 | < 7 7 | --- > 5 |+def f(arg: typing.List[str] | None = None): # RUF013 > 5 6 | pass > 6 7 | > 7 8 | 32,34c32,39 < 19 19 | pass < 20 20 | < 21 21 | --- > 1 |+from __future__ import annotations > 1 2 | import typing > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 19 20 | pass > 20 21 | > 21 22 | 36,39c41,44 < 22 |+def f(arg: typing.Union[int, str] | None = None): # RUF013 < 23 23 | pass < 24 24 | < 25 25 | --- > 23 |+def f(arg: typing.Union[int, str] | None = None): # RUF013 > 23 24 | pass > 24 25 | > 25 26 | 50,52c55,62 < 26 26 | # Literal < 27 27 | < 28 28 | --- > 1 |+from __future__ import annotations > 1 2 | import typing > 2 3 | > 3 4 | > -------------------------------------------------------------------------------- > 26 27 | # Literal > 27 28 | > 28 29 | 54,55c64,65 < 29 |+def f(arg: typing.Literal[1, "foo", True] | None = None): # RUF013 < 30 30 | pass --- > 30 |+def f(arg: typing.Literal[1, "foo", True] | None = None): # RUF013 > 30 31 | pass ``` </details> <details><summary>RUF013_4.py</summary> ```diff 3d2 < snapshot_kind: text 13,15c12,20 < 12 12 | def multiple_1(arg1: Optional, arg2: Optional = None): ... < 13 13 | < 14 14 | --- > 1 1 | # https://github.com/astral-sh/ruff/issues/13833 > 2 |+from __future__ import annotations > 2 3 | > 3 4 | from typing import Optional > 4 5 | > -------------------------------------------------------------------------------- > 12 13 | def multiple_1(arg1: Optional, arg2: Optional = None): ... > 13 14 | > 14 15 | 17,20c22,25 < 15 |+def multiple_2(arg1: Optional, arg2: Optional = None, arg3: int | None = None): ... < 16 16 | < 17 17 | < 18 18 | def return_type(arg: Optional = None) -> Optional: ... --- > 16 |+def multiple_2(arg1: Optional, arg2: Optional = None, arg3: int | None = None): ... > 16 17 | > 17 18 | > 18 19 | def return_type(arg: Optional = None) -> Optional: ... ``` </details> ## Future work This PR does not touch UP006, UP007, or UP045, which are currently coupled to FA100. If this new approach turns out well, we may eventually want to deprecate FA100 and add a `__future__` import in those rules' fixes too. --------- Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>	2025-07-16 08:50:52 -04:00
Dylan	00e7d1ffd6	[pycodestyle] Handle brace escapes for t-strings in logical lines (#19358) ... Tracks both f and t-strings in the logical line rules for `pycodestyle`. Progress towards #15506	2025-07-15 14:48:48 +00:00
Brent Westbrook	e9cac3684a	Move Pylint rendering to ruff_db (#19340) ... Summary -- This is a very simple output format, the only decision is what to do if the file is missing from the diagnostic. For now, I opted to `unwrap_or_default` both the path and the `OneIndexed` row number, giving `:1: main diagnostic message` in the test without a file. Another quirk here is that the path is relativized. I just pasted in the `relativize_path` and `get_cwd` implementations from `ruff_linter::fs` for now, but maybe there's a better place for them. I didn't see any details about why this needs to be relativized in the original [issue](https://github.com/astral-sh/ruff/issues/1953), [PR](https://github.com/astral-sh/ruff/pull/1995), or in the pylint [docs](https://flake8.pycqa.org/en/latest/internal/formatters.html#pylint-formatter), but it did change the results of the CLI integration test when I tried deleting it. I haven't been able to reproduce that in the CLI, though, so it may only happen with `Command::current_dir`. Test Plan -- Tests ported from `ruff_linter` and a new test for the case with no file --------- Co-authored-by: Micha Reiser <micha@reiser.io>	2025-07-15 10:14:49 -04:00
Dylan	92a302e291	[pylint] Extend invalid string character rules to include t-strings (#19355) ... Handle t-strings in PLE2510-15 Progress towards #15506	2025-07-15 07:59:51 -05:00
Alex Waygood	7b8161e80d	Make TC010 docs example more realistic (#19356)	2025-07-15 13:52:21 +01:00
Brent Westbrook	e9b0c33703	Move RDJSON rendering to ruff_db (#19293) ... ## Summary Another output format like #19133. This is the [reviewdog](https://github.com/reviewdog/reviewdog) output format, which is somewhat similar to regular JSON. Like #19270, in the first commit I converted from using `json!` to `Serialize` structs, then in the second commit I moved the module to `ruff_db`. The reviewdog [schema](320a8e73a9/proto/rdf/jsonschema/DiagnosticResult.json) seems a bit more flexible than our JSON schema, so I'm not sure if we need any preview checks here. I'll flag the places I wasn't sure about as review comments. ## Test Plan New tests in `rdjson.rs`, ported from the old `rjdson.rs` module, as well as the new CLI output tests. --------- Co-authored-by: Micha Reiser <micha@reiser.io>	2025-07-15 12:39:21 +00:00
Dylan	82391b5675	[flake8-use-pathlib] Skip single dots for invalid-pathlib-with-suffix (PTH210) on versions >= 3.14 (#19331) ... Skips [invalid-pathlib-with-suffix (PTH210)](https://docs.astral.sh/ruff/rules/invalid-pathlib-with-suffix/#invalid-pathlib-with-suffix-pth210) for `.with_suffix(".")` on Python versions 3.14 and greater, as per [the docs](https://docs.python.org/3.14/library/pathlib.html#pathlib.PurePath.with_suffix). Progress towards #15506	2025-07-15 07:05:00 -05:00
Dylan	464144f1c6	[ruff] Allow strict kwarg when checking for starmap-zip (RUF058) in Python 3.14+ (#19333) ... In Python 3.14 the keyword-argument `strict` was [added to `map`](https://docs.python.org/3.14/library/functions.html#map). This PR adds support for this when replacing a starmap-zip call with map in [starmap-zip (RUF058)](https://docs.astral.sh/ruff/rules/starmap-zip/#starmap-zip-ruf058). Progress towards #15506	2025-07-15 07:04:23 -05:00
GiGaGon	7b27fe966e	[pylint] Make example error out-of-the-box (PLE2502) (#19272) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> Part of #18972 Fixes #14346 This PR makes [bidirectional-unicode (PLE2502)](https://docs.astral.sh/ruff/rules/bidirectional-unicode/#bidirectional-unicode-ple2502)'s example error out-of-the-box, by converting it to use one of the test cases. The documentation in general is also updated to replace "bidirectional unicode character" with "bidirectional formatting character", as those are the only ones checked for, and the "unicode" suffix is redundant. The new example section looks like this: <img width="1074" height="264" alt="image" src="https://github.com/user-attachments/assets/cc1d2cb4-b590-4f20-a4d2-15b744872cdd" /> The "References" section link is also updated to reflect the rule's actual behavior. ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-14 14:46:23 -04:00
GiGaGon	966fd6f57a	[pydoclint] Fix SyntaxError from fixes with line continuations (D201, D202) (#19246) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> This PR fixes #7172 by suppressing the fixes for [docstring-missing-returns (DOC201)](https://docs.astral.sh/ruff/rules/docstring-missing-returns/#docstring-missing-returns-doc201) / [docstring-extraneous-returns (DOC202)](https://docs.astral.sh/ruff/rules/docstring-extraneous-returns/#docstring-extraneous-returns-doc202) if there is a surrounding line continuation character `\` that would make the fix cause a syntax error. To do this, the lints are changed from `AlwaysFixableViolation` to `Violation` with `FixAvailability::Sometimes`. In the case of `DOC201`, the fix is not given if the non-break line ends in a line continuation character `\`. Note that lines are iterated in reverse from the docstring to the function definition. In the case of `DOC202`, the fix is not given if the docstring ends with a line continuation character `\`. ## Test Plan <!-- How was it tested? --> Added a test case.	2025-07-14 13:31:36 -04:00
GiGaGon	059e90a98f	[refurb] Make example error out-of-the-box (FURB122) (#19297) ... ## Summary Part of #18972 This PR makes [for-loop-writes (FURB122)](https://docs.astral.sh/ruff/rules/for-loop-writes/#for-loop-writes-furb122)'s example error out-of-the-box. I also had to re-name the second case's variables to get both to raise at the same time, I suspect because of limitations in ruff's current semantic model. New names subject to bikeshedding, I just went with the least effort `_b` for binary suffix. [Old example](https://play.ruff.rs/19e8e47a-8058-4013-aef5-e9b5eab65962) ```py with Path("file").open("w") as f: for line in lines: f.write(line) with Path("file").open("wb") as f: for line in lines: f.write(line.encode()) ``` [New example](https://play.ruff.rs/e96b00e5-3c63-47c3-996d-dace420dd711) ```py from pathlib import Path with Path("file").open("w") as f: for line in lines: f.write(line) with Path("file").open("wb") as f_b: for line_b in lines_b: f_b.write(line_b.encode()) ``` The "Use instead" section was also modified similarly. ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-14 11:24:16 -05:00
Juriah	a4562ac673	[refurb] Make example error out-of-the-box (FURB177) (#19309) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary Part of #18972 This PR makes [implicit-cwd(FURB177)](https://docs.astral.sh/ruff/rules/implicit-cwd/)'s example error out-of-the-box. [Old example](https://play.ruff.rs/a0bef229-9626-426f-867f-55cb95ee64d8) ```python cwd = Path().resolve() ``` [New example](https://play.ruff.rs/bdbea4af-e276-4603-a1b6-88757dfaa399) ```python from pathlib import Path cwd = Path().resolve() ``` <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-14 11:23:02 -05:00
Dylan	2a2cc37158	Add t-string fixtures for rules that do not need to be modified (#19146) ... I used a script to attempt to identify those rules with the following property: changing f-strings to t-strings in the corresponding fixture altered the number of lint errors emitted. In other words, those rules for which f-strings and t-strings are not treated the same in the current implementation. This PR documents the subset of such rules where this is fine and no changes need to be made to the implementation of the rule. Mostly these are the rules where it is relevant that an f-string evaluates to type `str` at runtime whereas t-strings do not. In theory many of these fixtures are not super necessary - it's unlikely t-strings would be used for most of these. However, the internal handling of t-strings is tightly coupled with that of f-strings, and may become even more so as we implement the upcoming changes due to https://github.com/python/cpython/pull/135996 . So I'd like to keep these around as regression tests. Note: The `flake8-bandit` fixtures were already added during the original t-string implementation. | Rule(s) | Reason | | --- | --- | | [`unused-method-argument` (`ARG002`)](https://docs.astral.sh/ruff/rules/unused-method-argument/#unused-method-argument-arg002) | f-strings exempted for msg in `NotImplementedError` not relevant for t-strings | | [`logging-f-string` (`G004`)](https://docs.astral.sh/ruff/rules/logging-f-string/#logging-f-string-g004) | t-strings cannot be used here | | [`f-string-in-get-text-func-call` (`INT001`)](https://docs.astral.sh/ruff/rules/f-string-in-get-text-func-call/#f-string-in-get-text-func-call-int001) | rule justified by eager evaluation of interpolations | | [`flake8-bandit`](https://docs.astral.sh/ruff/rules/#flake8-bandit-s)| rules justified by eager evaluation of interpolations | | [`single-string-slots` (`PLC0205`)](https://docs.astral.sh/ruff/rules/single-string-slots/#single-string-slots-plc0205) | t-strings cannot be slots in general | | [`unnecessary-encode-utf8` (`UP012`)](https://docs.astral.sh/ruff/rules/unnecessary-encode-utf8/#unnecessary-encode-utf8-up012) | cannot encode t-strings | | [`no-self-use` (`PLR6301`)](https://docs.astral.sh/ruff/rules/no-self-use/#no-self-use-plr6301) | f-strings exempted for msg in NotImplementedError not relevant for t-strings | | [`pytest-raises-too-broad` (`PT011`)](https://docs.astral.sh/ruff/rules/pytest-raises-too-broad/) / [`pytest-fail-without-message` (`PT016`)](https://docs.astral.sh/ruff/rules/pytest-fail-without-message/#pytest-fail-without-message-pt016) / [`pytest-warns-too-broad` (`PT030`)](https://docs.astral.sh/ruff/rules/pytest-warns-too-broad/#pytest-warns-too-broad-pt030) | t-strings cannot be empty or used as messages | | [`assert-on-string-literal` (`PLW0129`)](https://docs.astral.sh/ruff/rules/assert-on-string-literal/#assert-on-string-literal-plw0129) | t-strings are not strings and cannot be empty | | [`native-literals` (`UP018`)](https://docs.astral.sh/ruff/rules/native-literals/#native-literals-up018) | t-strings are not native literals |	2025-07-14 09:46:31 -05:00
w0nder1ng	26f736bc46	[pep8_naming] Avoid false positives on standard library functions with uppercase names (N802) (#18907) ... Co-authored-by: Micha Reiser <micha@reiser.io>	2025-07-14 08:26:57 +00:00
GiGaGon	dca594f89f	[pyupgrade] Make example error out-of-the-box (UP040) (#19296) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> Part of #18972 This PR makes [non-pep695-type-alias (UP040)](https://docs.astral.sh/ruff/rules/non-pep695-type-alias/#non-pep695-type-alias-up040)'s example error out-of-the-box. [Old example](https://play.ruff.rs/6beca1be-45cd-4e5a-aafa-6a0584c10d64) ```py ListOfInt: TypeAlias = list[int] PositiveInt = TypeAliasType("PositiveInt", Annotated[int, Gt(0)]) ``` [New example](https://play.ruff.rs/bbad34da-bf07-44e6-9f34-53337e8f57d4) ```py from typing import Annotated, TypeAlias, TypeAliasType from annotated_types import Gt ListOfInt: TypeAlias = list[int] PositiveInt = TypeAliasType("PositiveInt", Annotated[int, Gt(0)]) ``` Imports were also added to the "Use instead" section. ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-12 18:39:25 +01:00
GiGaGon	4bc27133a9	[pyupgrade] Make example error out-of-the-box (UP046) (#19295)	2025-07-12 14:54:56 +01:00
GiGaGon	7154b64248	[pylint] Make example error out-of-the-box (PLE1507) (#19288) ... ## Summary Part of #18972 This PR makes [invalid-envvar-value (PLE1507)](https://docs.astral.sh/ruff/rules/invalid-envvar-value/#invalid-envvar-value-ple1507)'s example error out-of-the-box. [Old example](https://play.ruff.rs/a46a9bca-edd5-4474-b20d-e6b6d87291ca) ```py os.getenv(1) ``` [New example](https://play.ruff.rs/8348d32d-71fa-422c-b228-e2bc343765b1) ```py import os os.getenv(1) ``` The "Use instead" section was also updated similarly. ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-11 16:08:47 -05:00
GiGaGon	6d01c487a5	[pyupgrade] Make example error out-of-the-box (UP041) (#19292) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> Part of #18972 This PR makes [timeout-error-alias (UP041)](https://docs.astral.sh/ruff/rules/timeout-error-alias/#timeout-error-alias-up041)'s example error out-of-the-box. [Old example](https://play.ruff.rs/87e20352-d80a-46ec-98a2-6f6ea700438b) ```py raise asyncio.TimeoutError ``` [New example](https://play.ruff.rs/d3b95557-46a2-4856-bd71-30d5f3f5ca44) ```py import asyncio raise asyncio.TimeoutError ``` ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-11 16:08:20 -05:00
GiGaGon	6660b11422	[pyupgrade] Make example error out-of-the-box (UP023) (#19291) ... ## Summary Part of #18972 This PR makes [deprecated-c-element-tree (UP023)](https://docs.astral.sh/ruff/rules/deprecated-c-element-tree/#deprecated-c-element-tree-up023)'s example error out-of-the-box. I have no clue why the `import xml.etree.cElementTree` and `from xml.etree import cElementTree` cases are specifically carved out if they do not have an `as ...`, but the tests explicitly call this out, and that's how it is in `pyupgrade`'s source as well. b5c5f710fc/crates/ruff_linter/resources/test/fixtures/pyupgrade/UP023.py (L23-L31) [Old example](https://play.ruff.rs/632b8ce1-393d-45e5-9504-5444ae71a0d8) ```py from xml.etree import cElementTree ``` [New example](https://play.ruff.rs/fef4d378-8c54-41b2-8778-2d02bcbbd7d3) ```py from xml.etree import cElementTree as ET ``` The "Use instead" section was also updated similarly. ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-11 16:07:34 -05:00
Brent Westbrook	b5c5f710fc	Render Azure, JSON, and JSON lines output with the new diagnostics (#19133) ... ## Summary This was originally stacked on #19129, but some of the changes I made for JSON also impacted the Azure format, so I went ahead and combined them. The main changes here are: - Implementing `FileResolver` for Ruff's `EmitterContext` - Adding `FileResolver::notebook_index` and `FileResolver::is_notebook` methods - Adding a `DisplayDiagnostics` (with an "s") type for rendering a group of diagnostics at once - Adding `Azure`, `Json`, and `JsonLines` as new `DiagnosticFormat`s I tried a couple of alternatives to the `FileResolver::notebook` methods like passing down the `NotebookIndex` separately and trying to reparse a `Notebook` from Ruff's `SourceFile`. The latter seemed promising, but the `SourceFile` only stores the concatenated plain text of the notebook, not the re-parsable JSON. I guess the current version is just a variation on passing the `NotebookIndex`, but at least we can reuse the existing `resolver` argument. I think a lot of this can be cleaned up once Ruff has its own actual file resolver. As suggested, I also tried deleting the corresponding `Emitter` files in `ruff_linter`, but it doesn't look like git was able to follow this as a rename. It did, however, track that the tests were moved, so the snapshots should be easy to review. ## Test Plan Existing Ruff tests ported to tests in `ruff_db`. I think some other existing ruff tests also cover parts of this refactor. --------- Co-authored-by: Micha Reiser <micha@reiser.io>	2025-07-11 15:04:46 -04:00
Dan Parizher	ee88abf77c	[flake8_django] Fix DJ008 false positive for abstract models with type-annotated abstract field (#19221) ... Co-authored-by: Micha Reiser <micha@reiser.io>	2025-07-11 16:50:59 +00:00
Jack O'Connor	78bd73f25a	[ty] add support for nonlocal statements	2025-07-11 09:44:54 -07:00
Dan Parizher	110765154f	[flake8-bugbear] Fix B017 false negatives for keyword exception arguments (#19217) ... Co-authored-by: Micha Reiser <micha@reiser.io>	2025-07-11 16:43:09 +00:00
Dan Parizher	30ee44770d	Fix I002 import insertion after docstring with multiple string statements (#19222)	2025-07-11 18:35:41 +02:00
Brent Westbrook	f14ee9edd5	Use structs for JSON serialization (#19270) ... ## Summary See https://github.com/astral-sh/ruff/pull/19133#discussion_r2198413586 for recent discussion. This PR moves to using structs for the types in our JSON output format instead of the `json!` macro. I didn't rename any of the `message` references because that should be handled when rebasing #19133 onto this. My plan for handling the `preview` behavior with the new diagnostics is to use a wrapper enum. Something like: ```rust #[derive(Serialize)] #[serde(untagged)] pub(crate) enum JsonDiagnostic<'a> { Old(OldJsonDiagnostic<'a>), } #[derive(Serialize)] pub(crate) struct OldJsonDiagnostic<'a> { // ... } ``` Initially I thought I could use a `&dyn Serialize` for the affected fields, but I see that `Serialize` isn't dyn-compatible in testing this now. ## Test Plan Existing tests. One quirk of the new types is that their fields are in alphabetical order. I guess `json!` sorts the fields alphabetically? The tests were failing before I sorted the struct fields. ## Other formats It looks like the `rdjson`, `sarif`, and `gitlab` formats also use `json!`, so if we decide to merge this, I can do something similar for those before moving them to the new diagnostic format.	2025-07-11 09:37:44 -04:00
Brent Westbrook	5bc81f26c8	Bump 0.12.3 (#19279)	2025-07-11 09:07:50 -04:00
Victor Hugo Gomes	f2ae12bab3	[flake8-return] Fix false-positive for variables used inside nested functions in RET504 (#18433) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> This PR is the same as #17656. I accidentally deleted the branch of that PR, so I'm creating a new one. Fixes #14052 ## Test Plan Add regression tests <!-- How was it tested? -->	2025-07-10 16:10:22 -04:00
frank	83b5bbf004	Treat form feed as valid whitespace before a line continuation (#19220) ... Co-authored-by: Micha Reiser <micha@reiser.io>	2025-07-10 14:09:34 +00:00
Dan Parizher	221edcba5c	[pyupgrade] Keyword arguments in super should suppress the UP008 fix (#19131) ... ## Summary Fixes #19096	2025-07-09 15:13:22 -04:00
chiri	beb98dae7c	[flake8-use-pathlib] Add autofixes for PTH100, PTH106, PTH107, PTH108, PTH110, PTH111, PTH112, PTH113, PTH114, PTH115, PTH117, PTH119, PTH120 (#19213) ... ## Summary Part of #2331 ## Test Plan update snapshots for preview mode	2025-07-09 14:54:33 -04:00
GiGaGon	a18f76158d	[flake8-bandit] Make example error out-of-the-box (S412) (#19241) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> Part of #18972 This PR makes [suspicious-httpoxy-import (S412)](https://docs.astral.sh/ruff/rules/suspicious-httpoxy-import/#suspicious-httpoxy-import-s412)'s example error out-of-the-box. Since the checked imports are classes instead of modules, the example isn't valid. See #19009 for more details ``` PS ~>py -c "import wsgiref.handlers.CGIHandler" Traceback (most recent call last): File "<string>", line 1, in <module> import wsgiref.handlers.CGIHandler ModuleNotFoundError: No module named 'wsgiref.handlers.CGIHandler'; 'wsgiref.handlers' is not a package PS ~>py -c "from wsgiref.handlers import CGIHandler" PS ~> ``` [Old example](https://play.ruff.rs/bf48c901-6a46-4795-ba1d-c6af79d5c96e) ```py import wsgiref.handlers.CGIHandler ``` [New example](https://play.ruff.rs/1f0e1e60-1f0f-484a-9a17-2d0290a68f2a) ```py from wsgiref.handlers import CGIHandler ``` ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-09 14:25:27 -04:00
GiGaGon	8f400bb37a	[pydoclint] Make example error out-of-the-box (DOC501) (#19218) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> Part of #18972 This PR makes [docstring-missing-exception (DOC501)](https://docs.astral.sh/ruff/rules/docstring-missing-exception/#docstring-missing-exception-doc501)'s example error out-of-the-box. Since the exceptions in the function body need to undergo name resolution to figure out if one of them is `NotImplementedError`, `DOC501` won't lint if the raised name is not defined. This could be considered a limitation, but should be fine since `F821` already covers undefined names. I did discover a different edge case, but it's not relevant to the example. [Old example](https://play.ruff.rs/d213e87d-e5c7-49d8-a908-931f61f06055) ```py def calculate_speed(distance: float, time: float) -> float: """Calculate speed as distance divided by time. Args: distance: Distance traveled. time: Time spent traveling. Returns: Speed as distance divided by time. """ try: return distance / time except ZeroDivisionError as exc: raise FasterThanLightError from exc ``` [New example](https://play.ruff.rs/cb41e0b7-b950-4fa0-842d-cecab9c8e842) ```py class FasterThanLightError(ArithmeticError): ... def calculate_speed(distance: float, time: float) -> float: """Calculate speed as distance divided by time. Args: distance: Distance traveled. time: Time spent traveling. Returns: Speed as distance divided by time. """ try: return distance / time except ZeroDivisionError as exc: raise FasterThanLightError from exc ``` The "Use instead" section was also updated similarly. ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-09 12:59:31 -04:00
Dan Parizher	5eb5ec987d	[flake8-bugbear] Support non-context-manager calls in B017 (#19063) ... ## Summary Fixes #19050 --------- Co-authored-by: Brent Westbrook <brentrwestbrook@gmail.com>	2025-07-08 15:04:55 -04:00
Junhson Jean-Baptiste	fda188953f	[pylint] Update missing-maxsplit-arg docs and error to suggest proper usage (PLC0207) (#18949) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> Fix #18383 by updating the documentation and error message to explain that users should use `rsplit` in order to access the last element of the result with `maxsplit=1` ## Test Plan <!-- How was it tested? --> Only documentation and an error message was changed. As such, snapshots were updated to reflect the new error message. With this change, all existing tests pass.	2025-07-08 12:53:23 -04:00
GiGaGon	d78d10dd94	[pycodestyle] Make example not raise unnecessary SyntaxError (E114) (#19190) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> Part of #18972 This PR makes [indentation-with-invalid-multiple-comment (E114)](https://docs.astral.sh/ruff/rules/indentation-with-invalid-multiple-comment/#indentation-with-invalid-multiple-comment-e114)'s example not raise a syntax error by adding a 4 space indented `...`. The example still gave `E114` without this, but adding the `...` both makes the change in indentation of the comment clearer, and makes it not give a `SyntaxError`. ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-08 10:00:14 -04:00
GiGaGon	36276143be	[pycodestyle] Make example error out-of-the-box (E272) (#19191) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> Part of #18972 This PR makes [multiple-spaces-before-keyword (E272)](https://docs.astral.sh/ruff/rules/multiple-spaces-before-keyword/#multiple-spaces-before-keyword-e272)'s example error out-of-the-box. Since `True` is also a keyword, the old example raises `E271` instead. [Old example](https://play.ruff.rs/23ec3774-5038-471c-be3f-1c1e36f85cbb) ```py True and False ``` [New example](https://play.ruff.rs/d77432e2-fd99-4db2-9cd0-bc08675c0aca) ```py x and y ``` The "Use instead" section was also updated similarly. ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-08 09:58:04 -04:00
Brent Westbrook	2643dc5b7a	Rename Diagnostic::syntax_error methods, separate Ord implementation (#19179) ... ## Summary This PR addresses some additional feedback on #19053: - Renaming the `syntax_error` methods to `invalid_syntax` to match the lint id - Moving the standalone `diagnostic_from_violation` function to `Violation::into_diagnostic` - Removing the `Ord` and `PartialOrd` implementations from `Diagnostic` in favor of `Diagnostic::start_ordering` ## Test Plan Existing tests ## Additional Follow-ups Besides these, I also put the following comments on my todo list, but they seemed like they might be big enough to have their own PRs: - [Use `LintId::IOError` for IO errors](https://github.com/astral-sh/ruff/pull/19053#discussion_r2189425922) - [Move `Fix` and `Edit`](https://github.com/astral-sh/ruff/pull/19053#discussion_r2189448647) - [Avoid so many unwraps](https://github.com/astral-sh/ruff/pull/19053#discussion_r2189465980)	2025-07-08 09:54:19 -04:00
GiGaGon	4dd2c03144	[flake8-simplify] Make example error out-of-the-box (SIM116) (#19111) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> Part of #18972 This PR makes [if-else-block-instead-of-dict-lookup (SIM116)](https://docs.astral.sh/ruff/rules/if-else-block-instead-of-dict-lookup/#if-else-block-instead-of-dict-lookup-sim116)'s example error out-of-the-box [Old example](https://play.ruff.rs/718f17ee-fbe2-4520-97c6-153bc0f4502d) ```py if x == 1: return "Hello" elif x == 2: return "Goodbye" else: return "Goodnight" ``` [New example](https://play.ruff.rs/8a9b47b4-da46-4a50-8576-362cdd707cee) ```py def find_phrase(x): if x == 1: return "Hello" elif x == 2: return "Goodbye" elif x == 3: return "Good morning" else: return "Goodnight" ``` The "Use instead" section was also updated to reflect the new case. I also changed it to use an intermediary variable since I find the `return <long dict>.get` very ugly and hard to read. ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-07 17:17:55 -04:00
GiGaGon	de5264fe13	[flake8-use-pathlib] Make example error out-of-the-box (PTH210) (#19189) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> Part of #18972 This PR makes [invalid-pathlib-with-suffix (PTH210)](https://docs.astral.sh/ruff/rules/invalid-pathlib-with-suffix/#invalid-pathlib-with-suffix-pth210)'s example error out-of-the-box. [Old example](https://play.ruff.rs/d45720cc-fd08-4443-820f-b3bc9756ac59) ```py path.with_suffix("py") ``` [New example](https://play.ruff.rs/4103669e-19c5-464a-a3fb-6e7d190ce5fd) ```py from pathlib import Path path = Path() path.with_suffix("py") ``` The "Use instead" section was also modified similarly. ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-07 17:04:35 -04:00
chiri	e23780c2e1	[flake8-use-pathlib] Add autofixes for PTH203, PTH204, PTH205 (#18922) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary Part of #2331 | [#18763](https://github.com/astral-sh/ruff/pull/18763#issuecomment-2988340436) <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan update snapshots <!-- How was it tested? -->	2025-07-07 16:56:21 -04:00
GiGaGon	47f88b3008	[flake8-type-checking] Fix syntax error introduced by fix (TC008) (#19150) ... <!-- Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull requests.) - Does this pull request include references to any relevant issues? --> ## Summary <!-- What's the purpose of the change? What does it do, and why? --> I noticed this while working on #18972. If the string targeted by [quoted-type-alias (TC008)](https://docs.astral.sh/ruff/rules/quoted-type-alias/#quoted-type-alias-tc008) is a multiline string, the fix would introduce a syntax error. This PR fixes that by adding parenthesis around the resulting replacement if the string contained any newline characters (`\n`, `\r`) if it doesn't already have parenthesis outside `("""...""")` or inside `"""(...)"""` the annotation. Failing examples: https://play.ruff.rs/8793eb95-860a-4bb3-9cbc-6a042fee2946 ``` PS D:\rust_projects\ruff> Get-Content issue.py ``` ```py from typing import TypeAlias OptInt: TypeAlias = """int | None""" type OptInt = """int | None""" ``` ``` PS D:\rust_projects\ruff> uvx ruff check issue.py --isolated --select TC008 --fix --diff --preview ``` ``` error: Fix introduced a syntax error. Reverting all changes. This indicates a bug in Ruff. If you could open an issue at: https://github.com/astral-sh/ruff/issues/new?title=%5BFix%20error%5D ...quoting the contents of `issue.py`, the rule codes TC008, along with the `pyproject.toml` settings and executed command, we'd be very appreciative! ``` This PR also makes the example error out-of-the-box for #18972 Old example: https://play.ruff.rs/f6cd5adb-7f9b-444d-bb3e-8c045241d93e ```py OptInt: TypeAlias = "int | None" ``` New example: https://play.ruff.rs/906c1056-72c0-4777-b70b-2114eb9e6eaf ```py from typing import TypeAlias OptInt: TypeAlias = "int | None" ``` The import was also added to the "Use instead" section. ## Test Plan <!-- How was it tested? --> Added multiple test cases	2025-07-07 15:34:14 -05:00
GiGaGon	6e77e1b760	[flake8-pyi] Make example error out-of-the-box (PYI007, PYI008) (#19103) ... ## Summary Part of #18972 Both in one PR since they are in the same file No playground links since the playground does not support rules that only apply to PYI files PYI007 --- This PR makes [unrecognized-platform-check (PYI007)](https://docs.astral.sh/ruff/rules/unrecognized-platform-check/#unrecognized-platform-check-pyi007)'s example error out-of-the-box Old example: ``` PS ~\Desktop\New_folder\ruff>echo @" ``` ```py if sys.platform.startswith("linux"): # Linux specific definitions ... else: # Posix specific definitions ... ``` ``` "@ | uvx ruff check --isolated --preview --select PYI007 --stdin-filename "test.pyi" - ``` ``` All checks passed! ``` New example: ``` PS ~\Desktop\New_folder\ruff>echo @" ``` ```py import sys if sys.platform is "linux": # Linux specific definitions ... else: # Posix specific definitions ... ``` ``` "@ | uvx ruff check --isolated --preview --select PYI007 --stdin-filename "test.pyi" - ``` ```snap test.pyi:3:4: PYI007 Unrecognized `sys.platform` check | 1 | import sys 2 | 3 | if sys.platform is "linux": | ^^^^^^^^^^^^^^^^^^^^^^^ PYI007 4 | # Linux specific definitions 5 | ... | Found 1 error. ``` Imports were also added to the "use instead" section > [!NOTE] > `PYI007` is really hard to trigger, it's only specifically in the case of a comparison where the operator is not `!=` or `==`. The original example raises [complex-if-statement-in-stub (PYI002)](https://docs.astral.sh/ruff/rules/complex-if-statement-in-stub/#complex-if-statement-in-stub-pyi002) with or without the `import sys` PYI008 --- This PR makes [unrecognized-platform-name (PYI008)](https://docs.astral.sh/ruff/rules/unrecognized-platform-name/#unrecognized-platform-name-pyi008)'s example error out-of-the-box Old example: ``` PS ~\Desktop\New_folder\ruff>echo @" ``` ```py if sys.platform == "linus": ... ``` ``` "@ | uvx ruff check --isolated --preview --select PYI008 --stdin-filename "test.pyi" - ``` ``` All checks passed! ``` New example: ``` PS ~\Desktop\New_folder\ruff>echo @" ``` ```py import sys if sys.platform == "linus": ... ``` ``` "@ | uvx ruff check --isolated --preview --select PYI008 --stdin-filename "test.pyi" - ``` ```snap test.pyi:3:20: PYI008 Unrecognized platform `linus` | 1 | import sys 2 | 3 | if sys.platform == "linus": ... | ^^^^^^^ PYI008 | Found 1 error. ``` Imports were also added to the "use instead" section > [!NOTE] > The original example raises `PYI002` instead ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected --------- Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>	2025-07-07 21:11:43 +01:00
GiGaGon	1fd48120ba	[flake8-type-checking] Make example error out-of-the-box (TC001) (#19151) ... ## Summary Part of #18972 This PR makes [typing-only-first-party-import (TC001)](https://docs.astral.sh/ruff/rules/typing-only-first-party-import/#typing-only-first-party-import-tc001)'s example error out-of-the-box. The old example raised `TC002` instead of `TC001`, so this makes it a `from .` import to fix that. [Old example](https://play.ruff.rs/1fdbb293-86fc-4ed2-b2ff-b4836cea0c59) ```py from __future__ import annotations import local_module def func(sized: local_module.Container) -> int: return len(sized) ``` [New example](https://play.ruff.rs/b886535c-9203-48bb-812b-1aa306f2c287) ```py from __future__ import annotations from . import local_module def func(sized: local_module.Container) -> int: return len(sized) ``` The "Use instead" section was also modified similarly. ## Test Plan <!-- How was it tested? --> N/A, no functionality/tests affected	2025-07-07 08:53:37 -05:00
GiGaGon	a33cff2b12	Fix F701 to F707 errors in tests (#19125) ... ## Summary Per @ntBre in https://github.com/astral-sh/ruff/pull/19111, it would be a good idea to make the tests no longer have these syntax errors, so this PR updates the tests and snapshots. `B031` gave me a lot of trouble since the ending test of declaring a function named `groupby` makes it so that inside other functions, it's unclear which `groupby` is referred to since it depends on when the function is called. To fix it I made each function have it's own `from itertools import groupby` so there's no more ambiguity.	2025-07-04 13:43:18 -05:00
GiGaGon	f48a34fbab	[pylint, pyupgrade] Fix syntax errors in examples (PLW1501, UP028) (#19127) ... ## Summary From me and @ntBre's discussion in #19111. This PR makes these two examples into valid code, since they previously had `F701`-`F707` syntax errors. `SIM110` was already fixed in a different PR, I just forgot to pull.	2025-07-04 13:38:37 -05:00
Brent Westbrook	77a5c5ac80	Combine OldDiagnostic and Diagnostic (#19053) ... ## Summary This PR is a collaboration with @AlexWaygood from our pairing session last Friday. The main goal here is removing `ruff_linter::message::OldDiagnostic` in favor of using `ruff_db::diagnostic::Diagnostic` directly. This involved a few major steps: - Transferring the fields - Transferring the methods and trait implementations, where possible - Converting some constructor methods to free functions - Moving the `SecondaryCode` struct - Updating the method names I'm hoping that some of the methods, especially those in the `expect_ruff_*` family, won't be necessary long-term, but I avoided trying to replace them entirely for now to keep the already-large diff a bit smaller. ### Related refactors Alex and I noticed a few refactoring opportunities while looking at the code, specifically the very similar implementations for `create_parse_diagnostic`, `create_unsupported_syntax_diagnostic`, and `create_semantic_syntax_diagnostic`. We combined these into a single generic function, which I then copied into `ruff_linter::message` with some small changes and a TODO to combine them in the future. I also deleted the `DisplayParseErrorType` and `TruncateAtNewline` types for reporting parse errors. These were added in #4124, I believe to work around the error messages from LALRPOP. Removing these didn't affect any tests, so I think they were unnecessary now that we fully control the error messages from the parser. On a more minor note, I factored out some calls to the `OldDiagnostic::filename` (now `Diagnostic::expect_ruff_filename`) function to avoid repeatedly allocating `String`s in some places. ### Snapshot changes The `show_statistics_syntax_errors` integration test changed because the `OldDiagnostic::name` method used `syntax-error` instead of `invalid-syntax` like in ty. I think this (`--statistics`) is one of the only places we actually use this name for syntax errors, so I hope this is okay. An alternative is to use `syntax-error` in ty too. The other snapshot changes are from removing this code, as discussed on [Discord](1388252408): 34052a1185/crates/ruff_linter/src/message/mod.rs (L128-L135) I think both of these are technically breaking changes, but they only affect syntax errors and are very narrow in scope, while also pretty substantially simplifying the refactor, so I hope they're okay to include in a patch release. ## Test plan Existing tests, with the adjustments mentioned above --------- Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>	2025-07-03 13:01:09 -04:00
Brent Westbrook	9bee8376a1	Bump 0.12.2 (#19126)	2025-07-03 12:27:24 -04:00
Brent Westbrook	b00f68a23c	[ruff] Allow more field calls from attrs (RUF009) (#19021) ... Summary -- Closes #19014 by identifying more `field` functions from `attrs`. We already detected these when imported from `attrs` but not the `attr` module from the same package. These functions are identical to the `attrs` versions: ```pycon >>> import attrs, attr >>> attrs.field is attr.field True >>> attrs.Factory is attr.Factory True >>> ``` Test Plan -- Regression tests based on the issue	2025-07-03 10:29:55 -04:00