diff --git a/stage2/ast2ir.spl b/stage2/ast2ir.spl
index 2605814..ac5c31c 100644
--- a/stage2/ast2ir.spl
+++ b/stage2/ast2ir.spl
@@ -182,7 +182,7 @@ fn is_assign_arith(op: Punct): bool {
 
 fn int_lit_u64(n: *Node): u64 {
     match n.body {
-        .ExprIntLit(x) => {
+        .ExprIntLit(&x) => {
             var out: u64 = 0;
             match BigInt.to_u64(&out, x.value) { .Ok => {}, .Err(e) => {} }
             ret out;
@@ -217,14 +217,14 @@ fn emit_zero_value(self: *Ast2Ir, tid: usize): usize {
     var variants = Vec.blank(@sizeof(usize), @alignof(usize));
     match tn.node {
         .Bool => { is_bool = true; },
-        .Int(x) => { is_int = true; },
-        .Float(x) => { is_float = true; },
-        .Ptr(x) => { is_ptr = true; },
-        .Fn(x) => { is_fn = true; },
-        .Array(x) => { is_arr = true; arr_len = x.len; arr_elem = x.element; },
-        .Struct(x) => { is_struct = true; variants = x.variants; },
-        .Shape(x) => { is_shape = true; variants = x.variants; },
-        .Union(x) => { is_union = true; variants = x.variants; },
+        .Int(&x) => { is_int = true; },
+        .Float(&x) => { is_float = true; },
+        .Ptr(&x) => { is_ptr = true; },
+        .Fn(&x) => { is_fn = true; },
+        .Array(&x) => { is_arr = true; arr_len = x.len; arr_elem = x.element; },
+        .Struct(&x) => { is_struct = true; variants = x.variants; },
+        .Shape(&x) => { is_shape = true; variants = x.variants; },
+        .Union(&x) => { is_union = true; variants = x.variants; },
         _ => { ret 0; },
     }
     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 {
     var obj_ref: usize = 0;
     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 recv_lang = node_lang(obj);
     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);
     if n == null { ret 0; }
     match n.body {
-        .ExprIdent(x) => {
+        .ExprIdent(&x) => {
             var d = defn(self, n.resolved_def_id);
             if d != null && @enum2int(d.kind) == @enum2int(DefKind.Fn) { ret 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; }
             ret slot;
         },
-        .ExprUnary(x) => {
+        .ExprUnary(&x) => {
             if !punct_is(x.op, .Mul) { ret 0; }
             ret emit_expr(self, x.operand);
         },
-        .ExprField(x) => { ret lvalue_field(self, n, x.obj, x.name); },
-        .ExprIndex(x) => { ret lvalue_index(self, n, x.obj, x.index); },
+        .ExprField(&x) => { ret lvalue_field(self, n, x.obj, x.name); },
+        .ExprIndex(&x) => { ret lvalue_index(self, n, x.obj, x.index); },
         _ => { 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 {
-    match n.body { .ExprIntLit(x) => { ret true; }, _ => { ret false; } }
+    match n.body { .ExprIntLit(&x) => { ret true; }, _ => { 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 {
     var eref: 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);
     if v == 0 { ret 0; }
     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 {
     var obj_ref: usize = 0;
     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);
     if obj == null { ret 0; }
     var obj_lang = node_lang(obj);
@@ -959,7 +959,7 @@ fn ast2ir_enum_variant(self: *Ast2Ir, n: *Node): usize {
     var tn = irt(self, t);
     if tn == null { ret 0; }
     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;
     if !TypeTable.agg_member_idx(&self.sema.types.ir, t, field_name, &vidx) { ret 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);
     if n == null { ret 0; }
     match n.body {
-        .ExprIntLit(x) => { ret emit_int_lit(self, n); },
-        .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); },
-        .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); },
+        .ExprIntLit(&x) => { ret emit_int_lit(self, n); },
+        .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); },
+        .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); },
         .ExprNullLit => { ret IrBuilder.type_const_ptr(self.ir, node_ir(self, n), 0); },
         .ExprUndefinedLit => { ret 0; },
-        .ExprIdent(x) => { ret emit_ident(self, n); },
-        .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); },
-        .ExprCall(x) => { ret emit_call(self, n, x.callee, x.args); },
-        .ExprField(x) => { ret emit_field(self, n, ref, x.obj, x.name); },
-        .ExprIndex(x) => {
+        .ExprIdent(&x) => { ret emit_ident(self, n); },
+        .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); },
+        .ExprCall(&x) => { ret emit_call(self, n, x.callee, x.args); },
+        .ExprField(&x) => { ret emit_field(self, n, ref, x.obj, x.name); },
+        .ExprIndex(&x) => {
             var ptr = emit_lvalue(self, ref);
             if ptr == 0 { ret 0; }
             ret IrBuilder.mem_load(self.ir, node_ir(self, n), ptr);
         },
-        .ExprCast(x) => { ret emit_cast(self, n); },
-        .ExprTuple(x) => { ret emit_tuple(self, n, x.items); },
-        .ExprArrayLit(x) => { ret emit_array_lit(self, n, x.elems); },
-        .ExprAggregateLit(x) => { ret emit_aggregate_lit(self, n, x.name, x.fields); },
-        .ExprBlock(x) => { ret emit_block(self, n, x.stmts, x.tail_expr); },
-        .ExprIf(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); },
-        .ExprWhile(x) => { ret emit_loop_like(self, ref); },
-        .ExprLoop(x) => { ret emit_loop_like(self, ref); },
-        .ExprFor(x) => {
+        .ExprCast(&x) => { ret emit_cast(self, n); },
+        .ExprTuple(&x) => { ret emit_tuple(self, n, x.items); },
+        .ExprArrayLit(&x) => { ret emit_array_lit(self, n, x.elems); },
+        .ExprAggregateLit(&x) => { ret emit_aggregate_lit(self, n, x.name, x.fields); },
+        .ExprBlock(&x) => { ret emit_block(self, n, x.stmts, x.tail_expr); },
+        .ExprIf(&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); },
+        .ExprWhile(&x) => { ret emit_loop_like(self, ref); },
+        .ExprLoop(&x) => { ret emit_loop_like(self, ref); },
+        .ExprFor(&x) => {
             Diag.err(self.diag, n.span, .UnhandledNode, "for is not implemented yet");
             ret 0;
         },
-        .ExprSlice(x) => { ret emit_slice(self, n, x.obj, x.begin, x.end); },
-        .ExprComptimeCall(x) => {
+        .ExprSlice(&x) => { ret emit_slice(self, n, x.obj, x.begin, x.end); },
+        .ExprComptimeCall(&x) => {
             var in = IntrinOps.lookup_call(x.name);
             if @enum2int(in) == @enum2int(Intrin.None) { ret 0; }
             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 {
-    match n.body { .ExprIdent(x) => { ret true; }, _ => { ret false; } }
+    match n.body { .ExprIdent(&x) => { ret true; }, _ => { ret false; } }
     ret false;
 }
 
 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();
 }
 
@@ -1688,7 +1688,7 @@ fn emit_if_like(self: *Ast2Ir, ref: usize): usize {
     var n = Ast.node(self.ast, ref);
     if n == null { ret 0; }
     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 need_result = false;
@@ -1704,7 +1704,7 @@ fn emit_if_like(self: *Ast2Ir, ref: usize): usize {
     var else_ref: usize = 0;
     if is_ifvar {
         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);
         if vd == null { ret 0; }
         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);
     if n == null { ret 0; }
     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 need_result = false;
@@ -1783,7 +1783,7 @@ fn emit_loop_like(self: *Ast2Ir, ref: usize): usize {
     if is_while {
         head_blk = IrBuilder.block_begin(self.ir);
         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; }
         br = IrBuilder.control_br(self.ir, cond);
         IrBuilder.block_end(self.ir);
@@ -1884,7 +1884,7 @@ fn emit_break_stmt(self: *Ast2Ir, n: *Node): usize {
     var lbl = ByteView.empty();
     var expr_ref: usize = 0;
     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;
@@ -1913,24 +1913,24 @@ fn emit_stmt(self: *Ast2Ir, ref: usize) {
     var n = Ast.node(self.ast, ref);
     if n == null { ret; }
     match n.body {
-        .StatementRet(x) => {
+        .StatementRet(&x) => {
             var ret_ir = to_ir_type(self, self.cur_ret_lang);
             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)); }
         },
-        .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)); } },
-        .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)); },
-        .StatementContinue(x) => { emit_continue_stmt(self, n); },
-        .ExprBlock(x) => { ignore_usize(emit_expr(self, ref)); },
+        .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)); } },
+        .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)); },
+        .StatementContinue(&x) => { emit_continue_stmt(self, n); },
+        .ExprBlock(&x) => { 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) {
     if self.loop_stack.len == 0 { ret; }
     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;
     if lbl.len != 0 { target_index = find_loop_with_label(self, lbl); }
     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);
     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 { 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 {
-    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();
 }
 
@@ -2018,7 +2018,7 @@ fn emit_fn_body(self: *Ast2Ir, n: *Node) {
 
     var params = Vec.blank(@sizeof(usize), @alignof(usize));
     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;
     while i < params.len {
         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) {
     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;
     while i < members.len {
         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) {
     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;
     while i < members.len {
         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 {
-    match n.body { .TypeAggregate(x) => { ret true; }, _ => { ret false; } }
+    match n.body { .TypeAggregate(&x) => { ret true; }, _ => { ret false; } }
     ret false;
 }
 
@@ -2123,14 +2123,14 @@ fn emit_container_reserve(self: *Ast2Ir, ref: usize) {
     if n == null { ret; }
     var is_tlb = false;
     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 tlb_block != 0 { emit_container_reserve(self, tlb_block); }
         ret;
     }
     var decls = Vec.blank(@sizeof(usize), @alignof(usize));
     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; }
     var i: usize = 0;
     while i < decls.len {
@@ -2161,14 +2161,14 @@ fn emit_container_body(self: *Ast2Ir, ref: usize) {
     if n == null { ret; }
     var is_tlb = false;
     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 tlb_block != 0 { emit_container_body(self, tlb_block); }
         ret;
     }
     var decls = Vec.blank(@sizeof(usize), @alignof(usize));
     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; }
     var i: usize = 0;
     while i < decls.len {
@@ -2195,7 +2195,7 @@ fn emit_container_body(self: *Ast2Ir, ref: usize) {
 }
 
 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;
 }
 
diff --git a/stage2/ir2vm.spl b/stage2/ir2vm.spl
index 049ced5..29a2d77 100644
--- a/stage2/ir2vm.spl
+++ b/stage2/ir2vm.spl
@@ -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_load_slot(cg: *Cgen, ref: usize, k: VmKind) {
-    cg_laddr(cg, slot_result(&cg.frame, ref));
-    cg_load(cg, k);
+    emit(cg, .Laddr, .Void, slot_result(&cg.frame, ref));
+    emit(cg, .Load, k, 0);
 }
 
 fn cg_store_slot(cg: *Cgen, ref: usize, k: VmKind) {
-    cg_laddr(cg, slot_result(&cg.frame, ref));
-    cg_swap(cg);
-    cg_store(cg, k);
+    emit(cg, .Laddr, .Void, slot_result(&cg.frame, ref));
+    emit(cg, .Swap, .Void, 0);
+    emit(cg, .Store, k, 0);
 }
 
 fn cg_store_at(cg: *Cgen, addr: usize, k: VmKind) {
-    cg_laddr(cg, addr);
-    cg_swap(cg);
-    cg_store(cg, k);
+    emit(cg, .Laddr, .Void, addr);
+    emit(cg, .Swap, .Void, 0);
+    emit(cg, .Store, k, 0);
 }
 
 type DataLoc = struct {
diff --git a/stage2/mcode.spl b/stage2/mcode.spl
index 096ddab..18f73fa 100644
--- a/stage2/mcode.spl
+++ b/stage2/mcode.spl
@@ -572,33 +572,34 @@ fn encode(self: *Prog, out: *ByteBuffer): Status {
     // 精确预估输出大小并一次性预留，避免大文件逐字节增长导致的重复拷贝。
     var total: usize = 48;
     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 {
-        var f = func_at(self, fi);
-        if f != null {
-            var nlen = f.name.len + 1;
-            total = total + 8 + align8(nlen) + 32;
-        }
+        var f = func_base + fi;
+        var nlen = f.name.len + 1;
+        total = total + 8 + align8(nlen) + 32;
         fi = fi + 1;
     }
     total = total + self.insns.len * 12;
     fi = 0;
     while fi < self.natives.len {
-        var n = native_at(self, fi);
-        if n != null {
-            var nlen = n.name.len + 1;
-            total = total + 8 + align8(nlen) + 8;
-        }
+        var n = nat_base + fi;
+        var nlen = n.name.len + 1;
+        total = total + 8 + align8(nlen) + 8;
         fi = fi + 1;
     }
     fi = 0;
     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 = 1;
     while fi < self.gdata.len {
-        var e = gdata_at(self, fi);
-        if e != null { total = total + 8 + align8(e.storage.len); }
+        var e = gd_base + fi;
+        total = total + 8 + align8(e.storage.len);
         fi = fi + 1;
     }
     match ByteBuffer.reserve(out, total) { .Ok => {}, .Err(error) => {} }
@@ -622,8 +623,7 @@ fn encode(self: *Prog, out: *ByteBuffer): Status {
 
     var i: usize = 0;
     while i < nfuncs {
-        var f = func_at(self, i);
-        if f == null { ret .Err(make(.Io)); }
+        var f = func_base + i;
         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.nargs) { ret .Err(make(.Io)); }
@@ -633,20 +633,23 @@ fn encode(self: *Prog, out: *ByteBuffer): Status {
     }
 
     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 {
-        var ins = ins_at(self, i);
-        var d = out.storage.data + out.storage.len;
-        (d as *u16).* = @enum2int(ins.opcode) as u16;
-        ((d + 2) as *u16).* = @enum2int(ins.ty) as u16;
-        ((d + 4) as *u64).* = ins.imm as u64;
-        out.storage.len = out.storage.len + 12;
+        var p = ins_base + i;
+        var d = out_base + out_len;
+        (d as *u16).* = @enum2int(p.opcode) as u16;
+        ((d + 2) as *u16).* = @enum2int(p.ty) as u16;
+        ((d + 4) as *u64).* = p.imm as u64;
+        out_len = out_len + 12;
         i = i + 1;
     }
+    out.storage.len = out_len;
 
     i = 0;
     while i < nnatives {
-        var n = native_at(self, i);
-        if n == null { ret .Err(make(.Io)); }
+        var n = nat_base + i;
         if !put_name_field(out, n.name) { ret .Err(make(.Io)); }
         if !put_u64(out, n.idx_of_strtab) { ret .Err(make(.Io)); }
         i = i + 1;
@@ -654,17 +657,16 @@ fn encode(self: *Prog, out: *ByteBuffer): Status {
 
     i = 0;
     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_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)); }
         i = i + 1;
     }
 
     i = 1;
     while i < self.gdata.len {
-        var e = gdata_at(self, i);
-        if e == null { ret .Err(make(.Io)); }
+        var e = gd_base + i;
         var dsize = e.storage.len;
         if !put_u64(out, dsize) { ret .Err(make(.Io)); }
         if !put_view(out, ByteView.from_slice(ByteBuffer.as_slice(e.*))) { ret .Err(make(.Io)); }
diff --git a/stage2/sema.spl b/stage2/sema.spl
index 4c771ab..4ec32d0 100644
--- a/stage2/sema.spl
+++ b/stage2/sema.spl
@@ -337,13 +337,13 @@ fn resolve_attr_item(self: *Sema, a: *Node): usize {
 fn resolve_attrs(self: *Sema, n: *Node) {
     if n.attrs.len != 0 { ret; }
     match n.body {
-        .FnDecl(x) => { node_attr_raw(self, n, x.tag_list); },
-        .VarDecl(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); },
-        .MemberDecl(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); },
+        .FnDecl(&x) => { node_attr_raw(self, n, x.tag_list); },
+        .VarDecl(&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); },
+        .MemberDecl(&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); },
         _ => {},
     }
 }
@@ -353,7 +353,7 @@ fn resolve_attrs(self: *Sema, n: *Node) {
 fn build_aggregate(self: *Sema, te: *Node, owner_def_id: usize): usize {
     var kind_name = ByteView.empty();
     match te.body {
-        .TypeAggregate(x) => { kind_name = x.kind_name; },
+        .TypeAggregate(&x) => { kind_name = x.kind_name; },
         _ => {},
     }
     var lk: LangKind = .Struct;
@@ -389,7 +389,7 @@ fn build_aggregate(self: *Sema, te: *Node, owner_def_id: usize): usize {
 
     var mlist = ref_vec();
     match te.body {
-        .TypeAggregate(x) => { mlist = x.members; },
+        .TypeAggregate(&x) => { mlist = x.members; },
         _ => {},
     }
     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 {
-    match n.body { .PatternIdent(x) => { ret true; }, _ => { ret false; } }
+    match n.body { .PatternIdent(&x) => { ret true; }, _ => { ret false; } }
     ret false;
 }
 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;
 }
 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;
 }
 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;
 }
 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;
 }
 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;
 }
 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;
 }
 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;
 }
 
 fn pattern_name(pat: *Node): ByteView {
     match pat.body {
-        .PatternIdent(x) => { ret x.name; },
+        .PatternIdent(&x) => { ret x.name; },
         _ => { 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));
         if pd != null && is_param_decl(pd) {
             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 {
                 push_u(&params, infer(self, tref));
             } else {
@@ -951,7 +951,7 @@ fn infer_type_context(self: *Sema, ref: usize): usize {
     var n = node(self, ref);
     if n == null { ret 0; }
     match n.body {
-        .ExprIdent(x) => {
+        .ExprIdent(&x) => {
             var builtin = LangType.lookup_builtin(&self.types, x.name);
             if builtin != 0 {
                 n.resolved_lang_tid = builtin;
@@ -971,7 +971,7 @@ fn infer_type_context(self: *Sema, ref: usize): usize {
             n.resolved_lang_tid = t;
             ret t;
         },
-        .ExprField(x) => {
+        .ExprField(&x) => {
             var owner_id = infer_type_context(self, x.obj);
             var owner = lang_of(self, owner_id);
             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);
             ret 0;
         },
-        .ExprUnary(x) => {
+        .ExprUnary(&x) => {
             if punct_is(x.op, .Mul) {
                 var pointee = infer_type_context(self, x.operand);
                 if pointee == 0 { ret 0; }
@@ -1000,7 +1000,7 @@ fn infer_type_context(self: *Sema, ref: usize): usize {
             }
             ret 0;
         },
-        .ExprTuple(x) => {
+        .ExprTuple(&x) => {
             var elems = ref_vec();
             var i: usize = 0;
             while i < x.items.len {
@@ -1013,7 +1013,7 @@ fn infer_type_context(self: *Sema, ref: usize): usize {
             n.resolved_lang_tid = r;
             ret r;
         },
-        .ExprComptimeCall(x) => {
+        .ExprComptimeCall(&x) => {
             var r = infer(self, ref);
             n.resolved_lang_tid = 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 is_expr_ident(fnode) {
             var fname = ByteView.empty();
-            match fnode.body { .ExprIdent(x) => { fname = x.name; }, _ => {} }
+            match fnode.body { .ExprIdent(&x) => { fname = x.name; }, _ => {} }
             var idx: usize = 0;
             if !TypeTable.agg_member_idx(&self.types.ir, agg_ir, fname, &idx) {
                 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;
 
     match n.body {
-        .ExprUnary(x) => {
+        .ExprUnary(&x) => {
             if !(punct_is(x.op, .And) || punct_is(x.op, .Mul)) {
                 handled = true;
                 result = coerce(self, x.operand, expected);
             }
         },
-        .ExprBinary(x) => {
+        .ExprBinary(&x) => {
             handled = true;
             var op = x.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;
             }
         },
-        .ExprArrayLit(x) => {
+        .ExprArrayLit(&x) => {
             var en = lang_of(self, expected);
             if en != null && (kind_is(self, expected, .Array) || kind_is(self, expected, .Slice)) {
                 handled = true;
@@ -1757,7 +1757,7 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
                 result = expected;
             }
         },
-        .ExprTuple(x) => {
+        .ExprTuple(&x) => {
             var en = lang_of(self, expected);
             if en != null && kind_is(self, expected, .Tuple) {
                 handled = true;
@@ -1775,7 +1775,7 @@ fn coerce(self: *Sema, ref: usize, expected: usize): usize {
                 result = expected;
             }
         },
-        .ExprAggregateLit(x) => {
+        .ExprAggregateLit(&x) => {
             var en = lang_of(self, expected);
             if en != null && (kind_is(self, expected, .Struct) || kind_is(self, expected, .Union) ||
                               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 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;
                     if !TypeTable.agg_member_idx(&self.types.ir, agg_ir, iname, &idx) {
                         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) {
                             var iname = ByteView.empty();
                             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;
                             if !TypeTable.agg_member_idx(&self.types.ir, agg_ir, iname, &idx) {
                                 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;
             var bt = make_bool(self);
             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)); }
             result = expected;
         },
-        .ExprLoop(x) => {
+        .ExprLoop(&x) => {
             handled = true;
             var saved = self.current_loop_break_tid;
             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;
             result = expected;
         },
-        .ExprBlock(x) => {
+        .ExprBlock(&x) => {
             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 {
             var fits = true;
             match n.body {
-                .ExprIntLit(v) => {
+                .ExprIntLit(&v) => {
                     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 {
-    match n.body { .StructInitItem(x) => { ret true; }, _ => { ret false; } }
+    match n.body { .StructInitItem(&x) => { ret true; }, _ => { ret false; } }
     ret false;
 }
 
@@ -1929,28 +1929,28 @@ fn infer(self: *Sema, ref: usize): usize {
     resolve_attrs(self, n);
 
     match n.body {
-        .ExprIntLit(x) => {
+        .ExprIntLit(&x) => {
             var t = LangType.make_int(&self.types, 0, true);
             n.resolved_lang_tid = t;
             ret t;
         },
-        .ExprFloatLit(x) => {
+        .ExprFloatLit(&x) => {
             var t = LangType.make_float(&self.types, 0);
             n.resolved_lang_tid = t;
             ret t;
         },
-        .ExprCharLit(x) => {
+        .ExprCharLit(&x) => {
             var t = LangType.make_int(&self.types, 8, false);
             n.resolved_lang_tid = t;
             ret t;
         },
-        .ExprStringLit(x) => {
+        .ExprStringLit(&x) => {
             var u8t = LangType.make_int(&self.types, 8, false);
             var s = LangType.make_slice(&self.types, u8t);
             n.resolved_lang_tid = s;
             ret s;
         },
-        .ExprBoolLit(x) => {
+        .ExprBoolLit(&x) => {
             var t = make_bool(self);
             n.resolved_lang_tid = t;
             ret t;
@@ -1966,7 +1966,7 @@ fn infer(self: *Sema, ref: usize): usize {
             n.resolved_lang_tid = t;
             ret t;
         },
-        .ExprIdent(x) => {
+        .ExprIdent(&x) => {
             var sym = Symbol { .name = ByteView.empty(), .kind = .Error, .node = 0 };
             if !Scope.find(&self.scope, x.name, &sym) {
                 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;
             ret t;
         },
-        .ExprUnary(x) => {
+        .ExprUnary(&x) => {
             var op = infer(self, x.operand);
             if op == 0 { ret 0; }
             var tn = lang_of(self, op);
@@ -2032,25 +2032,25 @@ fn infer(self: *Sema, ref: usize): usize {
             }
             ret 0;
         },
-        .ExprBinary(x) => {
+        .ExprBinary(&x) => {
             ret infer_binary(self, n, x.op, x.left, x.right);
         },
-        .ExprCall(x) => {
+        .ExprCall(&x) => {
             ret infer_call(self, n, x.callee, x.args);
         },
-        .ExprField(x) => {
+        .ExprField(&x) => {
             ret infer_field(self, n, x.obj, x.name);
         },
-        .ExprIndex(x) => {
+        .ExprIndex(&x) => {
             ret infer_index(self, n, x.obj, x.index);
         },
-        .ExprSlice(x) => {
+        .ExprSlice(&x) => {
             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);
         },
-        .ExprTuple(x) => {
+        .ExprTuple(&x) => {
             var es = ref_vec();
             var i: usize = 0;
             while i < x.items.len {
@@ -2061,13 +2061,13 @@ fn infer(self: *Sema, ref: usize): usize {
             n.resolved_lang_tid = 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);
         },
-        .ExprAggregateLit(x) => {
+        .ExprAggregateLit(&x) => {
             ret infer_aggregate(self, n, x.name, x.fields);
         },
-        .ExprComptimeCall(x) => {
+        .ExprComptimeCall(&x) => {
             if ByteView.eq(x.name, ByteView.from_slice("import")) {
                 var t = sema_import(self, n, x.args);
                 n.resolved_lang_tid = t;
@@ -2090,10 +2090,10 @@ fn infer(self: *Sema, ref: usize): usize {
             n.resolved_lang_tid = t;
             ret t;
         },
-        .ExprBlock(x) => {
+        .ExprBlock(&x) => {
             ret block_body(self, n, 0);
         },
-        .ExprIf(x) => {
+        .ExprIf(&x) => {
             var bt = make_bool(self);
             ignore_usize(coerce(self, x.cond, bt));
             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;
             ret result;
         },
-        .ExprIfvar(x) => {
+        .ExprIfvar(&x) => {
             if x.var_decl == 0 { ret 0; }
             var vd = node(self, x.var_decl);
             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)); }
             ret 0;
         },
-        .ExprWhile(x) => {
+        .ExprWhile(&x) => {
             push_view(&self.label_stack, label_name(self, x.label));
             var bt = make_bool(self);
             ignore_usize(coerce(self, x.cond, bt));
@@ -2129,16 +2129,16 @@ fn infer(self: *Sema, ref: usize): usize {
             pop_label(self);
             ret 0;
         },
-        .ExprLoop(x) => {
+        .ExprLoop(&x) => {
             push_view(&self.label_stack, label_name(self, x.label));
             if x.body != 0 { ignore_usize(infer(self, x.body)); }
             pop_label(self);
             ret 0;
         },
-        .ExprFor(x) => {
+        .ExprFor(&x) => {
             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 i: usize = 0;
             while i < x.arms.len {
@@ -2162,7 +2162,7 @@ fn infer(self: *Sema, ref: usize): usize {
             }
             ret 0;
         },
-        .ExprFnType(x) => {
+        .ExprFnType(&x) => {
             var ps = ref_vec();
             var i: usize = 0;
             while i < x.params.len {
@@ -2174,7 +2174,7 @@ fn infer(self: *Sema, ref: usize): usize {
             n.resolved_lang_tid = fn_lang;
             ret fn_lang;
         },
-        .TypePath(x) => {
+        .TypePath(&x) => {
             var b = LangType.lookup_builtin(&self.types, x.name);
             if b != 0 {
                 n.resolved_lang_tid = b;
@@ -2189,13 +2189,13 @@ fn infer(self: *Sema, ref: usize): usize {
             n.resolved_lang_tid = t;
             ret t;
         },
-        .TypePointer(x) => {
+        .TypePointer(&x) => {
             var p = infer(self, x.pointee);
             var r = LangType.make_ptr(&self.types, p);
             n.resolved_lang_tid = r;
             ret r;
         },
-        .TypeArray(x) => {
+        .TypeArray(&x) => {
             var e = infer(self, x.elem_type);
             var len: usize = 0;
             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;
             ret r;
         },
-        .TypeSlice(x) => {
+        .TypeSlice(&x) => {
             var e = infer(self, x.elem_type);
             var r = LangType.make_slice(&self.types, e);
             n.resolved_lang_tid = r;
             ret r;
         },
-        .TypeFn(x) => {
+        .TypeFn(&x) => {
             var ps = ref_vec();
             var i: usize = 0;
             while i < x.params.len {
@@ -2221,7 +2221,7 @@ fn infer(self: *Sema, ref: usize): usize {
             n.resolved_lang_tid = r;
             ret r;
         },
-        .TypeParen(x) => {
+        .TypeParen(&x) => {
             if x.types.len == 0 {
                 var u = make_unit(self);
                 n.resolved_lang_tid = u;
@@ -2242,10 +2242,10 @@ fn infer(self: *Sema, ref: usize): usize {
             n.resolved_lang_tid = t;
             ret t;
         },
-        .TypeAggregate(x) => {
+        .TypeAggregate(&x) => {
             ret build_aggregate(self, n, 0);
         },
-        .TypeComptimeCall(x) => {
+        .TypeComptimeCall(&x) => {
             if ByteView.eq(x.name, ByteView.from_slice("self")) {
                 if self.current_aggregate_lang == 0 {
                     diag(self, n.span, .UndefinedSymbol, "`@self` outside of aggregate");
@@ -2261,7 +2261,7 @@ fn infer(self: *Sema, ref: usize): usize {
             }
             ret 0;
         },
-        .ContainerMembers(x) => {
+        .ContainerMembers(&x) => {
             var i: usize = 0;
             while i < x.declarations.len {
                 ignore_usize(infer(self, list_at(x.declarations, i)));
@@ -2269,48 +2269,48 @@ fn infer(self: *Sema, ref: usize): usize {
             }
             ret 0;
         },
-        .FnDecl(x) => {
+        .FnDecl(&x) => {
             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);
         },
-        .VarDecl(x) => { ret var_body(self, n); },
-        .ConstDecl(x) => { ret var_body(self, n); },
-        .MemberDecl(x) => {
+        .VarDecl(&x) => { ret var_body(self, n); },
+        .ConstDecl(&x) => { ret var_body(self, n); },
+        .MemberDecl(&x) => {
             if x.type_expr != 0 { ret infer(self, x.type_expr); }
             ret 0;
         },
-        .ParamDecl(x) => {
+        .ParamDecl(&x) => {
             if x.type_expr != 0 { ret infer(self, x.type_expr); }
             ret 0;
         },
-        .StatementRet(x) => {
+        .StatementRet(&x) => {
             ret infer_ret(self, n, x.expr);
         },
-        .StatementBreak(x) => {
+        .StatementBreak(&x) => {
             ret infer_break(self, n, x.label, x.expr);
         },
-        .StatementContinue(x) => {
+        .StatementContinue(&x) => {
             ret infer_continue(self, n, x.label);
         },
-        .StatementDefer(x) => {
+        .StatementDefer(&x) => {
             if x.body != 0 { ignore_usize(infer(self, x.body)); }
             ret 0;
         },
-        .StatementComptime(x) => {
+        .StatementComptime(&x) => {
             if x.body != 0 { ignore_usize(infer(self, x.body)); }
             ret 0;
         },
-        .StatementDecl(x) => {
+        .StatementDecl(&x) => {
             if x.decl != 0 { ignore_usize(infer(self, x.decl)); }
             ret 0;
         },
-        .StatementExpr(x) => {
+        .StatementExpr(&x) => {
             if x.expr != 0 { ignore_usize(infer(self, x.expr)); }
             ret 0;
         },
-        .TopLevelBlock(x) => {
+        .TopLevelBlock(&x) => {
             if x.block != 0 { ignore_usize(infer(self, x.block)); }
             ret 0;
         },
@@ -2320,7 +2320,7 @@ fn infer(self: *Sema, ref: usize): usize {
 }
 
 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;
 }
 
@@ -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 {
-    match n.body { .ExprFloatLit(x) => { ret true; }, _ => { ret false; } }
+    match n.body { .ExprFloatLit(&x) => { ret true; }, _ => { 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 {
-    match n.body { .PatternList(x) => { ret true; }, _ => { ret false; } }
+    match n.body { .PatternList(&x) => { ret true; }, _ => { 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 {
-    match n.body { .FnDecl(x) => { ret true; }, _ => { ret false; } }
+    match n.body { .FnDecl(&x) => { ret true; }, _ => { ret false; } }
     ret false;
 }