// Comptime type metaprogramming (REIFY) — `type_info` / `reify` / `field_type`
// plus the data model they reflect INTO and construct FROM. Mirrors the Zig
// `@typeInfo` / `@Type` split: reflect a type → data, construct a NEW nominal
// type from data.
//
// This is a SEPARATE on-demand module rather than part of the prelude: its data
// types would otherwise intern into every module's type table and shift every
// `.ir` snapshot. Import it explicitly:  #import "modules/std/meta.sx";
//
// `reify` / `type_info` / `field_type` are comptime-only builtins — a `reify`
// reached at runtime is a hard error (the type must be minted at compile time).

// One variant of a reify'd enum: a name plus an optional payload type.
// `payload = void` means a tagless variant (e.g. `closed`).
EnumVariant :: struct {
    name: string;
    payload: Type;
}

// The shape of an enum/tagged-union being reflected or constructed.
EnumInfo :: struct {
    variants: []EnumVariant;
}

// The reflected/constructed type shape. A tagged union over the kinds of type
// `reify` can mint. Phase 0 ships only `` .`enum ``; struct/tuple land later.
// The variant uses the backtick raw-identifier escape so it reads as the
// keyword `enum` (`` reify(.`enum(...)) ``) rather than a mangled `enum_`.
TypeInfo :: enum {
    `enum: EnumInfo;
}

// The compiler's ONLY type-construction primitives (comptime-only #builtins):
//   declare()            — mint a NEW empty (undefined) nominal type, returned
//                          as a `Type` handle. Using it before `define` is a
//                          loud error. References to it (`*Self`) are fine.
//   define(handle, info) — fill a declared handle's body from a `TypeInfo`.
// `reify` and every other constructor below are PLAIN sx built over these — the
// compiler has no `reify` knowledge.
declare    :: () -> Type #builtin;
define     :: (handle: Type, info: TypeInfo) #builtin;
type_info  :: ($T: Type) -> TypeInfo #builtin;
field_type :: ($T: Type, idx: i64) -> Type #builtin;

// reify(info) — the one-shot, non-recursive sugar: declare + define + return.
// (Recursive / mutually-recursive types use the explicit declare/define split
// so the handle can be referenced inside its own definition.)
reify :: (info: TypeInfo) -> Type {
    h := declare();
    define(h, info);
    return h;
}

// --- Reify'd shapes built in sx library code (no new compiler machinery) ---
//
// The channel result types, expressed as type-fns over `reify`. They are the
// canonical demonstration that `reify` carries a full enum through codegen:
// `RecvResult(i64)` constructs and matches like any hand-written enum, and is
// one nominal type across sites (the type-fn mangled-name identity path). The
// channel library (N3) consumes these once it lands.

// A blocking recv: a value, or the channel was closed (drained).
RecvResult :: ($T: Type) -> Type {
    return reify(.enum(.{ variants = .[
        EnumVariant.{ name = "value",  payload = T    },
        EnumVariant.{ name = "closed", payload = void },
    ] }));
}

// A non-blocking try-recv: a value, currently empty, or closed — three states
// a bool can't express.
TryResult :: ($T: Type) -> Type {
    return reify(.enum(.{ variants = .[
        EnumVariant.{ name = "value",  payload = T    },
        EnumVariant.{ name = "empty",  payload = void },
        EnumVariant.{ name = "closed", payload = void },
    ] }));
}