sonolus.py 0.10.7__py3-none-any.whl → 0.12.5__py3-none-any.whl

sonolus/script/internal/builtin_impls.py

@@ -1,4 +1,5 @@
-from typing import Never, assert_never
+from types import FunctionType
+from typing import Any, Never, assert_never
 
 from sonolus.backend.ops import Op
 from sonolus.script.array import Array
@@ -22,6 +23,7 @@ from sonolus.script.iterator import (
     _Zipper,
 )
 from sonolus.script.num import Num, _is_num
+from sonolus.script.record import Record
 
 _empty = object()
 
@@ -389,8 +391,90 @@ def _super(*args):
 
 
 @meta_fn
-def _type(value):
-    return type(value)
+def _hasattr(obj: Any, name: str) -> bool:
+    from sonolus.script.internal.constant import ConstantValue
+    from sonolus.script.internal.descriptor import SonolusDescriptor
+
+    name = validate_value(name)._as_py_()
+    if isinstance(obj, ConstantValue):
+        # Unwrap so we can access fields
+        obj = obj._as_py_()
+    descriptor = None
+    for cls in type.mro(type(obj)):
+        descriptor = cls.__dict__.get(name, None)
+        if descriptor is not None:
+            break
+    # We want to mirror what getattr supports and fail fast if a future getattr would fail.
+    match descriptor:
+        case None:
+            return hasattr(obj, name)
+        case property() | SonolusDescriptor() | FunctionType() | classmethod() | staticmethod():
+            return True
+        case non_descriptor if not hasattr(non_descriptor, "__get__"):
+            return True
+        case _:
+            raise TypeError(f"Unsupported field or descriptor {name}")
+
+
+@meta_fn
+def _getattr(obj: Any, name: str, default=_empty) -> Any:
+    from sonolus.backend.visitor import compile_and_call
+    from sonolus.script.internal.constant import ConstantValue
+    from sonolus.script.internal.descriptor import SonolusDescriptor
+
+    name = validate_value(name)._as_py_()
+    if isinstance(obj, ConstantValue):
+        # Unwrap so we can access fields
+        obj = obj._as_py_()
+    descriptor = None
+    for cls in type.mro(type(obj)):
+        descriptor = cls.__dict__.get(name, None)
+        if descriptor is not None:
+            break
+    match descriptor:
+        case property(fget=getter):
+            return compile_and_call(getter, obj)
+        case SonolusDescriptor() | FunctionType() | classmethod() | staticmethod() | None:
+            return validate_value(getattr(obj, name) if default is _empty else getattr(obj, name, default))
+        case non_descriptor if not hasattr(non_descriptor, "__get__"):
+            return validate_value(getattr(obj, name) if default is _empty else getattr(obj, name, default))
+        case _:
+            raise TypeError(f"Unsupported field or descriptor {name}")
+
+
+@meta_fn
+def _setattr(obj: Any, name: str, value: Any):
+    from sonolus.backend.visitor import compile_and_call
+    from sonolus.script.internal.descriptor import SonolusDescriptor
+
+    name = validate_value(name)._as_py_()
+    if obj._is_py_():
+        obj = obj._as_py_()
+    descriptor = getattr(type(obj), name, None)
+    match descriptor:
+        case property(fset=setter):
+            if setter is None:
+                raise AttributeError(f"Cannot set attribute {name} because property has no setter")
+            compile_and_call(setter, obj, value)
+        case SonolusDescriptor():
+            setattr(obj, name, value)
+        case _:
+            raise TypeError(f"Unsupported field or descriptor {name}")
+
+
+class _Type(Record):
+    @meta_fn
+    def __call__(self, value, /):
+        value = validate_value(value)
+        if value._is_py_():
+            value = value._as_py_()
+        return validate_value(type(value))
+
+    def __getitem__(self, item):
+        return self
+
+
+_type = _Type()
 
 
 @meta_fn
