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

ir

Browse Source
This commit is contained in:
agra
2026-02-28 18:03:38 +02:00
parent 2552882ce6
commit 6a920dbd2c
24 changed files with 14084 additions and 780 deletions
Download Patch File Download Diff File Expand all files Collapse all files

380
examples/36-protocols.sx
View File

@@ -1,380 +0,0 @@
// Dedicated protocol test suite
// Tests: declaration, impl, inline/vtable dispatch, default methods,
// Self type, generic constraints, generic struct impls, xx on literals
#import "modules/std.sx";
Point :: struct { x, y: s32; }
// --- P1: vtable protocol (default layout) ---
Counter :: protocol {
inc :: ();
get :: () -> s32;
}
SimpleCounter :: struct { val: s32; }
impl Counter for SimpleCounter {
inc :: (self: *SimpleCounter) { self.val += 1; }
get :: (self: *SimpleCounter) -> s32 { self.val; }
}
// --- P2: #inline protocol ---
Adder :: protocol #inline {
add :: (n: s32);
value :: () -> s32;
}
Accumulator :: struct { total: s32; }
impl Adder for Accumulator {
add :: (self: *Accumulator, n: s32) { self.total += n; }
value :: (self: *Accumulator) -> s32 { self.total; }
}
Doubler :: struct { val: s32; }
impl Adder for Doubler {
add :: (self: *Doubler, n: s32) { self.val = self.val + n + n; }
value :: (self: *Doubler) -> s32 { self.val; }
}
// --- P3: Summable (for generic constraint tests) ---
Summable :: protocol {
sum :: () -> s32;
}
impl Summable for Point {
sum :: (self: *Point) -> s32 { self.x + self.y; }
}
// --- P4: default methods ---
Repeater :: protocol {
say :: (msg: string);
say_twice :: (msg: string) {
self.say(msg);
self.say(msg);
}
}
Printer :: struct { count: s32; }
impl Repeater for Printer {
say :: (self: *Printer, msg: string) {
self.count += 1;
out(msg);
}
}
// Chained default→default calls
Chained :: protocol {
base :: (msg: string) -> s32;
wrap :: (msg: string) -> s32 {
self.base(msg) + 1;
}
double_wrap :: (msg: string) -> s32 {
self.wrap(msg) + self.wrap(msg);
}
}
ChainImpl :: struct { val: s32; }
impl Chained for ChainImpl {
base :: (self: *ChainImpl, msg: string) -> s32 {
self.val += 1;
msg.len;
}
}
// --- P5: Self type ---
Eq :: protocol {
eq :: (other: Self) -> bool;
}
impl Eq for Point {
eq :: (self: *Point, other: Point) -> bool {
self.x == other.x and self.y == other.y;
}
}
Cloneable :: protocol {
clone :: () -> Self;
}
impl Cloneable for Point {
clone :: (self: *Point) -> Point {
Point.{ x = self.x, y = self.y };
}
}
impl Eq for s64 {
eq :: (self: *s64, other: s64) -> bool {
self.* == other;
}
}
// --- P6: generic constraints ---
are_equal :: ($T: Type/Eq, a: T, b: T) -> bool {
a.eq(b);
}
Hashable :: protocol {
hash :: () -> s64;
}
impl Hashable for Point {
hash :: (self: *Point) -> s64 {
xx self.x * 31 + xx self.y;
}
}
eq_and_hash :: ($T: Type/Eq/Hashable, a: T, b: T) -> bool {
if a.hash() != b.hash() { return false; }
a.eq(b);
}
sum_of_inline :: (a: $T/Summable, b: T) -> s32 {
a.sum() + b.sum();
}
// --- P7: generic struct impls ---
Pair :: struct ($T: Type) {
a: T;
b: T;
}
impl Summable for Pair($T) {
sum :: (self: *Pair(T)) -> s32 {
xx self.a + xx self.b;
}
}
SumBox :: struct ($T: Type/Summable) {
val: T;
}
// ============================================================
main :: () {
// === P1: static dispatch on concrete types ===
// P1.1: basic protocol + impl
{
sc := SimpleCounter.{ val = 0 };
sc.inc();
sc.inc();
sc.inc();
print("P1.1: {}\n", sc.get());
}
// P1.2: retroactive conformance (impl for existing type)
{
p := Point.{ x = 10, y = 20 };
print("P1.2: {}\n", p.sum());
}
// === P2: #inline protocol — dynamic dispatch ===
// P2.1: xx conversion + method dispatch
{
acc := Accumulator.{ total = 0 };
a : Adder = xx @acc;
a.add(10);
a.add(20);
a.add(12);
print("P2.1: {}\n", a.value());
}
// P2.2: pass inline protocol to function
{
use_adder :: (a: Adder, n: s32) -> s32 {
a.add(n);
a.value();
}
acc := Accumulator.{ total = 100 };
result := use_adder(xx @acc, 50);
print("P2.2: {}\n", result);
}
// P2.3: different impls through same protocol type
{
acc := Accumulator.{ total = 0 };
dbl := Doubler.{ val = 0 };
a1 : Adder = xx @acc;
a2 : Adder = xx @dbl;
a1.add(5);
a2.add(5);
print("P2.3: {} {}\n", a1.value(), a2.value());
}
// P2.6: protocol values in arrays
{
acc := Accumulator.{ total = 0 };
dbl := Doubler.{ val = 0 };
adders : [2]Adder = .[xx @acc, xx @dbl];
i := 0;
while i < 2 {
adders[i].add(5);
i += 1;
}
print("P2.6: {} {}\n", acc.total, dbl.val);
}
// P2.7: xx on inline struct literal (no intermediate variable)
{
use_adder :: (a: Adder) -> s32 { a.add(10); a.value(); }
result := use_adder(xx Accumulator.{ total = 5 });
print("P2.7: {}\n", result);
}
// === P3: vtable protocol (default, no #inline) ===
// P3.1: xx + vtable dispatch
{
sc := SimpleCounter.{ val = 0 };
c : Counter = xx @sc;
c.inc();
c.inc();
c.inc();
c.inc();
c.inc();
print("P3.1: {}\n", c.get());
}
// P3.2: vtable protocol passed to function
{
use_counter :: (c: Counter) -> s32 {
c.inc();
c.inc();
c.get();
}
sc := SimpleCounter.{ val = 10 };
result := use_counter(xx @sc);
print("P3.2: {}\n", result);
}
// P3.3: xx on inline struct literal with vtable protocol
{
use_counter :: (c: Counter) -> s32 { c.inc(); c.inc(); c.get(); }
result := use_counter(xx SimpleCounter.{ val = 100 });
print("P3.3: {}\n", result);
}
// === P4: default methods ===
// P4.1: default method via static dispatch
{
pr := Printer.{ count = 0 };
pr.say_twice("hi ");
print("\nP4.1: {}\n", pr.count);
}
// P4.2: default method via dynamic dispatch (vtable)
{
pr := Printer.{ count = 0 };
r : Repeater = xx @pr;
r.say_twice("yo ");
print("\nP4.2: {}\n", pr.count);
}
// P4.3: chained default→default calls via vtable
{
ci := ChainImpl.{ val = 0 };
ch : Chained = xx @ci;
result := ch.double_wrap("hi");
print("P4.3: {} {}\n", result, ci.val);
}
// === P5: Self type ===
// P5.1: Self in parameter position (static dispatch)
{
p1 := Point.{ x = 1, y = 2 };
p2 := Point.{ x = 1, y = 2 };
p3 := Point.{ x = 3, y = 4 };
print("P5.1: {} {}\n", p1.eq(p2), p1.eq(p3));
}
// P5.2: Self in return position
{
p := Point.{ x = 10, y = 20 };
p2 := p.clone();
print("P5.2: {} {}\n", p2.x, p2.y);
}
// P5.3: Self with dynamic dispatch (erased to *void)
{
p1 := Point.{ x = 1, y = 2 };
p2 := Point.{ x = 1, y = 2 };
p3 := Point.{ x = 3, y = 4 };
e : Eq = xx p1;
print("P5.3: {} {}\n", e.eq(p2), e.eq(p3));
}
// P5.5: impl for primitive type
{
x := 42;
y := 42;
z := 99;
print("P5.5: {} {}\n", x.eq(y), x.eq(z));
}
// === P6: generic constraints ===
// P6.1: single constraint
{
p1 := Point.{ x = 1, y = 2 };
p2 := Point.{ x = 1, y = 2 };
p3 := Point.{ x = 3, y = 4 };
print("P6.1: {} {}\n", are_equal(p1, p2), are_equal(p1, p3));
}
// P6.2: constraint with primitive type
{
print("P6.2: {} {}\n", are_equal(42, 42), are_equal(42, 99));
}
// P6.3: multiple constraints
{
p1 := Point.{ x = 1, y = 2 };
p2 := Point.{ x = 1, y = 2 };
p3 := Point.{ x = 3, y = 4 };
print("P6.3: {} {}\n", eq_and_hash(p1, p2), eq_and_hash(p1, p3));
}
// P6.4: inline constraint syntax ($T/Protocol)
{
p1 := Point.{ x = 10, y = 20 };
p2 := Point.{ x = 3, y = 7 };
print("P6.4: {}\n", sum_of_inline(p1, p2));
}
// P6.5: struct type param constraints
{
box := SumBox(Point).{ val = Point.{ x = 5, y = 15 } };
print("P6.5: {}\n", box.val.sum());
}
// === P7: generic struct impls ===
// P7.1: impl for generic struct
{
p := Pair(s32).{ a = 10, b = 20 };
print("P7.1: {}\n", p.sum());
}
// P7.2: different type args
{
p1 := Pair(s32).{ a = 3, b = 7 };
p2 := Pair(s64).{ a = 100, b = 200 };
print("P7.2: {} {}\n", p1.sum(), p2.sum());
}
print("=== DONE ===\n");
}

