1321 commits

Author	SHA1	Message	Date
Shunsuke Shibayama	72df7eadff	Merge 0a80f98522 into 5ea30c4c53	2025-12-23 18:02:44 +09:00
Shunsuke Shibayama	0a80f98522	don't use return type context to specialize __init__ type variables ... ref: https://github.com/astral-sh/ruff/pull/22068	2025-12-23 18:02:38 +09:00
Micha Reiser	ccc9132f73	[ty] Use ModuleName::new_static in more places (#22156)	2025-12-23 09:24:49 +01:00
Ibraheem Ahmed	65021fcee9	[ty] Support type inference between protocol instances (#22120)	2025-12-23 09:24:01 +01:00
Micha Reiser	d6a7c9b4ed	[ty] Add respect-type-ignore-comments configuration option (#22137)	2025-12-23 08:36:51 +01:00
Shunsuke Shibayama	ca39add0a9	Merge branch 'main' into pr/17371	2025-12-23 14:55:41 +09:00
Charlie Marsh	4745d15fff	[ty] Respect debug text interpolation in f-strings (#22151) ... ## Summary Per @carljm's comment, we just fall back to `str`. Closes https://github.com/astral-sh/ty/issues/2151.	2025-12-22 20:21:28 -05:00
Shunsuke Shibayama	06db474f20	[ty] stabilize union-type ordering in fixed-point iteration (#22070) ... ## Summary This PR fixes https://github.com/astral-sh/ty/issues/2085. Based on the reported code, the panicking MRE is: ```python class Test: def __init__(self, x: int): self.left = x self.right = x def method(self): self.left, self.right = self.right, self.left if self.right: self.right = self.right ``` The type inference (`implicit_attribute_inner`) for `self.right` proceeds as follows: ``` 0: Divergent(Id(6c07)) 1: Unknown | int | (Divergent(Id(1c00)) & ~AlwaysFalsy) 2: Unknown | int | (Divergent(Id(6c07)) & ~AlwaysFalsy) | (Divergent(Id(1c00)) & ~AlwaysFalsy) 3: Unknown | int | (Divergent(Id(1c00)) & ~AlwaysFalsy) | (Divergent(Id(6c07)) & ~AlwaysFalsy) 4: Unknown | int | (Divergent(Id(6c07)) & ~AlwaysFalsy) | (Divergent(Id(1c00)) & ~AlwaysFalsy) ... ``` The problem is that the order of union types is not stable between cycles. To solve this, when unioning the previous union type with the current union type, we should use the previous type as the base and add only the new elements in this cycle (In the current implementation, this unioning order was reversed). ## Test Plan New corpus test	2025-12-22 16:16:03 -08:00
Charlie Marsh	664686bdbc	[ty] Exclude parameterized tuple types from narrowing when disjoint from comparison values (#22129) ... ## Summary IIUC, tuples with a known structure (`tuple_spec`) use the standard tuple `__eq__` which only returns `True` for other tuples, so they can be safely excluded when disjoint from string literals or other non-tuple types. Closes https://github.com/astral-sh/ty/issues/2140.	2025-12-22 20:44:49 +00:00
Micha Reiser	29d7f22c1f	[ty] Add ty.configuration and ty.configurationFile options (#22053)	2025-12-22 16:13:20 +01:00
Micha Reiser	8fc4349fd3	[ty] Split suppression.rs into multiple smaller modules (#22141)	2025-12-22 16:08:56 +01:00
Matthew Mckee	816b19c4a6	[ty] Rename set_invalid_syntax to set_invalid_type_annotation (#22140)	2025-12-22 14:29:03 +00:00
Matthew Mckee	a46835c224	[ty] Set flag to avoid type[T@f] being inserted when you double-click on the inlay (#22139)	2025-12-22 14:00:45 +00:00
Micha Reiser	884e83591e	[ty] Update salsa (#22072)	2025-12-22 13:22:54 +01:00
Charlie Marsh	fee4e2d72a	[ty] Distribute type[] over unions (#22115) ... ## Summary Closes https://github.com/astral-sh/ty/issues/2121.	2025-12-21 18:45:29 -05:00
Will Duke	b6e84eca16	[ty] Document invalid-syntax-in-forward-annotation and escape-character-in-forward-annotation (#22130) ... Co-authored-by: Alex Waygood <alex.waygood@gmail.com>	2025-12-21 19:35:44 +00:00
Micha Reiser	b4c2825afd	[ty] Move module resolver code into its own crate (#22106)	2025-12-21 11:00:34 +00:00
Ibraheem Ahmed	ad41728204	[ty] Avoid temporarily storing invalid multi-inference attempts (#22103) ... ## Summary I missed this in https://github.com/astral-sh/ruff/pull/22062. This avoids exponential runtime in the following snippet: ```py class X1: ... class X2: ... class X3: ... class X4: ... class X5: ... class X6: ... ... def f( x: list[X1 | None] | list[X2 | None] | list[X3 | None] | list[X4 | None] | list[X5 | None] | list[X6 | None] ... ): ... def g[T](x: T) -> list[T]: return [x] def id[T](x: T) -> T: return x f(id(id(id(id(g(X64())))))) ``` Eventually I want to refactor our multi-inference infrastructure (which is currently very brittle) to handle this implicitly, but this is a temporary performance fix until that happens.	2025-12-20 08:20:53 -08:00
Hugo	3ec63b964c	[ty] Add support for dict(...) calls in typed dict contexts (#22113) ... ## Summary fixes https://github.com/astral-sh/ty/issues/2127 - handle `dict(...)` calls in TypedDict context with bidirectional inference - validate keys/values using the existing TypedDict constructor implem - mdtest: add 1 positive test, 1 negative test for invalid coverage ## Test Plan ```sh cargo clippy --workspace --all-targets --all-features -- -D warnings # Rust linting cargo test # Rust testing uvx pre-commit run --all-files --show-diff-on-failure # Rust and Python formatting, Markdown and Python linting, etc. ``` fully green	2025-12-20 07:59:03 -08:00
Ibraheem Ahmed	2a959ef3f2	[ty] Avoid narrowing on non-generic calls (#22102) ... ## Summary Resolves https://github.com/astral-sh/ty/issues/2026.	2025-12-19 23:18:07 -05:00
Ibraheem Ahmed	674d3902c6	[ty] Only prefer declared types in non-covariant positions (#22068) ... ## Summary The following snippet currently errors because we widen the inferred type, even though `X` is covariant over `T`. If `T` was contravariant or invariant, this would be fine, as it would lead to an assignability error anyways. ```python class X[T]: def __init__(self: X[None]): ... def pop(self) -> T: raise NotImplementedError # error: Argument to bound method `__init__` is incorrect: Expected `X[None]`, found `X[int | None]` x: X[int | None] = X() ``` There are some cases where it is still helpful to prefer covariant declared types, but this error seems hard to fix otherwise, and makes our heuristics more consistent overall.	2025-12-19 17:27:31 -05:00
Alex Waygood	2151c3d351	[ty] Document that several rules are disabled by default because of the number of false positives they produce (#22095)	2025-12-19 18:45:18 +00:00
github-actions[bot]	df1552b9a4	[ty] Sync vendored typeshed stubs (#22091) ... Co-authored-by: typeshedbot <> Co-authored-by: Alex Waygood <alex.waygood@gmail.com>	2025-12-19 18:23:09 +00:00
Charlie Marsh	0f18a08a0a	[ty] Respect intersections in iterations (#21965) ... ## Summary This PR implements the strategy described in https://github.com/astral-sh/ty/issues/1871: we iterate over the positive types, resolve them, then intersect the results.	2025-12-19 12:36:37 -05:00
Shunsuke Shibayama	274bae84c8	refactor	2025-12-20 01:13:11 +09:00
Ibraheem Ahmed	270d755621	[ty] Avoid storing invalid multi-inference attempts (#22062) ... ## Summary This should make revealed types a little nicer, as well as avoid confusing the constraint solver in some cases (which were showing up in https://github.com/astral-sh/ruff/pull/21930).	2025-12-19 15:38:47 +00:00
Alex Waygood	28cdbb18c5	[ty] Minor followups to #22048 (#22082)	2025-12-19 13:58:59 +00:00
David Peter	0bac023cd2	[ty] Lockfiles for mdtests with external dependencies (#22077) ... ## Summary Add lockfiles for all mdtests which make use of external dependencies. When running tests normally, we use this lockfile when creating the temporary venv using `uv sync --locked`. A new `MDTEST_UPGRADE_LOCKFILES` environment variable is used to switch to a mode in which those lockfiles can be updated or regenerated. When using the Python mdtest runner, this environment variable is automatically set (because we use this command while developing, not to simulate exactly what happens in CI). A command-line flag is provided to opt out of this. ## Test Plan ### Using the mdtest runner #### Adding a new test (no lockfile yet) * Removed `attrs.lock` to simulate this * Ran `uv run crates/ty_python_semantic/mdtest.py -e external/`. The lockfile is generated and the test succeeds. #### Upgrading/downgrading a dependency * Changed pydantic requirement from `pydantic==2.12.2` to `pydantic==2.12.5` (also tested with `2.12.0`) * Ran `uv run crates/ty_python_semantic/mdtest.py -e external/`. The lockfile is updated and the test succeeds. ### Using cargo #### Adding a new test (no lockfile yet) * Removed `attrs.lock` to simulate this * Ran `MDTEST_EXTERNAL=1 cargo test -p ty_python_semantic --test mdtest mdtest__external` "naively", which outputs: > Failed to setup in-memory virtual environment with dependencies: Lockfile not found at '/home/shark/ruff/crates/ty_python_semantic/resources/mdtest/external/attrs.lock'. Run with `MDTEST_UPGRADE_LOCKFILES=1` to generate it. * Ran `MDTEST_UPGRADE_LOCKFILES=1 MDTEST_EXTERNAL=1 cargo test -p ty_python_semantic --test mdtest mdtest__external`. The lockfile is updated and the test succeeds. #### Upgrading/downgrading a dependency * Changed pydantic requirement from `pydantic==2.12.2` to `pydantic==2.12.5` (also tested with `2.12.0`) * Ran `MDTEST_EXTERNAL=1 cargo test -p ty_python_semantic --test mdtest mdtest__external` "naively", which outputs a similar error message as above. * Ran the command suggested in the error message (`MDTEST_EXTERNAL=1 MDTEST_UPGRADE_LOCKFILES=1 cargo test -p ty_python_semantic --test mdtest mdtest__external`). The lockfile is updated and the test succeeds.	2025-12-19 14:29:52 +01:00
Micha Reiser	e177cc2a5a	[ty] Improve union builder performance (#22048)	2025-12-19 08:29:16 +01:00
Shunsuke Shibayama	cc06d3e0d6	simply filter InnerIntersectionBuilders using equality check	2025-12-19 12:13:11 +09:00
Charlie Marsh	76854fdb15	[ty] Unwrap enum.nonmember values (#22025) ... ## Summary This PR unwraps the `enum.nonmember` type to match runtime behavior. Closes https://github.com/astral-sh/ty/issues/1974.	2025-12-18 19:59:49 -05:00
Shunsuke Shibayama	bbad56bfd3	Revert "add IntersectionBuilder::intersection_hashes" ... This reverts commit af8b75b3fd.	2025-12-19 09:43:43 +09:00
Shunsuke Shibayama	d77b45c995	Merge branch 'main' into infer-return-type	2025-12-19 09:43:18 +09:00
Douglas Creager	5a2d3cda3d	[ty] Remove some nondeterminism in constraint set tests (#22064) ... We're seeing a lot of nondeterminism in the ecosystem tests at the moment, which started (or at least got worse) once `Callable` inference landed. This PR attempts to remove this nondeterminism. We recently (https://github.com/astral-sh/ruff/pull/21983) added a `source_order` field to BDD nodes, which tracks when their constraint was added to the BDD. Since we build up constraints based on the order that they appear in the underlying source, that gives us a stable ordering even though we use an arbitrary salsa-derived ordering for the BDD variables. The issue (at least for some of the flakiness) is that we add "derived" constraints when walking a BDD tree, and those derived constraints inherit or borrow the `source_order` of the "real" constraint that implied them. That means we can get multiple constraints in our specialization that all have the same `source_order`. If we're not careful, those "tied" constraints can be ordered arbitrarily. The fix requires ~three~ ~four~ several steps: - When starting to construct a sequent map (the data structure that stores the derived constraints), we first sort all of the "real" constraints by their `source_order`. That ensures that we insert things into the sequent map in a stable order. - During sequent map construction, derived facts are discovered by a deterministic process applied to constraints in a (now) stable order. So derived facts are now also inserted in a stable order. - We update the fields of `SequentMap` to use `FxOrderSet` instead of `FxHashSet`, so that we retain that stable insertion order. - When walking BDD paths when constructing a specialization, we were already sorting the constraints by their `source_order`. However, we were not considering that we might get derived constraints, and therefore constraints with "ties". Because of that, we need to make sure to use a _stable_ sort, that retains the insertion order for those ties. All together, this...should...fix the nondeterminism. (Unfortunately, I haven't been able to effectively test this, since I haven't been able to coerce local tests to flop into the other order that we sometimes see in CI.)	2025-12-18 19:00:20 -05:00
Jack O'Connor	fa57253980	[ty] Implement disjointness for TypedDicts (#22044) ... This is a preliminary step towards tagged union narrowing for `TypedDict`: https://github.com/astral-sh/ty/issues/1479	2025-12-18 13:20:22 -08:00
Aria Desires	2e44a861cb	[ty] Disable possibly-missing-imports by default (#22041) ... @carljm put forth a reasonably compelling argument that just disabling this lint might be advisable. If we agree, here's the implementation. * Fixes https://github.com/astral-sh/ty/issues/309 --------- Co-authored-by: Carl Meyer <carl@astral.sh>	2025-12-18 20:06:34 +00:00
Micha Reiser	42b972753a	[ty] Use datatest instead of dirtest (#21937)	2025-12-18 18:05:02 +00:00
Shunsuke Shibayama	af8b75b3fd	add IntersectionBuilder::intersection_hashes	2025-12-19 02:15:24 +09:00
Andrew Gallant	bab3924833	[ty] Refactor completion generation ... This refactor is intended to give more structure to how we generate completions. There's now a `Context` for "how do we figure out what kind of completions to offer" and also a `CollectionContext` for "how do we figure out which completions are appropriate or not." We double down on `Completions` as a collector and a single point of truth for this. It now handles adding information to `Completion` (based on the context) and also skipping completions that are inappropriate (instead of filtering them after-the-fact). We also bundle a bunch of state into a new `ContextCursor` type, and then define a bunch of predicates/accessors on that type that were previously free functions with loads of parameters. Finally, we introduce more structure to ranking. Instead of an anonymous tuple, we define an explicit type with some helper types to hopefully make the influence on ranking from each constituent piece a bit clearer. This does seem to fix one bug around detecting the target for non-import completions, but otherwise should not have any changes in behavior. This is meant to be a precursor to improving completion ranking.	2025-12-18 11:00:09 -05:00
Aria Desires	56539db520	[ty] Fix some configuration panics in the LSP (#22040) ... ## Summary This is a revival of https://github.com/astral-sh/ruff/pull/21047 now that we have a reproducer again. * Fixes https://github.com/astral-sh/ty/issues/2031 * Fixes https://github.com/astral-sh/ty/issues/859 ## Test Plan e2e test from @zanieb --------- Co-authored-by: Zanie Blue <contact@zanie.dev>	2025-12-18 09:47:02 -05:00
Aria Desires	8d32ad1cab	[ty] Add support for attribute docstrings (#22036) ... ## Summary I should have factored this better but this includes a drive-by move of find_node to ruff_python_ast so ty_python_semantic can use it too. * Fixes https://github.com/astral-sh/ty/issues/2017 ## Test Plan Snapshots galore	2025-12-18 12:18:20 +00:00
Shunsuke Shibayama	1d1afaa517	fix Type::cycle_normalized	2025-12-18 20:14:45 +09:00
Aria Desires	7bb5dd87ff	[ty] Fix goto-declaration on the RHS of from module import submodule (#22042)	2025-12-18 08:28:05 +01:00
Charlie Marsh	06305f3c02	Make analyze_single_pattern_predicate a #[salsa::tracked] function (#22045) ... ## Summary We had a report of a blowup with the following snippet: ```python from enum import StrEnum class BigEnum(StrEnum): VALUE_01 = "VALUE_01" VALUE_02 = "VALUE_02" VALUE_03 = "VALUE_03" VALUE_04 = "VALUE_04" VALUE_05 = "VALUE_05" VALUE_06 = "VALUE_06" VALUE_07 = "VALUE_07" VALUE_08 = "VALUE_08" VALUE_09 = "VALUE_09" VALUE_10 = "VALUE_10" VALUE_11 = "VALUE_11" VALUE_12 = "VALUE_12" VALUE_13 = "VALUE_13" VALUE_14 = "VALUE_14" VALUE_15 = "VALUE_15" VALUE_16 = "VALUE_16" VALUE_17 = "VALUE_17" VALUE_18 = "VALUE_18" VALUE_19 = "VALUE_19" VALUE_20 = "VALUE_20" VALUE_21 = "VALUE_21" VALUE_22 = "VALUE_22" VALUE_23 = "VALUE_23" VALUE_24 = "VALUE_24" VALUE_25 = "VALUE_25" VALUE_26 = "VALUE_26" VALUE_27 = "VALUE_27" VALUE_28 = "VALUE_28" VALUE_29 = "VALUE_29" VALUE_30 = "VALUE_30" VALUE_31 = "VALUE_31" VALUE_32 = "VALUE_32" VALUE_33 = "VALUE_33" VALUE_34 = "VALUE_34" VALUE_35 = "VALUE_35" VALUE_36 = "VALUE_36" VALUE_37 = "VALUE_37" VALUE_38 = "VALUE_38" VALUE_39 = "VALUE_39" VALUE_40 = "VALUE_40" VALUE_41 = "VALUE_41" VALUE_42 = "VALUE_42" VALUE_43 = "VALUE_43" VALUE_44 = "VALUE_44" VALUE_45 = "VALUE_45" VALUE_46 = "VALUE_46" VALUE_47 = "VALUE_47" VALUE_48 = "VALUE_48" VALUE_49 = "VALUE_49" VALUE_50 = "VALUE_50" VALUE_51 = "VALUE_51" VALUE_52 = "VALUE_52" VALUE_53 = "VALUE_53" VALUE_54 = "VALUE_54" VALUE_55 = "VALUE_55" VALUE_56 = "VALUE_56" VALUE_57 = "VALUE_57" VALUE_58 = "VALUE_58" VALUE_59 = "VALUE_59" VALUE_60 = "VALUE_60" VALUE_61 = "VALUE_61" VALUE_62 = "VALUE_62" VALUE_63 = "VALUE_63" VALUE_64 = "VALUE_64" VALUE_65 = "VALUE_65" VALUE_66 = "VALUE_66" VALUE_67 = "VALUE_67" VALUE_68 = "VALUE_68" VALUE_69 = "VALUE_69" VALUE_70 = "VALUE_70" VALUE_71 = "VALUE_71" VALUE_72 = "VALUE_72" VALUE_73 = "VALUE_73" VALUE_74 = "VALUE_74" VALUE_75 = "VALUE_75" VALUE_76 = "VALUE_76" VALUE_77 = "VALUE_77" VALUE_78 = "VALUE_78" VALUE_79 = "VALUE_79" VALUE_80 = "VALUE_80" VALUE_81 = "VALUE_81" VALUE_82 = "VALUE_82" VALUE_83 = "VALUE_83" VALUE_84 = "VALUE_84" VALUE_85 = "VALUE_85" VALUE_86 = "VALUE_86" VALUE_87 = "VALUE_87" VALUE_88 = "VALUE_88" VALUE_89 = "VALUE_89" VALUE_90 = "VALUE_90" VALUE_91 = "VALUE_91" VALUE_92 = "VALUE_92" VALUE_93 = "VALUE_93" VALUE_94 = "VALUE_94" VALUE_95 = "VALUE_95" VALUE_96 = "VALUE_96" VALUE_97 = "VALUE_97" VALUE_98 = "VALUE_98" VALUE_99 = "VALUE_99" def get_info(self) -> tuple[str, int]: match self: case BigEnum.VALUE_01: return self.value, 1 case BigEnum.VALUE_02: return self.value, 2 case BigEnum.VALUE_03: return self.value, 3 case BigEnum.VALUE_04: return self.value, 4 case BigEnum.VALUE_05: return self.value, 5 case BigEnum.VALUE_06: return self.value, 6 case BigEnum.VALUE_07: return self.value, 7 case BigEnum.VALUE_08: return self.value, 8 case BigEnum.VALUE_09: return self.value, 9 case BigEnum.VALUE_10: return self.value, 10 case BigEnum.VALUE_11: return self.value, 11 case BigEnum.VALUE_12: return self.value, 12 case BigEnum.VALUE_13: return self.value, 13 case BigEnum.VALUE_14: return self.value, 14 case BigEnum.VALUE_15: return self.value, 15 case BigEnum.VALUE_16: return self.value, 16 case BigEnum.VALUE_17: return self.value, 17 case BigEnum.VALUE_18: return self.value, 18 case BigEnum.VALUE_19: return self.value, 19 case BigEnum.VALUE_20: return self.value, 20 case BigEnum.VALUE_21: return self.value, 21 case BigEnum.VALUE_22: return self.value, 22 case BigEnum.VALUE_23: return self.value, 23 case BigEnum.VALUE_24: return self.value, 24 case BigEnum.VALUE_25: return self.value, 25 case BigEnum.VALUE_26: return self.value, 26 case BigEnum.VALUE_27: return self.value, 27 case BigEnum.VALUE_28: return self.value, 28 case BigEnum.VALUE_29: return self.value, 29 case BigEnum.VALUE_30: return self.value, 30 case BigEnum.VALUE_31: return self.value, 31 case BigEnum.VALUE_32: return self.value, 32 case BigEnum.VALUE_33: return self.value, 33 case BigEnum.VALUE_34: return self.value, 34 case BigEnum.VALUE_35: return self.value, 35 case BigEnum.VALUE_36: return self.value, 36 case BigEnum.VALUE_37: return self.value, 37 case BigEnum.VALUE_38: return self.value, 38 case BigEnum.VALUE_39: return self.value, 39 case BigEnum.VALUE_40: return self.value, 40 case BigEnum.VALUE_41: return self.value, 41 case BigEnum.VALUE_42: return self.value, 42 case BigEnum.VALUE_43: return self.value, 43 case BigEnum.VALUE_44: return self.value, 44 case BigEnum.VALUE_45: return self.value, 45 case BigEnum.VALUE_46: return self.value, 46 case BigEnum.VALUE_47: return self.value, 47 case BigEnum.VALUE_48: return self.value, 48 case BigEnum.VALUE_49: return self.value, 49 case BigEnum.VALUE_50: return self.value, 50 case BigEnum.VALUE_51: return self.value, 51 case BigEnum.VALUE_52: return self.value, 52 case BigEnum.VALUE_53: return self.value, 53 case BigEnum.VALUE_54: return self.value, 54 case BigEnum.VALUE_55: return self.value, 55 case BigEnum.VALUE_56: return self.value, 56 case BigEnum.VALUE_57: return self.value, 57 case BigEnum.VALUE_58: return self.value, 58 case BigEnum.VALUE_59: return self.value, 59 case BigEnum.VALUE_60: return self.value, 60 case BigEnum.VALUE_61: return self.value, 61 case BigEnum.VALUE_62: return self.value, 62 case BigEnum.VALUE_63: return self.value, 63 case BigEnum.VALUE_64: return self.value, 64 case BigEnum.VALUE_65: return self.value, 65 case BigEnum.VALUE_66: return self.value, 66 case BigEnum.VALUE_67: return self.value, 67 case BigEnum.VALUE_68: return self.value, 68 case BigEnum.VALUE_69: return self.value, 69 case BigEnum.VALUE_70: return self.value, 70 case BigEnum.VALUE_71: return self.value, 71 case BigEnum.VALUE_72: return self.value, 72 case BigEnum.VALUE_73: return self.value, 73 case BigEnum.VALUE_74: return self.value, 74 case BigEnum.VALUE_75: return self.value, 75 case BigEnum.VALUE_76: return self.value, 76 case BigEnum.VALUE_77: return self.value, 77 case BigEnum.VALUE_78: return self.value, 78 case BigEnum.VALUE_79: return self.value, 79 case BigEnum.VALUE_80: return self.value, 80 case BigEnum.VALUE_81: return self.value, 81 case BigEnum.VALUE_82: return self.value, 82 case BigEnum.VALUE_83: return self.value, 83 case BigEnum.VALUE_84: return self.value, 84 case BigEnum.VALUE_85: return self.value, 85 case BigEnum.VALUE_86: return self.value, 86 case BigEnum.VALUE_87: return self.value, 87 case BigEnum.VALUE_88: return self.value, 88 case BigEnum.VALUE_89: return self.value, 89 case BigEnum.VALUE_90: return self.value, 90 case BigEnum.VALUE_91: return self.value, 91 case BigEnum.VALUE_92: return self.value, 92 case BigEnum.VALUE_93: return self.value, 93 case BigEnum.VALUE_94: return self.value, 94 case BigEnum.VALUE_95: return self.value, 95 case BigEnum.VALUE_96: return self.value, 96 case BigEnum.VALUE_97: return self.value, 97 case BigEnum.VALUE_98: return self.value, 98 case BigEnum.VALUE_99: return self.value, 99 ``` On my machine, memoizing the computation brings us from 70s to 0.6s.	2025-12-17 22:01:50 -05:00
Charlie Marsh	5bb9ee2a9d	[ty] Respect deferred values in keyword arguments et al for .pyi files (#22029) ... ## Summary Closes https://github.com/astral-sh/ty/issues/2019.	2025-12-17 14:02:10 -08:00
Aria Desires	638f230910	[ty] improve rendering of signatures in hovers (#22007) ... This is the return of #21438 because we never found anything better and I think it would be good to have this for the beta.	2025-12-17 20:09:31 +00:00
Douglas Creager	b36ff75a24	[ty] Don't add identical lower/upper bounds multiple times when inferring specializations (#22030) ... When inferring a specialization of a `Callable` type, we use the new constraint set implementation. In the example in https://github.com/astral-sh/ty/issues/1968, we end up with a constraint set that includes all of the following clauses: ``` U_co ≤ M1 | M2 | M3 | M4 | M5 | M6 | M7 M1 ≤ U_co ≤ M1 | M2 | M3 | M4 | M5 | M6 | M7 M2 ≤ U_co ≤ M1 | M2 | M3 | M4 | M5 | M6 | M7 M3 ≤ U_co ≤ M1 | M2 | M3 | M4 | M5 | M6 | M7 M4 ≤ U_co ≤ M1 | M2 | M3 | M4 | M5 | M6 | M7 M5 ≤ U_co ≤ M1 | M2 | M3 | M4 | M5 | M6 | M7 M6 ≤ U_co ≤ M1 | M2 | M3 | M4 | M5 | M6 | M7 M7 ≤ U_co ≤ M1 | M2 | M3 | M4 | M5 | M6 | M7 ``` In general, we take the upper bounds of those constraints to get the specialization. However, the upper bounds of those constraints are not all guaranteed to be the same, and so first we need to intersect them all together. In this case, the upper bounds are all identical, so their intersection is trivial: ``` U_co = M1 | M2 | M3 | M4 | M5 | M6 | M7 ``` But we were still doing the work of calculating that trivial intersection 7 times. And each time we have to do 7^2 comparisons of the `M*` classes, ending up with O(n^3) overall work. This pattern is common enough that we can put in a quick heuristic to prune identical copies of the same type before performing the intersection. Fixes https://github.com/astral-sh/ty/issues/1968	2025-12-17 13:35:52 -05:00
Charlie Marsh	30c3f9aafe	[ty] Apply narrowing to len calls based on argument size (#22026) ... ## Summary Closes https://github.com/astral-sh/ty/issues/1983.	2025-12-17 13:15:58 -05:00
Shunsuke Shibayama	edb970c9f6	Merge branch 'main' into infer-return-type	2025-12-18 00:55:23 +09:00
Shunsuke Shibayama	d02c834fbc	refactor	2025-12-18 00:53:59 +09:00