mirror of
https://github.com/astral-sh/ruff.git
synced 2025-09-27 12:29:28 +00:00
bf4b96c5de
## Summary In Python, the annotations on `x` and `y` here have very different treatment: ```python def foo(x: int): y: int ``` The `int` in `x: int` is a runtime-required annotation, because `x` gets added to the function's `__annotations__`. You'll notice, for example, that this fails: ```python from typing import TYPE_CHECKING if TYPE_CHECKING: from foo import Bar def f(x: Bar): ... ``` Because `Bar` is required to be available at runtime, not just at typing time. Meanwhile, this succeeds: ```python from typing import TYPE_CHECKING if TYPE_CHECKING: from foo import Bar def f(): x: Bar = 1 f() ``` (Both cases are fine if you use `from __future__ import annotations`.) Historically, we've tracked those annotations that are _not_ runtime-required via the semantic model's `ANNOTATION` flag. But annotations that _are_ runtime-required have been treated as "type definitions" that aren't annotations. This causes problems for the flake8-future-annotations rules, which try to detect whether adding `from __future__ import annotations` would _allow_ you to rewrite a type annotation. We need to know whether we're in _any_ type annotation, runtime-required or not, since adding `from __future__ import annotations` will convert any runtime-required annotation to a typing-only annotation. This PR adds separate state to track these runtime-required annotations. The changes in the test fixtures are correct -- these were false negatives before. Closes https://github.com/astral-sh/ruff/issues/5574. |
||
|---|---|---|
| .. | ||
| analyze | ||
| binding.rs | ||
| context.rs | ||
| definition.rs | ||
| globals.rs | ||
| lib.rs | ||
| model.rs | ||
| node.rs | ||
| reference.rs | ||
| scope.rs | ||
| star_import.rs | ||