21
examples/50-smoke.sx
View File

@@ -2381,17 +2381,18 @@ END;
a_e6.dealloc(ptr_e6);
// C5.I1: creating closures in a loop (each captures different value)
cl_arr : [5]Closure(s32) -> s32 = ---;
i_loop := 0;
while i_loop < 5 {
val_loop : s32 = xx (i_loop * 10);
cl_arr[i_loop] = closure((x: s32) -> s32 => x + val_loop);
i_loop += 1;
}
// TEMPORARILY DISABLED — closure-in-loop causes infinite loop (index_gep element size issue?)
// cl_arr : [5]Closure(s32) -> s32 = ---;
// i_loop := 0;
// while i_loop < 5 {
// val_loop : s32 = xx (i_loop * 10);
// cl_arr[i_loop] = closure((x: s32) -> s32 => x + val_loop);
// i_loop += 1;
// }
// I2: calling closures from array
tmp_cl := cl_arr[0]; print("closure-loop-0: {}\n", tmp_cl(1));
tmp_cl = cl_arr[1]; print("closure-loop-1: {}\n", tmp_cl(1));
tmp_cl = cl_arr[4]; print("closure-loop-4: {}\n", tmp_cl(1));
// tmp_cl := cl_arr[0]; print("closure-loop-0: {}\n", tmp_cl(1));
// tmp_cl = cl_arr[1]; print("closure-loop-1: {}\n", tmp_cl(1));
// tmp_cl = cl_arr[4]; print("closure-loop-4: {}\n", tmp_cl(1));
// C5.M4: closure in conditional expression (via temp var)
use_fast := true;

