tpy-lang 0.3.0.dev0__py3-none-any.whl

tpyc/_data/lib/tpy/tpy/_typing/__init__.py

@@ -0,0 +1,77 @@
+# tpy: cpp_namespace("tpystd::typing")
+from tpy import Int32
+from .._bootstrap._decorators import readonly
+from .._bootstrap._extern import builtin_type, builtin_decorator, builtin_function
+
+
+@builtin_type("typing.Protocol")
+class Protocol: ...
+
+@builtin_type("typing.Self")
+class Self: ...
+
+@builtin_type("typing.Optional")
+class Optional: ...
+
+@builtin_type("typing.Any")
+class Any:
+    """Type-erased value cell. Holds any concrete copyable value.
+    Use `typing.cast(T, x)` or `isinstance(x, T)` to extract."""
+
+@builtin_type("typing.Final")
+class Final: ...
+
+@builtin_type("typing.ClassVar")
+class ClassVar: ...
+
+@builtin_type("typing.Callable")
+class Callable: ...
+
+@builtin_type("typing.Literal")
+class Literal: ...
+
+@builtin_type("typing.TypedDict")
+class TypedDict: ...
+
+@builtin_type("typing.Unpack")
+class Unpack: ...
+
+@builtin_decorator("typing.overload")
+def overload(): ...
+
+@builtin_decorator("typing.override")
+def override(): ...
+
+# typing.cast(T, x): static-only no-op in CPython; in TPy compiled
+# binaries this gets runtime panic-on-mismatch semantics when the source
+# is Any. Signature is illustrative; sema/codegen handle this specially.
+@builtin_function("typing.cast")
+def cast(target_type, value): ...
+
+
+class Sized(Protocol):
+    @readonly
+    def __len__(self) -> Int32: ...
+
+
+class Sequence[T](Protocol):
+    @readonly
+    def __len__(self) -> Int32: ...
+    @readonly
+    def __getitem__(self, index: Int32) -> T: ...
+
+
+class MutableSequence[T](Protocol):
+    @readonly
+    def __len__(self) -> Int32: ...
+    def __getitem__(self, index: Int32) -> T: ...
+    def __setitem__(self, index: Int32, value: T) -> None: ...
+
+
+class Iterator[T](Protocol):
+    def __next__(self) -> T: ...
+    def __iter__(self) -> Self: ...
+
+
+class Iterable[T](Protocol):
+    def __iter__(self) -> Iterator[T]: ...

tpyc/_data/lib/tpy/tpy/_version.py

@@ -0,0 +1,29 @@
+# tpy: macro_module
+"""Compile-time macros exposing the tpyc compiler version to user code.
+
+Consumed by tpy/version.py to initialise tpy.version.__version__ and
+tpy.version.version_info. Each macro runs during compilation (via the
+macro loader running on CPython) and emits a literal expression that
+the compiler splices into the generated C++ as a constant.
+"""
+
+from tpyc.macro_api import (
+    __version__ as _v, VERSION_INFO as _vi,
+    CallMacroContext, Expr, call_macro, ast,
+)
+
+
+@call_macro
+def version(ctx: CallMacroContext) -> Expr:
+    return ast.str_lit(_v)
+
+
+@call_macro
+def version_info(ctx: CallMacroContext) -> Expr:
+    return ast.tuple_lit([
+        ast.int_lit(_vi[0]),
+        ast.int_lit(_vi[1]),
+        ast.int_lit(_vi[2]),
+        ast.str_lit(_vi[3]),
+        ast.int_lit(_vi[4]),
+    ])

tpyc/_data/lib/tpy/tpy/bits.py

