feature: Support TypeAlias and ClassVar type hints

Author: NiklasRosenstein

.changelog/_unreleased.toml

@@ -0,0 +1,5 @@
+[[entries]]
+id = "0e037f5f-10c3-4e38-92c5-9bef92c74e91"
+type = "feature"
+description = "Support `TypeAlias` and `ClassVar` type hints"
+author = "@NiklasRosenstein"

src/typeapi/typehint.py

@@ -4,6 +4,7 @@
 from types import ModuleType
 from typing import (
     Any,
+    ClassVar,
     Dict,
     Generator,
     Generic,
@@ -91,6 +92,10 @@ def _make_wrapper(cls, hint: object, source: "Any | None") -> "TypeHint":
             return TypeVarTypeHint(hint, source)
         elif origin == tuple:
             return TupleTypeHint(hint, source)
+        elif origin is None and getattr(hint, "__name__") == "TypeAlias":
+            return TypeAliasTypeHint(hint, source)
+        elif origin is ClassVar or hint is ClassVar:
+            return ClassVarTypeHint(hint, source)
 
         return ClassTypeHint(hint, source)
 
@@ -486,7 +491,7 @@ def __init__(self, hint: object, source: "Any | None") -> None:
         if self._args == ((),):
             self._args = ()
         elif self._args == () and self._hint == tuple:
-            raise ValueError(f"TupleTypeHint can only represent a parameterized tuple.")
+            raise ValueError("TupleTypeHint can only represent a parameterized tuple.")
         if ... in self._args:
             assert self._args[-1] == ..., "Tuple Ellipsis not as last arg"
             assert len(self._args) == 2, "Tuple with Ellipsis has more than two args"
@@ -511,3 +516,11 @@ def repeated(self) -> bool:
         """
 
         return self._repeated
+
+
+class TypeAliasTypeHint(TypeHint):
+    pass
+
+
+class ClassVarTypeHint(TypeHint):
+    pass

src/typeapi/typehint_test.py

@@ -1,14 +1,16 @@
-from typing import Any, Dict, Generic, List, Optional, Sequence, Tuple, TypeVar, Union
+from typing import Any, ClassVar, Dict, Generic, List, Optional, Sequence, Tuple, TypeVar, Union
 
 from pytest import mark
-from typing_extensions import Annotated, Literal
+from typing_extensions import Annotated, Literal, TypeAlias
 
 from typeapi.typehint import (
     AnnotatedTypeHint,
     ClassTypeHint,
+    ClassVarTypeHint,
     ForwardRefTypeHint,
     LiteralTypeHint,
     TupleTypeHint,
+    TypeAliasTypeHint,
     TypeHint,
     TypeVarTypeHint,
     UnionTypeHint,
@@ -543,7 +545,7 @@ class D(C[T]):
     hint = TypeHint(D[int])
     assert isinstance(hint, ClassTypeHint)
     assert hint.type is D
-    assert hint.bases == (C[T],)
+    assert hint.bases == (C[T],)  # type: ignore[valid-type]
     assert list(hint.recurse_bases("bfs")) == [
         TypeHint(D[int]),
         TypeHint(C[int]),
@@ -564,19 +566,39 @@ class CustomList(List[T]):
     hint = TypeHint(CustomList)
     assert isinstance(hint, ClassTypeHint)
     assert hint.type is CustomList
-    assert hint.bases == (List[T],)
+    assert hint.bases == (List[T],)  # type: ignore[valid-type]
     assert list(hint.recurse_bases("bfs")) == [
         TypeHint(CustomList),
-        TypeHint(List[T]),
+        TypeHint(List[T]),  # type: ignore[valid-type]
         TypeHint(object),
     ]
 
     hint = TypeHint(CustomList[int])
     assert isinstance(hint, ClassTypeHint)
     assert hint.type is CustomList
-    assert hint.bases == (List[T],)
+    assert hint.bases == (List[T],)  # type: ignore[valid-type]
     assert list(hint.recurse_bases("bfs")) == [
         TypeHint(CustomList[int]),
         TypeHint(List[int]),
         TypeHint(object),
     ]
+
+
+def test__TypeHint__with_TypeAlias() -> None:
+    hint = TypeHint(TypeAlias)
+    assert isinstance(hint, TypeAliasTypeHint)
+    assert hint.hint == TypeAlias
+    assert hint.args == ()
+
+
+def test__TypeHint__with_ClassVar() -> None:
+    hint = TypeHint(ClassVar)
+    assert isinstance(hint, ClassVarTypeHint)
+    assert hint.hint == ClassVar
+    assert hint.args == ()
+
+    hint = TypeHint(ClassVar[Union[int, str]])
+    assert isinstance(hint, ClassVarTypeHint)
+    assert hint.hint == ClassVar[Union[int, str]]
+    assert hint.args == (Union[int, str],)
+    assert hint[0] == TypeHint(Union[int, str])