@@ -404,12 +488,13 @@ BUILTIN_IMPLS = {
     id(abs): _abs,
     id(all): _all,
     id(any): _any,
-    id(sum): _sum,
     id(bool): _bool,
     id(callable): _callable,
     id(enumerate): _enumerate,
     id(filter): _filter,
     id(float): _float,
+    id(getattr): _getattr,
+    id(hasattr): _hasattr,
     id(int): _int,
     id(isinstance): _isinstance,
     id(iter): _iter,
@@ -420,6 +505,8 @@ BUILTIN_IMPLS = {
     id(next): _next,
     id(range): Range,
     id(reversed): _reversed,
+    id(setattr): _setattr,
+    id(sum): _sum,
     id(super): _super,
     id(type): _type,
     id(zip): _zip,

sonolus/script/internal/context.py

@@ -94,25 +94,36 @@ class ProjectContextState:
 
 class ModeContextState:
     archetypes: dict[type, int]
+    compile_time_only_archetypes: set[type]
     archetypes_by_name: dict[str, type]
     keys_by_archetype_id: Sequence[int]
     is_scored_by_archetype_id: Sequence[bool]
+    archetype_mro_id_array_rom_indexes: Sequence[int] | None = None
     environment_mappings: dict[_GlobalInfo, int]
     environment_offsets: dict[Block, int]
     mode: Mode
     lock: Lock
 
-    def __init__(self, mode: Mode, archetypes: dict[type, int] | None = None):
+    def __init__(self, mode: Mode, archetypes: list[type] | None = None):
         from sonolus.script.array import Array
 
-        self.archetypes = archetypes or {}
+        archetypes = [*archetypes] if archetypes is not None else []
+        seen_archetypes = {*archetypes}
+        compile_time_only_archetypes = set()
+        for type_ in [*archetypes]:
+            for entry in type_.mro():
+                if getattr(entry, "_is_concrete_archetype_", False) and entry not in seen_archetypes:
+                    archetypes.append(entry)
+                    seen_archetypes.add(entry)
+                    compile_time_only_archetypes.add(entry)
+        self.archetypes = {type_: idx for idx, type_ in enumerate(archetypes)}
+        self.compile_time_only_archetypes = compile_time_only_archetypes
         self.archetypes_by_name = {type_.name: type_ for type_, _ in self.archetypes.items()}  # type: ignore
-        ordered_archetypes = sorted(self.archetypes, key=lambda a: self.archetypes[a])
         self.keys_by_archetype_id = (
-            Array(*((getattr(a, "_key_", -1)) for a in ordered_archetypes)) if archetypes else Array[int, Literal[0]]()
+            Array(*((getattr(a, "_key_", -1)) for a in archetypes)) if archetypes else Array[int, Literal[0]]()
         )
         self.is_scored_by_archetype_id = (
-            Array(*((getattr(a, "_is_scored_", False)) for a in ordered_archetypes))
+            Array(*((getattr(a, "_is_scored_", False)) for a in archetypes))
             if archetypes
             else Array[bool, Literal[0]]()
         )
@@ -121,6 +132,27 @@ class ModeContextState:
         self.mode = mode
         self.lock = Lock()
 
+    def _init_archetype_mro_info(self, rom: ReadOnlyMemory):
+        from sonolus.script.array import Array
+        from sonolus.script.num import Num
+
+        with self.lock:
+            if self.archetype_mro_id_array_rom_indexes is not None:
+                return
+            archetype_mro_id_values = []
+            archetype_mro_id_offsets = []
+            for type_ in self.archetypes:
+                mro_ids = [self.archetypes[entry] for entry in type_.mro() if entry in self.archetypes]
+                archetype_mro_id_offsets.append(len(archetype_mro_id_values))
+                archetype_mro_id_values.append(len(mro_ids))
+                archetype_mro_id_values.extend(mro_ids)
+            archetype_mro_id_array_place = rom[tuple(archetype_mro_id_values)]
+
+            archetype_mro_id_rom_indexes = Array[int, len(archetype_mro_id_offsets)]._with_value(
+                [Num._accept_(offset + archetype_mro_id_array_place.index) for offset in archetype_mro_id_offsets]
+            )
+            self.archetype_mro_id_array_rom_indexes = archetype_mro_id_rom_indexes
+
 
 class CallbackContextState:
     callback: str
@@ -371,6 +403,15 @@ class Context:
                 self.mode_state.archetypes[type_] = len(self.mode_state.archetypes)
             return self.mode_state.archetypes[type_]
 
+    def get_archetype_mro_id_array(self, archetype_id: int) -> Sequence[int]:
+        from sonolus.script.containers import ArrayPointer
+        from sonolus.script.num import Num
+        from sonolus.script.pointer import _deref
+
+        self.mode_state._init_archetype_mro_info(self.rom)
+        rom_index = self.mode_state.archetype_mro_id_array_rom_indexes[archetype_id]
+        return ArrayPointer[int](_deref(self.blocks.EngineRom, rom_index, Num), self.blocks.EngineRom, rom_index + 1)
+
 
 def ctx() -> Context | Any:  # Using Any to silence type checker warnings if it's None
     return context_var.get()
@@ -551,7 +592,11 @@ def context_to_cfg(context: Context) -> BasicBlock:
             edge = FlowEdge(src=blocks[current], dst=blocks[target], cond=condition)
             blocks[current].outgoing.add(edge)
             blocks[target].incoming.add(edge)
-    return blocks[context]
+    result = blocks[context]
+    for current in tuple(iter_contexts(context)):
+        # Break cycles so memory can be cleaned without gc
+        del current.outgoing
+    return result
 
 
 def unique[T](iterable: Iterable[T]) -> list[T]:

sonolus/script/internal/generic.py

@@ -37,6 +37,11 @@ def validate_type_spec(spec: Any) -> PartialGeneric | TypeVar | type[Value]:
         validated_args = {validate_type_arg(arg) for arg in args}
         if len(validated_args) == 1:
             return validated_args.pop()
+
+    from sonolus.script.archetype import _BaseArchetype
+
+    if isinstance(spec, type) and issubclass(spec, _BaseArchetype):
+        raise TypeError(f"Expected a concrete type, got {spec}. Did you mean to write EntityRef[{spec.__name__}]?")
     raise TypeError(f"Invalid type spec: {spec}")
 
 
@@ -44,15 +49,18 @@ def validate_concrete_type(spec: Any) -> type[Value]:
     spec = validate_type_spec(spec)
     if isinstance(spec, type) and issubclass(spec, Value) and spec._is_concrete_():
         return spec
+    if (
+        isinstance(spec, type)
+        and issubclass(spec, Value)
+        and not spec._is_concrete_()
+        and issubclass(spec, GenericValue)
+    ):
+        raise TypeError(f"Expected a concrete type, got {spec}. Are there missing type arguments?")
+    if isinstance(spec, PartialGeneric):
+        raise TypeError(f"Expected a concrete type, got {spec}. Invalid use of a type parameter as a type argument?")
     raise TypeError(f"Expected a concrete type, got {spec}")
 
 
-def validate_type_args(args) -> tuple[Any, ...]:
-    if not isinstance(args, tuple):
-        args = (args,)
-    return tuple(validate_type_arg(arg) for arg in args)
-
-
 def contains_incomplete_type(args) -> bool:
     if not isinstance(args, tuple):
         args = (args,)
@@ -102,7 +110,26 @@ class GenericValue(Value):
     def __class_getitem__(cls, args: Any) -> type[Self]:
         if cls._type_args_ is not None:
             raise TypeError(f"Type {cls.__name__} is already parameterized")
-        args = validate_type_args(args)
+        if not isinstance(args, tuple):
+            args = (args,)
+        validated_args = []
+        for i, arg in enumerate(args):
+            if i < len(cls.__type_params__):
+                type_param = cls.__type_params__[i]
+            else:
+                type_param = None
+            try:
+                validated_args.append(validate_type_arg(arg))
+            except TypeError as e:
+                if type_param is not None:
+                    type_param_body = ", ".join(str(tp) for tp in cls.__type_params__)
+                    raise TypeError(
+                        f"Invalid type argument for type parameter {type_param} of "
+                        f"class {cls.__name__}[{type_param_body}]: {e}"
+                    ) from e
+                else:
+                    raise TypeError(f"Invalid type argument at position {i} of class {cls.__name__}: {e}") from e
+        args = tuple(validated_args)
         args = cls._validate_type_args_(args)
         if contains_incomplete_type(args):
             return PartialGeneric(cls, args)

sonolus/script/internal/impl.py

@@ -62,6 +62,12 @@ def try_validate_value(value: Any) -> Value | None:
     except ImportError:
         pass
 
+    if hasattr(value, "_init_") and callable(value._init_):
+        try:
+            value._init_()
+        except Exception as e:
+            raise RuntimeError(f"Error initializing value {value}: {e}") from e
+
     match value:
         case Value():
             return value
@@ -77,6 +83,10 @@ def try_validate_value(value: Any) -> Value | None:
             return TupleImpl._accept_(value)
         case dict():
             return DictImpl._accept_(value)
+        case set() | frozenset():
+            from sonolus.script.containers import FrozenNumSet
+
+            return FrozenNumSet.of(*value)
         case (
             PartialGeneric()
             | TypeVar()
@@ -90,11 +100,7 @@ def try_validate_value(value: Any) -> Value | None:
             | super()
         ):
             return BasicConstantValue.of(value)
-        case special_form if value in {
-            Literal,
-            Annotated,
-            Union,
-        }:
+        case special_form if value == Literal or value == Annotated or value == Union:  # noqa: PLR1714, SIM109
             return TypingSpecialFormConstant.of(special_form)
         case other_type if get_origin(value) in {Literal, Annotated, UnionType, tuple, type}:
             return BasicConstantValue.of(other_type)

sonolus/script/internal/introspection.py

@@ -1,4 +1,6 @@
 import inspect
+from abc import ABC
+from collections.abc import Sequence
 from typing import Annotated
 
 _missing = object()
@@ -11,9 +13,15 @@ def get_field_specifiers(
     globals=None,  # noqa: A002
     locals=None,  # noqa: A002
     eval_str=True,
+    included_classes: Sequence[type] | None = None,
 ):
     """Like inspect.get_annotations, but also turns class attributes into Annotated."""
-    results = inspect.get_annotations(cls, globals=globals, locals=locals, eval_str=eval_str)
+    if included_classes is not None:
+        results = {}
+        for entry in reversed(included_classes):
+            results.update(inspect.get_annotations(entry, eval_str=eval_str))
+    else:
+        results = inspect.get_annotations(cls, globals=globals, locals=locals, eval_str=eval_str)
     for key, value in results.items():
         class_value = getattr(cls, key, _missing)
         if class_value is not _missing and key not in skip:
@@ -26,6 +34,7 @@ def get_field_specifiers(
             and not callable(value)
             and not hasattr(value, "__func__")
             and not isinstance(value, property)
+            and not (issubclass(cls, ABC) and (hasattr(ABC, key)))
         ):
             raise ValueError(f"Missing annotation for {cls.__name__}.{key}")
     for skipped_key in skip:

sonolus/script/internal/tuple_impl.py

@@ -91,6 +91,12 @@ class TupleImpl(TransientValue):
         other = TupleImpl._accept_(other)
         return TupleImpl._accept_(self.value + other.value)
 
+    def __contains__(self, item):
+        for element in self.value:  # noqa: SIM110
+            if element == item:
+                return True
+        return False
+
     @staticmethod
     @meta_fn
     def _is_tuple_impl(value: Any) -> bool:

sonolus/script/interval.py

@@ -78,7 +78,7 @@ class Interval(Record):
         Returns:
             A new interval with the value added to both ends.
         """
-        return Interval._quick_construct(start=self.start + other, end=self.end + other)
+        return Interval._unchecked(start=self.start + other, end=self.end + other)
 
     @perf_meta_fn
     def __sub__(self, other: float | int) -> Interval:
@@ -90,7 +90,7 @@ class Interval(Record):
         Returns:
             A new interval with the value subtracted from both ends.
         """
-        return Interval._quick_construct(start=self.start - other, end=self.end - other)
+        return Interval._unchecked(start=self.start - other, end=self.end - other)
 
     @perf_meta_fn
     def __mul__(self, other: float | int) -> Interval:
@@ -102,7 +102,7 @@ class Interval(Record):
         Returns:
             A new interval with both ends multiplied by the value.
         """
-        return Interval._quick_construct(start=self.start * other, end=self.end * other)
+        return Interval._unchecked(start=self.start * other, end=self.end * other)
 
     @perf_meta_fn
     def __truediv__(self, other: float | int) -> Interval:
@@ -114,7 +114,7 @@ class Interval(Record):
         Returns:
             A new interval with both ends divided by the value.
         """
-        return Interval._quick_construct(start=self.start / other, end=self.end / other)
+        return Interval._unchecked(start=self.start / other, end=self.end / other)
 
     @perf_meta_fn
     def __floordiv__(self, other: float | int) -> Interval:
@@ -126,7 +126,7 @@ class Interval(Record):
         Returns:
             A new interval with both ends divided by the value and floored.
         """
-        return Interval._quick_construct(start=self.start // other, end=self.end // other)
+        return Interval._unchecked(start=self.start // other, end=self.end // other)
 
     def __and__(self, other: Interval) -> Interval:
         """Get the intersection of two intervals.

sonolus/script/project.py

@@ -149,3 +149,5 @@ class BuildConfig:
 
     runtime_checks: RuntimeChecks = RuntimeChecks.NONE
     """Runtime error checking mode."""
+
+    verbose: bool = False

sonolus/script/record.py

@@ -4,7 +4,7 @@ import inspect
 from abc import ABCMeta
 from collections.abc import Iterable
 from inspect import getmro
-from typing import Any, ClassVar, Self, TypeVar, dataclass_transform, get_origin
+from typing import Any, ClassVar, Protocol, Self, TypeVar, dataclass_transform, get_origin
 
 from sonolus.backend.place import BlockPlace
 from sonolus.script.internal.context import ctx
@@ -21,7 +21,8 @@ from sonolus.script.internal.value import BackingSource, DataValue, Value
 from sonolus.script.num import Num
 
 
-class RecordMeta(ABCMeta):
+# Protocol metaclass is a subclass of ABCMeta, but let's make ABCMeta explicit for clarity
+class RecordMeta(type(Protocol), ABCMeta):
     @meta_fn
     def __pos__[T](cls: type[T]) -> T:
         """Create a zero-initialized record instance."""
@@ -103,25 +104,28 @@ class Record(GenericValue, metaclass=RecordMeta):
         index = 0
         offset = 0
         for name, hint in hints.items():
-            if name not in cls.__annotations__:
-                continue
-            if hint is ClassVar or get_origin(hint) is ClassVar:
-                continue
-            if hasattr(cls, name):
-                raise TypeError("Default values are not supported for Record fields")
-            type_ = validate_type_spec(hint)
-            fields.append(_RecordField(name, type_, index, offset))
-            if isinstance(type_, type) and issubclass(type_, Value) and type_._is_concrete_():
-                offset += type_._size_()
-            setattr(cls, name, fields[-1])
-            index += 1
-            params.append(
-                inspect.Parameter(
-                    name,
-                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                    annotation=type_,
+            try:
+                if name not in cls.__annotations__:
+                    continue
+                if hint is ClassVar or get_origin(hint) is ClassVar:
+                    continue
+                if hasattr(cls, name):
+                    raise TypeError("Default values are not supported for Record fields")
+                type_ = validate_type_spec(hint)
+                fields.append(_RecordField(name, type_, index, offset))
+                if isinstance(type_, type) and issubclass(type_, Value) and type_._is_concrete_():
+                    offset += type_._size_()
+                setattr(cls, name, fields[-1])
+                index += 1
+                params.append(
+                    inspect.Parameter(
+                        name,
+                        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                        annotation=type_,
+                    )
                 )
-            )
+            except Exception as e:
+                raise TypeError(f"Error processing field '{name}' of Record {cls.__name__}: {e}") from e
 
         cls._parameterized_ = {}
         cls._fields_ = fields
@@ -172,7 +176,8 @@ class Record(GenericValue, metaclass=RecordMeta):
         return result
 
     @classmethod
-    def _quick_construct(cls, **kwargs) -> Self:
+    def _unchecked(cls, **kwargs) -> Self:
+        # Skips most validation, generally for internal use in frequently-called methods for performance reasons
         result = object.__new__(cls)
         for k, v in kwargs.items():
             if isinstance(v, int | float):
@@ -319,6 +324,16 @@ class Record(GenericValue, metaclass=RecordMeta):
         """
         return super().type_var_value(var)
 
+    @classmethod
+    def _validate_parameterized_(cls):
+        pass
+
+    @classmethod
+    def _get_parameterized(cls, args: tuple[Any, ...]) -> type[Self]:
+        result = super()._get_parameterized(args)
+        result._validate_parameterized_()
+        return result
+
 
 class _RecordField(SonolusDescriptor):
     def __init__(self, name: str, type_: type[Value] | Any, index: int, offset: int):

sonolus/script/runtime.py

@@ -1157,7 +1157,7 @@ def canvas() -> _PreviewRuntimeCanvas:
 @perf_meta_fn
 def screen() -> Rect:
     """Get the screen boundaries as a rectangle."""
-    return Rect._quick_construct(t=1, r=aspect_ratio(), b=-1, l=-aspect_ratio())
+    return Rect._unchecked(t=1, r=aspect_ratio(), b=-1, l=-aspect_ratio())
 
 
 def level_score() -> _LevelScore:

sonolus/script/stream.py

@@ -94,27 +94,34 @@ def streams[T](cls: type[T]) -> T:
     """
     if len(cls.__bases__) != 1:
         raise ValueError("Options class must not inherit from any class (except object)")
-    instance = cls()
-    entries = []
-    # Offset 0 is unused so we can tell when a stream object is uninitialized since it'll have offset 0.
-    offset = 1
-    for name, annotation in get_field_specifiers(cls).items():
-        if issubclass(annotation, Stream | StreamGroup):
-            annotation = cast(type[Stream | StreamGroup], annotation)
-            if annotation is Stream or annotation is StreamGroup:
-                raise TypeError(f"Invalid annotation for streams: {annotation}. Must have type arguments.")
-            setattr(cls, name, _StreamField(offset, annotation))
-            # Streams store their data across several backing streams
-            entries.append((name, offset, annotation))
-            offset += annotation.backing_size()
-        elif issubclass(annotation, Value) and annotation._is_concrete_():
-            setattr(cls, name, _StreamDataField(offset, annotation))
-            # Data fields store their data in a single backing stream at different offsets in the same stream
-            entries.append((name, offset, annotation))
-            offset += 1
-    instance._streams_ = entries
-    instance._is_comptime_value_ = True
-    return instance
+
+    @classmethod
+    def _init_(cls):
+        if getattr(cls, "_init_done_", False):
+            return
+        entries = []
+        # Offset 0 is unused so we can tell when a stream object is uninitialized since it'll have offset 0.
+        offset = 1
+        for name, annotation in get_field_specifiers(cls, skip={"_init_done_"}).items():
+            if issubclass(annotation, Stream | StreamGroup):
+                annotation = cast(type[Stream | StreamGroup], annotation)
+                if annotation is Stream or annotation is StreamGroup:
+                    raise TypeError(f"Invalid annotation for streams: {annotation}. Must have type arguments.")
+                setattr(cls, name, _StreamField(offset, annotation))
+                # Streams store their data across several backing streams
+                entries.append((name, offset, annotation))
+                offset += annotation.backing_size()
+            elif issubclass(annotation, Value) and annotation._is_concrete_():
+                setattr(cls, name, _StreamDataField(offset, annotation))
+                # Data fields store their data in a single backing stream at different offsets in the same stream
+                entries.append((name, offset, annotation))
+                offset += 1
+        cls._streams_ = entries
+        cls._is_comptime_value_ = True
+        cls._init_done_ = True
+
+    cls._init_ = _init_
+    return cls()
 
 
 @meta_fn

sonolus/script/transform.py

@@ -326,15 +326,16 @@ class Transform2d(Record):
             A new normalized transform.
         """
         assert self.a22 != 0, "Cannot normalize transform with a22 == 0"
+        a22 = self.a22 + (self.a22 == 0)
         return Transform2d(
-            self.a00 / self.a22,
-            self.a01 / self.a22,
-            self.a02 / self.a22,
-            self.a10 / self.a22,
-            self.a11 / self.a22,
-            self.a12 / self.a22,
-            self.a20 / self.a22,
-            self.a21 / self.a22,
+            self.a00 / a22,
+            self.a01 / a22,
+            self.a02 / a22,
+            self.a10 / a22,
+            self.a11 / a22,
+            self.a12 / a22,
+            self.a20 / a22,
+            self.a21 / a22,
             1,
         )
 

sonolus/script/values.py

@@ -1,7 +1,6 @@
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.generic import validate_concrete_type
 from sonolus.script.internal.impl import meta_fn, validate_value
-from sonolus.script.num import Num
 
 
 @meta_fn
@@ -49,8 +48,4 @@ def swap[T](a: T, b: T):
 @meta_fn
 def sizeof(type_: type, /) -> int:
     """Return the size of the given type."""
-    type_ = validate_concrete_type(type_)
-    if ctx():
-        return Num(type_._size_())
-    else:
-        return type_._size_()
+    return validate_concrete_type(type_)._size_()