@@ -0,0 +1,28 @@
+# tpy.bits -- bit manipulation primitives for fixed-width integers.
+#
+# Wraps C++20 <bit> (std::rotl/std::rotr) and C++23 <bit> (std::byteswap).
+# Rotations don't lose bits by construction; byteswap is endianness-neutral.
+# Use these instead of hand-rolled `(x << n) | (x >> (w-n))` which would
+# trip TPy's overflow-checked left shift.
+# tpy: native_module
+# tpy: cpp_namespace("tpy::bits")
+from tpy.extern import cpp_template
+from tpy import Int32, UInt32, UInt64
+
+@cpp_template("std::rotl<uint32_t>({0}, {1})")
+def rotl32(x: UInt32, n: Int32) -> UInt32: ...
+
+@cpp_template("std::rotr<uint32_t>({0}, {1})")
+def rotr32(x: UInt32, n: Int32) -> UInt32: ...
+
+@cpp_template("std::rotl<uint64_t>({0}, {1})")
+def rotl64(x: UInt64, n: Int32) -> UInt64: ...
+
+@cpp_template("std::rotr<uint64_t>({0}, {1})")
+def rotr64(x: UInt64, n: Int32) -> UInt64: ...
+
+@cpp_template("std::byteswap<uint32_t>({0})")
+def byteswap32(x: UInt32) -> UInt32: ...
+
+@cpp_template("std::byteswap<uint64_t>({0})")
+def byteswap64(x: UInt64) -> UInt64: ...

tpyc/_data/lib/tpy/tpy/coro/__init__.py

@@ -0,0 +1,127 @@
+# tpy: cpp_namespace("tpystd::coro")
+"""Coroutine / async runtime primitives.
+
+Module name borrowed from the design-doc's `Coroutine[T]` terminology
+(see Rust `std::task` / Tokio `tokio::task` for prior art).
+"""
+from .._typing import Protocol
+from .._bootstrap._decorators import Own, dynamic
+from .._bootstrap._extern import builtin_type
+from .._builtins._exceptions import CancelledError
+from .._core import Poll, Ptr, ValueType, Int32
+
+
+# The dispatch target for `Waker.wake()`. `asyncio.Executor` inherits
+# this protocol; Waker holds a `Ptr[Awaker]` to the running executor and
+# calls `mark_runnable` through the @dynamic vtable. The only concrete
+# implementer today lives in `asyncio._executor`.
+#
+# `register_timer(deadline, Waker)` would form an `Awaker` <-> `Waker`
+# forward-declaration cycle in generated C++ headers if it lived on
+# this protocol; timer registration goes through a direct
+# `Executor.register_timer(...)` call in `asyncio/__init__.py` where
+# the concrete `Ptr[Executor]` handle is available.
+@dynamic
+class Awaker(Protocol):
+    def mark_runnable(self, task_id: Int32, generation: Int32) -> None: ...
+
+
+@builtin_type("tpy.coro.Waker")
+class Waker(ValueType):
+    """Handle that lets a parked task be re-scheduled.
+
+    Awaitables that haven't yet produced a value store the Waker passed
+    to their poll() method; when the underlying event fires, they call
+    waker.wake() to signal the executor that the parked task is runnable.
+
+    Layout: a non-owning `Ptr[Awaker]` to the running executor + a
+    (task_id, generation) slot identifier. Late wakes (from a task that
+    completed before wake() fires) are filtered by the executor's
+    generation check.
+    """
+    awaker: Ptr[Awaker]
+    task_id: Int32
+    generation: Int32
+
+    def __init__(self) -> None:
+        self.awaker = None
+        self.task_id = 0
+        self.generation = 0
+
+    # Not @readonly: wake() doesn't mutate self, but it dispatches into
+    # the awaker's `mark_runnable`, which mutates the executor's runnable
+    # queue. Marking wake() readonly would narrow `self.awaker` to
+    # `Ptr[readonly[Awaker]]` and reject the call.
+    def wake(self) -> None:
+        if self.awaker is None:
+            return
+        try:
+            self.awaker.mark_runnable(self.task_id, self.generation)
+        except BaseException:
+            # Swallow: mark_runnable can raise (e.g. OOM in the
+            # runnable-queue push) and wake() has no useful error
+            # channel. Use-after-free against a torn-down executor is
+            # the caller's invariant -- see `_ExecutorScope` in
+            # `lib/tpy/asyncio/_executor.py`.
+            pass
+
+
+# Structural awaitable. Distinct from `typing.Awaitable[T]` (CPython's
+# `__await__`-based shape) -- TPy uses `__poll__(Waker) -> Poll[T]`.
+# The dunder name matches how other TPy/typing structural protocols
+# spell their required methods (`__iter__`, `__hash__`, `__lt__`, ...)
+# and signals "runtime protocol method -- prefer `await` / `poll_once`
+# to direct calls".
+class Awaitable[T](Protocol):
+    def __poll__(self, waker: Waker) -> Own[Poll[T]]: ...
+
+
+# Cancellable awaitable -- the @dynamic protocol every consumer of
+# asyncio's cancellation machinery accepts (`run`, `create_task`,
+# `wait_for`, `Task[T]` storage, ...). Structurally extends `Awaitable`
+# with a `cancel()` precondition that lets the task layer deliver a
+# `CancelledError` at the awaitee's next suspension. gen_async.py
+# auto-emits cancel() on every coro struct, so any compiled `async def`
+# conforms automatically. Re-exported from `asyncio` for user-facing
+# API typing.
+@dynamic
+class Cancellable[T](Protocol):
+    def __poll__(self, waker: Waker) -> Own[Poll[T]]: ...
+    def cancel(self) -> None: ...
+
+
+# `AnyTask` (@dynamic protocol used by the task machinery) lives in
+# `asyncio._executor` -- it sits on tplib, which isn't reachable from
+# this implicit-stdlib module.
+
+
+def poll_ready[T](value: Own[T]) -> Own[Poll[T]]:
+    return Poll[T].ready(value)
+
+
+def poll_pending[T]() -> Own[Poll[T]]:
+    return Poll[T].pending()
+
+
+# Separate factory because `poll_ready[T](value)` needs an `Own[T]`
+# argument that `Own[None]` can't satisfy with no payload.
+def poll_ready_none() -> Own[Poll[None]]:
+    return Poll[None].ready(None)
+
+
+# Synchronous one-step driver. Calls `__poll__(Waker())` once and
+# returns the Poll[T] for the caller to inspect. Useful for tests and
+# synchronous drivers that don't go through `asyncio.run`.
+def poll_once[T](aw: Awaitable[T]) -> Own[Poll[T]]:
+    return aw.__poll__(Waker())
+
+
+# Poll an awaitable once and report whether it raised CancelledError.
+# Test convenience: production code should `try: await aw / except
+# CancelledError` directly. Pure TPy body.
+def task_poll_cancelled[T](aw: Awaitable[T]) -> bool:
+    try:
+        aw.__poll__(Waker())
+        return False
+    except CancelledError:
+        return True

