zzy/spl
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

stage2 修复大量AI生成的风格问题 stage1 修复对于vm abi的错误生成

Browse Source
This commit is contained in:
zzy committed 2026-10-03 15:05:55 +08:00
1 parent 0e38858785
commit 76f980654c
40 files changed
+619 -938
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

stage2/ast.spl
+4 -9
View File
@@ -1,9 +1,7 @@
// Expect retcode = 0
// AST：用 ADT（enum 带载荷）表达节点，节点引用是 arena 序号 usize。
// stage1 的 C 结构只是「手写 union 模拟 ADT」；这里直接用 SPL 的 enum 载荷，
// 不照抄 union 布局，只要求最终 dump / 语义与 stage1 一致。
// 索引 0 为 NONE 哨兵（与 stage1 一致）。
// AST：节点为带载荷 ADT，节点引用是 arena 序号（0 为 NONE 哨兵）。最终 dump/语义须与
// splc0 一致。
type .{ .Error } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
@@ -18,7 +16,6 @@ type .{ .Sources, .Source, .set_at } = @import("utils/source.spl");
// 算子不另立 enum：AST 直接存词法 Punct。一元/二元由节点 kind 区分
// （一元：Sub=负 / Not=! / BitNot=~ / And=& / Mul=.*；二元即对应 Punct）。
// ---- 节点体（ADT；variant 名 = stage1 的 kind 名；载荷用内联匿名 struct）----
type Body = enum {
None,
@@ -302,11 +299,11 @@ fn alloc(self: *Ast, body: Body, span: Span): usize {
}
// 注册一段已解码的字符串字节（Ast 拥有；ByteView 指向其中，生命周期同 Ast）。
// 空字符串也保证非空 data 指针（镜像 stage1：空字面量仍有稳定的非空字节地址）。
// 空字符串也保证非空 data 指针（空字面量仍有稳定非空地址）。
fn push_string(self: *Ast, bytes: ByteBuffer): ByteView {
var b = bytes;
if b.storage.len == 0 {
match ByteBuffer.reserve(&b, 1) { .Ok => {}, .Err(error) => {} }
ByteBuffer.reserve(&b, 1);
}
@assert(b.storage.data != null, "ast string pool must be non-null");
// 直接构造，避免 from_slice 把空串规范成 null 视图。
@@ -329,7 +326,6 @@ fn ref_vec(): Vec {
ret Vec.blank(@sizeof(usize), @alignof(usize));
}
// ---- dump（镜像 stage1 spl_ast_dump）----
//
// AST:
// <indent>`-/|-kind #ref [line:col]
@@ -607,7 +603,6 @@ fn dump(ast: *Ast, out: *ByteBuffer): bool {
ret dump_node(ast, out, &stack, ast.root, true);
}
// ---- 测试 ----
fn test_kind_names() {
@assert(ByteView.eq(ByteView.from_slice(kind_name(.None)), ByteView.from_slice("none")),
stage2/ast2ir.spl
+135 -158
View File
@@ -1,8 +1,7 @@
// Expect retcode = 0
// AST -> SIR（移植自 stage1/spl_ast2ir.c）。两遍：先 reserve 所有函数（拿稳定
// func ref），再发射函数体。def2ir_map 记录 def -> IR 槽位（变量=内存指针，
// 函数=func ref）。loop_stack/defer_stack 驱动 break/continue/ret 的收尾。
// AST -> IR。两遍：先 reserve 所有函数拿稳定 func ref，再发射函数体；def2ir_map
// 记录 def -> 槽位（变量=内存指针，函数=func ref）。
type .{ .Error } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
@@ -52,7 +51,6 @@ cur_defer_base: usize,
diag: *Diag,
owned: Vec, // ByteBuffer：为 dbg.panic 消息提供稳定存储
// ---- 小工具 ----
fn list_at(v: Vec, i: usize): usize {
if i >= v.len { ret 0; }
@@ -60,7 +58,7 @@ fn list_at(v: Vec, i: usize): usize {
}
fn push_u(v: *Vec, x: usize) {
match Vec.push(v, &x as *u8) { .Ok => {}, .Err(e) => {} }
Vec.push(v, &x as *u8);
}
fn irt(self: *Ast2Ir, id: usize): *TypeEntry {
@@ -103,7 +101,7 @@ fn ir_map_get(self: *Ast2Ir, def_id: usize, out: *usize): bool {
}
fn ir_map_put(self: *Ast2Ir, def_id: usize, val: usize) {
match Map.put(&self.def2ir_map, &def_id as *u8, &val as *u8) { .Ok => {}, .Err(e) => {} }
Map.put(&self.def2ir_map, &def_id as *u8, &val as *u8);
}
fn glob_get(self: *Ast2Ir, def_id: usize, out: *usize): bool {
@@ -115,7 +113,7 @@ fn glob_get(self: *Ast2Ir, def_id: usize, out: *usize): bool {
}
fn glob_put(self: *Ast2Ir, def_id: usize, val: usize) {
match Map.put(&self.glob_gidx, &def_id as *u8, &val as *u8) { .Ok => {}, .Err(e) => {} }
Map.put(&self.glob_gidx, &def_id as *u8, &val as *u8);
}
// 顶层 var/const → 模块全局（alloc 于静态存储；引用是 *T 指针常量）。
@@ -141,7 +139,7 @@ fn emit_global_var(self: *Ast2Ir, d: *Node) {
match inode.body {
.ExprIntLit(bi) => {
var v: u64 = 0;
match BigInt.to_u64(&v, bi.value) { .Ok => {}, .Err(e) => {} }
BigInt.to_u64(&v, bi.value);
var bits = LangType.int_bits(&self.sema.types, ir);
var size = bits / 8;
if size != 0 {
@@ -149,7 +147,7 @@ fn emit_global_var(self: *Ast2Ir, d: *Node) {
var i: usize = 0;
while i < size {
var b = ((v >> (8 * i)) & 255) as u8;
match Vec.push(&bytes, &b as *u8) { .Ok => {}, .Err(e) => {} }
Vec.push(&bytes, &b as *u8);
i = i + 1;
}
}
@@ -184,7 +182,7 @@ fn int_lit_u64(n: *Node): u64 {
match n.body {
.ExprIntLit(&x) => {
var out: u64 = 0;
match BigInt.to_u64(&out, x.value) { .Ok => {}, .Err(e) => {} }
BigInt.to_u64(&out, x.value);
ret out;
},
_ => {},
@@ -198,7 +196,6 @@ fn ir_kind_of(self: *Ast2Ir, ref: usize): IrKind {
ret e.kind;
}
// ---- 零值 ----
fn emit_zero_value(self: *Ast2Ir, tid: usize): usize {
var tn = irt(self, tid);
@@ -277,7 +274,6 @@ fn variant_at(v: Vec, idx: usize): usize {
ret m.type_id;
}
// ---- 模式绑定 ----
fn pattern_has_ref(self: *Ast2Ir, pat_ref: usize): bool {
if pat_ref == 0 { ret false; }
@@ -334,7 +330,7 @@ fn emit_pattern_bind(self: *Ast2Ir, pat_ref: usize, src_ptr: usize, tid: usize,
if place_mode {
var slot = IrBuilder.mem_alloca(self.ir, tid, const_usize(self, 1));
var v = IrBuilder.mem_load(self.ir, tid, src_ptr);
ignore_usize(IrBuilder.mem_store(self.ir, tid, slot, v));
IrBuilder.mem_store(self.ir, tid, slot, v);
ir_map_put(self, pat.resolved_def_id, slot);
} else {
ir_map_put(self, pat.resolved_def_id, src_ptr);
@@ -348,7 +344,7 @@ fn emit_pattern_bind(self: *Ast2Ir, pat_ref: usize, src_ptr: usize, tid: usize,
if in != null { ptr_tid = node_ir(self, in); }
if ptr_tid == 0 { ptr_tid = TypeTable.make_ptr(&self.sema.types.ir, tid); }
var slot = IrBuilder.mem_alloca(self.ir, ptr_tid, const_usize(self, 1));
ignore_usize(IrBuilder.mem_store(self.ir, ptr_tid, slot, src_ptr));
IrBuilder.mem_store(self.ir, ptr_tid, slot, src_ptr);
emit_pattern_bind(self, x.pat, slot, ptr_tid, false);
ret;
},
@@ -539,7 +535,7 @@ fn copy_attrs_node(self: *Ast2Ir, n: *Node, ir_ref: usize) {
var i: usize = 0;
while i < n.attrs.len {
var a = list_at(n.attrs, i);
match Vec.push(&irn.attrs, &a as *u8) { .Ok => {}, .Err(e) => {} }
Vec.push(&irn.attrs, &a as *u8);
i = i + 1;
}
}
@@ -551,12 +547,11 @@ fn copy_attrs_func(self: *Ast2Ir, n: *Node, fn_ref: usize) {
var i: usize = 0;
while i < n.attrs.len {
var a = list_at(n.attrs, i);
match Vec.push(&irf.attrs, &a as *u8) { .Ok => {}, .Err(e) => {} }
Vec.push(&irf.attrs, &a as *u8);
i = i + 1;
}
}
// ---- intrinsic ----
fn ast2ir_intrin_cast(self: *Ast2Ir, n: *Node, in: Intrin, args: Vec): usize {
if args.len < 1 {
@@ -579,38 +574,39 @@ fn ast2ir_intrin_cast(self: *Ast2Ir, n: *Node, in: Intrin, args: Vec): usize {
}
fn ast2ir_intrin_call(self: *Ast2Ir, n: *Node, in: Intrin, args: Vec): usize {
if @enum2int(in) == @enum2int(Intrin.BitSizeof) {
var arg = Ast.node(self.ast, list_at(args, 0));
ret IrBuilder.type_bitsizeof(self.ir, node_ir(self, arg));
}
if @enum2int(in) == @enum2int(Intrin.Sizeof) {
var arg = Ast.node(self.ast, list_at(args, 0));
ret IrBuilder.type_sizeof(self.ir, node_ir(self, arg));
}
if @enum2int(in) == @enum2int(Intrin.Alignof) {
var arg = Ast.node(self.ast, list_at(args, 0));
ret IrBuilder.type_alignof(self.ir, node_ir(self, arg));
}
if @enum2int(in) == @enum2int(Intrin.Enum2Int) {
var src = Ast.node(self.ast, list_at(args, 0));
var v = emit_expr(self, list_at(args, 0));
if v == 0 { ret 0; }
var agg_t = node_ir(self, src);
var tag_t = node_ir(self, n);
if agg_t == 0 || tag_t == 0 { ret 0; }
ret IrBuilder.agg_extract(self.ir, agg_t, tag_t, 0, v);
}
if @enum2int(in) == @enum2int(Intrin.FieldCount) {
var arg = Ast.node(self.ast, list_at(args, 0));
ret IrBuilder.type_field_count(self.ir, node_ir(self, arg));
}
if @enum2int(in) == @enum2int(Intrin.OffsetOf) {
var arg = Ast.node(self.ast, list_at(args, 0));
var agg_t = node_ir(self, arg);
if agg_t == 0 { ret 0; }
var fnode = Ast.node(self.ast, list_at(args, 1));
var idx: usize = 0;
if fnode != null {
match in {
.BitSizeof => {
var arg = Ast.node(self.ast, list_at(args, 0));
ret IrBuilder.type_bitsizeof(self.ir, node_ir(self, arg));
},
.Sizeof => {
var arg = Ast.node(self.ast, list_at(args, 0));
ret IrBuilder.type_sizeof(self.ir, node_ir(self, arg));
},
.Alignof => {
var arg = Ast.node(self.ast, list_at(args, 0));
ret IrBuilder.type_alignof(self.ir, node_ir(self, arg));
},
.Enum2Int => {
var src = Ast.node(self.ast, list_at(args, 0));
var v = emit_expr(self, list_at(args, 0));
if v == 0 { ret 0; }
var agg_t = node_ir(self, src);
var tag_t = node_ir(self, n);
if agg_t == 0 || tag_t == 0 { ret 0; }
ret IrBuilder.agg_extract(self.ir, agg_t, tag_t, 0, v);
},
.FieldCount => {
var arg = Ast.node(self.ast, list_at(args, 0));
ret IrBuilder.type_field_count(self.ir, node_ir(self, arg));
},
.OffsetOf => {
var arg = Ast.node(self.ast, list_at(args, 0));
var agg_t = node_ir(self, arg);
if agg_t == 0 { ret 0; }
var fnode = Ast.node(self.ast, list_at(args, 1));
if fnode == null { ret 0; }
var idx: usize = 0;
match fnode.body {
.ExprIntLit(x) => { idx = int_lit_u64(fnode) as usize; },
.ExprIdent(e) => {
@@ -618,29 +614,16 @@ fn ast2ir_intrin_call(self: *Ast2Ir, n: *Node, in: Intrin, args: Vec): usize {
},
_ => { ret 0; },
}
} else {
ret 0;
}
var idx_node = const_usize(self, idx);
ret IrBuilder.type_offsetof(self.ir, agg_t, idx_node);
}
if @enum2int(in) == @enum2int(Intrin.Assert) {
ret ast2ir_intrin_assert(self, n, args);
}
if @enum2int(in) == @enum2int(Intrin.IntCast) ||
@enum2int(in) == @enum2int(Intrin.Truncate) ||
@enum2int(in) == @enum2int(Intrin.BitCast) ||
@enum2int(in) == @enum2int(Intrin.FloatCast) ||
@enum2int(in) == @enum2int(Intrin.Float2Int) ||
@enum2int(in) == @enum2int(Intrin.Int2Float) ||
@enum2int(in) == @enum2int(Intrin.Bool2Int) ||
@enum2int(in) == @enum2int(Intrin.Ptr2Int) ||
@enum2int(in) == @enum2int(Intrin.Int2Ptr) ||
@enum2int(in) == @enum2int(Intrin.PtrCast) {
ret ast2ir_intrin_cast(self, n, in, args);
}
if @enum2int(in) == @enum2int(Intrin.Breakpoint) {
ret IrBuilder.dbg_breakpoint(self.ir);
var idx_node = const_usize(self, idx);
ret IrBuilder.type_offsetof(self.ir, agg_t, idx_node);
},
.Assert => { ret ast2ir_intrin_assert(self, n, args); },
.IntCast, .Truncate, .BitCast, .FloatCast, .Float2Int, .Int2Float,
.Bool2Int, .Ptr2Int, .Int2Ptr, .PtrCast => {
ret ast2ir_intrin_cast(self, n, in, args);
},
.Breakpoint => { ret IrBuilder.dbg_breakpoint(self.ir); },
_ => { ret 0; },
}
ret 0;
}
@@ -665,22 +648,22 @@ fn ast2ir_intrin_assert(self: *Ast2Ir, n: *Node, args: Vec): usize {
if self.sema.sources != null && n.span.file != no_file() {
var src = set_at(self.sema.sources, n.span.file);
if src != null {
ignore_bool(append_bytes(&msg, ByteView.as_slice(src.fname)));
append_bytes(&msg, ByteView.as_slice(src.fname));
var pos = Source.line_col(src.*, n.span.start);
ignore_bool(append_bytes(&msg, ":"));
ignore_bool(append_num(&msg, pos.line));
ignore_bool(append_bytes(&msg, ":"));
ignore_bool(append_num(&msg, pos.col));
append_bytes(&msg, ":");
append_num(&msg, pos.line);
append_bytes(&msg, ":");
append_num(&msg, pos.col);
}
}
ignore_bool(append_bytes(&msg, ": assert failed"));
append_bytes(&msg, ": assert failed");
if args.len == 2 {
var mn = Ast.node(self.ast, list_at(args, 1));
if mn != null {
match mn.body {
.ExprStringLit(sl) => {
ignore_bool(append_bytes(&msg, ": "));
ignore_bool(append_bytes(&msg, ByteView.as_slice(sl.data)));
append_bytes(&msg, ": ");
append_bytes(&msg, ByteView.as_slice(sl.data));
},
_ => {},
}
@@ -688,8 +671,8 @@ fn ast2ir_intrin_assert(self: *Ast2Ir, n: *Node, args: Vec): usize {
}
var msg_view = ByteView.from_slice(ByteBuffer.as_slice(msg));
@assert(msg_view.len == 0 || msg_view.ptr != null, "panic message bytes must be non-null");
ignore_usize(IrBuilder.dbg_panic(self.ir, msg_view));
ignore_usize(IrBuilder.control_trap(self.ir));
IrBuilder.dbg_panic(self.ir, msg_view);
IrBuilder.control_trap(self.ir);
IrBuilder.block_end(self.ir);
var cont_blk = IrBuilder.block_begin(self.ir);
@@ -707,7 +690,6 @@ fn append_num(buf: *ByteBuffer, v: usize): bool {
ret false;
}
fn ignore_bool(b: bool) {}
fn ast2ir_intrin_field(self: *Ast2Ir, n: *Node, in: Intrin): usize {
if @enum2int(in) == @enum2int(Intrin.Len) { ret ast2ir_intrin_len(self, n); }
@@ -742,7 +724,6 @@ fn ast2ir_intrin_len(self: *Ast2Ir, n: *Node): usize {
ret 0;
}
// ---- 左值 ----
fn emit_lvalue(self: *Ast2Ir, ref: usize): usize {
var n = Ast.node(self.ast, ref);
@@ -857,33 +838,32 @@ fn extra_elem(e: LangEntry): usize {
ret 0;
}
fn ignore_usize(x: usize) {}
// ---- 转换 ----
fn ast2ir_emit_cast_builtin(self: *Ast2Ir, n: *Node, in: Intrin, ft: usize, tt: usize,
v: usize): usize {
if @enum2int(in) == @enum2int(Intrin.IntCast) {
var fs = irt(self, ft);
if fs != null {
match fs.node {
.Int(x) => { if x.is_signed { ret IrBuilder.cast_sext(self.ir, ft, tt, v); } },
_ => {},
match in {
.IntCast => {
var fs = irt(self, ft);
if fs != null {
match fs.node {
.Int(x) => { if x.is_signed { ret IrBuilder.cast_sext(self.ir, ft, tt, v); } },
_ => {},
}
}
}
ret IrBuilder.cast_zext(self.ir, ft, tt, v);
ret IrBuilder.cast_zext(self.ir, ft, tt, v);
},
.Truncate => { ret IrBuilder.cast_trunc(self.ir, ft, tt, v); },
.BitCast => { ret IrBuilder.cast_bitcast(self.ir, ft, tt, v); },
.FloatCast => { ret ir_float_cast(self, ft, tt, v); },
.Float2Int => { ret IrBuilder.case_float2int(self.ir, ft, tt, v); },
.Int2Float => { ret IrBuilder.case_int2float(self.ir, ft, tt, v); },
.Bool2Int => { ret IrBuilder.cast_bool2int(self.ir, ft, tt, v); },
.Ptr2Int => { ret IrBuilder.cast_ptr2int(self.ir, ft, tt, v); },
.Int2Ptr => { ret IrBuilder.cast_int2ptr(self.ir, ft, tt, v); },
.PtrCast => { ret IrBuilder.cast_bitcast(self.ir, ft, tt, v); },
_ => {},
}
if @enum2int(in) == @enum2int(Intrin.Truncate) { ret IrBuilder.cast_trunc(self.ir, ft, tt, v); }
if @enum2int(in) == @enum2int(Intrin.BitCast) { ret IrBuilder.cast_bitcast(self.ir, ft, tt, v); }
if @enum2int(in) == @enum2int(Intrin.FloatCast) {
ret ir_float_cast(self, ft, tt, v);
}
if @enum2int(in) == @enum2int(Intrin.Float2Int) { ret IrBuilder.case_float2int(self.ir, ft, tt, v); }
if @enum2int(in) == @enum2int(Intrin.Int2Float) { ret IrBuilder.case_int2float(self.ir, ft, tt, v); }
if @enum2int(in) == @enum2int(Intrin.Bool2Int) { ret IrBuilder.cast_bool2int(self.ir, ft, tt, v); }
if @enum2int(in) == @enum2int(Intrin.Ptr2Int) { ret IrBuilder.cast_ptr2int(self.ir, ft, tt, v); }
if @enum2int(in) == @enum2int(Intrin.Int2Ptr) { ret IrBuilder.cast_int2ptr(self.ir, ft, tt, v); }
if @enum2int(in) == @enum2int(Intrin.PtrCast) { ret IrBuilder.cast_bitcast(self.ir, ft, tt, v); }
Diag.err(self.diag, n.span, .Internal, "ast2ir: unknown cast builtin");
ret 0;
}
@@ -968,19 +948,18 @@ fn ast2ir_enum_variant(self: *Ast2Ir, n: *Node): usize {
var eptr = IrBuilder.mem_alloca(self.ir, t, const_usize(self, 1));
var tptr = IrBuilder.mem_field(self.ir, t, eptr, 0);
var tag_val = IrBuilder.type_const_int(self.ir, tag_ir, vidx);
ignore_usize(IrBuilder.mem_store(self.ir, tag_ir, tptr, tag_val));
IrBuilder.mem_store(self.ir, tag_ir, tptr, tag_val);
if vidx < variants.len {
var payload_ir = variant_at(variants, vidx);
if payload_ir != 0 {
var pptr = IrBuilder.mem_field(self.ir, t, eptr, vidx + 1);
var zero = emit_zero_value(self, payload_ir);
ignore_usize(IrBuilder.mem_store(self.ir, payload_ir, pptr, zero));
IrBuilder.mem_store(self.ir, payload_ir, pptr, zero);
}
}
ret eptr;
}
// ---- 表达式 ----
fn emit_expr(self: *Ast2Ir, ref: usize): usize {
var val = emit_expr_raw(self, ref);
@@ -1120,7 +1099,7 @@ fn emit_binary(self: *Ast2Ir, n: *Node, op: Punct, left: usize, right: usize): u
if ptr == 0 || v == 0 { ret 0; }
var ln = Ast.node(self.ast, left);
var t = node_ir(self, ln);
ignore_usize(IrBuilder.mem_store(self.ir, t, ptr, v));
IrBuilder.mem_store(self.ir, t, ptr, v);
ret v;
}
if is_assign_arith(op) { ret emit_assign_arith(self, op, left, right); }
@@ -1199,7 +1178,7 @@ fn emit_assign_arith(self: *Ast2Ir, op: Punct, left: usize, right: usize): usize
else if punct_is(op, .RShAssign) { res = IrBuilder.arith_shr(self.ir, t, lv, rv); }
else { ret 0; }
if res == 0 { ret 0; }
ignore_usize(IrBuilder.mem_store(self.ir, t, ptr, res));
IrBuilder.mem_store(self.ir, t, ptr, res);
ret res;
}
@@ -1210,14 +1189,14 @@ fn emit_short_circuit(self: *Ast2Ir, op: Punct, left: usize, right: usize): usiz
var l = emit_expr(self, left);
if l == 0 { ret 0; }
ignore_usize(IrBuilder.mem_store(self.ir, b_ir, slot, l));
IrBuilder.mem_store(self.ir, b_ir, slot, l);
var br = IrBuilder.control_br(self.ir, l);
IrBuilder.block_end(self.ir);
var rhs_blk = IrBuilder.block_begin(self.ir);
var r = emit_expr(self, right);
if r != 0 { ignore_usize(IrBuilder.mem_store(self.ir, b_ir, slot, r)); }
if r != 0 { IrBuilder.mem_store(self.ir, b_ir, slot, r); }
var rhs_end: usize = 0;
if !self.ir.terminated { rhs_end = IrBuilder.control_jmp(self.ir); }
IrBuilder.block_end(self.ir);
@@ -1371,7 +1350,7 @@ fn emit_array_to_slice(self: *Ast2Ir, n: *Node, t: usize, elems: Vec, elem_lang:
var fptr = IrBuilder.mem_field(self.ir, arr_ir, slot, i);
var v = emit_expr(self, list_at(elems, i));
if v == 0 { ret 0; }
ignore_usize(IrBuilder.mem_store(self.ir, elem_ir, fptr, v));
IrBuilder.mem_store(self.ir, elem_ir, fptr, v);
i = i + 1;
}
base = IrBuilder.mem_field(self.ir, arr_ir, slot, 0);
@@ -1413,13 +1392,13 @@ fn emit_aggregate_lit(self: *Ast2Ir, n: *Node, type_name: ByteView, fields: Vec)
var eptr = IrBuilder.mem_alloca(self.ir, t, const_usize(self, 1));
var tptr = IrBuilder.mem_field(self.ir, t, eptr, 0);
var tag_val = IrBuilder.type_const_int(self.ir, tag_ir, vidx);
ignore_usize(IrBuilder.mem_store(self.ir, tag_ir, tptr, tag_val));
IrBuilder.mem_store(self.ir, tag_ir, tptr, tag_val);
if iexpr != 0 {
var payload_ir = variant_at(variants, vidx);
var pptr = IrBuilder.mem_field(self.ir, t, eptr, vidx + 1);
var payload = emit_expr(self, iexpr);
if payload == 0 { ret 0; }
ignore_usize(IrBuilder.mem_store(self.ir, payload_ir, pptr, payload));
IrBuilder.mem_store(self.ir, payload_ir, pptr, payload);
}
ret eptr;
}
@@ -1474,7 +1453,7 @@ fn emit_aggregate_lit(self: *Ast2Ir, n: *Node, type_name: ByteView, fields: Vec)
}
fn set_u(v: *Vec, i: usize, x: usize) {
match Vec.set(v, i, &x as *u8) { .Ok => {}, .Err(e) => {} }
Vec.set(v, i, &x as *u8);
}
fn emit_deferred_until(self: *Ast2Ir, base: usize) {
@@ -1545,7 +1524,7 @@ fn emit_match(self: *Ast2Ir, n: *Node, matched_ref: usize, arms: Vec): usize {
scrut_slot = IrBuilder.mem_alloca(self.ir, matched_ir, const_usize(self, 1));
var scrut_val = emit_expr(self, matched_ref);
if scrut_val == 0 { ret 0; }
ignore_usize(IrBuilder.mem_store(self.ir, matched_ir, scrut_slot, scrut_val));
IrBuilder.mem_store(self.ir, matched_ir, scrut_slot, scrut_val);
}
var narms = arms.len;
@@ -1567,7 +1546,7 @@ fn emit_match(self: *Ast2Ir, n: *Node, matched_ref: usize, arms: Vec): usize {
push_u(&arm_branches, IrBuilder.control_jmp(self.ir));
}
IrBuilder.block_end(self.ir);
if i + 1 < narms { ignore_usize(IrBuilder.block_begin(self.ir)); }
if i + 1 < narms { IrBuilder.block_begin(self.ir); }
i = i + 1;
}
var no_match_blk = IrBuilder.block_begin(self.ir);
@@ -1585,7 +1564,7 @@ fn emit_match(self: *Ast2Ir, n: *Node, matched_ref: usize, arms: Vec): usize {
var body: usize = 0;
match arm.body { .MatchArm(ma) => { pat = ma.pattern; body = ma.body; }, _ => {} }
emit_pattern_bind(self, pat, scrut_slot, matched_ir, matched_place_mode);
if body != 0 { ignore_usize(emit_expr(self, body)); }
if body != 0 { emit_expr(self, body); }
}
var j: usize = 0;
if !self.ir.terminated { j = IrBuilder.control_jmp(self.ir); }
@@ -1600,12 +1579,14 @@ fn emit_match(self: *Ast2Ir, n: *Node, matched_ref: usize, arms: Vec): usize {
if branch != 0 {
var bk = ir_kind_of(self, branch);
var body_blk = list_at(body_blks, i);
if @enum2int(bk) == @enum2int(IrKind.ControlBr) {
var next_blk = no_match_blk;
if i + 1 < narms { next_blk = list_at(cond_blks, i + 1); }
IrBuilder.control_br_fixup(self.ir, branch, body_blk, next_blk);
} else if @enum2int(bk) == @enum2int(IrKind.ControlJmp) {
IrBuilder.control_jmp_fixup(self.ir, branch, body_blk);
match bk {
.ControlBr => {
var next_blk = no_match_blk;
if i + 1 < narms { next_blk = list_at(cond_blks, i + 1); }
IrBuilder.control_br_fixup(self.ir, branch, body_blk, next_blk);
},
.ControlJmp => { IrBuilder.control_jmp_fixup(self.ir, branch, body_blk); },
_ => {},
}
}
i = i + 1;
@@ -1682,7 +1663,6 @@ fn emit_slice(self: *Ast2Ir, n: *Node, obj_ref: usize, begin_ref: usize, end_ref
ret node;
}
// ---- if / loop ----
fn emit_if_like(self: *Ast2Ir, ref: usize): usize {
var n = Ast.node(self.ast, ref);
@@ -1729,7 +1709,7 @@ fn emit_if_like(self: *Ast2Ir, ref: usize): usize {
var then_v: usize = 0;
if then_ref != 0 { then_v = emit_expr(self, then_ref); }
if result_slot != 0 && then_v != 0 {
ignore_usize(IrBuilder.mem_store(self.ir, result_t, result_slot, then_v));
IrBuilder.mem_store(self.ir, result_t, result_slot, then_v);
}
var then_end: usize = 0;
if !self.ir.terminated { then_end = IrBuilder.control_jmp(self.ir); }
@@ -1739,7 +1719,7 @@ fn emit_if_like(self: *Ast2Ir, ref: usize): usize {
var else_v: usize = 0;
if else_ref != 0 { else_v = emit_expr(self, else_ref); }
if result_slot != 0 && else_v != 0 {
ignore_usize(IrBuilder.mem_store(self.ir, result_t, result_slot, else_v));
IrBuilder.mem_store(self.ir, result_t, result_slot, else_v);
}
var else_end: usize = 0;
if !self.ir.terminated { else_end = IrBuilder.control_jmp(self.ir); }
@@ -1815,9 +1795,9 @@ fn emit_loop_like(self: *Ast2Ir, ref: usize): usize {
}
}
if label_ref != 0 { ctx.label = label_name_of(self, label_ref); }
match Vec.push(&self.loop_stack, &ctx as *u8) { .Ok => {}, .Err(e) => {} }
Vec.push(&self.loop_stack, &ctx as *u8);
if body_ref != 0 { ignore_usize(emit_expr(self, body_ref)); }
if body_ref != 0 { emit_expr(self, body_ref); }
var body_end: usize = 0;
if !self.ir.terminated { body_end = IrBuilder.control_jmp(self.ir); }
@@ -1827,7 +1807,7 @@ fn emit_loop_like(self: *Ast2Ir, ref: usize): usize {
var else_v: usize = 0;
if is_while && else_ref != 0 { else_v = emit_expr(self, else_ref); }
if result_slot != 0 && else_v != 0 {
ignore_usize(IrBuilder.mem_store(self.ir, result_t, result_slot, else_v));
IrBuilder.mem_store(self.ir, result_t, result_slot, else_v);
}
if pre_jmp != 0 { IrBuilder.control_jmp_fixup(self.ir, pre_jmp, cont_blk); }
if br != 0 { IrBuilder.control_br_fixup(self.ir, br, body_blk, after_blk); }
@@ -1858,7 +1838,7 @@ fn pop_loop(self: *Ast2Ir) {
.cont_blk = 0, .defer_base = 0, .label = ByteView.empty(),
.breaks = Vec.blank(@sizeof(usize), @alignof(usize)), .result_slot = 0, .result_tid = 0,
};
match Vec.pop(&self.loop_stack, &out as *u8) { .Ok => {}, .Err(e) => {} }
Vec.pop(&self.loop_stack, &out as *u8);
}
fn label_name_of(self: *Ast2Ir, ref: usize): ByteView {
@@ -1896,7 +1876,7 @@ fn emit_break_stmt(self: *Ast2Ir, n: *Node): usize {
if expr_ref != 0 && target.result_slot != 0 {
var bv = emit_expr(self, expr_ref);
if bv != 0 {
ignore_usize(IrBuilder.mem_store(self.ir, target.result_tid, target.result_slot, bv));
IrBuilder.mem_store(self.ir, target.result_tid, target.result_slot, bv);
}
}
emit_deferred_until(self, target.defer_base);
@@ -1907,7 +1887,6 @@ fn emit_break_stmt(self: *Ast2Ir, n: *Node): usize {
ret 0;
}
// ---- 语句 / 声明 ----
fn emit_stmt(self: *Ast2Ir, ref: usize) {
var n = Ast.node(self.ast, ref);
@@ -1918,20 +1897,20 @@ fn emit_stmt(self: *Ast2Ir, ref: usize) {
var v: usize = 0;
if x.expr != 0 { v = emit_expr(self, x.expr); }
emit_deferred_until(self, self.cur_defer_base);
if !self.ir.terminated { ignore_usize(IrBuilder.control_ret(self.ir, ret_ir, v)); }
if !self.ir.terminated { IrBuilder.control_ret(self.ir, ret_ir, v); }
},
.StatementDefer(&x) => { if x.body != 0 { push_u(&self.defer_stack, x.body); } },
.StatementComptime(&x) => { if x.body != 0 { ignore_usize(emit_expr(self, x.body)); } },
.StatementComptime(&x) => { if x.body != 0 { emit_expr(self, x.body); } },
.StatementDecl(&x) => { if x.decl != 0 { emit_decl(self, x.decl); } },
.StatementExpr(&x) => { if x.expr != 0 { ignore_usize(emit_expr(self, x.expr)); } },
.ExprIf(&x) => { ignore_usize(emit_if_like(self, ref)); },
.ExprIfvar(&x) => { ignore_usize(emit_if_like(self, ref)); },
.ExprWhile(&x) => { ignore_usize(emit_loop_like(self, ref)); },
.ExprLoop(&x) => { ignore_usize(emit_loop_like(self, ref)); },
.StatementBreak(&x) => { ignore_usize(emit_break_stmt(self, n)); },
.StatementExpr(&x) => { if x.expr != 0 { emit_expr(self, x.expr); } },
.ExprIf(&x) => { emit_if_like(self, ref); },
.ExprIfvar(&x) => { emit_if_like(self, ref); },
.ExprWhile(&x) => { emit_loop_like(self, ref); },
.ExprLoop(&x) => { emit_loop_like(self, ref); },
.StatementBreak(&x) => { emit_break_stmt(self, n); },
.StatementContinue(&x) => { emit_continue_stmt(self, n); },
.ExprBlock(&x) => { ignore_usize(emit_expr(self, ref)); },
_ => { ignore_usize(emit_expr(self, ref)); },
.ExprBlock(&x) => { emit_expr(self, ref); },
_ => { emit_expr(self, ref); },
}
}
@@ -1957,8 +1936,8 @@ fn emit_decl(self: *Ast2Ir, ref: usize) {
var n = Ast.node(self.ast, ref);
if n == null { ret; }
match n.body {
.VarDecl(&x) => { if self.ir.current_fn != 0 { ignore_usize(emit_var_decl(self, n)); } },
.ConstDecl(&x) => { if self.ir.current_fn != 0 { ignore_usize(emit_var_decl(self, n)); } },
.VarDecl(&x) => { if self.ir.current_fn != 0 { emit_var_decl(self, n); } },
.ConstDecl(&x) => { if self.ir.current_fn != 0 { emit_var_decl(self, n); } },
_ => {},
}
}
@@ -1989,8 +1968,8 @@ fn fn_name_of(n: *Node): ByteView {
fn diag_name(self: *Ast2Ir, span: Span, code: Code, prefix: []u8, name: ByteView) {
var b = ByteBuffer.new();
defer { ByteBuffer.drop(&b); }
match ByteBuffer.append(&b, prefix) { .Ok => {}, .Err(e) => {} }
match ByteBuffer.append(&b, ByteView.as_slice(name)) { .Ok => {}, .Err(e) => {} }
ByteBuffer.append(&b, prefix);
ByteBuffer.append(&b, ByteView.as_slice(name));
Diag.err(self.diag, span, code, ByteBuffer.as_slice(b));
}
@@ -2014,7 +1993,7 @@ fn emit_fn_body(self: *Ast2Ir, n: *Node) {
var defer_base = self.cur_defer_base;
var loop_base = self.loop_stack.len;
ignore_usize(IrBuilder.block_begin(self.ir));
IrBuilder.block_begin(self.ir);
var params = Vec.blank(@sizeof(usize), @alignof(usize));
var body_ref: usize = 0;
@@ -2031,23 +2010,23 @@ fn emit_fn_body(self: *Ast2Ir, n: *Node) {
var pv = IrBuilder.control_param(self.ir, p_ir, idx);
var one = const_usize(self, 1);
var slot = IrBuilder.mem_alloca(self.ir, p_ir, one);
ignore_usize(IrBuilder.mem_store(self.ir, p_ir, slot, pv));
IrBuilder.mem_store(self.ir, p_ir, slot, pv);
ir_map_put(self, pd.resolved_def_id, slot);
}
}
i = i + 1;
}
if body_ref != 0 { ignore_usize(emit_expr(self, body_ref)); }
if body_ref != 0 { emit_expr(self, body_ref); }
if !self.ir.terminated { emit_deferred_until(self, defer_base); }
if !self.ir.terminated {
if ret_is_unit {
ignore_usize(IrBuilder.control_ret(self.ir, ret_ir, 0));
IrBuilder.control_ret(self.ir, ret_ir, 0);
} else if ret_ir != 0 {
var zero = emit_zero_value(self, ret_ir);
ignore_usize(IrBuilder.control_ret(self.ir, ret_ir, zero));
IrBuilder.control_ret(self.ir, ret_ir, zero);
} else {
ignore_usize(IrBuilder.control_unreachable(self.ir));
IrBuilder.control_unreachable(self.ir);
}
}
@@ -2077,7 +2056,7 @@ fn emit_aggregate_fns_reserve(self: *Ast2Ir, te: *Node) {
var mn = Ast.node(self.ast, list_at(members, i));
if mn != null {
match mn.body {
.FnDecl(x) => { ignore_usize(emit_fn_reserve(self, mn)); },
.FnDecl(x) => { emit_fn_reserve(self, mn); },
.MemberDecl(md) => {
if md.type_expr != 0 {
var mt = Ast.node(self.ast, md.type_expr);
@@ -2138,7 +2117,7 @@ fn emit_container_reserve(self: *Ast2Ir, ref: usize) {
var d = Ast.node(self.ast, dref);
if d != null {
match d.body {
.FnDecl(x) => { ignore_usize(emit_fn_reserve(self, d)); },
.FnDecl(x) => { emit_fn_reserve(self, d); },
.TypeDecl(td) => {
var tpat = Ast.node(self.ast, td.pattern);
if tpat != null && is_pattern_ident(tpat) {
@@ -2251,7 +2230,6 @@ fn emit_implicit_cast(self: *Ast2Ir, n: *Node, ft: usize, tt: usize, v: usize):
ret 0;
}
// ---- 驱动 ----
fn new(builder: *IrBuilder, sema: *Sema, diag: *Diag): Ast2Ir {
ret Ast2Ir {
@@ -2330,6 +2308,5 @@ fn list_ptr(v: Vec, i: usize): *Ast {
ret null;
}
// ---- 测试 ----
fn main() {}
stage2/attr.spl
+3 -9
View File
@@ -1,8 +1,7 @@
// Expect retcode = 0
// 属性注册表与属性节点（移植自 stage1/spl_attr.c）。注册表是数据：内置属性
// 在 register_builtins 里登记，查找按 (ns, name)。节点记录命中信息 + 实参。
// 新增属性只加注册项，不改 sema 逻辑（对应 SPL.md 的 @/# 扩展点）。
// 属性注册表：内置属性在 register_builtins 登记，按 (ns, name) 查找。新增属性只加
// 注册项，不改 sema 逻辑（SPL.md 的 @/# 扩展点）。
type .{ .Error } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
@@ -163,10 +162,7 @@ fn alloc(self: *Attr, info_index: usize, args: Vec): usize {
}
fn registry_add(self: *Attr, info: AttrInfo) {
match Vec.push(&self.registry, &info as *u8) {
.Ok => {},
.Err(error) => {},
}
Vec.push(&self.registry, &info as *u8);
}
// 返回注册表下标（>=1）或 0。
@@ -205,7 +201,6 @@ fn register_builtins(self: *Attr) {
registry_add(self, make_info("", "export", .Ir, .Decl, .Optional, 1, 1));
}
// ---- dump（镜像 stage1 spl_attr_dump / spl_attr_dump_id）----
fn push_out(buf: *ByteBuffer, bytes: []u8): bool {
match ByteBuffer.append(buf, bytes) {
@@ -341,7 +336,6 @@ fn dump(self: *Attr, out: *ByteBuffer): bool {
ret true;
}
// ---- 测试 ----
fn expect_text(buf: ByteBuffer, expected: []u8) {
var got = ByteBuffer.as_slice(buf);
stage2/def.spl
+4 -12
View File
@@ -1,12 +1,7 @@
// Expect retcode = 0
// 声明句柄表（移植自 stage1/spl_lang_type.h 的 spl_def_node_t 部分）。
// DefId 是「声明」的稳定身份：作用域符号、AST 节点 resolved_def_id、以及将来
// comptime 生成的声明都用它。前向引用/环形引用由 state 状态机表达。
//
// 与 stage1 的差异：owner_ast 改为不透明 `*any`（借用），使本表不依赖具体 AST
// 表示，便于将来 comptime/序列化复用；sema 侧自行 cast 回 *Ast。
// 名称是 ByteView（借用源/AST），本表不做拥有。
// 声明句柄表。DefId 是声明的稳定身份：作用域符号、节点 resolved_def_id、comptime
// 生成的声明都用它；前向/环形引用由 state 状态机表达。owner_ast 为不透明 *any。
type .{ .Error } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
@@ -84,7 +79,7 @@ fn drop(self: *DefTable) {
Vec.drop(&self.table);
}
// id 0 与越界均返回 null（对应 stage1 spl_def_node）。
// id 0 与越界均返回 null。
fn node(self: *DefTable, id: usize): *DefNode {
if id == 0 || id >= self.table.len { ret null; }
ret (self.table.data as *DefNode) + id;
@@ -129,7 +124,6 @@ fn get_lang_id(self: *DefTable, id: usize): usize {
ret d.lang_id;
}
// ---- 分类 ----
fn kind_name(kind: DefKind): []u8 {
match kind {
@@ -156,7 +150,7 @@ fn state_name(state: DeclState): []u8 {
ret "unknown";
}
// 能作为类型使用的 def（对应 stage1 sema_def_is_type）。
// 能作为类型使用的 def。
fn is_type_kind(kind: DefKind): bool {
match kind {
.Scalar => { ret true; },
@@ -169,7 +163,6 @@ fn is_type_kind(kind: DefKind): bool {
ret false;
}
// ---- dump（镜像 stage1 spl_type_def_dump 的文本）----
fn push_out(buf: *ByteBuffer, bytes: []u8): bool {
match ByteBuffer.append(buf, bytes) {
@@ -203,7 +196,6 @@ fn dump(self: *DefTable, id: usize, out: *ByteBuffer): bool {
ret push_out(out, ByteView.as_slice(d.name));
}
// ---- 测试 ----
fn test_alloc_and_state() {
var dt: DefTable = undefined;
stage2/diag.spl
+2 -15
View File
@@ -1,14 +1,7 @@
// Expect retcode = 0
// 丰富诊断（参考 rustc / Clang / Swift 的设计，不照搬 stage1 C 实现）：
// Severity Note/Help/Warning/Error/Fatal
// Code 固定语义枚举 + 稳定 E 码；集中管理，利于 diff
// Span 字节区间 {file,start,end}；file 是 Sources 的下标，NO_FILE 表示无位置
// Label 主/次标签（span + 文本），可多个
// Child 子诊断（note/help，可带 span），挂在条目上
// 渲染：人类可读（源码行 + caret 下划线）与 JSON（字段稳定）双格式。
// 位置只存下标，渲染时经 Sources 解析行列/取行，避免复制文件名。
// 消息按拥有型 Str 保存；条目拥有其 labels/children；clear/drop 释放全部内部资源。
// 丰富诊断：Severity / 稳定 E 码 / Span / Label / Child，渲染为人类可读或 JSON。
// 位置只存下标，渲染时经 Sources 解析行列；条目拥有其字符串与 labels/children。
type .{ .Error, .Status, .make } = @import("./utils/error.spl");
type .{ .Vec } = @import("./utils/vec.spl");
@@ -181,7 +174,6 @@ fn has_error(self: Diag): bool { ret self.errors > 0; }
fn has_fatal(self: Diag): bool { ret self.fatals > 0; }
// ---- 采集 ----
// 追加一条诊断，返回其下标（失败返回 no_file()）。span 为主位置。
fn emit(self: *Diag, severity: Severity, stage: Stage, code: Code, span: Span,
@@ -265,7 +257,6 @@ fn attach_child(self: *Diag, severity: Severity, span: Span, msg: []u8): Status
ret .Ok;
}
// ---- 名称 ----
fn severity_name(severity: Severity): []u8 {
match severity {
@@ -370,7 +361,6 @@ fn code_name(code: Code): []u8 {
ret "none";
}
// ---- 渲染：公共小工具 ----
fn append_num(out: *ByteBuffer, value: usize): Status {
ret append_usize(out, value, 10, false);
@@ -519,7 +509,6 @@ fn render_human(self: *Diag, out: *ByteBuffer): Status {
ret .Ok;
}
// ---- JSON 渲染（字段稳定，供 LSP / diff 工具）----
fn append_json_hex4(out: *ByteBuffer, b: u8): Status {
var hex: []u8 = "0123456789abcdef";
@@ -661,7 +650,6 @@ fn render_json(self: *Diag, out: *ByteBuffer): Status {
ret ByteBuffer.append_byte(out, ']');
}
// ---- 生命周期 ----
fn drop_item(it: *Item) {
Str.drop(&it.message);
@@ -700,7 +688,6 @@ fn drop(self: *Diag) {
self.sources = null;
}
// ---- 测试辅助 ----
fn view(text: []u8): ByteView {
ret ByteView.from_slice(text);
stage2/eval.spl
+9 -18
View File
@@ -1,22 +1,16 @@
// Expect retcode = 0
// comptime / const 求值的**接口 seam**（本轮只占位，不实现求值）。
//
// 目标：把「编译期求值」从 sema 主体里隔离出来，将来接一个解释器（可直接复用
// VM 或 AST 求值器）时不动 sema 结构。sema 只在 comptime 语句 / const 初始化 /
// @import 等点调用这里；未实现时统一返回 NotConst（= 放弃折叠，不报错）。
//
// 分块编译相关：eval 未来的产物是「编译期生成的声明」，统一经 DeclSink 登记，
// 由驱动在固定点循环里插入并触发重跑；eval 自己不直接改 sema 表，避免重入。
// comptime/const 求值的接口 seam：sema 只在此调用，未实现时返回 NotConst（放弃折叠、
// 不报错）。编译期生成的声明经 DeclSink 登记，不改 sema 表。
type .{ .Error } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
type Ast = @import("./ast.spl");
type Diag = @import("./diag.spl");
// 编译期值：占位。未来扩展为 BigInt / 聚合 / 类型句柄等。
// 编译期值（当前仅标量）。
type EvalValue = enum {
Int: usize, // TODO: BigInt
Int: usize,
Bool: bool,
}
@@ -36,14 +30,13 @@ type DeclSinkResult = enum {
Err: Error,
}
// 求值上下文（借用 sink 与 diag；本轮不持有所有权）。
// 求值上下文：sink/diag 均借用，不持有所有权。
type Eval = @self;
sink: *DeclSink, // 借用，可为 null
diag: *Diag, // 借用，可为 null
enabled: bool, // false = 完全不求值（等价旧行为）
enabled: bool, // false = 完全不求值
// ---- DeclSink ----
fn sink_new(): DeclSinkResult {
var s = DeclSink { .items = Vec.blank(@sizeof(usize), @alignof(usize)) };
@@ -66,7 +59,6 @@ fn sink_len(self: *DeclSink): usize {
ret self.items.len;
}
// ---- Eval ----
fn new(sink: *DeclSink, diag: *Diag, enabled: bool): Eval {
ret Eval {
@@ -80,25 +72,24 @@ fn is_enabled(self: *Eval): bool {
ret self.enabled;
}
// 求值一个表达式。本轮一律 NotConst（可由调用方作为「放弃折叠」处理）。
// 求值表达式：当前一律 NotConst（调用方按“放弃折叠”处理）。
fn eval_expr(self: *Eval, ast: *Ast, ref: usize): EvalOutcome {
if !self.enabled { ret .NotConst; }
ret .NotConst;
}
// 执行一个 comptime 块（可能产生声明，登记到 sink）。本轮不做。
// 执行 comptime 块；当前不实现，直接 NotConst。
fn run_block(self: *Eval, ast: *Ast, ref: usize): EvalOutcome {
if !self.enabled { ret .NotConst; }
ret .NotConst;
}
// 顶层 const 初始化求值。本轮不做。
// 顶层 const 初始化求值；当前不实现。
fn eval_const_init(self: *Eval, ast: *Ast, ref: usize): EvalOutcome {
if !self.enabled { ret .NotConst; }
ret .NotConst;
}
// ---- 测试 ----
fn test_sink() {
var sink: DeclSink = undefined;
stage2/intrin.spl
+3 -5
View File
@@ -1,8 +1,7 @@
// Expect retcode = 0
// 内建（intrinsic）注册表（移植自 stage1/spl_intrin.c）。表是数据：按 kind 查
// 描述信息，按名字/字段/`as` 转换规则反查 kind。新增内建只改 info_at，
// 不改 sema 逻辑（对应 SPL.md 的 @/# 扩展点）。
// 内建注册表：按 Intrin 查描述信息，按名字/字段/`as` 规则反查 Intrin。新增内建只改
// info_at，不改 sema 逻辑（SPL.md 的 @/# 扩展点）。
type .{ .ByteView } = @import("utils/byte_view.spl");
type TypeTable = @import("./type_table.spl");
@@ -63,7 +62,7 @@ fn kind_is(a: LangKind, b: LangKind): bool {
ret @enum2int(a) == @enum2int(b);
}
// 与 stage1 表逐项对应（枚举顺序即 kind 数值）。
// 枚举顺序即 kind 数值（与 splc0 表一致）。
fn info_at(index: usize): IntrinInfo {
match index {
1 => {
@@ -250,7 +249,6 @@ fn lookup_cast(ir: *TypeTable, ft: usize, tt: usize): Intrin {
ret .None;
}
// ---- 测试 ----
fn test_info_table() {
var d = info(.Sizeof);
stage2/ir.spl
+9 -16
View File
@@ -1,10 +1,7 @@
// Expect retcode = 0
// SIR 中间表示（移植自 stage1/spl_ir.c/.h）。节点用 arena 序号引用（0 = error），
// 按函数分桶。节点公共字段（kind/dbg/attrs）在外层 entry，kind 专属载荷在 ADT
// IrBody；kind 与载荷变体一一对应（多种 kind 可共享同一载荷形状）。
//
// builder 维护当前函数/基本块/fixup 表，负责发射节点与回填跳转。
// SIR 中间表示：节点用 arena 序号引用（0=error），按函数分桶；公共字段在 IrEntry，
// kind 专属载荷在 IrBody ADT（kind 与载荷一一对应）。builder 负责发射与跳转回填。
type .{ .Error } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
@@ -138,7 +135,6 @@ type Ir = @self;
funcs: Vec, // IrFunc
globals: Vec, // Global
// ---- 生命周期 ----
fn new_entry(): IrEntry {
ret IrEntry {
@@ -159,8 +155,8 @@ fn new(): Ir {
.nodes = Vec.blank(@sizeof(IrEntry), @alignof(IrEntry)),
};
var sn = new_entry();
match Vec.push(&sentinel.nodes, &sn as *u8) { .Ok => {}, .Err(error) => {} }
match Vec.push(&ir.funcs, &sentinel as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(&sentinel.nodes, &sn as *u8);
Vec.push(&ir.funcs, &sentinel as *u8);
ret ir;
}
@@ -307,7 +303,6 @@ fn kind_name(kind: IrKind): []u8 {
ret "?";
}
// ---- dump ----
fn out_str(out: *ByteBuffer, s: []u8): bool {
match ByteBuffer.append(out, s) { .Ok => { ret true; }, .Err(error) => { ret false; } }
@@ -360,11 +355,10 @@ fn dump_body(out: *ByteBuffer, ty: *TypeTable, e: *IrEntry): bool {
.Arith(a) => {
if !dump_type(out, ty, a.tid) { ret false; }
if !dump_ref(out, a.left) { ret false; }
// 一元 arith（neg/abs/not）不打印 right（镜像 stage1）。
if @enum2int(e.kind) == @enum2int(IrKind.ArithNeg) ||
@enum2int(e.kind) == @enum2int(IrKind.ArithAbs) ||
@enum2int(e.kind) == @enum2int(IrKind.ArithNot) {
ret true;
// 一元 arith（neg/abs/not）不打印 right。
match e.kind {
.ArithNeg, .ArithAbs, .ArithNot => { ret true; },
_ => {},
}
ret dump_ref(out, a.right);
},
@@ -465,7 +459,7 @@ fn dump_body(out: *ByteBuffer, ty: *TypeTable, e: *IrEntry): bool {
match ByteBuffer.append_byte(out, cv as u8) { .Ok => {}, .Err(error) => { ret false; } }
ret out_str(out, "'");
}
// stage1 对其他常量统一按 int_lit 打印（union 别名）。
// 其他常量统一按 int_lit 打印（union 别名）。
var iv: usize = 0;
match c.lit {
.Int(v) => { iv = v; },
@@ -582,7 +576,6 @@ fn dump(self: *Ir, ty: *TypeTable, attr: *Attr, out: *ByteBuffer): bool {
ret true;
}
// ---- 测试 ----
fn test_kinds() {
@assert(ByteView.eq(ByteView.from_slice(kind_name(.ArithAdd)), ByteView.from_slice("arith.add")),
stage2/ir2c.spl
+2 -13
View File
@@ -1,12 +1,7 @@
// Expect retcode = 0
// IR -> C99 后端（P1a 子集）。
//
// 设计：每个 IR ref 一个 C 局部变量（C 编译器 -O2 会做 mem2reg），标签用 goto；
// 类型直接由 IR 的 tid 决定，生成期无运行时分发。
//
// 每个非 extern 函数的 C 名为 `spl_f<fid>`；extern 函数直接用其 SPL 名
// （由 runtime 提供）。暂不支持聚合/切片/全局数据。
// IR -> C99。每个 IR ref 生成一个 C 局部变量（交给 C 编译器 mem2reg），标签用 goto；
// 类型由 IR tid 决定，生成期无运行时分发。非 extern 函数名为 `spl_f<fid>`。
type .{ .Vec } = @import("utils/vec.spl");
type .{ .ByteView } = @import("utils/byte_view.spl");
@@ -83,7 +78,6 @@ fn put_unsupported(self: *Ir2C, what: []u8) {
put(self, " */\n");
}
// ---- 类型查询 ----
fn info_of(self: *Ir2C, tid: usize): *LayoutM.LayoutInfo {
ret LayoutM.info_of(self.layout, tid);
@@ -168,7 +162,6 @@ fn fn_ret_type(self: *Ir2C, fn_tid: usize): usize {
ret 0;
}
// ---- C 类型 ----
fn put_type(self: *Ir2C, tid: usize): bool {
var te = TypeTable.node(self.ty, tid);
@@ -231,7 +224,6 @@ fn c_fn_name(self: *Ir2C, fid: usize) {
put_u(self, fid);
}
// ---- 常量解析 ----
fn const_node(self: *Ir2C, f: *IrFunc, ref: usize): usize {
if ref == 0 || ref >= f.nodes.len { ret 0; }
@@ -250,7 +242,6 @@ fn const_node(self: *Ir2C, f: *IrFunc, ref: usize): usize {
ret 0;
}
// ---- 聚合字段 ----
fn field_tid(self: *Ir2C, tid: usize, idx: usize): usize {
var te = TypeTable.node(self.ty, tid);
@@ -436,7 +427,6 @@ fn emit_agg_insert(self: *Ir2C, ref: usize, n: *IrEntry) {
}
}
// ---- 节点发射 ----
fn emit_arith(self: *Ir2C, ref: usize, n: *IrEntry) {
match n.body {
@@ -1224,7 +1214,6 @@ fn emit_def(self: *Ir2C, fid: usize) {
put(self, "spl_trap();\n}\n");
}
// ---- driver ----
fn find_main(self: *Ir2C): usize {
var i: usize = 1;
stage2/ir2vm.spl
+25 -44
View File
@@ -1,11 +1,7 @@
// Expect retcode = 0
// IR -> VM 机器码（移植自 stage1/spl_ir2vm.c）。
// 依赖：IR（ir.spl）、IR 类型表（type_table.spl）、布局（layout.spl）、
// 属性（attr.spl）、字节码容器（mcode.spl）。
//
// extern_native 用「按函数 ref 下标的 isize 数组」代替 stage1 的 map：
// 默认 -1 表示非 extern，>=0 表示 native 索引（语义等价）。
// IR -> VM 字节码。extern_native 是按函数 ref 下标的 isize 数组：-1 非 extern，
// >=0 为 native 索引。
type .{ .Vec } = @import("utils/vec.spl");
type .{ .ByteView } = @import("utils/byte_view.spl");
@@ -19,7 +15,7 @@ type IrM = @import("./ir.spl");
type .{ .Ir, .IrFunc, .IrEntry, .Global } = @import("./ir.spl");
type Mcode = @import("./mcode.spl");
type .{ .Prog, .Op, .VmKind, .VmIns, .VmFunc } = @import("./mcode.spl");
type Mem = @import("sys/mem.spl");
type Mem = @import("utils/memory.spl");
type Ir2Vm = @self;
@@ -31,7 +27,6 @@ extern_native: Vec, // isize
global_gaddr: Vec, // usize：每个全局变量在 prog.gdata 的下标
prog: Prog,
// ---- 类型/布局查询 ----
fn info_of(ctx: *Ir2Vm, tid: usize): *LayoutM.LayoutInfo {
ret LayoutM.info_of(ctx.layout, tid);
@@ -187,7 +182,6 @@ fn ir_result_tid(ctx: *Ir2Vm, n: *IrEntry): usize {
ret 0;
}
// ---- 小工具 ----
// 内部热路径：假定索引有效，直接取址（省去 Vec.get/valid）。
fn usize_at(v: *Vec, i: usize): usize {
@@ -195,7 +189,7 @@ fn usize_at(v: *Vec, i: usize): usize {
}
fn push_usize(v: *Vec, x: usize) {
ignore_bool(Vec.push_raw(v, &x as *u8));
Vec.push_raw(v, &x as *u8);
}
fn fnode(f: *IrFunc, i: usize): *IrEntry {
@@ -239,7 +233,6 @@ fn const_fn(n: *IrEntry): usize {
ret 0;
}
// ---- extern ----
fn fn_check_extern(ctx: *Ir2Vm, f: *IrFunc): bool {
if ctx.attr == null || f == null { ret false; }
@@ -275,7 +268,6 @@ fn extern_set(ctx: *Ir2Vm, ref: usize, value: isize) {
}
}
// ---- 帧布局 ----
type Slot = struct {
result_off: usize,
@@ -363,7 +355,7 @@ fn frame_build(fl: *FrameLayout, ctx: *Ir2Vm, fid: usize) {
var i: usize = 0;
while i < n {
var blank: Slot = .{ .result_off = 0, .data_off = 0 };
ignore_bool(Vec.push_raw(&fl.slots, &blank as *u8));
Vec.push_raw(&fl.slots, &blank as *u8);
i = i + 1;
}
@@ -397,7 +389,6 @@ fn frame_drop(fl: *FrameLayout) {
Vec.drop(&fl.slots);
}
// ---- cgen ----
type FixKind = enum {
Jmp,
@@ -432,7 +423,7 @@ fn emit(cg: *Cgen, op: Op, ty: VmKind, imm: usize) {
prog.insns.len = i + 1;
ret;
}
ignore_usize(Mcode.add_instr(prog, op, ty, imm));
Mcode.add_instr(prog, op, ty, imm);
}
fn ip_of(cg: *Cgen): usize {
@@ -534,7 +525,7 @@ fn cg_add_fix(cg: *Cgen, ins_idx: usize, kind: FixKind, node_target: usize, fn_t
.node_target = node_target,
.fn_target = fn_target,
};
match Vec.push(cg.fixups, &fx as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(cg.fixups, &fx as *u8);
}
fn arith_tid(n: *IrEntry): usize {
@@ -696,7 +687,7 @@ fn cg_cast(cg: *Cgen, ref: usize, n: *IrEntry) {
} else if f_bool && t_int {
emit(cg, .Zext, .Void, 1);
}
ignore_bool(t_bool);
t_bool;
cg_store_slot(cg, ref, tk);
},
_ => {},
@@ -1148,7 +1139,6 @@ fn cmp_tid(n: *IrEntry): usize {
ret 0;
}
// ---- 翻译 ----
fn translate_function(ctx: *Ir2Vm, fid: usize, all_fixups: *Vec): usize {
var irf = IrM.func(ctx.ir, fid);
@@ -1172,7 +1162,7 @@ fn translate_function(ctx: *Ir2Vm, fid: usize, all_fixups: *Vec): usize {
var func_ip = ip_of(&cg);
ignore_usize(Mcode.add_func(&ctx.prog, irf.name, fn_nargs(ctx, irf.fn_tid), func_ip));
Mcode.add_func(&ctx.prog, irf.name, fn_nargs(ctx, irf.fn_tid), func_ip);
var local_slots = (cg.frame.frame_bytes - cg.frame.args_bytes + 7) / 8;
emit(&cg, .Alloc, .Void, local_slots);
@@ -1193,23 +1183,19 @@ fn translate_function(ctx: *Ir2Vm, fid: usize, all_fixups: *Vec): usize {
i = 0;
while i < local_fixups.len {
match Vec.get(&local_fixups, i) {
.Ok(ptr) => {
var fx = ptr as *Fix;
if @enum2int(fx.kind) == @enum2int(FixKind.Jmp) {
var ins = ins_ptr(&ctx.prog, fx.ins_idx);
if ins != null {
var target_ip: usize = 0;
if fx.node_target < nnodes {
target_ip = usize_at(&cg.node_ip, fx.node_target);
}
ins.imm = target_ip - fx.ins_idx - 1;
var fx = (local_fixups.data as *Fix) + i;
match fx.kind {
.Jmp => {
var ins = ins_ptr(&ctx.prog, fx.ins_idx);
if ins != null {
var target_ip: usize = 0;
if fx.node_target < nnodes {
target_ip = usize_at(&cg.node_ip, fx.node_target);
}
} else if @enum2int(fx.kind) == @enum2int(FixKind.Fnaddr) {
match Vec.push(all_fixups, ptr as *u8) { .Ok => {}, .Err(error) => {} }
ins.imm = target_ip - fx.ins_idx - 1;
}
},
.Err(error) => {},
.Fnaddr => { Vec.push(all_fixups, fx as *u8); },
}
i = i + 1;
}
@@ -1220,9 +1206,8 @@ fn translate_function(ctx: *Ir2Vm, fid: usize, all_fixups: *Vec): usize {
ret func_ip;
}
// ---- 生命周期 / 入口 ----
// 就地初始化（避免返回含 Prog 的大聚合；对应 stage1 spl_ir2vm_init）。
// 就地初始化，避免返回含 Prog 的大聚合。
fn init(ctx: *Ir2Vm, ir: *Ir, ty: *TypeTable, layout: *Layout, attr: *Attr) {
ctx.ir = ir;
ctx.ty = ty;
@@ -1246,7 +1231,7 @@ fn drop(ctx: *Ir2Vm) {
fn run_func(ctx: *Ir2Vm, ref: usize): i32 {
var all_fixups = Vec.blank(@sizeof(Fix), @alignof(Fix));
defer { Vec.drop(&all_fixups); }
ignore_usize(translate_function(ctx, ref, &all_fixups));
translate_function(ctx, ref, &all_fixups);
ret 0;
}
@@ -1258,7 +1243,7 @@ fn run(ctx: *Ir2Vm): i32 {
var i: usize = 0;
while i < n {
var v: isize = -1;
match Vec.push(&ctx.extern_native, &v as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(&ctx.extern_native, &v as *u8);
i = i + 1;
}
i = 1;
@@ -1283,12 +1268,12 @@ fn run(ctx: *Ir2Vm): i32 {
didx = Mcode.add_data(&ctx.prog, g.data.data as usize, gsize);
}
var dv = didx;
match Vec.push(&ctx.global_gaddr, &dv as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(&ctx.global_gaddr, &dv as *u8);
gi = gi + 1;
}
// 哨兵：保证真实函数入口地址非零。
ignore_usize(Mcode.add_instr(&ctx.prog, .Halt, .Void, 0));
Mcode.add_instr(&ctx.prog, .Halt, .Void, 0);
// 预分配指令容量（按 IR 节点数粗略估计），减少逐条 append 的扩容/拷贝。
var est: usize = 16;
@@ -1298,7 +1283,7 @@ fn run(ctx: *Ir2Vm): i32 {
if irf != null { est = est + irf.nodes.len * 8 + 32; }
i = i + 1;
}
match Vec.reserve(&ctx.prog.insns, est) { .Ok => {}, .Err(error) => {} }
Vec.reserve(&ctx.prog.insns, est);
// Pass 2：翻译非 extern 函数。
var fid_ip = Vec.blank(@sizeof(usize), @alignof(usize));
@@ -1382,12 +1367,8 @@ fn store(ctx: *Ir2Vm, path: ByteView): bool {
ret false;
}
// ---- 工具 ----
fn ignore_usize(v: usize) {}
fn ignore_bool(b: bool) {}
// ---- 测试 ----
fn main() {
var ir = IrM.new();
stage2/ir_builder.spl
+22 -50
View File
@@ -1,7 +1,6 @@
// Expect retcode = 0
// SIR builder (IrBuilder). Split from ir.spl: stage1 ast2ir
// infinitely recurses on same-file @self nesting; cross-file is fine.
// IR 构建器：单独成文件，以免 ast2ir 在同文件 @self 嵌套时无限递归。
type .{ .Error } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
@@ -18,8 +17,6 @@ fn list_at(v: Vec, i: usize): usize {
ret ((v.data as *usize) + i).*;
}
// ---- builder ----
type FixKind = enum { BrTrue, BrFalse, Jmp }
type Fix = struct {
@@ -46,13 +43,9 @@ fn builder_alloc(self: *IrBuilder, kind: IrKind): usize {
e.kind = kind;
e.dbg = self.dbg;
}
if self.current_block >= self.blocks.len { ret ref; }
match Vec.get(&self.blocks, self.current_block) {
.Ok(p) => {
var slot = p as *usize;
if slot.* == 0 { slot.* = ref; }
},
.Err(error) => {},
if self.current_block < self.blocks.len {
var slot = (self.blocks.data as *usize) + self.current_block;
if slot.* == 0 { slot.* = ref; }
}
ret ref;
}
@@ -113,25 +106,18 @@ fn fn_begin_at(self: *IrBuilder, fid: usize) {
fn fn_end(self: *IrBuilder) {
var k: usize = 0;
while k < self.fixups.len {
match Vec.get(&self.fixups, k) {
.Ok(fp) => {
var fx = fp as *Fix;
var e = Ir.node(&self.ir, self.current_fn, fx.node);
if e != null {
var target: usize = 0;
if fx.block < self.blocks.len { target = list_at(self.blocks, fx.block); }
if target != 0 {
if @enum2int(fx.slot) == @enum2int(FixKind.BrTrue) {
match e.body { .Br(&b) => { b.true_label = target; }, _ => {} }
} else if @enum2int(fx.slot) == @enum2int(FixKind.BrFalse) {
match e.body { .Br(&b) => { b.false_label = target; }, _ => {} }
} else {
match e.body { .Jmp(&j) => { j.label = target; }, _ => {} }
}
}
var fx = (self.fixups.data as *Fix) + k;
var e = Ir.node(&self.ir, self.current_fn, fx.node);
if e != null {
var target: usize = 0;
if fx.block < self.blocks.len { target = list_at(self.blocks, fx.block); }
if target != 0 {
match fx.slot {
.BrTrue => { match e.body { .Br(&b) => { b.true_label = target; }, _ => {} } },
.BrFalse => { match e.body { .Br(&b) => { b.false_label = target; }, _ => {} } },
.Jmp => { match e.body { .Jmp(&j) => { j.label = target; }, _ => {} } },
}
},
.Err(error) => {},
}
}
k = k + 1;
}
@@ -143,7 +129,7 @@ fn fn_end(self: *IrBuilder) {
fn block_begin(self: *IrBuilder): usize {
var zero: usize = 0;
match Vec.push(&self.blocks, &zero as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(&self.blocks, &zero as *u8);
var block = self.blocks.len - 1;
self.current_block = block;
self.terminated = false;
@@ -151,10 +137,9 @@ fn block_begin(self: *IrBuilder): usize {
}
fn block_end(self: *IrBuilder) {
// terminated 与空块校验在 stage1 为 Panic；这里保持同样约束但不终止进程。
// 空实现：本实现不做 terminated/空块校验（不终止进程）。
}
// ---- arith / cmp / cast ----
fn set_arith(self: *IrBuilder, kind: IrKind, tid: usize, left: usize, right: usize): usize {
var ref = builder_alloc(self, kind);
@@ -211,7 +196,6 @@ fn cast_bool2int(self: *IrBuilder, f: usize, t: usize, v: usize): usize { ret se
fn case_int2float(self: *IrBuilder, f: usize, t: usize, v: usize): usize { ret set_cast(self, .CaseInt2float, f, t, v); }
fn case_float2int(self: *IrBuilder, f: usize, t: usize, v: usize): usize { ret set_cast(self, .CaseFloat2int, f, t, v); }
// ---- memory ----
fn mem_alloca(self: *IrBuilder, tid: usize, count: usize): usize {
var ref = builder_alloc(self, .MemAlloca);
@@ -269,7 +253,6 @@ fn mem_set(self: *IrBuilder, tid: usize, dst: usize, val: usize, size: usize): u
ret ref;
}
// ---- type const ----
fn const_node(self: *IrBuilder, tid: usize, lit: ConstLit): usize {
var ref = builder_alloc(self, .TypeConst);
@@ -292,7 +275,6 @@ fn add_global(self: *IrBuilder, tid: usize, zero: bool, bytes: Vec): usize {
ret Ir.add_global(&self.ir, tid, zero, bytes);
}
// ---- type ops ----
fn type_bitsizeof(self: *IrBuilder, tid: usize): usize {
var ref = builder_alloc(self, .TypeBitsizeof);
@@ -329,7 +311,6 @@ fn type_field_count(self: *IrBuilder, tid: usize): usize {
ret ref;
}
// ---- agg ----
fn agg_construct(self: *IrBuilder, tid: usize): usize {
var ref = builder_alloc(self, .AggConstruct);
@@ -343,12 +324,8 @@ fn agg_construct(self: *IrBuilder, tid: usize): usize {
fn agg_construct_field(self: *IrBuilder, node_ref: usize, field: usize) {
var e = Ir.node(&self.ir, self.current_fn, node_ref);
if e == null { ret; }
// 载荷按值绑定：改副本后写回。
match e.body {
.AggConstruct(a) => {
match Vec.push(&a.fields, &field as *u8) { .Ok => {}, .Err(error) => {} }
e.body = .AggConstruct(a);
},
.AggConstruct(&a) => { Vec.push(&a.fields, &field as *u8); },
_ => {},
}
}
@@ -369,7 +346,6 @@ fn agg_insert(self: *IrBuilder, tid: usize, field_idx: usize, agg: usize, field:
ret ref;
}
// ---- control ----
fn control_select(self: *IrBuilder, tid: usize, cond: usize, tv: usize, fv: usize): usize {
var ref = builder_alloc(self, .ControlSelect);
@@ -388,9 +364,9 @@ fn control_br(self: *IrBuilder, cond: usize): usize {
fn control_br_fixup(self: *IrBuilder, ref: usize, true_block: usize, false_block: usize) {
var f1 = Fix { .node = ref, .slot = .BrTrue, .block = true_block };
match Vec.push(&self.fixups, &f1 as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(&self.fixups, &f1 as *u8);
var f2 = Fix { .node = ref, .slot = .BrFalse, .block = false_block };
match Vec.push(&self.fixups, &f2 as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(&self.fixups, &f2 as *u8);
}
fn control_jmp(self: *IrBuilder): usize {
@@ -403,7 +379,7 @@ fn control_jmp(self: *IrBuilder): usize {
fn control_jmp_fixup(self: *IrBuilder, ref: usize, target_block: usize) {
var fx = Fix { .node = ref, .slot = .Jmp, .block = target_block };
match Vec.push(&self.fixups, &fx as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(&self.fixups, &fx as *u8);
}
fn control_call(self: *IrBuilder, tid: usize, fn_ref: usize): usize {
@@ -419,12 +395,8 @@ fn control_call(self: *IrBuilder, tid: usize, fn_ref: usize): usize {
fn control_call_param(self: *IrBuilder, call_node: usize, arg: usize) {
var e = Ir.node(&self.ir, self.current_fn, call_node);
if e == null { ret; }
// 载荷按值绑定：改副本后写回。
match e.body {
.Call(c) => {
match Vec.push(&c.params, &arg as *u8) { .Ok => {}, .Err(error) => {} }
e.body = .Call(c);
},
.Call(&c) => { Vec.push(&c.params, &arg as *u8); },
_ => {},
}
}
stage2/lang_type.spl
+11 -37
View File
@@ -1,11 +1,7 @@
// Expect retcode = 0
// 语言类型表（移植自 stage1/spl_lang_type.c）：在 IR 类型表（type_table.spl）
// 之上，登记「语言层类型」= IR 类型 id + 语言种类 + 聚合方法表，同样 hash-consing。
// 另持有声明句柄表（def.spl）与语言类型子类型/求交/字面量适配。
//
// 语言类型是 sema 的主类型：AST 节点 resolved_lang_tid、def.lang_id 都指这里。
// 名称/方法名是 ByteView（借用）；聚合方法表与 tuple/fn 的载荷 Vec 由本表拥有。
// 语言类型表：在 IR 类型表之上登记「语言层类型」（IR 类型 id + 种类 + 聚合成员），
// 按结构 hash-consing。sema 的 resolved_lang_tid / def.lang_id 都指向这里。
type .{ .Error } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
@@ -77,7 +73,6 @@ type LangTypeResult = enum {
Err: Error,
}
// ---- 小工具 ----
fn seed(): usize {
ret 14695981039346656037;
@@ -142,7 +137,6 @@ fn elem_of(entry: LangEntry): usize {
ret 0;
}
// ---- 生命周期 ----
fn new_entry(kind: LangKind, ir_type_id: usize): LangEntry {
ret LangEntry {
@@ -215,7 +209,7 @@ fn drop(self: *LangType) {
TypeTable.drop(&self.ir);
}
// id 0 与越界返回 null（对应 stage1 spl_lang_type_node）。
// id 0 与越界返回 null。
fn lang_node(self: *LangType, id: usize): *LangEntry {
if id == 0 || id >= self.lang_table.len { ret null; }
ret (self.lang_table.data as *LangEntry) + id;
@@ -231,7 +225,6 @@ fn get_ir_type(self: *LangType, lang_id: usize): usize {
ret ir_type(self, lang_id);
}
// ---- IR 类型槽位预留（自引用聚合）----
fn reserve_ir(self: *LangType): usize {
ret TypeTable.reserve(&self.ir);
@@ -241,7 +234,6 @@ fn define_ir(self: *LangType, id: usize, src: *TypeNode) {
TypeTable.define(&self.ir, id, src);
}
// ---- def 便捷封装（sema 侧只用 LangType）----
fn alloc_def(self: *LangType, kind: DefKind, name: ByteView, span: Span, owner: *any,
ast_node_ref: usize): usize {
@@ -266,7 +258,6 @@ fn def_is_type(self: *LangType, id: usize): bool {
ret DefTable.is_type_kind(d.kind);
}
// ---- intern ----
fn free_extra(e: *LangEntry) {
match e.extra {
@@ -423,10 +414,7 @@ fn fold_insert(self: *LangType, hash: usize, id: usize) {
var e = lang_node(self, id);
if e == null { ret; }
e.hash_next = old;
match Map.put(&self.fold, &hash as *u8, &id as *u8) {
.Ok => {},
.Err(error) => {},
}
Map.put(&self.fold, &hash as *u8, &id as *u8);
}
// intern 一个 probe：命中释放载荷并返回已有 id；否则复制入表。probe 返回后失效。
@@ -460,7 +448,6 @@ fn push_simple(self: *LangType, kind: LangKind, ir: usize): usize {
ret push(self, &e);
}
// ---- builders ----
fn make_error(self: *LangType): usize {
ret push_simple(self, .Error, TypeTable.make_error(&self.ir));
@@ -560,13 +547,10 @@ fn make_range(self: *LangType, elem_lang: usize): usize {
ret push(self, &e);
}
// 为 tuple 字段生成稳定的十进制名字（"0"/"1"/...），镜像 stage1。
// tuple 字段用稳定的十进制名（"0"/"1"/...）。
fn intern_index_name(self: *LangType, value: usize): ByteView {
var b = ByteBuffer.new();
match append_usize(&b, value, 10, false) {
.Ok => {},
.Err(error) => {},
}
append_usize(&b, value, 10, false);
var view = ByteView.from_slice(ByteBuffer.as_slice(b));
match Vec.push(&self.owned_names, &b as *u8) {
.Ok => {},
@@ -646,7 +630,7 @@ fn parse_bits(rest: []u8): usize {
ret value;
}
// 内置类型名：bool/void/isize/usize/any/iN/uN/fN（对应 stage1 spl_type_lookup_builtin）。
// 内置类型名：bool/void/isize/usize/any/iN/uN/fN。
fn lookup_builtin(self: *LangType, name: ByteView): usize {
if name.len == 0 { ret 0; }
if ByteView.eq(name, ByteView.from_slice("bool")) { ret make_bool(self); }
@@ -675,7 +659,6 @@ fn lookup_builtin(self: *LangType, name: ByteView): usize {
ret 0;
}
// ---- IR 位宽读取 ----
fn int_bits(self: *LangType, ir_id: usize): usize {
var te = TypeTable.node(&self.ir, ir_id);
@@ -707,7 +690,6 @@ fn float_bits(self: *LangType, ir_id: usize): usize {
ret 0;
}
// ---- 语言层子类型 / 求交 / 字面量适配 ----
fn is_subtype(self: *LangType, sub: usize, super: usize): bool {
if sub == 0 || super == 0 { ret false; }
@@ -838,7 +820,7 @@ fn int_fits(self: *LangType, target: usize, value: BigInt): bool {
.Err(error) => { ret false; },
}
// 镜像 stage1：目标位宽 >= 64 时不做边界检查（其 mpa 只存低 64 位）。
// 目标位宽 >= 64 时不做边界检查（mpa 只存低 64 位）。
if bits >= 64 { ret true; }
var u: u64 = 0;
@@ -860,7 +842,6 @@ fn int_fits(self: *LangType, target: usize, value: BigInt): bool {
ret false;
}
// ---- dump（镜像 stage1 spl_lang_type_dump）----
fn push_out(buf: *ByteBuffer, bytes: []u8): bool {
match ByteBuffer.append(buf, bytes) {
@@ -898,10 +879,7 @@ fn dump_rec(self: *LangType, id: usize, out: *ByteBuffer, stack: *Vec): bool {
if e == null {
if !push_out(out, "none") { ret false; }
var dropped: usize = 0;
match Vec.pop(stack, &dropped as *u8) {
.Ok => {},
.Err(error) => {},
}
Vec.pop(stack, &dropped as *u8);
ret true;
}
@@ -941,7 +919,7 @@ fn dump_rec(self: *LangType, id: usize, out: *ByteBuffer, stack: *Vec): bool {
if !push_out(out, "[") { ok = false; }
if ok && !push_usize(out, len) { ok = false; }
if ok && !push_out(out, "]") { ok = false; }
// 镜像 stage1：数组直接 dump IR 类型（会重复一次 [N]）。
// 数组直接 dump IR 类型（会重复一次 [N]）。
if ok { ok = TypeTable.pure_dump(&self.ir, e.ir_type_id, out); }
},
.Slice => {
@@ -995,10 +973,7 @@ fn dump_rec(self: *LangType, id: usize, out: *ByteBuffer, stack: *Vec): bool {
}
var dropped2: usize = 0;
match Vec.pop(stack, &dropped2 as *u8) {
.Ok => {},
.Err(error) => {},
}
Vec.pop(stack, &dropped2 as *u8);
ret ok;
}
@@ -1008,7 +983,6 @@ fn dump(self: *LangType, id: usize, out: *ByteBuffer): bool {
ret dump_rec(self, id, out, &stack);
}
// ---- 测试 ----
fn expect_text(buf: ByteBuffer, expected: []u8) {
var got = ByteBuffer.as_slice(buf);
stage2/layout.spl
+4 -9
View File
@@ -1,9 +1,7 @@
// Expect retcode = 0
// 目标布局（移植自 stage1/spl_layout.c）。输入是 IR 类型表 TypeTable；
// 为每个类型计算 size_bits / align_bits / 字段位偏移，供 ir2vm 使用。
// 默认 64 位平台：标量按 1/2/4/8 字节对齐，指针 = usize，聚合按最大字段对齐
// 且不允许重排（与 stage1 的默认策略一致）。
// 目标布局：由 IR 类型表计算 size/align/字段位偏移，供 ir2vm 使用。默认 64 位平台，
// 聚合按最大字段对齐且不重排。
type .{ .Error } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
@@ -47,7 +45,7 @@ fn info_at(self: *Layout, id: usize): *LayoutInfo {
ret (self.infos.data as *LayoutInfo) + id;
}
// 未解析或越界返回 null（对应 stage1 spl_layout_info_of）。
// 未解析或越界返回 null。
fn info_of(self: *Layout, id: usize): *LayoutInfo {
var info = info_at(self, id);
if info == null || !info.resolved { ret null; }
@@ -84,10 +82,7 @@ fn ensure(self: *Layout, n: usize) {
}
fn push_usize(v: *Vec, x: usize) {
match Vec.push(v, &x as *u8) {
.Ok => {},
.Err(error) => {},
}
Vec.push(v, &x as *u8);
}
fn usize_at(v: *Vec, i: usize): usize {
stage2/lexer.spl
+2 -7
View File
@@ -1,9 +1,7 @@
// Expect retcode = 0
// 词法分析器：字节流 -> Vec<Token>。镜像 stage1/spl_lexer.c 的行为：
// 行注释作为 token 产出；块注释（可嵌套）整体跳过；换行产出 Endline；EOF 产出 Eof。
// 复用 utils/ascii 做字符分类；整型/字符在词法期解码后放进 TokenKind 载荷。
// Token.text 借用输入字节，不复制。
// 字节流 -> Vec<Token>。行为镜像 splc0（保证 diff）：行注释作为 token 产出，块注释
//（可嵌套）跳过，换行产 Endline，EOF 产 Eof。Token.text 借用输入，不复制。
type .{ .Vec, .VecResult } = @import("utils/vec.spl");
type .{ .ByteView } = @import("utils/byte_view.spl");
@@ -80,7 +78,6 @@ fn decode_char(text: ByteView): u8 {
ret e;
}
// ---- 读取辅助 ----
fn has2(self: *Lexer, ch: u8): bool {
ret self.pos + 1 < self.src.len && self.src.ptr[self.pos + 1] == ch;
@@ -120,7 +117,6 @@ fn op3(self: *Lexer, out: *Vec, punct: Punct, start: usize, line: usize, col: us
emit_to(self, out, .Punct(punct), start, start + 3, line, col);
}
// ---- 复合扫描 ----
fn scan_int(self: *Lexer, out: *Vec, start: usize, line: usize, col: usize) {
var p = self.pos;
@@ -453,7 +449,6 @@ fn lex(src: ByteView, diag: *Diag, file: usize): VecResult {
ret .Ok(out);
}
// ---- 测试辅助 ----
fn view(text: []u8): ByteView {
ret ByteView.from_slice(text);
stage2/mcode.spl
+29 -47
View File
@@ -1,28 +1,15 @@
// Expect retcode = 0
// SPL VM 机器码容器（移植自 stage0/spl_mcode.c 的构建/序列化/dump 部分）。
// 只负责「内存中的 prog」与「写入 .sir」，不包含反序列化（由 C 侧 spl_cli 读）。
//
// 字符串一律是 ByteView（借用上层 IR/attr 的名称，本模块不复制、不释放）；
// gdata 条目是 ByteBuffer，由本模块拥有并释放。
//
// 二进制格式（元数据字段均为 u64 小端）：
// [HEADER] magic(8) nfuncs(8) ninsns(8) nnatives(8) nstrs(8) ndata(8)
// [FUNCS] 每项: name_len(8) name(pad8, 含结尾 NUL) idx_of_strtab(8)
// nargs(8) ninsns(8) address(8)
// [INSTRS] 每项: opcode(2) type(2) imm(8) = 12 字节
// [NATIVES] 每项: name_len(8) name(pad8, 含结尾 NUL) idx_of_strtab(8)
// [STRTAB] 每项: slen(8) str(pad8)
// [GDATA] 每项: dsize(8) data(pad8)
// VM 字节码容器：内存中的 Prog 与 .sir 序列化（反序列化在 C 侧 spl_cli）。
// 字符串用 ByteView 借用、不拥有；gdata 条目为 ByteBuffer，由本模块拥有释放。
type .{ .Error, .Status, .make } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
type .{ .ByteView } = @import("utils/byte_view.spl");
type .{ .ByteBuffer } = @import("utils/byte_buffer.spl");
type .{ .append_usize, .append_i64 } = @import("utils/fmt.spl");
type Mem = @import("sys/mem.spl");
type File = @import("sys/file.spl");
type .{ .open_cstr, .write_all, .read_all } = @import("utils/io.spl");
type Mem = @import("utils/memory.spl");
type .{ .open_cstr, .write_all, .read_all, .File } = @import("utils/io.spl");
type Op = enum {
Error,
@@ -208,7 +195,6 @@ fn kind_name(k: VmKind): []u8 {
ret "???";
}
// ---- 生命周期 ----
fn new(): ProgResult {
var prog = Prog {
@@ -264,7 +250,6 @@ fn drop(self: *Prog) {
Vec.drop(&self.insns);
}
// ---- 构建 ----
fn add_instr(self: *Prog, op: Op, ty: VmKind, imm: usize): usize {
var i = self.insns.len;
@@ -306,7 +291,7 @@ fn add_data(self: *Prog, ptr: usize, size: usize): usize {
}
if size != 0 {
if ptr == 0 { ByteBuffer.drop(&entry); ret 0; }
ignore_ptr(Mem.copy(entry.storage.data as *any, ptr as *any, size));
Mem.copy(entry.storage.data as *any, ptr as *any, size);
entry.storage.len = size;
}
match Vec.push(&self.gdata, &entry as *u8) {
@@ -353,7 +338,6 @@ fn get_or_add_native(self: *Prog, name: ByteView): isize {
ret (self.natives.len - 1) as isize;
}
// ---- dump（输出必须与 stage0 spl_prog_dump 逐字节一致）----
fn out_s(out: *ByteBuffer, s: []u8): bool {
match ByteBuffer.append(out, s) { .Ok => { ret true; }, .Err(error) => { ret false; } }
@@ -470,21 +454,23 @@ fn dump(self: *Prog, out: *ByteBuffer): bool {
if !out_s(out, " ") { ret false; }
if !out_i(out, ins.imm as i64) { ret false; }
if @enum2int(ins.opcode) == @enum2int(Op.Jmp) ||
@enum2int(ins.opcode) == @enum2int(Op.Bz) ||
@enum2int(ins.opcode) == @enum2int(Op.Bnz) {
if !out_s(out, " ; -> ") { ret false; }
if !out_u(out, i + 1 + ins.imm) { ret false; }
} else if @enum2int(ins.opcode) == @enum2int(Op.Call) {
if !out_s(out, " ; nargs=") { ret false; }
if !out_u(out, ins.imm) { ret false; }
if !out_s(out, ", from stack") { ret false; }
} else if @enum2int(ins.opcode) == @enum2int(Op.Calli) {
if !out_s(out, " ; indirect call") { ret false; }
} else if @enum2int(ins.opcode) == @enum2int(Op.Gaddr) {
if !out_s(out, " ; gdata[") { ret false; }
if !out_u(out, ins.imm) { ret false; }
if !out_s(out, "]") { ret false; }
match ins.opcode {
.Jmp, .Bz, .Bnz => {
if !out_s(out, " ; -> ") { ret false; }
if !out_u(out, i + 1 + ins.imm) { ret false; }
},
.Call => {
if !out_s(out, " ; nargs=") { ret false; }
if !out_u(out, ins.imm) { ret false; }
if !out_s(out, ", from stack") { ret false; }
},
.Calli => { if !out_s(out, " ; indirect call") { ret false; } },
.Gaddr => {
if !out_s(out, " ; gdata[") { ret false; }
if !out_u(out, ins.imm) { ret false; }
if !out_s(out, "]") { ret false; }
},
_ => {},
}
if !out_s(out, "\n") { ret false; }
i = i + 1;
@@ -513,14 +499,13 @@ fn str_at(self: *Prog, i: usize): ByteView {
ret ByteView.empty();
}
// ---- 序列化 ----
fn align8(n: usize): usize {
ret (n + 7) & (~(7 as usize));
}
// 说明：以下 put_* 直接写入已预留容量的 ByteBuffer 存储（store 已按精确总大小 reserve），
// 跳过 ByteBuffer.append → Vec.append 的校验/拷贝路径。若容量不足会越界，故 store 先校验容量。
// put_* 直接写入已预留容量的 ByteBuffer 存储（store 已按精确总大小 reserve），跳过
// append 的校验/拷贝；容量不足会越界，故 store 先校验容量。
fn put_u8(out: *ByteBuffer, b: u8): bool {
out.storage.data[out.storage.len] = b;
@@ -545,7 +530,7 @@ fn put_u64(out: *ByteBuffer, v: usize): bool {
fn put_zeros(out: *ByteBuffer, n: usize): bool {
if n != 0 {
ignore_ptr(Mem.set((out.storage.data + out.storage.len) as *any, 0, n));
Mem.set((out.storage.data + out.storage.len) as *any, 0, n);
out.storage.len = out.storage.len + n;
}
ret true;
@@ -602,7 +587,7 @@ fn encode(self: *Prog, out: *ByteBuffer): Status {
total = total + 8 + align8(e.storage.len);
fi = fi + 1;
}
match ByteBuffer.reserve(out, total) { .Ok => {}, .Err(error) => {} }
ByteBuffer.reserve(out, total);
if out.storage.cap < total || out.storage.data == null { ret .Err(make(.Io)); }
if !put_view(out, ByteView.from_slice("SPLBIN")) { ret .Err(make(.Io)); }
@@ -702,10 +687,7 @@ fn serialize(self: *Prog, out: *ByteBuffer): Status {
ret encode(self, out);
}
fn ignore_ptr(p: *any) {}
fn ignore_usize(v: usize) {}
// ---- 测试 ----
fn test_dump_basic() {
var pr: Prog = undefined;
@@ -715,7 +697,7 @@ fn test_dump_basic() {
}
defer { drop(&pr); }
ignore_usize(add_instr(&pr, .Halt, .Void, 0));
add_instr(&pr, .Halt, .Void, 0);
var out = ByteBuffer.new();
defer { ByteBuffer.drop(&out); }
@@ -763,8 +745,8 @@ fn test_store_roundtrip() {
}
defer { drop(&pr); }
ignore_usize(add_func(&pr, ByteView.from_slice("main"), 0, 0));
ignore_usize(add_instr(&pr, .Halt, .Void, 0));
add_func(&pr, ByteView.from_slice("main"), 0, 0);
add_instr(&pr, .Halt, .Void, 0);
var path = ByteView.from_slice("build/_mcode_roundtrip.tmp");
match store(&pr, path) {
stage2/parser.spl
+177 -213
View File
@@ -1,7 +1,6 @@
// Expect retcode = 0
// Parser：token 流 -> Ast（ADT 节点）。C 版只作控制流参考，节点分配顺序需与 stage1
// 一致，以保证 dump 的 #ref 可对比。pos 在 token 向量上移动，自动跳过 trivia。
// token 流 -> Ast。节点分配顺序必须与 splc0 一致，否则 dump 的 #ref 无法逐字节对比。
type .{ .Vec } = @import("utils/vec.spl");
type .{ .ByteView } = @import("utils/byte_view.spl");
@@ -41,7 +40,6 @@ fn new(ast: *Ast, toks: Vec, diag: *Diag): Parser {
};
}
// ---- token 访问 ----
fn token_ptr(self: *Parser, index: usize): *Token {
if index >= self.toks.len { ret null; }
@@ -138,7 +136,6 @@ fn at_eof(self: *Parser): bool {
ret false;
}
// ---- 错误 ----
fn span_of(self: *Parser, tok: *Token): Span {
if tok == null { ret span_none(); }
@@ -151,7 +148,7 @@ fn parse_error(self: *Parser, tok: *Token, what: []u8) {
Diag.err(self.diag, span_of(self, tok), .ParseExpected, what);
}
// 转义解码（镜像 stage1 spl_decode_escape）：去掉引号，处理 \n \t \r \0 \\ \' \" \xHH。
// 转义解码：去掉引号，处理 \n \t \r \0 \\ \' \" \xHH。
fn hex_digit(c: u8): u8 {
if c >= '0' && c <= '9' { ret c - '0'; }
if c >= 'a' && c <= 'f' { ret (c - 'a') + 10; }
@@ -172,9 +169,7 @@ fn decode_str(t: ByteView): ByteBuffer {
if e == 'x' && i + 3 < end {
var hi = hex_digit(t.ptr[i + 2]);
var lo = hex_digit(t.ptr[i + 3]);
match ByteBuffer.append_byte(&out, (hi * 16 + lo) as u8) {
.Ok => {}, .Err(error) => {},
}
ByteBuffer.append_byte(&out, (hi * 16 + lo) as u8);
i = i + 4;
} else {
var d: u8 = e;
@@ -182,11 +177,11 @@ fn decode_str(t: ByteView): ByteBuffer {
else if e == 't' { d = '\t'; }
else if e == 'r' { d = '\r'; }
else if e == '0' { d = 0; }
match ByteBuffer.append_byte(&out, d) { .Ok => {}, .Err(error) => {} }
ByteBuffer.append_byte(&out, d);
i = i + 2;
}
} else {
match ByteBuffer.append_byte(&out, c) { .Ok => {}, .Err(error) => {} }
ByteBuffer.append_byte(&out, c);
i = i + 1;
}
}
@@ -203,7 +198,6 @@ fn expect_punct(self: *Parser, punct: Punct, what: []u8): bool {
ret true;
}
// ---- 节点 ----
fn new_node(self: *Parser, body: Body, tok: *Token): usize {
ret Ast.alloc(self.ast, body, span_of(self, tok));
@@ -262,7 +256,6 @@ fn int_token_u64(self: *Parser, tok: *Token, radix: Radix): u64 {
ret v;
}
// ---- 判定（stage1 can_start_*）----
fn can_start_expr(kind: TokenKind): bool {
match kind {
@@ -335,11 +328,10 @@ fn can_start_statement(kind: TokenKind): bool {
ret false;
}
// ---- 模式（M3.2 子集：ident / _ / .variant / tuple / .{ } ）----
fn parse_pattern_aggregate(self: *Parser, start: *Token): usize {
if !expect_punct(self, .LBrace, "'{' after '.'") { ret 0; }
// stage1 先分配 PATTERN_AGGREGATE，再解析字段。
// 先分配 PATTERN_AGGREGATE，再解析字段。
var ref = new_node(self, .PatternAggregate(.{ .items = ref_vec() }), start);
var fields = ref_vec();
while !self.failed {
@@ -354,7 +346,7 @@ fn parse_pattern_aggregate(self: *Parser, start: *Token): usize {
if name == null { break; }
match name.kind { .Ident => {}, _ => { break; } }
advance(self);
// stage1 先分配 PATTERN_FIELD，再解析可选子模式。
// 先分配 PATTERN_FIELD，再解析可选子模式。
var fre = new_node(self, .PatternField(.{
.name = name.text,
.pattern = 0,
@@ -449,7 +441,7 @@ fn parse_pattern_atom(self: *Parser): usize {
if nx == null { ret 0; }
match nx.kind { .Ident => {}, _ => { ret 0; } }
advance(self);
// stage1 先分配 PATTERN_DOT，再解析子模式。
// 先分配 PATTERN_DOT，再解析子模式。
var ref = new_node(self, .PatternDot(.{
.name = nx.text,
.sub_pattern = 0,
@@ -472,7 +464,7 @@ fn parse_pattern_atom(self: *Parser): usize {
},
.LParen => {
advance(self);
// stage1 先分配 PATTERN_TUPLE，再解析内部模式。
// 先分配 PATTERN_TUPLE，再解析内部模式。
var ref = new_node(self, .PatternTuple(.{ .items = ref_vec() }), t);
if at_punct(self, .RParen) {
advance(self);
@@ -562,7 +554,6 @@ fn parse_pattern(self: *Parser): usize {
ret new_node(self, .PatternList(.{ .items = atoms }), peek(self));
}
// ---- 声明 ----
fn parse_tag_list(self: *Parser, out: *Vec, is_external: bool, allow_at: bool, bang_only: bool) {
while !self.failed {
@@ -593,7 +584,7 @@ fn parse_tag_list(self: *Parser, out: *Vec, is_external: bool, allow_at: bool, b
if t == null { ret; }
match t.kind { .Ident => {}, _ => { parse_error(self, t, "expected tag name"); ret; } }
advance(self);
// stage1 先分配 tag 节点，再解析参数。
// 先分配 tag 节点，再解析参数。
var body: Body = .TagItem(.{
.is_at = is_at,
.is_external = ext_here,
@@ -724,20 +715,16 @@ fn token_starts_type(t: *Token): bool {
match t.kind {
.Ident => { ret true; },
.Keyword(k) => {
if @enum2int(k) == @enum2int(Keyword.Type) { ret true; }
if @enum2int(k) == @enum2int(Keyword.Bool) { ret true; }
if @enum2int(k) == @enum2int(Keyword.Any) { ret true; }
if @enum2int(k) == @enum2int(Keyword.Fn) { ret true; }
if @enum2int(k) == @enum2int(Keyword.Struct) { ret true; }
if @enum2int(k) == @enum2int(Keyword.Union) { ret true; }
if @enum2int(k) == @enum2int(Keyword.Enum) { ret true; }
if @enum2int(k) == @enum2int(Keyword.Shape) { ret true; }
match k {
.Type, .Bool, .Any, .Fn, .Struct, .Union, .Enum, .Shape => { ret true; },
_ => {},
}
},
.Punct(p) => {
if @enum2int(p) == @enum2int(Punct.Mul) { ret true; }
if @enum2int(p) == @enum2int(Punct.LBracket) { ret true; }
if @enum2int(p) == @enum2int(Punct.At) { ret true; }
if @enum2int(p) == @enum2int(Punct.Sharp) { ret true; }
match p {
.Mul, .LBracket, .At, .Sharp => { ret true; },
_ => {},
}
},
_ => {},
}
@@ -795,7 +782,7 @@ fn parse_type_decl(self: *Parser, tags: Vec): usize {
var pattern = parse_pattern(self);
if pattern == 0 { ret 0; }
if !expect_punct(self, .Assign, "'=' in type declaration") { ret 0; }
// stage1 先分配 TYPE_DECL 再解析 type_expr（影响 #ref 顺序）。
// 先分配 TYPE_DECL 再解析 type_expr（影响 #ref 顺序）。
var ref = new_node(self, .TypeDecl(.{
.attr_list = tags,
.pattern = pattern,
@@ -913,32 +900,33 @@ fn parse_container_declaration(self: *Parser): usize {
match t.kind {
.Eof => { ret 0; },
.Keyword(k) => {
if @enum2int(k) == @enum2int(Keyword.Fn) { ret parse_fn_decl(self, tags, false); }
if @enum2int(k) == @enum2int(Keyword.Type) { ret parse_type_decl(self, tags); }
if @enum2int(k) == @enum2int(Keyword.Var) {
ret parse_var_const_decl(self, tags, false);
}
if @enum2int(k) == @enum2int(Keyword.Const) {
ret parse_var_const_decl(self, tags, true);
}
if @enum2int(k) == @enum2int(Keyword.Comptime) {
// `comptime fn ...` -> 标记为编译期函数；否则 `comptime { }` 声明。
var nxt = peek_next(self);
if nxt != null && kind_is_keyword(nxt.kind, .Fn) {
advance(self);
ret parse_fn_decl(self, tags, true);
}
ret parse_comptime_decl(self);
match k {
.Fn => { ret parse_fn_decl(self, tags, false); },
.Type => { ret parse_type_decl(self, tags); },
.Var => { ret parse_var_const_decl(self, tags, false); },
.Const => { ret parse_var_const_decl(self, tags, true); },
.Comptime => {
var nxt = peek_next(self);
if nxt != null && kind_is_keyword(nxt.kind, .Fn) {
advance(self);
ret parse_fn_decl(self, tags, true);
}
ret parse_comptime_decl(self);
},
_ => {},
}
},
.Ident => { ret parse_member_decl(self, tags); },
.Punct(p) => {
if @enum2int(p) == @enum2int(Punct.LBrace) {
var block = parse_block(self);
ret new_node(self, .TopLevelBlock(.{
.tag_list = tags,
.block = block,
}), t);
match p {
.LBrace => {
var block = parse_block(self);
ret new_node(self, .TopLevelBlock(.{
.tag_list = tags,
.block = block,
}), t);
},
_ => {},
}
},
_ => {},
@@ -948,7 +936,6 @@ fn parse_container_declaration(self: *Parser): usize {
ret 0;
}
// ---- 类型 ----
fn parse_type_comptime_call(self: *Parser): usize {
var start = peek(self);
@@ -977,7 +964,7 @@ fn parse_type_base(self: *Parser): usize {
if kind_is_keyword(bt.kind, .Fn) {
advance(self);
if !expect_punct(self, .LParen, "'(' in function type") { ret 0; }
// stage1 先分配 TYPE_FN，再解析参数与返回类型。
// 先分配 TYPE_FN，再解析参数与返回类型。
var ref = new_node(self, .TypeFn(.{
.is_comptime = false,
.params = ref_vec(),
@@ -1011,10 +998,13 @@ fn parse_type_base(self: *Parser): usize {
match bt.kind {
.Keyword(k) => {
var kind_name: []u8 = "";
if @enum2int(k) == @enum2int(Keyword.Struct) { kind_name = "struct"; }
else if @enum2int(k) == @enum2int(Keyword.Union) { kind_name = "union"; }
else if @enum2int(k) == @enum2int(Keyword.Enum) { kind_name = "enum"; }
else if @enum2int(k) == @enum2int(Keyword.Shape) { kind_name = "shape"; }
match k {
.Struct => { kind_name = "struct"; },
.Union => { kind_name = "union"; },
.Enum => { kind_name = "enum"; },
.Shape => { kind_name = "shape"; },
_ => {},
}
if kind_name.len != 0 {
advance(self);
if !expect_punct(self, .LBrace, "'{' in aggregate type") { ret 0; }
@@ -1088,20 +1078,21 @@ fn parse_type_base(self: *Parser): usize {
}), bt);
},
.Keyword(k) => {
// stage1 is_builtin_type_kw：bool / any 作为类型路径；stage3 增加 `type`。
if @enum2int(k) == @enum2int(Keyword.Bool) ||
@enum2int(k) == @enum2int(Keyword.Any) ||
@enum2int(k) == @enum2int(Keyword.Type) {
advance(self);
ret new_node(self, .TypePath(.{
.name = bt.text,
.generic_args = ref_vec(),
}), bt);
match k {
.Bool, .Any, .Type => {
advance(self);
ret new_node(self, .TypePath(.{
.name = bt.text,
.generic_args = ref_vec(),
}), bt);
},
_ => {},
}
},
.Punct(p) => {
if @enum2int(p) == @enum2int(Punct.At) || @enum2int(p) == @enum2int(Punct.Sharp) {
ret parse_type_comptime_call(self);
match p {
.At, .Sharp => { ret parse_type_comptime_call(self); },
_ => {},
}
},
_ => {},
@@ -1116,7 +1107,7 @@ fn parse_type_expr(self: *Parser): usize {
if kind_is_punct(t.kind, .Mul) {
advance(self);
// stage1 先分配 POINTER，再解析 pointee。
// 先分配 POINTER，再解析 pointee。
var ref = new_node(self, .TypePointer(.{ .pointee = 0 }), t);
var pointee = parse_type_expr(self);
var pn = Ast.node(self.ast, ref);
@@ -1200,7 +1191,6 @@ fn parse_type_expr(self: *Parser): usize {
ret base;
}
// ---- 表达式 ----
type BinInfo = struct { op: Punct, prec: i32, right: bool }
type BinResult = enum { No, Yes: BinInfo }
@@ -1367,7 +1357,7 @@ fn parse_postfix(self: *Parser): usize {
if kind_is_punct(t.kind, .LParen) {
advance(self);
// stage1 先分配 CALL，再解析实参（影响 #ref 顺序）。
// 先分配 CALL，再解析实参（影响 #ref 顺序）。
var ref = new_node(self, .ExprCall(.{ .callee = expr, .args = ref_vec() }), t);
var args = parse_expr_list(self);
var cn = Ast.node(self.ast, ref);
@@ -1480,47 +1470,31 @@ fn parse_primary(self: *Parser): usize {
ret new_node(self, .ExprStringLit(.{ .data = Ast.push_string(self.ast, decode_str(t.text)) }), t);
},
.Keyword(k) => {
if @enum2int(k) == @enum2int(Keyword.True) {
advance(self);
ret new_node(self, .ExprBoolLit(.{ .value = true }), t);
}
if @enum2int(k) == @enum2int(Keyword.False) {
advance(self);
ret new_node(self, .ExprBoolLit(.{ .value = false }), t);
}
if @enum2int(k) == @enum2int(Keyword.Null) {
advance(self);
ret new_node(self, .ExprNullLit, t);
}
if @enum2int(k) == @enum2int(Keyword.Undefined) {
advance(self);
ret new_node(self, .ExprUndefinedLit, t);
}
if @enum2int(k) == @enum2int(Keyword.If) { ret parse_if_expr(self); }
if @enum2int(k) == @enum2int(Keyword.While) { ret parse_while_expr(self); }
if @enum2int(k) == @enum2int(Keyword.Loop) { ret parse_loop_expr(self); }
if @enum2int(k) == @enum2int(Keyword.For) { ret parse_for_expr(self); }
if @enum2int(k) == @enum2int(Keyword.Match) { ret parse_match_expr(self); }
// `try <expr>`：错误上抛前缀。
if @enum2int(k) == @enum2int(Keyword.Try) {
advance(self);
var tv = parse_expr(self);
ret new_node(self, .ExprTry(.{ .value = tv }), t);
}
// `comptime <expr>`：编译期表达式（可调用普通函数、返回类型等）。
if @enum2int(k) == @enum2int(Keyword.Comptime) {
advance(self);
var cbody = parse_expr(self);
ret new_node(self, .ExprComptime(.{ .body = cbody }), t);
}
// 类型即表达式：仅在 comptime 上下文内允许 `struct { ... }` 等聚合类型。
if self.comptime_depth > 0 {
if @enum2int(k) == @enum2int(Keyword.Struct) ||
@enum2int(k) == @enum2int(Keyword.Union) ||
@enum2int(k) == @enum2int(Keyword.Enum) ||
@enum2int(k) == @enum2int(Keyword.Shape) {
ret parse_type_base(self);
}
match k {
.True => { advance(self); ret new_node(self, .ExprBoolLit(.{ .value = true }), t); },
.False => { advance(self); ret new_node(self, .ExprBoolLit(.{ .value = false }), t); },
.Null => { advance(self); ret new_node(self, .ExprNullLit, t); },
.Undefined => { advance(self); ret new_node(self, .ExprUndefinedLit, t); },
.If => { ret parse_if_expr(self); },
.While => { ret parse_while_expr(self); },
.Loop => { ret parse_loop_expr(self); },
.For => { ret parse_for_expr(self); },
.Match => { ret parse_match_expr(self); },
.Try => {
advance(self);
var tv = parse_expr(self);
ret new_node(self, .ExprTry(.{ .value = tv }), t);
},
.Comptime => {
advance(self);
var cbody = parse_expr(self);
ret new_node(self, .ExprComptime(.{ .body = cbody }), t);
},
.Struct, .Union, .Enum, .Shape => {
// 类型即表达式仅限 comptime 上下文。
if self.comptime_depth > 0 { ret parse_type_base(self); }
},
_ => {},
}
parse_error(self, t, "unrecognized expression");
ret 0;
@@ -1528,7 +1502,7 @@ fn parse_primary(self: *Parser): usize {
.Ident => {
advance(self);
if at_punct(self, .LBrace) && self.stop_agg == 0 {
// stage1 先分配 AGGREGATE_LIT，再解析字段。
// 先分配 AGGREGATE_LIT，再解析字段。
var ref = new_node(self, .ExprAggregateLit(.{
.name = t.text,
.fields = ref_vec(),
@@ -1536,10 +1510,7 @@ fn parse_primary(self: *Parser): usize {
var fields = parse_aggregate_fields(self);
var an = Ast.node(self.ast, ref);
match an.body {
.ExprAggregateLit(a) => {
a.fields = fields;
an.body = .ExprAggregateLit(a);
},
.ExprAggregateLit(&a) => { a.fields = fields; },
_ => {},
}
ret ref;
@@ -1547,71 +1518,69 @@ fn parse_primary(self: *Parser): usize {
ret new_node(self, .ExprIdent(.{ .name = t.text }), t);
},
.Punct(p) => {
if @enum2int(p) == @enum2int(Punct.Dot) {
advance(self);
var nx = peek(self);
if nx == null { parse_error(self, t, "unexpected '.'"); ret 0; }
if kind_is_punct(nx.kind, .LBrace) && self.stop_agg == 0 {
var ref = new_node(self, .ExprAggregateLit(.{
.name = ByteView.empty(),
.fields = ref_vec(),
}), t);
var fields = parse_aggregate_fields(self);
var an = Ast.node(self.ast, ref);
match an.body {
.ExprAggregateLit(a) => {
a.fields = fields;
an.body = .ExprAggregateLit(a);
},
_ => {},
match p {
.Dot => {
advance(self);
var nx = peek(self);
if nx == null { parse_error(self, t, "unexpected '.'"); ret 0; }
if kind_is_punct(nx.kind, .LBrace) && self.stop_agg == 0 {
var ref = new_node(self, .ExprAggregateLit(.{
.name = ByteView.empty(),
.fields = ref_vec(),
}), t);
var fields = parse_aggregate_fields(self);
var an = Ast.node(self.ast, ref);
match an.body {
.ExprAggregateLit(&a) => { a.fields = fields; },
_ => {},
}
ret ref;
}
ret ref;
}
if kind_is_punct(nx.kind, .LBracket) {
advance(self);
var elems = parse_expr_list(self);
if !expect_punct(self, .RBracket, "']' in array literal") { ret 0; }
ret new_node(self, .ExprArrayLit(.{
.has_len = false,
.len = 0,
.is_underscore_len = false,
.elem_type = 0,
.elems = elems,
}), t);
}
var is_ident = false;
match nx.kind { .Ident => { is_ident = true; }, _ => {} }
if is_ident { ret parse_variant_construct(self, t); }
parse_error(self, nx, "expected '{', '[' or identifier after '.'");
ret 0;
}
if @enum2int(p) == @enum2int(Punct.LBracket) { ret parse_array_literal(self); }
if @enum2int(p) == @enum2int(Punct.LBrace) { ret parse_block(self); }
if @enum2int(p) == @enum2int(Punct.At) || @enum2int(p) == @enum2int(Punct.Sharp) {
ret parse_comptime_call(self);
}
if @enum2int(p) == @enum2int(Punct.LParen) {
advance(self);
var elems = ref_vec();
if at_punct(self, .RParen) {
advance(self);
ret new_node(self, .ExprTuple(.{ .items = elems }), t);
}
var first = parse_expr(self);
if at_punct(self, .Comma) {
match Vec.push(&elems, &first as *u8) { .Ok => {}, .Err(e) => { ret 0; } }
while at_punct(self, .Comma) {
if kind_is_punct(nx.kind, .LBracket) {
advance(self);
if at_punct(self, .RParen) { break; }
var nx = parse_expr(self);
match Vec.push(&elems, &nx as *u8) { .Ok => {}, .Err(e) => { ret 0; } }
var elems = parse_expr_list(self);
if !expect_punct(self, .RBracket, "']' in array literal") { ret 0; }
ret new_node(self, .ExprArrayLit(.{
.has_len = false,
.len = 0,
.is_underscore_len = false,
.elem_type = 0,
.elems = elems,
}), t);
}
expect_punct(self, .RParen, "')' in tuple literal");
ret new_node(self, .ExprTuple(.{ .items = elems }), t);
}
expect_punct(self, .RParen, "')' in paren expression");
Vec.drop(&elems);
ret first;
var is_ident = false;
match nx.kind { .Ident => { is_ident = true; }, _ => {} }
if is_ident { ret parse_variant_construct(self, t); }
parse_error(self, nx, "expected '{', '[' or identifier after '.'");
ret 0;
},
.LBracket => { ret parse_array_literal(self); },
.LBrace => { ret parse_block(self); },
.At, .Sharp => { ret parse_comptime_call(self); },
.LParen => {
advance(self);
var elems = ref_vec();
if at_punct(self, .RParen) {
advance(self);
ret new_node(self, .ExprTuple(.{ .items = elems }), t);
}
var first = parse_expr(self);
if at_punct(self, .Comma) {
Vec.push(&elems, &first as *u8);
while at_punct(self, .Comma) {
advance(self);
if at_punct(self, .RParen) { break; }
var nx = parse_expr(self);
Vec.push(&elems, &nx as *u8);
}
expect_punct(self, .RParen, "')' in tuple literal");
ret new_node(self, .ExprTuple(.{ .items = elems }), t);
}
expect_punct(self, .RParen, "')' in paren expression");
Vec.drop(&elems);
ret first;
},
_ => {},
}
},
_ => {},
@@ -1761,7 +1730,6 @@ fn parse_expr_list(self: *Parser): Vec {
ret vec;
}
// ---- if / while / loop / for / match ----
fn parse_if_expr(self: *Parser): usize {
var kw = peek(self);
@@ -1928,7 +1896,7 @@ fn parse_match_expr(self: *Parser): usize {
if at_punct(self, .Comma) { advance(self); }
}
if !expect_punct(self, .RBrace, "'}' in match") { ret 0; }
// stage1 先分配 MATCH_EXPR，再逐个分配 MATCH_ARM。
// 先分配 MATCH_EXPR，再逐个分配 MATCH_ARM。
var ref = new_node(self, .ExprMatch(.{
.matched_expr = matched,
.arms = ref_vec(),
@@ -1957,7 +1925,6 @@ fn parse_match_expr(self: *Parser): usize {
ret ref;
}
// ---- 语句 ----
fn parse_ret_stmt(self: *Parser): usize {
var kw = peek(self);
@@ -2054,27 +2021,26 @@ fn parse_statement(self: *Parser): usize {
match t.kind {
.Keyword(k) => {
if @enum2int(k) == @enum2int(Keyword.Ret) { ret parse_ret_stmt(self); }
if @enum2int(k) == @enum2int(Keyword.Break) { ret parse_break_stmt(self); }
if @enum2int(k) == @enum2int(Keyword.Continue) { ret parse_continue_stmt(self); }
if @enum2int(k) == @enum2int(Keyword.Defer) { ret parse_defer_stmt(self); }
if @enum2int(k) == @enum2int(Keyword.Errdefer) { ret parse_errdefer_stmt(self); }
if @enum2int(k) == @enum2int(Keyword.Comptime) { ret parse_comptime_stmt(self); }
if @enum2int(k) == @enum2int(Keyword.Var) ||
@enum2int(k) == @enum2int(Keyword.Const) ||
@enum2int(k) == @enum2int(Keyword.Type) {
var tags = ref_vec();
parse_tag_list(self, &tags, false, false, false);
var decl: usize = 0;
if @enum2int(k) == @enum2int(Keyword.Var) {
decl = parse_var_const_decl(self, tags, false);
} else if @enum2int(k) == @enum2int(Keyword.Const) {
decl = parse_var_const_decl(self, tags, true);
} else {
decl = parse_type_decl(self, tags);
}
if decl == 0 { ret 0; }
ret new_node(self, .StatementDecl(.{ .decl = decl }), t);
match k {
.Ret => { ret parse_ret_stmt(self); },
.Break => { ret parse_break_stmt(self); },
.Continue => { ret parse_continue_stmt(self); },
.Defer => { ret parse_defer_stmt(self); },
.Errdefer => { ret parse_errdefer_stmt(self); },
.Comptime => { ret parse_comptime_stmt(self); },
.Var, .Const, .Type => {
var tags = ref_vec();
parse_tag_list(self, &tags, false, false, false);
var decl: usize = 0;
match k {
.Var => { decl = parse_var_const_decl(self, tags, false); },
.Const => { decl = parse_var_const_decl(self, tags, true); },
_ => { decl = parse_type_decl(self, tags); },
}
if decl == 0 { ret 0; }
ret new_node(self, .StatementDecl(.{ .decl = decl }), t);
},
_ => {},
}
},
_ => {},
@@ -2179,7 +2145,7 @@ fn block_push_stmt(self: *Parser, ref: usize, stmt: usize) {
var n = Ast.node(self.ast, ref);
match n.body {
.ExprBlock(b) => {
match Vec.push(&b.stmts, &stmt as *u8) { .Ok => {}, .Err(e) => {} }
Vec.push(&b.stmts, &stmt as *u8);
n.body = .ExprBlock(b);
},
_ => {},
@@ -2200,7 +2166,6 @@ fn block_set_tail(self: *Parser, ref: usize, expr: usize) {
}
}
// ---- 入口 ----
fn skip_to_sync(self: *Parser) {
while !self.failed {
@@ -2215,7 +2180,7 @@ fn skip_to_sync(self: *Parser) {
}
}
// 解析整个文件；Root/ContainerMembers 最后分配（与 stage1 一致）。
// 解析整个文件；Root/ContainerMembers 最后分配（#ref 顺序须与 splc0 一致）。
fn parse(self: *Parser) {
var external_tags = ref_vec();
var declarations = ref_vec();
@@ -2258,7 +2223,6 @@ fn parse(self: *Parser) {
self.ast.root = root;
}
// ---- 测试 ----
fn lex_tokens(src: []u8): Vec {
var out = Vec.blank(@sizeof(Token), @alignof(Token));
@@ -2322,7 +2286,7 @@ fn expect_text(buf: *ByteBuffer, expected: []u8) {
}
}
// 与 stage1 `splc0 --dump ast` 输出逐字节一致（含 #ref 与 [line:col]）。
// 与 splc0 --dump ast 逐字节一致（含 #ref 与 [line:col]）。
fn test_parse_decls() {
var src: []u8 = "type Point = struct { x: i32, y: i32 };\nfn f(a: i32): i32;\n";
var toks = lex_tokens(src);
@@ -2354,7 +2318,7 @@ fn test_parse_decls() {
"AST:\n`-root #13\n `-container_members #12\n |-type_decl #2 [1:1]\n | |-pattern_ident #1 [1:6]\n | `-type_aggregate #3 [1:14]\n | |-member_decl #5 [1:23]\n | | |-type_path #4 [1:26]\n | `-member_decl #7 [1:31]\n | |-type_path #6 [1:34]\n `-fn_decl #11 [2:1]\n `-param_decl #9 [2:6]\n `-type_path #8 [2:9]\n |-type_path #10 [2:15]\n");
}
// 表达式/语句/块：与 001_main.spl 的 stage1 dump 逐字节一致。
// 表达式/语句/块：与 splc0 dump 逐字节一致。
fn test_parse_main() {
var src: []u8 = "// Expect retcode = 0\n\nfn main(): i32 {\n ret 0;\n}\n";
var toks = lex_tokens(src);
@@ -2386,7 +2350,7 @@ fn test_parse_main() {
"AST:\n`-root #7\n `-container_members #6\n `-fn_decl #5 [3:1]\n |-type_path #1 [3:12]\n `-block #2 [3:16]\n `-statement_ret #4 [4:5]\n `-int_lit #3 [4:9]\n");
}
// 任意宽度整数：2^64 也能正确解析（stage1 u64 之外）；含分隔符与多进制。
// 任意宽度整数：2^64 也能正确解析；含分隔符与多进制。
fn check_int(src: []u8, expected: []u8) {
var toks = lex_tokens(src);
defer { Vec.drop(&toks); }
stage2/scope.spl
+2 -5
View File
@@ -1,9 +1,7 @@
// Expect retcode = 0
// 作用域树（移植自 stage1/spl_scope.c）。每个作用域是一张名字 -> Symbol 表，
// 节点用 parent 指向父作用域；查找从 current_scope 沿父链上溯（支持遮蔽）。
// 名字是 ByteView（借用源/AST）；Map 复制键值字节，但 ByteView 指向的字节由
// 调用方保证存活。node 字段是 def.spl 的 DefId。
// 作用域树：名字 -> Symbol，节点经 parent 上溯查找（支持遮蔽）。名字借用源字节，
// 存活由调用方保证；node 为 def.spl 的 DefId。
type .{ .Error } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
@@ -134,7 +132,6 @@ fn find(self: *Scope, name: ByteView, out: *Symbol): bool {
ret false;
}
// ---- 测试 ----
fn sym(name: []u8, kind: SymbolKind, node: usize): Symbol {
ret Symbol {
stage2/sema.spl
+111 -144
View File
@@ -1,11 +1,7 @@
// Expect retcode = 0
// 语义分析（移植自 stage1/spl_sema.c）。持有语言类型表 / 作用域树 / 属性表 /
// comptime 接口；AST 与诊断是借用。阶段：collect_names -> collect_type_unpacks
// -> 模块根聚合 -> collect_types -> collect_signatures -> infer。
//
// 与 stage1 的差异：诊断消息从简（不逐字复刻）；类型系统/def/scope/attr/intrin
// 全部走 stage2 模块；comptime 只走 eval seam（本轮不求值，返回 NotConst）。
// 语义分析：名字/类型/def 解析与推断。持有类型表、作用域树、属性表；AST 与诊断
// 为借用。comptime 求值经 eval seam 注入。
type .{ .Error, .Status } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
@@ -34,7 +30,7 @@ type .{ .Lexer } = @import("./lexer.spl");
type .{ .Parser } = @import("./parser.spl");
type .{ .set_new, .set_add, .set_drop } = @import("utils/source.spl");
// 模块加载接口（seam）：驱动提供；本轮可为 null。
// 模块加载接口（seam）：由驱动提供；可为 null。
type LoadResult = enum {
Ok: *Ast,
Missing,
@@ -66,7 +62,6 @@ type SemaResult = enum {
Err: Error,
}
// ---- 小工具 ----
fn list_at(v: Vec, i: usize): usize {
if i >= v.len { ret 0; }
@@ -74,17 +69,11 @@ fn list_at(v: Vec, i: usize): usize {
}
fn push_u(v: *Vec, x: usize) {
match Vec.push(v, &x as *u8) {
.Ok => {},
.Err(error) => {},
}
Vec.push(v, &x as *u8);
}
fn push_view(v: *Vec, x: ByteView) {
match Vec.push(v, &x as *u8) {
.Ok => {},
.Err(error) => {},
}
Vec.push(v, &x as *u8);
}
fn ref_vec(): Vec {
@@ -138,7 +127,7 @@ fn lang_from_ir(self: *Sema, ir: usize): usize {
while i < self.types.lang_table.len {
var e = LangType.lang_node(&self.types, i);
if e != null && e.ir_type_id == ir {
match Map.put(&self.ir_to_lang, &ir as *u8, &i as *u8) { .Ok => {}, .Err(error) => {} }
Map.put(&self.ir_to_lang, &ir as *u8, &i as *u8);
ret i;
}
i = i + 1;
@@ -163,7 +152,6 @@ fn def_state_is(d: *DefNode, want: DeclState): bool {
ret @enum2int(d.state) == @enum2int(want);
}
// ---- 诊断（消息从简；类型名走 dump 到缓冲）----
fn diag(self: *Sema, span: Span, code: Code, msg: []u8) {
Diag.err(self.diag, span, code, msg);
@@ -172,15 +160,15 @@ fn diag(self: *Sema, span: Span, code: Code, msg: []u8) {
fn diag_name(self: *Sema, span: Span, code: Code, prefix: []u8, name: ByteView) {
var b = ByteBuffer.new();
defer { ByteBuffer.drop(&b); }
match ByteBuffer.append(&b, prefix) { .Ok => {}, .Err(e) => {} }
match ByteBuffer.append(&b, ByteView.as_slice(name)) { .Ok => {}, .Err(e) => {} }
ByteBuffer.append(&b, prefix);
ByteBuffer.append(&b, ByteView.as_slice(name));
Diag.err(self.diag, span, code, ByteBuffer.as_slice(b));
}
fn diag_ty(self: *Sema, span: Span, code: Code, prefix: []u8, tid: usize) {
var b = ByteBuffer.new();
defer { ByteBuffer.drop(&b); }
match ByteBuffer.append(&b, prefix) { .Ok => {}, .Err(e) => {} }
ByteBuffer.append(&b, prefix);
LangType.dump(&self.types, tid, &b);
Diag.err(self.diag, span, code, ByteBuffer.as_slice(b));
}
@@ -188,14 +176,13 @@ fn diag_ty(self: *Sema, span: Span, code: Code, prefix: []u8, tid: usize) {
fn diag_ty2(self: *Sema, span: Span, code: Code, prefix: []u8, a: usize, b: usize) {
var buf = ByteBuffer.new();
defer { ByteBuffer.drop(&buf); }
match ByteBuffer.append(&buf, prefix) { .Ok => {}, .Err(e) => {} }
ByteBuffer.append(&buf, prefix);
LangType.dump(&self.types, a, &buf);
match ByteBuffer.append(&buf, " vs ") { .Ok => {}, .Err(e) => {} }
ByteBuffer.append(&buf, " vs ");
LangType.dump(&self.types, b, &buf);
Diag.err(self.diag, span, code, ByteBuffer.as_slice(buf));
}
// ---- 生命周期 ----
fn new(ast: *Ast, diag: *Diag): SemaResult {
var types: LangType = undefined;
@@ -244,7 +231,6 @@ fn drop(self: *Sema) {
LangType.drop(&self.types);
}
// ---- 作用域 ----
fn push_scope(self: *Sema) {
var id = Scope.alloc(&self.scope);
@@ -258,7 +244,6 @@ fn pop_scope(self: *Sema) {
}
}
// ---- 属性 ----
fn node_attr_raw(self: *Sema, n: *Node, raw: Vec) {
var i: usize = 0;
@@ -312,17 +297,17 @@ fn resolve_attr_item(self: *Sema, a: *Node): usize {
match arg.body {
.ExprIdent(e) => {
var av: AttrArg = .Str(e.name);
match Vec.push(&args, &av as *u8) { .Ok => {}, .Err(er) => {} }
Vec.push(&args, &av as *u8);
},
.ExprStringLit(sl) => {
var av: AttrArg = .Str(sl.data);
match Vec.push(&args, &av as *u8) { .Ok => {}, .Err(er) => {} }
Vec.push(&args, &av as *u8);
},
.ExprIntLit(iv) => {
var num: i64 = 0;
match BigInt.to_i64(&num, iv.value) { .Ok => {}, .Err(er) => {} }
BigInt.to_i64(&num, iv.value);
var av: AttrArg = .Int(num);
match Vec.push(&args, &av as *u8) { .Ok => {}, .Err(er) => {} }
Vec.push(&args, &av as *u8);
},
_ => {
diag(self, arg.span, .UnknownAttr, "unsupported attribute arg");
@@ -348,7 +333,6 @@ fn resolve_attrs(self: *Sema, n: *Node) {
}
}
// ---- 聚合构建 ----
fn build_aggregate(self: *Sema, te: *Node, owner_def_id: usize): usize {
var kind_name = ByteView.empty();
@@ -403,7 +387,7 @@ fn build_aggregate(self: *Sema, te: *Node, owner_def_id: usize): usize {
if md.type_expr != 0 { mtid = infer(self, md.type_expr); }
var mm = Member { .name = md.name, .type_id = ir_of(self, mtid),
.ast_node_ref = mref };
match Vec.push(&members, &mm as *u8) { .Ok => {}, .Err(er) => {} }
Vec.push(&members, &mm as *u8);
},
.FnDecl(fd) => {
var fn_def = mn.resolved_def_id;
@@ -415,7 +399,7 @@ fn build_aggregate(self: *Sema, te: *Node, owner_def_id: usize): usize {
var fn_d = def_node(self, fn_def);
if fn_d != null { fn_d.owner_def = owner_def_id; }
var meth = LangMethod { .name = fd.name, .def_id = fn_def };
match Vec.push(&methods, &meth as *u8) { .Ok => {}, .Err(er) => {} }
Vec.push(&methods, &meth as *u8);
},
.TypeDecl(td) => {
var tpat = node(self, td.pattern);
@@ -431,7 +415,7 @@ fn build_aggregate(self: *Sema, te: *Node, owner_def_id: usize): usize {
mn.resolved_def_id = tdef;
}
var meth = LangMethod { .name = tname, .def_id = tdef };
match Vec.push(&methods, &meth as *u8) { .Ok => {}, .Err(er) => {} }
Vec.push(&methods, &meth as *u8);
}
},
_ => {},
@@ -443,16 +427,21 @@ fn build_aggregate(self: *Sema, te: *Node, owner_def_id: usize): usize {
self.current_aggregate_lang = saved;
// IR 节点
if @enum2int(lk) == @enum2int(LangKind.Enum) {
var tag_ir = TypeTable.make_int(&self.types.ir, 32, true);
tk = .Enum(.{ .mode = .Auto, .fixed_align_bits = 0, .tag_type = tag_ir,
.variants = members });
} else if @enum2int(lk) == @enum2int(LangKind.Union) {
tk = .Union(.{ .mode = .Auto, .fixed_align_bits = 0, .tag_type = 0, .variants = members });
} else if @enum2int(lk) == @enum2int(LangKind.Shape) {
tk = .Shape(.{ .mode = .Auto, .fixed_align_bits = 0, .tag_type = 0, .variants = members });
} else {
tk = .Struct(.{ .mode = .Auto, .fixed_align_bits = 0, .tag_type = 0, .variants = members });
match lk {
.Enum => {
var tag_ir = TypeTable.make_int(&self.types.ir, 32, true);
tk = .Enum(.{ .mode = .Auto, .fixed_align_bits = 0, .tag_type = tag_ir,
.variants = members });
},
.Union => {
tk = .Union(.{ .mode = .Auto, .fixed_align_bits = 0, .tag_type = 0, .variants = members });
},
.Shape => {
tk = .Shape(.{ .mode = .Auto, .fixed_align_bits = 0, .tag_type = 0, .variants = members });
},
_ => {
tk = .Struct(.{ .mode = .Auto, .fixed_align_bits = 0, .tag_type = 0, .variants = members });
},
}
TypeTable.define(&self.types.ir, agg_ir, &tk);
@@ -501,7 +490,7 @@ fn build_container_aggregate(self: *Sema, n: *Node, owner_def_id: usize): usize
if md.type_expr != 0 { mtid = infer(self, md.type_expr); }
var mm = Member { .name = md.name, .type_id = ir_of(self, mtid),
.ast_node_ref = dref };
match Vec.push(&members, &mm as *u8) { .Ok => {}, .Err(er) => {} }
Vec.push(&members, &mm as *u8);
},
.FnDecl(fd) => {
var fn_def = d.resolved_def_id;
@@ -509,7 +498,7 @@ fn build_container_aggregate(self: *Sema, n: *Node, owner_def_id: usize): usize
var fn_d = def_node(self, fn_def);
if fn_d != null { fn_d.owner_def = owner_def_id; }
var meth = LangMethod { .name = fd.name, .def_id = fn_def };
match Vec.push(&methods, &meth as *u8) { .Ok => {}, .Err(er) => {} }
Vec.push(&methods, &meth as *u8);
}
},
.TypeDecl(td) => {
@@ -518,7 +507,7 @@ fn build_container_aggregate(self: *Sema, n: *Node, owner_def_id: usize): usize
var tpat = node(self, td.pattern);
if tpat != null && is_pattern_ident(tpat) {
var meth = LangMethod { .name = pattern_name(tpat), .def_id = tdef };
match Vec.push(&methods, &meth as *u8) { .Ok => {}, .Err(er) => {} }
Vec.push(&methods, &meth as *u8);
}
}
},
@@ -550,7 +539,7 @@ fn container_var_method(self: *Sema, pat_ref: usize, methods: *Vec) {
var vdef = pat.resolved_def_id;
if vdef == 0 { ret; }
var meth = LangMethod { .name = pattern_name(pat), .def_id = vdef };
match Vec.push(methods, &meth as *u8) { .Ok => {}, .Err(er) => {} }
Vec.push(methods, &meth as *u8);
}
fn is_pattern_ident(n: *Node): bool {
@@ -593,7 +582,6 @@ fn pattern_name(pat: *Node): ByteView {
}
}
// ---- @import ----
fn sema_import(self: *Sema, n: *Node, args: Vec): usize {
if self.loader == null {
@@ -666,7 +654,6 @@ fn sema_import(self: *Sema, n: *Node, args: Vec): usize {
ret t;
}
// ---- 声明求值 ----
fn eval_decl(self: *Sema, def_id: usize): usize {
var d = def_node(self, def_id);
@@ -809,7 +796,7 @@ fn collect_names(self: *Sema, ref: usize) {
n.resolved_def_id = file_def;
var file_sym = Symbol { .name = ByteView.from_slice("$file"), .kind = .Type,
.node = file_def };
ignore_bool(Scope.insert(&self.scope, mod_scope, file_sym));
Scope.insert(&self.scope, mod_scope, file_sym);
var i: usize = 0;
while i < cm.declarations.len {
@@ -887,7 +874,7 @@ fn collect_types(self: *Sema, ref: usize) {
var pat = node(self, td.pattern);
if pat != null && is_pattern_ident(pat) &&
d.resolved_def_id != 0 {
ignore_usize(eval_decl(self, d.resolved_def_id));
eval_decl(self, d.resolved_def_id);
}
},
_ => {},
@@ -910,7 +897,7 @@ fn collect_signatures(self: *Sema) {
if d != null && d.owner == (self.ast as *any) &&
@enum2int(d.kind) == @enum2int(DefKind.Fn) &&
def_state_is(d, .Unresolved) {
ignore_usize(eval_decl(self, i));
eval_decl(self, i);
}
i = i + 1;
}
@@ -945,7 +932,6 @@ fn collect_type_unpacks(self: *Sema, ref: usize) {
}
}
// ---- 类型上下文（intrinsic 参数）----
fn infer_type_context(self: *Sema, ref: usize): usize {
var n = node(self, ref);
@@ -1024,7 +1010,6 @@ fn infer_type_context(self: *Sema, ref: usize): usize {
ret 0;
}
// ---- intrinsic 调用 ----
fn punct_is(op: Punct, want: Punct): bool {
ret @enum2int(op) == @enum2int(want);
@@ -1091,8 +1076,8 @@ fn intrin_call(self: *Sema, n: *Node, in: Intrin, args: Vec): usize {
}
if intrin_is(in, .Assert) {
var bt = make_bool(self);
ignore_usize(coerce(self, list_at(args, 0), bt));
if nargs == 2 { ignore_usize(infer(self, list_at(args, 1))); }
coerce(self, list_at(args, 0), bt);
if nargs == 2 { infer(self, list_at(args, 1)); }
ret make_unit(self);
}
if intrin_is(in, .IntCast) || intrin_is(in, .Truncate) || intrin_is(in, .BitCast) ||
@@ -1113,7 +1098,7 @@ fn intrin_call(self: *Sema, n: *Node, in: Intrin, args: Vec): usize {
ret dst;
}
if intrin_is(in, .Bool2Int) || intrin_is(in, .Ptr2Int) {
ignore_usize(infer(self, list_at(args, 0)));
infer(self, list_at(args, 0));
if nargs >= 2 {
var dst = infer(self, list_at(args, 1));
if dst == 0 { ret 0; }
@@ -1185,7 +1170,6 @@ fn intrin_field(self: *Sema, n: *Node, in: Intrin): usize {
ret 0;
}
// ---- 块 / 模式 / 解包 ----
fn block_body(self: *Sema, n: *Node, expected: usize): usize {
var stmts = ref_vec();
@@ -1200,7 +1184,7 @@ fn block_body(self: *Sema, n: *Node, expected: usize): usize {
push_scope(self);
var i: usize = 0;
while i < stmts.len {
ignore_usize(infer(self, list_at(stmts, i)));
infer(self, list_at(stmts, i));
i = i + 1;
}
var r: usize = 0;
@@ -1243,7 +1227,7 @@ fn bind_pattern(self: *Sema, pat_ref: usize, matched_tid: usize) {
if pattern_is_literal(pat) {
var lt = infer(self, pat_ref);
if lt != 0 && matched_tid != 0 {
ignore_usize(coerce(self, pat_ref, matched_tid));
coerce(self, pat_ref, matched_tid);
}
ret;
}
@@ -1404,14 +1388,10 @@ fn type_unpack_one(self: *Sema, pat: *Node, name: ByteView, src_lang: usize) {
var d = def_node(self, m.def_id);
var k: SymbolKind = .Var;
if d != null {
if @enum2int(d.kind) == @enum2int(DefKind.Fn) {
k = .Fn;
} else if @enum2int(d.kind) == @enum2int(DefKind.Agg) ||
@enum2int(d.kind) == @enum2int(DefKind.Scalar) ||
@enum2int(d.kind) == @enum2int(DefKind.Distinct) ||
@enum2int(d.kind) == @enum2int(DefKind.Alias) ||
@enum2int(d.kind) == @enum2int(DefKind.Builtin) {
k = .Type;
match d.kind {
.Fn => { k = .Fn; },
.Agg, .Scalar, .Distinct, .Alias, .Builtin => { k = .Type; },
_ => {},
}
}
var sym = Symbol { .name = name, .kind = k, .node = m.def_id };
@@ -1485,7 +1465,6 @@ fn do_type_unpack(self: *Sema, decl: *Node, pat: *Node, type_expr_ref: usize) {
type_unpack_walk(self, pat, src_lang);
}
// ---- var/const 推断 ----
fn var_body(self: *Sema, n: *Node): usize {
var decl_tid: usize = 0;
@@ -1531,7 +1510,6 @@ fn for_elem_type(self: *Sema, lang_tid: usize): usize {
ret elem_of_lang(e.*);
}
// ---- 驱动 ----
fn run_module(self: *Sema, module_ref: usize) {
if self.ast == null || module_ref == 0 { ret; }
@@ -1556,7 +1534,7 @@ fn run_module(self: *Sema, module_ref: usize) {
collect_types(self, module_ref);
collect_signatures(self);
ignore_usize(infer(self, module_ref));
infer(self, module_ref);
self.current_aggregate_lang = saved_agg;
self.scope.current_scope = saved_scope;
@@ -1582,8 +1560,6 @@ fn method_at(v: *Vec, i: usize): *LangMethod {
ret null;
}
fn ignore_usize(x: usize) {}
fn ignore_bool(x: bool) {}
// ============================================================
// infer / coerce：下面两块是主体（step 2 填入）。
@@ -1652,7 +1628,13 @@ fn agg_variants_copy(self: *Sema, agg_ir: usize): Vec {
ret out;
}
// ---- coerce ----
// 二元运算两侧都 coerce 到 expected；成功返回 expected，失败返回 0。
fn coerce_binop_same(self: *Sema, left: usize, right: usize, expected: usize): usize {
if coerce(self, left, expected) == 0 { ret 0; }
if coerce(self, right, expected) == 0 { ret 0; }
ret expected;
}
fn coerce(self: *Sema, ref: usize, expected: usize): usize {
if ref == 0 || expected == 0 { ret 0; }
@@ -1709,8 +1691,8 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
diag_ty2(self, n.span, .TypeMismatch, "comparison mismatch: ", lt2, rt2);
ret 0;
}
ignore_usize(coerce(self, x.left, common));
ignore_usize(coerce(self, x.right, common));
coerce(self, x.left, common);
coerce(self, x.right, common);
result = make_bool(self);
} else if is_addsub(op) {
var en = lang_of(self, expected);
@@ -1729,19 +1711,13 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
}
result = expected;
} else {
if coerce(self, x.left, expected) == 0 { ret 0; }
if coerce(self, x.right, expected) == 0 { ret 0; }
result = expected;
result = coerce_binop_same(self, x.left, x.right, expected);
}
} else {
if coerce(self, x.left, expected) == 0 { ret 0; }
if coerce(self, x.right, expected) == 0 { ret 0; }
result = expected;
result = coerce_binop_same(self, x.left, x.right, expected);
}
} else {
if coerce(self, x.left, expected) == 0 { ret 0; }
if coerce(self, x.right, expected) == 0 { ret 0; }
result = expected;
result = coerce_binop_same(self, x.left, x.right, expected);
}
},
.ExprArrayLit(&x) => {
@@ -1848,16 +1824,16 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
.ExprIf(&x) => {
handled = true;
var bt = make_bool(self);
ignore_usize(coerce(self, x.cond, bt));
if x.then_block != 0 { ignore_usize(coerce(self, x.then_block, expected)); }
if x.else_branch != 0 { ignore_usize(coerce(self, x.else_branch, expected)); }
coerce(self, x.cond, bt);
if x.then_block != 0 { coerce(self, x.then_block, expected); }
if x.else_branch != 0 { coerce(self, x.else_branch, expected); }
result = expected;
},
.ExprLoop(&x) => {
handled = true;
var saved = self.current_loop_break_tid;
self.current_loop_break_tid = expected;
ignore_usize(infer(self, ref));
infer(self, ref);
self.current_loop_break_tid = saved;
result = expected;
},
@@ -1920,7 +1896,6 @@ fn kind_is_body_struct_init(n: *Node): bool {
ret false;
}
// ---- infer ----
fn infer(self: *Sema, ref: usize): usize {
if ref == 0 { ret 0; }
@@ -2004,7 +1979,7 @@ fn infer(self: *Sema, ref: usize): usize {
}
if punct_is(x.op, .Not) {
var bt = make_bool(self);
ignore_usize(coerce(self, x.operand, bt));
coerce(self, x.operand, bt);
n.resolved_lang_tid = bt;
ret bt;
}
@@ -2095,7 +2070,7 @@ fn infer(self: *Sema, ref: usize): usize {
},
.ExprIf(&x) => {
var bt = make_bool(self);
ignore_usize(coerce(self, x.cond, bt));
coerce(self, x.cond, bt);
var then_t = if x.then_block != 0 { infer(self, x.then_block) } else { 0 };
var else_t = if x.else_branch != 0 { infer(self, x.else_branch) } else { 0 };
var result: usize = 0;
@@ -2114,24 +2089,24 @@ fn infer(self: *Sema, ref: usize): usize {
var vd = node(self, x.var_decl);
if vd == null { ret 0; }
push_scope(self);
ignore_usize(var_body(self, vd));
if x.then_block != 0 { ignore_usize(infer(self, x.then_block)); }
var_body(self, vd);
if x.then_block != 0 { infer(self, x.then_block); }
pop_scope(self);
if x.else_branch != 0 { ignore_usize(infer(self, x.else_branch)); }
if x.else_branch != 0 { infer(self, x.else_branch); }
ret 0;
},
.ExprWhile(&x) => {
push_view(&self.label_stack, label_name(self, x.label));
var bt = make_bool(self);
ignore_usize(coerce(self, x.cond, bt));
if x.body != 0 { ignore_usize(infer(self, x.body)); }
if x.else_branch != 0 { ignore_usize(infer(self, x.else_branch)); }
coerce(self, x.cond, bt);
if x.body != 0 { infer(self, x.body); }
if x.else_branch != 0 { infer(self, x.else_branch); }
pop_label(self);
ret 0;
},
.ExprLoop(&x) => {
push_view(&self.label_stack, label_name(self, x.label));
if x.body != 0 { ignore_usize(infer(self, x.body)); }
if x.body != 0 { infer(self, x.body); }
pop_label(self);
ret 0;
},
@@ -2155,7 +2130,7 @@ fn infer(self: *Sema, ref: usize): usize {
}
push_scope(self);
bind_pattern(self, pat, matched);
if body != 0 { ignore_usize(infer(self, body)); }
if body != 0 { infer(self, body); }
pop_scope(self);
}
i = i + 1;
@@ -2264,7 +2239,7 @@ fn infer(self: *Sema, ref: usize): usize {
.ContainerMembers(&x) => {
var i: usize = 0;
while i < x.declarations.len {
ignore_usize(infer(self, list_at(x.declarations, i)));
infer(self, list_at(x.declarations, i));
i = i + 1;
}
ret 0;
@@ -2295,23 +2270,23 @@ fn infer(self: *Sema, ref: usize): usize {
ret infer_continue(self, n, x.label);
},
.StatementDefer(&x) => {
if x.body != 0 { ignore_usize(infer(self, x.body)); }
if x.body != 0 { infer(self, x.body); }
ret 0;
},
.StatementComptime(&x) => {
if x.body != 0 { ignore_usize(infer(self, x.body)); }
if x.body != 0 { infer(self, x.body); }
ret 0;
},
.StatementDecl(&x) => {
if x.decl != 0 { ignore_usize(infer(self, x.decl)); }
if x.decl != 0 { infer(self, x.decl); }
ret 0;
},
.StatementExpr(&x) => {
if x.expr != 0 { ignore_usize(infer(self, x.expr)); }
if x.expr != 0 { infer(self, x.expr); }
ret 0;
},
.TopLevelBlock(&x) => {
if x.block != 0 { ignore_usize(infer(self, x.block)); }
if x.block != 0 { infer(self, x.block); }
ret 0;
},
_ => { ret 0; },
@@ -2326,24 +2301,21 @@ fn kind_is_body_ident(n: *Node): bool {
fn pop_label(self: *Sema) {
var out = ByteView.empty();
match Vec.pop(&self.label_stack, &out as *u8) {
.Ok => {},
.Err(error) => {},
}
Vec.pop(&self.label_stack, &out as *u8);
}
fn infer_binary(self: *Sema, n: *Node, op: Punct, left: usize, right: usize): usize {
if punct_is(op, .Assign) || is_assign_arith(op) {
var lt = infer(self, left);
if lt == 0 { ret 0; }
ignore_usize(coerce(self, right, lt));
coerce(self, right, lt);
n.resolved_lang_tid = lt;
ret lt;
}
if punct_is(op, .OrOr) || punct_is(op, .AndAnd) {
var bt = make_bool(self);
ignore_usize(coerce(self, left, bt));
ignore_usize(coerce(self, right, bt));
coerce(self, left, bt);
coerce(self, right, bt);
n.resolved_lang_tid = bt;
ret bt;
}
@@ -2356,15 +2328,15 @@ fn infer_binary(self: *Sema, n: *Node, op: Punct, left: usize, right: usize): us
diag_ty2(self, n.span, .TypeMismatch, "comparison mismatch: ", lt, rt);
ret 0;
}
ignore_usize(coerce(self, left, common));
ignore_usize(coerce(self, right, common));
coerce(self, left, common);
coerce(self, right, common);
var b = make_bool(self);
n.resolved_lang_tid = b;
ret b;
}
if punct_is(op, .Range) {
ignore_usize(infer(self, left));
ignore_usize(infer(self, right));
infer(self, left);
infer(self, right);
var i64t = LangType.make_int(&self.types, 64, true);
var r = LangType.make_range(&self.types, i64t);
n.resolved_lang_tid = r;
@@ -2377,7 +2349,7 @@ fn infer_binary(self: *Sema, n: *Node, op: Punct, left: usize, right: usize): us
diag(self, n.span, .TypeMismatch, "shift requires integer operands");
ret 0;
}
ignore_usize(infer(self, right));
infer(self, right);
n.resolved_lang_tid = lt;
ret lt;
}
@@ -2387,7 +2359,7 @@ fn infer_binary(self: *Sema, n: *Node, op: Punct, left: usize, right: usize): us
if kind_is(self, lt2, .Ptr) && kind_is(self, rt2, .Int) && is_addsub(op) {
if int_bits(self, rt2) == 0 {
var it = make_isize(self);
ignore_usize(coerce(self, right, it));
coerce(self, right, it);
}
n.resolved_lang_tid = lt2;
ret lt2;
@@ -2397,8 +2369,8 @@ fn infer_binary(self: *Sema, n: *Node, op: Punct, left: usize, right: usize): us
diag_ty2(self, n.span, .TypeMismatch, "operand types cannot be joined: ", lt2, rt2);
ret 0;
}
ignore_usize(coerce(self, left, common2));
ignore_usize(coerce(self, right, common2));
coerce(self, left, common2);
coerce(self, right, common2);
n.resolved_lang_tid = common2;
ret common2;
}
@@ -2530,7 +2502,7 @@ fn infer_field(self: *Sema, n: *Node, obj_ref: usize, field_name: ByteView): usi
fn infer_index(self: *Sema, n: *Node, obj_ref: usize, index_ref: usize): usize {
var obj_tid = infer(self, obj_ref);
ignore_usize(infer(self, index_ref));
infer(self, index_ref);
var obj = lang_of(self, obj_tid);
if obj == null { ret 0; }
var elem: usize = 0;
@@ -2546,7 +2518,7 @@ fn infer_index(self: *Sema, n: *Node, obj_ref: usize, index_ref: usize): usize {
var iv: i64 = -1;
match idx_node.body {
.ExprIntLit(lit) => {
match BigInt.to_i64(&iv, lit.value) { .Ok => {}, .Err(e) => {} }
BigInt.to_i64(&iv, lit.value);
},
_ => {},
}
@@ -2567,8 +2539,8 @@ fn infer_index(self: *Sema, n: *Node, obj_ref: usize, index_ref: usize): usize {
fn infer_slice(self: *Sema, n: *Node, obj_ref: usize, begin_ref: usize, end_ref: usize): usize {
var obj_tid = infer(self, obj_ref);
if begin_ref != 0 { ignore_usize(infer(self, begin_ref)); }
if end_ref != 0 { ignore_usize(infer(self, end_ref)); }
if begin_ref != 0 { infer(self, begin_ref); }
if end_ref != 0 { infer(self, end_ref); }
var obj = lang_of(self, obj_tid);
if obj == null { ret 0; }
if !(kind_is(self, obj_tid, .Array) || kind_is(self, obj_tid, .Ptr) ||
@@ -2685,7 +2657,7 @@ fn infer_aggregate(self: *Sema, n: *Node, type_name: ByteView, fields: Vec): usi
}
if idx < field_irs.len {
var ft = lang_from_ir(self, list_at(field_irs, idx));
if ft != 0 && iexpr != 0 { ignore_usize(coerce(self, iexpr, ft)); }
if ft != 0 && iexpr != 0 { coerce(self, iexpr, ft); }
}
}
i = i + 1;
@@ -2726,8 +2698,8 @@ fn infer_for(self: *Sema, n: *Node, label_ref: usize, iter_exprs: Vec, pattern_r
}
}
if body_ref != 0 { ignore_usize(infer(self, body_ref)); }
if else_ref != 0 { ignore_usize(infer(self, else_ref)); }
if body_ref != 0 { infer(self, body_ref); }
if else_ref != 0 { infer(self, else_ref); }
pop_scope(self);
pop_label(self);
@@ -2786,7 +2758,7 @@ fn infer_fn_decl(self: *Sema, n: *Node, params_ref: Vec, ret_ref: usize, body_re
}
var old_ret = self.current_fn_ret_tid;
self.current_fn_ret_tid = ret_tid;
ignore_usize(infer(self, body_ref));
infer(self, body_ref);
self.current_fn_ret_tid = old_ret;
pop_scope(self);
self.current_aggregate_lang = saved_agg;
@@ -2811,7 +2783,7 @@ fn infer_type_decl(self: *Sema, n: *Node, pattern_ref: usize, type_ref: usize):
while i < members.len {
var mref = list_at(members, i);
var mn = node(self, mref);
if mn != null && kind_is_body_fn_decl(mn) { ignore_usize(infer(self, mref)); }
if mn != null && kind_is_body_fn_decl(mn) { infer(self, mref); }
i = i + 1;
}
}
@@ -2826,9 +2798,9 @@ fn kind_is_body_fn_decl(n: *Node): bool {
fn infer_ret(self: *Sema, n: *Node, expr_ref: usize): usize {
if expr_ref != 0 {
if self.current_fn_ret_tid != 0 {
ignore_usize(coerce(self, expr_ref, self.current_fn_ret_tid));
coerce(self, expr_ref, self.current_fn_ret_tid);
} else {
ignore_usize(infer(self, expr_ref));
infer(self, expr_ref);
}
} else if self.current_fn_ret_tid != 0 {
var u = make_unit(self);
@@ -2850,9 +2822,9 @@ fn infer_break(self: *Sema, n: *Node, label_ref: usize, expr_ref: usize): usize
}
if expr_ref != 0 {
if self.current_loop_break_tid != 0 {
ignore_usize(coerce(self, expr_ref, self.current_loop_break_tid));
coerce(self, expr_ref, self.current_loop_break_tid);
} else {
ignore_usize(infer(self, expr_ref));
infer(self, expr_ref);
}
}
ret 0;
@@ -2884,7 +2856,6 @@ fn label_in_stack(self: *Sema, lbl: ByteView): bool {
ret false;
}
// ---- dump（镜像 stage1 spl_sema_dump；供 splc1 --dump sema 人读）----
type SymPrint = struct {
key: ByteView,
@@ -2928,7 +2899,7 @@ fn dump(self: *Sema, out: *ByteBuffer): bool {
if !out_u(out, sn.parent) { ret false; }
if !out_str(out, "\n") { ret false; }
// 收集后按符号名排序输出（与 stage1 一致，顺序与哈希布局解耦）。
// 收集后按符号名排序输出（顺序与哈希布局解耦）。
var entries = Vec.blank(@sizeof(SymPrint), @alignof(SymPrint));
var sc = Map.slot_count(sn.symbols);
var j: usize = 0;
@@ -2942,10 +2913,7 @@ fn dump(self: *Sema, out: *ByteBuffer): bool {
.name = sym.name,
.node = sym.node,
};
match Vec.push(&entries, &sp as *u8) {
.Ok => {},
.Err(error) => {},
}
Vec.push(&entries, &sp as *u8);
}
j = j + 1;
}
@@ -2959,11 +2927,11 @@ fn dump(self: *Sema, out: *ByteBuffer): bool {
var prev = sym_at(&entries, b - 1).*;
if ByteView.cmp(prev.key, cur.key) <= 0 { break; }
var pv = prev;
match Vec.set(&entries, b, &pv as *u8) { .Ok => {}, .Err(error) => {} }
Vec.set(&entries, b, &pv as *u8);
b = b - 1;
}
var cv = cur;
match Vec.set(&entries, b, &cv as *u8) { .Ok => {}, .Err(error) => {} }
Vec.set(&entries, b, &cv as *u8);
a = a + 1;
}
@@ -3019,7 +2987,6 @@ fn dump(self: *Sema, out: *ByteBuffer): bool {
ret Attr.dump(&self.attr, out);
}
// ---- 测试 ----
// 走完整前端：lex -> parse -> sema；返回 0 表示无（新）诊断。
fn sema_source(text: []u8): i32 {
stage2/splc1.spl
+25 -42
View File
@@ -1,8 +1,7 @@
// Expect retcode = 0
// splc1 (stage2 自举编译器入口)。
// 当前实现 `--dump <lex|ast|sema|ir|vm> <file> [out]`：读取源文件，按与 stage1
// splc0 完全一致的格式打印各阶段产物，供 diff 测试逐字节比对。
// splc1：自举编译器入口。`splc1 <in> <out>` 编译；`--dump <mode> <file>` 打印各阶段
// 产物，格式必须与 splc0 逐字节一致以通过 diff。
type .{ .ByteView } = @import("./utils/byte_view.spl");
type .{ .ByteBuffer } = @import("./utils/byte_buffer.spl");
@@ -13,8 +12,7 @@ type Ast = @import("./ast.spl");
type Parser = @import("./parser.spl");
type Sema = @import("./sema.spl");
type .{ .append_usize } = @import("./utils/fmt.spl");
type .{ .read_all, .print, .eprint, .open_cstr, .write_all } = @import("./utils/io.spl");
type File = @import("./sys/file.spl");
type .{ .read_all, .print, .eprint, .open_cstr, .write_all, .File } = @import("./utils/io.spl");
type .{ .Sources, .Source, .set_new, .set_add, .set_at, .set_drop } = @import("./utils/source.spl");
type .{ .Diag, .Code, .span_none } = @import("./diag.spl");
type Logger = @import("./utils/log.spl");
@@ -27,7 +25,7 @@ type .{ .Layout } = @import("./layout.spl");
type Ir2VmM = @import("./ir2vm.spl");
type .{ .Ir2Vm } = @import("./ir2vm.spl");
type Ir2CM = @import("./ir2c.spl");
type .{ .alloc, .free } = @import("./sys/mem.spl");
type .{ .alloc, .free } = @import("./utils/memory.spl");
fn token_at(tokens: *Vec, index: usize): Token {
match Vec.get(tokens, index) {
@@ -131,14 +129,11 @@ fn dump_lex(log: *Logger, path: ByteView): i32 {
}
defer { Vec.drop(&tokens); }
// 非法输入：走诊断（stage1 在此处是宽容无视，stage2 显式报错）。
// 非法输入：走诊断（显式报错，不静默）。
if Diag.has_error(diag) {
var rendered = ByteBuffer.new();
defer { ByteBuffer.drop(&rendered); }
match Diag.render_human(&diag, &rendered) {
.Ok => {},
.Err(error) => {},
}
Diag.render_human(&diag, &rendered);
eprint(ByteBuffer.as_slice(rendered));
ret 1;
}
@@ -200,10 +195,7 @@ fn dump_ast(log: *Logger, path: ByteView): i32 {
if Diag.has_error(diag) || p.failed {
var rendered = ByteBuffer.new();
defer { ByteBuffer.drop(&rendered); }
match Diag.render_human(&diag, &rendered) {
.Ok => {},
.Err(error) => {},
}
Diag.render_human(&diag, &rendered);
eprint(ByteBuffer.as_slice(rendered));
ret 1;
}
@@ -221,7 +213,6 @@ fn dump_ast(log: *Logger, path: ByteView): i32 {
ret 0;
}
// ---- @import 模块加载器（driver 侧）----
type ModEntry = struct {
path: ByteView,
@@ -236,7 +227,6 @@ type LoaderCtx = struct {
diag: *Diag,
}
fn ignore_bool(b: bool) {}
fn append_bytes(buf: *ByteBuffer, bytes: []u8): bool {
match ByteBuffer.append(buf, bytes) {
@@ -263,7 +253,7 @@ fn sub(p: ByteView, a: usize, b: usize): []u8 {
fn normalize_pop(out: *ByteBuffer) {
var cur = ByteBuffer.as_slice(out.*);
if cur.len == 0 {
ignore_bool(append_bytes(out, ".."));
append_bytes(out, "..");
ret;
}
var end = cur.len;
@@ -274,7 +264,7 @@ fn normalize_pop(out: *ByteBuffer) {
var start = end;
while start > 0 && cur.ptr[start - 1] != '/' { start = start - 1; }
if end - start == 2 && cur.ptr[start] == '.' && cur.ptr[start + 1] == '.' {
ignore_bool(append_bytes(out, ".."));
append_bytes(out, "..");
ret;
}
var new_len: usize = 0;
@@ -286,7 +276,7 @@ fn normalize_pop(out: *ByteBuffer) {
// 折叠重复分隔符、解析 "." 与 ".."、'\' 统一成 '/'。
fn normalize_into(out: *ByteBuffer, p: ByteView) {
if p.len > 0 && (p.ptr[0] == '/' || p.ptr[0] == '\\') {
ignore_bool(append_byte(out, '/'));
append_byte(out, '/');
}
var i: usize = 0;
while i < p.len {
@@ -302,9 +292,9 @@ fn normalize_into(out: *ByteBuffer, p: ByteView) {
}
var cur = ByteBuffer.as_slice(out.*);
if cur.len > 0 && cur.ptr[cur.len - 1] != '/' {
ignore_bool(append_byte(out, '/'));
append_byte(out, '/');
}
ignore_bool(append_bytes(out, seg));
append_bytes(out, seg);
}
}
@@ -325,9 +315,9 @@ fn resolve_path(from: ByteView, path: ByteView): ByteBuffer {
i = i + 1;
}
if last >= 0 {
ignore_bool(append_bytes(&out, sub(from, 0, (last as usize) + 1)));
append_bytes(&out, sub(from, 0, (last as usize) + 1));
}
ignore_bool(append_bytes(&out, ByteView.as_slice(path)));
append_bytes(&out, ByteView.as_slice(path));
var norm = ByteBuffer.new();
normalize_into(&norm, ByteView.from_slice(ByteBuffer.as_slice(out)));
ByteBuffer.drop(&out);
@@ -504,10 +494,7 @@ fn dump_sema(log: *Logger, path: ByteView): i32 {
if Diag.has_error(diag) || p.failed {
var rendered = ByteBuffer.new();
defer { ByteBuffer.drop(&rendered); }
match Diag.render_human(&diag, &rendered) {
.Ok => {},
.Err(error) => {},
}
Diag.render_human(&diag, &rendered);
eprint(ByteBuffer.as_slice(rendered));
ret 1;
}
@@ -538,10 +525,7 @@ fn dump_sema(log: *Logger, path: ByteView): i32 {
if Diag.has_error(diag) {
var rendered = ByteBuffer.new();
defer { ByteBuffer.drop(&rendered); }
match Diag.render_human(&diag, &rendered) {
.Ok => {},
.Err(error) => {},
}
Diag.render_human(&diag, &rendered);
eprint(ByteBuffer.as_slice(rendered));
ret 1;
}
@@ -573,7 +557,7 @@ type PipeMode = enum {
fn step(mode: PipeMode, s: []u8) {
if @enum2int(mode) == @enum2int(PipeMode.State) {
match eprint(s) { .Ok => {}, .Err(error) => {} }
eprint(s);
}
}
@@ -631,7 +615,7 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
if Diag.has_error(diag) || p.failed {
var rendered = ByteBuffer.new();
defer { ByteBuffer.drop(&rendered); }
match Diag.render_human(&diag, &rendered) { .Ok => {}, .Err(error) => {} }
Diag.render_human(&diag, &rendered);
eprint(ByteBuffer.as_slice(rendered));
ret 1;
}
@@ -662,7 +646,7 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
if Diag.has_error(diag) {
var rendered = ByteBuffer.new();
defer { ByteBuffer.drop(&rendered); }
match Diag.render_human(&diag, &rendered) { .Ok => {}, .Err(error) => {} }
Diag.render_human(&diag, &rendered);
eprint(ByteBuffer.as_slice(rendered));
ret 1;
}
@@ -677,13 +661,13 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
var asts = Vec.blank(@sizeof(usize), @alignof(usize));
defer { Vec.drop(&asts); }
var ap: *Ast = &ast;
match Vec.push(&asts, &ap as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(&asts, &ap as *u8);
var mi: usize = 0;
while mi < ctx.mods.len {
var m = mod_at(&ctx, mi);
if m != null && m.ok && m.ast != null {
var mp: *Ast = m.ast;
match Vec.push(&asts, &mp as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(&asts, &mp as *u8);
}
mi = mi + 1;
}
@@ -692,7 +676,7 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
if Diag.has_error(diag) {
var rendered = ByteBuffer.new();
defer { ByteBuffer.drop(&rendered); }
match Diag.render_human(&diag, &rendered) { .Ok => {}, .Err(error) => {} }
Diag.render_human(&diag, &rendered);
eprint(ByteBuffer.as_slice(rendered));
ret 1;
}
@@ -736,8 +720,8 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
Logger.error(log, "cannot open C output file");
ret 1;
}
match write_all(&f, ByteBuffer.as_slice(cout)) { .Ok => {}, .Err(error) => {} }
ignore_i32(File.close(&f));
write_all(&f, ByteBuffer.as_slice(cout));
File.close(&f);
} else {
match print(ByteBuffer.as_slice(cout)) {
.Ok => {},
@@ -754,7 +738,7 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
var ir2vm: Ir2Vm = undefined;
Ir2VmM.init(&ir2vm, &builder.ir, &sema.types.ir, &layout, &sema.attr);
defer { Ir2VmM.drop(&ir2vm); }
ignore_i32(Ir2VmM.run(&ir2vm));
Ir2VmM.run(&ir2vm);
step(mode, "state: ir2vm ok\n");
if @enum2int(mode) == @enum2int(PipeMode.Vm) {
@@ -782,7 +766,6 @@ fn run_pipeline(log: *Logger, path: ByteView, mode: PipeMode, outpath: ByteView)
ret 0;
}
fn ignore_i32(v: i32) {}
fn main(argc: i32, argv: **u8): i32 {
// 无参数：自测运行（`nob test stage2`）视为成功。
stage2/token.spl
+2 -4
View File
@@ -1,7 +1,7 @@
// Expect retcode = 0
// 词法单元：用带载荷 ADT 表达 TokenKind；关键词/算符各自独立 enum。
// 整型与字符在词法期解码并随载荷携带；文本一律借用源切片（不复制）。
// 词法单元：TokenKind 为带载荷 ADT，关键词/算符各自独立 enum；整型/字符在词法期
// 解码，文本一律借用源切片。
type .{ .ByteView } = @import("utils/byte_view.spl");
@@ -128,7 +128,6 @@ fn keyword_of(text: ByteView): KeywordResult {
ret .No;
}
// ---- token 类型名（与 stage1 spl_tok_type_name 逐字一致，供 dump/diff 使用）----
fn keyword_name(kw: Keyword): []u8 {
match kw {
@@ -242,7 +241,6 @@ fn kind_name(kind: TokenKind): []u8 {
ret "?";
}
// ---- 测试辅助 ----
fn view(text: []u8): ByteView {
ret ByteView.from_slice(text);
stage2/type_table.spl
+7 -28
View File
@@ -1,11 +1,7 @@
// Expect retcode = 0
// IR 类型表（移植自 stage1/spl_type.c）。类型按结构 hash-consing（intern），
// id 0 为保留哨兵（Error）。节点借用式持有：名称是 ByteView（指向源/AST），
// 不复制字符串；聚合成员与函数参数的 Vec 由本表拥有，drop 时统一释放。
//
// hash 只用于选桶；相等永远由结构比较决定。桶以「完整 hash -> 链头 id」的
// Map 存储，节点自带 hash_next 串链（对应 stage1 的 spl_fold）。
// IR 类型表：按结构 hash-consing。id 0 为保留哨兵（Error）。成员/参数 Vec 由本表
// 拥有；hash 仅用于选桶，相等始终由结构比较决定。
type .{ .Error } = @import("utils/error.spl");
type .{ .Vec } = @import("utils/vec.spl");
@@ -41,7 +37,7 @@ type AggKind = enum {
Shape,
}
// 与 stage1 spl_type_node_kind_t 一一对应；Forall/Exists 保留（暂打印 quant）。
// 变体顺序即 kind 数值；Forall/Exists 暂按 quant 打印。
type TypeNode = enum {
Error,
Never,
@@ -78,7 +74,6 @@ type TypeTableResult = enum {
Err: Error,
}
// ---- hash（FNV 风格；值不必与 stage1 相同，只要结构一致即可）----
fn seed(): usize {
ret 14695981039346656037;
@@ -290,7 +285,6 @@ fn free_payload(n: *TypeNode) {
}
}
// ---- 底层访问 ----
fn usize_at(v: Vec, i: usize): usize {
match Vec.get(&v, i) {
@@ -317,13 +311,12 @@ fn push_member(v: *Vec, name: []u8, type_id: usize) {
}
}
// id 0 与越界均返回 null（对应 stage1 spl_type_node）。
// id 0 与越界均返回 null。
fn node(self: *TypeTable, id: usize): *TypeEntry {
if id == 0 || id >= self.table.len { ret null; }
ret (self.table.data as *TypeEntry) + id;
}
// ---- 生命周期 ----
fn new(): TypeTableResult {
var tt = TypeTable {
@@ -376,7 +369,6 @@ fn define(self: *TypeTable, id: usize, src: *TypeNode) {
src.* = .Error;
}
// ---- intern ----
fn fold_find(self: *TypeTable, hash: usize, probe: *TypeNode): usize {
var head: usize = 0;
@@ -403,10 +395,7 @@ fn fold_insert(self: *TypeTable, hash: usize, id: usize) {
var n = node(self, id);
if n == null { ret; }
n.hash_next = old;
match Map.put(&self.fold, &hash as *u8, &id as *u8) {
.Ok => {},
.Err(error) => {},
}
Map.put(&self.fold, &hash as *u8, &id as *u8);
}
// intern 一个 probe：命中则释放 probe 载荷并返回已有 id；否则复制入表。
@@ -433,7 +422,6 @@ fn push(self: *TypeTable, probe: *TypeNode): usize {
ret id;
}
// ---- builders ----
fn make_error(self: *TypeTable): usize {
var n: TypeNode = .Error;
@@ -513,7 +501,6 @@ fn make_agg(self: *TypeTable, kind: AggKind, agg: Agg): usize {
ret push(self, &n);
}
// ---- 查询 ----
fn is_subtype(self: *TypeTable, sub: usize, super: usize): bool {
if sub == 0 || super == 0 { ret false; }
@@ -597,7 +584,6 @@ fn agg_member_idx(self: *TypeTable, tid: usize, name: ByteView, out_idx: *usize)
ret false;
}
// ---- dump（镜像 stage1 spl_type_pure_dump）----
fn push_out(buf: *ByteBuffer, bytes: []u8): bool {
match ByteBuffer.append(buf, bytes) {
@@ -637,10 +623,7 @@ fn dump_rec(self: *TypeTable, id: usize, out: *ByteBuffer, stack: *Vec): bool {
if n == null {
if !push_out(out, "none") { ret false; }
var popped: usize = 0;
match Vec.pop(stack, &popped as *u8) {
.Ok => {},
.Err(error) => {},
}
Vec.pop(stack, &popped as *u8);
ret true;
}
@@ -698,10 +681,7 @@ fn dump_rec(self: *TypeTable, id: usize, out: *ByteBuffer, stack: *Vec): bool {
}
var dropped: usize = 0;
match Vec.pop(stack, &dropped as *u8) {
.Ok => {},
.Err(error) => {},
}
Vec.pop(stack, &dropped as *u8);
ret ok;
}
@@ -739,7 +719,6 @@ fn pure_dump_text(self: *TypeTable, id: usize): ByteBuffer {
ret out;
}
// ---- 测试 ----
fn test_intern_simple() {
var tt: TypeTable = undefined;
stage2/utils/algorithm.spl
-1
View File
@@ -155,7 +155,6 @@ fn stable_sort(data: *u8, len: usize, elem_size: usize,
ret .Ok;
}
// ---- 测试 ----
type Item = struct {
key: i32,
stage2/utils/arena.spl
-1
View File
@@ -127,7 +127,6 @@ fn drop(self: *Arena) {
self.current = 0;
}
// ---- 测试辅助 ----
fn is_aligned(p: *u8, align: usize): bool {
ret ((p as usize) & (align - 1)) == 0;
stage2/utils/byte_buffer.spl
+1 -1
View File
@@ -26,7 +26,7 @@ fn new(): ByteBuffer {
fn with_capacity(cap: usize): ByteBuffer {
var b = new();
match reserve(&b, cap) { .Ok => {}, .Err(error) => {} }
reserve(&b, cap);
ret b;
}
stage2/utils/fmt.spl
+2 -4
View File
@@ -9,8 +9,8 @@ type .{ .ByteView } = @import("byte_view.spl");
type .{ .Value, .int, .uint, .char, .str, .addr } = @import("value.spl");
type .{ .BigInt, .Bits } = @import("mp.spl");
// 注意：radix 边界直接用字面量。stage1 刻意不做常量求值/折叠，
// 顶层 const 不应用于运行时表达式。
// radix 边界直接用字面量：顶层 const 不参与运行时常量折叠。
fn valid_radix(radix: u8): bool {
ret radix >= 2 && radix <= 36;
}
@@ -71,7 +71,6 @@ fn append_bool(out: *ByteBuffer, value: bool): Status {
ret ByteBuffer.append(out, "false");
}
// ---- 显式装箱值格式化 ----
// Int/Uint 落到整数；signed 仅对 Int 的十进制生效，其余按无符号位模式输出。
fn append_value_int(out: *ByteBuffer, value: Value, radix: u8, uppercase: bool,
@@ -223,7 +222,6 @@ fn format(out: *ByteBuffer, fmt: []u8, args: []Value): Status {
ret ByteBuffer.append(out, ByteBuffer.as_slice(temp));
}
// ---- 测试辅助 ----
fn expect_ok(result: Status) {
match result {
stage2/utils/hash.spl
-2
View File
@@ -34,7 +34,6 @@ fn hash_usize_value(value: usize): usize {
ret h;
}
// ---- map 回调 ----
// 键按 usize 解释。
fn hash_usize(key: *u8): usize {
@@ -55,7 +54,6 @@ fn eq_view(a: *u8, b: *u8): bool {
ret ByteView.eq((a as *ByteView).*, (b as *ByteView).*);
}
// ---- 测试辅助 ----
fn expect_hash(view: []u8, expected: usize) {
var got = hash_bytes(view.ptr, view.len);
stage2/utils/io.spl
+2 -7
View File
@@ -1,11 +1,7 @@
// Expect retcode = 0
// I/O 便利层（构建在 sys/file 之上）：
// - C 字符串路径/模式的 open 包装
// - 精确读取、完整写入和普通文件整读
// - stdout/stderr 打印
// 说明：read_all 会按文件大小一次性读入 ByteBuffer；不处理增长中的文件。
// 短读、短写后的零进展及关闭失败返回 Err(.Io)；文件写入不承诺回滚。
// sys/file 之上的 I/O 便利层：C 字符串路径 open、精确读取/完整写入、整读、stdout/stderr 打印。
// 短读/短写零进展与关闭失败返回 Err(.Io)；写入失败不承诺回滚。
type .{ .Error, .Status, .make } = @import("error.spl");
type .{ .ByteView } = @import("byte_view.spl");
@@ -130,7 +126,6 @@ fn read_all(path: ByteView, out: *ByteBuffer): Status {
ret .Ok;
}
// ---- 测试辅助 ----
fn view(text: []u8): ByteView {
ret ByteView.from_slice(text);
stage2/utils/json.spl
+3 -9
View File
@@ -1,10 +1,6 @@
// Expect retcode = 0
// 轻量 JSON 解析 / 输出器（递归下降 + 节点池），用于验证底层库的拼装，未来服务 LSP。
// 设计：
// - 输入 ByteView，字符串/数字以“源切片”借用，不做解码，round-trip 保真；
// - 节点池 Vec[JsonNode]；数组/对象子项存 Vec[JsonChild]，保留插入顺序；
// - 错误带字节位置（error.spl）；输出写 ByteBuffer；缩进/数字用 ByteBuffer/fmt。
// 限制：不做字符串转义解码、数字不做数值化（原样保存）；递归/输出深度上限见 max_depth()。
// 轻量 JSON 解析/输出器：输入按源切片借用、不解码（round-trip 保真），数字不做数值化。
// 节点/子项存 Vec 保留插入顺序；输出写 ByteBuffer。递归/输出深度上限见 max_depth()。
type .{ .Error, .Status, .make, .at } = @import("error.spl");
type .{ .ByteView, .ViewResult, .FindResult } = @import("byte_view.spl");
@@ -393,7 +389,7 @@ fn root_index(doc: *Json): usize {
ret doc.root;
}
// 枚举 tag 取整（stage1 枚举 == 有缺陷，用 @enum2int 比较更稳妥）。
// 枚举 tag 取整：枚举 == 不可靠，用 @enum2int 比较。
fn kind_code(kind: JsonKind): usize {
ret @enum2int(kind) as usize;
}
@@ -578,7 +574,6 @@ fn emit_pretty(out: *ByteBuffer, doc: *Json, indent: usize): Status {
ret emit(out, doc, doc.root, indent, 0);
}
// ---- 构造辅助（写 JSON 片段；字符串需由调用方保证已转义）----
fn write_int(out: *ByteBuffer, value: i64): Status {
ret append_i64(out, value, 10, false);
@@ -588,7 +583,6 @@ fn write_u64(out: *ByteBuffer, value: u64): Status {
ret append_u64(out, value, 10, false);
}
// ---- 测试辅助 ----
fn expect_ok(result: Status) {
match result {
stage2/utils/log.spl
-2
View File
@@ -89,7 +89,6 @@ fn fatal(self: *Logger, message: []u8) {
Exit.fail();
}
// ---- 格式化入口（显式装箱，见 value.spl / fmt.format）----
// 先格式化到临时缓冲；格式错误在写出前返回 Err(.InvalidFormat)。
fn logf(self: *Logger, level: Level, fmt: []u8, args: []Value): Status {
@@ -125,7 +124,6 @@ fn fatalf(self: *Logger, fmt: []u8, args: []Value) {
Exit.fail();
}
// ---- 测试 ----
fn expect_name(level: Level, expected: []u8) {
@assert(ByteView.eq(ByteView.from_slice(level_name(level)),
stage2/utils/lsp_frame.spl
-1
View File
@@ -99,7 +99,6 @@ fn parse_frame(input: ByteView, body_out: *ByteBuffer): FrameResult {
ret .Ok(body_start + content_len);
}
// ---- 测试辅助 ----
fn expect_ok(result: Status) {
match result {
stage2/utils/map.spl
-1
View File
@@ -155,7 +155,6 @@ fn take(source: *Map): Map {
ret result;
}
// ---- 测试辅助 ----
fn expect_ok(result: Status) {
match result {
stage2/utils/memory.spl
+13 -3
View File
@@ -1,13 +1,23 @@
// Expect retcode = 0
// 尺寸计算和字节移动；不分配、不释放内存，不改变任何资源的所有权。
// 尺寸计算、字节移动与内存分配统一门面（分配/释放转发自 sys/mem）。
// 本模块不改变任何资源的所有权。
type .{ .Error, .Status, .make } = @import("error.spl");
type SysMem = @import("../sys/mem.spl");
// 分配/释放/字节操作转发（core 只经本模块使用内存，不直接依赖 sys）。
fn alloc(sz: usize): *any { ret SysMem.alloc(sz); }
fn free(p: *any) { SysMem.free(p); }
fn realloc(p: *any, sz: usize): *any { ret SysMem.realloc(p, sz); }
fn copy(dst: *any, src: *any, n: usize): *any { ret SysMem.copy(dst, src, n); }
fn cmp(a: *any, b: *any, n: usize): isize { ret SysMem.cmp(a, b, n); }
fn set(dst: *any, byte: u8, n: usize): *any { ret SysMem.set(dst, byte, n); }
fn zero(dst: *any, n: usize): *any { ret SysMem.zero(dst, n); }
#extern(vm) fn vm_memcpy(dst: *any, src: *any, n: usize): *any;
#extern(vm) fn vm_memmove(dst: *any, src: *any, n: usize): *any;
fn ignore_ptr(p: *any) {}
type SizeResult = enum {
Ok: usize,
@@ -75,7 +85,7 @@ fn move(dst: []u8, src: []u8): Status {
if dst_addr == src_addr { ret .Ok; }
// 重叠安全，统一走原生 memmove。
ignore_ptr(vm_memmove(dst.ptr as *any, src.ptr as *any, count));
vm_memmove(dst.ptr as *any, src.ptr as *any, count);
ret .Ok;
}
stage2/utils/path.spl
-1
View File
@@ -297,7 +297,6 @@ fn normalize_into(out: *ByteBuffer, path: ByteView, style: PathStyle): Status {
ret .Ok;
}
// ---- 测试 ----
fn expect_ok(result: Status) {
match result { .Ok => {}, .Err(error) => { @assert(false, "unexpected path error"); }, }
}
stage2/utils/profile.spl
+6 -12
View File
@@ -1,10 +1,7 @@
// Expect retcode = 0
// 全量热点/耗时记录器（配合 @file_name()/@line()/@col() 与 sys/time.spl）。
// 每个调用点聚合：count、独占(self)与包含(total)的 steps/ns。
// - total_* 含被调用者（嵌套会重复，跨站点求和会超过墙钟）
// - self_* = total_* - 子区间之和，用于定位真正的热点
// 用法（严格 LIFO，defer 正好满足）：
// 采样热点记录器：每个调用点聚合 count 与 self/total 的 steps/ns（self = total 减子区间）。
// 严格 LIFO，用 defer 配对：
// var tok = Profile.begin(&prof, @file_name(), @line(), @col());
// defer { Profile.end(&prof, tok); }
@@ -139,7 +136,7 @@ fn begin(self: *Profile, fname: []u8, line: usize, col: usize): usize {
.Err(error) => { ret 0; },
}
var token = self.spans.len - 1;
match Vec.push(&self.stack, &token as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(&self.stack, &token as *u8);
ret token;
}
@@ -164,7 +161,7 @@ fn end(self: *Profile, token: usize) {
// 弹栈并把区间计入父 span（LIFO）。
var popped: usize = 0;
match Vec.pop(&self.stack, &popped as *u8) { .Ok => {}, .Err(error) => {} }
Vec.pop(&self.stack, &popped as *u8);
var n = self.stack.len;
if n > 0 {
var p = span_at(self, usize_at(&self.stack, n - 1));
@@ -175,7 +172,6 @@ fn end(self: *Profile, token: usize) {
}
}
// ---- dump / save ----
fn out_s(out: *ByteBuffer, s: []u8): bool {
match ByteBuffer.append(out, s) { .Ok => { ret true; }, .Err(error) => { ret false; } }
@@ -202,7 +198,7 @@ fn dump(self: *Profile, out: *ByteBuffer): bool {
defer { Vec.drop(&idx); }
var i: usize = 0;
while i < self.sites.len {
match Vec.push(&idx, &i as *u8) { .Ok => {}, .Err(error) => {} }
Vec.push(&idx, &i as *u8);
i = i + 1;
}
@@ -271,7 +267,6 @@ fn save(self: *Profile, path: ByteView): bool {
ret true;
}
// ---- 测试 ----
fn spin(n: usize): usize {
var i: usize = 0;
@@ -293,10 +288,9 @@ fn test_profile() {
@assert(s != null && s.count >= 1, "count");
@assert(s.total_steps > 0, "steps");
@assert(s.self_steps > 0, "self steps");
if v == 0 { ignore_usize(v + 1); }
if v == 0 { v + 1; }
}
fn ignore_usize(v: usize) {}
fn main() {
test_profile();
stage2/utils/set.spl
-1
View File
@@ -74,7 +74,6 @@ fn drop(self: *Set) {
Map.drop(&self.map);
}
// ---- 测试 ----
fn expect_ok(result: Status) {
match result {
stage2/utils/source.spl
-2
View File
@@ -123,7 +123,6 @@ fn drop(self: *Source) {
Vec.drop(&self.line_starts);
}
// ---- 多文件集合 ----
type Sources = struct {
items: Vec, // Source
@@ -191,7 +190,6 @@ fn set_drop(set: *Sources) {
Map.drop(&set.by_name);
}
// ---- 测试辅助 ----
fn view(text: []u8): ByteView {
ret ByteView.from_slice(text);
stage2/utils/str.spl
-1
View File
@@ -122,7 +122,6 @@ fn drop(self: *Str) {
ByteBuffer.drop(&self.storage);
}
// ---- 测试辅助 ----
fn expect_ok(result: Status) {
match result {
stage2/utils/utf8.spl
-1
View File
@@ -181,7 +181,6 @@ fn utf16_to_byte(data: *u8, len: usize, utf16_off: usize): usize {
ret i;
}
// ---- 测试辅助 ----
fn expect_ok(result: Status) {
match result {
stage2/utils/value.spl
-1
View File
@@ -43,7 +43,6 @@ fn addr(value: *any): Value {
ret .Ptr(value);
}
// ---- 测试 ----
fn test_int_and_uint() {
match int(-5) {