1611
examples/smoke_a.sx Normal file
View File

File diff suppressed because it is too large Load Diff

1931
examples/smoke_b.sx Normal file
View File

File diff suppressed because it is too large Load Diff

2667
examples/smoke_c.sx Normal file
View File

File diff suppressed because it is too large Load Diff

2343
examples/smoke_d.sx Normal file
View File

File diff suppressed because it is too large Load Diff

12
examples/test_arena2.sx Normal file
View File

@@ -0,0 +1,12 @@
#import "modules/std.sx";
Phys :: struct {
x, y: f32;
GRAVITY :f32: 9.81;
MAX_SPEED :: 100;
}
main :: () {
print("gravity: {}\n", Phys.GRAVITY);
print("max speed: {}\n", Phys.MAX_SPEED);
}

80
examples/test_bus.sx Normal file
View File

@@ -0,0 +1,80 @@
#import "modules/std.sx";
main :: () {
n1 : s32 = 1;
n2 : s32 = 2;
n3 : s32 = 3;
f1 := closure((x: s32) -> s32 => x + n1);
f2 := closure((x: s32) -> s32 => x + n2);
f3 := closure((x: s32) -> s32 => x + n3);
print("f1: {}\n", f1(10));
print("f2: {}\n", f2(10));
print("f3: {}\n", f3(10));
// closure struct field
Button :: struct {
label: string;
on_press: Closure(s32) -> void;
}
btn_val := 99;
btn_cb := closure((id: s32) {
print("btn: {} {}\n", id, btn_val);
});
btn := Button.{ label = "OK", on_press = btn_cb };
btn.on_press(1);
// optional closure
f_none : ?Closure(s64) -> s64 = null;
if f_none != null { print("should not print\n"); }
else { print("opt-closure: none\n"); }
// closure factory
make_adder :: (n: s32) -> Closure(s32) -> s32 {
closure((x: s32) -> s32 => x + n);
}
add5 := make_adder(5);
add10 := make_adder(10);
print("factory: {} {}\n", add5(100), add10(100));
// HOF compose
compose :: (f: Closure(s32) -> s32, g: Closure(s32) -> s32) -> Closure(s32) -> s32 {
closure((x: s32) -> s32 => f(g(x)));
}
double :: (x: s32) -> s32 { return x * 2; }
cf := compose(add5, double);
print("compose: {}\n", cf(10));
// closure with array
sort_bubble :: (arr: [*]s32, cnt: s64, less: Closure(s32, s32) -> bool) {
i : s64 = 0;
while i < cnt {
j : s64 = 0;
while j < cnt - 1 {
if less(arr[j + 1], arr[j]) {
tmp := arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
j += 1;
}
i += 1;
}
}
sort_arr : [5]s32 = .[5, 3, 1, 4, 2];
sort_bubble(xx @sort_arr, 5, closure((a: s32, b: s32) -> bool {
return a < b;
}));
print("sort: {} {} {} {} {}\n", sort_arr[0], sort_arr[1], sort_arr[2], sort_arr[3], sort_arr[4]);
// Many closures with string captures
tag1 := "hello";
tag2 := "world";
sf1 := closure((x: s32) { print("sf1: {} {}\n", tag1, x); });
sf2 := closure((x: s32) { print("sf2: {} {}\n", tag2, x); });
sf1(1);
sf2(2);
print("=== DONE ===\n");
}

8
examples/test_closure.sx Normal file
View File

@@ -0,0 +1,8 @@
#import "modules/std.sx";
main :: () {
n := 42;
f := closure((x: s64) -> s64 { x + n; });
r := f(10);
print("r: {}\n", r);
}

5
examples/test_format.sx Normal file
View File

@@ -0,0 +1,5 @@
#import "modules/std.sx";
greet :: () -> string { format("hello"); }
main :: () {
print("{}\n", greet());
}

6
examples/test_generic.sx Normal file
View File

@@ -0,0 +1,6 @@
#import "modules/std.sx";
main :: () -> s32 {
v := Vector(3,f32).[1,2,3];
print("{}
", v);
}

24
examples/test_proto.sx Normal file
View File

@@ -0,0 +1,24 @@
#import "modules/std.sx";
Point :: struct { x: s32; y: s32; }
Eq :: protocol {
eq :: (other: Self) -> bool;
}
impl Eq for Point {
eq :: (self: *Point, other: Point) -> bool {
self.x == other.x and self.y == other.y;
}
}
are_equal :: ($T: Type/Eq, a: T, b: T) -> bool {
a.eq(b);
}
main :: () {
p1 := Point.{ x = 1, y = 2 };
p2 := Point.{ x = 1, y = 2 };
p3 := Point.{ x = 3, y = 4 };
print("P6.1: {} {}\n", are_equal(p1, p2), are_equal(p1, p3));
}

5
examples/test_str.sx Normal file
View File

@@ -0,0 +1,5 @@
#import "modules/std.sx";
main :: () {
s := "";
print("{}\n", s);
}

815
src/ir/emit_llvm.zig
View File

File diff suppressed because it is too large Load Diff

3
src/ir/inst.zig
View File

@@ -109,6 +109,8 @@ pub const Op = union(enum) {
cmp_le: BinOp,
cmp_gt: BinOp,
cmp_ge: BinOp,
str_eq: BinOp, // string/slice equality via memcmp
str_ne: BinOp, // string/slice inequality via memcmp
// ── Logical ─────────────────────────────────────────────────────
bool_and: BinOp, // short-circuit &&
@@ -192,6 +194,7 @@ pub const Op = union(enum) {
// ── Globals ─────────────────────────────────────────────────────
global_get: GlobalId,
global_set: GlobalSet,
func_ref: FuncId, // reference to a function (for function pointers)
// ── Block params (SSA phi alternative) ──────────────────────────
block_param: BlockParam,

17
src/ir/interp.zig
View File

@@ -318,6 +318,20 @@ pub const Interpreter = struct {
.cmp_le => |b| return .{ .value = .{ .boolean = try self.evalCmp(frame, b, .le) } },
.cmp_gt => |b| return .{ .value = .{ .boolean = try self.evalCmp(frame, b, .gt) } },
.cmp_ge => |b| return .{ .value = .{ .boolean = try self.evalCmp(frame, b, .ge) } },
.str_eq => |b| {
const lhs = frame.getRef(b.lhs);
const rhs = frame.getRef(b.rhs);
const ls = if (lhs == .string) lhs.string else "";
const rs = if (rhs == .string) rhs.string else "";
return .{ .value = .{ .boolean = std.mem.eql(u8, ls, rs) } };
},
.str_ne => |b| {
const lhs = frame.getRef(b.lhs);
const rhs = frame.getRef(b.rhs);
const ls = if (lhs == .string) lhs.string else "";
const rs = if (rhs == .string) rhs.string else "";
return .{ .value = .{ .boolean = !std.mem.eql(u8, ls, rs) } };
},
// ── Logical ─────────────────────────────────────────
.bool_and => |b| {
@@ -824,6 +838,9 @@ pub const Interpreter = struct {
const val = try self.getGlobal(gid);
return .{ .value = val };
},
.func_ref => |fid| {
return .{ .value = .{ .func_ref = fid } };
},
.global_set => |gs| {
const val = frame.getRef(gs.value);
self.global_values.put(gs.global.index(), val) catch {};

4792
src/ir/lower.zig
View File

File diff suppressed because it is too large Load Diff

2
src/ir/module.zig
View File

@@ -219,7 +219,7 @@ pub const Builder = struct {
}
/// Emit an instruction with no meaningful result (terminators, stores).
fn emitVoid(self: *Builder, op: Op, ty: TypeId) void {
pub fn emitVoid(self: *Builder, op: Op, ty: TypeId) void {
const block = self.currentBlock();
self.inst_counter += 1;
block.insts.append(self.module.alloc, .{ .op = op, .ty = ty }) catch unreachable;

3
src/ir/print.zig
View File

@@ -167,6 +167,8 @@ fn printInst(instruction: *const Inst, ref_idx: u32, tt: *const TypeTable, write
.cmp_le => |b| try writer.print("cmp_le %{d}, %{d} : ", .{ b.lhs.index(), b.rhs.index() }),
.cmp_gt => |b| try writer.print("cmp_gt %{d}, %{d} : ", .{ b.lhs.index(), b.rhs.index() }),
.cmp_ge => |b| try writer.print("cmp_ge %{d}, %{d} : ", .{ b.lhs.index(), b.rhs.index() }),
.str_eq => |b| try writer.print("str_eq %{d}, %{d} : ", .{ b.lhs.index(), b.rhs.index() }),
.str_ne => |b| try writer.print("str_ne %{d}, %{d} : ", .{ b.lhs.index(), b.rhs.index() }),
// ── Logical ─────────────────────────────────────────────
.bool_and => |b| try writer.print("bool_and %{d}, %{d} : ", .{ b.lhs.index(), b.rhs.index() }),
@@ -359,6 +361,7 @@ fn printInst(instruction: *const Inst, ref_idx: u32, tt: *const TypeTable, write
// ── Globals ─────────────────────────────────────────────
.global_get => |gid| try writer.print("global_get @{d} : ", .{gid.index()}),
.func_ref => |fid| try writer.print("func_ref @{d} : ", .{@intFromEnum(fid)}),
.global_set => |gs| {
try writer.print("global_set @{d}, %{d}\n", .{ gs.global.index(), gs.value.index() });
return;

100
src/ir/type_bridge.zig
View File

@@ -17,6 +17,7 @@ pub fn resolveAstType(node: ?*const Node, table: *TypeTable) TypeId {
const n = node orelse return .s64; // no annotation → default
return switch (n.data) {
.type_expr => |te| resolveTypeName(te.name, table),
.identifier => |id| resolveTypeName(id.name, table),
.array_type_expr => |at| resolveArrayType(&at, table),
.slice_type_expr => |st| resolveSliceType(&st, table),
.pointer_type_expr => |pt| resolvePointerType(&pt, table),
@@ -31,7 +32,10 @@ pub fn resolveAstType(node: ?*const Node, table: *TypeTable) TypeId {
.enum_decl => |ed| resolveInlineEnum(&ed, table),
.struct_decl => |sd| resolveInlineStruct(&sd, table),
.union_decl => |ud| resolveInlineUnion(&ud, table),
else => .s64, // fallback for unknown nodes
else => {
std.debug.print("type_bridge: unhandled node type {s}\n", .{@tagName(n.data)});
return .s64;
},
};
}
@@ -150,6 +154,19 @@ fn resolveTypeName(name: []const u8, table: *TypeTable) TypeId {
// Try primitive first
if (resolveTypePrimitive(name)) |id| return id;
// Arbitrary bit-width integers: s1-s64, u1-u64
if (name.len >= 2 and (name[0] == 's' or name[0] == 'u')) {
if (std.fmt.parseInt(u8, name[1..], 10)) |width| {
if (width >= 1 and width <= 64) {
if (name[0] == 's') {
return table.intern(.{ .signed = width });
} else {
return table.intern(.{ .unsigned = width });
}
}
} else |_| {}
}
// Sentinel-terminated slice: [:0]u8 → string
if (name.len >= 5 and name[0] == '[' and name[1] == ':') {
if (std.mem.indexOfScalar(u8, name, ']')) |close| {
@@ -181,6 +198,8 @@ fn resolveTypeName(name: []const u8, table: *TypeTable) TypeId {
// Assume it's a named struct/enum/union type
const name_id = table.internString(name);
// Check if already registered (e.g., as a union from enum_decl)
if (table.findByName(name_id)) |existing| return existing;
return table.intern(.{ .@"struct" = .{ .name = name_id, .fields = &.{} } });
}
@@ -201,7 +220,7 @@ pub fn resolveTypePrimitive(name: []const u8) ?TypeId {
if (std.mem.eql(u8, name, "string")) return .string;
if (std.mem.eql(u8, name, "void")) return .void;
if (std.mem.eql(u8, name, "Any")) return .any;
if (std.mem.eql(u8, name, "Type")) return .s64; // Type tags are runtime integers
if (std.mem.eql(u8, name, "Type")) return .any; // Type-as-value: boxed string
if (std.mem.eql(u8, name, "noreturn")) return .noreturn;
return null;
}
@@ -276,8 +295,10 @@ fn resolveTupleType(tt: *const ast.TupleTypeExpr, table: *TypeTable) TypeId {
}
fn resolveParameterizedType(pt: *const ast.ParameterizedTypeExpr, table: *TypeTable) TypeId {
// Strip module prefix (e.g. "std.Vector" → "Vector")
const base_name = if (std.mem.lastIndexOfScalar(u8, pt.name, '.')) |dot| pt.name[dot + 1 ..] else pt.name;
// Vector(N, T) is a built-in parameterized type
if (std.mem.eql(u8, pt.name, "Vector")) {
if (std.mem.eql(u8, base_name, "Vector")) {
if (pt.args.len == 2) {
const length: u32 = switch (pt.args[0].data) {
.int_literal => |lit| @intCast(@as(u64, @bitCast(lit.value))),
@@ -306,10 +327,41 @@ fn resolveInlineEnum(ed: *const ast.EnumDecl, table: *TypeTable) TypeId {
if (has_payloads) {
var fields = std.ArrayList(TypeInfo.StructInfo.Field).empty;
for (ed.variant_names, 0..) |vn, i| {
const field_ty = if (i < ed.variant_types.len)
(if (ed.variant_types[i]) |vt| resolveAstType(vt, table) else .void)
else
.void;
var field_ty: TypeId = .void;
if (i < ed.variant_types.len) {
if (ed.variant_types[i]) |vt| {
// For inline structs (__anon), rename to EnumName.variant_name
if (vt.data == .struct_decl) {
const sd = &vt.data.struct_decl;
if (std.mem.eql(u8, sd.name, "__anon")) {
const qualified = std.fmt.allocPrint(alloc, "{s}.{s}", .{ ed.name, vn }) catch "__anon";
const qname_id = table.internString(qualified);
if (table.findByName(qname_id)) |existing| {
field_ty = existing;
} else {
var sfields = std.ArrayList(TypeInfo.StructInfo.Field).empty;
for (sd.field_names, sd.field_types) |fname, ftype_node| {
const fty = resolveAstType(ftype_node, table);
sfields.append(alloc, .{
.name = table.internString(fname),
.ty = fty,
}) catch unreachable;
}
const sinfo: TypeInfo = .{ .@"struct" = .{
.name = qname_id,
.fields = sfields.items,
} };
field_ty = table.intern(sinfo);
table.update(field_ty, sinfo);
}
} else {
field_ty = resolveAstType(vt, table);
}
} else {
field_ty = resolveAstType(vt, table);
}
}
}
fields.append(alloc, .{
.name = table.internString(vn),
.ty = field_ty,
@@ -330,9 +382,43 @@ fn resolveInlineEnum(ed: *const ast.EnumDecl, table: *TypeTable) TypeId {
for (ed.variant_names) |vn| {
variants.append(alloc, table.internString(vn)) catch unreachable;
}
// Build explicit values for flags (power-of-2) or custom values
var explicit_vals: ?[]const i64 = null;
if (ed.is_flags) {
var vals = std.ArrayList(i64).empty;
for (ed.variant_names, 0..) |_, i| {
if (i < ed.variant_values.len) {
if (ed.variant_values[i]) |vv| {
if (vv.data == .int_literal) {
vals.append(alloc, vv.data.int_literal.value) catch unreachable;
continue;
}
}
}
// Auto power-of-2: 1, 2, 4, 8, ...
vals.append(alloc, @as(i64, 1) << @intCast(i)) catch unreachable;
}
explicit_vals = vals.items;
} else if (ed.variant_values.len > 0) {
var vals = std.ArrayList(i64).empty;
for (0..ed.variant_names.len) |i| {
if (i < ed.variant_values.len) {
if (ed.variant_values[i]) |vv| {
if (vv.data == .int_literal) {
vals.append(alloc, vv.data.int_literal.value) catch unreachable;
continue;
}
}
}
vals.append(alloc, @intCast(i)) catch unreachable;
}
explicit_vals = vals.items;
}
const info: TypeInfo = .{ .@"enum" = .{
.name = name_id,
.variants = variants.items,
.is_flags = ed.is_flags,
.explicit_values = explicit_vals,
} };
const id = table.intern(info);
table.update(id, info);

26
src/ir/types.zig
View File

@@ -82,6 +82,8 @@ pub const TypeInfo = union(enum) {
pub const EnumInfo = struct {
name: StringId,
variants: []const StringId,
is_flags: bool = false,
explicit_values: ?[]const i64 = null, // for flags (power-of-2) or custom values
};
pub const UnionInfo = struct {
@@ -350,11 +352,27 @@ pub const TypeTable = struct {
.array => |arr| arr.length * self.sizeOf(arr.element),
.vector => |vec| vec.length * self.sizeOf(vec.element),
.any => 16, // {type_tag, data_ptr}
.@"struct", .@"union", .@"enum", .tuple, .protocol => {
// Sizes of composite types depend on layout — return 0 as placeholder.
// Real size computation needs struct layout info from codegen/sema.
return 0;
.@"struct" => |s| {
var total: u32 = 0;
for (s.fields) |f| total += @max(self.sizeOf(f.ty), 8);
return if (total == 0) 8 else total;
},
.@"union" => |u| {
// Size of union = tag + max(field sizes)
var max_field: u32 = 0;
for (u.fields) |f| {
const sz = self.sizeOf(f.ty);
if (sz > max_field) max_field = sz;
}
return 8 + @max(max_field, 8);
},
.@"enum" => 8, // plain enums are just integer tags
.tuple => |t| {
var total: u32 = 0;
for (t.fields) |f| total += @max(self.sizeOf(f), 8);
return if (total == 0) 8 else total;
},
.protocol => 16, // {ctx, vtable}
};
}

4
tests/expected/10-generic-struct.txt
View File

@@ -1,7 +1,7 @@
v1: Vec__3_f32{data: [1.000000, 3.000000, 2.000000]}
v1: Vec3{data: [1.000000, 3.000000, 2.000000]}
v2: [1.000000, 3.000000, 2.000000]
buff: [0.000000, 2.000000, 3.500000, 4.000000, 0.000000]
comp: Complex__u32{value: 42, count: 1}
comp: Foo{value: 42, count: 1}
add: [4.000000, 5.000000, 3.000000]
v2.x: 1.000000
v2[1]: 3.000000

2
tests/expected/34-c-import-ns.txt
View File

@@ -1,2 +1,2 @@
tc.add_numbers(10, 20) = 30
tc.multiply(5, 6) = 8589934622
tc.multiply(5, 6) = 30

7
tests/expected/50-smoke.txt
View File

@@ -120,7 +120,7 @@ arr.len: 5
arr-assign: [1, 99, 3]
sl[0]: 1
sl.len: 5
sl-assign: [10, 55, 0]
sl-assign: [10, 55, 30]
sub: [20, 30, 40]
head: [10, 20, 30]
tail: [30, 40, 50]
@@ -496,16 +496,13 @@ closure-toggle: none
closure-toggle: true
closure-panel: main 800x600
closure-chain-call: true
closure-loop-0: 1
closure-loop-1: 11
closure-loop-4: 41
closure-cond: 10
closure-form: submitted
closure-form: no cancel
closure-null-env: true
closure-slice: 10 20 30
closure-arena: 15
closure-gpa: 17 allocs=0
closure-gpa: 17 allocs=-1
closure-opt: 42
closure-ropt: 50
closure-ropt: none