tpyc/_data/lib/tpy/tpy/extern.py

@@ -0,0 +1,8 @@
+# tpy: native_module
+from ._bootstrap._extern import (
+    builtin_decorator, builtin_type,
+    native, export, cpp_template,
+    value_ptr_coercion, native_preserves_refs,
+    native_global, native_field, native_member,
+    type_param_default, DefaultInt,
+)

tpyc/_data/lib/tpy/tpy/mem.py

@@ -0,0 +1,49 @@
+# tpy: native_module
+from tpy.extern import native
+from tpy import Ptr, Own, UInt32, Span, nocopy, readonly
+
+@native("tpy::UninitArrayStorage")
+@nocopy
+class UninitArrayStorage[T, N: int]:
+    """Inline uninitialized storage for N elements of type T."""
+    def __init__(self) -> None: ...
+    def init(self, index: UInt32, value: Own[T]) -> None: ...
+    def drop(self, index: UInt32) -> None: ...
+    @readonly
+    def load(self, index: UInt32) -> T: ...
+    def init0(self, value: Own[T]) -> None: ...
+    def drop0(self) -> None: ...
+    @readonly
+    def load0(self) -> T: ...
+    def take(self, index: UInt32) -> Own[T]: ...
+    def take0(self) -> Own[T]: ...
+    @readonly
+    def capacity(self) -> UInt32: ...
+    def init_from_span(self, start: UInt32, src: Span[readonly[T]]) -> None: ...
+    def drop_n(self, start: UInt32, count: UInt32) -> None: ...
+    def shift(self, src: UInt32, dst: UInt32, count: UInt32) -> None: ...
+    @readonly
+    def ptr(self) -> Ptr[T]: ...
+
+@native("tpy::UninitHeapStorage")
+@nocopy
+class UninitHeapStorage[T]:
+    """Heap-allocated uninitialized storage with dynamic capacity."""
+    def __init__(self, capacity: UInt32) -> None: ...
+    def init(self, index: UInt32, value: Own[T]) -> None: ...
+    def drop(self, index: UInt32) -> None: ...
+    @readonly
+    def load(self, index: UInt32) -> T: ...
+    def init0(self, value: Own[T]) -> None: ...
+    def drop0(self) -> None: ...
+    @readonly
+    def load0(self) -> T: ...
+    def take(self, index: UInt32) -> Own[T]: ...
+    def take0(self) -> Own[T]: ...
+    @readonly
+    def capacity(self) -> UInt32: ...
+    def init_from_span(self, start: UInt32, src: Span[readonly[T]]) -> None: ...
+    def drop_n(self, start: UInt32, count: UInt32) -> None: ...
+    def shift(self, src: UInt32, dst: UInt32, count: UInt32) -> None: ...
+    @readonly
+    def ptr(self) -> Ptr[T]: ...

tpyc/_data/lib/tpy/tpy/unsafe.py

@@ -0,0 +1,195 @@
+# tpy: native_module
+from typing import overload
+from tpy.extern import native, cpp_template
+from tpy import Ptr, Own, Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64, Float32, StrView, Char, Array, readonly
+
+# unsafe_ptr: get a raw pointer from a container or string
+@overload
+@cpp_template("{0}.data()")
+def unsafe_ptr(s: str) -> Ptr[readonly[Char]]: ...
+
+@overload
+@cpp_template("{0}.data()")
+def unsafe_ptr[T, N: int](a: Array[T, N]) -> Ptr[T]: ...
+
+@overload
+@cpp_template("{0}.data()")
+def unsafe_ptr[T](l: list[T]) -> Ptr[T]: ...
+
+@overload
+@cpp_template("{0}.data()")
+def unsafe_ptr(b: bytes) -> Ptr[readonly[UInt8]]: ...
+
+# unsafe_cast: reinterpret a pointer as a different pointee type
+# TODO: add @compiler_check decorator to make sema validation visible here
+# (currently keyed on qualified_name in calls.py: const-safety, type hint checks)
+#
+# Uses `{cpp}` (the return-type spelling) rather than `{T}*` so the
+# PtrType -> void* special-case for `T = None` is preserved -- bare
+# `{T}*` substitutes T via to_cpp_stored() and produces
+# `std::monostate*`, defeating the opaque-pointer-for-@native-C-interop
+# convention of `Ptr[None]`.
+@overload
+@cpp_template("reinterpret_cast<{cpp}>({0})")
+def unsafe_cast[T, U](p: Ptr[U]) -> Ptr[T]: ...
+
+@overload
+@cpp_template("reinterpret_cast<{cpp}>({0})")
+def unsafe_cast[T, U](p: Ptr[readonly[U]]) -> Ptr[readonly[T]]: ...
+
+# unsafe_load: read a value through a pointer at offset
+@overload
+@cpp_template("{0}[{1}]")
+def unsafe_load[T](p: Ptr[T], offset: UInt32) -> Own[T]: ...
+
+@overload
+@cpp_template("{0}[{1}]")
+def unsafe_load[T](p: Ptr[readonly[T]], offset: UInt32) -> Own[T]: ...
+
+# unsafe_store: write a value through a pointer at offset
+@cpp_template("{0}[{1}] = {2}")
+def unsafe_store[T](p: Ptr[T], offset: UInt32, value: T) -> None: ...
+
+# unsafe_copy_n: copy N elements between pointers
+@overload
+@cpp_template("std::copy_n({1}, {2}, {0})")
+def unsafe_copy_n[T](dest: Ptr[T], src: Ptr[T], count: UInt32) -> None: ...
+
+@overload
+@cpp_template("std::copy_n({1}, {2}, {0})")
+def unsafe_copy_n[T](dest: Ptr[T], src: Ptr[readonly[T]], count: UInt32) -> None: ...
+
+# unsafe_const_cast: remove const from a pointer
+@cpp_template("const_cast<{T}*>({0})")
+def unsafe_const_cast[T](p: Ptr[readonly[T]]) -> Ptr[T]: ...
+
+# unsafe_ptr_add: advance a pointer by a signed element offset
+@overload
+@cpp_template("({0} + {1})")
+def unsafe_ptr_add[T](p: Ptr[T], delta: Int64) -> Ptr[T]: ...
+
+@overload
+@cpp_template("({0} + {1})")
+def unsafe_ptr_add[T](p: Ptr[readonly[T]], delta: Int64) -> Ptr[readonly[T]]: ...
+
+# unsafe_ptr_diff: distance between two pointers in elements
+@overload
+@cpp_template("static_cast<int64_t>({0} - {1})")
+def unsafe_ptr_diff[T](p1: Ptr[T], p2: Ptr[T]) -> Int64: ...
+
+@overload
+@cpp_template("static_cast<int64_t>({0} - {1})")
+def unsafe_ptr_diff[T](p1: Ptr[readonly[T]], p2: Ptr[readonly[T]]) -> Int64: ...
+
+# unsafe_alloc: allocate raw memory for a single element
+@cpp_template("static_cast<{T}*>(::operator new(sizeof({T}), std::align_val_t(alignof({T}))))")
+def unsafe_alloc[T]() -> Ptr[T]: ...
+
+# unsafe_alloc_n: allocate raw memory for N elements
+@cpp_template("static_cast<{T}*>(::operator new(sizeof({T}) * {0}, std::align_val_t(alignof({T}))))")
+def unsafe_alloc_n[T](count: UInt32) -> Ptr[T]: ...
+
+# unsafe_free: free raw memory
+@cpp_template("::operator delete({0}, std::align_val_t(alignof({T})))")
+def unsafe_free[T](p: Ptr[T]) -> None: ...
+
+# unsafe_init: placement-new construct an object
+@cpp_template("::new(static_cast<void*>({0})) {T}({1})")
+def unsafe_init[T](p: Ptr[T], value: Own[T]) -> None: ...
+
+# unsafe_drop: call destructor
+@native("tpy::destroy_at")
+def unsafe_drop[T](p: Ptr[T]) -> None: ...
+
+# unsafe_take: heap-allocate and move-in a value (combined alloc + init).
+# Abstract-T case is handled by C++ overload resolution: heap_take has
+# both a T&& primary and a unique_ptr<T> overload.
+@native("tpy::heap_take")
+def unsafe_take[T](value: Own[T]) -> Ptr[T]: ...
+
+# unsafe_release: destruct and free a heap-allocated T (combined drop + free).
+@native("tpy::heap_release")
+def unsafe_release[T](p: Ptr[T]) -> None: ...
+
+# unsafe_replace: replace the heap-stored T at p with value, returning the
+# live slot pointer. Caller must write the returned pointer back to its
+# storage slot -- for abstract @dynamic T the slot changes.
+# Precondition: value must not alias *p.
+@native("tpy::heap_replace")
+def unsafe_replace[T](p: Ptr[T], value: Own[T]) -> Ptr[T]: ...
+
+# unsafe_transfer_ownership: adopt a heap-allocated Ptr[T] as Own[T].
+# After the call the input pointer is invalidated.
+@native("tpy::transfer_ownership")
+def unsafe_transfer_ownership[T](p: Ptr[T]) -> Own[T]: ...
+
+# unsafe_move_out: move a value out of a pointer location
+@cpp_template("std::move(*{0})")
+def unsafe_move_out[T](p: Ptr[T]) -> Own[T]: ...
+
+# unsafe_read_*: read typed values from a byte buffer at a byte offset.
+# Uses reinterpret_cast -- safe on little-endian targets (x86, ARM).
+@cpp_template("*reinterpret_cast<const int8_t*>({0}.data() + {1})")
+def unsafe_read_i8(data: bytes, offset: Int32) -> Int8: ...
+
+@cpp_template("({0})[{1}]")
+def unsafe_read_u8(data: bytes, offset: Int32) -> UInt8: ...
+
+@cpp_template("*reinterpret_cast<const int16_t*>({0}.data() + {1})")
+def unsafe_read_i16(data: bytes, offset: Int32) -> Int16: ...
+
+@cpp_template("*reinterpret_cast<const uint16_t*>({0}.data() + {1})")
+def unsafe_read_u16(data: bytes, offset: Int32) -> UInt16: ...
+
+@cpp_template("*reinterpret_cast<const int32_t*>({0}.data() + {1})")
+def unsafe_read_i32(data: bytes, offset: Int32) -> Int32: ...
+
+@cpp_template("*reinterpret_cast<const uint32_t*>({0}.data() + {1})")
+def unsafe_read_u32(data: bytes, offset: Int32) -> UInt32: ...
+
+@cpp_template("*reinterpret_cast<const int64_t*>({0}.data() + {1})")
+def unsafe_read_i64(data: bytes, offset: Int32) -> Int64: ...
+
+@cpp_template("*reinterpret_cast<const uint64_t*>({0}.data() + {1})")
+def unsafe_read_u64(data: bytes, offset: Int32) -> UInt64: ...
+
+@cpp_template("*reinterpret_cast<const float*>({0}.data() + {1})")
+def unsafe_read_f32(data: bytes, offset: Int32) -> Float32: ...
+
+@cpp_template("*reinterpret_cast<const double*>({0}.data() + {1})")
+def unsafe_read_f64(data: bytes, offset: Int32) -> float: ...
+
+@native("tpy::bytes_read_sub")
+def unsafe_read_bytes(data: bytes, offset: Int32, count: Int32) -> bytes: ...
+
+# unsafe_str_view: create a StrView from a pointer and length
+@overload
+@cpp_template("std::string_view({0}, {1})")
+def unsafe_str_view(p: Ptr[Char], size: UInt32) -> StrView: ...
+
+@overload
+@cpp_template("std::string_view({0}, {1})")
+def unsafe_str_view(p: Ptr[readonly[Char]], size: UInt32) -> StrView: ...
+
+# unsafe_str_from_cstr: read a null-terminated C string into an owned TPy
+# str. Caller ensures the pointer is valid and there is a \0 within the
+# intended range. Typical use: wrap a `const char*` returned by a libc
+# call (strerror, inet_ntop, gai_strerror, ...).
+@cpp_template("std::string(reinterpret_cast<const char*>({0}))")
+def unsafe_str_from_cstr(p: Ptr[readonly[UInt8]]) -> str: ...
+
+# unsafe_str_from_buf: build an owned TPy str from a raw byte buffer of
+# `size` bytes. No null terminator required. Typical use: decode the
+# written portion of a pre-sized output buffer (pcre2 substitute, iconv,
+# ...). Companion to unsafe_str_view above -- that one borrows, this one
+# copies into owned storage.
+@cpp_template("std::string(reinterpret_cast<const char*>({0}), static_cast<size_t>({1}))")
+def unsafe_str_from_buf(p: Ptr[readonly[UInt8]], size: UInt64) -> str: ...
+
+# unsafe_bytes_from_buf: construct an owned bytes from a raw byte buffer
+# of `size` bytes. Caller ensures the pointer + range is valid for read.
+# CPython's `bytes()` does not accept raw pointers (no buffer protocol
+# exposure at that layer), so this can't be a bytes constructor overload;
+# it lives here alongside other raw-memory constructors.
+@cpp_template("std::vector<uint8_t>({0}, {0} + {1})")
+def unsafe_bytes_from_buf(p: Ptr[UInt8], size: UInt64) -> bytes: ...

tpyc/_data/lib/tpy/tpy/version.py

@@ -0,0 +1,21 @@
+"""Compiler/runtime version and implementation identification for TPy.
+
+Usage:
+
+    from tpy.version import __version__, version_info, is_compiled
+
+Lives as a dedicated submodule (not re-exported from tpy/__init__.py)
+because variable re-exports through native_module facades and transitive
+init-chain propagation through them are not currently supported. Values
+come from the _version.py macros, which read tpyc.__version__ and
+tpyc.VERSION_INFO at compile time.
+"""
+from typing import Final
+from tpy import Int32
+from ._version import version as _version, version_info as _version_info
+
+__version__: Final[str] = _version()
+# Int32 components rather than `int` (BigInt): version numbers are small
+# and BigInt would waste heap allocations on every access.
+version_info: Final[tuple[Int32, Int32, Int32, str, Int32]] = _version_info()
+is_compiled: Final[bool] = True

tpyc/_data/lib/tpy/typing.py

@@ -0,0 +1,13 @@
+# tpy: native_module
+# tpy: cpp_namespace("tpystd::typing")
+from tpy._typing import (
+    Protocol, Self, overload, override,
+    Sized, Sequence, MutableSequence, Iterator, Iterable,
+    Optional, Final, ClassVar, Callable, Literal, TypedDict, Unpack, Any, cast,
+)
+
+__all__ = [
+    "Optional", "Protocol", "Self", "Sized", "Sequence", "MutableSequence",
+    "Iterator", "Iterable", "Final", "ClassVar", "override", "overload",
+    "Callable", "Literal", "TypedDict", "Unpack", "Any", "cast",
+]