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

arena

Browse Source
This commit is contained in:
agra
2026-02-18 15:59:49 +02:00
parent 2f5eb84259
commit 188ffed5af
13 changed files with 414 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/ast.zig
View File

@@ -39,6 +39,7 @@ pub const Node = struct {
type_expr: TypeExpr,
param: Param,
defer_stmt: DeferStmt,
push_stmt: PushStmt,
comptime_expr: ComptimeExpr,
insert_expr: InsertExpr,
return_stmt: ReturnStmt,
@@ -253,12 +254,18 @@ pub const StructTypeParam = struct {
constraint: *Node, // type_expr: "u32" for value param, "Type" for type param
};
pub const UsingEntry = struct {
insert_index: u32, // position in field_names where used fields are spliced
type_name: []const u8, // struct type to inline
};
pub const StructDecl = struct {
name: []const u8,
field_names: []const []const u8,
field_types: []const *Node, // type_expr nodes
field_defaults: []const ?*Node, // default value per field, null if none
type_params: []const StructTypeParam = &.{},
using_entries: []const UsingEntry = &.{},
};
pub const StructFieldInit = struct {
@@ -288,6 +295,11 @@ pub const DeferStmt = struct {
expr: *Node,
};
pub const PushStmt = struct {
context_expr: *Node,
body: *Node,
};
pub const ComptimeExpr = struct {
expr: *Node,
};

140
src/codegen.zig
View File

@@ -506,6 +506,12 @@ pub const CodeGen = struct {
return null;
}
/// Lookup a named value in locals or global mutables (for field access/assignment).
fn getNamedOrGlobal(self: *CodeGen, name: []const u8) ?NamedValue {
if (self.named_values.get(name)) |nv| return nv;
return self.global_mutable_vars.get(name);
}
/// Build an alloca in the entry block of the current function so that
/// stack space is reserved once, not on every loop iteration.
fn buildEntryBlockAlloca(self: *CodeGen, ty: c.LLVMTypeRef, name: [*:0]const u8) c.LLVMValueRef {
@@ -2266,6 +2272,14 @@ pub const CodeGen = struct {
const info = try self.getTaggedEnumInfo(resolved);
return self.loadIfPointer(raw_val, info.llvm_type, "retval");
} else {
// If ret_type is a pointer/many-pointer/fn-pointer and the LLVM value is already
// an opaque ptr, return it directly. llvmTypeToSxType would misclassify LLVM ptr
// as string_type, causing a bogus slice_to_ptr conversion and crash.
if ((ret_type.isPointer() or ret_type.isManyPointer() or ret_type == .function_type) and
c.LLVMGetTypeKind(c.LLVMTypeOf(raw_val)) == c.LLVMPointerTypeKind)
{
return raw_val;
}
const src_ty = self.llvmTypeToSxType(c.LLVMTypeOf(raw_val));
return self.convertValue(raw_val, src_ty, ret_type);
}
@@ -2512,6 +2526,9 @@ pub const CodeGen = struct {
}
return null;
},
.push_stmt => |ps| {
return self.genPushStmt(ps);
},
.insert_expr => |ins| {
// Substitute comptime param nodes before evaluation (e.g., replace $fmt identifier with literal)
const expr = if (self.comptime_param_nodes != null)
@@ -3063,7 +3080,7 @@ pub const CodeGen = struct {
// Object must be an identifier for now
if (fa.object.data != .identifier) return self.emitError("field assignment target must be a variable");
const obj_name = fa.object.data.identifier.name;
const entry = self.named_values.get(obj_name) orelse return self.emitErrorFmt("undefined variable '{s}'", .{obj_name});
const entry = self.getNamedOrGlobal(obj_name) orelse return self.emitErrorFmt("undefined variable '{s}'", .{obj_name});
// Pointer auto-deref: p.field = val
if (entry.ty.isPointer()) {
@@ -3487,7 +3504,7 @@ pub const CodeGen = struct {
if (operand.data == .field_access) {
const fa = operand.data.field_access;
if (fa.object.data == .identifier) {
if (self.named_values.get(fa.object.data.identifier.name)) |entry| {
if (self.getNamedOrGlobal(fa.object.data.identifier.name)) |entry| {
if (entry.ty.isStruct()) {
const sname = entry.ty.struct_type;
const info = try self.getStructInfo(sname);
@@ -3616,6 +3633,56 @@ pub const CodeGen = struct {
}
}
/// Expand #using entries: interleave used struct fields with declared fields.
fn expandStructUsing(self: *CodeGen, sd: ast.StructDecl) !StructInfo {
var all_names = std.ArrayList([]const u8).empty;
var all_types = std.ArrayList(Type).empty;
var all_defaults = std.ArrayList(?*Node).empty;
var using_idx: usize = 0;
for (0..sd.field_names.len + 1) |i| {
// Splice #using entries whose insert_index matches current position
while (using_idx < sd.using_entries.len and
sd.using_entries[using_idx].insert_index == i)
{
const entry = sd.using_entries[using_idx];
const used_name = self.resolveAlias(entry.type_name);
const used_info = self.lookupStructInfo(used_name) orelse
return self.emitErrorFmt("#using: struct '{s}' not found (declared before '{s}'?)", .{ entry.type_name, sd.name });
for (used_info.field_names, 0..) |fname, fi| {
try all_names.append(self.allocator, fname);
try all_types.append(self.allocator, used_info.field_types[fi]);
try all_defaults.append(self.allocator, used_info.field_defaults[fi]);
}
using_idx += 1;
}
// Append own field at position i
if (i < sd.field_names.len) {
try all_names.append(self.allocator, sd.field_names[i]);
try all_types.append(self.allocator, self.resolveType(sd.field_types[i]));
try all_defaults.append(self.allocator, sd.field_defaults[i]);
}
}
// Build LLVM struct type with expanded fields
var llvm_types = std.ArrayList(c.LLVMTypeRef).empty;
for (all_types.items) |ty| {
try llvm_types.append(self.allocator, self.typeToLLVM(ty));
}
const name_z = try self.allocator.dupeZ(u8, sd.name);
const struct_ty = c.LLVMStructCreateNamed(self.context, name_z.ptr);
const llvm_slice = try llvm_types.toOwnedSlice(self.allocator);
c.LLVMStructSetBody(struct_ty, if (llvm_slice.len > 0) llvm_slice.ptr else null, @intCast(llvm_slice.len), 0);
return StructInfo{
.field_names = try all_names.toOwnedSlice(self.allocator),
.field_types = try all_types.toOwnedSlice(self.allocator),
.field_defaults = try all_defaults.toOwnedSlice(self.allocator),
.llvm_type = struct_ty,
};
}
fn registerStructType(self: *CodeGen, sd: ast.StructDecl) anyerror!void {
// Generic struct: store as template instead of registering now
if (sd.type_params.len > 0) {
@@ -3628,29 +3695,34 @@ pub const CodeGen = struct {
try self.hoistInlineTypeDecl(sd.name, sd.field_names[i], ft);
}
const build = try self.buildStructFields(sd.name, sd.field_types);
const sinfo = if (sd.using_entries.len > 0)
try self.expandStructUsing(sd)
else blk: {
const build = try self.buildStructFields(sd.name, sd.field_types);
// Process field defaults: replace #run expressions with comptime global references
var resolved_defaults = try self.allocator.alloc(?*Node, sd.field_defaults.len);
for (sd.field_defaults, 0..) |fd, i| {
if (fd != null and fd.?.data == .comptime_expr) {
const synthetic_name = try std.fmt.allocPrint(self.allocator, "__struct_{s}_field_{d}", .{ sd.name, i });
const field_type_override: ?Type = if (i < build.field_sx_types.len) build.field_sx_types[i] else null;
try self.registerComptimeGlobal(synthetic_name, fd.?.data.comptime_expr.expr, field_type_override);
const id_node = try self.allocator.create(Node);
id_node.* = .{ .span = .{ .start = 0, .end = 0 }, .data = .{ .identifier = .{ .name = synthetic_name } } };
resolved_defaults[i] = id_node;
} else {
resolved_defaults[i] = fd;
// Process field defaults: replace #run expressions with comptime global references
var resolved_defaults = try self.allocator.alloc(?*Node, sd.field_defaults.len);
for (sd.field_defaults, 0..) |fd, i| {
if (fd != null and fd.?.data == .comptime_expr) {
const synthetic_name = try std.fmt.allocPrint(self.allocator, "__struct_{s}_field_{d}", .{ sd.name, i });
const field_type_override: ?Type = if (i < build.field_sx_types.len) build.field_sx_types[i] else null;
try self.registerComptimeGlobal(synthetic_name, fd.?.data.comptime_expr.expr, field_type_override);
const id_node = try self.allocator.create(Node);
id_node.* = .{ .span = .{ .start = 0, .end = 0 }, .data = .{ .identifier = .{ .name = synthetic_name } } };
resolved_defaults[i] = id_node;
} else {
resolved_defaults[i] = fd;
}
}
}
const sinfo = StructInfo{
.field_names = sd.field_names,
.field_types = build.field_sx_types,
.field_defaults = resolved_defaults,
.llvm_type = build.llvm_type,
break :blk StructInfo{
.field_names = sd.field_names,
.field_types = build.field_sx_types,
.field_defaults = resolved_defaults,
.llvm_type = build.llvm_type,
};
};
try self.type_registry.put(sd.name, .{ .struct_info = sinfo });
_ = try self.getAnyTypeId(sd.name, .{ .struct_type = sd.name });
}
@@ -5016,7 +5088,7 @@ pub const CodeGen = struct {
fn genFieldAccess(self: *CodeGen, fa: ast.FieldAccess) !c.LLVMValueRef {
// Check if the object is a struct or vector variable
if (fa.object.data == .identifier) {
if (self.named_values.get(fa.object.data.identifier.name)) |entry| {
if (self.getNamedOrGlobal(fa.object.data.identifier.name)) |entry| {
// Pointer auto-deref: p.field → p.*.field
if (entry.ty.isPointer()) {
const pointee_ty = self.resolveTypeFromName(entry.ty.pointer_type.pointee_name) orelse
@@ -6528,6 +6600,29 @@ pub const CodeGen = struct {
return null;
}
fn genPushStmt(self: *CodeGen, ps: ast.PushStmt) !c.LLVMValueRef {
// Look up the 'context' global mutable variable
const ctx_entry = self.global_mutable_vars.get("context") orelse
return self.emitError("push requires a global 'context' variable");
const ctx_ty = ctx_entry.ty;
const llvm_ty = self.typeToLLVM(ctx_ty);
// Save current context value
const saved = c.LLVMBuildLoad2(self.builder, llvm_ty, ctx_entry.ptr, "saved_ctx");
// Evaluate new context expression and store to global
const new_ctx = try self.genExprAsType(ps.context_expr, ctx_ty);
_ = c.LLVMBuildStore(self.builder, new_ctx, ctx_entry.ptr);
// Generate body
_ = try self.genExpr(ps.body);
// Restore saved context
_ = c.LLVMBuildStore(self.builder, saved, ctx_entry.ptr);
return null;
}
fn genForExpr(self: *CodeGen, for_expr: ast.ForExpr) !c.LLVMValueRef {
const i64_type = self.i64Type();
@@ -7202,6 +7297,7 @@ pub const CodeGen = struct {
.bool_literal => .boolean,
.string_literal => .string_type,
.insert_expr => .void_type,
.push_stmt => .void_type,
.comptime_expr => |ct| self.inferType(ct.expr),
.binary_op => |binop| {
switch (binop.op) {

10
src/comptime.zig
View File

@@ -968,7 +968,11 @@ pub const Compiler = struct {
.pointer_type_expr, .many_pointer_type_expr => {
try self.emit(.push_void); // type expressions not meaningful as values
},
.undef_literal => {
try self.emit(.push_void);
},
.defer_stmt => {}, // defer not meaningful in comptime
.push_stmt => {}, // push not meaningful in comptime
.insert_expr => {}, // handled by codegen, not VM
else => {
return error.UnsupportedExpression;
@@ -1259,6 +1263,9 @@ pub const VM = struct {
} else {
try self.push(.{ .void_val = {} });
}
} else if (obj == .void_val) {
// Undefined/zeroed struct — all fields are zero
try self.push(.{ .int_val = 0 });
} else {
return error.TypeError;
}
@@ -1807,6 +1814,9 @@ pub const VM = struct {
.var_decl => |vd| {
if (std.mem.eql(u8, vd.name, name)) {
if (vd.value) |val_expr| {
// undef_literal (= ---) means zeroed/undefined — return void
if (val_expr.data == .undef_literal)
return .{ .void_val = {} };
return self.compileAndEvalGlobal(name, val_expr);
}
return .{ .void_val = {} };

1
src/lexer.zig
View File

@@ -71,6 +71,7 @@ pub const Lexer = struct {
.{ "#builtin", Tag.hash_builtin },
.{ "#foreign", Tag.hash_foreign },
.{ "#library", Tag.hash_library },
.{ "#using", Tag.hash_using },
};
inline for (directives) |d| {
const keyword = d[0];

2
src/lsp/server.zig
View File

@@ -992,12 +992,14 @@ pub const Server = struct {
.kw_and,
.kw_or,
.kw_null,
.kw_push,
.hash_run,
.hash_import,
.hash_insert,
.hash_builtin,
.hash_foreign,
.hash_library,
.hash_using,
=> ST.keyword,
.kw_f32, .kw_f64, .kw_Type => ST.type_,

37
src/parser.zig
View File

@@ -553,8 +553,25 @@ pub const Parser = struct {
var field_names = std.ArrayList([]const u8).empty;
var field_types = std.ArrayList(*Node).empty;
var field_defaults = std.ArrayList(?*Node).empty;
var using_entries = std.ArrayList(ast.UsingEntry).empty;
while (self.current.tag != .r_brace and self.current.tag != .eof) {
// Check for #using directive
if (self.current.tag == .hash_using) {
self.advance(); // skip #using
if (self.current.tag != .identifier) {
return self.fail("expected type name after '#using'");
}
const used_type = self.tokenSlice(self.current);
self.advance();
try using_entries.append(self.allocator, .{
.insert_index = @intCast(field_names.items.len),
.type_name = used_type,
});
if (self.current.tag == .semicolon) self.advance();
continue;
}
// Parse field group: name1, name2, ...: type (= default)?;
var group_names = std.ArrayList([]const u8).empty;
@@ -607,6 +624,7 @@ pub const Parser = struct {
.field_types = try field_types.toOwnedSlice(self.allocator),
.field_defaults = try field_defaults.toOwnedSlice(self.allocator),
.type_params = try type_params.toOwnedSlice(self.allocator),
.using_entries = try using_entries.toOwnedSlice(self.allocator),
} });
}
@@ -959,6 +977,9 @@ pub const Parser = struct {
try self.expectSemicolonAfter(expr);
return expr;
}
if (self.current.tag == .kw_push) {
return try self.parsePushStmt();
}
// Expression statement
const expr = try self.parseExpr();
@@ -1326,6 +1347,9 @@ pub const Parser = struct {
.kw_for => {
return self.parseForExpr();
},
.kw_push => {
return self.parsePushStmt();
},
.kw_break => {
self.advance();
return try self.createNode(start, .{ .break_expr = {} });
@@ -1473,6 +1497,19 @@ pub const Parser = struct {
} });
}
fn parsePushStmt(self: *Parser) anyerror!*Node {
const start = self.current.loc.start;
self.advance(); // skip 'push'
const context_expr = try self.parseExpr();
const body = try self.parseBlock();
return try self.createNode(start, .{ .push_stmt = .{
.context_expr = context_expr,
.body = body,
} });
}
fn parseForExpr(self: *Parser) anyerror!*Node {
const start = self.current.loc.start;
self.advance(); // skip 'for'

55
src/sema.zig
View File

@@ -197,16 +197,45 @@ pub const Analyzer = struct {
},
.struct_decl => |sd| {
try self.addSymbol(sd.name, .struct_type, .{ .struct_type = sd.name }, node.span);
// Populate struct_types registry
var field_types = std.ArrayList(Type).empty;
for (sd.field_types) |ft| {
const resolved = Type.fromTypeExpr(ft) orelse Type.s(64);
try field_types.append(self.allocator, resolved);
// Populate struct_types registry, expanding #using entries
if (sd.using_entries.len > 0) {
var all_names = std.ArrayList([]const u8).empty;
var all_types = std.ArrayList(Type).empty;
var using_idx: usize = 0;
for (0..sd.field_names.len + 1) |i| {
while (using_idx < sd.using_entries.len and
sd.using_entries[using_idx].insert_index == i)
{
const entry = sd.using_entries[using_idx];
if (self.struct_types.get(entry.type_name)) |used| {
for (used.field_names, 0..) |fname, fi| {
try all_names.append(self.allocator, fname);
try all_types.append(self.allocator, used.field_types[fi]);
}
}
using_idx += 1;
}
if (i < sd.field_names.len) {
try all_names.append(self.allocator, sd.field_names[i]);
const resolved = Type.fromTypeExpr(sd.field_types[i]) orelse Type.s(64);
try all_types.append(self.allocator, resolved);
}
}
try self.struct_types.put(sd.name, .{
.field_names = try all_names.toOwnedSlice(self.allocator),
.field_types = try all_types.toOwnedSlice(self.allocator),
});
} else {
var field_types = std.ArrayList(Type).empty;
for (sd.field_types) |ft| {
const resolved = Type.fromTypeExpr(ft) orelse Type.s(64);
try field_types.append(self.allocator, resolved);
}
try self.struct_types.put(sd.name, .{
.field_names = sd.field_names,
.field_types = try field_types.toOwnedSlice(self.allocator),
});
}
try self.struct_types.put(sd.name, .{
.field_names = sd.field_names,
.field_types = try field_types.toOwnedSlice(self.allocator),
});
},
.union_decl => |ud| {
try self.addSymbol(ud.name, .enum_type, .{ .union_type = ud.name }, node.span);
@@ -701,6 +730,10 @@ pub const Analyzer = struct {
.defer_stmt => |ds| {
try self.analyzeNode(ds.expr);
},
.push_stmt => |ps| {
try self.analyzeNode(ps.context_expr);
try self.analyzeNode(ps.body);
},
.comptime_expr => |ct| {
try self.analyzeNode(ct.expr);
},
@@ -979,6 +1012,10 @@ pub fn findNodeAtOffset(node: *Node, offset: u32) ?*Node {
.defer_stmt => |ds| {
if (findNodeAtOffset(ds.expr, offset)) |found| return found;
},
.push_stmt => |ps| {
if (findNodeAtOffset(ps.context_expr, offset)) |found| return found;
if (findNodeAtOffset(ps.body, offset)) |found| return found;
},
.comptime_expr => |ct| {
if (findNodeAtOffset(ct.expr, offset)) |found| return found;
},

3
src/token.zig
View File

@@ -29,6 +29,7 @@ pub const Tag = enum {
kw_or,
kw_Type, // Type (metatype keyword)
kw_null, // null
kw_push, // push
// Symbols
colon, // :
@@ -82,6 +83,7 @@ pub const Tag = enum {
hash_builtin, // #builtin
hash_foreign, // #foreign
hash_library, // #library
hash_using, // #using
triple_minus, // ---
// Special
@@ -178,6 +180,7 @@ pub const keywords = std.StaticStringMap(Tag).initComptime(.{
.{ "or", .kw_or },
.{ "Type", .kw_Type },
.{ "null", .kw_null },
.{ "push", .kw_push },
});
pub fn getKeyword(bytes: []const u8) ?Tag {