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

stage2 支持左值的引用绑定

Browse Source
This commit is contained in:
zzy committed 2026-09-29 23:00:24 +08:00
1 parent 40cffa9cb5
commit 0e38858785
4 files changed
+196 -194
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

stage2/ast2ir.spl
+74 -74
View File
@@ -182,7 +182,7 @@ fn is_assign_arith(op: Punct): bool {
fn int_lit_u64(n: *Node): u64 { fn int_lit_u64(n: *Node): u64 {
match n.body { match n.body {
.ExprIntLit(x) => { .ExprIntLit(&x) => {
var out: u64 = 0; var out: u64 = 0;
match BigInt.to_u64(&out, x.value) { .Ok => {}, .Err(e) => {} } match BigInt.to_u64(&out, x.value) { .Ok => {}, .Err(e) => {} }
ret out; ret out;
@@ -217,14 +217,14 @@ fn emit_zero_value(self: *Ast2Ir, tid: usize): usize {
var variants = Vec.blank(@sizeof(usize), @alignof(usize)); var variants = Vec.blank(@sizeof(usize), @alignof(usize));
match tn.node { match tn.node {
.Bool => { is_bool = true; }, .Bool => { is_bool = true; },
.Int(x) => { is_int = true; }, .Int(&x) => { is_int = true; },
.Float(x) => { is_float = true; }, .Float(&x) => { is_float = true; },
.Ptr(x) => { is_ptr = true; }, .Ptr(&x) => { is_ptr = true; },
.Fn(x) => { is_fn = true; }, .Fn(&x) => { is_fn = true; },
.Array(x) => { is_arr = true; arr_len = x.len; arr_elem = x.element; }, .Array(&x) => { is_arr = true; arr_len = x.len; arr_elem = x.element; },
.Struct(x) => { is_struct = true; variants = x.variants; }, .Struct(&x) => { is_struct = true; variants = x.variants; },
.Shape(x) => { is_shape = true; variants = x.variants; }, .Shape(&x) => { is_shape = true; variants = x.variants; },
.Union(x) => { is_union = true; variants = x.variants; }, .Union(&x) => { is_union = true; variants = x.variants; },
_ => { ret 0; }, _ => { ret 0; },
} }
if is_bool { ret IrBuilder.type_const_bool(self.ir, tid, false); } if is_bool { ret IrBuilder.type_const_bool(self.ir, tid, false); }
@@ -717,7 +717,7 @@ fn ast2ir_intrin_field(self: *Ast2Ir, n: *Node, in: Intrin): usize {
fn ast2ir_intrin_len(self: *Ast2Ir, n: *Node): usize { fn ast2ir_intrin_len(self: *Ast2Ir, n: *Node): usize {
var obj_ref: usize = 0; var obj_ref: usize = 0;
var fname = ByteView.empty(); var fname = ByteView.empty();
match n.body { .ExprField(x) => { obj_ref = x.obj; fname = x.name; }, _ => {} } match n.body { .ExprField(&x) => { obj_ref = x.obj; fname = x.name; }, _ => {} }
var obj = Ast.node(self.ast, obj_ref); var obj = Ast.node(self.ast, obj_ref);
var recv_lang = node_lang(obj); var recv_lang = node_lang(obj);
var recv = ltn(self, recv_lang); var recv = ltn(self, recv_lang);
@@ -748,7 +748,7 @@ fn emit_lvalue(self: *Ast2Ir, ref: usize): usize {
var n = Ast.node(self.ast, ref); var n = Ast.node(self.ast, ref);
if n == null { ret 0; } if n == null { ret 0; }
match n.body { match n.body {
.ExprIdent(x) => { .ExprIdent(&x) => {
var d = defn(self, n.resolved_def_id); var d = defn(self, n.resolved_def_id);
if d != null && @enum2int(d.kind) == @enum2int(DefKind.Fn) { ret 0; } if d != null && @enum2int(d.kind) == @enum2int(DefKind.Fn) { ret 0; }
var g: usize = 0; var g: usize = 0;
@@ -762,12 +762,12 @@ fn emit_lvalue(self: *Ast2Ir, ref: usize): usize {
if !ir_map_get(self, n.resolved_def_id, &slot) { ret 0; } if !ir_map_get(self, n.resolved_def_id, &slot) { ret 0; }
ret slot; ret slot;
}, },
.ExprUnary(x) => { .ExprUnary(&x) => {
if !punct_is(x.op, .Mul) { ret 0; } if !punct_is(x.op, .Mul) { ret 0; }
ret emit_expr(self, x.operand); ret emit_expr(self, x.operand);
}, },
.ExprField(x) => { ret lvalue_field(self, n, x.obj, x.name); }, .ExprField(&x) => { ret lvalue_field(self, n, x.obj, x.name); },
.ExprIndex(x) => { ret lvalue_index(self, n, x.obj, x.index); }, .ExprIndex(&x) => { ret lvalue_index(self, n, x.obj, x.index); },
_ => { ret 0; }, _ => { ret 0; },
} }
ret 0; ret 0;
@@ -844,7 +844,7 @@ fn lvalue_index(self: *Ast2Ir, n: *Node, obj_ref: usize, index_ref: usize): usiz
} }
fn is_int_lit(n: *Node): bool { fn is_int_lit(n: *Node): bool {
match n.body { .ExprIntLit(x) => { ret true; }, _ => { ret false; } } match n.body { .ExprIntLit(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
@@ -902,7 +902,7 @@ fn ir_float_cast(self: *Ast2Ir, ft: usize, tt: usize, v: usize): usize {
fn emit_cast(self: *Ast2Ir, n: *Node): usize { fn emit_cast(self: *Ast2Ir, n: *Node): usize {
var eref: usize = 0; var eref: usize = 0;
var tref: usize = 0; var tref: usize = 0;
match n.body { .ExprCast(x) => { eref = x.expr; tref = x.type_expr; }, _ => {} } match n.body { .ExprCast(&x) => { eref = x.expr; tref = x.type_expr; }, _ => {} }
var v = emit_expr_raw(self, eref); var v = emit_expr_raw(self, eref);
if v == 0 { ret 0; } if v == 0 { ret 0; }
var src = Ast.node(self.ast, eref); var src = Ast.node(self.ast, eref);
@@ -921,7 +921,7 @@ fn emit_cast(self: *Ast2Ir, n: *Node): usize {
fn ast2ir_field_from_value(self: *Ast2Ir, n: *Node): usize { fn ast2ir_field_from_value(self: *Ast2Ir, n: *Node): usize {
var obj_ref: usize = 0; var obj_ref: usize = 0;
var field_name = ByteView.empty(); var field_name = ByteView.empty();
match n.body { .ExprField(x) => { obj_ref = x.obj; field_name = x.name; }, _ => {} } match n.body { .ExprField(&x) => { obj_ref = x.obj; field_name = x.name; }, _ => {} }
var obj = Ast.node(self.ast, obj_ref); var obj = Ast.node(self.ast, obj_ref);
if obj == null { ret 0; } if obj == null { ret 0; }
var obj_lang = node_lang(obj); var obj_lang = node_lang(obj);
@@ -959,7 +959,7 @@ fn ast2ir_enum_variant(self: *Ast2Ir, n: *Node): usize {
var tn = irt(self, t); var tn = irt(self, t);
if tn == null { ret 0; } if tn == null { ret 0; }
var field_name = ByteView.empty(); var field_name = ByteView.empty();
match n.body { .ExprField(x) => { field_name = x.name; }, _ => {} } match n.body { .ExprField(&x) => { field_name = x.name; }, _ => {} }
var vidx: usize = 0; var vidx: usize = 0;
if !TypeTable.agg_member_idx(&self.sema.types.ir, t, field_name, &vidx) { ret 0; } if !TypeTable.agg_member_idx(&self.sema.types.ir, t, field_name, &vidx) { ret 0; }
var tag_ir: usize = 0; var tag_ir: usize = 0;
@@ -1001,39 +1001,39 @@ fn emit_expr_raw(self: *Ast2Ir, ref: usize): usize {
var n = Ast.node(self.ast, ref); var n = Ast.node(self.ast, ref);
if n == null { ret 0; } if n == null { ret 0; }
match n.body { match n.body {
.ExprIntLit(x) => { ret emit_int_lit(self, n); }, .ExprIntLit(&x) => { ret emit_int_lit(self, n); },
.ExprFloatLit(x) => { ret IrBuilder.type_const_float(self.ir, node_ir(self, n), 0.0); }, .ExprFloatLit(&x) => { ret IrBuilder.type_const_float(self.ir, node_ir(self, n), 0.0); },
.ExprCharLit(x) => { ret IrBuilder.type_const_char(self.ir, node_ir(self, n), x.value); }, .ExprCharLit(&x) => { ret IrBuilder.type_const_char(self.ir, node_ir(self, n), x.value); },
.ExprStringLit(sl) => { ret emit_string_lit(self, n, sl.data); }, .ExprStringLit(&sl) => { ret emit_string_lit(self, n, sl.data); },
.ExprBoolLit(x) => { ret IrBuilder.type_const_bool(self.ir, node_ir(self, n), x.value); }, .ExprBoolLit(&x) => { ret IrBuilder.type_const_bool(self.ir, node_ir(self, n), x.value); },
.ExprNullLit => { ret IrBuilder.type_const_ptr(self.ir, node_ir(self, n), 0); }, .ExprNullLit => { ret IrBuilder.type_const_ptr(self.ir, node_ir(self, n), 0); },
.ExprUndefinedLit => { ret 0; }, .ExprUndefinedLit => { ret 0; },
.ExprIdent(x) => { ret emit_ident(self, n); }, .ExprIdent(&x) => { ret emit_ident(self, n); },
.ExprUnary(x) => { ret emit_unary(self, n, ref, x.op, x.operand); }, .ExprUnary(&x) => { ret emit_unary(self, n, ref, x.op, x.operand); },
.ExprBinary(x) => { ret emit_binary(self, n, x.op, x.left, x.right); }, .ExprBinary(&x) => { ret emit_binary(self, n, x.op, x.left, x.right); },
.ExprCall(x) => { ret emit_call(self, n, x.callee, x.args); }, .ExprCall(&x) => { ret emit_call(self, n, x.callee, x.args); },
.ExprField(x) => { ret emit_field(self, n, ref, x.obj, x.name); }, .ExprField(&x) => { ret emit_field(self, n, ref, x.obj, x.name); },
.ExprIndex(x) => { .ExprIndex(&x) => {
var ptr = emit_lvalue(self, ref); var ptr = emit_lvalue(self, ref);
if ptr == 0 { ret 0; } if ptr == 0 { ret 0; }
ret IrBuilder.mem_load(self.ir, node_ir(self, n), ptr); ret IrBuilder.mem_load(self.ir, node_ir(self, n), ptr);
}, },
.ExprCast(x) => { ret emit_cast(self, n); }, .ExprCast(&x) => { ret emit_cast(self, n); },
.ExprTuple(x) => { ret emit_tuple(self, n, x.items); }, .ExprTuple(&x) => { ret emit_tuple(self, n, x.items); },
.ExprArrayLit(x) => { ret emit_array_lit(self, n, x.elems); }, .ExprArrayLit(&x) => { ret emit_array_lit(self, n, x.elems); },
.ExprAggregateLit(x) => { ret emit_aggregate_lit(self, n, x.name, x.fields); }, .ExprAggregateLit(&x) => { ret emit_aggregate_lit(self, n, x.name, x.fields); },
.ExprBlock(x) => { ret emit_block(self, n, x.stmts, x.tail_expr); }, .ExprBlock(&x) => { ret emit_block(self, n, x.stmts, x.tail_expr); },
.ExprIf(x) => { ret emit_if_like(self, ref); }, .ExprIf(&x) => { ret emit_if_like(self, ref); },
.ExprIfvar(x) => { ret emit_if_like(self, ref); }, .ExprIfvar(&x) => { ret emit_if_like(self, ref); },
.ExprMatch(x) => { ret emit_match(self, n, x.matched_expr, x.arms); }, .ExprMatch(&x) => { ret emit_match(self, n, x.matched_expr, x.arms); },
.ExprWhile(x) => { ret emit_loop_like(self, ref); }, .ExprWhile(&x) => { ret emit_loop_like(self, ref); },
.ExprLoop(x) => { ret emit_loop_like(self, ref); }, .ExprLoop(&x) => { ret emit_loop_like(self, ref); },
.ExprFor(x) => { .ExprFor(&x) => {
Diag.err(self.diag, n.span, .UnhandledNode, "for is not implemented yet"); Diag.err(self.diag, n.span, .UnhandledNode, "for is not implemented yet");
ret 0; ret 0;
}, },
.ExprSlice(x) => { ret emit_slice(self, n, x.obj, x.begin, x.end); }, .ExprSlice(&x) => { ret emit_slice(self, n, x.obj, x.begin, x.end); },
.ExprComptimeCall(x) => { .ExprComptimeCall(&x) => {
var in = IntrinOps.lookup_call(x.name); var in = IntrinOps.lookup_call(x.name);
if @enum2int(in) == @enum2int(Intrin.None) { ret 0; } if @enum2int(in) == @enum2int(Intrin.None) { ret 0; }
ret ast2ir_intrin_call(self, n, in, x.args); ret ast2ir_intrin_call(self, n, in, x.args);
@@ -1262,12 +1262,12 @@ fn emit_call(self: *Ast2Ir, n: *Node, callee_ref: usize, args: Vec): usize {
} }
fn is_ident(n: *Node): bool { fn is_ident(n: *Node): bool {
match n.body { .ExprIdent(x) => { ret true; }, _ => { ret false; } } match n.body { .ExprIdent(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
fn ident_name(n: *Node): ByteView { fn ident_name(n: *Node): ByteView {
match n.body { .ExprIdent(x) => { ret x.name; }, _ => { ret ByteView.empty(); } } match n.body { .ExprIdent(&x) => { ret x.name; }, _ => { ret ByteView.empty(); } }
ret ByteView.empty(); ret ByteView.empty();
} }
@@ -1688,7 +1688,7 @@ fn emit_if_like(self: *Ast2Ir, ref: usize): usize {
var n = Ast.node(self.ast, ref); var n = Ast.node(self.ast, ref);
if n == null { ret 0; } if n == null { ret 0; }
var is_ifvar = false; var is_ifvar = false;
match n.body { .ExprIfvar(x) => { is_ifvar = true; }, _ => {} } match n.body { .ExprIfvar(&x) => { is_ifvar = true; }, _ => {} }
var result_t = node_ir(self, n); var result_t = node_ir(self, n);
var need_result = false; var need_result = false;
@@ -1704,7 +1704,7 @@ fn emit_if_like(self: *Ast2Ir, ref: usize): usize {
var else_ref: usize = 0; var else_ref: usize = 0;
if is_ifvar { if is_ifvar {
var vd_ref: usize = 0; var vd_ref: usize = 0;
match n.body { .ExprIfvar(x) => { vd_ref = x.var_decl; }, _ => {} } match n.body { .ExprIfvar(&x) => { vd_ref = x.var_decl; }, _ => {} }
var vd = Ast.node(self.ast, vd_ref); var vd = Ast.node(self.ast, vd_ref);
if vd == null { ret 0; } if vd == null { ret 0; }
var slot = emit_var_decl(self, vd); var slot = emit_var_decl(self, vd);
@@ -1763,7 +1763,7 @@ fn emit_loop_like(self: *Ast2Ir, ref: usize): usize {
var n = Ast.node(self.ast, ref); var n = Ast.node(self.ast, ref);
if n == null { ret 0; } if n == null { ret 0; }
var is_while = false; var is_while = false;
match n.body { .ExprWhile(x) => { is_while = true; }, _ => {} } match n.body { .ExprWhile(&x) => { is_while = true; }, _ => {} }
var result_t = node_ir(self, n); var result_t = node_ir(self, n);
var need_result = false; var need_result = false;
@@ -1783,7 +1783,7 @@ fn emit_loop_like(self: *Ast2Ir, ref: usize): usize {
if is_while { if is_while {
head_blk = IrBuilder.block_begin(self.ir); head_blk = IrBuilder.block_begin(self.ir);
var cond: usize = 0; var cond: usize = 0;
match n.body { .ExprWhile(x) => { cond = emit_expr(self, x.cond); }, _ => {} } match n.body { .ExprWhile(&x) => { cond = emit_expr(self, x.cond); }, _ => {} }
if cond == 0 { ret 0; } if cond == 0 { ret 0; }
br = IrBuilder.control_br(self.ir, cond); br = IrBuilder.control_br(self.ir, cond);
IrBuilder.block_end(self.ir); IrBuilder.block_end(self.ir);
@@ -1884,7 +1884,7 @@ fn emit_break_stmt(self: *Ast2Ir, n: *Node): usize {
var lbl = ByteView.empty(); var lbl = ByteView.empty();
var expr_ref: usize = 0; var expr_ref: usize = 0;
match n.body { match n.body {
.StatementBreak(x) => { lbl = label_name_of(self, x.label); expr_ref = x.expr; }, .StatementBreak(&x) => { lbl = label_name_of(self, x.label); expr_ref = x.expr; },
_ => {}, _ => {},
} }
var target_index = self.loop_stack.len - 1; var target_index = self.loop_stack.len - 1;
@@ -1913,24 +1913,24 @@ fn emit_stmt(self: *Ast2Ir, ref: usize) {
var n = Ast.node(self.ast, ref); var n = Ast.node(self.ast, ref);
if n == null { ret; } if n == null { ret; }
match n.body { match n.body {
.StatementRet(x) => { .StatementRet(&x) => {
var ret_ir = to_ir_type(self, self.cur_ret_lang); var ret_ir = to_ir_type(self, self.cur_ret_lang);
var v: usize = 0; var v: usize = 0;
if x.expr != 0 { v = emit_expr(self, x.expr); } if x.expr != 0 { v = emit_expr(self, x.expr); }
emit_deferred_until(self, self.cur_defer_base); 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 { ignore_usize(IrBuilder.control_ret(self.ir, ret_ir, v)); }
}, },
.StatementDefer(x) => { if x.body != 0 { push_u(&self.defer_stack, x.body); } }, .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 { ignore_usize(emit_expr(self, x.body)); } },
.StatementDecl(x) => { if x.decl != 0 { emit_decl(self, x.decl); } }, .StatementDecl(&x) => { if x.decl != 0 { emit_decl(self, x.decl); } },
.StatementExpr(x) => { if x.expr != 0 { ignore_usize(emit_expr(self, x.expr)); } }, .StatementExpr(&x) => { if x.expr != 0 { ignore_usize(emit_expr(self, x.expr)); } },
.ExprIf(x) => { ignore_usize(emit_if_like(self, ref)); }, .ExprIf(&x) => { ignore_usize(emit_if_like(self, ref)); },
.ExprIfvar(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)); }, .ExprWhile(&x) => { ignore_usize(emit_loop_like(self, ref)); },
.ExprLoop(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)); }, .StatementBreak(&x) => { ignore_usize(emit_break_stmt(self, n)); },
.StatementContinue(x) => { emit_continue_stmt(self, n); }, .StatementContinue(&x) => { emit_continue_stmt(self, n); },
.ExprBlock(x) => { ignore_usize(emit_expr(self, ref)); }, .ExprBlock(&x) => { ignore_usize(emit_expr(self, ref)); },
_ => { ignore_usize(emit_expr(self, ref)); }, _ => { ignore_usize(emit_expr(self, ref)); },
} }
} }
@@ -1938,7 +1938,7 @@ fn emit_stmt(self: *Ast2Ir, ref: usize) {
fn emit_continue_stmt(self: *Ast2Ir, n: *Node) { fn emit_continue_stmt(self: *Ast2Ir, n: *Node) {
if self.loop_stack.len == 0 { ret; } if self.loop_stack.len == 0 { ret; }
var lbl = ByteView.empty(); var lbl = ByteView.empty();
match n.body { .StatementContinue(x) => { lbl = label_name_of(self, x.label); }, _ => {} } match n.body { .StatementContinue(&x) => { lbl = label_name_of(self, x.label); }, _ => {} }
var target_index = self.loop_stack.len - 1; var target_index = self.loop_stack.len - 1;
if lbl.len != 0 { target_index = find_loop_with_label(self, lbl); } if lbl.len != 0 { target_index = find_loop_with_label(self, lbl); }
if target_index == ~(0 as usize) { ret; } if target_index == ~(0 as usize) { ret; }
@@ -1957,8 +1957,8 @@ fn emit_decl(self: *Ast2Ir, ref: usize) {
var n = Ast.node(self.ast, ref); var n = Ast.node(self.ast, ref);
if n == null { ret; } if n == null { ret; }
match n.body { match n.body {
.VarDecl(x) => { if self.ir.current_fn != 0 { ignore_usize(emit_var_decl(self, n)); } }, .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)); } }, .ConstDecl(&x) => { if self.ir.current_fn != 0 { ignore_usize(emit_var_decl(self, n)); } },
_ => {}, _ => {},
} }
} }
@@ -1982,7 +1982,7 @@ fn emit_fn_reserve(self: *Ast2Ir, n: *Node): usize {
} }
fn fn_name_of(n: *Node): ByteView { fn fn_name_of(n: *Node): ByteView {
match n.body { .FnDecl(x) => { ret x.name; }, _ => { ret ByteView.empty(); } } match n.body { .FnDecl(&x) => { ret x.name; }, _ => { ret ByteView.empty(); } }
ret ByteView.empty(); ret ByteView.empty();
} }
@@ -2018,7 +2018,7 @@ fn emit_fn_body(self: *Ast2Ir, n: *Node) {
var params = Vec.blank(@sizeof(usize), @alignof(usize)); var params = Vec.blank(@sizeof(usize), @alignof(usize));
var body_ref: usize = 0; var body_ref: usize = 0;
match n.body { .FnDecl(x) => { params = x.params; body_ref = x.body; }, _ => {} } match n.body { .FnDecl(&x) => { params = x.params; body_ref = x.body; }, _ => {} }
var i: usize = 0; var i: usize = 0;
while i < params.len { while i < params.len {
var pref = list_at(params, i); var pref = list_at(params, i);
@@ -2071,7 +2071,7 @@ fn fn_ret(e: LangEntry): usize {
fn emit_aggregate_fns_reserve(self: *Ast2Ir, te: *Node) { fn emit_aggregate_fns_reserve(self: *Ast2Ir, te: *Node) {
var members = Vec.blank(@sizeof(usize), @alignof(usize)); var members = Vec.blank(@sizeof(usize), @alignof(usize));
match te.body { .TypeAggregate(x) => { members = x.members; }, _ => { ret; } } match te.body { .TypeAggregate(&x) => { members = x.members; }, _ => { ret; } }
var i: usize = 0; var i: usize = 0;
while i < members.len { while i < members.len {
var mn = Ast.node(self.ast, list_at(members, i)); var mn = Ast.node(self.ast, list_at(members, i));
@@ -2093,7 +2093,7 @@ fn emit_aggregate_fns_reserve(self: *Ast2Ir, te: *Node) {
fn emit_aggregate_fns_body(self: *Ast2Ir, te: *Node) { fn emit_aggregate_fns_body(self: *Ast2Ir, te: *Node) {
var members = Vec.blank(@sizeof(usize), @alignof(usize)); var members = Vec.blank(@sizeof(usize), @alignof(usize));
match te.body { .TypeAggregate(x) => { members = x.members; }, _ => { ret; } } match te.body { .TypeAggregate(&x) => { members = x.members; }, _ => { ret; } }
var i: usize = 0; var i: usize = 0;
while i < members.len { while i < members.len {
var mn = Ast.node(self.ast, list_at(members, i)); var mn = Ast.node(self.ast, list_at(members, i));
@@ -2114,7 +2114,7 @@ fn emit_aggregate_fns_body(self: *Ast2Ir, te: *Node) {
} }
fn is_type_aggregate(n: *Node): bool { fn is_type_aggregate(n: *Node): bool {
match n.body { .TypeAggregate(x) => { ret true; }, _ => { ret false; } } match n.body { .TypeAggregate(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
@@ -2123,14 +2123,14 @@ fn emit_container_reserve(self: *Ast2Ir, ref: usize) {
if n == null { ret; } if n == null { ret; }
var is_tlb = false; var is_tlb = false;
var tlb_block: usize = 0; var tlb_block: usize = 0;
match n.body { .TopLevelBlock(x) => { is_tlb = true; tlb_block = x.block; }, _ => {} } match n.body { .TopLevelBlock(&x) => { is_tlb = true; tlb_block = x.block; }, _ => {} }
if is_tlb { if is_tlb {
if tlb_block != 0 { emit_container_reserve(self, tlb_block); } if tlb_block != 0 { emit_container_reserve(self, tlb_block); }
ret; ret;
} }
var decls = Vec.blank(@sizeof(usize), @alignof(usize)); var decls = Vec.blank(@sizeof(usize), @alignof(usize));
var is_cm = false; var is_cm = false;
match n.body { .ContainerMembers(x) => { is_cm = true; decls = x.declarations; }, _ => {} } match n.body { .ContainerMembers(&x) => { is_cm = true; decls = x.declarations; }, _ => {} }
if !is_cm { ret; } if !is_cm { ret; }
var i: usize = 0; var i: usize = 0;
while i < decls.len { while i < decls.len {
@@ -2161,14 +2161,14 @@ fn emit_container_body(self: *Ast2Ir, ref: usize) {
if n == null { ret; } if n == null { ret; }
var is_tlb = false; var is_tlb = false;
var tlb_block: usize = 0; var tlb_block: usize = 0;
match n.body { .TopLevelBlock(x) => { is_tlb = true; tlb_block = x.block; }, _ => {} } match n.body { .TopLevelBlock(&x) => { is_tlb = true; tlb_block = x.block; }, _ => {} }
if is_tlb { if is_tlb {
if tlb_block != 0 { emit_container_body(self, tlb_block); } if tlb_block != 0 { emit_container_body(self, tlb_block); }
ret; ret;
} }
var decls = Vec.blank(@sizeof(usize), @alignof(usize)); var decls = Vec.blank(@sizeof(usize), @alignof(usize));
var is_cm = false; var is_cm = false;
match n.body { .ContainerMembers(x) => { is_cm = true; decls = x.declarations; }, _ => {} } match n.body { .ContainerMembers(&x) => { is_cm = true; decls = x.declarations; }, _ => {} }
if !is_cm { ret; } if !is_cm { ret; }
var i: usize = 0; var i: usize = 0;
while i < decls.len { while i < decls.len {
@@ -2195,7 +2195,7 @@ fn emit_container_body(self: *Ast2Ir, ref: usize) {
} }
fn is_pattern_ident(n: *Node): bool { fn is_pattern_ident(n: *Node): bool {
match n.body { .PatternIdent(x) => { ret true; }, _ => { ret false; } } match n.body { .PatternIdent(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
stage2/ir2vm.spl
+8 -8
View File
@@ -456,20 +456,20 @@ fn cg_swap(cg: *Cgen) { emit(cg, .Swap, .Void, 0); }
fn cg_gaddr(cg: *Cgen, idx: usize) { emit(cg, .Gaddr, .Void, idx); } fn cg_gaddr(cg: *Cgen, idx: usize) { emit(cg, .Gaddr, .Void, idx); }
fn cg_load_slot(cg: *Cgen, ref: usize, k: VmKind) { fn cg_load_slot(cg: *Cgen, ref: usize, k: VmKind) {
cg_laddr(cg, slot_result(&cg.frame, ref)); emit(cg, .Laddr, .Void, slot_result(&cg.frame, ref));
cg_load(cg, k); emit(cg, .Load, k, 0);
} }
fn cg_store_slot(cg: *Cgen, ref: usize, k: VmKind) { fn cg_store_slot(cg: *Cgen, ref: usize, k: VmKind) {
cg_laddr(cg, slot_result(&cg.frame, ref)); emit(cg, .Laddr, .Void, slot_result(&cg.frame, ref));
cg_swap(cg); emit(cg, .Swap, .Void, 0);
cg_store(cg, k); emit(cg, .Store, k, 0);
} }
fn cg_store_at(cg: *Cgen, addr: usize, k: VmKind) { fn cg_store_at(cg: *Cgen, addr: usize, k: VmKind) {
cg_laddr(cg, addr); emit(cg, .Laddr, .Void, addr);
cg_swap(cg); emit(cg, .Swap, .Void, 0);
cg_store(cg, k); emit(cg, .Store, k, 0);
} }
type DataLoc = struct { type DataLoc = struct {
stage2/mcode.spl
+25 -23
View File
@@ -572,33 +572,34 @@ fn encode(self: *Prog, out: *ByteBuffer): Status {
// 精确预估输出大小并一次性预留，避免大文件逐字节增长导致的重复拷贝。 // 精确预估输出大小并一次性预留，避免大文件逐字节增长导致的重复拷贝。
var total: usize = 48; var total: usize = 48;
var fi: usize = 0; var fi: usize = 0;
var func_base = self.funcs.data as *VmFunc;
var nat_base = self.natives.data as *VmNative;
var str_base = self.strtab.data as *ByteView;
var gd_base = self.gdata.data as *ByteBuffer;
while fi < self.funcs.len { while fi < self.funcs.len {
var f = func_at(self, fi); var f = func_base + fi;
if f != null {
var nlen = f.name.len + 1; var nlen = f.name.len + 1;
total = total + 8 + align8(nlen) + 32; total = total + 8 + align8(nlen) + 32;
}
fi = fi + 1; fi = fi + 1;
} }
total = total + self.insns.len * 12; total = total + self.insns.len * 12;
fi = 0; fi = 0;
while fi < self.natives.len { while fi < self.natives.len {
var n = native_at(self, fi); var n = nat_base + fi;
if n != null {
var nlen = n.name.len + 1; var nlen = n.name.len + 1;
total = total + 8 + align8(nlen) + 8; total = total + 8 + align8(nlen) + 8;
}
fi = fi + 1; fi = fi + 1;
} }
fi = 0; fi = 0;
while fi < self.strtab.len { while fi < self.strtab.len {
total = total + 8 + align8(str_at(self, fi).len); var s = str_base + fi;
total = total + 8 + align8(s.len);
fi = fi + 1; fi = fi + 1;
} }
fi = 1; fi = 1;
while fi < self.gdata.len { while fi < self.gdata.len {
var e = gdata_at(self, fi); var e = gd_base + fi;
if e != null { total = total + 8 + align8(e.storage.len); } total = total + 8 + align8(e.storage.len);
fi = fi + 1; fi = fi + 1;
} }
match ByteBuffer.reserve(out, total) { .Ok => {}, .Err(error) => {} } match ByteBuffer.reserve(out, total) { .Ok => {}, .Err(error) => {} }
@@ -622,8 +623,7 @@ fn encode(self: *Prog, out: *ByteBuffer): Status {
var i: usize = 0; var i: usize = 0;
while i < nfuncs { while i < nfuncs {
var f = func_at(self, i); var f = func_base + i;
if f == null { ret .Err(make(.Io)); }
if !put_name_field(out, f.name) { ret .Err(make(.Io)); } if !put_name_field(out, f.name) { ret .Err(make(.Io)); }
if !put_u64(out, f.idx_of_strtab) { ret .Err(make(.Io)); } if !put_u64(out, f.idx_of_strtab) { ret .Err(make(.Io)); }
if !put_u64(out, f.nargs) { ret .Err(make(.Io)); } if !put_u64(out, f.nargs) { ret .Err(make(.Io)); }
@@ -633,20 +633,23 @@ fn encode(self: *Prog, out: *ByteBuffer): Status {
} }
i = 0; i = 0;
var ins_base = self.insns.data as *VmIns;
var out_base = out.storage.data;
var out_len = out.storage.len;
while i < ninsns { while i < ninsns {
var ins = ins_at(self, i); var p = ins_base + i;
var d = out.storage.data + out.storage.len; var d = out_base + out_len;
(d as *u16).* = @enum2int(ins.opcode) as u16; (d as *u16).* = @enum2int(p.opcode) as u16;
((d + 2) as *u16).* = @enum2int(ins.ty) as u16; ((d + 2) as *u16).* = @enum2int(p.ty) as u16;
((d + 4) as *u64).* = ins.imm as u64; ((d + 4) as *u64).* = p.imm as u64;
out.storage.len = out.storage.len + 12; out_len = out_len + 12;
i = i + 1; i = i + 1;
} }
out.storage.len = out_len;
i = 0; i = 0;
while i < nnatives { while i < nnatives {
var n = native_at(self, i); var n = nat_base + i;
if n == null { ret .Err(make(.Io)); }
if !put_name_field(out, n.name) { ret .Err(make(.Io)); } if !put_name_field(out, n.name) { ret .Err(make(.Io)); }
if !put_u64(out, n.idx_of_strtab) { ret .Err(make(.Io)); } if !put_u64(out, n.idx_of_strtab) { ret .Err(make(.Io)); }
i = i + 1; i = i + 1;
@@ -654,17 +657,16 @@ fn encode(self: *Prog, out: *ByteBuffer): Status {
i = 0; i = 0;
while i < nstrs { while i < nstrs {
var s = str_at(self, i); var s = str_base + i;
if !put_u64(out, s.len) { ret .Err(make(.Io)); } if !put_u64(out, s.len) { ret .Err(make(.Io)); }
if !put_view(out, s) { ret .Err(make(.Io)); } if !put_view(out, s.*) { ret .Err(make(.Io)); }
if !put_zeros(out, align8(s.len) - s.len) { ret .Err(make(.Io)); } if !put_zeros(out, align8(s.len) - s.len) { ret .Err(make(.Io)); }
i = i + 1; i = i + 1;
} }
i = 1; i = 1;
while i < self.gdata.len { while i < self.gdata.len {
var e = gdata_at(self, i); var e = gd_base + i;
if e == null { ret .Err(make(.Io)); }
var dsize = e.storage.len; var dsize = e.storage.len;
if !put_u64(out, dsize) { ret .Err(make(.Io)); } if !put_u64(out, dsize) { ret .Err(make(.Io)); }
if !put_view(out, ByteView.from_slice(ByteBuffer.as_slice(e.*))) { ret .Err(make(.Io)); } if !put_view(out, ByteView.from_slice(ByteBuffer.as_slice(e.*))) { ret .Err(make(.Io)); }
stage2/sema.spl
+89 -89
View File
@@ -337,13 +337,13 @@ fn resolve_attr_item(self: *Sema, a: *Node): usize {
fn resolve_attrs(self: *Sema, n: *Node) { fn resolve_attrs(self: *Sema, n: *Node) {
if n.attrs.len != 0 { ret; } if n.attrs.len != 0 { ret; }
match n.body { match n.body {
.FnDecl(x) => { node_attr_raw(self, n, x.tag_list); }, .FnDecl(&x) => { node_attr_raw(self, n, x.tag_list); },
.VarDecl(x) => { node_attr_raw(self, n, x.attr_list); }, .VarDecl(&x) => { node_attr_raw(self, n, x.attr_list); },
.ConstDecl(x) => { node_attr_raw(self, n, x.attr_list); }, .ConstDecl(&x) => { node_attr_raw(self, n, x.attr_list); },
.TypeDecl(x) => { node_attr_raw(self, n, x.attr_list); }, .TypeDecl(&x) => { node_attr_raw(self, n, x.attr_list); },
.MemberDecl(x) => { node_attr_raw(self, n, x.attr_list); }, .MemberDecl(&x) => { node_attr_raw(self, n, x.attr_list); },
.ParamDecl(x) => { node_attr_raw(self, n, x.attr_list); }, .ParamDecl(&x) => { node_attr_raw(self, n, x.attr_list); },
.TopLevelBlock(x) => { node_attr_raw(self, n, x.tag_list); }, .TopLevelBlock(&x) => { node_attr_raw(self, n, x.tag_list); },
_ => {}, _ => {},
} }
} }
@@ -353,7 +353,7 @@ fn resolve_attrs(self: *Sema, n: *Node) {
fn build_aggregate(self: *Sema, te: *Node, owner_def_id: usize): usize { fn build_aggregate(self: *Sema, te: *Node, owner_def_id: usize): usize {
var kind_name = ByteView.empty(); var kind_name = ByteView.empty();
match te.body { match te.body {
.TypeAggregate(x) => { kind_name = x.kind_name; }, .TypeAggregate(&x) => { kind_name = x.kind_name; },
_ => {}, _ => {},
} }
var lk: LangKind = .Struct; var lk: LangKind = .Struct;
@@ -389,7 +389,7 @@ fn build_aggregate(self: *Sema, te: *Node, owner_def_id: usize): usize {
var mlist = ref_vec(); var mlist = ref_vec();
match te.body { match te.body {
.TypeAggregate(x) => { mlist = x.members; }, .TypeAggregate(&x) => { mlist = x.members; },
_ => {}, _ => {},
} }
var i: usize = 0; var i: usize = 0;
@@ -554,41 +554,41 @@ fn container_var_method(self: *Sema, pat_ref: usize, methods: *Vec) {
} }
fn is_pattern_ident(n: *Node): bool { fn is_pattern_ident(n: *Node): bool {
match n.body { .PatternIdent(x) => { ret true; }, _ => { ret false; } } match n.body { .PatternIdent(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
fn is_type_aggregate(n: *Node): bool { fn is_type_aggregate(n: *Node): bool {
match n.body { .TypeAggregate(x) => { ret true; }, _ => { ret false; } } match n.body { .TypeAggregate(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
fn is_param_decl(n: *Node): bool { fn is_param_decl(n: *Node): bool {
match n.body { .ParamDecl(x) => { ret true; }, _ => { ret false; } } match n.body { .ParamDecl(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
fn is_type_decl(n: *Node): bool { fn is_type_decl(n: *Node): bool {
match n.body { .TypeDecl(x) => { ret true; }, _ => { ret false; } } match n.body { .TypeDecl(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
fn is_pattern_field(n: *Node): bool { fn is_pattern_field(n: *Node): bool {
match n.body { .PatternField(x) => { ret true; }, _ => { ret false; } } match n.body { .PatternField(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
fn is_expr_string_lit(n: *Node): bool { fn is_expr_string_lit(n: *Node): bool {
match n.body { .ExprStringLit(x) => { ret true; }, _ => { ret false; } } match n.body { .ExprStringLit(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
fn is_expr_ident(n: *Node): bool { fn is_expr_ident(n: *Node): bool {
match n.body { .ExprIdent(x) => { ret true; }, _ => { ret false; } } match n.body { .ExprIdent(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
fn is_expr_int_lit(n: *Node): bool { fn is_expr_int_lit(n: *Node): bool {
match n.body { .ExprIntLit(x) => { ret true; }, _ => { ret false; } } match n.body { .ExprIntLit(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
fn pattern_name(pat: *Node): ByteView { fn pattern_name(pat: *Node): ByteView {
match pat.body { match pat.body {
.PatternIdent(x) => { ret x.name; }, .PatternIdent(&x) => { ret x.name; },
_ => { ret ByteView.empty(); }, _ => { ret ByteView.empty(); },
} }
} }
@@ -774,7 +774,7 @@ fn infer_fn_signature(self: *Sema, n: *Node): usize {
var pd = node(self, list_at(params_list, i)); var pd = node(self, list_at(params_list, i));
if pd != null && is_param_decl(pd) { if pd != null && is_param_decl(pd) {
var tref: usize = 0; var tref: usize = 0;
match pd.body { .ParamDecl(x) => { tref = x.type_expr; }, _ => {} } match pd.body { .ParamDecl(&x) => { tref = x.type_expr; }, _ => {} }
if tref != 0 { if tref != 0 {
push_u(&params, infer(self, tref)); push_u(&params, infer(self, tref));
} else { } else {
@@ -951,7 +951,7 @@ fn infer_type_context(self: *Sema, ref: usize): usize {
var n = node(self, ref); var n = node(self, ref);
if n == null { ret 0; } if n == null { ret 0; }
match n.body { match n.body {
.ExprIdent(x) => { .ExprIdent(&x) => {
var builtin = LangType.lookup_builtin(&self.types, x.name); var builtin = LangType.lookup_builtin(&self.types, x.name);
if builtin != 0 { if builtin != 0 {
n.resolved_lang_tid = builtin; n.resolved_lang_tid = builtin;
@@ -971,7 +971,7 @@ fn infer_type_context(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
ret t; ret t;
}, },
.ExprField(x) => { .ExprField(&x) => {
var owner_id = infer_type_context(self, x.obj); var owner_id = infer_type_context(self, x.obj);
var owner = lang_of(self, owner_id); var owner = lang_of(self, owner_id);
if owner == null { ret 0; } if owner == null { ret 0; }
@@ -990,7 +990,7 @@ fn infer_type_context(self: *Sema, ref: usize): usize {
diag_name(self, n.span, .TypeMismatch, "not a type member `", x.name); diag_name(self, n.span, .TypeMismatch, "not a type member `", x.name);
ret 0; ret 0;
}, },
.ExprUnary(x) => { .ExprUnary(&x) => {
if punct_is(x.op, .Mul) { if punct_is(x.op, .Mul) {
var pointee = infer_type_context(self, x.operand); var pointee = infer_type_context(self, x.operand);
if pointee == 0 { ret 0; } if pointee == 0 { ret 0; }
@@ -1000,7 +1000,7 @@ fn infer_type_context(self: *Sema, ref: usize): usize {
} }
ret 0; ret 0;
}, },
.ExprTuple(x) => { .ExprTuple(&x) => {
var elems = ref_vec(); var elems = ref_vec();
var i: usize = 0; var i: usize = 0;
while i < x.items.len { while i < x.items.len {
@@ -1013,7 +1013,7 @@ fn infer_type_context(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = r; n.resolved_lang_tid = r;
ret r; ret r;
}, },
.ExprComptimeCall(x) => { .ExprComptimeCall(&x) => {
var r = infer(self, ref); var r = infer(self, ref);
n.resolved_lang_tid = r; n.resolved_lang_tid = r;
ret r; ret r;
@@ -1160,7 +1160,7 @@ fn intrin_call(self: *Sema, n: *Node, in: Intrin, args: Vec): usize {
if fnode == null { ret 0; } if fnode == null { ret 0; }
if is_expr_ident(fnode) { if is_expr_ident(fnode) {
var fname = ByteView.empty(); var fname = ByteView.empty();
match fnode.body { .ExprIdent(x) => { fname = x.name; }, _ => {} } match fnode.body { .ExprIdent(&x) => { fname = x.name; }, _ => {} }
var idx: usize = 0; var idx: usize = 0;
if !TypeTable.agg_member_idx(&self.types.ir, agg_ir, fname, &idx) { if !TypeTable.agg_member_idx(&self.types.ir, agg_ir, fname, &idx) {
diag_name(self, n.span, .NoField, "no field `", fname); diag_name(self, n.span, .NoField, "no field `", fname);
@@ -1681,13 +1681,13 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
var result: usize = 0; var result: usize = 0;
match n.body { match n.body {
.ExprUnary(x) => { .ExprUnary(&x) => {
if !(punct_is(x.op, .And) || punct_is(x.op, .Mul)) { if !(punct_is(x.op, .And) || punct_is(x.op, .Mul)) {
handled = true; handled = true;
result = coerce(self, x.operand, expected); result = coerce(self, x.operand, expected);
} }
}, },
.ExprBinary(x) => { .ExprBinary(&x) => {
handled = true; handled = true;
var op = x.op; var op = x.op;
if punct_is(op, .Assign) || is_assign_arith(op) { if punct_is(op, .Assign) || is_assign_arith(op) {
@@ -1744,7 +1744,7 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
result = expected; result = expected;
} }
}, },
.ExprArrayLit(x) => { .ExprArrayLit(&x) => {
var en = lang_of(self, expected); var en = lang_of(self, expected);
if en != null && (kind_is(self, expected, .Array) || kind_is(self, expected, .Slice)) { if en != null && (kind_is(self, expected, .Array) || kind_is(self, expected, .Slice)) {
handled = true; handled = true;
@@ -1757,7 +1757,7 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
result = expected; result = expected;
} }
}, },
.ExprTuple(x) => { .ExprTuple(&x) => {
var en = lang_of(self, expected); var en = lang_of(self, expected);
if en != null && kind_is(self, expected, .Tuple) { if en != null && kind_is(self, expected, .Tuple) {
handled = true; handled = true;
@@ -1775,7 +1775,7 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
result = expected; result = expected;
} }
}, },
.ExprAggregateLit(x) => { .ExprAggregateLit(&x) => {
var en = lang_of(self, expected); var en = lang_of(self, expected);
if en != null && (kind_is(self, expected, .Struct) || kind_is(self, expected, .Union) || if en != null && (kind_is(self, expected, .Struct) || kind_is(self, expected, .Union) ||
kind_is(self, expected, .Enum) || kind_is(self, expected, .Slice)) { kind_is(self, expected, .Enum) || kind_is(self, expected, .Slice)) {
@@ -1806,7 +1806,7 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
} }
var iname = ByteView.empty(); var iname = ByteView.empty();
var iexpr: usize = 0; var iexpr: usize = 0;
match item.body { .StructInitItem(si) => { iname = si.name; iexpr = si.expr; }, _ => {} } match item.body { .StructInitItem(&si) => { iname = si.name; iexpr = si.expr; }, _ => {} }
var idx: usize = 0; var idx: usize = 0;
if !TypeTable.agg_member_idx(&self.types.ir, agg_ir, iname, &idx) { if !TypeTable.agg_member_idx(&self.types.ir, agg_ir, iname, &idx) {
diag_name(self, item.span, .NoField, "no variant `", iname); diag_name(self, item.span, .NoField, "no variant `", iname);
@@ -1825,7 +1825,7 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
if item != null && kind_is_body_struct_init(item) { if item != null && kind_is_body_struct_init(item) {
var iname = ByteView.empty(); var iname = ByteView.empty();
var iexpr: usize = 0; var iexpr: usize = 0;
match item.body { .StructInitItem(si) => { iname = si.name; iexpr = si.expr; }, _ => {} } match item.body { .StructInitItem(&si) => { iname = si.name; iexpr = si.expr; }, _ => {} }
var idx: usize = 0; var idx: usize = 0;
if !TypeTable.agg_member_idx(&self.types.ir, agg_ir, iname, &idx) { if !TypeTable.agg_member_idx(&self.types.ir, agg_ir, iname, &idx) {
diag_name(self, item.span, .NoField, "no field `", iname); diag_name(self, item.span, .NoField, "no field `", iname);
@@ -1845,7 +1845,7 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
} }
} }
}, },
.ExprIf(x) => { .ExprIf(&x) => {
handled = true; handled = true;
var bt = make_bool(self); var bt = make_bool(self);
ignore_usize(coerce(self, x.cond, bt)); ignore_usize(coerce(self, x.cond, bt));
@@ -1853,7 +1853,7 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
if x.else_branch != 0 { ignore_usize(coerce(self, x.else_branch, expected)); } if x.else_branch != 0 { ignore_usize(coerce(self, x.else_branch, expected)); }
result = expected; result = expected;
}, },
.ExprLoop(x) => { .ExprLoop(&x) => {
handled = true; handled = true;
var saved = self.current_loop_break_tid; var saved = self.current_loop_break_tid;
self.current_loop_break_tid = expected; self.current_loop_break_tid = expected;
@@ -1861,7 +1861,7 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
self.current_loop_break_tid = saved; self.current_loop_break_tid = saved;
result = expected; result = expected;
}, },
.ExprBlock(x) => { .ExprBlock(&x) => {
ret block_body(self, n, expected); ret block_body(self, n, expected);
}, },
_ => {}, _ => {},
@@ -1881,7 +1881,7 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
if is_expr_int_lit(n) && int_bits(self, expected) != 0 { if is_expr_int_lit(n) && int_bits(self, expected) != 0 {
var fits = true; var fits = true;
match n.body { match n.body {
.ExprIntLit(v) => { .ExprIntLit(&v) => {
if !LangType.int_fits(&self.types, expected, v.value) { fits = false; } if !LangType.int_fits(&self.types, expected, v.value) { fits = false; }
}, },
_ => {}, _ => {},
@@ -1916,7 +1916,7 @@ fn elem_of_lang(e: LangEntry): usize {
} }
fn kind_is_body_struct_init(n: *Node): bool { fn kind_is_body_struct_init(n: *Node): bool {
match n.body { .StructInitItem(x) => { ret true; }, _ => { ret false; } } match n.body { .StructInitItem(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
@@ -1929,28 +1929,28 @@ fn infer(self: *Sema, ref: usize): usize {
resolve_attrs(self, n); resolve_attrs(self, n);
match n.body { match n.body {
.ExprIntLit(x) => { .ExprIntLit(&x) => {
var t = LangType.make_int(&self.types, 0, true); var t = LangType.make_int(&self.types, 0, true);
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
ret t; ret t;
}, },
.ExprFloatLit(x) => { .ExprFloatLit(&x) => {
var t = LangType.make_float(&self.types, 0); var t = LangType.make_float(&self.types, 0);
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
ret t; ret t;
}, },
.ExprCharLit(x) => { .ExprCharLit(&x) => {
var t = LangType.make_int(&self.types, 8, false); var t = LangType.make_int(&self.types, 8, false);
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
ret t; ret t;
}, },
.ExprStringLit(x) => { .ExprStringLit(&x) => {
var u8t = LangType.make_int(&self.types, 8, false); var u8t = LangType.make_int(&self.types, 8, false);
var s = LangType.make_slice(&self.types, u8t); var s = LangType.make_slice(&self.types, u8t);
n.resolved_lang_tid = s; n.resolved_lang_tid = s;
ret s; ret s;
}, },
.ExprBoolLit(x) => { .ExprBoolLit(&x) => {
var t = make_bool(self); var t = make_bool(self);
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
ret t; ret t;
@@ -1966,7 +1966,7 @@ fn infer(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
ret t; ret t;
}, },
.ExprIdent(x) => { .ExprIdent(&x) => {
var sym = Symbol { .name = ByteView.empty(), .kind = .Error, .node = 0 }; var sym = Symbol { .name = ByteView.empty(), .kind = .Error, .node = 0 };
if !Scope.find(&self.scope, x.name, &sym) { if !Scope.find(&self.scope, x.name, &sym) {
diag_name(self, n.span, .UndefinedSymbol, "undefined identifier `", x.name); diag_name(self, n.span, .UndefinedSymbol, "undefined identifier `", x.name);
@@ -1981,7 +1981,7 @@ fn infer(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
ret t; ret t;
}, },
.ExprUnary(x) => { .ExprUnary(&x) => {
var op = infer(self, x.operand); var op = infer(self, x.operand);
if op == 0 { ret 0; } if op == 0 { ret 0; }
var tn = lang_of(self, op); var tn = lang_of(self, op);
@@ -2032,25 +2032,25 @@ fn infer(self: *Sema, ref: usize): usize {
} }
ret 0; ret 0;
}, },
.ExprBinary(x) => { .ExprBinary(&x) => {
ret infer_binary(self, n, x.op, x.left, x.right); ret infer_binary(self, n, x.op, x.left, x.right);
}, },
.ExprCall(x) => { .ExprCall(&x) => {
ret infer_call(self, n, x.callee, x.args); ret infer_call(self, n, x.callee, x.args);
}, },
.ExprField(x) => { .ExprField(&x) => {
ret infer_field(self, n, x.obj, x.name); ret infer_field(self, n, x.obj, x.name);
}, },
.ExprIndex(x) => { .ExprIndex(&x) => {
ret infer_index(self, n, x.obj, x.index); ret infer_index(self, n, x.obj, x.index);
}, },
.ExprSlice(x) => { .ExprSlice(&x) => {
ret infer_slice(self, n, x.obj, x.begin, x.end); ret infer_slice(self, n, x.obj, x.begin, x.end);
}, },
.ExprCast(x) => { .ExprCast(&x) => {
ret infer_cast(self, n, x.expr, x.type_expr); ret infer_cast(self, n, x.expr, x.type_expr);
}, },
.ExprTuple(x) => { .ExprTuple(&x) => {
var es = ref_vec(); var es = ref_vec();
var i: usize = 0; var i: usize = 0;
while i < x.items.len { while i < x.items.len {
@@ -2061,13 +2061,13 @@ fn infer(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
ret t; ret t;
}, },
.ExprArrayLit(x) => { .ExprArrayLit(&x) => {
ret infer_array(self, n, x.elem_type, x.has_len, x.len, x.is_underscore_len, x.elems); ret infer_array(self, n, x.elem_type, x.has_len, x.len, x.is_underscore_len, x.elems);
}, },
.ExprAggregateLit(x) => { .ExprAggregateLit(&x) => {
ret infer_aggregate(self, n, x.name, x.fields); ret infer_aggregate(self, n, x.name, x.fields);
}, },
.ExprComptimeCall(x) => { .ExprComptimeCall(&x) => {
if ByteView.eq(x.name, ByteView.from_slice("import")) { if ByteView.eq(x.name, ByteView.from_slice("import")) {
var t = sema_import(self, n, x.args); var t = sema_import(self, n, x.args);
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
@@ -2090,10 +2090,10 @@ fn infer(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
ret t; ret t;
}, },
.ExprBlock(x) => { .ExprBlock(&x) => {
ret block_body(self, n, 0); ret block_body(self, n, 0);
}, },
.ExprIf(x) => { .ExprIf(&x) => {
var bt = make_bool(self); var bt = make_bool(self);
ignore_usize(coerce(self, x.cond, bt)); ignore_usize(coerce(self, x.cond, bt));
var then_t = if x.then_block != 0 { infer(self, x.then_block) } else { 0 }; var then_t = if x.then_block != 0 { infer(self, x.then_block) } else { 0 };
@@ -2109,7 +2109,7 @@ fn infer(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = result; n.resolved_lang_tid = result;
ret result; ret result;
}, },
.ExprIfvar(x) => { .ExprIfvar(&x) => {
if x.var_decl == 0 { ret 0; } if x.var_decl == 0 { ret 0; }
var vd = node(self, x.var_decl); var vd = node(self, x.var_decl);
if vd == null { ret 0; } if vd == null { ret 0; }
@@ -2120,7 +2120,7 @@ fn infer(self: *Sema, ref: usize): usize {
if x.else_branch != 0 { ignore_usize(infer(self, x.else_branch)); } if x.else_branch != 0 { ignore_usize(infer(self, x.else_branch)); }
ret 0; ret 0;
}, },
.ExprWhile(x) => { .ExprWhile(&x) => {
push_view(&self.label_stack, label_name(self, x.label)); push_view(&self.label_stack, label_name(self, x.label));
var bt = make_bool(self); var bt = make_bool(self);
ignore_usize(coerce(self, x.cond, bt)); ignore_usize(coerce(self, x.cond, bt));
@@ -2129,16 +2129,16 @@ fn infer(self: *Sema, ref: usize): usize {
pop_label(self); pop_label(self);
ret 0; ret 0;
}, },
.ExprLoop(x) => { .ExprLoop(&x) => {
push_view(&self.label_stack, label_name(self, x.label)); push_view(&self.label_stack, label_name(self, x.label));
if x.body != 0 { ignore_usize(infer(self, x.body)); } if x.body != 0 { ignore_usize(infer(self, x.body)); }
pop_label(self); pop_label(self);
ret 0; ret 0;
}, },
.ExprFor(x) => { .ExprFor(&x) => {
ret infer_for(self, n, x.label, x.iter_exprs, x.pattern, x.body, x.else_branch); ret infer_for(self, n, x.label, x.iter_exprs, x.pattern, x.body, x.else_branch);
}, },
.ExprMatch(x) => { .ExprMatch(&x) => {
var matched = infer(self, x.matched_expr); var matched = infer(self, x.matched_expr);
var i: usize = 0; var i: usize = 0;
while i < x.arms.len { while i < x.arms.len {
@@ -2162,7 +2162,7 @@ fn infer(self: *Sema, ref: usize): usize {
} }
ret 0; ret 0;
}, },
.ExprFnType(x) => { .ExprFnType(&x) => {
var ps = ref_vec(); var ps = ref_vec();
var i: usize = 0; var i: usize = 0;
while i < x.params.len { while i < x.params.len {
@@ -2174,7 +2174,7 @@ fn infer(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = fn_lang; n.resolved_lang_tid = fn_lang;
ret fn_lang; ret fn_lang;
}, },
.TypePath(x) => { .TypePath(&x) => {
var b = LangType.lookup_builtin(&self.types, x.name); var b = LangType.lookup_builtin(&self.types, x.name);
if b != 0 { if b != 0 {
n.resolved_lang_tid = b; n.resolved_lang_tid = b;
@@ -2189,13 +2189,13 @@ fn infer(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
ret t; ret t;
}, },
.TypePointer(x) => { .TypePointer(&x) => {
var p = infer(self, x.pointee); var p = infer(self, x.pointee);
var r = LangType.make_ptr(&self.types, p); var r = LangType.make_ptr(&self.types, p);
n.resolved_lang_tid = r; n.resolved_lang_tid = r;
ret r; ret r;
}, },
.TypeArray(x) => { .TypeArray(&x) => {
var e = infer(self, x.elem_type); var e = infer(self, x.elem_type);
var len: usize = 0; var len: usize = 0;
if x.has_len { len = x.len as usize; } if x.has_len { len = x.len as usize; }
@@ -2203,13 +2203,13 @@ fn infer(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = r; n.resolved_lang_tid = r;
ret r; ret r;
}, },
.TypeSlice(x) => { .TypeSlice(&x) => {
var e = infer(self, x.elem_type); var e = infer(self, x.elem_type);
var r = LangType.make_slice(&self.types, e); var r = LangType.make_slice(&self.types, e);
n.resolved_lang_tid = r; n.resolved_lang_tid = r;
ret r; ret r;
}, },
.TypeFn(x) => { .TypeFn(&x) => {
var ps = ref_vec(); var ps = ref_vec();
var i: usize = 0; var i: usize = 0;
while i < x.params.len { while i < x.params.len {
@@ -2221,7 +2221,7 @@ fn infer(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = r; n.resolved_lang_tid = r;
ret r; ret r;
}, },
.TypeParen(x) => { .TypeParen(&x) => {
if x.types.len == 0 { if x.types.len == 0 {
var u = make_unit(self); var u = make_unit(self);
n.resolved_lang_tid = u; n.resolved_lang_tid = u;
@@ -2242,10 +2242,10 @@ fn infer(self: *Sema, ref: usize): usize {
n.resolved_lang_tid = t; n.resolved_lang_tid = t;
ret t; ret t;
}, },
.TypeAggregate(x) => { .TypeAggregate(&x) => {
ret build_aggregate(self, n, 0); ret build_aggregate(self, n, 0);
}, },
.TypeComptimeCall(x) => { .TypeComptimeCall(&x) => {
if ByteView.eq(x.name, ByteView.from_slice("self")) { if ByteView.eq(x.name, ByteView.from_slice("self")) {
if self.current_aggregate_lang == 0 { if self.current_aggregate_lang == 0 {
diag(self, n.span, .UndefinedSymbol, "`@self` outside of aggregate"); diag(self, n.span, .UndefinedSymbol, "`@self` outside of aggregate");
@@ -2261,7 +2261,7 @@ fn infer(self: *Sema, ref: usize): usize {
} }
ret 0; ret 0;
}, },
.ContainerMembers(x) => { .ContainerMembers(&x) => {
var i: usize = 0; var i: usize = 0;
while i < x.declarations.len { while i < x.declarations.len {
ignore_usize(infer(self, list_at(x.declarations, i))); ignore_usize(infer(self, list_at(x.declarations, i)));
@@ -2269,48 +2269,48 @@ fn infer(self: *Sema, ref: usize): usize {
} }
ret 0; ret 0;
}, },
.FnDecl(x) => { .FnDecl(&x) => {
ret infer_fn_decl(self, n, x.params, x.ret_type, x.body); ret infer_fn_decl(self, n, x.params, x.ret_type, x.body);
}, },
.TypeDecl(x) => { .TypeDecl(&x) => {
ret infer_type_decl(self, n, x.pattern, x.type_expr); ret infer_type_decl(self, n, x.pattern, x.type_expr);
}, },
.VarDecl(x) => { ret var_body(self, n); }, .VarDecl(&x) => { ret var_body(self, n); },
.ConstDecl(x) => { ret var_body(self, n); }, .ConstDecl(&x) => { ret var_body(self, n); },
.MemberDecl(x) => { .MemberDecl(&x) => {
if x.type_expr != 0 { ret infer(self, x.type_expr); } if x.type_expr != 0 { ret infer(self, x.type_expr); }
ret 0; ret 0;
}, },
.ParamDecl(x) => { .ParamDecl(&x) => {
if x.type_expr != 0 { ret infer(self, x.type_expr); } if x.type_expr != 0 { ret infer(self, x.type_expr); }
ret 0; ret 0;
}, },
.StatementRet(x) => { .StatementRet(&x) => {
ret infer_ret(self, n, x.expr); ret infer_ret(self, n, x.expr);
}, },
.StatementBreak(x) => { .StatementBreak(&x) => {
ret infer_break(self, n, x.label, x.expr); ret infer_break(self, n, x.label, x.expr);
}, },
.StatementContinue(x) => { .StatementContinue(&x) => {
ret infer_continue(self, n, x.label); ret infer_continue(self, n, x.label);
}, },
.StatementDefer(x) => { .StatementDefer(&x) => {
if x.body != 0 { ignore_usize(infer(self, x.body)); } if x.body != 0 { ignore_usize(infer(self, x.body)); }
ret 0; ret 0;
}, },
.StatementComptime(x) => { .StatementComptime(&x) => {
if x.body != 0 { ignore_usize(infer(self, x.body)); } if x.body != 0 { ignore_usize(infer(self, x.body)); }
ret 0; ret 0;
}, },
.StatementDecl(x) => { .StatementDecl(&x) => {
if x.decl != 0 { ignore_usize(infer(self, x.decl)); } if x.decl != 0 { ignore_usize(infer(self, x.decl)); }
ret 0; ret 0;
}, },
.StatementExpr(x) => { .StatementExpr(&x) => {
if x.expr != 0 { ignore_usize(infer(self, x.expr)); } if x.expr != 0 { ignore_usize(infer(self, x.expr)); }
ret 0; ret 0;
}, },
.TopLevelBlock(x) => { .TopLevelBlock(&x) => {
if x.block != 0 { ignore_usize(infer(self, x.block)); } if x.block != 0 { ignore_usize(infer(self, x.block)); }
ret 0; ret 0;
}, },
@@ -2320,7 +2320,7 @@ fn infer(self: *Sema, ref: usize): usize {
} }
fn kind_is_body_ident(n: *Node): bool { fn kind_is_body_ident(n: *Node): bool {
match n.body { .ExprIdent(x) => { ret true; }, _ => { ret false; } } match n.body { .ExprIdent(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
@@ -2614,7 +2614,7 @@ fn infer_cast(self: *Sema, n: *Node, expr_ref: usize, type_ref: usize): usize {
} }
fn is_expr_float_lit(n: *Node): bool { fn is_expr_float_lit(n: *Node): bool {
match n.body { .ExprFloatLit(x) => { ret true; }, _ => { ret false; } } match n.body { .ExprFloatLit(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
@@ -2735,7 +2735,7 @@ fn infer_for(self: *Sema, n: *Node, label_ref: usize, iter_exprs: Vec, pattern_r
} }
fn kind_is_body_pattern_list(n: *Node): bool { fn kind_is_body_pattern_list(n: *Node): bool {
match n.body { .PatternList(x) => { ret true; }, _ => { ret false; } } match n.body { .PatternList(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }
@@ -2819,7 +2819,7 @@ fn infer_type_decl(self: *Sema, n: *Node, pattern_ref: usize, type_ref: usize):
} }
fn kind_is_body_fn_decl(n: *Node): bool { fn kind_is_body_fn_decl(n: *Node): bool {
match n.body { .FnDecl(x) => { ret true; }, _ => { ret false; } } match n.body { .FnDecl(&x) => { ret true; }, _ => { ret false; } }
ret false; ret false;
} }