mirror of
https://github.com/astral-sh/ruff.git
synced 2025-09-30 22:01:18 +00:00
[ty] Add functions for revealing assignability/subtyping constraints (#20217)
This PR adds two new `ty_extensions` functions, `reveal_when_assignable_to` and `reveal_when_subtype_of`. These are closely related to the existing `is_assignable_to` and `is_subtype_of`, but instead of returning when the property (always) holds, it produces a diagnostic that describes _when_ the property holds. (This will let us construct mdtests that print out constraints that are not always true or always false — though we don't currently have any instances of those.) I did not replace _every_ occurrence of the `is_property` variants in the mdtest suite, instead focusing on the generics-related tests where it will be important to see the full detail of the constraint sets. As part of this, I also updated the mdtest harness to accept the shorter `# revealed:` assertion format for more than just `reveal_type`, and updated the existing uses of `reveal_protocol_interface` to take advantage of this.
This commit is contained in:
Douglas Creager
GitHub
parent
200349c6e8
commit
77b2cee223
7 changed files with 309 additions and 199 deletions
|
|
@ -129,7 +129,7 @@ specialization. Thus, the typevar is a subtype of itself and of `object`, but no
|
|||
(including other typevars).
|
||||
|
||||
```py
|
||||
from ty_extensions import is_assignable_to, is_subtype_of, static_assert
|
||||
from ty_extensions import reveal_when_assignable_to, reveal_when_subtype_of
|
||||
|
||||
class Super: ...
|
||||
class Base(Super): ...
|
||||
|
|
@ -137,23 +137,23 @@ class Sub(Base): ...
|
|||
class Unrelated: ...
|
||||
|
||||
def unbounded_unconstrained[T, U](t: T, u: U) -> None:
|
||||
static_assert(is_assignable_to(T, T))
|
||||
static_assert(is_assignable_to(T, object))
|
||||
static_assert(not is_assignable_to(T, Super))
|
||||
static_assert(is_assignable_to(U, U))
|
||||
static_assert(is_assignable_to(U, object))
|
||||
static_assert(not is_assignable_to(U, Super))
|
||||
static_assert(not is_assignable_to(T, U))
|
||||
static_assert(not is_assignable_to(U, T))
|
||||
reveal_when_assignable_to(T, T) # revealed: always
|
||||
reveal_when_assignable_to(T, object) # revealed: always
|
||||
reveal_when_assignable_to(T, Super) # revealed: never
|
||||
reveal_when_assignable_to(U, U) # revealed: always
|
||||
reveal_when_assignable_to(U, object) # revealed: always
|
||||
reveal_when_assignable_to(U, Super) # revealed: never
|
||||
reveal_when_assignable_to(T, U) # revealed: never
|
||||
reveal_when_assignable_to(U, T) # revealed: never
|
||||
|
||||
static_assert(is_subtype_of(T, T))
|
||||
static_assert(is_subtype_of(T, object))
|
||||
static_assert(not is_subtype_of(T, Super))
|
||||
static_assert(is_subtype_of(U, U))
|
||||
static_assert(is_subtype_of(U, object))
|
||||
static_assert(not is_subtype_of(U, Super))
|
||||
static_assert(not is_subtype_of(T, U))
|
||||
static_assert(not is_subtype_of(U, T))
|
||||
reveal_when_subtype_of(T, T) # revealed: always
|
||||
reveal_when_subtype_of(T, object) # revealed: always
|
||||
reveal_when_subtype_of(T, Super) # revealed: never
|
||||
reveal_when_subtype_of(U, U) # revealed: always
|
||||
reveal_when_subtype_of(U, object) # revealed: always
|
||||
reveal_when_subtype_of(U, Super) # revealed: never
|
||||
reveal_when_subtype_of(T, U) # revealed: never
|
||||
reveal_when_subtype_of(U, T) # revealed: never
|
||||
```
|
||||
|
||||
A bounded typevar is assignable to its bound, and a bounded, fully static typevar is a subtype of
|
||||
|
|
@ -167,40 +167,40 @@ from typing import Any
|
|||
from typing_extensions import final
|
||||
|
||||
def bounded[T: Super](t: T) -> None:
|
||||
static_assert(is_assignable_to(T, Super))
|
||||
static_assert(not is_assignable_to(T, Sub))
|
||||
static_assert(not is_assignable_to(Super, T))
|
||||
static_assert(not is_assignable_to(Sub, T))
|
||||
reveal_when_assignable_to(T, Super) # revealed: always
|
||||
reveal_when_assignable_to(T, Sub) # revealed: never
|
||||
reveal_when_assignable_to(Super, T) # revealed: never
|
||||
reveal_when_assignable_to(Sub, T) # revealed: never
|
||||
|
||||
static_assert(is_subtype_of(T, Super))
|
||||
static_assert(not is_subtype_of(T, Sub))
|
||||
static_assert(not is_subtype_of(Super, T))
|
||||
static_assert(not is_subtype_of(Sub, T))
|
||||
reveal_when_subtype_of(T, Super) # revealed: always
|
||||
reveal_when_subtype_of(T, Sub) # revealed: never
|
||||
reveal_when_subtype_of(Super, T) # revealed: never
|
||||
reveal_when_subtype_of(Sub, T) # revealed: never
|
||||
|
||||
def bounded_by_gradual[T: Any](t: T) -> None:
|
||||
static_assert(is_assignable_to(T, Any))
|
||||
static_assert(is_assignable_to(Any, T))
|
||||
static_assert(is_assignable_to(T, Super))
|
||||
static_assert(not is_assignable_to(Super, T))
|
||||
static_assert(is_assignable_to(T, Sub))
|
||||
static_assert(not is_assignable_to(Sub, T))
|
||||
reveal_when_assignable_to(T, Any) # revealed: always
|
||||
reveal_when_assignable_to(Any, T) # revealed: always
|
||||
reveal_when_assignable_to(T, Super) # revealed: always
|
||||
reveal_when_assignable_to(Super, T) # revealed: never
|
||||
reveal_when_assignable_to(T, Sub) # revealed: always
|
||||
reveal_when_assignable_to(Sub, T) # revealed: never
|
||||
|
||||
static_assert(not is_subtype_of(T, Any))
|
||||
static_assert(not is_subtype_of(Any, T))
|
||||
static_assert(not is_subtype_of(T, Super))
|
||||
static_assert(not is_subtype_of(Super, T))
|
||||
static_assert(not is_subtype_of(T, Sub))
|
||||
static_assert(not is_subtype_of(Sub, T))
|
||||
reveal_when_subtype_of(T, Any) # revealed: never
|
||||
reveal_when_subtype_of(Any, T) # revealed: never
|
||||
reveal_when_subtype_of(T, Super) # revealed: never
|
||||
reveal_when_subtype_of(Super, T) # revealed: never
|
||||
reveal_when_subtype_of(T, Sub) # revealed: never
|
||||
reveal_when_subtype_of(Sub, T) # revealed: never
|
||||
|
||||
@final
|
||||
class FinalClass: ...
|
||||
|
||||
def bounded_final[T: FinalClass](t: T) -> None:
|
||||
static_assert(is_assignable_to(T, FinalClass))
|
||||
static_assert(not is_assignable_to(FinalClass, T))
|
||||
reveal_when_assignable_to(T, FinalClass) # revealed: always
|
||||
reveal_when_assignable_to(FinalClass, T) # revealed: never
|
||||
|
||||
static_assert(is_subtype_of(T, FinalClass))
|
||||
static_assert(not is_subtype_of(FinalClass, T))
|
||||
reveal_when_subtype_of(T, FinalClass) # revealed: always
|
||||
reveal_when_subtype_of(FinalClass, T) # revealed: never
|
||||
```
|
||||
|
||||
Two distinct fully static typevars are not subtypes of each other, even if they have the same
|
||||
|
|
@ -210,18 +210,18 @@ typevars to `Never` in addition to that final class.
|
|||
|
||||
```py
|
||||
def two_bounded[T: Super, U: Super](t: T, u: U) -> None:
|
||||
static_assert(not is_assignable_to(T, U))
|
||||
static_assert(not is_assignable_to(U, T))
|
||||
reveal_when_assignable_to(T, U) # revealed: never
|
||||
reveal_when_assignable_to(U, T) # revealed: never
|
||||
|
||||
static_assert(not is_subtype_of(T, U))
|
||||
static_assert(not is_subtype_of(U, T))
|
||||
reveal_when_subtype_of(T, U) # revealed: never
|
||||
reveal_when_subtype_of(U, T) # revealed: never
|
||||
|
||||
def two_final_bounded[T: FinalClass, U: FinalClass](t: T, u: U) -> None:
|
||||
static_assert(not is_assignable_to(T, U))
|
||||
static_assert(not is_assignable_to(U, T))
|
||||
reveal_when_assignable_to(T, U) # revealed: never
|
||||
reveal_when_assignable_to(U, T) # revealed: never
|
||||
|
||||
static_assert(not is_subtype_of(T, U))
|
||||
static_assert(not is_subtype_of(U, T))
|
||||
reveal_when_subtype_of(T, U) # revealed: never
|
||||
reveal_when_subtype_of(U, T) # revealed: never
|
||||
```
|
||||
|
||||
A constrained fully static typevar is assignable to the union of its constraints, but not to any of
|
||||
|
|
@ -232,64 +232,64 @@ intersection of all of its constraints is a subtype of the typevar.
|
|||
from ty_extensions import Intersection
|
||||
|
||||
def constrained[T: (Base, Unrelated)](t: T) -> None:
|
||||
static_assert(not is_assignable_to(T, Super))
|
||||
static_assert(not is_assignable_to(T, Base))
|
||||
static_assert(not is_assignable_to(T, Sub))
|
||||
static_assert(not is_assignable_to(T, Unrelated))
|
||||
static_assert(is_assignable_to(T, Super | Unrelated))
|
||||
static_assert(is_assignable_to(T, Base | Unrelated))
|
||||
static_assert(not is_assignable_to(T, Sub | Unrelated))
|
||||
static_assert(not is_assignable_to(Super, T))
|
||||
static_assert(not is_assignable_to(Unrelated, T))
|
||||
static_assert(not is_assignable_to(Super | Unrelated, T))
|
||||
static_assert(is_assignable_to(Intersection[Base, Unrelated], T))
|
||||
reveal_when_assignable_to(T, Super) # revealed: never
|
||||
reveal_when_assignable_to(T, Base) # revealed: never
|
||||
reveal_when_assignable_to(T, Sub) # revealed: never
|
||||
reveal_when_assignable_to(T, Unrelated) # revealed: never
|
||||
reveal_when_assignable_to(T, Super | Unrelated) # revealed: always
|
||||
reveal_when_assignable_to(T, Base | Unrelated) # revealed: always
|
||||
reveal_when_assignable_to(T, Sub | Unrelated) # revealed: never
|
||||
reveal_when_assignable_to(Super, T) # revealed: never
|
||||
reveal_when_assignable_to(Unrelated, T) # revealed: never
|
||||
reveal_when_assignable_to(Super | Unrelated, T) # revealed: never
|
||||
reveal_when_assignable_to(Intersection[Base, Unrelated], T) # revealed: always
|
||||
|
||||
static_assert(not is_subtype_of(T, Super))
|
||||
static_assert(not is_subtype_of(T, Base))
|
||||
static_assert(not is_subtype_of(T, Sub))
|
||||
static_assert(not is_subtype_of(T, Unrelated))
|
||||
static_assert(is_subtype_of(T, Super | Unrelated))
|
||||
static_assert(is_subtype_of(T, Base | Unrelated))
|
||||
static_assert(not is_subtype_of(T, Sub | Unrelated))
|
||||
static_assert(not is_subtype_of(Super, T))
|
||||
static_assert(not is_subtype_of(Unrelated, T))
|
||||
static_assert(not is_subtype_of(Super | Unrelated, T))
|
||||
static_assert(is_subtype_of(Intersection[Base, Unrelated], T))
|
||||
reveal_when_subtype_of(T, Super) # revealed: never
|
||||
reveal_when_subtype_of(T, Base) # revealed: never
|
||||
reveal_when_subtype_of(T, Sub) # revealed: never
|
||||
reveal_when_subtype_of(T, Unrelated) # revealed: never
|
||||
reveal_when_subtype_of(T, Super | Unrelated) # revealed: always
|
||||
reveal_when_subtype_of(T, Base | Unrelated) # revealed: always
|
||||
reveal_when_subtype_of(T, Sub | Unrelated) # revealed: never
|
||||
reveal_when_subtype_of(Super, T) # revealed: never
|
||||
reveal_when_subtype_of(Unrelated, T) # revealed: never
|
||||
reveal_when_subtype_of(Super | Unrelated, T) # revealed: never
|
||||
reveal_when_subtype_of(Intersection[Base, Unrelated], T) # revealed: always
|
||||
|
||||
def constrained_by_gradual[T: (Base, Any)](t: T) -> None:
|
||||
static_assert(is_assignable_to(T, Super))
|
||||
static_assert(is_assignable_to(T, Base))
|
||||
static_assert(not is_assignable_to(T, Sub))
|
||||
static_assert(not is_assignable_to(T, Unrelated))
|
||||
static_assert(is_assignable_to(T, Any))
|
||||
static_assert(is_assignable_to(T, Super | Any))
|
||||
static_assert(is_assignable_to(T, Super | Unrelated))
|
||||
static_assert(not is_assignable_to(Super, T))
|
||||
static_assert(is_assignable_to(Base, T))
|
||||
static_assert(not is_assignable_to(Unrelated, T))
|
||||
static_assert(is_assignable_to(Any, T))
|
||||
static_assert(not is_assignable_to(Super | Any, T))
|
||||
static_assert(is_assignable_to(Base | Any, T))
|
||||
static_assert(not is_assignable_to(Super | Unrelated, T))
|
||||
static_assert(is_assignable_to(Intersection[Base, Unrelated], T))
|
||||
static_assert(is_assignable_to(Intersection[Base, Any], T))
|
||||
reveal_when_assignable_to(T, Super) # revealed: always
|
||||
reveal_when_assignable_to(T, Base) # revealed: always
|
||||
reveal_when_assignable_to(T, Sub) # revealed: never
|
||||
reveal_when_assignable_to(T, Unrelated) # revealed: never
|
||||
reveal_when_assignable_to(T, Any) # revealed: always
|
||||
reveal_when_assignable_to(T, Super | Any) # revealed: always
|
||||
reveal_when_assignable_to(T, Super | Unrelated) # revealed: always
|
||||
reveal_when_assignable_to(Super, T) # revealed: never
|
||||
reveal_when_assignable_to(Base, T) # revealed: always
|
||||
reveal_when_assignable_to(Unrelated, T) # revealed: never
|
||||
reveal_when_assignable_to(Any, T) # revealed: always
|
||||
reveal_when_assignable_to(Super | Any, T) # revealed: never
|
||||
reveal_when_assignable_to(Base | Any, T) # revealed: always
|
||||
reveal_when_assignable_to(Super | Unrelated, T) # revealed: never
|
||||
reveal_when_assignable_to(Intersection[Base, Unrelated], T) # revealed: always
|
||||
reveal_when_assignable_to(Intersection[Base, Any], T) # revealed: always
|
||||
|
||||
static_assert(not is_subtype_of(T, Super))
|
||||
static_assert(not is_subtype_of(T, Base))
|
||||
static_assert(not is_subtype_of(T, Sub))
|
||||
static_assert(not is_subtype_of(T, Unrelated))
|
||||
static_assert(not is_subtype_of(T, Any))
|
||||
static_assert(not is_subtype_of(T, Super | Any))
|
||||
static_assert(not is_subtype_of(T, Super | Unrelated))
|
||||
static_assert(not is_subtype_of(Super, T))
|
||||
static_assert(not is_subtype_of(Base, T))
|
||||
static_assert(not is_subtype_of(Unrelated, T))
|
||||
static_assert(not is_subtype_of(Any, T))
|
||||
static_assert(not is_subtype_of(Super | Any, T))
|
||||
static_assert(not is_subtype_of(Base | Any, T))
|
||||
static_assert(not is_subtype_of(Super | Unrelated, T))
|
||||
static_assert(not is_subtype_of(Intersection[Base, Unrelated], T))
|
||||
static_assert(not is_subtype_of(Intersection[Base, Any], T))
|
||||
reveal_when_subtype_of(T, Super) # revealed: never
|
||||
reveal_when_subtype_of(T, Base) # revealed: never
|
||||
reveal_when_subtype_of(T, Sub) # revealed: never
|
||||
reveal_when_subtype_of(T, Unrelated) # revealed: never
|
||||
reveal_when_subtype_of(T, Any) # revealed: never
|
||||
reveal_when_subtype_of(T, Super | Any) # revealed: never
|
||||
reveal_when_subtype_of(T, Super | Unrelated) # revealed: never
|
||||
reveal_when_subtype_of(Super, T) # revealed: never
|
||||
reveal_when_subtype_of(Base, T) # revealed: never
|
||||
reveal_when_subtype_of(Unrelated, T) # revealed: never
|
||||
reveal_when_subtype_of(Any, T) # revealed: never
|
||||
reveal_when_subtype_of(Super | Any, T) # revealed: never
|
||||
reveal_when_subtype_of(Base | Any, T) # revealed: never
|
||||
reveal_when_subtype_of(Super | Unrelated, T) # revealed: never
|
||||
reveal_when_subtype_of(Intersection[Base, Unrelated], T) # revealed: never
|
||||
reveal_when_subtype_of(Intersection[Base, Any], T) # revealed: never
|
||||
```
|
||||
|
||||
Two distinct fully static typevars are not subtypes of each other, even if they have the same
|
||||
|
|
@ -299,58 +299,58 @@ the same type.
|
|||
|
||||
```py
|
||||
def two_constrained[T: (int, str), U: (int, str)](t: T, u: U) -> None:
|
||||
static_assert(not is_assignable_to(T, U))
|
||||
static_assert(not is_assignable_to(U, T))
|
||||
reveal_when_assignable_to(T, U) # revealed: never
|
||||
reveal_when_assignable_to(U, T) # revealed: never
|
||||
|
||||
static_assert(not is_subtype_of(T, U))
|
||||
static_assert(not is_subtype_of(U, T))
|
||||
reveal_when_subtype_of(T, U) # revealed: never
|
||||
reveal_when_subtype_of(U, T) # revealed: never
|
||||
|
||||
@final
|
||||
class AnotherFinalClass: ...
|
||||
|
||||
def two_final_constrained[T: (FinalClass, AnotherFinalClass), U: (FinalClass, AnotherFinalClass)](t: T, u: U) -> None:
|
||||
static_assert(not is_assignable_to(T, U))
|
||||
static_assert(not is_assignable_to(U, T))
|
||||
reveal_when_assignable_to(T, U) # revealed: never
|
||||
reveal_when_assignable_to(U, T) # revealed: never
|
||||
|
||||
static_assert(not is_subtype_of(T, U))
|
||||
static_assert(not is_subtype_of(U, T))
|
||||
reveal_when_subtype_of(T, U) # revealed: never
|
||||
reveal_when_subtype_of(U, T) # revealed: never
|
||||
```
|
||||
|
||||
A bound or constrained typevar is a subtype of itself in a union:
|
||||
|
||||
```py
|
||||
def union[T: Base, U: (Base, Unrelated)](t: T, u: U) -> None:
|
||||
static_assert(is_assignable_to(T, T | None))
|
||||
static_assert(is_assignable_to(U, U | None))
|
||||
reveal_when_assignable_to(T, T | None) # revealed: always
|
||||
reveal_when_assignable_to(U, U | None) # revealed: always
|
||||
|
||||
static_assert(is_subtype_of(T, T | None))
|
||||
static_assert(is_subtype_of(U, U | None))
|
||||
reveal_when_subtype_of(T, T | None) # revealed: always
|
||||
reveal_when_subtype_of(U, U | None) # revealed: always
|
||||
```
|
||||
|
||||
A bound or constrained typevar in a union with a dynamic type is assignable to the typevar:
|
||||
|
||||
```py
|
||||
def union_with_dynamic[T: Base, U: (Base, Unrelated)](t: T, u: U) -> None:
|
||||
static_assert(is_assignable_to(T | Any, T))
|
||||
static_assert(is_assignable_to(U | Any, U))
|
||||
reveal_when_assignable_to(T | Any, T) # revealed: always
|
||||
reveal_when_assignable_to(U | Any, U) # revealed: always
|
||||
|
||||
static_assert(not is_subtype_of(T | Any, T))
|
||||
static_assert(not is_subtype_of(U | Any, U))
|
||||
reveal_when_subtype_of(T | Any, T) # revealed: never
|
||||
reveal_when_subtype_of(U | Any, U) # revealed: never
|
||||
```
|
||||
|
||||
And an intersection of a typevar with another type is always a subtype of the TypeVar:
|
||||
|
||||
```py
|
||||
from ty_extensions import Intersection, Not, is_disjoint_from
|
||||
from ty_extensions import Intersection, Not, is_disjoint_from, static_assert
|
||||
|
||||
class A: ...
|
||||
|
||||
def inter[T: Base, U: (Base, Unrelated)](t: T, u: U) -> None:
|
||||
static_assert(is_assignable_to(Intersection[T, Unrelated], T))
|
||||
static_assert(is_subtype_of(Intersection[T, Unrelated], T))
|
||||
reveal_when_assignable_to(Intersection[T, Unrelated], T) # revealed: always
|
||||
reveal_when_subtype_of(Intersection[T, Unrelated], T) # revealed: always
|
||||
|
||||
static_assert(is_assignable_to(Intersection[U, A], U))
|
||||
static_assert(is_subtype_of(Intersection[U, A], U))
|
||||
reveal_when_assignable_to(Intersection[U, A], U) # revealed: always
|
||||
reveal_when_subtype_of(Intersection[U, A], U) # revealed: always
|
||||
|
||||
static_assert(is_disjoint_from(Not[T], T))
|
||||
static_assert(is_disjoint_from(T, Not[T]))
|
||||
|
|
@ -647,14 +647,14 @@ The intersection of a typevar with any other type is assignable to (and if fully
|
|||
of) itself.
|
||||
|
||||
```py
|
||||
from ty_extensions import is_assignable_to, is_subtype_of, static_assert, Not
|
||||
from ty_extensions import reveal_when_assignable_to, reveal_when_subtype_of, Not
|
||||
|
||||
def intersection_is_assignable[T](t: T) -> None:
|
||||
static_assert(is_assignable_to(Intersection[T, None], T))
|
||||
static_assert(is_assignable_to(Intersection[T, Not[None]], T))
|
||||
reveal_when_assignable_to(Intersection[T, None], T) # revealed: always
|
||||
reveal_when_assignable_to(Intersection[T, Not[None]], T) # revealed: always
|
||||
|
||||
static_assert(is_subtype_of(Intersection[T, None], T))
|
||||
static_assert(is_subtype_of(Intersection[T, Not[None]], T))
|
||||
reveal_when_subtype_of(Intersection[T, None], T) # revealed: always
|
||||
reveal_when_subtype_of(Intersection[T, Not[None]], T) # revealed: always
|
||||
```
|
||||
|
||||
## Narrowing
|
||||
|
|
|
|||
|
|
@ -413,13 +413,13 @@ To see the kinds and types of the protocol members, you can use the debugging ai
|
|||
from ty_extensions import reveal_protocol_interface
|
||||
from typing import SupportsIndex, SupportsAbs, ClassVar, Iterator
|
||||
|
||||
# error: [revealed-type] "Revealed protocol interface: `{"method_member": MethodMember(`(self) -> bytes`), "x": AttributeMember(`int`), "y": PropertyMember { getter: `def y(self) -> str` }, "z": PropertyMember { getter: `def z(self) -> int`, setter: `def z(self, z: int) -> None` }}`"
|
||||
# revealed: {"method_member": MethodMember(`(self) -> bytes`), "x": AttributeMember(`int`), "y": PropertyMember { getter: `def y(self) -> str` }, "z": PropertyMember { getter: `def z(self) -> int`, setter: `def z(self, z: int) -> None` }}
|
||||
reveal_protocol_interface(Foo)
|
||||
# error: [revealed-type] "Revealed protocol interface: `{"__index__": MethodMember(`(self) -> int`)}`"
|
||||
# revealed: {"__index__": MethodMember(`(self) -> int`)}
|
||||
reveal_protocol_interface(SupportsIndex)
|
||||
# error: [revealed-type] "Revealed protocol interface: `{"__abs__": MethodMember(`(self) -> Unknown`)}`"
|
||||
# revealed: {"__abs__": MethodMember(`(self) -> Unknown`)}
|
||||
reveal_protocol_interface(SupportsAbs)
|
||||
# error: [revealed-type] "Revealed protocol interface: `{"__iter__": MethodMember(`(self) -> Iterator[Unknown]`), "__next__": MethodMember(`(self) -> Unknown`)}`"
|
||||
# revealed: {"__iter__": MethodMember(`(self) -> Iterator[Unknown]`), "__next__": MethodMember(`(self) -> Unknown`)}
|
||||
reveal_protocol_interface(Iterator)
|
||||
|
||||
# error: [invalid-argument-type] "Invalid argument to `reveal_protocol_interface`: Only protocol classes can be passed to `reveal_protocol_interface`"
|
||||
|
|
@ -439,9 +439,9 @@ do not implement any special handling for generic aliases passed to the function
|
|||
reveal_type(get_protocol_members(SupportsAbs[int])) # revealed: frozenset[str]
|
||||
reveal_type(get_protocol_members(Iterator[int])) # revealed: frozenset[str]
|
||||
|
||||
# error: [revealed-type] "Revealed protocol interface: `{"__abs__": MethodMember(`(self) -> int`)}`"
|
||||
# revealed: {"__abs__": MethodMember(`(self) -> int`)}
|
||||
reveal_protocol_interface(SupportsAbs[int])
|
||||
# error: [revealed-type] "Revealed protocol interface: `{"__iter__": MethodMember(`(self) -> Iterator[int]`), "__next__": MethodMember(`(self) -> int`)}`"
|
||||
# revealed: {"__iter__": MethodMember(`(self) -> Iterator[int]`), "__next__": MethodMember(`(self) -> int`)}
|
||||
reveal_protocol_interface(Iterator[int])
|
||||
|
||||
class BaseProto(Protocol):
|
||||
|
|
@ -450,16 +450,16 @@ class BaseProto(Protocol):
|
|||
class SubProto(BaseProto, Protocol):
|
||||
def member(self) -> bool: ...
|
||||
|
||||
# error: [revealed-type] "Revealed protocol interface: `{"member": MethodMember(`(self) -> int`)}`"
|
||||
# revealed: {"member": MethodMember(`(self) -> int`)}
|
||||
reveal_protocol_interface(BaseProto)
|
||||
|
||||
# error: [revealed-type] "Revealed protocol interface: `{"member": MethodMember(`(self) -> bool`)}`"
|
||||
# revealed: {"member": MethodMember(`(self) -> bool`)}
|
||||
reveal_protocol_interface(SubProto)
|
||||
|
||||
class ProtoWithClassVar(Protocol):
|
||||
x: ClassVar[int]
|
||||
|
||||
# error: [revealed-type] "Revealed protocol interface: `{"x": AttributeMember(`int`; ClassVar)}`"
|
||||
# revealed: {"x": AttributeMember(`int`; ClassVar)}
|
||||
reveal_protocol_interface(ProtoWithClassVar)
|
||||
|
||||
class ProtocolWithDefault(Protocol):
|
||||
|
|
@ -468,7 +468,7 @@ class ProtocolWithDefault(Protocol):
|
|||
# We used to incorrectly report this as having an `x: Literal[0]` member;
|
||||
# declared types should take priority over inferred types for protocol interfaces!
|
||||
#
|
||||
# error: [revealed-type] "Revealed protocol interface: `{"x": AttributeMember(`int`)}`"
|
||||
# revealed: {"x": AttributeMember(`int`)}
|
||||
reveal_protocol_interface(ProtocolWithDefault)
|
||||
```
|
||||
|
||||
|
|
@ -2474,7 +2474,7 @@ class Foo(Protocol):
|
|||
from stub import Foo
|
||||
from ty_extensions import reveal_protocol_interface
|
||||
|
||||
# error: [revealed-type] "Revealed protocol interface: `{"x": AttributeMember(`int`; ClassVar)}`"
|
||||
# revealed: {"x": AttributeMember(`int`; ClassVar)}
|
||||
reveal_protocol_interface(Foo)
|
||||
```
|
||||
|
||||
|
|
|
|||
|
|
@ -4168,6 +4168,24 @@ impl<'db> Type<'db> {
|
|||
)
|
||||
.into(),
|
||||
|
||||
Some(
|
||||
KnownFunction::RevealWhenAssignableTo | KnownFunction::RevealWhenSubtypeOf,
|
||||
) => Binding::single(
|
||||
self,
|
||||
Signature::new(
|
||||
Parameters::new([
|
||||
Parameter::positional_only(Some(Name::new_static("a")))
|
||||
.type_form()
|
||||
.with_annotated_type(Type::any()),
|
||||
Parameter::positional_only(Some(Name::new_static("b")))
|
||||
.type_form()
|
||||
.with_annotated_type(Type::any()),
|
||||
]),
|
||||
Some(KnownClass::NoneType.to_instance(db)),
|
||||
),
|
||||
)
|
||||
.into(),
|
||||
|
||||
Some(KnownFunction::IsSingleton | KnownFunction::IsSingleValued) => {
|
||||
Binding::single(
|
||||
self,
|
||||
|
|
|
|||
|
|
@ -133,9 +133,6 @@ pub(crate) trait Constraints<'db>: Clone + Sized {
|
|||
}
|
||||
|
||||
// This is here so that we can easily print constraint sets when debugging.
|
||||
// TODO: Add a ty_extensions function to reveal constraint sets so that this is no longer dead
|
||||
// code, and so that we verify the contents of our rendering.
|
||||
#[expect(dead_code)]
|
||||
fn display(&self, db: &'db dyn Db) -> impl Display;
|
||||
}
|
||||
|
||||
|
|
@ -345,34 +342,6 @@ impl<'db> ConstraintSet<'db> {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
// This is here so that we can easily print constraint sets when debugging.
|
||||
// TODO: Add a ty_extensions function to reveal constraint sets so that this is no longer dead
|
||||
// code, and so that we verify the contents of our rendering.
|
||||
#[expect(dead_code)]
|
||||
pub(crate) fn display(&self, db: &'db dyn Db) -> impl Display {
|
||||
struct DisplayConstraintSet<'a, 'db> {
|
||||
set: &'a ConstraintSet<'db>,
|
||||
db: &'db dyn Db,
|
||||
}
|
||||
|
||||
impl Display for DisplayConstraintSet<'_, '_> {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
if self.set.clauses.is_empty() {
|
||||
return f.write_str("0");
|
||||
}
|
||||
for (i, clause) in self.set.clauses.iter().enumerate() {
|
||||
if i > 0 {
|
||||
f.write_str(" ∨ ")?;
|
||||
}
|
||||
clause.display(self.db).fmt(f)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
DisplayConstraintSet { set: self, db }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'db> Constraints<'db> for ConstraintSet<'db> {
|
||||
|
|
@ -411,7 +380,27 @@ impl<'db> Constraints<'db> for ConstraintSet<'db> {
|
|||
}
|
||||
|
||||
fn display(&self, db: &'db dyn Db) -> impl Display {
|
||||
self.display(db)
|
||||
struct DisplayConstraintSet<'a, 'db> {
|
||||
set: &'a ConstraintSet<'db>,
|
||||
db: &'db dyn Db,
|
||||
}
|
||||
|
||||
impl Display for DisplayConstraintSet<'_, '_> {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
if self.set.clauses.is_empty() {
|
||||
return f.write_str("0");
|
||||
}
|
||||
for (i, clause) in self.set.clauses.iter().enumerate() {
|
||||
if i > 0 {
|
||||
f.write_str(" ∨ ")?;
|
||||
}
|
||||
clause.display(self.db).fmt(f)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
DisplayConstraintSet { set: self, db }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ use crate::semantic_index::definition::Definition;
|
|||
use crate::semantic_index::scope::ScopeId;
|
||||
use crate::semantic_index::semantic_index;
|
||||
use crate::types::call::{Binding, CallArguments};
|
||||
use crate::types::constraints::Constraints;
|
||||
use crate::types::constraints::{ConstraintSet, Constraints};
|
||||
use crate::types::context::InferContext;
|
||||
use crate::types::diagnostic::{
|
||||
INVALID_ARGUMENT_TYPE, REDUNDANT_CAST, STATIC_ASSERT_ERROR, TYPE_ASSERTION_FAILURE,
|
||||
|
|
@ -1188,6 +1188,10 @@ pub enum KnownFunction {
|
|||
HasMember,
|
||||
/// `ty_extensions.reveal_protocol_interface`
|
||||
RevealProtocolInterface,
|
||||
/// `ty_extensions.reveal_when_assignable_to`
|
||||
RevealWhenAssignableTo,
|
||||
/// `ty_extensions.reveal_when_subtype_of`
|
||||
RevealWhenSubtypeOf,
|
||||
}
|
||||
|
||||
impl KnownFunction {
|
||||
|
|
@ -1253,6 +1257,8 @@ impl KnownFunction {
|
|||
| Self::StaticAssert
|
||||
| Self::HasMember
|
||||
| Self::RevealProtocolInterface
|
||||
| Self::RevealWhenAssignableTo
|
||||
| Self::RevealWhenSubtypeOf
|
||||
| Self::AllMembers => module.is_ty_extensions(),
|
||||
Self::ImportModule => module.is_importlib(),
|
||||
}
|
||||
|
|
@ -1548,6 +1554,54 @@ impl KnownFunction {
|
|||
overload.set_return_type(Type::module_literal(db, file, module));
|
||||
}
|
||||
|
||||
KnownFunction::RevealWhenAssignableTo => {
|
||||
let [Some(ty_a), Some(ty_b)] = overload.parameter_types() else {
|
||||
return;
|
||||
};
|
||||
let constraints = ty_a.when_assignable_to::<ConstraintSet>(db, *ty_b);
|
||||
let Some(builder) =
|
||||
context.report_diagnostic(DiagnosticId::RevealedType, Severity::Info)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let mut diag = builder.into_diagnostic("Assignability holds");
|
||||
let span = context.span(call_expression);
|
||||
if constraints.is_always_satisfied(db) {
|
||||
diag.annotate(Annotation::primary(span).message("always"));
|
||||
} else if constraints.is_never_satisfied(db) {
|
||||
diag.annotate(Annotation::primary(span).message("never"));
|
||||
} else {
|
||||
diag.annotate(
|
||||
Annotation::primary(span)
|
||||
.message(format_args!("when {}", constraints.display(db))),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
KnownFunction::RevealWhenSubtypeOf => {
|
||||
let [Some(ty_a), Some(ty_b)] = overload.parameter_types() else {
|
||||
return;
|
||||
};
|
||||
let constraints = ty_a.when_subtype_of::<ConstraintSet>(db, *ty_b);
|
||||
let Some(builder) =
|
||||
context.report_diagnostic(DiagnosticId::RevealedType, Severity::Info)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let mut diag = builder.into_diagnostic("Subtyping holds");
|
||||
let span = context.span(call_expression);
|
||||
if constraints.is_always_satisfied(db) {
|
||||
diag.annotate(Annotation::primary(span).message("always"));
|
||||
} else if constraints.is_never_satisfied(db) {
|
||||
diag.annotate(Annotation::primary(span).message("never"));
|
||||
} else {
|
||||
diag.annotate(
|
||||
Annotation::primary(span)
|
||||
.message(format_args!("when {}", constraints.display(db))),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
|
@ -1608,6 +1662,8 @@ pub(crate) mod tests {
|
|||
| KnownFunction::IsEquivalentTo
|
||||
| KnownFunction::HasMember
|
||||
| KnownFunction::RevealProtocolInterface
|
||||
| KnownFunction::RevealWhenAssignableTo
|
||||
| KnownFunction::RevealWhenSubtypeOf
|
||||
| KnownFunction::AllMembers => KnownModule::TyExtensions,
|
||||
|
||||
KnownFunction::ImportModule => KnownModule::ImportLib,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue