Add enum variant constructors to VM

synapticvoid · synapticvoid · commit ff9b7dba1cb3 · 2026-04-01T10:54:44.000+02:00
Close #50
diff --git a/src/tests/bytecode_vm_test.zig b/src/tests/bytecode_vm_test.zig
@@ -1172,3 +1172,144 @@ test "compiler: nested field access a.b.c" {
     const result = try runCompiled(allocator, &.{ point_decl, line_decl, p_decl, l_decl }, .{ .field_access = fa_x });
     try std.testing.expect(result.eql(.{ .int = 3 }));
 }
+
+// ===========================================================================
+// Step 7: Enum variant constructors
+// ===========================================================================
+
+test "compiler: enum zero-field variant construction" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    // enum Color { Red, Green }
+    const variants = [_]ast.Statement.Variant{
+        .{ .name = ident("Red"), .fields = &.{} },
+        .{ .name = ident("Green"), .fields = &.{} },
+    };
+    const enum_decl = ast.Statement{ .enum_declaration = .{
+        .name = ident("Color"),
+        .is_error = false,
+        .variants = &variants,
+    } };
+
+    // Color.Red()
+    const fa = try allocator.create(ast.Expression.FieldAccess);
+    fa.* = .{ .object = .{ .variable = .{ .token = ident("Color") } }, .name = ident("Red") };
+    const call = try allocator.create(ast.Expression.FnCall);
+    call.* = .{ .callee = .{ .field_access = fa }, .args = &.{} };
+
+    const result = try runCompiled(allocator, &.{enum_decl}, .{ .fn_call = call });
+    try std.testing.expect(result == .struct_instance);
+    try std.testing.expectEqualStrings("Color.Red", result.struct_instance.type_name);
+    try std.testing.expectEqual(@as(usize, 0), result.struct_instance.field_values.len);
+}
+
+test "compiler: enum variant with fields" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    // enum Shape { Circle(const radius: Int) }
+    const circle_fields = [_]ast.Statement.FieldDeclaration{
+        .{ .name = ident("radius"), .type_annotation = dummyType(), .mutability = .constant, .default_value = null },
+    };
+    const variants = [_]ast.Statement.Variant{
+        .{ .name = ident("Circle"), .fields = &circle_fields },
+    };
+    const enum_decl = ast.Statement{ .enum_declaration = .{
+        .name = ident("Shape"),
+        .is_error = false,
+        .variants = &variants,
+    } };
+
+    // Shape.Circle(5)
+    const fa = try allocator.create(ast.Expression.FieldAccess);
+    fa.* = .{ .object = .{ .variable = .{ .token = ident("Shape") } }, .name = ident("Circle") };
+    const args = [_]ast.Expression{
+        .{ .literal = .{ .token = ident("5"), .value = .{ .int = 5 } } },
+    };
+    const call = try allocator.create(ast.Expression.FnCall);
+    call.* = .{ .callee = .{ .field_access = fa }, .args = &args };
+
+    const result = try runCompiled(allocator, &.{enum_decl}, .{ .fn_call = call });
+    try std.testing.expect(result == .struct_instance);
+    try std.testing.expectEqualStrings("Shape.Circle", result.struct_instance.type_name);
+    try std.testing.expectEqual(@as(usize, 1), result.struct_instance.field_values.len);
+    try std.testing.expect(result.struct_instance.field_values[0].eql(.{ .int = 5 }));
+}
+
+test "compiler: qualified enum access resolves to correct variant" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    // enum Color { Red, Green }
+    const variants = [_]ast.Statement.Variant{
+        .{ .name = ident("Red"), .fields = &.{} },
+        .{ .name = ident("Green"), .fields = &.{} },
+    };
+    const enum_decl = ast.Statement{ .enum_declaration = .{
+        .name = ident("Color"),
+        .is_error = false,
+        .variants = &variants,
+    } };
+
+    // Color.Green()  — must resolve to Green, not Red
+    const fa = try allocator.create(ast.Expression.FieldAccess);
+    fa.* = .{ .object = .{ .variable = .{ .token = ident("Color") } }, .name = ident("Green") };
+    const call = try allocator.create(ast.Expression.FnCall);
+    call.* = .{ .callee = .{ .field_access = fa }, .args = &.{} };
+
+    const result = try runCompiled(allocator, &.{enum_decl}, .{ .fn_call = call });
+    try std.testing.expect(result == .struct_instance);
+    try std.testing.expectEqualStrings("Color.Green", result.struct_instance.type_name);
+}
+
+test "compiler: nested enum coercion" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    // enum Inner { A }
+    const inner_variants = [_]ast.Statement.Variant{
+        .{ .name = ident("A"), .fields = &.{} },
+    };
+    const inner_decl = ast.Statement{ .enum_declaration = .{
+        .name = ident("Inner"),
+        .is_error = false,
+        .variants = &inner_variants,
+    } };
+
+    // enum Outer { Inner, B }
+    // "Inner" has zero declared fields but matches a known enum → single-field wrapper
+    const outer_variants = [_]ast.Statement.Variant{
+        .{ .name = ident("Inner"), .fields = &.{} },
+        .{ .name = ident("B"), .fields = &.{} },
+    };
+    const outer_decl = ast.Statement{ .enum_declaration = .{
+        .name = ident("Outer"),
+        .is_error = false,
+        .variants = &outer_variants,
+    } };
+
+    // Inner.A()
+    const inner_fa = try allocator.create(ast.Expression.FieldAccess);
+    inner_fa.* = .{ .object = .{ .variable = .{ .token = ident("Inner") } }, .name = ident("A") };
+    const inner_call = try allocator.create(ast.Expression.FnCall);
+    inner_call.* = .{ .callee = .{ .field_access = inner_fa }, .args = &.{} };
+
+    // Outer.Inner(Inner.A())
+    const outer_fa = try allocator.create(ast.Expression.FieldAccess);
+    outer_fa.* = .{ .object = .{ .variable = .{ .token = ident("Outer") } }, .name = ident("Inner") };
+    const outer_args = [_]ast.Expression{.{ .fn_call = inner_call }};
+    const outer_call = try allocator.create(ast.Expression.FnCall);
+    outer_call.* = .{ .callee = .{ .field_access = outer_fa }, .args = &outer_args };
+
+    const result = try runCompiled(allocator, &.{ inner_decl, outer_decl }, .{ .fn_call = outer_call });
+    try std.testing.expect(result == .struct_instance);
+    try std.testing.expectEqualStrings("Outer.Inner", result.struct_instance.type_name);
+    try std.testing.expectEqual(@as(usize, 1), result.struct_instance.field_values.len);
+    try std.testing.expect(result.struct_instance.field_values[0] == .struct_instance);
+    try std.testing.expectEqualStrings("Inner.A", result.struct_instance.field_values[0].struct_instance.type_name);
+}
diff --git a/src/vm/compiler.zig b/src/vm/compiler.zig
@@ -31,6 +31,9 @@ pub const Compiler = struct {
     chunk: *Chunk,
     locals: std.ArrayList(Local),
     scope_depth: u32,
+    // Set of declared enum type names; used to detect when a zero-field variant references
+    // an existing enum (nested enum coercion at runtime)
+    known_enum_names: std.StringHashMapUnmanaged(void),
     allocator: std.mem.Allocator,
 
     // Static entry point to compile statements to a Program
@@ -41,6 +44,7 @@ pub const Compiler = struct {
             .chunk = &program.chunk,
             .locals = .{},
             .scope_depth = 0,
+            .known_enum_names = .{},
             .allocator = allocator,
         };
         errdefer compiler.deinit();
@@ -56,12 +60,14 @@ pub const Compiler = struct {
             .chunk = &program.chunk,
             .locals = .{},
             .scope_depth = 0,
+            .known_enum_names = .{},
             .allocator = allocator,
         };
     }
 
     pub fn deinit(self: *Compiler) void {
         self.locals.deinit(self.allocator);
+        self.known_enum_names.deinit(self.allocator);
     }
 
     // NOTE: -- Statements
@@ -81,8 +87,8 @@ pub const Compiler = struct {
             .var_declaration => |var_decl| try self.compileVarDeclarationStatement(var_decl),
             .fn_declaration => |fn_decl| try self.compileFnDeclarationStatement(fn_decl),
             .struct_declaration => |struct_decl| try self.compileStructDeclarationStatement(struct_decl),
+            .enum_declaration => |ed| try self.compileEnumDeclarationStatement(ed),
             .@"return" => |ret| try self.compileReturnStatement(ret),
-            else => return error.UnsupportedNode,
         }
     }
 
@@ -170,6 +176,46 @@ pub const Compiler = struct {
         _ = try self.program.addStructDef(struct_obj);
     }
 
+    fn compileEnumDeclarationStatement(self: *Compiler, ed: ast.Statement.EnumDeclaration) CompileError!void {
+        const enum_name = ed.name.lexeme;
+        for (ed.variants) |variant| {
+            // Build the qualified name EnumName.VariantName
+            const variant_name = variant.name.lexeme;
+            const type_name = try self.buildEnumVariantQualifiedName(enum_name, variant_name);
+
+            var field_names: [][]const u8 = undefined;
+
+            // Nesting an enum inside another?
+            // e.g: enum StaffRole { Admin, Member };
+            // enum AnyRole { StaffRole, Guest };
+            // When compiling AnyRole, StaffRole is already defined.
+            if (variant.fields.len == 0 and self.known_enum_names.contains(variant_name)) {
+                // Rather than redefining the enum, just reference it
+                const names = try self.allocator.alloc([]const u8, 1);
+                names[0] = variant_name;
+                field_names = names;
+            } else {
+                // Collect field_names
+                field_names = try self.allocator.alloc([]const u8, variant.fields.len);
+                for (variant.fields, 0..) |f, i| {
+                    field_names[i] = f.name.lexeme;
+                }
+            }
+
+            // The struct def is always a .case kind (for equality)
+            _ = try self.program.addStructDef(.{
+                .name = type_name,
+                .kind = .case,
+                .field_names = field_names,
+                .body_field_names = &.{},
+                .body_default_fn = null,
+            });
+        }
+
+        // Don't forget to add the enum to our known enum names
+        try self.known_enum_names.put(self.allocator, enum_name, {});
+    }
+
     fn compileReturnStatement(self: *Compiler, ret: ast.Statement.Return) CompileError!void {
         if (ret.value) |value| {
             try self.compileExpression(value);
@@ -353,6 +399,22 @@ pub const Compiler = struct {
     }
 
     fn compileFieldAccess(self: *Compiler, fa: *const ast.Expression.FieldAccess) CompileError!void {
+        // Access an enum variant
+        if (fa.object == .variable and self.known_enum_names.contains(fa.object.variable.token.lexeme)) {
+            const type_name = try self.buildEnumVariantQualifiedName(fa.object.variable.token.lexeme, fa.name.lexeme);
+            defer self.allocator.free(type_name);
+
+            // Search for a matching name
+            for (self.program.struct_defs.items, 0..) |def, i| {
+                if (std.mem.eql(u8, def.name, type_name)) {
+                    try self.emitConstant(.{ .struct_constructor = @intCast(i) }, fa.name.line);
+                    return;
+                }
+            }
+            return error.UndefinedStruct;
+        }
+
+        // Access a field
         try self.compileExpression(fa.object);
         const name_idx = try self.chunk.addConstant(.{ .string = fa.name.lexeme });
 
@@ -482,4 +544,14 @@ pub const Compiler = struct {
 
         return null;
     }
+
+    // Returns the qualified name EnumName.VariantName
+    fn buildEnumVariantQualifiedName(self: *Compiler, enum_name: []const u8, variant_name: []const u8) CompileError![]const u8 {
+        const type_name = try self.allocator.alloc(u8, enum_name.len + variant_name.len + 1);
+        @memcpy(type_name[0..enum_name.len], enum_name);
+        type_name[enum_name.len] = '.';
+        @memcpy(type_name[enum_name.len + 1 ..], variant_name);
+
+        return type_name;
+    }
 };
diff --git a/src/vm/value.zig b/src/vm/value.zig
@@ -16,13 +16,21 @@ pub const Value = union(enum) {
 
     // Builtin function
     native: NativeFn,
-    //
+
     // pointer so that copies of a value share identity (u2 = u1 means u1.field == u2.field)
     // var u1 = User("Bob");
     // var u2 = u1;
     // if (u1.name == u2.name) { ... } // true
     struct_instance: *StructInstance,
 
+    // Index of a struct constructor
+    // Stored in a struct defs table in Program
+    //
+    // This makes struct constructor first-class citizens:
+    // enum Color { Red };
+    // transform(Color.Red); // Constructor is passed as a variable
+    struct_constructor: u16,
+
     pub const StructInstance = struct {
         type_name: []const u8,
         field_names: []const []const u8,
@@ -71,6 +79,7 @@ pub const Value = union(enum) {
                 }
                 return true;
             },
+            .struct_constructor => |a| a == other.struct_constructor,
         };
     }
 
@@ -88,7 +97,11 @@ pub const Value = union(enum) {
             .boolean => |b| b,
             .int => |n| n != 0,
             .string => |s| s.len > 0,
-            .function, .native, .struct_instance => true,
+            .function,
+            .native,
+            .struct_instance,
+            .struct_constructor,
+            => true,
         };
     }
 
