diff --git a/crates/ty_ide/src/inlay_hints.rs b/crates/ty_ide/src/inlay_hints.rs index fea9b2030f..c6ddf8d846 100644 --- a/crates/ty_ide/src/inlay_hints.rs +++ b/crates/ty_ide/src/inlay_hints.rs @@ -6428,11 +6428,11 @@ mod tests { a = Literal['a', 'b', 'c']", ); - assert_snapshot!(test.inlay_hints(), @r" + assert_snapshot!(test.inlay_hints(), @r#" from typing import Literal - a[: ] = Literal['a', 'b', 'c'] - "); + a[: ] = Literal['a', 'b', 'c'] + "#); } struct InlayHintLocationDiagnostic { diff --git a/crates/ty_python_semantic/resources/mdtest/annotations/any.md b/crates/ty_python_semantic/resources/mdtest/annotations/any.md index c2cc2d2461..1bdc306112 100644 --- a/crates/ty_python_semantic/resources/mdtest/annotations/any.md +++ b/crates/ty_python_semantic/resources/mdtest/annotations/any.md @@ -169,13 +169,13 @@ def f(x: Any[int]): `Any` cannot be called (this leads to a `TypeError` at runtime): ```py -Any() # error: [call-non-callable] "Object of type `typing.Any` is not callable" +Any() # error: [call-non-callable] "Object of type `` is not callable" ``` `Any` also cannot be used as a metaclass (under the hood, this leads to an implicit call to `Any`): ```py -class F(metaclass=Any): ... # error: [invalid-metaclass] "Metaclass type `typing.Any` is not callable" +class F(metaclass=Any): ... # error: [invalid-metaclass] "Metaclass type `` is not callable" ``` And `Any` cannot be used in `isinstance()` checks: diff --git a/crates/ty_python_semantic/resources/mdtest/annotations/never.md b/crates/ty_python_semantic/resources/mdtest/annotations/never.md index 81efd2d864..2cd7845771 100644 --- a/crates/ty_python_semantic/resources/mdtest/annotations/never.md +++ b/crates/ty_python_semantic/resources/mdtest/annotations/never.md @@ -59,7 +59,7 @@ python-version = "3.11" ```py from typing import Never -reveal_type(Never) # revealed: typing.Never +reveal_type(Never) # revealed: ``` ### Python 3.10 diff --git a/crates/ty_python_semantic/resources/mdtest/binary/classes.md b/crates/ty_python_semantic/resources/mdtest/binary/classes.md index db42286c84..4a3580a8de 100644 --- a/crates/ty_python_semantic/resources/mdtest/binary/classes.md +++ b/crates/ty_python_semantic/resources/mdtest/binary/classes.md @@ -13,7 +13,7 @@ python-version = "3.10" class A: ... class B: ... -reveal_type(A | B) # revealed: types.UnionType +reveal_type(A | B) # revealed: ``` ## Union of two classes (prior to 3.10) @@ -43,14 +43,14 @@ class A: ... class B: ... def _(sub_a: type[A], sub_b: type[B]): - reveal_type(A | sub_b) # revealed: types.UnionType - reveal_type(sub_a | B) # revealed: types.UnionType - reveal_type(sub_a | sub_b) # revealed: types.UnionType + reveal_type(A | sub_b) # revealed: + reveal_type(sub_a | B) # revealed: + reveal_type(sub_a | sub_b) # revealed: class C[T]: ... class D[T]: ... -reveal_type(C | D) # revealed: types.UnionType +reveal_type(C | D) # revealed: -reveal_type(C[int] | D[str]) # revealed: types.UnionType +reveal_type(C[int] | D[str]) # revealed: ``` diff --git a/crates/ty_python_semantic/resources/mdtest/class/super.md b/crates/ty_python_semantic/resources/mdtest/class/super.md index e4dd9b77bc..750f589125 100644 --- a/crates/ty_python_semantic/resources/mdtest/class/super.md +++ b/crates/ty_python_semantic/resources/mdtest/class/super.md @@ -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()`. # 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] "`` is not a valid class" reveal_type(super(typing.ChainMap, collections.ChainMap())) # revealed: Unknown # Meanwhile, it's not valid to inherit from unsubscripted `typing.Generic`, # but it *is* valid as the first argument to `super()`. -reveal_type(super(typing.Generic, typing.SupportsInt)) # revealed: > +# +# revealed: , > +reveal_type(super(typing.Generic, typing.SupportsInt)) def _(x: type[typing.Any], y: typing.Any): reveal_type(super(x, y)) # revealed: diff --git a/crates/ty_python_semantic/resources/mdtest/function/return_type.md b/crates/ty_python_semantic/resources/mdtest/function/return_type.md index b985ddfe3d..81ccb339e7 100644 --- a/crates/ty_python_semantic/resources/mdtest/function/return_type.md +++ b/crates/ty_python_semantic/resources/mdtest/function/return_type.md @@ -80,7 +80,7 @@ class Foo(Protocol): def f[T](self, v: T) -> T: ... t = (Protocol, int) -reveal_type(t[0]) # revealed: typing.Protocol +reveal_type(t[0]) # revealed: class Lorem(t[0]): def f(self) -> int: ... diff --git a/crates/ty_python_semantic/resources/mdtest/generics/pep695/aliases.md b/crates/ty_python_semantic/resources/mdtest/generics/pep695/aliases.md index 57fc838498..e10febeaeb 100644 --- a/crates/ty_python_semantic/resources/mdtest/generics/pep695/aliases.md +++ b/crates/ty_python_semantic/resources/mdtest/generics/pep695/aliases.md @@ -62,7 +62,7 @@ The specialization must match the generic types: ```py # 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: ``` And non-generic types cannot be specialized: @@ -85,19 +85,19 @@ type BoundedByUnion[T: int | str] = ... class IntSubclass(int): ... -reveal_type(Bounded[int]) # revealed: Bounded[int] -reveal_type(Bounded[IntSubclass]) # revealed: Bounded[IntSubclass] +reveal_type(Bounded[int]) # revealed: +reveal_type(Bounded[IntSubclass]) # revealed: # 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: # 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: -reveal_type(BoundedByUnion[int]) # revealed: BoundedByUnion[int] -reveal_type(BoundedByUnion[IntSubclass]) # revealed: BoundedByUnion[IntSubclass] -reveal_type(BoundedByUnion[str]) # revealed: BoundedByUnion[str] -reveal_type(BoundedByUnion[int | str]) # revealed: BoundedByUnion[int | str] +reveal_type(BoundedByUnion[int]) # revealed: +reveal_type(BoundedByUnion[IntSubclass]) # revealed: +reveal_type(BoundedByUnion[str]) # revealed: +reveal_type(BoundedByUnion[int | str]) # revealed: ``` 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 type Constrained[T: (int, str)] = ... -reveal_type(Constrained[int]) # revealed: Constrained[int] +reveal_type(Constrained[int]) # revealed: # TODO: error: [invalid-argument-type] # TODO: revealed: Constrained[Unknown] -reveal_type(Constrained[IntSubclass]) # revealed: Constrained[IntSubclass] +reveal_type(Constrained[IntSubclass]) # revealed: -reveal_type(Constrained[str]) # revealed: Constrained[str] +reveal_type(Constrained[str]) # revealed: # TODO: error: [invalid-argument-type] # TODO: revealed: Unknown -reveal_type(Constrained[int | str]) # revealed: Constrained[int | str] +reveal_type(Constrained[int | str]) # revealed: # 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: ``` 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 type WithDefault[T, U = int] = ... -reveal_type(WithDefault[str, str]) # revealed: WithDefault[str, str] -reveal_type(WithDefault[str]) # revealed: WithDefault[str, int] +reveal_type(WithDefault[str, str]) # revealed: +reveal_type(WithDefault[str]) # revealed: ``` If the type alias is not specialized explicitly, it is implicitly specialized to `Unknown`: diff --git a/crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md b/crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md index ed73c9323b..d0836559f3 100644 --- a/crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md +++ b/crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md @@ -77,44 +77,44 @@ IntOrTypeVar = int | T TypeVarOrNone = T | None NoneOrTypeVar = None | T -reveal_type(IntOrStr) # revealed: types.UnionType -reveal_type(IntOrStrOrBytes1) # revealed: types.UnionType -reveal_type(IntOrStrOrBytes2) # revealed: types.UnionType -reveal_type(IntOrStrOrBytes3) # revealed: types.UnionType -reveal_type(IntOrStrOrBytes4) # revealed: types.UnionType -reveal_type(IntOrStrOrBytes5) # revealed: types.UnionType -reveal_type(IntOrStrOrBytes6) # revealed: types.UnionType -reveal_type(BytesOrIntOrStr) # revealed: types.UnionType -reveal_type(IntOrNone) # revealed: types.UnionType -reveal_type(NoneOrInt) # revealed: types.UnionType -reveal_type(IntOrStrOrNone) # revealed: types.UnionType -reveal_type(NoneOrIntOrStr) # revealed: types.UnionType -reveal_type(IntOrAny) # revealed: types.UnionType -reveal_type(AnyOrInt) # revealed: types.UnionType -reveal_type(NoneOrAny) # revealed: types.UnionType -reveal_type(AnyOrNone) # revealed: types.UnionType -reveal_type(NeverOrAny) # revealed: types.UnionType -reveal_type(AnyOrNever) # revealed: types.UnionType -reveal_type(UnknownOrInt) # revealed: types.UnionType -reveal_type(IntOrUnknown) # revealed: types.UnionType -reveal_type(StrOrZero) # revealed: types.UnionType -reveal_type(ZeroOrStr) # revealed: types.UnionType -reveal_type(IntOrLiteralString) # revealed: types.UnionType -reveal_type(LiteralStringOrInt) # revealed: types.UnionType -reveal_type(NoneOrTuple) # revealed: types.UnionType -reveal_type(TupleOrNone) # revealed: types.UnionType -reveal_type(IntOrAnnotated) # revealed: types.UnionType -reveal_type(AnnotatedOrInt) # revealed: types.UnionType -reveal_type(IntOrOptional) # revealed: types.UnionType -reveal_type(OptionalOrInt) # revealed: types.UnionType -reveal_type(IntOrTypeOfStr) # revealed: types.UnionType -reveal_type(TypeOfStrOrInt) # revealed: types.UnionType -reveal_type(IntOrCallable) # revealed: types.UnionType -reveal_type(CallableOrInt) # revealed: types.UnionType -reveal_type(TypeVarOrInt) # revealed: types.UnionType -reveal_type(IntOrTypeVar) # revealed: types.UnionType -reveal_type(TypeVarOrNone) # revealed: types.UnionType -reveal_type(NoneOrTypeVar) # revealed: types.UnionType +reveal_type(IntOrStr) # revealed: +reveal_type(IntOrStrOrBytes1) # revealed: +reveal_type(IntOrStrOrBytes2) # revealed: +reveal_type(IntOrStrOrBytes3) # revealed: +reveal_type(IntOrStrOrBytes4) # revealed: +reveal_type(IntOrStrOrBytes5) # revealed: +reveal_type(IntOrStrOrBytes6) # revealed: +reveal_type(BytesOrIntOrStr) # revealed: +reveal_type(IntOrNone) # revealed: +reveal_type(NoneOrInt) # revealed: +reveal_type(IntOrStrOrNone) # revealed: +reveal_type(NoneOrIntOrStr) # revealed: +reveal_type(IntOrAny) # revealed: +reveal_type(AnyOrInt) # revealed: +reveal_type(NoneOrAny) # revealed: +reveal_type(AnyOrNone) # revealed: +reveal_type(NeverOrAny) # revealed: +reveal_type(AnyOrNever) # revealed: +reveal_type(UnknownOrInt) # revealed: +reveal_type(IntOrUnknown) # revealed: +reveal_type(StrOrZero) # revealed: +reveal_type(ZeroOrStr) # revealed: +reveal_type(IntOrLiteralString) # revealed: +reveal_type(LiteralStringOrInt) # revealed: +reveal_type(NoneOrTuple) # revealed: +reveal_type(TupleOrNone) # revealed: +reveal_type(IntOrAnnotated) # revealed: +reveal_type(AnnotatedOrInt) # revealed: +reveal_type(IntOrOptional) # revealed: +reveal_type(OptionalOrInt) # revealed: +reveal_type(IntOrTypeOfStr) # revealed: +reveal_type(TypeOfStrOrInt) # revealed: +reveal_type(IntOrCallable) # revealed: bytes)'> +reveal_type(CallableOrInt) # revealed: bytes) | int'> +reveal_type(TypeVarOrInt) # revealed: +reveal_type(IntOrTypeVar) # revealed: +reveal_type(TypeVarOrNone) # revealed: +reveal_type(NoneOrTypeVar) # revealed: def _( 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`? # But we still need to record what the elements are, since (according to the typing spec) # `X` is still a valid type alias -reveal_type(X) # revealed: types.UnionType +reveal_type(X) # revealed: def f(obj: X): reveal_type(obj) # revealed: Foo | Bar @@ -391,16 +391,17 @@ MyOptional = T | None reveal_type(MyList) # revealed: reveal_type(MyDict) # revealed: -reveal_type(MyType) # revealed: GenericAlias +reveal_type(MyType) # revealed: reveal_type(IntAndType) # revealed: reveal_type(Pair) # revealed: reveal_type(Sum) # revealed: -reveal_type(ListOrTuple) # revealed: types.UnionType -reveal_type(ListOrTupleLegacy) # revealed: types.UnionType +reveal_type(ListOrTuple) # revealed: +# revealed: +reveal_type(ListOrTupleLegacy) reveal_type(MyCallable) # revealed: @Todo(Callable[..] specialized with ParamSpec) -reveal_type(AnnotatedType) # revealed: +reveal_type(AnnotatedType) # revealed: ]'> reveal_type(TransparentAlias) # revealed: typing.TypeVar -reveal_type(MyOptional) # revealed: types.UnionType +reveal_type(MyOptional) # revealed: def _( list_of_ints: MyList[int], @@ -456,12 +457,12 @@ AnnotatedInt = AnnotatedType[int] SubclassOfInt = MyType[int] CallableIntToStr = MyCallable[[int], str] -reveal_type(IntsOrNone) # revealed: types.UnionType -reveal_type(IntsOrStrs) # revealed: types.UnionType +reveal_type(IntsOrNone) # revealed: +reveal_type(IntsOrStrs) # revealed: reveal_type(ListOfPairs) # revealed: -reveal_type(ListOrTupleOfInts) # revealed: types.UnionType -reveal_type(AnnotatedInt) # revealed: -reveal_type(SubclassOfInt) # revealed: GenericAlias +reveal_type(ListOrTupleOfInts) # revealed: +reveal_type(AnnotatedInt) # revealed: ]'> +reveal_type(SubclassOfInt) # revealed: reveal_type(CallableIntToStr) # revealed: @Todo(Callable[..] specialized with ParamSpec) def _( @@ -495,8 +496,8 @@ MyOtherType = MyType[T] TypeOrList = MyType[B] | MyList[B] reveal_type(MyOtherList) # revealed: -reveal_type(MyOtherType) # revealed: GenericAlias -reveal_type(TypeOrList) # revealed: types.UnionType +reveal_type(MyOtherType) # revealed: +reveal_type(TypeOrList) # revealed: def _( list_of_ints: MyOtherList[int], @@ -898,7 +899,7 @@ from typing import Optional MyOptionalInt = Optional[int] -reveal_type(MyOptionalInt) # revealed: types.UnionType +reveal_type(MyOptionalInt) # revealed: def _(optional_int: MyOptionalInt): reveal_type(optional_int) # revealed: int | None @@ -931,9 +932,9 @@ MyLiteralString = LiteralString MyNoReturn = NoReturn MyNever = Never -reveal_type(MyLiteralString) # revealed: typing.LiteralString -reveal_type(MyNoReturn) # revealed: typing.NoReturn -reveal_type(MyNever) # revealed: typing.Never +reveal_type(MyLiteralString) # revealed: +reveal_type(MyNoReturn) # revealed: +reveal_type(MyNever) # revealed: def _( ls: MyLiteralString, @@ -986,8 +987,8 @@ from typing import Union IntOrStr = Union[int, str] IntOrStrOrBytes = Union[int, Union[str, bytes]] -reveal_type(IntOrStr) # revealed: types.UnionType -reveal_type(IntOrStrOrBytes) # revealed: types.UnionType +reveal_type(IntOrStr) # revealed: +reveal_type(IntOrStrOrBytes) # revealed: def _( 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" EmptyUnion = Union[()] -reveal_type(EmptyUnion) # revealed: types.UnionType +reveal_type(EmptyUnion) # revealed: def _(empty: EmptyUnion): reveal_type(empty) # revealed: Never @@ -1060,14 +1061,14 @@ SubclassOfG = type[G] SubclassOfGInt = type[G[int]] SubclassOfP = type[P] -reveal_type(SubclassOfA) # revealed: GenericAlias -reveal_type(SubclassOfAny) # revealed: GenericAlias -reveal_type(SubclassOfAOrB1) # revealed: GenericAlias -reveal_type(SubclassOfAOrB2) # revealed: types.UnionType -reveal_type(SubclassOfAOrB3) # revealed: types.UnionType -reveal_type(SubclassOfG) # revealed: GenericAlias -reveal_type(SubclassOfGInt) # revealed: GenericAlias -reveal_type(SubclassOfP) # revealed: GenericAlias +reveal_type(SubclassOfA) # revealed: +reveal_type(SubclassOfAny) # revealed: +reveal_type(SubclassOfAOrB1) # revealed: +reveal_type(SubclassOfAOrB2) # revealed: +reveal_type(SubclassOfAOrB3) # revealed: +reveal_type(SubclassOfG) # revealed: +reveal_type(SubclassOfGInt) # revealed: +reveal_type(SubclassOfP) # revealed: def _( subclass_of_a: SubclassOfA, @@ -1148,14 +1149,14 @@ SubclassOfG = Type[G] SubclassOfGInt = Type[G[int]] SubclassOfP = Type[P] -reveal_type(SubclassOfA) # revealed: GenericAlias -reveal_type(SubclassOfAny) # revealed: GenericAlias -reveal_type(SubclassOfAOrB1) # revealed: GenericAlias -reveal_type(SubclassOfAOrB2) # revealed: types.UnionType -reveal_type(SubclassOfAOrB3) # revealed: types.UnionType -reveal_type(SubclassOfG) # revealed: GenericAlias -reveal_type(SubclassOfGInt) # revealed: GenericAlias -reveal_type(SubclassOfP) # revealed: GenericAlias +reveal_type(SubclassOfA) # revealed: +reveal_type(SubclassOfAny) # revealed: +reveal_type(SubclassOfAOrB1) # revealed: +reveal_type(SubclassOfAOrB2) # revealed: +reveal_type(SubclassOfAOrB3) # revealed: +reveal_type(SubclassOfG) # revealed: +reveal_type(SubclassOfGInt) # revealed: +reveal_type(SubclassOfP) # revealed: def _( subclass_of_a: SubclassOfA, @@ -1270,25 +1271,25 @@ DefaultDictOrNone = DefaultDict[str, int] | None DequeOrNone = Deque[str] | None OrderedDictOrNone = OrderedDict[str, int] | None -reveal_type(NoneOrList) # revealed: types.UnionType -reveal_type(NoneOrSet) # revealed: types.UnionType -reveal_type(NoneOrDict) # revealed: types.UnionType -reveal_type(NoneOrFrozenSet) # revealed: types.UnionType -reveal_type(NoneOrChainMap) # revealed: types.UnionType -reveal_type(NoneOrCounter) # revealed: types.UnionType -reveal_type(NoneOrDefaultDict) # revealed: types.UnionType -reveal_type(NoneOrDeque) # revealed: types.UnionType -reveal_type(NoneOrOrderedDict) # revealed: types.UnionType +reveal_type(NoneOrList) # revealed: +reveal_type(NoneOrSet) # revealed: +reveal_type(NoneOrDict) # revealed: +reveal_type(NoneOrFrozenSet) # revealed: +reveal_type(NoneOrChainMap) # revealed: +reveal_type(NoneOrCounter) # revealed: +reveal_type(NoneOrDefaultDict) # revealed: +reveal_type(NoneOrDeque) # revealed: +reveal_type(NoneOrOrderedDict) # revealed: -reveal_type(ListOrNone) # revealed: types.UnionType -reveal_type(SetOrNone) # revealed: types.UnionType -reveal_type(DictOrNone) # revealed: types.UnionType -reveal_type(FrozenSetOrNone) # revealed: types.UnionType -reveal_type(ChainMapOrNone) # revealed: types.UnionType -reveal_type(CounterOrNone) # revealed: types.UnionType -reveal_type(DefaultDictOrNone) # revealed: types.UnionType -reveal_type(DequeOrNone) # revealed: types.UnionType -reveal_type(OrderedDictOrNone) # revealed: types.UnionType +reveal_type(ListOrNone) # revealed: +reveal_type(SetOrNone) # revealed: +reveal_type(DictOrNone) # revealed: +reveal_type(FrozenSetOrNone) # revealed: +reveal_type(ChainMapOrNone) # revealed: +reveal_type(CounterOrNone) # revealed: +reveal_type(DefaultDictOrNone) # revealed: +reveal_type(DequeOrNone) # revealed: +reveal_type(OrderedDictOrNone) # revealed: def _( none_or_list: NoneOrList, @@ -1381,9 +1382,9 @@ CallableNoArgs = Callable[[], None] BasicCallable = Callable[[int, str], bytes] GradualCallable = Callable[..., str] -reveal_type(CallableNoArgs) # revealed: GenericAlias -reveal_type(BasicCallable) # revealed: GenericAlias -reveal_type(GradualCallable) # revealed: GenericAlias +reveal_type(CallableNoArgs) # revealed: None'> +reveal_type(BasicCallable) # revealed: bytes'> +reveal_type(GradualCallable) # revealed: str'> def _( 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 `...`" InvalidCallable2 = Callable[int, str] -reveal_type(InvalidCallable1) # revealed: GenericAlias -reveal_type(InvalidCallable2) # revealed: GenericAlias +reveal_type(InvalidCallable1) # revealed: Unknown'> +reveal_type(InvalidCallable2) # revealed: Unknown'> def _(invalid_callable1: InvalidCallable1, invalid_callable2: InvalidCallable2): reveal_type(invalid_callable1) # revealed: (...) -> Unknown diff --git a/crates/ty_python_semantic/resources/mdtest/import/conventions.md b/crates/ty_python_semantic/resources/mdtest/import/conventions.md index 48d93515a8..28ea0b4bc2 100644 --- a/crates/ty_python_semantic/resources/mdtest/import/conventions.md +++ b/crates/ty_python_semantic/resources/mdtest/import/conventions.md @@ -53,8 +53,8 @@ in `import os.path as os.path` the `os.path` is not a valid identifier. ```py from b import Any, Literal, foo -reveal_type(Any) # revealed: typing.Any -reveal_type(Literal) # revealed: typing.Literal +reveal_type(Any) # revealed: +reveal_type(Literal) # revealed: reveal_type(foo) # revealed: ``` @@ -132,7 +132,7 @@ reveal_type(Any) # revealed: Unknown ```pyi from typing import Any -reveal_type(Any) # revealed: typing.Any +reveal_type(Any) # revealed: ``` ## Nested mixed re-export and not @@ -169,7 +169,7 @@ reveal_type(Any) # revealed: Unknown ```pyi from typing import Any -reveal_type(Any) # revealed: typing.Any +reveal_type(Any) # revealed: ``` ## Exported as different name diff --git a/crates/ty_python_semantic/resources/mdtest/import/star.md b/crates/ty_python_semantic/resources/mdtest/import/star.md index 14cff45efc..a60c0062b1 100644 --- a/crates/ty_python_semantic/resources/mdtest/import/star.md +++ b/crates/ty_python_semantic/resources/mdtest/import/star.md @@ -1437,7 +1437,7 @@ are present due to `*` imports. import collections.abc reveal_type(collections.abc.Sequence) # revealed: -reveal_type(collections.abc.Callable) # revealed: typing.Callable +reveal_type(collections.abc.Callable) # revealed: reveal_type(collections.abc.Set) # revealed: ``` diff --git a/crates/ty_python_semantic/resources/mdtest/mro.md b/crates/ty_python_semantic/resources/mdtest/mro.md index b158cbb62b..da57d7f9a7 100644 --- a/crates/ty_python_semantic/resources/mdtest/mro.md +++ b/crates/ty_python_semantic/resources/mdtest/mro.md @@ -301,7 +301,7 @@ class B: ... EitherOr = A | B -# error: [invalid-base] "Invalid class base with type `types.UnionType`" +# error: [invalid-base] "Invalid class base with type ``" class Foo(EitherOr): ... ``` diff --git a/crates/ty_python_semantic/resources/mdtest/narrow/isinstance.md b/crates/ty_python_semantic/resources/mdtest/narrow/isinstance.md index 6e712b3e71..68562e06ad 100644 --- a/crates/ty_python_semantic/resources/mdtest/narrow/isinstance.md +++ b/crates/ty_python_semantic/resources/mdtest/narrow/isinstance.md @@ -156,7 +156,7 @@ from typing import Union IntOrStr = Union[int, str] -reveal_type(IntOrStr) # revealed: types.UnionType +reveal_type(IntOrStr) # revealed: def _(x: int | str | bytes | memoryview | range): if isinstance(x, IntOrStr): diff --git a/crates/ty_python_semantic/resources/mdtest/narrow/issubclass.md b/crates/ty_python_semantic/resources/mdtest/narrow/issubclass.md index 52fcb6dfb5..ed9964274a 100644 --- a/crates/ty_python_semantic/resources/mdtest/narrow/issubclass.md +++ b/crates/ty_python_semantic/resources/mdtest/narrow/issubclass.md @@ -209,7 +209,7 @@ from typing import Union IntOrStr = Union[int, str] -reveal_type(IntOrStr) # revealed: types.UnionType +reveal_type(IntOrStr) # revealed: def f(x: type[int | str | bytes | range]): if issubclass(x, IntOrStr): diff --git a/crates/ty_python_semantic/resources/mdtest/pep613_type_aliases.md b/crates/ty_python_semantic/resources/mdtest/pep613_type_aliases.md index c41b88b3b1..69f92dda94 100644 --- a/crates/ty_python_semantic/resources/mdtest/pep613_type_aliases.md +++ b/crates/ty_python_semantic/resources/mdtest/pep613_type_aliases.md @@ -113,7 +113,7 @@ MyList: TypeAlias = list[T] ListOrSet: TypeAlias = list[T] | set[T] reveal_type(MyList) # revealed: -reveal_type(ListOrSet) # revealed: types.UnionType +reveal_type(ListOrSet) # revealed: def _(list_of_int: MyList[int], list_or_set_of_str: ListOrSet[str]): reveal_type(list_of_int) # revealed: list[int] @@ -293,7 +293,7 @@ def _(rec: RecursiveHomogeneousTuple): reveal_type(rec) # revealed: tuple[Divergent, ...] ClassInfo: TypeAlias = type | UnionType | tuple["ClassInfo", ...] -reveal_type(ClassInfo) # revealed: types.UnionType +reveal_type(ClassInfo) # revealed: def my_isinstance(obj: object, classinfo: ClassInfo) -> bool: # TODO should be `type | UnionType | tuple[ClassInfo, ...]` diff --git a/crates/ty_python_semantic/resources/mdtest/snapshots/isinstance.md_-_Narrowing_for_`isins…_-_`classinfo`_is_an_in…_(eeef56c0ef87a30b).snap b/crates/ty_python_semantic/resources/mdtest/snapshots/isinstance.md_-_Narrowing_for_`isins…_-_`classinfo`_is_an_in…_(eeef56c0ef87a30b).snap index 822f9319a1..195610b255 100644 --- a/crates/ty_python_semantic/resources/mdtest/snapshots/isinstance.md_-_Narrowing_for_`isins…_-_`classinfo`_is_an_in…_(eeef56c0ef87a30b).snap +++ b/crates/ty_python_semantic/resources/mdtest/snapshots/isinstance.md_-_Narrowing_for_`isins…_-_`classinfo`_is_an_in…_(eeef56c0ef87a30b).snap @@ -63,7 +63,7 @@ error[invalid-argument-type]: Invalid second argument to `isinstance` 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: Elements `` and `` in the union are not class objects +info: Elements `` and `` in the union are not class objects info: rule `invalid-argument-type` is enabled by default ``` @@ -82,7 +82,7 @@ error[invalid-argument-type]: Invalid second argument to `isinstance` 13 | else: | 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 `` in the union, and 2 more elements, are not class objects info: rule `invalid-argument-type` is enabled by default ``` diff --git a/crates/ty_python_semantic/resources/mdtest/snapshots/mro.md_-_Method_Resolution_Or…_-_Unresolvable_MROs_in…_(e2b355c09a967862).snap b/crates/ty_python_semantic/resources/mdtest/snapshots/mro.md_-_Method_Resolution_Or…_-_Unresolvable_MROs_in…_(e2b355c09a967862).snap index c7590f4255..42e41b6e87 100644 --- a/crates/ty_python_semantic/resources/mdtest/snapshots/mro.md_-_Method_Resolution_Or…_-_Unresolvable_MROs_in…_(e2b355c09a967862).snap +++ b/crates/ty_python_semantic/resources/mdtest/snapshots/mro.md_-_Method_Resolution_Or…_-_Unresolvable_MROs_in…_(e2b355c09a967862).snap @@ -24,7 +24,7 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/mro.md # Diagnostics ``` -error[inconsistent-mro]: Cannot create a consistent method resolution order (MRO) for class `Baz` with bases list `[typing.Protocol[T], , ]` +error[inconsistent-mro]: Cannot create a consistent method resolution order (MRO) for class `Baz` with bases list `[, , ]` --> src/mdtest_snippet.py:7:1 | 5 | class Foo(Protocol): ... diff --git a/crates/ty_python_semantic/resources/mdtest/snapshots/protocols.md_-_Protocols_-_Calls_to_protocol_cl…_(288988036f34ddcf).snap b/crates/ty_python_semantic/resources/mdtest/snapshots/protocols.md_-_Protocols_-_Calls_to_protocol_cl…_(288988036f34ddcf).snap index 4e18a85fd6..57bedf5797 100644 --- a/crates/ty_python_semantic/resources/mdtest/snapshots/protocols.md_-_Protocols_-_Calls_to_protocol_cl…_(288988036f34ddcf).snap +++ b/crates/ty_python_semantic/resources/mdtest/snapshots/protocols.md_-_Protocols_-_Calls_to_protocol_cl…_(288988036f34ddcf).snap @@ -42,7 +42,7 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/protocols.md # Diagnostics ``` -error[call-non-callable]: Object of type `typing.Protocol` is not callable +error[call-non-callable]: Object of type `` is not callable --> src/mdtest_snippet.py:4:13 | 3 | # error: [call-non-callable] diff --git a/crates/ty_python_semantic/src/types.rs b/crates/ty_python_semantic/src/types.rs index b1cfc9d3c9..81d056f91a 100644 --- a/crates/ty_python_semantic/src/types.rs +++ b/crates/ty_python_semantic/src/types.rs @@ -7331,7 +7331,7 @@ impl<'db> Type<'db> { | SpecialFormType::Union | SpecialFormType::Intersection => Err(InvalidTypeExpressionError { invalid_expressions: smallvec::smallvec_inline![ - InvalidTypeExpression::RequiresArguments(*self) + InvalidTypeExpression::RequiresArguments(*special_form) ], fallback_type: Type::unknown(), }), @@ -7357,7 +7357,7 @@ impl<'db> Type<'db> { | SpecialFormType::Unpack | SpecialFormType::CallableTypeOf => Err(InvalidTypeExpressionError { invalid_expressions: smallvec::smallvec_inline![ - InvalidTypeExpression::RequiresOneArgument(*self) + InvalidTypeExpression::RequiresOneArgument(*special_form) ], fallback_type: Type::unknown(), }), @@ -7365,7 +7365,7 @@ impl<'db> Type<'db> { SpecialFormType::Annotated | SpecialFormType::Concatenate => { Err(InvalidTypeExpressionError { invalid_expressions: smallvec::smallvec_inline![ - InvalidTypeExpression::RequiresTwoArguments(*self) + InvalidTypeExpression::RequiresTwoArguments(*special_form) ], fallback_type: Type::unknown(), }) @@ -9087,11 +9087,11 @@ impl<'db> InvalidTypeExpressionError<'db> { #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, get_size2::GetSize)] enum InvalidTypeExpression<'db> { /// 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 - RequiresArguments(Type<'db>), + RequiresArguments(SpecialFormType), /// 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 Protocol, /// Same for `Generic` @@ -9131,20 +9131,17 @@ impl<'db> InvalidTypeExpression<'db> { impl std::fmt::Display for Display<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self.error { - InvalidTypeExpression::RequiresOneArgument(ty) => write!( + InvalidTypeExpression::RequiresOneArgument(special_form) => write!( f, - "`{ty}` requires exactly one argument when used in a type expression", - ty = ty.display(self.db) + "`{special_form}` requires exactly one argument when used in a type expression", ), - InvalidTypeExpression::RequiresArguments(ty) => write!( + InvalidTypeExpression::RequiresArguments(special_form) => write!( f, - "`{ty}` requires at least one argument when used in a type expression", - ty = ty.display(self.db) + "`{special_form}` requires at least one argument when used in a type expression", ), - InvalidTypeExpression::RequiresTwoArguments(ty) => write!( + InvalidTypeExpression::RequiresTwoArguments(special_form) => write!( f, - "`{ty}` requires at least two arguments when used in a type expression", - ty = ty.display(self.db) + "`{special_form}` requires at least two arguments when used in a type expression", ), InvalidTypeExpression::Protocol => { f.write_str("`typing.Protocol` is not allowed in type expressions") diff --git a/crates/ty_python_semantic/src/types/diagnostic.rs b/crates/ty_python_semantic/src/types/diagnostic.rs index d72cbf8dbc..2706787998 100644 --- a/crates/ty_python_semantic/src/types/diagnostic.rs +++ b/crates/ty_python_semantic/src/types/diagnostic.rs @@ -2998,11 +2998,10 @@ pub(crate) fn report_invalid_arguments_to_annotated( let Some(builder) = context.report_lint(&INVALID_TYPE_FORM, subscript) else { return; }; - builder.into_diagnostic(format_args!( - "Special form `{}` expected at least 2 arguments \ + builder.into_diagnostic( + "Special form `typing.Annotated` expected at least 2 arguments \ (one type and at least one metadata element)", - SpecialFormType::Annotated - )); + ); } pub(crate) fn report_invalid_argument_number_to_special_form( @@ -3103,8 +3102,7 @@ pub(crate) fn report_invalid_arguments_to_callable( return; }; builder.into_diagnostic(format_args!( - "Special form `{}` expected exactly two arguments (parameter types and return type)", - SpecialFormType::Callable + "Special form `typing.Callable` expected exactly two arguments (parameter types and return type)", )); } diff --git a/crates/ty_python_semantic/src/types/display.rs b/crates/ty_python_semantic/src/types/display.rs index cadd54eef1..95ee3ad748 100644 --- a/crates/ty_python_semantic/src/types/display.rs +++ b/crates/ty_python_semantic/src/types/display.rs @@ -696,7 +696,8 @@ impl<'db> FmtDetailed<'db> for DisplayRepresentation<'db> { ), }, Type::SpecialForm(special_form) => { - write!(f.with_type(self.ty), "{special_form}") + f.set_invalid_syntax(); + write!(f.with_type(self.ty), "") } Type::KnownInstance(known_instance) => known_instance .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); match self.known_instance { KnownInstanceType::SubscriptedProtocol(generic_context) => { + f.set_invalid_syntax(); + f.write_str("") } KnownInstanceType::SubscriptedGeneric(generic_context) => { + f.set_invalid_syntax(); + f.write_str("") } KnownInstanceType::TypeAliasType(alias) => { if let Some(specialization) = alias.specialization(self.db) { - f.write_str(alias.name(self.db))?; + f.set_invalid_syntax(); + f.write_str(" FmtDetailed<'db> for DisplayKnownInstanceRepr<'db> { DisplaySettings::default(), ) .to_string(), - ) + )?; + f.write_str("'>") } else { 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. KnownInstanceType::TypeVar(typevar_instance) => { if typevar_instance.kind(self.db).is_paramspec() { - f.write_str("typing.ParamSpec") + f.with_type(ty).write_str("typing.ParamSpec") } else { - f.write_str("typing.TypeVar") + f.with_type(ty).write_str("typing.TypeVar") } } 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")?; write!(f, "{}", specialization.display_full(self.db)) } - KnownInstanceType::UnionType(_) => f.with_type(ty).write_str("types.UnionType"), - KnownInstanceType::Literal(_) => { + KnownInstanceType::UnionType(union) => { f.set_invalid_syntax(); - f.write_str("") + 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.write_str("") + write!( + f, + "", + inner.inner(self.db).display(self.db) + ) } - KnownInstanceType::TypeGenericAlias(_) | KnownInstanceType::Callable(_) => { - f.with_type(ty).write_str("GenericAlias") + KnownInstanceType::Annotated(inner) => { + f.set_invalid_syntax(); + f.write_str("]'>", + 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("") } KnownInstanceType::LiteralStringAlias(_) => f.write_str("str"), KnownInstanceType::NewType(declaration) => { f.set_invalid_syntax(); - write!(f, "", declaration.name(self.db)) + f.write_str("") } } }