mirror of
https://github.com/astral-sh/ruff
synced 2026-01-23 14:30:53 -05:00
e7e86b85840ffc62c18d1ec2ee46740a2c9db27c
717 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
Andrew Gallant
|
e7e86b8584 |
red_knot_python_semantic: remove InferContext::report_diagnostic
... and replace it with use of `report()`. Interestingly, this is the only instance of `report_diagnostic` used directly, and thus anticipated to be the only instance of using `report()`. If this ends up being a true single use method, we could make it less generic and tailored specifically to "reveal type." Two other things to note: I left the "primary message" as empty. This avoids changing snapshots. I address this in a subsequent commit. The creation of a diagnostic here is a bit verbose/annoying. Certainly more so than it was. This is somewhat expected since our diagnostic model is more expressive and because we don't have a proc macro. I avoided creating helpers for this case since there's only one use of `report()`. But I expect to create helpers for the `lint()` case. |
||
|
Andrew Gallant
|
f84bc07d56 |
red_knot_python_semantic: add "reporter" API
This is a surgical change that adds new `report()` and `lint()` APIs to `InferContext`. These are intended to replace the existing `report_*` APIs. The comments should explain what these reporters are meant to do. For the most part, this is "just" shuffling some code around. The actual logic for determining whether a lint *should* be reported or not remains unchanged and we don't make any changes to how a `Diagnostic` is actually constructed (yet). I initially tried to just use `LintReporter` and `DiagnosticReporter` without the builder types, since I perceive the builder types to be an annoying additional layer. But I found it also exceedingly annoying to have to construct and provide the diagnostic message before you even know if you are going to build the diagnostic. I also felt like this could result in potentially unnecessary and costly querying in some cases, although this is somewhat hand wavy. So I overall felt like the builder route was the way to go. If the builders end up being super annoying, we can probably add convenience APIs for common patterns to paper over them. |
||
David Peter
|
5b6e94981d |
[red-knot] Silence unresolved-attribute in unreachable code (#17305)
## Summary Basically just repeat the same thing that we did for `unresolved-reference`, but now for attribute expressions. We now also handle the case where the unresolved attribute (or the unresolved reference) diagnostic originates from a stringified type annotation. And I made the evaluation of reachability constraints lazy (will only be evaluated right before we are about to emit a diagnostic). ## Test Plan New Markdown tests for stringified annotations. |
||
Carl Meyer
|
ec74f2d522 |
Revert "[red-knot] Type narrowing for assertions (#17149)" (#17335)
I merged #17149 without checking the ecosystem results, and it still caused a cycle panic in pybind11. Reverting for now until I fix that, so we don't lose the ecosystem signal on other PRs. |
||
Matthew Mckee
|
907b6ed7b5 |
[red-knot] Type narrowing for assertions (#17149)
## Summary Fixes #17147 ## Test Plan Add new narrow/assert.md test file --------- Co-authored-by: Carl Meyer <carl@astral.sh> |
||
|
Carl Meyer
|
fd9882a1f4 |
[red-knot] avoid unnecessary evaluation of visibility constraint on definitely-unbound symbol (#17326)
This causes spurious query cycles. This PR also includes an update to Salsa, which gives us db events on cycle iteration, so we can write tests asserting the absence of a cycle. |
||
|
David Peter
|
4d50ee6f52 |
[red-knot] Track reachability of scopes (#17332)
## Summary
Track the reachability of nested scopes within their parent scopes. We
use this as an additional requirement for emitting
`unresolved-reference` diagnostics (and in the future,
`unresolved-attribute` and `unresolved-import`). This means that we only
emit `unresolved-reference` for a given use of a symbol if the use
itself is reachable (within its own scope), *and if the scope itself is
reachable*. For example, no diagnostic should be emitted for the use of
`x` here:
```py
if False:
x = 1
def f():
print(x) # this use of `x` is reachable inside the `f` scope,
# but the whole `f` scope is not reachable.
```
There are probably more fine-grained ways of solving this problem, but
they require a more sophisticated understanding of nested scopes (see
#15777, in particular
https://github.com/astral-sh/ruff/issues/15777#issuecomment-2788950267).
But it doesn't seem completely unreasonable to silence *this specific
kind of error* in unreachable scopes.
## Test Plan
Observed changes in reachability tests and ecosystem.
|
||
|
David Peter
|
5fef4d4572 |
Use python.typing.org for typing documentation links (#17323)
## Summary There is a new official URL for the typing documentation: https://typing.python.org/ Change all https://typing.readthedocs.io/ links to use the new sub domain, which is slightly shorter and looks more official. ## Test Plan Tested to see if each and every new URL is accessible. I noticed that some links go to https://typing.python.org/en/latest/source/stubs.html which seems to be outdated, but that is a separate issue. The same page shows up for the old URL. |
||
Alex Waygood
|
781b653511 |
[red-knot] Fix false positives on types.UnionType instances in type expressions (#17297)
|
||
|
Alex Waygood
|
73399029b2 |
[red-knot] Optimise visibility constraints for *-import definitions (#17317)
|
||
Douglas Creager
|
ff376fc262 |
[red-knot] Allow explicit specialization of generic classes (#17023)
This PR lets you explicitly specialize a generic class using a subscript expression. It introduces three new Rust types for representing classes: - `NonGenericClass` - `GenericClass` (not specialized) - `GenericAlias` (specialized) and two enum wrappers: - `ClassType` (a non-generic class or generic alias, represents a class _type_ at runtime) - `ClassLiteralType` (a non-generic class or generic class, represents a class body in the AST) We also add internal support for specializing callables, in particular function literals. (That is, the internal `Type` representation now attaches an optional specialization to a function literal.) This is used in this PR for the methods of a generic class, but should also give us most of what we need for specializing generic _functions_ (which this PR does not yet tackle). --------- Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com> Co-authored-by: Carl Meyer <carl@astral.sh> |
||
|
Alex Waygood
|
6ec4c6a97e |
[red-knot] Improve handling of visibility constraints in external modules when resolving * imports (#17286)
|
||
Micha Reiser
|
8249a72412 |
[red-knot] Default python-platform to current platform (#17183)
## Summary As discussed in https://github.com/astral-sh/ruff/issues/16983 and "mitigate" said issue for the alpha. This PR changes the default for `PythonPlatform` to be the current platform rather than `all`. I'm not sure if we should be as sophisticated as supporting `ios` and `android` as defaults but it was easy... ## Test Plan Updated Markdown tests. --------- Co-authored-by: David Peter <mail@david-peter.de> |
||
|
David Peter
|
2cee86d807 |
[red-knot] Add custom __setattr__ support (#16748)
## Summary Add support for classes with a custom `__setattr__` method. ## Test Plan New Markdown tests, ecosystem checks. |
||
Mike Perlov
|
fab7d820bd |
[red-knot] Add __init__ arguments check when doing try_call on a class literal (#16512)
## Summary * Addresses #16511 for simple cases where only `__init__` method is bound on class or doesn't exist at all. * fixes a bug with argument counting in bound method diagnostics Caveats: * No handling of `__new__` or modified `__call__` on metaclass. * This leads to a couple of false positive errors in tests ## Test Plan - A couple new cases in mdtests - cargo nextest run -p red_knot_python_semantic --no-fail-fast --------- Co-authored-by: Carl Meyer <carl@astral.sh> Co-authored-by: David Peter <sharkdp@users.noreply.github.com> |
||
|
David Peter
|
b662c3ff7e |
[red-knot] Add support for assert_never (#17287)
## Summary We already have partial "support" for `assert_never`, because it is annotated as ```pyi def assert_never(arg: Never, /) -> Never: ... ``` in typeshed. So we already emit a `invalid-argument-type` diagnostic if the argument type to `assert_never` is not assignable to `Never`. That is not enough, however. Gradual types like `Any`, `Unknown`, `@Todo(…)` or `Any & int` can be assignable to `Never`. Which means that we didn't issue any diagnostic in those cases. Also, it seems like `assert_never` deserves a dedicated diagnostic message, not just a generic "invalid argument type" error. ## Test Plan New Markdown tests. |
||
|
David Peter
|
60f2e67454 |
[red-knot] Reachability analysis (#17199)
## Summary This implements a new approach to silencing `unresolved-reference` diagnostics by keeping track of the reachability of each use of a symbol. The changes merged in https://github.com/astral-sh/ruff/pull/17169 are still needed for the "Use of variable in nested function" test case, but that could also be solved in another way eventually (see https://github.com/astral-sh/ruff/issues/15777). We can use the same technique to silence `unresolved-import` and `unresolved-attribute` false-positives, but I think this could be merged in isolation. ## Test Plan New Markdown tests, ecosystem tests |
||
|
David Peter
|
3657f798c9 |
[red-knot] Add --python-platform CLI option (#17284)
## Summary Add a new `--python-platform` command-line option, in analogy to `--python-version`. ## Test Plan Added new integration test. |
||
|
Matthew Mckee
|
4a4a376f02 |
[red-knot] Allow ellipsis default params in stub functions (#17243)
## Summary Fixes #17234 ## Test Plan Add tests to functions/paremeters.md --------- Co-authored-by: Carl Meyer <carl@astral.sh> |
||
|
Micha Reiser
|
6cc2d02dfa |
[red-knot] Support stub packages (#17204)
## Summary This PR adds support for stub packages, except for partial stub packages (a stub package is always considered non-partial). I read the specification at [typing.python.org/en/latest/spec/distributing.html#stub-only-packages](https://typing.python.org/en/latest/spec/distributing.html#stub-only-packages) but I found it lacking some details, especially on how to handle namespace packages or when the regular and stub packages disagree on whether they're namespace packages. I tried to document my decisions in the mdtests where the specification isn't clear and compared the behavior to Pyright. Mypy seems to only support stub packages in the venv folder. At least, it never picked up my stub packages otherwise. I decided not to spend too much time fighting mypyp, which is why I focused the comparison around Pyright Closes https://github.com/astral-sh/ruff/issues/16612 ## Test plan Added mdtests |
||
|
Alex Waygood
|
ac5d220d75 |
[red-knot] Fix python setting in mdtests, and rewrite a site-packages test as an mdtest (#17222)
## Summary This PR does the following things: - Fixes the `python` configuration setting for mdtest (added in https://github.com/astral-sh/ruff/pull/17221) so that it expects a path pointing to a venv's `sys.prefix` variable rather than the a path pointing to the venv's `site-packages` subdirectory. This brings the `python` setting in mdtest in sync with our CLI `--python` flag. - Tweaks mdtest so that it automatically creates a valid `pyvenv.cfg` file for you if you don't specify one. This makes it much more ergonomic to write an mdtest with a custom `python` setting: red-knot will reject a `python` setting that points to a directory that doesn't have a `pyvenv.cfg` file in it - Tweaks mdtest so that it doesn't check a custom `pyvenv.cfg` as Python source code if you _do_ add a custom `pyvenv.cfg` file for your mock virtual environment in an mdtest. (You get a lot of diagnostics about Python syntax errors in the `pyvenv.cfg` file, otherwise!) - Rewrites the test added in https://github.com/astral-sh/ruff/pull/17178 as an mdtest, and deletes the original test that was added in that PR ## Test Plan I verified that the new mdtest fails if I revert the changes to `resolver.rs` that were added in https://github.com/astral-sh/ruff/pull/17178 |
||
|
Matthew Mckee
|
73a9974d8a |
Fix CallableTypeOf display signature (#17235)
|
||
cake-monotone
|
7e6d3838bd |
[red-knot] Add cycle handling to narrow constraints queries (#17209)
## Summary This PR fixes the cycle issue that was causing problems in the `support super` PR. ### Affected queries - `all_narrowing_constraints_for_expression` - `all_negative_narrowing_constraints_for_expression` -- Additionally, `bidict` and `werkzeug` have been added to the project-selection list in `mypy_primer`. This PR also addresses the panics that occurred while analyzing those packages: - `bidict`: panic triggered by `all_narrowing_constraints_for_expression` - `werkzeug`: panic triggered by `all_negative_narrowing_constraints_for_expression` I think the mypy-primer results for this PR can serve as sufficient test :) |
||
|
David Peter
|
1a6a10b30f |
[red-knot] Empty tuple is always-falsy (#17213)
## Summary Fix assignability of `tuple[()]` to `AlwaysFalsy`. closes #17202 ## Test Plan Ran the property tests for a while |
||
|
Micha Reiser
|
ffa824e037 |
[red-knot] Add Type.definition method (#17153)
## Summary This is a follow up to the goto type definition PR. Specifically, that we want to avoid exposing too many semantic model internals publicly. I want to get some feedback on the approach taken. I think it goes into the right direction but I'm not super happy with it. The basic idea is that we add a `Type::definition` method which does the "goto type definition". The parts that I think make it awkward: * We can't directly return `Definition` because we don't create a `Definition` for modules (but we could?). Although I think it makes sense to possibly have a more public wrapper type anyway? * It doesn't handle unions and intersections. Mainly because not all elements in an intersection may have a definition and we only want to show a navigation target for intersections if there's only a single positive element (besides maybe `Unknown`). An alternative design or an addition to this design is to introduce a `SemanticAnalysis(Db)` struct that has methods like `type_definition(&self, type)` which explicitly exposes the methods we want. I don't feel comfortable design this API yet because it's unclear how fine granular it has to be (and if it is very fine granular, directly using `Type` might be better after all) ## Test Plan `cargo test` |
||
|
Carl Meyer
|
bf0306887a |
[red-knot] don't remove negations when simplifying constrained typevars (#17189)
For two non-disjoint types `P` and `Q`, the simplification of `(P | Q) & ~Q` is not `P`, but `P & ~Q`. In other words, the non-empty set `P & Q` is also excluded from the type. The same applies for a constrained typevar `[T: (P, Q)]`: `T & ~Q` should simplify to `P & ~Q`, not just `P`. Implementing this is actually purely a matter of removing code from the constrained typevar simplification logic; we just need to not bother removing the negations. If the negations are actually redundant (because the constraint types are disjoint), normal intersection simplification will already eliminate them (as shown in the added test.) |
||
|
Micha Reiser
|
e7684d3493 |
Enable overindented docs lint (#17182)
## Summary It turns out that `a.` isn't a list format supported by rustdoc. I changed the documentation to use `1.`, `2.` instead. ## Test Plan `cargo clippy` |
||
|
Douglas Creager
|
64e7e1aa64 |
[red-knot] Add Type::TypeVar variant (#17102)
This adds a new `Type` variant for holding an instance of a typevar inside of a generic function or class. We don't handle specializing the typevars yet, but this should implement most of the typing rules for inside the generic function/class, where we don't know yet which specific type the typevar will be specialized to. This PR does _not_ yet handle the constraint that multiple occurrences of the typevar must be specialized to the _same_ time. (There is an existing test case for this in `generics/functions.md` which is still marked as TODO.) --------- Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com> Co-authored-by: Carl Meyer <carl@astral.sh> |
||
|
Micha Reiser
|
8a4158c5f8 |
Upgrade to Rust 1.86 and bump MSRV to 1.84 (#17171)
<!-- Thank you for contributing to Ruff! 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? - Does this pull request include references to any relevant issues? --> ## Summary I decided to disable the new [`needless_continue`](https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue) rule because I often found the explicit `continue` more readable over an empty block or having to invert the condition of an other branch. ## Test Plan `cargo test` --------- Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com> |
||
|
David Peter
|
fedd982fd5 |
[red-knot] Avoid unresolved-reference in unreachable code (#17169)
## Summary This PR changes the inferred type for symbols in unreachable sections of code to `Never` (instead of reporting them as unbound), in order to silence false positive diagnostics. See the lengthy comment in the code for further details. ## Test Plan - Updated Markdown tests. - Manually verified a couple of ecosystem diagnostic changes. |
||
|
Alex Waygood
|
a1eb834a5f |
Fix relative import resolution in site-packages packages when the site-packages search path is a subdirectory of the first-party search path (#17178)
## Summary
If a package in `site-packages` had this directory structure:
```py
# bar/__init__.py
from .a import A
# bar/a.py
class A: ...
```
then we would fail to resolve the `from .a import A` import _if_ (as is
usually the case!) the `site-packages` search path was located inside a
`.venv` directory that was a subdirectory of the project's first-party
search path. The reason for this is a bug in `file_to_module` in the
module resolver. In this loop, we would identify that
`/project_root/.venv/lib/python3.13/site-packages/foo/__init__.py` can
be turned into a path relative to the first-party search path
(`/project_root`):
|
||
|
Alex Waygood
|
ca0cce3f9c |
[red-knot] Fix more [redundant-cast] false positives (#17170)
Fixes #17164. Simply checking whether one type is gradually equivalent to another is too simplistic here: `Any` is gradually equivalent to `Todo`, but we should permit users to cast from `Todo` or `Unknown` to `Any` without complaining about it. This changes our logic so that we only complain about redundant casts if: - the two types are exactly equal (when normalized) OR they are equivalent (we'll still complain about `Any -> Any` casts, and about `Any | str | int` -> `str | int | Any` casts, since their normalized forms are exactly equal, even though the type is not fully static -- and therefore does not participate in equivalence relations) - AND the casted type does not contain `Todo` |
||
|
David Peter
|
3f00010a7a |
[red-knot] Three-argument type-calls take 'str' as the first argument (#17168)
## Summary Similar to #17163, a minor fix in the signature of `type(…)`. ## Test Plan New MD tests |
||
|
Alex Waygood
|
62f8d855d2 |
[red-knot] Improve Debug implementation for semantic_index::SymbolTable (#17172)
## Summary
`dbg!`ing a `SymbolTable` is currently very noisy due to the
`symbols_by_name` field, which doesn't tell you very much at all. The
noisiness makes debugging difficult. This PR removes the
`symbols_by_name` field from the `Debug` implementation.
## Test Plan
`dbg!` output before of the `builtins.pyi` global-scope symbol table:
<details>
```
[crates/red_knot_python_semantic/src/symbol.rs:633:5] symbol_table(db, scope) = SymbolTable {
symbols: [
Symbol {
name: Name("_ast"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_sitebuiltins"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_typeshed"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("sys"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("types"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("dict_items"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("dict_keys"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("dict_values"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("AnyStr_co"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ConvertibleToFloat"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ConvertibleToInt"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("FileDescriptorOrPath"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("OpenBinaryMode"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("OpenBinaryModeReading"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("OpenBinaryModeUpdating"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("OpenBinaryModeWriting"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("OpenTextMode"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ReadableBuffer"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsAdd"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsAiter"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsAnext"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsDivMod"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsFlush"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsIter"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsKeysAndGetItem"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsLenAndGetItem"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsNext"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsRAdd"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsRDivMod"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsRichComparison"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsRichComparisonT"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsWrite"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Awaitable"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Callable"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Iterable"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Iterator"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("MutableSet"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Reversible"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("AbstractSet"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Sized"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("BufferedRandom"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("BufferedReader"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("BufferedWriter"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("FileIO"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("TextIOWrapper"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("CellType"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("CodeType"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("TracebackType"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("IO"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Any"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("BinaryIO"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ClassVar"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Generic"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Mapping"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("MutableMapping"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("MutableSequence"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Protocol"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Sequence"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsAbs"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsBytes"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsComplex"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsFloat"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SupportsIndex"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("TypeVar"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("final"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("overload"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("type_check_only"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Concatenate"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Literal"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("LiteralString"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ParamSpec"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Self"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("TypeAlias"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("TypeGuard"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("TypeIs"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("TypeVarTuple"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("deprecated"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("GenericAlias"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_T"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("int"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_I"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_T_co"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_T_contra"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_R_co"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_KT"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_VT"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_S"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_T1"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_T2"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_T3"),
flags: SymbolFlags(
IS_BOUND,
),
},
Symbol {
name: Name("_T4"),
flags: SymbolFlags(
IS_BOUND,
),
},
Symbol {
name: Name("_T5"),
flags: SymbolFlags(
IS_BOUND,
),
},
Symbol {
name: Name("_SupportsNextT_co"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_SupportsAnextT_co"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_AwaitableT"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_AwaitableT_co"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_P"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_StartT_co"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_StopT_co"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_StepT_co"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("object"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("staticmethod"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("classmethod"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("type"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("super"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_PositiveInteger"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_NegativeInteger"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_LiteralInteger"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("float"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("complex"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_FormatMapMapping"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_TranslateTable"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("str"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("bytes"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("bytearray"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_IntegerFormats"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("memoryview"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("bool"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("slice"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("tuple"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("function"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("list"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("dict"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("set"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("frozenset"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("enumerate"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("range"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("property"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_NotImplementedType"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("NotImplemented"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("abs"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("all"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("any"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ascii"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("bin"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("breakpoint"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("callable"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("chr"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_PathLike"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("aiter"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_SupportsSynchronousAnext"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("anext"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("compile"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("copyright"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("credits"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("delattr"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("dir"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("divmod"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("eval"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("exec"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("exit"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("filter"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("format"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("getattr"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("globals"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("hasattr"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("hash"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("help"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("hex"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("id"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("input"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_GetItemIterable"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("iter"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_ClassInfo"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("isinstance"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("issubclass"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("len"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("license"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("locals"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("map"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("max"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("min"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("next"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("oct"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_Opener"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("open"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ord"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_SupportsWriteAndFlush"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("print"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_E_contra"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_M_contra"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_SupportsPow2"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_SupportsPow3NoneOnly"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_SupportsPow3"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_SupportsSomeKindOfPow"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("pow"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("quit"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("reversed"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("repr"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_SupportsRound1"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_SupportsRound2"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("round"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("setattr"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("sorted"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_AddableT1"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_AddableT2"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_SupportsSumWithNoDefaultGiven"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_SupportsSumNoDefaultT"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("sum"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("vars"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("zip"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("__import__"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("__build_class__"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("EllipsisType"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ellipsis"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Ellipsis"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("BaseException"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("GeneratorExit"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("KeyboardInterrupt"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SystemExit"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Exception"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("StopIteration"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("OSError"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("EnvironmentError"),
flags: SymbolFlags(
IS_BOUND,
),
},
Symbol {
name: Name("IOError"),
flags: SymbolFlags(
IS_BOUND,
),
},
Symbol {
name: Name("WindowsError"),
flags: SymbolFlags(
IS_BOUND,
),
},
Symbol {
name: Name("ArithmeticError"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("AssertionError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("AttributeError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("BufferError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("EOFError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ImportError"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("LookupError"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("MemoryError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("NameError"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ReferenceError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("RuntimeError"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("StopAsyncIteration"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SyntaxError"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SystemError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("TypeError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ValueError"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("FloatingPointError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("OverflowError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ZeroDivisionError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ModuleNotFoundError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("IndexError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("KeyError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("UnboundLocalError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("BlockingIOError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ChildProcessError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ConnectionError"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("BrokenPipeError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ConnectionAbortedError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ConnectionRefusedError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ConnectionResetError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("FileExistsError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("FileNotFoundError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("InterruptedError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("IsADirectoryError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("NotADirectoryError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("PermissionError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ProcessLookupError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("TimeoutError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("NotImplementedError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("RecursionError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("IndentationError"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("TabError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("UnicodeError"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("UnicodeDecodeError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("UnicodeEncodeError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("UnicodeTranslateError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("Warning"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("UserWarning"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("DeprecationWarning"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("SyntaxWarning"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("RuntimeWarning"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("FutureWarning"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("PendingDeprecationWarning"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ImportWarning"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("UnicodeWarning"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("BytesWarning"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ResourceWarning"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("EncodingWarning"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("_BaseExceptionT_co"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_BaseExceptionT"),
flags: SymbolFlags(
IS_BOUND,
),
},
Symbol {
name: Name("_ExceptionT_co"),
flags: SymbolFlags(
IS_USED | IS_BOUND,
),
},
Symbol {
name: Name("_ExceptionT"),
flags: SymbolFlags(
IS_BOUND,
),
},
Symbol {
name: Name("BaseExceptionGroup"),
flags: SymbolFlags(
IS_USED | IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("ExceptionGroup"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
Symbol {
name: Name("PythonFinalizationError"),
flags: SymbolFlags(
IS_BOUND | IS_DECLARED,
),
},
],
symbols_by_name: {
ScopedSymbolId(
235,
): (),
ScopedSymbolId(
267,
): (),
ScopedSymbolId(
86,
): (),
ScopedSymbolId(
22,
): (),
ScopedSymbolId(
182,
): (),
ScopedSymbolId(
213,
): (),
ScopedSymbolId(
252,
): (),
ScopedSymbolId(
177,
): (),
ScopedSymbolId(
173,
): (),
ScopedSymbolId(
108,
): (),
ScopedSymbolId(
122,
): (),
ScopedSymbolId(
118,
): (),
ScopedSymbolId(
197,
): (),
ScopedSymbolId(
69,
): (),
ScopedSymbolId(
134,
): (),
ScopedSymbolId(
52,
): (),
ScopedSymbolId(
248,
): (),
ScopedSymbolId(
168,
): (),
ScopedSymbolId(
2,
): (),
ScopedSymbolId(
129,
): (),
ScopedSymbolId(
5,
): (),
ScopedSymbolId(
18,
): (),
ScopedSymbolId(
150,
): (),
ScopedSymbolId(
9,
): (),
ScopedSymbolId(
16,
): (),
ScopedSymbolId(
205,
): (),
ScopedSymbolId(
246,
): (),
ScopedSymbolId(
68,
): (),
ScopedSymbolId(
93,
): (),
ScopedSymbolId(
189,
): (),
ScopedSymbolId(
161,
): (),
ScopedSymbolId(
64,
): (),
ScopedSymbolId(
124,
): (),
ScopedSymbolId(
229,
): (),
ScopedSymbolId(
94,
): (),
ScopedSymbolId(
202,
): (),
ScopedSymbolId(
67,
): (),
ScopedSymbolId(
120,
): (),
ScopedSymbolId(
219,
): (),
ScopedSymbolId(
12,
): (),
ScopedSymbolId(
20,
): (),
ScopedSymbolId(
79,
): (),
ScopedSymbolId(
11,
): (),
ScopedSymbolId(
157,
): (),
ScopedSymbolId(
216,
): (),
ScopedSymbolId(
231,
): (),
ScopedSymbolId(
239,
): (),
ScopedSymbolId(
140,
): (),
ScopedSymbolId(
36,
): (),
ScopedSymbolId(
13,
): (),
ScopedSymbolId(
184,
): (),
ScopedSymbolId(
204,
): (),
ScopedSymbolId(
70,
): (),
ScopedSymbolId(
259,
): (),
ScopedSymbolId(
96,
): (),
ScopedSymbolId(
111,
): (),
ScopedSymbolId(
72,
): (),
ScopedSymbolId(
247,
): (),
ScopedSymbolId(
101,
): (),
ScopedSymbolId(
242,
): (),
ScopedSymbolId(
261,
): (),
ScopedSymbolId(
263,
): (),
ScopedSymbolId(
214,
): (),
ScopedSymbolId(
62,
): (),
ScopedSymbolId(
166,
): (),
ScopedSymbolId(
244,
): (),
ScopedSymbolId(
257,
): (),
ScopedSymbolId(
133,
): (),
ScopedSymbolId(
112,
): (),
ScopedSymbolId(
87,
): (),
ScopedSymbolId(
90,
): (),
ScopedSymbolId(
117,
): (),
ScopedSymbolId(
158,
): (),
ScopedSymbolId(
162,
): (),
ScopedSymbolId(
230,
): (),
ScopedSymbolId(
154,
): (),
ScopedSymbolId(
255,
): (),
ScopedSymbolId(
35,
): (),
ScopedSymbolId(
39,
): (),
ScopedSymbolId(
138,
): (),
ScopedSymbolId(
190,
): (),
ScopedSymbolId(
21,
): (),
ScopedSymbolId(
66,
): (),
ScopedSymbolId(
181,
): (),
ScopedSymbolId(
7,
): (),
ScopedSymbolId(
236,
): (),
ScopedSymbolId(
251,
): (),
ScopedSymbolId(
152,
): (),
ScopedSymbolId(
227,
): (),
ScopedSymbolId(
78,
): (),
ScopedSymbolId(
55,
): (),
ScopedSymbolId(
61,
): (),
ScopedSymbolId(
253,
): (),
ScopedSymbolId(
47,
): (),
ScopedSymbolId(
65,
): (),
ScopedSymbolId(
153,
): (),
ScopedSymbolId(
104,
): (),
ScopedSymbolId(
74,
): (),
ScopedSymbolId(
107,
): (),
ScopedSymbolId(
149,
): (),
ScopedSymbolId(
98,
): (),
ScopedSymbolId(
155,
): (),
ScopedSymbolId(
169,
): (),
ScopedSymbolId(
180,
): (),
ScopedSymbolId(
237,
): (),
ScopedSymbolId(
146,
): (),
ScopedSymbolId(
15,
): (),
ScopedSymbolId(
243,
): (),
ScopedSymbolId(
17,
): (),
ScopedSymbolId(
136,
): (),
ScopedSymbolId(
80,
): (),
ScopedSymbolId(
44,
): (),
ScopedSymbolId(
228,
): (),
ScopedSymbolId(
60,
): (),
ScopedSymbolId(
245,
): (),
ScopedSymbolId(
193,
): (),
ScopedSymbolId(
264,
): (),
ScopedSymbolId(
268,
): (),
ScopedSymbolId(
58,
): (),
ScopedSymbolId(
258,
): (),
ScopedSymbolId(
279,
): (),
ScopedSymbolId(
113,
): (),
ScopedSymbolId(
135,
): (),
ScopedSymbolId(
240,
): (),
ScopedSymbolId(
85,
): (),
ScopedSymbolId(
186,
): (),
ScopedSymbolId(
100,
): (),
ScopedSymbolId(
187,
): (),
ScopedSymbolId(
106,
): (),
ScopedSymbolId(
73,
): (),
ScopedSymbolId(
223,
): (),
ScopedSymbolId(
49,
): (),
ScopedSymbolId(
83,
): (),
ScopedSymbolId(
77,
): (),
ScopedSymbolId(
43,
): (),
ScopedSymbolId(
274,
): (),
ScopedSymbolId(
46,
): (),
ScopedSymbolId(
151,
): (),
ScopedSymbolId(
217,
): (),
ScopedSymbolId(
178,
): (),
ScopedSymbolId(
278,
): (),
ScopedSymbolId(
132,
): (),
ScopedSymbolId(
6,
): (),
ScopedSymbolId(
174,
): (),
ScopedSymbolId(
99,
): (),
ScopedSymbolId(
196,
): (),
ScopedSymbolId(
109,
): (),
ScopedSymbolId(
128,
): (),
ScopedSymbolId(
123,
): (),
ScopedSymbolId(
102,
): (),
ScopedSymbolId(
116,
): (),
ScopedSymbolId(
172,
): (),
ScopedSymbolId(
32,
): (),
ScopedSymbolId(
105,
): (),
ScopedSymbolId(
241,
): (),
ScopedSymbolId(
95,
): (),
ScopedSymbolId(
206,
): (),
ScopedSymbolId(
209,
): (),
ScopedSymbolId(
198,
): (),
ScopedSymbolId(
81,
): (),
ScopedSymbolId(
170,
): (),
ScopedSymbolId(
171,
): (),
ScopedSymbolId(
8,
): (),
ScopedSymbolId(
276,
): (),
ScopedSymbolId(
1,
): (),
ScopedSymbolId(
212,
): (),
ScopedSymbolId(
222,
): (),
ScopedSymbolId(
33,
): (),
ScopedSymbolId(
144,
): (),
ScopedSymbolId(
194,
): (),
ScopedSymbolId(
125,
): (),
ScopedSymbolId(
89,
): (),
ScopedSymbolId(
38,
): (),
ScopedSymbolId(
51,
): (),
ScopedSymbolId(
19,
): (),
ScopedSymbolId(
163,
): (),
ScopedSymbolId(
0,
): (),
ScopedSymbolId(
211,
): (),
ScopedSymbolId(
3,
): (),
ScopedSymbolId(
226,
): (),
ScopedSymbolId(
121,
): (),
ScopedSymbolId(
148,
): (),
ScopedSymbolId(
232,
): (),
ScopedSymbolId(
262,
): (),
ScopedSymbolId(
260,
): (),
ScopedSymbolId(
91,
): (),
ScopedSymbolId(
270,
): (),
ScopedSymbolId(
269,
): (),
ScopedSymbolId(
225,
): (),
ScopedSymbolId(
191,
): (),
ScopedSymbolId(
115,
): (),
ScopedSymbolId(
28,
): (),
ScopedSymbolId(
220,
): (),
ScopedSymbolId(
164,
): (),
ScopedSymbolId(
250,
): (),
ScopedSymbolId(
137,
): (),
ScopedSymbolId(
141,
): (),
ScopedSymbolId(
24,
): (),
ScopedSymbolId(
54,
): (),
ScopedSymbolId(
45,
): (),
ScopedSymbolId(
188,
): (),
ScopedSymbolId(
75,
): (),
ScopedSymbolId(
40,
): (),
ScopedSymbolId(
234,
): (),
ScopedSymbolId(
30,
): (),
ScopedSymbolId(
41,
): (),
ScopedSymbolId(
127,
): (),
ScopedSymbolId(
185,
): (),
ScopedSymbolId(
145,
): (),
ScopedSymbolId(
23,
): (),
ScopedSymbolId(
238,
): (),
ScopedSymbolId(
143,
): (),
ScopedSymbolId(
167,
): (),
ScopedSymbolId(
110,
): (),
ScopedSymbolId(
25,
): (),
ScopedSymbolId(
31,
): (),
ScopedSymbolId(
57,
): (),
ScopedSymbolId(
195,
): (),
ScopedSymbolId(
221,
): (),
ScopedSymbolId(
218,
): (),
ScopedSymbolId(
37,
): (),
ScopedSymbolId(
71,
): (),
ScopedSymbolId(
50,
): (),
ScopedSymbolId(
176,
): (),
ScopedSymbolId(
179,
): (),
ScopedSymbolId(
200,
): (),
ScopedSymbolId(
266,
): (),
ScopedSymbolId(
277,
): (),
ScopedSymbolId(
119,
): (),
ScopedSymbolId(
84,
): (),
ScopedSymbolId(
114,
): (),
ScopedSymbolId(
165,
): (),
ScopedSymbolId(
271,
): (),
ScopedSymbolId(
280,
): (),
ScopedSymbolId(
256,
): (),
ScopedSymbolId(
249,
): (),
ScopedSymbolId(
88,
): (),
ScopedSymbolId(
27,
): (),
ScopedSymbolId(
139,
): (),
ScopedSymbolId(
265,
): (),
ScopedSymbolId(
4,
): (),
ScopedSymbolId(
53,
): (),
ScopedSymbolId(
29,
): (),
ScopedSymbolId(
130,
): (),
ScopedSymbolId(
42,
): (),
ScopedSymbolId(
76,
): (),
ScopedSymbolId(
147,
): (),
ScopedSymbolId(
156,
): (),
ScopedSymbolId(
208,
): (),
ScopedSymbolId(
273,
): (),
ScopedSymbolId(
183,
): (),
ScopedSymbolId(
224,
): (),
ScopedSymbolId(
97,
): (),
ScopedSymbolId(
233,
): (),
ScopedSymbolId(
82,
): (),
ScopedSymbolId(
142,
): (),
ScopedSymbolId(
254,
): (),
ScopedSymbolId(
131,
): (),
ScopedSymbolId(
63,
): (),
ScopedSymbolId(
48,
): (),
ScopedSymbolId(
215,
): (),
ScopedSymbolId(
103,
): (),
ScopedSymbolId(
14,
): (),
ScopedSymbolId(
92,
): (),
ScopedSymbolId(
207,
): (),
ScopedSymbolId(
275,
): (),
ScopedSymbolId(
160,
): (),
ScopedSymbolId(
26,
): (),
ScopedSymbolId(
56,
): (),
ScopedSymbolId(
34,
): (),
ScopedSymbolId(
272,
): (),
ScopedSymbolId(
59,
): (),
ScopedSymbolId(
126,
): (),
ScopedSymbolId(
159,
): (),
ScopedSymbolId(
199,
): (),
ScopedSymbolId(
175,
): (),
ScopedSymbolId(
192,
): (),
ScopedSymbolId(
201,
): (),
ScopedSymbolId(
203,
): (),
ScopedSymbolId(
210,
): (),
ScopedSymbolId(
10,
): (),
},
}
```
</details>
I checked that with this PR, the second field is gone from the debug
output (I'd paste it in, but it goes over the GitHub comment length
maximum).
|
||
|
David Peter
|
130339f3d8 |
[red-knot] Fix str(…) calls (#17163)
## Summary The existing signature for `str` calls had various problems, one of which I noticed while looking at some ecosystem projects (`scrapy`, added as a project to mypy_primer in this PR). ## Test Plan - New tests for `str(…)` calls. - Observed reduction of false positives in ecosystem checks |
||
Eric Mark Martin
|
e50fc049ab |
[red-knot] visibility_constraint analysis for match cases (#17077)
## Summary Add visibility constraint analysis for pattern predicate kinds `Singleton`, `Or`, and `Class`. ## Test Plan update conditional/match.md |
||
Dhruv Manilawala
|
177afabe18 |
[red-knot] Callable types are disjoint from literals (#17160)
## Summary A callable type is disjoint from other literal types. For example, `Type::StringLiteral` must be an instance of exactly `str`, not a subclass of `str`, and `str` is not callable. The same applies to other literal types. This should hopefully fix #17144, I couldn't produce any failures after running property tests multiple times. ## Test Plan Add test cases for disjointness check between callable and other literal types. Run property tests multiple times. |
||
|
Alex Waygood
|
28c68934a4 |
[red-knot] Fix inference for pow between two literal integers (#17161)
## Summary Python `**` works differently to Rust `**`! ## Test Plan Added an mdtest for various edge cases, and checked in the Python REPL that we infer the correct type in all the new cases tested. |
||
|
Alex Waygood
|
c2bb5d5250 |
[red-knot] Fix equivalence of differently ordered unions that contain Callable types (#17145)
## Summary Fixes https://github.com/astral-sh/ruff/issues/17058. Equivalent callable types were not understood as equivalent when they appeared nested inside unions and intersections. This PR fixes that by ensuring that `Callable` elements nested inside unions, intersections and tuples have their representations normalized before one union type is compared with another for equivalence, or before one intersection type is compared with another for equivalence. The normalizations applied to a `Callable` type are: - the type of the default value is stripped from all parameters (only whether the parameter _has_ a default value is relevant to whether one `Callable` type is equivalent to another) - The names of the parameters are stripped from positional-only parameters, variadic parameters and keyword-variadic parameters - Unions and intersections that are present (top-level or nested) inside parameter annotations or return annotations are normalized. Adding a `CallableType::normalized()` method also allows us to simplify the implementation of `CallableType::is_equivalent_to()`. ### Should these normalizations be done eagerly as part of a `CallableType` constructor? I considered this. It's something that we could still consider doing in the future; this PR doesn't rule it out as a possibility. However, I didn't pursue it for now, for several reasons: 1. Our current `Display` implementation doesn't handle well the possibility that a parameter might not have a name or an annotated type. Callable types with parameters like this would be displayed as follows: ```py (, ,) -> None: ... ``` That's fixable! It could easily become something like `(Unknown, Unknown) -> None: ...`. But it also illustrates that we probably want to retain the parameter names when displaying the signature of a `lambda` function if you're hovering over a reference to the lambda in an IDE. Currently we don't have a `LambdaType` struct for representing `lambda` functions; if we wanted to eagerly normalize signatures when creating `CallableType`s, we'd probably have to add a `LambdaType` struct so that we would retain the full signature of a `lambda` function, rather than representing it as an eagerly simplified `CallableType`. 2. In order to ensure that it's impossible to create `CallableType`s without the parameters being normalized, I'd either have to create an alternative `SimplifiedSignature` struct (which would duplicate a lot of code), or move `CallableType` to a new module so that the only way of constructing a `CallableType` instance would be via a constructor method that performs the normalizations eagerly on the callable's signature. Again, this isn't a dealbreaker, and I think it's still an option, but it would be a lot of churn, and it didn't seem necessary for now. Doing it this way, at least to start with, felt like it would create a diff that's easier to review and felt like it would create fewer merge conflicts for others. ## Test Plan - Added a regression mdtest for https://github.com/astral-sh/ruff/issues/17058 - Ran `QUICKCHECK_TESTS=1000000 cargo test --release -p red_knot_python_semantic -- --ignored types::property_tests::stable` |
||
|
David Peter
|
af988bf866 |
[red-knot] Detect division-by-zero in unions and intersections (#17157)
## Summary
With this PR, we emit a diagnostic for this case where
previously didn't:
```py
from typing import Literal
def f(m: int, n: Literal[-1, 0, 1]):
# error: [division-by-zero] "Cannot divide object of type `int` by zero"
return m / n
```
## Test Plan
New Markdown test
|
||
|
Andrew Gallant
|
185bcfef1a |
red_knot_python_semantic: remove comment about TypeCheckDiagnostic
I put this in its own commit in case all of the information removed here was controversial. But it *looks* stale to me. At the very least, `TypeCheckDiagnostic` no longer exists, so that would need to be fixed. And it doesn't really make sense to me (at this point) to make `Diagnostic` a Salsa struct, particularly since we are keen on using it in Ruff (at some point). |
||
|
Andrew Gallant
|
c30e80a3f4 |
ruff_db: delete most of the old diagnostic code
We do keep around `OldSecondaryDiagnosticMessage`, since that's part of the Red Knot `InferContext` API. But it's a rather simple type, and we'll be able to delete it entirely once `InferContext` exposes the new `Diagnostic` type directly. Since we aren't consuming `OldSecondaryDiagnosticMessage` any more, we can now accept a slice instead of a vec. (Thanks Clippy.) |
||
|
Andrew Gallant
|
4e169e5f6c |
red_knot: use Diagnostic inside of red knot
This replaces things like `TypeCheckDiagnostic` with the new Diagnostic` type. This is a "surgical" replacement where we retain the existing API of of diagnostic reporting such that _most_ of Red Knot doesn't need to be changed to support this update. But it will enable us to start using the new diagnostic renderer and to delete the old renderer. It also paves the path for exposing the new `Diagnostic` data model to the broader Red Knot codebase. |
||
|
Andrew Gallant
|
a8a18e7171 |
red_knot_python_semantic: remove WithDiagnostic trait
I did this mostly because it wasn't buying us much, and I'm trying to simplify the public API of the types I'd like to refactor in order to make the refactor simpler. If we really want something like this, we can re-add it later. |
||
|
Andrew Gallant
|
a953373892 |
red_knot_python_semantic: remove Deref impl on TypeCheckDiagnostics
I removed this to see how much code was depending internally on the `&[Arc<TypeCheckDiagnostic>]` representation. Thankfully, it was just one place. So I just removed the `Deref` impl in favor of adding an explicit `iter` method. In general, I think using `Deref` for things like this is _somewhat_ of an abuse. The tip-off is if there are `&self` or `&mut self` methods on the type, then it's probably not a good candidate for `Deref`. |
||
|
Micha Reiser
|
2ae39edccf |
[red-knot] Goto type definition (#16901)
## Summary Implement basic *Goto type definition* support for Red Knot's LSP. This PR also builds the foundation for other LSP operations. E.g., Goto definition, hover, etc., should be able to reuse some, if not most, logic introduced in this PR. The basic steps of resolving the type definitions are: 1. Find the closest token for the cursor offset. This is a bit more subtle than I first anticipated because the cursor could be positioned right between the callee and the `(` in `call(test)`, in which case we want to resolve the type for `call`. 2. Find the node with the minimal range that fully encloses the token found in 1. I somewhat suspect that 1 and 2 could be done at the same time but it complicated things because we also need to compute the spine (ancestor chain) for the node and there's no guarantee that the found nodes have the same ancestors 3. Reduce the node found in 2. to a node that is a valid goto target. This may require traversing upwards to e.g. find the closest expression. 4. Resolve the type for the goto target 5. Resolve the location for the type, return it to the LSP ## Design decisions The current implementation navigates to the inferred type. I think this is what we want because it means that it correctly accounts for narrowing (in which case we want to go to the narrowed type because that's the value's type at the given position). However, it does have the downside that Goto type definition doesn't work whenever we infer `T & Unknown` because intersection types aren't supported. I'm not sure what to do about this specific case, other than maybe ignoring `Unkown` in Goto type definition if the type is an intersection? ## Known limitations * Types defined in the vendored typeshed aren't supported because the client can't open files from the red knot binary (we can either implement our own file protocol and handler OR extract the typeshed files and point there). See https://github.com/astral-sh/ruff/issues/17041 * Red Knot only exposes an API to get types for expressions and definitions. However, there are many other nodes with identifiers that can have a type (e.g. go to type of a globals statement, match patterns, ...). We can add support for those in separate PRs (after we figure out how to query the types from the semantic model). See https://github.com/astral-sh/ruff/issues/17113 * We should have a higher-level API for the LSP that doesn't directly call semantic queries. I intentionally decided not to design that API just yet. ## Test plan https://github.com/user-attachments/assets/fa077297-a42d-4ec8-b71f-90c0802b4edb Goto type definition on a union <img width="1215" alt="Screenshot 2025-04-01 at 13 02 55" src="https://github.com/user-attachments/assets/689cabcc-4a86-4a18-b14a-c56f56868085" /> Note: I recorded this using a custom typeshed path so that navigating to builtins works. |
||
|
cake-monotone
|
7e97910704 |
[red-knot] Fix _NotImplementedType check for Python >=3.10 (#17143)
<!-- Thank you for contributing to Ruff! 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? - Does this pull request include references to any relevant issues? --> ## Summary from https://github.com/astral-sh/ruff/pull/17034#discussion_r2024222525 This is a simple PR to fix the invalid behavior of `NotImplemented` on Python >=3.10. ## Test Plan I think it would be better if we could run mdtest across multiple Python versions in GitHub Actions. <!-- How was it tested? --> --------- Co-authored-by: David Peter <sharkdp@users.noreply.github.com> |
||
|
David Peter
|
ae2cf91a36 |
[red-knot] Decorators and properties (#17017)
## Summary Add support for decorators on function as well as support for properties by adding special handling for `@property` and `@<name of property>.setter`/`.getter` decorators. closes https://github.com/astral-sh/ruff/issues/16987 ## Ecosystem results - ✔️ A lot of false positives are fixed by our new understanding of properties - 🔴 A bunch of new false positives (typically `possibly-unbound-attribute` or `invalid-argument-type`) occur because we currently do not perform type narrowing on attributes. And with the new understanding of properties, this becomes even more relevant. In many cases, the narrowing occurs through an assertion, so this is also something that we need to implement to get rid of these false positives. - 🔴 A few new false positives occur because we do not understand generics, and therefore some calls to custom setters fail. - 🔴 Similarly, some false positives occur because we do not understand protocols yet. - ✔️ Seems like a true positive to me. [The setter]( |
||
|
Matthew Mckee
|
eb3e176309 |
[red-knot] Add callable subtyping for callable instances and bound methods (#17105)
## Summary Trying to improve #17005 Partially fixes #16953 ## Test Plan Update is_subtype_of.md --------- Co-authored-by: Carl Meyer <carl@astral.sh> |
||
|
Dhruv Manilawala
|
d38f6fcc55 |
[red-knot] Add property tests for callable types (#17006)
## Summary
Part of #15382, this PR adds property tests for callable types.
Specifically, this PR updates the property tests to generate an
arbitrary signature for a general callable type which includes:
* Arbitrary combination of parameter kinds in the correct order
* Arbitrary number of parameters
* Arbitrary optional types for annotation and return type
* Arbitrary parameter names (no duplicate names), optional for
positional-only parameters
## Test Plan
```
QUICKCHECK_TESTS=100000 cargo test -p red_knot_python_semantic -- --ignored types::property_tests::stable
```
Also, the commands in CI:
|