The type of `list[int]` and `MyType[int]` should not be the same type if `MyType[T]` is a type alias

Typing
1

I’ve stumbled over this situation recently; isinstance claims that a Generic Type Alias is not a TypeAliasType when subscripted, though in practice it actually is by virtue of having all the members of a TypeAliasType.

>>> from typing import Annotated
>>> type MyInt = Annotated[int, "test"]
>>> type MyType[T] = Annotated[T, "test"]

>>> type(MyInt)
<class ‘typing.TypeAliasType’>
>>> type(MyType)
<class ‘typing.TypeAliasType’>
>>> type(MyType[int])
<class ‘types.GenericAlias’> # <----- Not a TypeAliasType
>>> type(list[int])
<class ‘types.GenericAlias’>

>>> from typing import TypeAliasType
>>> isinstance(MyInt, TypeAliasType)
True
>>> isinstance(MyType, TypeAliasType)
True
>>> isinstance(MyType[int], TypeAliasType) # <----- Not a TypeAliasType
False
>>> isinstance(list[int], TypeAliasType)
False

>>> MyInt.__value__
typing.Annotated[int, 'test']
>>> MyType.__value__
typing.Annotated[T, 'test']
>>> MyType[int].__value__
typing.Annotated[T, 'test'] # <----- Actually a TypeAliasType?
>>> list[int].__value__
Traceback (most recent call last):
  File "<python-input-28>", line 1, in <module>
    list[int].__value__
AttributeError: type object 'list' has no attribute '__value__'. Did you mean: '__le__'?

That means in practice, when analysing a Generic Type Alias, I need to work around the type-checker, because the only way to check whether something is actually a Generic Type Alias is to do this:

if isinstance(t, GenericAlias) and hasattr(t, "__value__"):
    t = cast(TypeAliasType, t)
    # Now I can work with t.__value__ or other members

I get that MyType[int] is a syntactically a GenericAlias, but semantically it’s not. It’s also in a weird limbo state because MyType[int].__value__ returns typing.Annotated[T, 'test'], meaning something like type(get_args(t.__value__)[0])) returns typing.TypeVar, which indicates that t is generic and must be made concrete by passing a type, which is wrong. It would be better if MyType[int].__value__ already returned the concrete value typing.Annotated[int, 'test'].

I’m wondering if this genuinely a bug or if I’m maybe misunderstanding something about the intent of the type system here?