Python
/
ruff
mirror of https://github.com/astral-sh/ruff
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[ty] Improve the display of various special-form types (#21775)

This commit is contained in:
Alex Waygood 2025-12-03 21:19:59 +00:00 committed by GitHub
parent 8ebecb2a88
commit 14fce0d440
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
20 changed files with 220 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
crates/ty_ide/src/inlay_hints.rs
View File

@ -6428,11 +6428,11 @@ mod tests {
a = Literal['a', 'b', 'c']", a = Literal['a', 'b', 'c']",
); );
assert_snapshot!(test.inlay_hints(), @r" assert_snapshot!(test.inlay_hints(), @r#"
from typing import Literal from typing import Literal
a[: <typing.Literal special form>] = Literal['a', 'b', 'c'] a[: <special form 'Literal["a", "b", "c"]'>] = Literal['a', 'b', 'c']
"); "#);
} }
struct InlayHintLocationDiagnostic { struct InlayHintLocationDiagnostic {

4
crates/ty_python_semantic/resources/mdtest/annotations/any.md
View File

@ -169,13 +169,13 @@ def f(x: Any[int]):
`Any` cannot be called (this leads to a `TypeError` at runtime): `Any` cannot be called (this leads to a `TypeError` at runtime):
```py ```py
Any() # error: [call-non-callable] "Object of type `typing.Any` is not callable" Any() # error: [call-non-callable] "Object of type `<special form 'typing.Any'>` is not callable"
``` ```
`Any` also cannot be used as a metaclass (under the hood, this leads to an implicit call to `Any`): `Any` also cannot be used as a metaclass (under the hood, this leads to an implicit call to `Any`):
```py ```py
class F(metaclass=Any): ... # error: [invalid-metaclass] "Metaclass type `typing.Any` is not callable" class F(metaclass=Any): ... # error: [invalid-metaclass] "Metaclass type `<special form 'typing.Any'>` is not callable"
``` ```
And `Any` cannot be used in `isinstance()` checks: And `Any` cannot be used in `isinstance()` checks:

2
crates/ty_python_semantic/resources/mdtest/annotations/never.md
View File

@ -59,7 +59,7 @@ python-version = "3.11"
```py ```py
from typing import Never from typing import Never
reveal_type(Never) # revealed: typing.Never reveal_type(Never) # revealed: <special form 'typing.Never'>
``` ```
### Python 3.10 ### Python 3.10

12
crates/ty_python_semantic/resources/mdtest/binary/classes.md
View File

@ -13,7 +13,7 @@ python-version = "3.10"
class A: ... class A: ...
class B: ... class B: ...
reveal_type(A | B) # revealed: types.UnionType reveal_type(A | B) # revealed: <types.UnionType special form 'A | B'>
``` ```
## Union of two classes (prior to 3.10) ## Union of two classes (prior to 3.10)
@ -43,14 +43,14 @@ class A: ...
class B: ... class B: ...
def _(sub_a: type[A], sub_b: type[B]): def _(sub_a: type[A], sub_b: type[B]):
reveal_type(A | sub_b) # revealed: types.UnionType reveal_type(A | sub_b) # revealed: <types.UnionType special form>
reveal_type(sub_a | B) # revealed: types.UnionType reveal_type(sub_a | B) # revealed: <types.UnionType special form>
reveal_type(sub_a | sub_b) # revealed: types.UnionType reveal_type(sub_a | sub_b) # revealed: <types.UnionType special form>
class C[T]: ... class C[T]: ...
class D[T]: ... class D[T]: ...
reveal_type(C | D) # revealed: types.UnionType reveal_type(C | D) # revealed: <types.UnionType special form 'C[Unknown] | D[Unknown]'>
reveal_type(C[int] | D[str]) # revealed: types.UnionType reveal_type(C[int] | D[str]) # revealed: <types.UnionType special form 'C[int] | D[str]'>
``` ```

6
crates/ty_python_semantic/resources/mdtest/class/super.md
View File

@ -603,12 +603,14 @@ super(object, object()).__class__
# Not all objects valid in a class's bases list are valid as the first argument to `super()`. # Not all objects valid in a class's bases list are valid as the first argument to `super()`.
# For example, it's valid to inherit from `typing.ChainMap`, but it's not valid as the first argument to `super()`. # For example, it's valid to inherit from `typing.ChainMap`, but it's not valid as the first argument to `super()`.
# #
# error: [invalid-super-argument] "`typing.ChainMap` is not a valid class" # error: [invalid-super-argument] "`<special form 'typing.ChainMap'>` is not a valid class"
reveal_type(super(typing.ChainMap, collections.ChainMap())) # revealed: Unknown reveal_type(super(typing.ChainMap, collections.ChainMap())) # revealed: Unknown
# Meanwhile, it's not valid to inherit from unsubscripted `typing.Generic`, # Meanwhile, it's not valid to inherit from unsubscripted `typing.Generic`,
# but it *is* valid as the first argument to `super()`. # but it *is* valid as the first argument to `super()`.
reveal_type(super(typing.Generic, typing.SupportsInt)) # revealed: <super: typing.Generic, <class 'SupportsInt'>> #
# revealed: <super: <special form 'typing.Generic'>, <class 'SupportsInt'>>
reveal_type(super(typing.Generic, typing.SupportsInt))
def _(x: type[typing.Any], y: typing.Any): def _(x: type[typing.Any], y: typing.Any):
reveal_type(super(x, y)) # revealed: <super: Any, Any> reveal_type(super(x, y)) # revealed: <super: Any, Any>

2
crates/ty_python_semantic/resources/mdtest/function/return_type.md
View File

@ -80,7 +80,7 @@ class Foo(Protocol):
def f[T](self, v: T) -> T: ... def f[T](self, v: T) -> T: ...
t = (Protocol, int) t = (Protocol, int)
reveal_type(t[0]) # revealed: typing.Protocol reveal_type(t[0]) # revealed: <special form 'typing.Protocol'>
class Lorem(t[0]): class Lorem(t[0]):
def f(self) -> int: ... def f(self) -> int: ...

32
crates/ty_python_semantic/resources/mdtest/generics/pep695/aliases.md
View File

@ -62,7 +62,7 @@ The specialization must match the generic types:
```py ```py
# error: [invalid-type-arguments] "Too many type arguments: expected 1, got 2" # error: [invalid-type-arguments] "Too many type arguments: expected 1, got 2"
reveal_type(C[int, int]) # revealed: C[Unknown] reveal_type(C[int, int]) # revealed: <type alias 'C[Unknown]'>
``` ```
And non-generic types cannot be specialized: And non-generic types cannot be specialized:
@ -85,19 +85,19 @@ type BoundedByUnion[T: int | str] = ...
class IntSubclass(int): ... class IntSubclass(int): ...
reveal_type(Bounded[int]) # revealed: Bounded[int] reveal_type(Bounded[int]) # revealed: <type alias 'Bounded[int]'>
reveal_type(Bounded[IntSubclass]) # revealed: Bounded[IntSubclass] reveal_type(Bounded[IntSubclass]) # revealed: <type alias 'Bounded[IntSubclass]'>
# error: [invalid-type-arguments] "Type `str` is not assignable to upper bound `int` of type variable `T@Bounded`" # error: [invalid-type-arguments] "Type `str` is not assignable to upper bound `int` of type variable `T@Bounded`"
reveal_type(Bounded[str]) # revealed: Bounded[Unknown] reveal_type(Bounded[str]) # revealed: <type alias 'Bounded[Unknown]'>
# error: [invalid-type-arguments] "Type `int | str` is not assignable to upper bound `int` of type variable `T@Bounded`" # error: [invalid-type-arguments] "Type `int | str` is not assignable to upper bound `int` of type variable `T@Bounded`"
reveal_type(Bounded[int | str]) # revealed: Bounded[Unknown] reveal_type(Bounded[int | str]) # revealed: <type alias 'Bounded[Unknown]'>
reveal_type(BoundedByUnion[int]) # revealed: BoundedByUnion[int] reveal_type(BoundedByUnion[int]) # revealed: <type alias 'BoundedByUnion[int]'>
reveal_type(BoundedByUnion[IntSubclass]) # revealed: BoundedByUnion[IntSubclass] reveal_type(BoundedByUnion[IntSubclass]) # revealed: <type alias 'BoundedByUnion[IntSubclass]'>
reveal_type(BoundedByUnion[str]) # revealed: BoundedByUnion[str] reveal_type(BoundedByUnion[str]) # revealed: <type alias 'BoundedByUnion[str]'>
reveal_type(BoundedByUnion[int | str]) # revealed: BoundedByUnion[int | str] reveal_type(BoundedByUnion[int | str]) # revealed: <type alias 'BoundedByUnion[int | str]'>
``` ```
If the type variable is constrained, the specialized type must satisfy those constraints: If the type variable is constrained, the specialized type must satisfy those constraints:
@ -105,20 +105,20 @@ If the type variable is constrained, the specialized type must satisfy those con
```py ```py
type Constrained[T: (int, str)] = ... type Constrained[T: (int, str)] = ...
reveal_type(Constrained[int]) # revealed: Constrained[int] reveal_type(Constrained[int]) # revealed: <type alias 'Constrained[int]'>
# TODO: error: [invalid-argument-type] # TODO: error: [invalid-argument-type]
# TODO: revealed: Constrained[Unknown] # TODO: revealed: Constrained[Unknown]
reveal_type(Constrained[IntSubclass]) # revealed: Constrained[IntSubclass] reveal_type(Constrained[IntSubclass]) # revealed: <type alias 'Constrained[IntSubclass]'>
reveal_type(Constrained[str]) # revealed: Constrained[str] reveal_type(Constrained[str]) # revealed: <type alias 'Constrained[str]'>
# TODO: error: [invalid-argument-type] # TODO: error: [invalid-argument-type]
# TODO: revealed: Unknown # TODO: revealed: Unknown
reveal_type(Constrained[int | str]) # revealed: Constrained[int | str] reveal_type(Constrained[int | str]) # revealed: <type alias 'Constrained[int | str]'>
# error: [invalid-type-arguments] "Type `object` does not satisfy constraints `int`, `str` of type variable `T@Constrained`" # error: [invalid-type-arguments] "Type `object` does not satisfy constraints `int`, `str` of type variable `T@Constrained`"
reveal_type(Constrained[object]) # revealed: Constrained[Unknown] reveal_type(Constrained[object]) # revealed: <type alias 'Constrained[Unknown]'>
``` ```
If the type variable has a default, it can be omitted: If the type variable has a default, it can be omitted:
@ -126,8 +126,8 @@ If the type variable has a default, it can be omitted:
```py ```py
type WithDefault[T, U = int] = ... type WithDefault[T, U = int] = ...
reveal_type(WithDefault[str, str]) # revealed: WithDefault[str, str] reveal_type(WithDefault[str, str]) # revealed: <type alias 'WithDefault[str, str]'>
reveal_type(WithDefault[str]) # revealed: WithDefault[str, int] reveal_type(WithDefault[str]) # revealed: <type alias 'WithDefault[str, int]'>
``` ```
If the type alias is not specialized explicitly, it is implicitly specialized to `Unknown`: If the type alias is not specialized explicitly, it is implicitly specialized to `Unknown`:

195
crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md
View File

@ -77,44 +77,44 @@ IntOrTypeVar = int | T
TypeVarOrNone = T | None TypeVarOrNone = T | None
NoneOrTypeVar = None | T NoneOrTypeVar = None | T
reveal_type(IntOrStr) # revealed: types.UnionType reveal_type(IntOrStr) # revealed: <types.UnionType special form 'int | str'>
reveal_type(IntOrStrOrBytes1) # revealed: types.UnionType reveal_type(IntOrStrOrBytes1) # revealed: <types.UnionType special form 'int | str | bytes'>
reveal_type(IntOrStrOrBytes2) # revealed: types.UnionType reveal_type(IntOrStrOrBytes2) # revealed: <types.UnionType special form 'int | str | bytes'>
reveal_type(IntOrStrOrBytes3) # revealed: types.UnionType reveal_type(IntOrStrOrBytes3) # revealed: <types.UnionType special form 'int | str | bytes'>
reveal_type(IntOrStrOrBytes4) # revealed: types.UnionType reveal_type(IntOrStrOrBytes4) # revealed: <types.UnionType special form 'int | str | bytes'>
reveal_type(IntOrStrOrBytes5) # revealed: types.UnionType reveal_type(IntOrStrOrBytes5) # revealed: <types.UnionType special form 'int | str | bytes'>
reveal_type(IntOrStrOrBytes6) # revealed: types.UnionType reveal_type(IntOrStrOrBytes6) # revealed: <types.UnionType special form 'int | str | bytes'>
reveal_type(BytesOrIntOrStr) # revealed: types.UnionType reveal_type(BytesOrIntOrStr) # revealed: <types.UnionType special form 'bytes | int | str'>
reveal_type(IntOrNone) # revealed: types.UnionType reveal_type(IntOrNone) # revealed: <types.UnionType special form 'int | None'>
reveal_type(NoneOrInt) # revealed: types.UnionType reveal_type(NoneOrInt) # revealed: <types.UnionType special form 'None | int'>
reveal_type(IntOrStrOrNone) # revealed: types.UnionType reveal_type(IntOrStrOrNone) # revealed: <types.UnionType special form 'int | str | None'>
reveal_type(NoneOrIntOrStr) # revealed: types.UnionType reveal_type(NoneOrIntOrStr) # revealed: <types.UnionType special form 'None | int | str'>
reveal_type(IntOrAny) # revealed: types.UnionType reveal_type(IntOrAny) # revealed: <types.UnionType special form 'int | Any'>
reveal_type(AnyOrInt) # revealed: types.UnionType reveal_type(AnyOrInt) # revealed: <types.UnionType special form 'Any | int'>
reveal_type(NoneOrAny) # revealed: types.UnionType reveal_type(NoneOrAny) # revealed: <types.UnionType special form 'None | Any'>
reveal_type(AnyOrNone) # revealed: types.UnionType reveal_type(AnyOrNone) # revealed: <types.UnionType special form 'Any | None'>
reveal_type(NeverOrAny) # revealed: types.UnionType reveal_type(NeverOrAny) # revealed: <types.UnionType special form 'Any'>
reveal_type(AnyOrNever) # revealed: types.UnionType reveal_type(AnyOrNever) # revealed: <types.UnionType special form 'Any'>
reveal_type(UnknownOrInt) # revealed: types.UnionType reveal_type(UnknownOrInt) # revealed: <types.UnionType special form 'Unknown | int'>
reveal_type(IntOrUnknown) # revealed: types.UnionType reveal_type(IntOrUnknown) # revealed: <types.UnionType special form 'int | Unknown'>
reveal_type(StrOrZero) # revealed: types.UnionType reveal_type(StrOrZero) # revealed: <types.UnionType special form 'str | Literal[0]'>
reveal_type(ZeroOrStr) # revealed: types.UnionType reveal_type(ZeroOrStr) # revealed: <types.UnionType special form 'Literal[0] | str'>
reveal_type(IntOrLiteralString) # revealed: types.UnionType reveal_type(IntOrLiteralString) # revealed: <types.UnionType special form 'int | LiteralString'>
reveal_type(LiteralStringOrInt) # revealed: types.UnionType reveal_type(LiteralStringOrInt) # revealed: <types.UnionType special form 'LiteralString | int'>
reveal_type(NoneOrTuple) # revealed: types.UnionType reveal_type(NoneOrTuple) # revealed: <types.UnionType special form 'None | tuple[int, str]'>
reveal_type(TupleOrNone) # revealed: types.UnionType reveal_type(TupleOrNone) # revealed: <types.UnionType special form 'tuple[int, str] | None'>
reveal_type(IntOrAnnotated) # revealed: types.UnionType reveal_type(IntOrAnnotated) # revealed: <types.UnionType special form 'int | str'>
reveal_type(AnnotatedOrInt) # revealed: types.UnionType reveal_type(AnnotatedOrInt) # revealed: <types.UnionType special form 'str | int'>
reveal_type(IntOrOptional) # revealed: types.UnionType reveal_type(IntOrOptional) # revealed: <types.UnionType special form 'int | str | None'>
reveal_type(OptionalOrInt) # revealed: types.UnionType reveal_type(OptionalOrInt) # revealed: <types.UnionType special form 'str | None | int'>
reveal_type(IntOrTypeOfStr) # revealed: types.UnionType reveal_type(IntOrTypeOfStr) # revealed: <types.UnionType special form 'int | type[str]'>
reveal_type(TypeOfStrOrInt) # revealed: types.UnionType reveal_type(TypeOfStrOrInt) # revealed: <types.UnionType special form 'type[str] | int'>
reveal_type(IntOrCallable) # revealed: types.UnionType reveal_type(IntOrCallable) # revealed: <types.UnionType special form 'int | ((str, /) -> bytes)'>
reveal_type(CallableOrInt) # revealed: types.UnionType reveal_type(CallableOrInt) # revealed: <types.UnionType special form '((str, /) -> bytes) | int'>
reveal_type(TypeVarOrInt) # revealed: types.UnionType reveal_type(TypeVarOrInt) # revealed: <types.UnionType special form 'T@TypeVarOrInt | int'>
reveal_type(IntOrTypeVar) # revealed: types.UnionType reveal_type(IntOrTypeVar) # revealed: <types.UnionType special form 'int | T@IntOrTypeVar'>
reveal_type(TypeVarOrNone) # revealed: types.UnionType reveal_type(TypeVarOrNone) # revealed: <types.UnionType special form 'T@TypeVarOrNone | None'>
reveal_type(NoneOrTypeVar) # revealed: types.UnionType reveal_type(NoneOrTypeVar) # revealed: <types.UnionType special form 'None | T@NoneOrTypeVar'>
def _( def _(
int_or_str: IntOrStr, int_or_str: IntOrStr,
@ -295,7 +295,7 @@ X = Foo | Bar
# In an ideal world, perhaps we would respect `Meta.__or__` here and reveal `str`? # In an ideal world, perhaps we would respect `Meta.__or__` here and reveal `str`?
# But we still need to record what the elements are, since (according to the typing spec) # But we still need to record what the elements are, since (according to the typing spec)
# `X` is still a valid type alias # `X` is still a valid type alias
reveal_type(X) # revealed: types.UnionType reveal_type(X) # revealed: <types.UnionType special form 'Foo | Bar'>
def f(obj: X): def f(obj: X):
reveal_type(obj) # revealed: Foo | Bar reveal_type(obj) # revealed: Foo | Bar
@ -391,16 +391,17 @@ MyOptional = T | None
reveal_type(MyList) # revealed: <class 'list[T@MyList]'> reveal_type(MyList) # revealed: <class 'list[T@MyList]'>
reveal_type(MyDict) # revealed: <class 'dict[T@MyDict, U@MyDict]'> reveal_type(MyDict) # revealed: <class 'dict[T@MyDict, U@MyDict]'>
reveal_type(MyType) # revealed: GenericAlias reveal_type(MyType) # revealed: <special form 'type[T@MyType]'>
reveal_type(IntAndType) # revealed: <class 'tuple[int, T@IntAndType]'> reveal_type(IntAndType) # revealed: <class 'tuple[int, T@IntAndType]'>
reveal_type(Pair) # revealed: <class 'tuple[T@Pair, T@Pair]'> reveal_type(Pair) # revealed: <class 'tuple[T@Pair, T@Pair]'>
reveal_type(Sum) # revealed: <class 'tuple[T@Sum, U@Sum]'> reveal_type(Sum) # revealed: <class 'tuple[T@Sum, U@Sum]'>
reveal_type(ListOrTuple) # revealed: types.UnionType reveal_type(ListOrTuple) # revealed: <types.UnionType special form 'list[T@ListOrTuple] | tuple[T@ListOrTuple, ...]'>
reveal_type(ListOrTupleLegacy) # revealed: types.UnionType # revealed: <types.UnionType special form 'list[T@ListOrTupleLegacy] | tuple[T@ListOrTupleLegacy, ...]'>
reveal_type(ListOrTupleLegacy)
reveal_type(MyCallable) # revealed: @Todo(Callable[..] specialized with ParamSpec) reveal_type(MyCallable) # revealed: @Todo(Callable[..] specialized with ParamSpec)
reveal_type(AnnotatedType) # revealed: <typing.Annotated special form> reveal_type(AnnotatedType) # revealed: <special form 'typing.Annotated[T@AnnotatedType, <metadata>]'>
reveal_type(TransparentAlias) # revealed: typing.TypeVar reveal_type(TransparentAlias) # revealed: typing.TypeVar
reveal_type(MyOptional) # revealed: types.UnionType reveal_type(MyOptional) # revealed: <types.UnionType special form 'T@MyOptional | None'>
def _( def _(
list_of_ints: MyList[int], list_of_ints: MyList[int],
@ -456,12 +457,12 @@ AnnotatedInt = AnnotatedType[int]
SubclassOfInt = MyType[int] SubclassOfInt = MyType[int]
CallableIntToStr = MyCallable[[int], str] CallableIntToStr = MyCallable[[int], str]
reveal_type(IntsOrNone) # revealed: types.UnionType reveal_type(IntsOrNone) # revealed: <types.UnionType special form 'list[int] | None'>
reveal_type(IntsOrStrs) # revealed: types.UnionType reveal_type(IntsOrStrs) # revealed: <types.UnionType special form 'tuple[int, int] | tuple[str, str]'>
reveal_type(ListOfPairs) # revealed: <class 'list[tuple[str, str]]'> reveal_type(ListOfPairs) # revealed: <class 'list[tuple[str, str]]'>
reveal_type(ListOrTupleOfInts) # revealed: types.UnionType reveal_type(ListOrTupleOfInts) # revealed: <types.UnionType special form 'list[int] | tuple[int, ...]'>
reveal_type(AnnotatedInt) # revealed: <typing.Annotated special form> reveal_type(AnnotatedInt) # revealed: <special form 'typing.Annotated[int, <metadata>]'>
reveal_type(SubclassOfInt) # revealed: GenericAlias reveal_type(SubclassOfInt) # revealed: <special form 'type[int]'>
reveal_type(CallableIntToStr) # revealed: @Todo(Callable[..] specialized with ParamSpec) reveal_type(CallableIntToStr) # revealed: @Todo(Callable[..] specialized with ParamSpec)
def _( def _(
@ -495,8 +496,8 @@ MyOtherType = MyType[T]
TypeOrList = MyType[B] | MyList[B] TypeOrList = MyType[B] | MyList[B]
reveal_type(MyOtherList) # revealed: <class 'list[T@MyOtherList]'> reveal_type(MyOtherList) # revealed: <class 'list[T@MyOtherList]'>
reveal_type(MyOtherType) # revealed: GenericAlias reveal_type(MyOtherType) # revealed: <special form 'type[T@MyOtherType]'>
reveal_type(TypeOrList) # revealed: types.UnionType reveal_type(TypeOrList) # revealed: <types.UnionType special form 'type[B@TypeOrList] | list[B@TypeOrList]'>
def _( def _(
list_of_ints: MyOtherList[int], list_of_ints: MyOtherList[int],
@ -898,7 +899,7 @@ from typing import Optional
MyOptionalInt = Optional[int] MyOptionalInt = Optional[int]
reveal_type(MyOptionalInt) # revealed: types.UnionType reveal_type(MyOptionalInt) # revealed: <types.UnionType special form 'int | None'>
def _(optional_int: MyOptionalInt): def _(optional_int: MyOptionalInt):
reveal_type(optional_int) # revealed: int | None reveal_type(optional_int) # revealed: int | None
@ -931,9 +932,9 @@ MyLiteralString = LiteralString
MyNoReturn = NoReturn MyNoReturn = NoReturn
MyNever = Never MyNever = Never
reveal_type(MyLiteralString) # revealed: typing.LiteralString reveal_type(MyLiteralString) # revealed: <special form 'typing.LiteralString'>
reveal_type(MyNoReturn) # revealed: typing.NoReturn reveal_type(MyNoReturn) # revealed: <special form 'typing.NoReturn'>
reveal_type(MyNever) # revealed: typing.Never reveal_type(MyNever) # revealed: <special form 'typing.Never'>
def _( def _(
ls: MyLiteralString, ls: MyLiteralString,
@ -986,8 +987,8 @@ from typing import Union
IntOrStr = Union[int, str] IntOrStr = Union[int, str]
IntOrStrOrBytes = Union[int, Union[str, bytes]] IntOrStrOrBytes = Union[int, Union[str, bytes]]
reveal_type(IntOrStr) # revealed: types.UnionType reveal_type(IntOrStr) # revealed: <types.UnionType special form 'int | str'>
reveal_type(IntOrStrOrBytes) # revealed: types.UnionType reveal_type(IntOrStrOrBytes) # revealed: <types.UnionType special form 'int | str | bytes'>
def _( def _(
int_or_str: IntOrStr, int_or_str: IntOrStr,
@ -1015,7 +1016,7 @@ An empty `typing.Union` leads to a `TypeError` at runtime, so we emit an error.
# error: [invalid-type-form] "`typing.Union` requires at least one type argument" # error: [invalid-type-form] "`typing.Union` requires at least one type argument"
EmptyUnion = Union[()] EmptyUnion = Union[()]
reveal_type(EmptyUnion) # revealed: types.UnionType reveal_type(EmptyUnion) # revealed: <types.UnionType special form 'Never'>
def _(empty: EmptyUnion): def _(empty: EmptyUnion):
reveal_type(empty) # revealed: Never reveal_type(empty) # revealed: Never
@ -1060,14 +1061,14 @@ SubclassOfG = type[G]
SubclassOfGInt = type[G[int]] SubclassOfGInt = type[G[int]]
SubclassOfP = type[P] SubclassOfP = type[P]
reveal_type(SubclassOfA) # revealed: GenericAlias reveal_type(SubclassOfA) # revealed: <special form 'type[A]'>
reveal_type(SubclassOfAny) # revealed: GenericAlias reveal_type(SubclassOfAny) # revealed: <special form 'type[Any]'>
reveal_type(SubclassOfAOrB1) # revealed: GenericAlias reveal_type(SubclassOfAOrB1) # revealed: <special form 'type[A | B]'>
reveal_type(SubclassOfAOrB2) # revealed: types.UnionType reveal_type(SubclassOfAOrB2) # revealed: <types.UnionType special form 'type[A] | type[B]'>
reveal_type(SubclassOfAOrB3) # revealed: types.UnionType reveal_type(SubclassOfAOrB3) # revealed: <types.UnionType special form 'type[A] | type[B]'>
reveal_type(SubclassOfG) # revealed: GenericAlias reveal_type(SubclassOfG) # revealed: <special form 'type[G[Unknown]]'>
reveal_type(SubclassOfGInt) # revealed: GenericAlias reveal_type(SubclassOfGInt) # revealed: <special form 'type[G[int]]'>
reveal_type(SubclassOfP) # revealed: GenericAlias reveal_type(SubclassOfP) # revealed: <special form 'type[P]'>
def _( def _(
subclass_of_a: SubclassOfA, subclass_of_a: SubclassOfA,
@ -1148,14 +1149,14 @@ SubclassOfG = Type[G]
SubclassOfGInt = Type[G[int]] SubclassOfGInt = Type[G[int]]
SubclassOfP = Type[P] SubclassOfP = Type[P]
reveal_type(SubclassOfA) # revealed: GenericAlias reveal_type(SubclassOfA) # revealed: <special form 'type[A]'>
reveal_type(SubclassOfAny) # revealed: GenericAlias reveal_type(SubclassOfAny) # revealed: <special form 'type[Any]'>
reveal_type(SubclassOfAOrB1) # revealed: GenericAlias reveal_type(SubclassOfAOrB1) # revealed: <special form 'type[A | B]'>
reveal_type(SubclassOfAOrB2) # revealed: types.UnionType reveal_type(SubclassOfAOrB2) # revealed: <types.UnionType special form 'type[A] | type[B]'>
reveal_type(SubclassOfAOrB3) # revealed: types.UnionType reveal_type(SubclassOfAOrB3) # revealed: <types.UnionType special form 'type[A] | type[B]'>
reveal_type(SubclassOfG) # revealed: GenericAlias reveal_type(SubclassOfG) # revealed: <special form 'type[G[Unknown]]'>
reveal_type(SubclassOfGInt) # revealed: GenericAlias reveal_type(SubclassOfGInt) # revealed: <special form 'type[G[int]]'>
reveal_type(SubclassOfP) # revealed: GenericAlias reveal_type(SubclassOfP) # revealed: <special form 'type[P]'>
def _( def _(
subclass_of_a: SubclassOfA, subclass_of_a: SubclassOfA,
@ -1270,25 +1271,25 @@ DefaultDictOrNone = DefaultDict[str, int] | None
DequeOrNone = Deque[str] | None DequeOrNone = Deque[str] | None
OrderedDictOrNone = OrderedDict[str, int] | None OrderedDictOrNone = OrderedDict[str, int] | None
reveal_type(NoneOrList) # revealed: types.UnionType reveal_type(NoneOrList) # revealed: <types.UnionType special form 'None | list[str]'>
reveal_type(NoneOrSet) # revealed: types.UnionType reveal_type(NoneOrSet) # revealed: <types.UnionType special form 'None | set[str]'>
reveal_type(NoneOrDict) # revealed: types.UnionType reveal_type(NoneOrDict) # revealed: <types.UnionType special form 'None | dict[str, int]'>
reveal_type(NoneOrFrozenSet) # revealed: types.UnionType reveal_type(NoneOrFrozenSet) # revealed: <types.UnionType special form 'None | frozenset[str]'>
reveal_type(NoneOrChainMap) # revealed: types.UnionType reveal_type(NoneOrChainMap) # revealed: <types.UnionType special form 'None | ChainMap[str, int]'>
reveal_type(NoneOrCounter) # revealed: types.UnionType reveal_type(NoneOrCounter) # revealed: <types.UnionType special form 'None | Counter[str]'>
reveal_type(NoneOrDefaultDict) # revealed: types.UnionType reveal_type(NoneOrDefaultDict) # revealed: <types.UnionType special form 'None | defaultdict[str, int]'>
reveal_type(NoneOrDeque) # revealed: types.UnionType reveal_type(NoneOrDeque) # revealed: <types.UnionType special form 'None | deque[str]'>
reveal_type(NoneOrOrderedDict) # revealed: types.UnionType reveal_type(NoneOrOrderedDict) # revealed: <types.UnionType special form 'None | OrderedDict[str, int]'>
reveal_type(ListOrNone) # revealed: types.UnionType reveal_type(ListOrNone) # revealed: <types.UnionType special form 'list[int] | None'>
reveal_type(SetOrNone) # revealed: types.UnionType reveal_type(SetOrNone) # revealed: <types.UnionType special form 'set[int] | None'>
reveal_type(DictOrNone) # revealed: types.UnionType reveal_type(DictOrNone) # revealed: <types.UnionType special form 'dict[str, int] | None'>
reveal_type(FrozenSetOrNone) # revealed: types.UnionType reveal_type(FrozenSetOrNone) # revealed: <types.UnionType special form 'frozenset[int] | None'>
reveal_type(ChainMapOrNone) # revealed: types.UnionType reveal_type(ChainMapOrNone) # revealed: <types.UnionType special form 'ChainMap[str, int] | None'>
reveal_type(CounterOrNone) # revealed: types.UnionType reveal_type(CounterOrNone) # revealed: <types.UnionType special form 'Counter[str] | None'>
reveal_type(DefaultDictOrNone) # revealed: types.UnionType reveal_type(DefaultDictOrNone) # revealed: <types.UnionType special form 'defaultdict[str, int] | None'>
reveal_type(DequeOrNone) # revealed: types.UnionType reveal_type(DequeOrNone) # revealed: <types.UnionType special form 'deque[str] | None'>
reveal_type(OrderedDictOrNone) # revealed: types.UnionType reveal_type(OrderedDictOrNone) # revealed: <types.UnionType special form 'OrderedDict[str, int] | None'>
def _( def _(
none_or_list: NoneOrList, none_or_list: NoneOrList,
@ -1381,9 +1382,9 @@ CallableNoArgs = Callable[[], None]
BasicCallable = Callable[[int, str], bytes] BasicCallable = Callable[[int, str], bytes]
GradualCallable = Callable[..., str] GradualCallable = Callable[..., str]
reveal_type(CallableNoArgs) # revealed: GenericAlias reveal_type(CallableNoArgs) # revealed: <typing.Callable special form '() -> None'>
reveal_type(BasicCallable) # revealed: GenericAlias reveal_type(BasicCallable) # revealed: <typing.Callable special form '(int, str, /) -> bytes'>
reveal_type(GradualCallable) # revealed: GenericAlias reveal_type(GradualCallable) # revealed: <typing.Callable special form '(...) -> str'>
def _( def _(
callable_no_args: CallableNoArgs, callable_no_args: CallableNoArgs,
@ -1415,8 +1416,8 @@ InvalidCallable1 = Callable[[int]]
# error: [invalid-type-form] "The first argument to `Callable` must be either a list of types, ParamSpec, Concatenate, or `...`" # error: [invalid-type-form] "The first argument to `Callable` must be either a list of types, ParamSpec, Concatenate, or `...`"
InvalidCallable2 = Callable[int, str] InvalidCallable2 = Callable[int, str]
reveal_type(InvalidCallable1) # revealed: GenericAlias reveal_type(InvalidCallable1) # revealed: <typing.Callable special form '(...) -> Unknown'>
reveal_type(InvalidCallable2) # revealed: GenericAlias reveal_type(InvalidCallable2) # revealed: <typing.Callable special form '(...) -> Unknown'>
def _(invalid_callable1: InvalidCallable1, invalid_callable2: InvalidCallable2): def _(invalid_callable1: InvalidCallable1, invalid_callable2: InvalidCallable2):
reveal_type(invalid_callable1) # revealed: (...) -> Unknown reveal_type(invalid_callable1) # revealed: (...) -> Unknown

8
crates/ty_python_semantic/resources/mdtest/import/conventions.md
View File

@ -53,8 +53,8 @@ in `import os.path as os.path` the `os.path` is not a valid identifier.
```py ```py
from b import Any, Literal, foo from b import Any, Literal, foo
reveal_type(Any) # revealed: typing.Any reveal_type(Any) # revealed: <special form 'typing.Any'>
reveal_type(Literal) # revealed: typing.Literal reveal_type(Literal) # revealed: <special form 'typing.Literal'>
reveal_type(foo) # revealed: <module 'foo'> reveal_type(foo) # revealed: <module 'foo'>
``` ```
@ -132,7 +132,7 @@ reveal_type(Any) # revealed: Unknown
```pyi ```pyi
from typing import Any from typing import Any
reveal_type(Any) # revealed: typing.Any reveal_type(Any) # revealed: <special form 'typing.Any'>
``` ```
## Nested mixed re-export and not ## Nested mixed re-export and not
@ -169,7 +169,7 @@ reveal_type(Any) # revealed: Unknown
```pyi ```pyi
from typing import Any from typing import Any
reveal_type(Any) # revealed: typing.Any reveal_type(Any) # revealed: <special form 'typing.Any'>
``` ```
## Exported as different name ## Exported as different name

2
crates/ty_python_semantic/resources/mdtest/import/star.md
View File

@ -1437,7 +1437,7 @@ are present due to `*` imports.
import collections.abc import collections.abc
reveal_type(collections.abc.Sequence) # revealed: <class 'Sequence'> reveal_type(collections.abc.Sequence) # revealed: <class 'Sequence'>
reveal_type(collections.abc.Callable) # revealed: typing.Callable reveal_type(collections.abc.Callable) # revealed: <special form 'typing.Callable'>
reveal_type(collections.abc.Set) # revealed: <class 'AbstractSet'> reveal_type(collections.abc.Set) # revealed: <class 'AbstractSet'>
``` ```

2
crates/ty_python_semantic/resources/mdtest/mro.md
View File

@ -301,7 +301,7 @@ class B: ...
EitherOr = A | B EitherOr = A | B
# error: [invalid-base] "Invalid class base with type `types.UnionType`" # error: [invalid-base] "Invalid class base with type `<types.UnionType special form 'A | B'>`"
class Foo(EitherOr): ... class Foo(EitherOr): ...
``` ```

2
crates/ty_python_semantic/resources/mdtest/narrow/isinstance.md
View File

@ -156,7 +156,7 @@ from typing import Union
IntOrStr = Union[int, str] IntOrStr = Union[int, str]
reveal_type(IntOrStr) # revealed: types.UnionType reveal_type(IntOrStr) # revealed: <types.UnionType special form 'int | str'>
def _(x: int | str | bytes | memoryview | range): def _(x: int | str | bytes | memoryview | range):
if isinstance(x, IntOrStr): if isinstance(x, IntOrStr):

2
crates/ty_python_semantic/resources/mdtest/narrow/issubclass.md
View File

@ -209,7 +209,7 @@ from typing import Union
IntOrStr = Union[int, str] IntOrStr = Union[int, str]
reveal_type(IntOrStr) # revealed: types.UnionType reveal_type(IntOrStr) # revealed: <types.UnionType special form 'int | str'>
def f(x: type[int | str | bytes | range]): def f(x: type[int | str | bytes | range]):
if issubclass(x, IntOrStr): if issubclass(x, IntOrStr):

4
crates/ty_python_semantic/resources/mdtest/pep613_type_aliases.md
View File

@ -113,7 +113,7 @@ MyList: TypeAlias = list[T]
ListOrSet: TypeAlias = list[T] | set[T] ListOrSet: TypeAlias = list[T] | set[T]
reveal_type(MyList) # revealed: <class 'list[T]'> reveal_type(MyList) # revealed: <class 'list[T]'>
reveal_type(ListOrSet) # revealed: types.UnionType reveal_type(ListOrSet) # revealed: <types.UnionType special form 'list[T] | set[T]'>
def _(list_of_int: MyList[int], list_or_set_of_str: ListOrSet[str]): def _(list_of_int: MyList[int], list_or_set_of_str: ListOrSet[str]):
reveal_type(list_of_int) # revealed: list[int] reveal_type(list_of_int) # revealed: list[int]
@ -293,7 +293,7 @@ def _(rec: RecursiveHomogeneousTuple):
reveal_type(rec) # revealed: tuple[Divergent, ...] reveal_type(rec) # revealed: tuple[Divergent, ...]
ClassInfo: TypeAlias = type | UnionType | tuple["ClassInfo", ...] ClassInfo: TypeAlias = type | UnionType | tuple["ClassInfo", ...]
reveal_type(ClassInfo) # revealed: types.UnionType reveal_type(ClassInfo) # revealed: <types.UnionType special form 'type | UnionType | tuple[Divergent, ...]'>
def my_isinstance(obj: object, classinfo: ClassInfo) -> bool: def my_isinstance(obj: object, classinfo: ClassInfo) -> bool:
# TODO should be `type | UnionType | tuple[ClassInfo, ...]` # TODO should be `type | UnionType | tuple[ClassInfo, ...]`

4
crates/ty_python_semantic/resources/mdtest/snapshots/isinstance.md_-_Narrowing_for_`isins…_-_`classinfo`_is_an_in…_(eeef56c0ef87a30b).snap
View File

@ -63,7 +63,7 @@ error[invalid-argument-type]: Invalid second argument to `isinstance`
10 | # error: [invalid-argument-type] 10 | # error: [invalid-argument-type]
| |
info: A `UnionType` instance can only be used as the second argument to `isinstance` if all elements are class objects info: A `UnionType` instance can only be used as the second argument to `isinstance` if all elements are class objects
info: Elements `<typing.Literal special form>` and `<class 'list[int]'>` in the union are not class objects info: Elements `<special form 'Literal[42]'>` and `<class 'list[int]'>` in the union are not class objects
info: rule `invalid-argument-type` is enabled by default info: rule `invalid-argument-type` is enabled by default
``` ```
@ -82,7 +82,7 @@ error[invalid-argument-type]: Invalid second argument to `isinstance`
13 | else: 13 | else:
| |
info: A `UnionType` instance can only be used as the second argument to `isinstance` if all elements are class objects info: A `UnionType` instance can only be used as the second argument to `isinstance` if all elements are class objects
info: Element `typing.Any` in the union, and 2 more elements, are not class objects info: Element `<special form 'typing.Any'>` in the union, and 2 more elements, are not class objects
info: rule `invalid-argument-type` is enabled by default info: rule `invalid-argument-type` is enabled by default
``` ```

2
crates/ty_python_semantic/resources/mdtest/snapshots/mro.md_-_Method_Resolution_Or…_-_Unresolvable_MROs_in…_(e2b355c09a967862).snap
View File

@ -24,7 +24,7 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/mro.md
# Diagnostics # Diagnostics
``` ```
error[inconsistent-mro]: Cannot create a consistent method resolution order (MRO) for class `Baz` with bases list `[typing.Protocol[T], <class 'Foo'>, <class 'Bar[T@Baz]'>]` error[inconsistent-mro]: Cannot create a consistent method resolution order (MRO) for class `Baz` with bases list `[<special form 'typing.Protocol[T]'>, <class 'Foo'>, <class 'Bar[T@Baz]'>]`
--> src/mdtest_snippet.py:7:1 --> src/mdtest_snippet.py:7:1
| |
5 | class Foo(Protocol): ... 5 | class Foo(Protocol): ...

2
crates/ty_python_semantic/resources/mdtest/snapshots/protocols.md_-_Protocols_-_Calls_to_protocol_cl…_(288988036f34ddcf).snap
View File

@ -42,7 +42,7 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/protocols.md
# Diagnostics # Diagnostics
``` ```
error[call-non-callable]: Object of type `typing.Protocol` is not callable error[call-non-callable]: Object of type `<special form 'typing.Protocol'>` is not callable
--> src/mdtest_snippet.py:4:13 --> src/mdtest_snippet.py:4:13
| |
3 | # error: [call-non-callable] 3 | # error: [call-non-callable]

27
crates/ty_python_semantic/src/types.rs
View File

@ -7331,7 +7331,7 @@ impl<'db> Type<'db> {
| SpecialFormType::Union | SpecialFormType::Union
| SpecialFormType::Intersection => Err(InvalidTypeExpressionError { | SpecialFormType::Intersection => Err(InvalidTypeExpressionError {
invalid_expressions: smallvec::smallvec_inline![ invalid_expressions: smallvec::smallvec_inline![
InvalidTypeExpression::RequiresArguments(*self) InvalidTypeExpression::RequiresArguments(*special_form)
], ],
fallback_type: Type::unknown(), fallback_type: Type::unknown(),
}), }),
@ -7357,7 +7357,7 @@ impl<'db> Type<'db> {
| SpecialFormType::Unpack | SpecialFormType::Unpack
| SpecialFormType::CallableTypeOf => Err(InvalidTypeExpressionError { | SpecialFormType::CallableTypeOf => Err(InvalidTypeExpressionError {
invalid_expressions: smallvec::smallvec_inline![ invalid_expressions: smallvec::smallvec_inline![
InvalidTypeExpression::RequiresOneArgument(*self) InvalidTypeExpression::RequiresOneArgument(*special_form)
], ],
fallback_type: Type::unknown(), fallback_type: Type::unknown(),
}), }),
@ -7365,7 +7365,7 @@ impl<'db> Type<'db> {
SpecialFormType::Annotated | SpecialFormType::Concatenate => { SpecialFormType::Annotated | SpecialFormType::Concatenate => {
Err(InvalidTypeExpressionError { Err(InvalidTypeExpressionError {
invalid_expressions: smallvec::smallvec_inline![ invalid_expressions: smallvec::smallvec_inline![
InvalidTypeExpression::RequiresTwoArguments(*self) InvalidTypeExpression::RequiresTwoArguments(*special_form)
], ],
fallback_type: Type::unknown(), fallback_type: Type::unknown(),
}) })
@ -9087,11 +9087,11 @@ impl<'db> InvalidTypeExpressionError<'db> {
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, get_size2::GetSize)] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, get_size2::GetSize)]
enum InvalidTypeExpression<'db> { enum InvalidTypeExpression<'db> {
/// Some types always require exactly one argument when used in a type expression /// Some types always require exactly one argument when used in a type expression
RequiresOneArgument(Type<'db>), RequiresOneArgument(SpecialFormType),
/// Some types always require at least one argument when used in a type expression /// Some types always require at least one argument when used in a type expression
RequiresArguments(Type<'db>), RequiresArguments(SpecialFormType),
/// Some types always require at least two arguments when used in a type expression /// Some types always require at least two arguments when used in a type expression
RequiresTwoArguments(Type<'db>), RequiresTwoArguments(SpecialFormType),
/// The `Protocol` class is invalid in type expressions /// The `Protocol` class is invalid in type expressions
Protocol, Protocol,
/// Same for `Generic` /// Same for `Generic`
@ -9131,20 +9131,17 @@ impl<'db> InvalidTypeExpression<'db> {
impl std::fmt::Display for Display<'_> { impl std::fmt::Display for Display<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self.error { match self.error {
InvalidTypeExpression::RequiresOneArgument(ty) => write!( InvalidTypeExpression::RequiresOneArgument(special_form) => write!(
f, f,
"`{ty}` requires exactly one argument when used in a type expression", "`{special_form}` requires exactly one argument when used in a type expression",
ty = ty.display(self.db)
), ),
InvalidTypeExpression::RequiresArguments(ty) => write!( InvalidTypeExpression::RequiresArguments(special_form) => write!(
f, f,
"`{ty}` requires at least one argument when used in a type expression", "`{special_form}` requires at least one argument when used in a type expression",
ty = ty.display(self.db)
), ),
InvalidTypeExpression::RequiresTwoArguments(ty) => write!( InvalidTypeExpression::RequiresTwoArguments(special_form) => write!(
f, f,
"`{ty}` requires at least two arguments when used in a type expression", "`{special_form}` requires at least two arguments when used in a type expression",
ty = ty.display(self.db)
), ),
InvalidTypeExpression::Protocol => { InvalidTypeExpression::Protocol => {
f.write_str("`typing.Protocol` is not allowed in type expressions") f.write_str("`typing.Protocol` is not allowed in type expressions")

10
crates/ty_python_semantic/src/types/diagnostic.rs
View File

@ -2998,11 +2998,10 @@ pub(crate) fn report_invalid_arguments_to_annotated(
let Some(builder) = context.report_lint(&INVALID_TYPE_FORM, subscript) else { let Some(builder) = context.report_lint(&INVALID_TYPE_FORM, subscript) else {
return; return;
}; };
builder.into_diagnostic(format_args!( builder.into_diagnostic(
"Special form `{}` expected at least 2 arguments \ "Special form `typing.Annotated` expected at least 2 arguments \
(one type and at least one metadata element)", (one type and at least one metadata element)",
SpecialFormType::Annotated );
));
} }
pub(crate) fn report_invalid_argument_number_to_special_form( pub(crate) fn report_invalid_argument_number_to_special_form(
@ -3103,8 +3102,7 @@ pub(crate) fn report_invalid_arguments_to_callable(
return; return;
}; };
builder.into_diagnostic(format_args!( builder.into_diagnostic(format_args!(
"Special form `{}` expected exactly two arguments (parameter types and return type)", "Special form `typing.Callable` expected exactly two arguments (parameter types and return type)",
SpecialFormType::Callable
)); ));
} }

74
crates/ty_python_semantic/src/types/display.rs
View File

@ -696,7 +696,8 @@ impl<'db> FmtDetailed<'db> for DisplayRepresentation<'db> {
), ),
}, },
Type::SpecialForm(special_form) => { Type::SpecialForm(special_form) => {
write!(f.with_type(self.ty), "{special_form}") f.set_invalid_syntax();
write!(f.with_type(self.ty), "<special form '{special_form}'>")
} }
Type::KnownInstance(known_instance) => known_instance Type::KnownInstance(known_instance) => known_instance
.display_with(self.db, self.settings.clone()) .display_with(self.db, self.settings.clone())
@ -2173,16 +2174,24 @@ impl<'db> FmtDetailed<'db> for DisplayKnownInstanceRepr<'db> {
let ty = Type::KnownInstance(self.known_instance); let ty = Type::KnownInstance(self.known_instance);
match self.known_instance { match self.known_instance {
KnownInstanceType::SubscriptedProtocol(generic_context) => { KnownInstanceType::SubscriptedProtocol(generic_context) => {
f.set_invalid_syntax();
f.write_str("<special form '")?;
f.with_type(ty).write_str("typing.Protocol")?; f.with_type(ty).write_str("typing.Protocol")?;
f.write_str(&generic_context.display(self.db).to_string()) f.write_str(&generic_context.display(self.db).to_string())?;
f.write_str("'>")
} }
KnownInstanceType::SubscriptedGeneric(generic_context) => { KnownInstanceType::SubscriptedGeneric(generic_context) => {
f.set_invalid_syntax();
f.write_str("<special form '")?;
f.with_type(ty).write_str("typing.Generic")?; f.with_type(ty).write_str("typing.Generic")?;
f.write_str(&generic_context.display(self.db).to_string()) f.write_str(&generic_context.display(self.db).to_string())?;
f.write_str("'>")
} }
KnownInstanceType::TypeAliasType(alias) => { KnownInstanceType::TypeAliasType(alias) => {
if let Some(specialization) = alias.specialization(self.db) { if let Some(specialization) = alias.specialization(self.db) {
f.write_str(alias.name(self.db))?; f.set_invalid_syntax();
f.write_str("<type alias '")?;
f.with_type(ty).write_str(alias.name(self.db))?;
f.write_str( f.write_str(
&specialization &specialization
.display_short( .display_short(
@ -2191,7 +2200,8 @@ impl<'db> FmtDetailed<'db> for DisplayKnownInstanceRepr<'db> {
DisplaySettings::default(), DisplaySettings::default(),
) )
.to_string(), .to_string(),
) )?;
f.write_str("'>")
} else { } else {
f.with_type(ty).write_str("typing.TypeAliasType") f.with_type(ty).write_str("typing.TypeAliasType")
} }
@ -2201,9 +2211,9 @@ impl<'db> FmtDetailed<'db> for DisplayKnownInstanceRepr<'db> {
// have a `Type::TypeVar(_)`, which is rendered as the typevar's name. // have a `Type::TypeVar(_)`, which is rendered as the typevar's name.
KnownInstanceType::TypeVar(typevar_instance) => { KnownInstanceType::TypeVar(typevar_instance) => {
if typevar_instance.kind(self.db).is_paramspec() { if typevar_instance.kind(self.db).is_paramspec() {
f.write_str("typing.ParamSpec") f.with_type(ty).write_str("typing.ParamSpec")
} else { } else {
f.write_str("typing.TypeVar") f.with_type(ty).write_str("typing.TypeVar")
} }
} }
KnownInstanceType::Deprecated(_) => f.write_str("warnings.deprecated"), KnownInstanceType::Deprecated(_) => f.write_str("warnings.deprecated"),
@ -2226,22 +2236,56 @@ impl<'db> FmtDetailed<'db> for DisplayKnownInstanceRepr<'db> {
f.with_type(ty).write_str("ty_extensions.Specialization")?; f.with_type(ty).write_str("ty_extensions.Specialization")?;
write!(f, "{}", specialization.display_full(self.db)) write!(f, "{}", specialization.display_full(self.db))
} }
KnownInstanceType::UnionType(_) => f.with_type(ty).write_str("types.UnionType"), KnownInstanceType::UnionType(union) => {
KnownInstanceType::Literal(_) => {
f.set_invalid_syntax(); f.set_invalid_syntax();
f.write_str("<typing.Literal special form>") f.write_char('<')?;
f.with_type(ty).write_str("types.UnionType")?;
f.write_str(" special form")?;
if let Ok(ty) = union.union_type(self.db) {
write!(f, " '{}'", ty.display(self.db))?;
}
f.write_char('>')
} }
KnownInstanceType::Annotated(_) => { KnownInstanceType::Literal(inner) => {
f.set_invalid_syntax(); f.set_invalid_syntax();
f.write_str("<typing.Annotated special form>") write!(
f,
"<special form '{}'>",
inner.inner(self.db).display(self.db)
)
} }
KnownInstanceType::TypeGenericAlias(_) | KnownInstanceType::Callable(_) => { KnownInstanceType::Annotated(inner) => {
f.with_type(ty).write_str("GenericAlias") f.set_invalid_syntax();
f.write_str("<special form '")?;
f.with_type(ty).write_str("typing.Annotated")?;
write!(
f,
"[{}, <metadata>]'>",
inner.inner(self.db).display(self.db)
)
}
KnownInstanceType::Callable(callable) => {
f.set_invalid_syntax();
f.write_char('<')?;
f.with_type(ty).write_str("typing.Callable")?;
write!(f, " special form '{}'>", callable.display(self.db))
}
KnownInstanceType::TypeGenericAlias(inner) => {
f.set_invalid_syntax();
f.write_str("<special form '")?;
write!(
f.with_type(ty),
"type[{}]",
inner.inner(self.db).display(self.db)
)?;
f.write_str("'>")
} }
KnownInstanceType::LiteralStringAlias(_) => f.write_str("str"), KnownInstanceType::LiteralStringAlias(_) => f.write_str("str"),
KnownInstanceType::NewType(declaration) => { KnownInstanceType::NewType(declaration) => {
f.set_invalid_syntax(); f.set_invalid_syntax();
write!(f, "<NewType pseudo-class '{}'>", declaration.name(self.db)) f.write_str("<NewType pseudo-class '")?;
f.with_type(ty).write_str(declaration.name(self.db))?;
f.write_str("'>")
} }
} }
} }