lab/sx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

P5.7 Step D: re-express metatype declare() as sx over declare_type

Browse Source 
declare(name) is now an ordinary sx fn in modules/std/meta.sx that calls the
abi(.compiler) declare_type primitive — both mint/find the same forward nominal
slot. Removed the bespoke .declare arm from callBuiltinVm and the BuiltinId.declare
member; dropped the declare interception in tryLowerReflectionCall (the call now
routes to the sx fn). preregisterForwardTypes still scans for the literal
declare("Name") spelling so *Name self-references forward-register before the
body lowers (0618). define/type_info/field_type remain builtins.
This commit is contained in:
agra
2026-06-19 20:58:34 +03:00
parent 61f5700a36
commit 8850fcce70
4 changed files with 55 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/ir/comptime_vm.zig
View File

@@ -1900,14 +1900,9 @@ pub const Vm = struct {
/// parity holds). Keeps BOTH paths alive during the VM-default transition.
fn callBuiltinVm(self: *Vm, bi: inst_mod.BuiltinCall, ins_ty: TypeId, frame: *Frame, ref_types: []const TypeId) Error!?Reg {
switch (bi.builtin) {
// declare(name) → mint an EMPTY nominal slot, returned as a Type value.
.declare => {
const table = try self.requireTable();
if (bi.args.len != 1) return self.failMsg("comptime declare: expected (name)");
const s = frame.get(bi.args[0].index()); // string fat-pointer Addr
const text = try self.machine.bytes(try self.sliceData(table, s), @intCast(try self.sliceLen(s)));
return @as(Reg, (self.declareNominal(table, text)).index());
},
// `declare(name)` is no longer a builtin — it's plain sx in
// `modules/std/meta.sx` over the `declare_type` compiler-API primitive
// (`callCompilerFn`). The `.declare` BuiltinId was removed with it.
// define(handle, info) → complete the declared slot from a TypeInfo VALUE.
.define => {
const table = try self.requireTable();

13
src/ir/inst.zig
View File

@@ -452,17 +452,14 @@ pub const BuiltinId = enum(u16) {
type_eq,
type_is_unsigned,
has_impl,
// The compiler's ONLY comptime type-CONSTRUCTION primitives. Higher-level
// The comptime type-CONSTRUCTION terminator builtin. Higher-level
// constructors (one-shot, channel-result, etc.) are ordinary sx built over
// these — the compiler knows none of them by name. Both are comptime-only
// (the interp mutates the type table via its
// `mint` handle); reaching them at runtime / emit is a hard error.
// declare() → mint an EMPTY (undefined) nominal slot, returned
// as a `Type` value. Using the slot before its
// `define` is a loud diagnostic.
// it — the compiler knows none of them by name. Comptime-only (the comptime
// VM mutates the type table); reaching it at runtime / emit is a hard error.
// (`declare` is no longer a builtin — it's plain sx over the `declare_type`
// compiler-API primitive in `modules/std/meta.sx`.)
// define(handle, info) → decode the `TypeInfo` VALUE (the name travels in
// it) and complete the slot.
declare,
define,
// The comptime reflection INVERSE of `define`: read a type's variants
// (name + payload type) out of the type table and CONSTRUCT the same

22
src/ir/lower/call.zig
View File

@@ -1677,22 +1677,12 @@ pub fn tryLowerReflectionCall(self: *Lowering, name: []const u8, c: *const ast.C
// classification covers all 7; it runs before dispatch.
if (self.reflectionTypeArgGuard(name, c)) |sentinel| return sentinel;
if (std.mem.eql(u8, name, "declare")) {
// Comptime type-construction primitive: mint an empty nominal slot NAMED
// by its (compile-time string) argument. Comptime-only — emitted as a
// builtin_call the interp executes against its `mint` table; never
// reaches codegen (its sx callers are only ever comptime-evaluated).
if (c.args.len != 1) {
if (self.diagnostics) |d| d.addFmt(.err, c.callee.span, "declare(name) takes one string argument", .{});
return Ref.none;
}
// The named forward type is pre-registered by `evalComptimeType`'s
// `preregisterForwardTypes` before this body lowers (so a `*Name`
// self-reference resolves); the interp's `declare` returns that slot.
const name_ref = self.lowerExpr(c.args[0]);
const args_owned = self.alloc.dupe(Ref, &.{name_ref}) catch return Ref.none;
return self.builder.callBuiltin(.declare, args_owned, .type_value);
}
// `declare(name)` is now an ordinary sx function (`modules/std/meta.sx`)
// written over the `abi(.compiler)` primitive `declare_type` — no longer
// intercepted here. (`preregisterForwardTypes` still scans for the literal
// `declare("Name")` spelling so a `*Name` self-reference forward-registers
// before the body lowers; the sx `declare` calls `declare_type`, which
// returns that same forward slot.)
if (std.mem.eql(u8, name, "define")) {
// Comptime type-construction primitive: complete a declare()'d slot
// from a TypeInfo value. `define(handle, info)`.