11475 commits

This branch

This branch

All branches

Author	SHA1	Message	Date
Dhruv Manilawala	c2a05b4825	[ty] Use bitflags for resolved client capabilities (#19393) ... ## Summary This PR updates the `ResolvedClientCapabilities` to be represented as `bitflags`. This allows us to remove the `Arc` as the type becomes copy. Additionally, this PR also fixed the goto definition and declaration code to use the `textDocument.definition.linkSupport` and `textDocument.declaration.linkSupport` client capability. This PR also removes the unused client capabilities which are `code_action_deferred_edit_resolution`, `apply_edit`, and `document_changes` which are all related to auto-fix ability.	2025-07-17 15:31:47 +05:30
UnboundVariable	fae0b5c89e	[ty] Initial implementation of declaration and definition providers. (#19371) ... This PR implements "go to definition" and "go to declaration" functionality for name nodes only. Future PRs will add support for attributes, module names in import statements, keyword argument names, etc. This PR: * Registers a declaration and definition request handler for the language server. * Splits out the `goto_type_definition` into its own module. The `goto` module contains functionality that is common to `goto_type_definition`, `goto_declaration` and `goto_definition`. * Roughs in a new module `stub_mapping` that is not yet implemented. It will be responsible for mapping a definition in a stub file to its corresponding definition(s) in an implementation (source) file. * Adds a new IDE support function `definitions_for_name` that collects all of the definitions associated with a name and resolves any imports (recursively) to find the original definitions associated with that name. * Adds a new `VisibleAncestorsIter` stuct that iterates up the scope hierarchy but skips scopes that are not visible to starting scope. --------- Co-authored-by: UnboundVariable <unbound@gmail.com>	2025-07-16 15:07:24 -07:00
Matthew Mckee	cbe94b094b	[ty] Support empty function bodies in if TYPE_CHECKING blocks (#19372) ... ## Summary Resolves https://github.com/astral-sh/ty/issues/339 Supports having a blank function body inside `if TYPE_CHECKING` block or in the elif or else of a `if not TYPE_CHECKING` block. ```py if TYPE_CHECKING: def foo() -> int: ... if not TYPE_CHECKING: ... else: def bar() -> int: ... ``` ## Test Plan Update `function/return_type.md` --------- Co-authored-by: Carl Meyer <carl@astral.sh>	2025-07-16 14:48:04 -06:00
Dan Parizher	029de784f1	[flake8-use-pathlib] Fix false negative on direct Path() instantiation (PTH210) (#19388) ... ## Summary Fixes #19329 --------- Co-authored-by: Brent Westbrook <36778786+ntBre@users.noreply.github.com>	2025-07-16 20:43:03 +00:00
frank	ff94fe7447	Treat form feed as valid whitespace before a semicolon (#19343) ... fixes #19310	2025-07-16 16:39:05 -04:00
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
Jack O'Connor	64ac7d7dbf	[ty] use the name span rather than the statement span for unresolved global lints (#19379) ... This is a follow-up to https://github.com/astral-sh/ruff/pull/19344 that improves the error formatting slightly. For example with this program: ```py def f(): global foo, bar ``` Before we printed: ``` 1 | def f(): 2 | global foo, bar | ^^^^^^^^^^^^^^^ `foo` has no declarations or bindings in the global scope ... 1 | def f(): 2 | global foo, bar | ^^^^^^^^^^^^^^^ `bar` has no declarations or bindings in the global scope ``` Now we print: ``` 1 | def f(): 2 | global foo, bar | ^^^ `foo` has no declarations or bindings in the global scope ... 1 | def f(): 2 | global foo, bar | ^^^ `bar` has no declarations or bindings in the global scope ``` --------- Co-authored-by: Micha Reiser <micha@reiser.io>	2025-07-16 15:34:47 +00:00
Jack O'Connor	5f2e855c29	allow reads of "free" variables to refer to a global declaration ... Previously this worked if there was also a binding in the same scope as the `global` declaration (probably almost always the case), but CPython doesn't require this. This change surfaced an error in an existing test, where a global variable was only ever declared and bound using the `global` keyword, and never mentioned explicitly in the global scope. @AlexWaygood suggested we probably want to keep that requirement, so I'm adding an a new test for that on top of fixing the failing test.	2025-07-16 08:30:42 -07:00
Jack O'Connor	3b4667ec32	respect annotation-only declarations in infer_place_load	2025-07-16 08:30:42 -07: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
Cornelius Roemer	b8dddd514f	chore: Document Material for MkDocs Insiders limitations in CONTRIBUTING.md in more detail (#19373) ... Co-authored-by: Micha Reiser <micha@reiser.io>	2025-07-16 08:42:25 +00:00
Jack O'Connor	e73a8ba571	lint on the global keyword if there's no explicit definition in the global scope	2025-07-15 16:56:54 -07:00
David Peter	a1edb69ea5	[ty] Enum literal types (#19328) ... ## Summary Add a new `Type::EnumLiteral(…)` variant and infer this type for member accesses on enums. **Example**: No more `@Todo` types here: ```py from enum import Enum class Answer(Enum): YES = 1 NO = 2 def is_yes(self) -> bool: return self == Answer.YES reveal_type(Answer.YES) # revealed: Literal[Answer.YES] reveal_type(Answer.YES == Answer.NO) # revealed: Literal[False] reveal_type(Answer.YES.is_yes()) # revealed: bool ``` ## Test Plan * Many new Markdown tests for the new type variant * Added enum literal types to property tests, ran property tests ## Ecosystem analysis Summary: Lots of false positives removed. All of the new diagnostics are either new true positives (the majority) or known problems. Click for detailed analysis</summary> Details: ```diff AutoSplit (https://github.com/Toufool/AutoSplit) + error[call-non-callable] src/capture_method/__init__.py:137:9: Method `__getitem__` of type `bound method CaptureMethodDict.__getitem__(key: Never, /) -> type[CaptureMethodBase]` is not callable on object of type `CaptureMethodDict` + error[call-non-callable] src/capture_method/__init__.py:147:9: Method `__getitem__` of type `bound method CaptureMethodDict.__getitem__(key: Never, /) -> type[CaptureMethodBase]` is not callable on object of type `CaptureMethodDict` + error[call-non-callable] src/capture_method/__init__.py:148:1: Method `__getitem__` of type `bound method CaptureMethodDict.__getitem__(key: Never, /) -> type[CaptureMethodBase]` is not callable on object of type `CaptureMethodDict` ``` New true positives. That `__getitem__` method is apparently annotated with `Never` to prevent developers from using it. ```diff dd-trace-py (https://github.com/DataDog/dd-trace-py) + error[invalid-assignment] ddtrace/vendor/psutil/_common.py:29:5: Object of type `None` is not assignable to `Literal[AddressFamily.AF_INET6]` + error[invalid-assignment] ddtrace/vendor/psutil/_common.py:33:5: Object of type `None` is not assignable to `Literal[AddressFamily.AF_UNIX]` ``` Arguably true positives: e0a772c28b/ddtrace/vendor/psutil/_common.py (L29) ```diff ignite (https://github.com/pytorch/ignite) + error[invalid-argument-type] tests/ignite/engine/test_custom_events.py:190:34: Argument to bound method `__call__` is incorrect: Expected `((...) -> Unknown) | None`, found `Literal["123"]` + error[invalid-argument-type] tests/ignite/engine/test_custom_events.py:220:37: Argument to function `default_event_filter` is incorrect: Expected `Engine`, found `None` + error[invalid-argument-type] tests/ignite/engine/test_custom_events.py:220:43: Argument to function `default_event_filter` is incorrect: Expected `int`, found `None` + error[call-non-callable] tests/ignite/engine/test_custom_events.py:561:9: Object of type `CustomEvents` is not callable + error[invalid-argument-type] tests/ignite/metrics/test_frequency.py:50:38: Argument to bound method `attach` is incorrect: Expected `Events`, found `CallableEventWithFilter` ``` All true positives. Some of them are inside `pytest.raises(TypeError, …)` blocks 🙃 ```diff meson (https://github.com/mesonbuild/meson) + error[invalid-argument-type] unittests/internaltests.py:243:51: Argument to bound method `__init__` is incorrect: Expected `bool`, found `Literal[MachineChoice.HOST]` + error[invalid-argument-type] unittests/internaltests.py:271:51: Argument to bound method `__init__` is incorrect: Expected `bool`, found `Literal[MachineChoice.HOST]` ``` New true positives. Enum literals can not be assigned to `bool`, even if their value types are `0` and `1`. ```diff poetry (https://github.com/python-poetry/poetry) + error[invalid-assignment] src/poetry/console/exceptions.py:101:5: Object of type `Literal[""]` is not assignable to `InitVar[str]` ``` New false positive, missing support for `InitVar`. ```diff prefect (https://github.com/PrefectHQ/prefect) + error[invalid-argument-type] src/integrations/prefect-dask/tests/test_task_runners.py:193:17: Argument is incorrect: Expected `StateType`, found `Literal[StateType.COMPLETED]` ``` This is confusing. There are two definitions ([one](74d8cd93ee/src/prefect/client/schemas/objects.py (L89-L100)), [two](https://github.com/PrefectHQ/prefect/blob/main/src/prefect/server/schemas/states.py#L40)) of the `StateType` enum. Here, we're trying to assign one to the other. I don't think that should be allowed, so this is a true positive (?). ```diff python-htmlgen (https://github.com/srittau/python-htmlgen) + error[invalid-assignment] test_htmlgen/form.py:51:9: Object of type `str` is not assignable to attribute `autocomplete` of type `Autocomplete | None` + error[invalid-assignment] test_htmlgen/video.py:38:9: Object of type `str` is not assignable to attribute `preload` of type `Preload | None` ``` True positives. [The stubs are wrong](01e3b911ac/htmlgen/form.pyi (L8-L10)). These should not contain type annotations, but rather just `OFF = ...`. ```diff rotki (https://github.com/rotki/rotki) + error[invalid-argument-type] rotkehlchen/tests/unit/test_serialization.py:62:30: Argument to bound method `deserialize` is incorrect: Expected `str`, found `Literal[15]` ``` New true positive. ```diff vision (https://github.com/pytorch/vision) + error[unresolved-attribute] test/test_extended_models.py:302:17: Type `type[WeightsEnum]` has no attribute `DEFAULT` + error[unresolved-attribute] test/test_extended_models.py:302:58: Type `type[WeightsEnum]` has no attribute `DEFAULT` ``` Also new true positives. No `DEFAULT` member exists on `WeightsEnum`.	2025-07-15 21:31:53 +02:00
github-actions[bot]	a0d4e1f854	[ty] Sync vendored typeshed stubs (#19368) ... Co-authored-by: typeshedbot <> Co-authored-by: Alex Waygood <alex.waygood@gmail.com>	2025-07-15 18:14:46 +00:00
Alex Waygood	c0d04f2d56	Fix typeshed-sync workflow (#19367)	2025-07-15 19:07:38 +01:00
Alex Waygood	8d7d02193e	Rework typeshed-sync workflow to also add docstrings for Windows- and MacOS-specific APIs (#19360)	2025-07-15 18:14:32 +01:00
Zanie Blue	78dfc8af0f	[ty] Allow -qq for silent output mode (#19366) ... This matches uv's behavior. Briefly discussed at https://github.com/astral-sh/ruff/pull/19233#discussion_r2197930360 I think the most useful case is to avoid piping to `/dev/null` which hard to do properly in a cross-platform script.	2025-07-15 17:08:19 +00:00
Zanie Blue	0c84652cc5	[ty] Allow -q short alias for --quiet (#19364)	2025-07-15 12:00:07 -05:00
Alex Waygood	560ae04346	Add shellcheck to pre-commit (#19361)	2025-07-15 16:49:13 +00:00
Jack O'Connor	a357a68fc9	distinguish references from definitions in infer_nonlocal ... The initial implementation of `infer_nonlocal` landed in https://github.com/astral-sh/ruff/pull/19112 fails to report an error for this example: ```py x = 1 def f(): # This is only a usage of `x`, not a definition. It shouldn't be # enough to make the `nonlocal` statement below allowed. print(x) def g(): nonlocal x ``` Fix this by continuing to walk enclosing scopes when the place we've found isn't bound, declared, or `nonlocal`.	2025-07-15 07:55:40 -07: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
Douglas Creager	f4d0273532	[ty] Combine CallArguments and CallArgumentTypes (#19337) ... We previously had separate `CallArguments` and `CallArgumentTypes` types in support of our two-phase call binding logic. `CallArguments` would store only the arity/kind of each argument (positional, keyword, variadic, etc). We then performed parameter matching using only this arity/kind information, and then infered the type of each argument, placing the result of this second phase into a new `CallArgumentTypes`. In #18996, we will need to infer the types of splatted arguments _before_ performing parameter matching, since we need to know the argument type to accurately infer its length, which informs how many parameters the splatted argument is matched against. That makes this separation of Rust types no longer useful. This PR merges everything back into a single `CallArguments`. In the case where we are performing two-phase call binding, the types will be initialized to `None`, and updated to the actual argument type during the second `check_types` phase. _[This is a refactoring in support of fixing the merge conflicts on #18996. I've pulled this out into a separate PR to make it easier to review in isolation.]_	2025-07-15 10:20:58 -04: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
Alex Waygood	002f9057db	[ty] Reduce false positives for TypedDict types (#19354)	2025-07-15 12:47:19 +01:00
Dhruv Manilawala	f3a27406c9	[ty] Remove ConnectionInitializer (#19353) ... ## Summary This PR removes the `ConnectionInitializer` and inlines the `initialize_start` and `initialize_finish` calls. The main benefit of this is that it will allow us to use [`Connection::memory`](https://docs.rs/lsp-server/latest/lsp_server/struct.Connection.html#method.memory) in the mock server. That method returns two `Connection` where one of them will represent the client side connection and the other will be sent to the `Server::new` call to be used by the server. This way the mock client can send notifications and requests to mimic the editor. ## Test Plan I tested out the initialization process and checked that the initialized result contains the server capabilities and server info.	2025-07-15 17:02:44 +05:30
Alex Waygood	2c9da80985	[ty] Use Type::string_literal() more (#19352)	2025-07-15 11:09:07 +00:00
David Peter	8e61da740a	[ty] Add ecosystem-report workflow (#19349) ... ## Summary Adds a new workflow that generates an ecosystem report of all diagnostics and publishes it to Cloudflare pages. ## Test Plan Not yet tested.	2025-07-15 12:29:44 +02:00
Micha Reiser	e506296cec	[ty] Make use of salsa Lookup when interning values (#19347)	2025-07-15 09:54:43 +02:00
github-actions[bot]	966cc9d6e9	[ty] Sync vendored typeshed stubs (#19345) ... Close and reopen this PR to trigger CI Co-authored-by: typeshedbot <>	2025-07-15 11:46:59 +05:30
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
github-actions[bot]	4f60f0e925	[ty] Sync vendored typeshed stubs (#19334) ... Co-authored-by: typeshedbot <> Co-authored-by: Alex Waygood <alex.waygood@gmail.com>	2025-07-14 17:34:09 +01: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
Alex Waygood	021a70d30c	[ty] ignore errors when reformatting codemodded typeshed (#19332)	2025-07-14 16:14:01 +00:00
Alex Waygood	fddf2f33d2	[ty] Provide docstrings for stdlib APIs when hovering over them in an IDE (#19311)	2025-07-14 17:00:45 +01:00
Dhruv Manilawala	b4c42eb83b	[ty] Add virtual files to the only project database (#19322) ... ## Summary Previously, the virtual files were being added to the default database that's present on the session. This is wrong because the default database is for any files that don't belong to any project i.e., they're outside of any projects managed by the server. Virtual files are neither part of the project nor it is outside the projects. This was not the intention as in the initial version, virtual files were being added to the only project database managed by the server. This PR fixes this by reverting back to the original behavior where virtual files will be added to the only project database present. When support for multiple workspace and project is added, this will require updating (https://github.com/astral-sh/ty/issues/794). This is required for #19264 because workspace diagnostics doesn't check the default project database yet. Ideally, the default db should be checked as well. The implementation of this PR means that virtual files are now being included for workspace diagnostics but it doesn't work completely e.g., if I save an untitled file the diagnostics disappears but it doesn't appear back for the (now) saved file on disk as shown in the following video demonstration: https://github.com/user-attachments/assets/123e8d20-1e95-4c7d-b7eb-eb65be8c476e	2025-07-14 20:17:51 +05:30
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
Dhruv Manilawala	8a217e5920	[ty] Remove FileLookupError (#19323) ... ## Summary This PR removes the `FileLookupError` as it's not really required. The original intention was that this would be returned from the `.file` lookup to the different handlers but we've since moved the logic of "lookup file and add trace message if file unavailable with the reason" under the `file_ok` method which all of the handlers use.	2025-07-14 13:35:14 +00:00
Andrew Gallant	f7973ac870	[ty] Fix handling of metaclasses in object.<CURSOR> completions ... Basically, we weren't quite using `Type::member` in every case correctly. Specifically, this example from @sharkdp: ``` class Meta(type): @property def meta_attr(self) -> int: return 0 class C(metaclass=Meta): ... C.<CURSOR> ``` While we would return `C.meta_attr` here, we were claiming its type was `property`. But its type should be `int`. Ref https://github.com/astral-sh/ruff/pull/19216#discussion_r2197065241	2025-07-14 08:24:23 -04:00
Micha Reiser	3560f86450	[ty] Use an interval map for scopes by expression (#19025)	2025-07-14 13:50:58 +02:00
David Peter	f22da352db	[ty] List all enum members (#19283) ... ## Summary Adds a way to list all members of an `Enum` and implements almost all of the mechanisms by which members are distinguished from non-members ([spec](https://typing.python.org/en/latest/spec/enums.html#defining-members)). This has no effect on actual enums, so far. ## Test Plan New Markdown tests using `ty_extensions.enum_members`.	2025-07-14 13:18:17 +02:00
Micha Reiser	cb530a0216	[ty] Handle configuration errors in LSP more gracefully (#19262)	2025-07-14 12:27:52 +02:00
Micha Reiser	90026047f9	[ty] Use python version and path from Python extension (#19012)	2025-07-14 09:47:27 +00:00