@@ -125,6 +138,7 @@ pub const Value = union(enum) {
                     },
                 }
             },
+            .struct_constructor => |sc| try writer.print("constructor<{d}>", .{sc}),
         }
     }
 };
diff --git a/src/vm/vm.zig b/src/vm/vm.zig
@@ -232,13 +232,53 @@ pub const Vm = struct {
                         },
                         .native => {
                             // Slice of the fn args
-                            const args = self.stack[base_slot + 1 .. base_slot + 1 + arity];
+                            const arg0_idx = base_slot + 1;
+                            const args = self.stack[arg0_idx .. arg0_idx + arity];
 
                             // Call builtin function, remove the args and push the return value
                             const ret_value = callee.native.func(args, self.ctx);
                             self.stack_top = base_slot;
                             self.push(ret_value);
                         },
+                        .struct_constructor => {
+                            // Stack: [ ..., constructor_value, arg0, arg1, ... ]
+                            //                    ^ base_slot
+                            const struct_def_idx = callee.struct_constructor;
+                            const def = self.program.struct_defs.items[struct_def_idx];
+
+                            // Check arity
+                            if (def.field_names.len != arity) {
+                                return error.ArityMismatch;
+                            }
+
+                            // Allocate args
+                            const arg0_idx = base_slot + 1;
+                            const args = self.stack[arg0_idx .. arg0_idx + def.field_names.len];
+                            var field_values = try self.allocator.alloc(Value, args.len);
+                            for (args, 0..) |arg, i| {
+                                field_values[i] = arg;
+                            }
+
+                            // Allocate body args
+                            const body_field_values = try self.allocator.alloc(Value, def.body_field_names.len);
+                            for (body_field_values) |*v| {
+                                v.* = Value.unit;
+                            }
+
+                            const instance = try self.allocator.create(Value.StructInstance);
+                            instance.* = .{
+                                .type_name = def.name,
+                                .field_names = def.field_names,
+                                .body_field_names = def.body_field_names,
+                                .field_values = field_values,
+                                .body_field_values = body_field_values,
+                                .kind = def.kind,
+                            };
+
+                            // Reset stack top now that we consumed everything
+                            self.stack_top = base_slot;
+                            self.push(Value{ .struct_instance = instance });
+                        },
                         else => return error.NotCallable,
                     }
                 },
