zig0

astgen.c (411494B) - Raw

---

 // astgen.c — AST to ZIR conversion, ported from lib/std/zig/AstGen.zig.
 //
 // Structural translation of AstGen.zig into C.
 // Each function corresponds to a Zig function with the same name,
 // with line references to Zig 0.15.1 AstGen.zig.
 
 #include "astgen.h"
 #include "common.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
 // --- Declaration.Flags.Id enum (Zir.zig:2724) ---
 
 typedef enum {
     DECL_ID_UNNAMED_TEST,
     DECL_ID_TEST,
     DECL_ID_DECLTEST,
     DECL_ID_COMPTIME,
     DECL_ID_CONST_SIMPLE,
     DECL_ID_CONST_TYPED,
     DECL_ID_CONST,
     DECL_ID_PUB_CONST_SIMPLE,
     DECL_ID_PUB_CONST_TYPED,
     DECL_ID_PUB_CONST,
     DECL_ID_EXTERN_CONST_SIMPLE,
     DECL_ID_EXTERN_CONST,
     DECL_ID_PUB_EXTERN_CONST_SIMPLE,
     DECL_ID_PUB_EXTERN_CONST,
     DECL_ID_EXPORT_CONST,
     DECL_ID_PUB_EXPORT_CONST,
     DECL_ID_VAR_SIMPLE,
     DECL_ID_VAR,
     DECL_ID_VAR_THREADLOCAL,
     DECL_ID_PUB_VAR_SIMPLE,
     DECL_ID_PUB_VAR,
     DECL_ID_PUB_VAR_THREADLOCAL,
     DECL_ID_EXTERN_VAR,
     DECL_ID_EXTERN_VAR_THREADLOCAL,
     DECL_ID_PUB_EXTERN_VAR,
     DECL_ID_PUB_EXTERN_VAR_THREADLOCAL,
     DECL_ID_EXPORT_VAR,
     DECL_ID_EXPORT_VAR_THREADLOCAL,
     DECL_ID_PUB_EXPORT_VAR,
     DECL_ID_PUB_EXPORT_VAR_THREADLOCAL,
 } DeclFlagsId;
 
 // --- Import tracking (AstGen.zig:265) ---
 
 typedef struct {
     uint32_t name; // NullTerminatedString index
     uint32_t token; // Ast.TokenIndex
 } ImportEntry;
 
 // --- AstGen internal context (mirrors AstGen struct, AstGen.zig:153) ---
 
 typedef struct {
     const Ast* tree;
     ZirInstTag* inst_tags;
     ZirInstData* inst_datas;
     uint32_t inst_len;
     uint32_t inst_cap;
     uint32_t* extra;
     uint32_t extra_len;
     uint32_t extra_cap;
     uint8_t* string_bytes;
     uint32_t string_bytes_len;
     uint32_t string_bytes_cap;
     // String dedup table: stores positions in string_bytes that are
     // registered for deduplication (mirrors AstGen.string_table).
     // Only strings added via identAsString/strLitAsString (non-embedded-null)
     // are registered. Multiline strings are NOT registered.
     uint32_t* string_table;
     uint32_t string_table_len;
     uint32_t string_table_cap;
     uint32_t source_offset;
     uint32_t source_line;
     uint32_t source_column;
     ImportEntry* imports;
     uint32_t imports_len;
     uint32_t imports_cap;
     // Namespace decl table: maps string indices to node indices.
     // Populated by scanContainer, used by identifier resolution.
     uint32_t* decl_names; // string indices
     uint32_t* decl_nodes; // node indices
     uint32_t decl_table_len;
     uint32_t decl_table_cap;
     // Shared dynamic array for GenZir instructions (AstGen.zig:11796).
     // Sub-blocks share this array and track their slice via
     // instructions_top.
     uint32_t* scratch_instructions;
     uint32_t scratch_inst_len;
     uint32_t scratch_inst_cap;
     // Scratch extra array for call arguments (mirrors AstGen.scratch in Zig).
     // Used to collect body lengths + body instructions before copying to
     // extra.
     uint32_t* scratch_extra;
     uint32_t scratch_extra_len;
     uint32_t scratch_extra_cap;
     // Return type ref for the current function (set during fnDecl/testDecl).
     uint32_t fn_ret_ty; // ZirInstRef
     // Pointer to the fn_block GenZir for the current function (AstGen.zig:45).
     void* fn_block; // GenZir*
     // ref_table: deferred REF instructions (AstGen.zig:58-68).
     // Key = operand inst index, Value = ref inst index.
     uint32_t* ref_table_keys;
     uint32_t* ref_table_vals;
     uint32_t ref_table_len;
     uint32_t ref_table_cap;
     // nodes_need_rl: set of AST node indices that need result locations.
     // Populated by astRlAnnotate() pre-pass (AstRlAnnotate.zig).
     uint32_t* nodes_need_rl;
     uint32_t nodes_need_rl_len;
     uint32_t nodes_need_rl_cap;
     bool has_compile_errors;
 } AstGenCtx;
 
 static void setCompileError(AstGenCtx* ag, const char* where, int line) {
     (void)where;
     (void)line;
     ag->has_compile_errors = true;
 }
 #define SET_ERROR(ag) setCompileError(ag, __func__, __LINE__)
 
 // Set fn_block pointer on AstGenCtx. The caller is responsible for saving
 // and restoring the previous value before the pointed-to GenZir goes out
 // of scope (AstGen.zig:45).
 static void setFnBlock(AstGenCtx* ag, void* block) { ag->fn_block = block; }
 
 // --- ref_table operations (AstGen.zig:58-68) ---
 // Simple linear-scan hash table for deferred REF instructions.
 
 // Returns pointer to existing value if key found, NULL if not found.
 static uint32_t* refTableGet(AstGenCtx* ag, uint32_t key) {
     for (uint32_t i = 0; i < ag->ref_table_len; i++) {
         if (ag->ref_table_keys[i] == key)
             return &ag->ref_table_vals[i];
     }
     return NULL;
 }
 
 // getOrPut: returns pointer to value slot; sets *found to true if existed.
 static uint32_t* refTableGetOrPut(AstGenCtx* ag, uint32_t key, bool* found) {
     for (uint32_t i = 0; i < ag->ref_table_len; i++) {
         if (ag->ref_table_keys[i] == key) {
             *found = true;
             return &ag->ref_table_vals[i];
         }
     }
     *found = false;
     if (ag->ref_table_len >= ag->ref_table_cap) {
         uint32_t new_cap = ag->ref_table_cap == 0 ? 16 : ag->ref_table_cap * 2;
         ag->ref_table_keys
             = realloc(ag->ref_table_keys, new_cap * sizeof(uint32_t));
         ag->ref_table_vals
             = realloc(ag->ref_table_vals, new_cap * sizeof(uint32_t));
         ag->ref_table_cap = new_cap;
     }
     uint32_t idx = ag->ref_table_len++;
     ag->ref_table_keys[idx] = key;
     return &ag->ref_table_vals[idx];
 }
 
 // fetchRemove: if key exists, remove it and return true with *val set.
 static bool refTableFetchRemove(AstGenCtx* ag, uint32_t key, uint32_t* val) {
     for (uint32_t i = 0; i < ag->ref_table_len; i++) {
         if (ag->ref_table_keys[i] == key) {
             *val = ag->ref_table_vals[i];
             // Swap with last element.
             ag->ref_table_len--;
             if (i < ag->ref_table_len) {
                 ag->ref_table_keys[i] = ag->ref_table_keys[ag->ref_table_len];
                 ag->ref_table_vals[i] = ag->ref_table_vals[ag->ref_table_len];
             }
             return true;
         }
     }
     return false;
 }
 
 // --- Result location (AstGen.zig:11808) ---
 // Simplified version of ResultInfo.Loc.
 // Defined here (before GenZir) because GenZir.break_result_info uses it.
 
 // ResultInfo.Context (AstGen.zig:371-386).
 typedef enum {
     RI_CTX_NONE,
     RI_CTX_RETURN,
     RI_CTX_ERROR_HANDLING_EXPR,
     RI_CTX_SHIFT_OP,
     RI_CTX_FN_ARG,
     RI_CTX_CONST_INIT,
     RI_CTX_ASSIGNMENT,
 } ResultCtx;
 
 typedef enum {
     RL_NONE, // Just compute the value.
     RL_REF, // Compute a pointer to the value.
     RL_DISCARD, // Compute but discard (emit ensure_result_non_error).
     RL_TY, // Coerce to specific type.
     RL_COERCED_TY, // Coerce to specific type, result is the coercion.
     RL_PTR, // Store result to typed pointer. data=alloc inst, src_node=node.
     RL_INFERRED_PTR, // Store result to inferred pointer. data=alloc inst.
     RL_REF_COERCED_TY, // Ref with pointer type. data=ptr_ty_inst.
 } ResultLocTag;
 
 typedef struct {
     ResultLocTag tag;
     uint32_t data; // ZirInstRef: ty_inst for TY/COERCED_TY, alloc inst for
                    // PTR/INFERRED_PTR.
     uint32_t src_node; // Only used for RL_PTR.
     ResultCtx ctx; // ResultInfo.Context (AstGen.zig:371).
 } ResultLoc;
 
 #define RL_NONE_VAL                                                           \
     ((ResultLoc) {                                                            \
         .tag = RL_NONE, .data = 0, .src_node = 0, .ctx = RI_CTX_NONE })
 #define RL_REF_VAL                                                            \
     ((ResultLoc) {                                                            \
         .tag = RL_REF, .data = 0, .src_node = 0, .ctx = RI_CTX_NONE })
 #define RL_DISCARD_VAL                                                        \
     ((ResultLoc) {                                                            \
         .tag = RL_DISCARD, .data = 0, .src_node = 0, .ctx = RI_CTX_NONE })
 #define RL_IS_REF(rl) ((rl).tag == RL_REF || (rl).tag == RL_REF_COERCED_TY)
 
 // --- Scope types (AstGen.zig:11621-11768) ---
 
 typedef enum {
     SCOPE_GEN_ZIR,
     SCOPE_LOCAL_VAL,
     SCOPE_LOCAL_PTR,
     SCOPE_DEFER_NORMAL,
     SCOPE_DEFER_ERROR,
     SCOPE_NAMESPACE,
     SCOPE_TOP,
     SCOPE_LABEL,
 } ScopeTag;
 
 typedef struct Scope {
     ScopeTag tag;
 } Scope;
 
 // --- GenZir scope (mirrors GenZir struct, AstGen.zig:11772) ---
 //
 // Sub-blocks share the parent AstGenCtx's scratch_instructions array and
 // record their starting offset (instructions_top). This mirrors the upstream
 // GenZir.instructions / instructions_top design (AstGen.zig:11796-11850).
 
 typedef struct {
     Scope base; // tag = SCOPE_GEN_ZIR
     Scope* parent;
     AstGenCtx* astgen;
     uint32_t decl_node_index;
     uint32_t decl_line;
     bool is_comptime;
     bool is_inline; // true for inline for/while, labeled blocks in comptime
     bool c_import; // true inside @cImport block
     uint32_t instructions_top; // start index in shared array
     uint32_t break_block; // UINT32_MAX = none (AstGen.zig:11780)
     uint32_t continue_block; // UINT32_MAX = none (AstGen.zig:11784)
     // Label for labeled blocks (AstGen.zig:11800, 11869-11874).
     uint32_t label_token; // UINT32_MAX = no label
     uint32_t label_block_inst; // the BLOCK instruction index
     ResultLoc break_result_info; // RL for break values
 } GenZir;
 
 // Scope.LocalVal (AstGen.zig:11682).
 // This is always a `const` local and the `inst` is a value type, not a
 // pointer.
 typedef struct {
     Scope base; // tag = SCOPE_LOCAL_VAL
     Scope* parent;
     GenZir* gen_zir;
     uint32_t inst; // ZirInstRef
     uint32_t token_src; // Ast.TokenIndex
     uint32_t name; // NullTerminatedString (string table index)
 } ScopeLocalVal;
 
 // Scope.LocalPtr (AstGen.zig:11704).
 // This could be a `const` or `var` local. It has a pointer instead of a value.
 typedef struct {
     Scope base; // tag = SCOPE_LOCAL_PTR
     Scope* parent;
     GenZir* gen_zir;
     uint32_t ptr; // ZirInstRef
     uint32_t token_src; // Ast.TokenIndex
     uint32_t name; // NullTerminatedString (string table index)
     bool maybe_comptime;
 } ScopeLocalPtr;
 
 // Scope.Defer (AstGen.zig:11741).
 typedef struct {
     Scope base; // tag = SCOPE_DEFER_NORMAL or SCOPE_DEFER_ERROR
     Scope* parent;
     uint32_t index;
     uint32_t len;
 } ScopeDefer;
 
 // Scope.Label — for labeled blocks and loops.
 typedef struct {
     Scope base; // tag = SCOPE_LABEL
     Scope* parent;
     uint32_t label_name; // NullTerminatedString
     uint32_t block_inst; // instruction index (not ref)
 } ScopeLabel;
 
 // --- GenZir instruction helpers (AstGen.zig:11830-11850) ---
 
 // Returns the number of instructions in this scope.
 static uint32_t gzInstructionsLen(const GenZir* gz) {
     return gz->astgen->scratch_inst_len - gz->instructions_top;
 }
 
 // Returns pointer to start of this scope's instructions in the shared array.
 static const uint32_t* gzInstructionsSlice(const GenZir* gz) {
     return gz->astgen->scratch_instructions + gz->instructions_top;
 }
 
 // Mirrors GenZir.instructionsSliceUpto (AstGen.zig:11835).
 // Returns instructions from gz up to (but not including) stacked_gz's start.
 static uint32_t gzInstructionsLenUpto(
     const GenZir* gz, const GenZir* stacked_gz) {
     return stacked_gz->instructions_top - gz->instructions_top;
 }
 
 static const uint32_t* gzInstructionsSliceUpto(
     const GenZir* gz, const GenZir* stacked_gz) {
     (void)stacked_gz; // used only for length computation
     return gz->astgen->scratch_instructions + gz->instructions_top;
 }
 
 // Mirrors GenZir.unstack (AstGen.zig:11822).
 // Restores the shared array length to this scope's start.
 static void gzUnstack(GenZir* gz) {
     gz->astgen->scratch_inst_len = gz->instructions_top;
 }
 
 // Append an instruction index to this scope's portion of the shared array.
 static void gzAppendInstruction(GenZir* gz, uint32_t inst_idx) {
     AstGenCtx* ag = gz->astgen;
     if (ag->scratch_inst_len >= ag->scratch_inst_cap) {
         uint32_t new_cap
             = ag->scratch_inst_cap > 0 ? ag->scratch_inst_cap * 2 : 64;
         uint32_t* p
             = realloc(ag->scratch_instructions, new_cap * sizeof(uint32_t));
         if (!p)
             exit(1);
         ag->scratch_instructions = p;
         ag->scratch_inst_cap = new_cap;
     }
     ag->scratch_instructions[ag->scratch_inst_len++] = inst_idx;
 }
 
 // Mirrors GenZir.makeSubBlock (AstGen.zig:11852).
 static GenZir makeSubBlock(GenZir* parent, Scope* scope) {
     GenZir sub;
     memset(&sub, 0, sizeof(sub));
     sub.base.tag = SCOPE_GEN_ZIR;
     sub.parent = scope;
     sub.astgen = parent->astgen;
     sub.decl_node_index = parent->decl_node_index;
     sub.decl_line = parent->decl_line;
     sub.is_comptime = parent->is_comptime;
     sub.c_import = parent->c_import;
     sub.instructions_top = parent->astgen->scratch_inst_len;
     sub.break_block = UINT32_MAX;
     sub.continue_block = UINT32_MAX;
     sub.label_token = UINT32_MAX;
     return sub;
 }
 
 // --- Capacity helpers ---
 
 static void ensureExtraCapacity(AstGenCtx* ag, uint32_t additional) {
     uint32_t needed = ag->extra_len + additional;
     if (needed > ag->extra_cap) {
         uint32_t new_cap = ag->extra_cap * 2;
         if (new_cap < needed)
             new_cap = needed;
         uint32_t* p = realloc(ag->extra, new_cap * sizeof(uint32_t));
         if (!p)
             exit(1);
         ag->extra = p;
         ag->extra_cap = new_cap;
     }
 }
 
 static void ensureInstCapacity(AstGenCtx* ag, uint32_t additional) {
     uint32_t needed = ag->inst_len + additional;
     if (needed > ag->inst_cap) {
         uint32_t new_cap = ag->inst_cap * 2;
         if (new_cap < needed)
             new_cap = needed;
         ZirInstTag* t = realloc(ag->inst_tags, new_cap * sizeof(ZirInstTag));
         ZirInstData* d
             = realloc(ag->inst_datas, new_cap * sizeof(ZirInstData));
         if (!t || !d)
             exit(1);
         ag->inst_tags = t;
         ag->inst_datas = d;
         ag->inst_cap = new_cap;
     }
 }
 
 static void ensureStringBytesCapacity(AstGenCtx* ag, uint32_t additional) {
     uint32_t needed = ag->string_bytes_len + additional;
     if (needed > ag->string_bytes_cap) {
         uint32_t new_cap = ag->string_bytes_cap * 2;
         if (new_cap < needed)
             new_cap = needed;
         uint8_t* p = realloc(ag->string_bytes, new_cap * sizeof(uint8_t));
         if (!p)
             exit(1);
         ag->string_bytes = p;
         ag->string_bytes_cap = new_cap;
     }
 }
 
 // --- Extra data helpers ---
 
 static uint32_t addExtraU32(AstGenCtx* ag, uint32_t value) {
     ensureExtraCapacity(ag, 1);
     uint32_t idx = ag->extra_len;
     ag->extra[ag->extra_len++] = value;
     return idx;
 }
 
 // --- Instruction helpers ---
 
 // Mirrors AstGen.reserveInstructionIndex (AstGen.zig:12902).
 static uint32_t reserveInstructionIndex(AstGenCtx* ag) {
     ensureInstCapacity(ag, 1);
     uint32_t idx = ag->inst_len;
     memset(&ag->inst_datas[idx], 0, sizeof(ZirInstData));
     ag->inst_tags[idx] = (ZirInstTag)0;
     ag->inst_len++;
     return idx;
 }
 
 // Forward declarations.
 static int32_t tokenIndexToRelative(const GenZir* gz, uint32_t token);
 static uint32_t firstToken(const Ast* tree, uint32_t node);
 static bool nodesNeedRlContains(const AstGenCtx* ag, uint32_t node);
 
 // Mirrors GenZir.makeUnTok (AstGen.zig:12520).
 // Allocates an instruction but does NOT add to GenZir body.
 // Returns the raw instruction INDEX (not a Ref).
 static uint32_t makeUnTok(
     GenZir* gz, ZirInstTag tag, uint32_t operand, uint32_t abs_tok_index) {
     AstGenCtx* ag = gz->astgen;
     ensureInstCapacity(ag, 1);
     uint32_t idx = ag->inst_len;
     ZirInstData data;
     data.un_tok.src_tok = tokenIndexToRelative(gz, abs_tok_index);
     data.un_tok.operand = operand;
     ag->inst_tags[idx] = tag;
     ag->inst_datas[idx] = data;
     ag->inst_len++;
     return idx; // Raw index, NOT a Ref.
 }
 
 // Mirrors GenZir.add (AstGen.zig:13162).
 // Appends an instruction and records it in the GenZir body.
 // Returns the instruction index as a Ref (index + ZIR_INST_REF_START_INDEX).
 static uint32_t addInstruction(GenZir* gz, ZirInstTag tag, ZirInstData data) {
     AstGenCtx* ag = gz->astgen;
     ensureInstCapacity(ag, 1);
     uint32_t idx = ag->inst_len;
     ag->inst_tags[idx] = tag;
     ag->inst_datas[idx] = data;
     ag->inst_len++;
     // Record in sub-block body.
     gzAppendInstruction(gz, idx);
     return idx + ZIR_REF_START_INDEX; // toRef()
 }
 
 // Mirrors GenZir.addInt (AstGen.zig:12238).
 static uint32_t addInt(GenZir* gz, uint64_t integer) {
     ZirInstData data;
     data.int_val = integer;
     return addInstruction(gz, ZIR_INST_INT, data);
 }
 
 // Mirrors GenZir.add for bin data (Zir.zig:1877).
 // Creates an instruction with bin data (lhs + rhs stored in inst_datas).
 static uint32_t addBin(
     GenZir* gz, ZirInstTag tag, uint32_t lhs, uint32_t rhs) {
     ZirInstData data;
     data.bin.lhs = lhs;
     data.bin.rhs = rhs;
     return addInstruction(gz, tag, data);
 }
 
 // Mirrors GenZir.addPlNode (AstGen.zig:12308).
 // Creates an instruction with pl_node data and 2-word payload.
 static uint32_t addPlNodeBin(
     GenZir* gz, ZirInstTag tag, uint32_t node, uint32_t lhs, uint32_t rhs) {
     AstGenCtx* ag = gz->astgen;
     ensureExtraCapacity(ag, 2);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = lhs;
     ag->extra[ag->extra_len++] = rhs;
     ZirInstData data;
     data.pl_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
     data.pl_node.payload_index = payload_index;
     return addInstruction(gz, tag, data);
 }
 
 // Mirrors addPlNode for 3-operand payloads (e.g. ArrayTypeSentinel).
 static uint32_t addPlNodeTriple(GenZir* gz, ZirInstTag tag, uint32_t node,
     uint32_t a, uint32_t b, uint32_t c) {
     AstGenCtx* ag = gz->astgen;
     ensureExtraCapacity(ag, 3);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = a;
     ag->extra[ag->extra_len++] = b;
     ag->extra[ag->extra_len++] = c;
     ZirInstData data;
     data.pl_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
     data.pl_node.payload_index = payload_index;
     return addInstruction(gz, tag, data);
 }
 
 // Checks if an AST identifier node is the single underscore `_`.
 // Used for inferred array length detection in [_]T patterns.
 // Intentionally does NOT support @"_" syntax (matches upstream).
 static bool isUnderscoreIdent(const Ast* tree, uint32_t ident_node) {
     uint32_t id_tok = tree->nodes.main_tokens[ident_node];
     uint32_t id_start = tree->tokens.starts[id_tok];
     if (tree->source[id_start] != '_')
         return false;
     if (id_start + 1 >= tree->source_len)
         return true;
     char next = tree->source[id_start + 1];
     return !((next >= 'a' && next <= 'z') || (next >= 'A' && next <= 'Z')
         || next == '_' || (next >= '0' && next <= '9'));
 }
 
 // Mirrors GenZir.addUnNode (AstGen.zig:12406).
 static uint32_t addUnNode(
     GenZir* gz, ZirInstTag tag, uint32_t operand, uint32_t node) {
     ZirInstData data;
     data.un_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
     data.un_node.operand = operand;
     return addInstruction(gz, tag, data);
 }
 
 // Mirrors GenZir.addUnTok (AstGen.zig:12497).
 static uint32_t addUnTok(
     GenZir* gz, ZirInstTag tag, uint32_t operand, uint32_t abs_tok_index) {
     ZirInstData data;
     data.un_tok.src_tok = tokenIndexToRelative(gz, abs_tok_index);
     data.un_tok.operand = operand;
     return addInstruction(gz, tag, data);
 }
 
 // Mirrors GenZir.addStrTok (AstGen.zig:12349).
 static uint32_t addStrTok(
     GenZir* gz, ZirInstTag tag, uint32_t str_index, uint32_t token) {
     ZirInstData data;
     data.str_tok.start = str_index;
     data.str_tok.src_tok = tokenIndexToRelative(gz, token);
     return addInstruction(gz, tag, data);
 }
 
 // Mirrors GenZir.addPlNodePayloadIndex (AstGen.zig:12332).
 static uint32_t addPlNodePayloadIndex(
     GenZir* gz, ZirInstTag tag, uint32_t node, uint32_t payload_index) {
     ZirInstData data;
     data.pl_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
     data.pl_node.payload_index = payload_index;
     return addInstruction(gz, tag, data);
 }
 
 // --- Source cursor (AstGen.zig:13335-13359) ---
 
 // Mirrors AstGen.advanceSourceCursor (AstGen.zig:13342).
 static void advanceSourceCursor(AstGenCtx* ag, uint32_t end) {
     const char* source = ag->tree->source;
     uint32_t i = ag->source_offset;
     uint32_t line = ag->source_line;
     uint32_t column = ag->source_column;
     assert(i <= end);
     while (i < end) {
         if (source[i] == '\n') {
             line++;
             column = 0;
         } else {
             column++;
         }
         i++;
     }
     ag->source_offset = i;
     ag->source_line = line;
     ag->source_column = column;
 }
 
 // Mirrors tree.firstToken (Ast.zig:596).
 // Recurse through nodes to find the first token.
 static uint32_t firstToken(const Ast* tree, uint32_t node) {
     uint32_t n = node;
     while (1) {
         AstNodeTag tag = tree->nodes.tags[n];
         switch (tag) {
         case AST_NODE_ROOT:
             return 0;
 
         // Return main_token directly (Ast.zig:602-643).
         case AST_NODE_TEST_DECL:
         case AST_NODE_ERRDEFER:
         case AST_NODE_DEFER:
         case AST_NODE_BOOL_NOT:
         case AST_NODE_NEGATION:
         case AST_NODE_BIT_NOT:
         case AST_NODE_NEGATION_WRAP:
         case AST_NODE_ADDRESS_OF:
         case AST_NODE_TRY:
         case AST_NODE_AWAIT:
         case AST_NODE_OPTIONAL_TYPE:
         case AST_NODE_SWITCH:
         case AST_NODE_SWITCH_COMMA:
         case AST_NODE_IF_SIMPLE:
         case AST_NODE_IF:
         case AST_NODE_SUSPEND:
         case AST_NODE_RESUME:
         case AST_NODE_CONTINUE:
         case AST_NODE_BREAK:
         case AST_NODE_RETURN:
         case AST_NODE_ANYFRAME_TYPE:
         case AST_NODE_IDENTIFIER:
         case AST_NODE_ANYFRAME_LITERAL:
         case AST_NODE_CHAR_LITERAL:
         case AST_NODE_NUMBER_LITERAL:
         case AST_NODE_UNREACHABLE_LITERAL:
         case AST_NODE_STRING_LITERAL:
         case AST_NODE_MULTILINE_STRING_LITERAL:
         case AST_NODE_GROUPED_EXPRESSION:
         case AST_NODE_BUILTIN_CALL_TWO:
         case AST_NODE_BUILTIN_CALL_TWO_COMMA:
         case AST_NODE_BUILTIN_CALL:
         case AST_NODE_BUILTIN_CALL_COMMA:
         case AST_NODE_ERROR_SET_DECL:
         case AST_NODE_COMPTIME:
         case AST_NODE_NOSUSPEND:
         case AST_NODE_ASM_SIMPLE:
         case AST_NODE_ASM:
         case AST_NODE_ARRAY_TYPE:
         case AST_NODE_ARRAY_TYPE_SENTINEL:
         case AST_NODE_ERROR_VALUE:
         case AST_NODE_PTR_TYPE_ALIGNED:
         case AST_NODE_PTR_TYPE_SENTINEL:
         case AST_NODE_PTR_TYPE:
         case AST_NODE_PTR_TYPE_BIT_RANGE:
             return tree->nodes.main_tokens[n];
 
         // Return main_token - 1: dot-prefixed inits and enum_literal
         // (Ast.zig:645-654).
         case AST_NODE_ARRAY_INIT_DOT:
         case AST_NODE_ARRAY_INIT_DOT_COMMA:
         case AST_NODE_ARRAY_INIT_DOT_TWO:
         case AST_NODE_ARRAY_INIT_DOT_TWO_COMMA:
         case AST_NODE_STRUCT_INIT_DOT:
         case AST_NODE_STRUCT_INIT_DOT_COMMA:
         case AST_NODE_STRUCT_INIT_DOT_TWO:
         case AST_NODE_STRUCT_INIT_DOT_TWO_COMMA:
         case AST_NODE_ENUM_LITERAL:
             return tree->nodes.main_tokens[n] - 1;
 
         // Recurse into LHS: all binary ops and compound expressions
         // (Ast.zig:656-733).
         case AST_NODE_CATCH:
         case AST_NODE_EQUAL_EQUAL:
         case AST_NODE_BANG_EQUAL:
         case AST_NODE_LESS_THAN:
         case AST_NODE_GREATER_THAN:
         case AST_NODE_LESS_OR_EQUAL:
         case AST_NODE_GREATER_OR_EQUAL:
         case AST_NODE_ASSIGN_MUL:
         case AST_NODE_ASSIGN_DIV:
         case AST_NODE_ASSIGN_MOD:
         case AST_NODE_ASSIGN_ADD:
         case AST_NODE_ASSIGN_SUB:
         case AST_NODE_ASSIGN_SHL:
         case AST_NODE_ASSIGN_SHL_SAT:
         case AST_NODE_ASSIGN_SHR:
         case AST_NODE_ASSIGN_BIT_AND:
         case AST_NODE_ASSIGN_BIT_XOR:
         case AST_NODE_ASSIGN_BIT_OR:
         case AST_NODE_ASSIGN_MUL_WRAP:
         case AST_NODE_ASSIGN_ADD_WRAP:
         case AST_NODE_ASSIGN_SUB_WRAP:
         case AST_NODE_ASSIGN_MUL_SAT:
         case AST_NODE_ASSIGN_ADD_SAT:
         case AST_NODE_ASSIGN_SUB_SAT:
         case AST_NODE_ASSIGN:
         case AST_NODE_MERGE_ERROR_SETS:
         case AST_NODE_MUL:
         case AST_NODE_DIV:
         case AST_NODE_MOD:
         case AST_NODE_ARRAY_MULT:
         case AST_NODE_MUL_WRAP:
         case AST_NODE_MUL_SAT:
         case AST_NODE_ADD:
         case AST_NODE_SUB:
         case AST_NODE_ARRAY_CAT:
         case AST_NODE_ADD_WRAP:
         case AST_NODE_SUB_WRAP:
         case AST_NODE_ADD_SAT:
         case AST_NODE_SUB_SAT:
         case AST_NODE_SHL:
         case AST_NODE_SHL_SAT:
         case AST_NODE_SHR:
         case AST_NODE_BIT_AND:
         case AST_NODE_BIT_XOR:
         case AST_NODE_BIT_OR:
         case AST_NODE_ORELSE:
         case AST_NODE_BOOL_AND:
         case AST_NODE_BOOL_OR:
         case AST_NODE_SLICE_OPEN:
         case AST_NODE_ARRAY_ACCESS:
         case AST_NODE_ARRAY_INIT_ONE:
         case AST_NODE_ARRAY_INIT_ONE_COMMA:
         case AST_NODE_SWITCH_RANGE:
         case AST_NODE_ERROR_UNION:
         case AST_NODE_FOR_RANGE:
         case AST_NODE_CALL_ONE:
         case AST_NODE_CALL_ONE_COMMA:
         case AST_NODE_STRUCT_INIT_ONE:
         case AST_NODE_STRUCT_INIT_ONE_COMMA:
         case AST_NODE_CALL:
         case AST_NODE_CALL_COMMA:
         case AST_NODE_STRUCT_INIT:
         case AST_NODE_STRUCT_INIT_COMMA:
         case AST_NODE_SLICE:
         case AST_NODE_SLICE_SENTINEL:
         case AST_NODE_ARRAY_INIT:
         case AST_NODE_ARRAY_INIT_COMMA:
         case AST_NODE_FIELD_ACCESS:
         case AST_NODE_UNWRAP_OPTIONAL:
         case AST_NODE_DEREF:
         case AST_NODE_ASYNC_CALL_ONE:
         case AST_NODE_ASYNC_CALL_ONE_COMMA:
         case AST_NODE_ASYNC_CALL:
         case AST_NODE_ASYNC_CALL_COMMA:
             n = tree->nodes.datas[n].lhs;
             continue;
 
         // Var decls: scan backwards for modifiers (Ast.zig:771-792).
         case AST_NODE_GLOBAL_VAR_DECL:
         case AST_NODE_LOCAL_VAR_DECL:
         case AST_NODE_SIMPLE_VAR_DECL:
         case AST_NODE_ALIGNED_VAR_DECL: {
             uint32_t mt = tree->nodes.main_tokens[n];
             uint32_t i = mt;
             while (i > 0) {
                 TokenizerTag tt = tree->tokens.tags[i - 1];
                 if (tt == TOKEN_KEYWORD_EXTERN || tt == TOKEN_KEYWORD_EXPORT
                     || tt == TOKEN_KEYWORD_PUB
                     || tt == TOKEN_KEYWORD_THREADLOCAL
                     || tt == TOKEN_KEYWORD_COMPTIME
                     || tt == TOKEN_STRING_LITERAL) {
                     i--;
                 } else {
                     break;
                 }
             }
             return i;
         }
         // Fn decls: scan backwards for modifiers (Ast.zig:737-759).
         case AST_NODE_FN_DECL:
         case AST_NODE_FN_PROTO_SIMPLE:
         case AST_NODE_FN_PROTO_MULTI:
         case AST_NODE_FN_PROTO_ONE:
         case AST_NODE_FN_PROTO: {
             uint32_t mt = tree->nodes.main_tokens[n];
             uint32_t i = mt;
             while (i > 0) {
                 TokenizerTag tt = tree->tokens.tags[i - 1];
                 if (tt == TOKEN_KEYWORD_EXTERN || tt == TOKEN_KEYWORD_EXPORT
                     || tt == TOKEN_KEYWORD_PUB || tt == TOKEN_KEYWORD_INLINE
                     || tt == TOKEN_KEYWORD_NOINLINE
                     || tt == TOKEN_STRING_LITERAL) {
                     i--;
                 } else {
                     break;
                 }
             }
             return i;
         }
         // Container fields: check for preceding comptime (Ast.zig:761-769).
         case AST_NODE_CONTAINER_FIELD_INIT:
         case AST_NODE_CONTAINER_FIELD_ALIGN:
         case AST_NODE_CONTAINER_FIELD: {
             uint32_t mt = tree->nodes.main_tokens[n];
             if (mt > 0 && tree->tokens.tags[mt - 1] == TOKEN_KEYWORD_COMPTIME)
                 return mt - 1;
             return mt;
         }
         // Blocks: check for label (Ast.zig:794-805).
         case AST_NODE_BLOCK:
         case AST_NODE_BLOCK_SEMICOLON:
         case AST_NODE_BLOCK_TWO:
         case AST_NODE_BLOCK_TWO_SEMICOLON: {
             uint32_t lbrace = tree->nodes.main_tokens[n];
             if (lbrace >= 2 && tree->tokens.tags[lbrace - 1] == TOKEN_COLON
                 && tree->tokens.tags[lbrace - 2] == TOKEN_IDENTIFIER)
                 return lbrace - 2;
             return lbrace;
         }
         // Fallback for any remaining node types.
         default:
             return tree->nodes.main_tokens[n];
         }
     }
 }
 
 // Mirrors AstGen.advanceSourceCursorToNode (AstGen.zig:13335).
 static void advanceSourceCursorToNode(AstGenCtx* ag, uint32_t node) {
     uint32_t ft = firstToken(ag->tree, node);
     uint32_t token_start = ag->tree->tokens.starts[ft];
     (void)0; // cursor backward check disabled temporarily
     advanceSourceCursor(ag, token_start);
 }
 
 // Mirrors maybeAdvanceSourceCursorToMainToken (AstGen.zig:13324).
 // Skips advancing when in comptime scope (matching upstream behavior).
 static void advanceSourceCursorToMainToken(
     AstGenCtx* ag, const GenZir* gz, uint32_t node) {
     if (gz->is_comptime)
         return;
     uint32_t main_tok = ag->tree->nodes.main_tokens[node];
     uint32_t token_start = ag->tree->tokens.starts[main_tok];
     advanceSourceCursor(ag, token_start);
 }
 
 // --- Token helpers ---
 
 // Mirrors GenZir.tokenIndexToRelative (AstGen.zig:11897).
 // Returns destination - base as i32.
 static int32_t tokenIndexToRelative(const GenZir* gz, uint32_t token) {
     uint32_t base = firstToken(gz->astgen->tree, gz->decl_node_index);
     return (int32_t)token - (int32_t)base;
 }
 
 // --- String bytes helpers ---
 
 // Search for an existing null-terminated string in string_bytes.
 // Returns the index if found, or UINT32_MAX if not found.
 // Mirrors string_table dedup (AstGen.zig:11564).
 // Find a string in string_table (registered strings only).
 // Mirrors AstGen.string_table hash table lookup.
 static uint32_t findExistingString(
     const AstGenCtx* ag, const char* str, uint32_t len) {
     for (uint32_t k = 0; k < ag->string_table_len; k++) {
         uint32_t pos = ag->string_table[k];
         // Compare: string at pos is null-terminated in string_bytes.
         const char* existing = (const char*)ag->string_bytes + pos;
         uint32_t existing_len = (uint32_t)strlen(existing);
         if (existing_len == len && memcmp(existing, str, len) == 0) {
             return pos;
         }
     }
     return UINT32_MAX;
 }
 
 // Register a string position in the string table for deduplication.
 static void registerString(AstGenCtx* ag, uint32_t pos) {
     if (ag->string_table_len >= ag->string_table_cap) {
         uint32_t new_cap = ag->string_table_cap * 2;
         if (new_cap < 64)
             new_cap = 64;
         uint32_t* p = realloc(ag->string_table, new_cap * sizeof(uint32_t));
         if (!p)
             exit(1);
         ag->string_table = p;
         ag->string_table_cap = new_cap;
     }
     ag->string_table[ag->string_table_len++] = pos;
 }
 
 // Mirrors AstGen.tokenIdentEql (AstGen.zig:6148-6152).
 // Compares two identifier tokens by source text without touching string_bytes.
 static bool tokenIdentEql(const Ast* tree, uint32_t tok1, uint32_t tok2) {
     uint32_t s1 = tree->tokens.starts[tok1];
     uint32_t s2 = tree->tokens.starts[tok2];
     uint32_t e1 = tree->tokens.starts[tok1 + 1];
     uint32_t e2 = tree->tokens.starts[tok2 + 1];
     // Token length includes trailing whitespace in starts delta, but for
     // identifiers the actual content is a contiguous alphanumeric/underscore
     // run. Compute actual identifier lengths.
     uint32_t len1 = 0;
     while (s1 + len1 < e1) {
         char c = tree->source[s1 + len1];
         if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
                 || (c >= '0' && c <= '9') || c == '_'))
             break;
         len1++;
     }
     uint32_t len2 = 0;
     while (s2 + len2 < e2) {
         char c = tree->source[s2 + len2];
         if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
                 || (c >= '0' && c <= '9') || c == '_'))
             break;
         len2++;
     }
     return len1 == len2
         && memcmp(tree->source + s1, tree->source + s2, len1) == 0;
 }
 
 // Forward declaration for strLitAsString (used by identAsString for @"..."
 // quoted identifiers with escapes).
 static void strLitAsString(AstGenCtx* ag, uint32_t str_lit_token,
     uint32_t* out_index, uint32_t* out_len);
 
 // Mirrors AstGen.identAsString (AstGen.zig:11530).
 // Handles both bare identifiers and @"..." quoted identifiers.
 static uint32_t identAsString(AstGenCtx* ag, uint32_t ident_token) {
     uint32_t start = ag->tree->tokens.starts[ident_token];
     const char* source = ag->tree->source;
 
     if (source[start] == '@' && start + 1 < ag->tree->source_len
         && source[start + 1] == '"') {
         // Quoted identifier: @"name" (AstGen.zig:11297-11308).
         // Extract content between quotes, handling escapes.
         uint32_t si, sl;
         // str_lit_token refers to the same token, content starts after @"
         // We reuse strLitAsString but offset by 1 to skip '@'.
         // Actually, strLitAsString expects a token whose source starts
         // with '"'. The @"..." token starts with '@'. We need to handle
         // the offset manually.
         uint32_t content_start = start + 2; // skip @"
         uint32_t content_end = content_start;
         while (
             content_end < ag->tree->source_len && source[content_end] != '"')
             content_end++;
         // Check for escapes.
         bool has_escapes = false;
         for (uint32_t j = content_start; j < content_end; j++) {
             if (source[j] == '\\') {
                 has_escapes = true;
                 break;
             }
         }
 
         if (!has_escapes) {
             uint32_t content_len = content_end - content_start;
             uint32_t existing
                 = findExistingString(ag, source + content_start, content_len);
             if (existing != UINT32_MAX)
                 return existing;
             uint32_t str_index = ag->string_bytes_len;
             ensureStringBytesCapacity(ag, content_len + 1);
             memcpy(ag->string_bytes + ag->string_bytes_len,
                 source + content_start, content_len);
             ag->string_bytes_len += content_len;
             ag->string_bytes[ag->string_bytes_len++] = 0;
             registerString(ag, str_index);
             return str_index;
         }
 
         // With escapes: use strLitAsString-like decoding.
         strLitAsString(ag, ident_token, &si, &sl);
         return si;
     }
 
     // Bare identifier: scan alphanumeric + underscore.
     uint32_t end = start;
     while (end < ag->tree->source_len) {
         char ch = source[end];
         if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
             || (ch >= '0' && ch <= '9') || ch == '_') {
             end++;
         } else {
             break;
         }
     }
     uint32_t ident_len = end - start;
 
     // Check for existing string (dedup).
     uint32_t existing = findExistingString(ag, source + start, ident_len);
     if (existing != UINT32_MAX)
         return existing;
 
     uint32_t str_index = ag->string_bytes_len;
     ensureStringBytesCapacity(ag, ident_len + 1);
     memcpy(ag->string_bytes + ag->string_bytes_len, source + start, ident_len);
     ag->string_bytes_len += ident_len;
     ag->string_bytes[ag->string_bytes_len++] = 0;
     registerString(ag, str_index);
     return str_index;
 }
 
 // Mirrors AstGen.strLitAsString (AstGen.zig:11553).
 // Decodes string literal, checks for embedded nulls.
 // If embedded null found: store raw bytes without trailing null, no dedup.
 // Otherwise: dedup via string_table, add trailing null.
 static void strLitAsString(AstGenCtx* ag, uint32_t str_lit_token,
     uint32_t* out_index, uint32_t* out_len) {
     uint32_t tok_start = ag->tree->tokens.starts[str_lit_token];
     const char* source = ag->tree->source;
 
     // Skip opening quote.
     uint32_t i = tok_start + 1;
     // Find closing quote, skipping escaped characters.
     uint32_t raw_end = i;
     while (raw_end < ag->tree->source_len) {
         if (source[raw_end] == '\\') {
             raw_end += 2; // skip escape + escaped char
         } else if (source[raw_end] == '"') {
             break;
         } else {
             raw_end++;
         }
     }
 
     // Check if there are any escape sequences.
     bool has_escapes = false;
     for (uint32_t j = i; j < raw_end; j++) {
         if (source[j] == '\\') {
             has_escapes = true;
             break;
         }
     }
 
     if (!has_escapes) {
         // Fast path: no escapes, no embedded nulls possible.
         uint32_t content_len = raw_end - i;
         uint32_t existing = findExistingString(ag, source + i, content_len);
         if (existing != UINT32_MAX) {
             *out_index = existing;
             *out_len = content_len;
             return;
         }
         uint32_t str_index = ag->string_bytes_len;
         ensureStringBytesCapacity(ag, content_len + 1);
         memcpy(
             ag->string_bytes + ag->string_bytes_len, source + i, content_len);
         ag->string_bytes_len += content_len;
         ag->string_bytes[ag->string_bytes_len++] = 0;
         registerString(ag, str_index);
         *out_index = str_index;
         *out_len = content_len;
         return;
     }
 
     // Slow path: process escape sequences (AstGen.zig:11558).
     // Decode directly into string_bytes (like upstream).
     uint32_t str_index = ag->string_bytes_len;
     uint32_t max_len = raw_end - i;
     ensureStringBytesCapacity(ag, max_len + 1);
     while (i < raw_end) {
         if (source[i] == '\\') {
             i++;
             if (i >= raw_end)
                 break;
             switch (source[i]) {
             case 'n':
                 ag->string_bytes[ag->string_bytes_len++] = '\n';
                 break;
             case 'r':
                 ag->string_bytes[ag->string_bytes_len++] = '\r';
                 break;
             case 't':
                 ag->string_bytes[ag->string_bytes_len++] = '\t';
                 break;
             case '\\':
                 ag->string_bytes[ag->string_bytes_len++] = '\\';
                 break;
             case '\'':
                 ag->string_bytes[ag->string_bytes_len++] = '\'';
                 break;
             case '"':
                 ag->string_bytes[ag->string_bytes_len++] = '"';
                 break;
             case 'x': {
                 // \xNN hex escape.
                 uint8_t val = 0;
                 for (int k = 0; k < 2 && i + 1 < raw_end; k++) {
                     i++;
                     char c = source[i];
                     if (c >= '0' && c <= '9')
                         val = (uint8_t)(val * 16 + (uint8_t)(c - '0'));
                     else if (c >= 'a' && c <= 'f')
                         val = (uint8_t)(val * 16 + 10 + (uint8_t)(c - 'a'));
                     else if (c >= 'A' && c <= 'F')
                         val = (uint8_t)(val * 16 + 10 + (uint8_t)(c - 'A'));
                 }
                 ag->string_bytes[ag->string_bytes_len++] = val;
                 break;
             }
             case 'u': {
                 // \u{NNNNNN} unicode escape (string_literal.zig:194-231).
                 // Skip past '{'.
                 i++;
                 // Parse hex digits until '}'.
                 uint32_t codepoint = 0;
                 while (i + 1 < raw_end) {
                     i++;
                     char c = source[i];
                     if (c >= '0' && c <= '9') {
                         codepoint = codepoint * 16 + (uint32_t)(c - '0');
                     } else if (c >= 'a' && c <= 'f') {
                         codepoint = codepoint * 16 + 10 + (uint32_t)(c - 'a');
                     } else if (c >= 'A' && c <= 'F') {
                         codepoint = codepoint * 16 + 10 + (uint32_t)(c - 'A');
                     } else {
                         // Must be '}', done.
                         break;
                     }
                 }
                 // Encode codepoint as UTF-8 (unicode.zig:53-82).
                 if (codepoint <= 0x7F) {
                     ag->string_bytes[ag->string_bytes_len++]
                         = (uint8_t)codepoint;
                 } else if (codepoint <= 0x7FF) {
                     ag->string_bytes[ag->string_bytes_len++]
                         = (uint8_t)(0xC0 | (codepoint >> 6));
                     ag->string_bytes[ag->string_bytes_len++]
                         = (uint8_t)(0x80 | (codepoint & 0x3F));
                 } else if (codepoint <= 0xFFFF) {
                     ag->string_bytes[ag->string_bytes_len++]
                         = (uint8_t)(0xE0 | (codepoint >> 12));
                     ag->string_bytes[ag->string_bytes_len++]
                         = (uint8_t)(0x80 | ((codepoint >> 6) & 0x3F));
                     ag->string_bytes[ag->string_bytes_len++]
                         = (uint8_t)(0x80 | (codepoint & 0x3F));
                 } else {
                     ag->string_bytes[ag->string_bytes_len++]
                         = (uint8_t)(0xF0 | (codepoint >> 18));
                     ag->string_bytes[ag->string_bytes_len++]
                         = (uint8_t)(0x80 | ((codepoint >> 12) & 0x3F));
                     ag->string_bytes[ag->string_bytes_len++]
                         = (uint8_t)(0x80 | ((codepoint >> 6) & 0x3F));
                     ag->string_bytes[ag->string_bytes_len++]
                         = (uint8_t)(0x80 | (codepoint & 0x3F));
                 }
                 break;
             }
             default:
                 ag->string_bytes[ag->string_bytes_len++] = (uint8_t)source[i];
                 break;
             }
         } else {
             ag->string_bytes[ag->string_bytes_len++] = (uint8_t)source[i];
         }
         i++;
     }
     uint32_t decoded_len = ag->string_bytes_len - str_index;
     uint8_t* key = ag->string_bytes + str_index;
 
     // Check for embedded null bytes (AstGen.zig:11560).
     // If found, skip dedup and don't add trailing null.
     bool has_embedded_null = false;
     for (uint32_t j = 0; j < decoded_len; j++) {
         if (key[j] == 0) {
             has_embedded_null = true;
             break;
         }
     }
     if (has_embedded_null) {
         *out_index = str_index;
         *out_len = decoded_len;
         return;
     }
 
     // Dedup against string_table (AstGen.zig:11564-11585).
     uint32_t existing = findExistingString(ag, (const char*)key, decoded_len);
     if (existing != UINT32_MAX) {
         // Shrink back (AstGen.zig:11570).
         ag->string_bytes_len = str_index;
         *out_index = existing;
         *out_len = decoded_len;
         return;
     }
 
     // New entry: add trailing null and register.
     ensureStringBytesCapacity(ag, 1);
     ag->string_bytes[ag->string_bytes_len++] = 0;
     registerString(ag, str_index);
     *out_index = str_index;
     *out_len = decoded_len;
 }
 
 // --- Declaration helpers ---
 
 // Mirrors GenZir.makeDeclaration (AstGen.zig:12906).
 static uint32_t makeDeclaration(AstGenCtx* ag, uint32_t node) {
     ensureInstCapacity(ag, 1);
     uint32_t idx = ag->inst_len;
     ag->inst_tags[idx] = ZIR_INST_DECLARATION;
     ZirInstData data;
     memset(&data, 0, sizeof(data));
     data.declaration.src_node = node;
     // payload_index is set later by setDeclaration.
     ag->inst_datas[idx] = data;
     ag->inst_len++;
     return idx;
 }
 
 // Mirrors GenZir.makeBreakCommon (AstGen.zig:12667).
 // Creates a break_inline instruction with a Break payload in extra.
 // Records the instruction in the GenZir body.
 static uint32_t makeBreakInline(GenZir* gz, uint32_t block_inst,
     uint32_t operand, int32_t operand_src_node) {
     AstGenCtx* ag = gz->astgen;
     ensureInstCapacity(ag, 1);
     ensureExtraCapacity(ag, 2);
 
     // Write Zir.Inst.Break payload to extra (Zir.zig:2489).
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = (uint32_t)operand_src_node;
     ag->extra[ag->extra_len++] = block_inst;
 
     uint32_t idx = ag->inst_len;
     ag->inst_tags[idx] = ZIR_INST_BREAK_INLINE;
     ZirInstData data;
     data.break_data.operand = operand;
     data.break_data.payload_index = payload_index;
     ag->inst_datas[idx] = data;
     ag->inst_len++;
 
     // Record in sub-block body.
     gzAppendInstruction(gz, idx);
     return idx;
 }
 
 // Mirrors GenZir.makeBlockInst (AstGen.zig:12890).
 // Creates a pl_node instruction with payload_index left as 0 (set later).
 // Does NOT append to gz's instruction list.
 // Returns instruction index (not a ref).
 static uint32_t makeBlockInst(
     AstGenCtx* ag, ZirInstTag tag, const GenZir* gz, uint32_t node) {
     ensureInstCapacity(ag, 1);
     uint32_t idx = ag->inst_len;
     ag->inst_tags[idx] = tag;
     ZirInstData data;
     memset(&data, 0, sizeof(data));
     data.pl_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
     data.pl_node.payload_index = 0; // set later
     ag->inst_datas[idx] = data;
     ag->inst_len++;
     return idx;
 }
 
 // Mirrors appendPossiblyRefdBodyInst (AstGen.zig:13675-13683).
 // Appends body_inst first, then recursively appends ref_table entry.
 static void appendPossiblyRefdBodyInst(AstGenCtx* ag, uint32_t body_inst) {
     ag->extra[ag->extra_len++] = body_inst;
     uint32_t ref_inst;
     if (refTableFetchRemove(ag, body_inst, &ref_inst)) {
         appendPossiblyRefdBodyInst(ag, ref_inst);
     }
 }
 
 // Mirrors appendBodyWithFixupsExtraRefsArrayList (AstGen.zig:13659-13673).
 // First processes extra_refs (e.g. param_insts), prepending their ref_table
 // entries. Then writes body instructions with ref_table fixups.
 static void appendBodyWithFixupsExtraRefs(AstGenCtx* ag, const uint32_t* body,
     uint32_t body_len, const uint32_t* extra_refs, uint32_t extra_refs_len) {
     for (uint32_t i = 0; i < extra_refs_len; i++) {
         uint32_t ref_inst;
         if (refTableFetchRemove(ag, extra_refs[i], &ref_inst)) {
             appendPossiblyRefdBodyInst(ag, ref_inst);
         }
     }
     for (uint32_t i = 0; i < body_len; i++) {
         appendPossiblyRefdBodyInst(ag, body[i]);
     }
 }
 
 // Scratch extra capacity helper (for call arg bodies).
 static void ensureScratchExtraCapacity(AstGenCtx* ag, uint32_t additional) {
     uint32_t needed = ag->scratch_extra_len + additional;
     if (needed > ag->scratch_extra_cap) {
         uint32_t new_cap = ag->scratch_extra_cap * 2;
         if (new_cap < needed)
             new_cap = needed;
         if (new_cap < 64)
             new_cap = 64;
         uint32_t* p = realloc(ag->scratch_extra, new_cap * sizeof(uint32_t));
         if (!p)
             exit(1);
         ag->scratch_extra = p;
         ag->scratch_extra_cap = new_cap;
     }
 }
 
 // Like appendPossiblyRefdBodyInst but appends to scratch_extra instead of
 // extra.
 static void appendPossiblyRefdBodyInstScratch(
     AstGenCtx* ag, uint32_t body_inst) {
     ag->scratch_extra[ag->scratch_extra_len++] = body_inst;
     uint32_t ref_inst;
     if (refTableFetchRemove(ag, body_inst, &ref_inst)) {
         ensureScratchExtraCapacity(ag, 1);
         appendPossiblyRefdBodyInstScratch(ag, ref_inst);
     }
 }
 
 // Mirrors countBodyLenAfterFixupsExtraRefs (AstGen.zig:13694-13711).
 static uint32_t countBodyLenAfterFixupsExtraRefs(AstGenCtx* ag,
     const uint32_t* body, uint32_t body_len, const uint32_t* extra_refs,
     uint32_t extra_refs_len) {
     uint32_t count = body_len;
     for (uint32_t i = 0; i < body_len; i++) {
         uint32_t check_inst = body[i];
         const uint32_t* ref;
         while ((ref = refTableGet(ag, check_inst)) != NULL) {
             count++;
             check_inst = *ref;
         }
     }
     for (uint32_t i = 0; i < extra_refs_len; i++) {
         uint32_t check_inst = extra_refs[i];
         const uint32_t* ref;
         while ((ref = refTableGet(ag, check_inst)) != NULL) {
             count++;
             check_inst = *ref;
         }
     }
     return count;
 }
 
 // Mirrors countBodyLenAfterFixups (AstGen.zig:13686-13688).
 static uint32_t countBodyLenAfterFixups(
     AstGenCtx* ag, const uint32_t* body, uint32_t body_len) {
     return countBodyLenAfterFixupsExtraRefs(ag, body, body_len, NULL, 0);
 }
 
 // Mirrors GenZir.setBlockBody (AstGen.zig:11949).
 // Writes Block payload (body_len + instruction indices) to extra.
 // Sets the instruction's payload_index. Unstacks gz.
 static void setBlockBody(AstGenCtx* ag, GenZir* gz, uint32_t inst) {
     uint32_t raw_body_len = gzInstructionsLen(gz);
     const uint32_t* body = gzInstructionsSlice(gz);
     uint32_t body_len = countBodyLenAfterFixups(ag, body, raw_body_len);
     ensureExtraCapacity(ag, 1 + body_len);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = body_len;
     for (uint32_t i = 0; i < raw_body_len; i++) {
         appendPossiblyRefdBodyInst(ag, body[i]);
     }
     ag->inst_datas[inst].pl_node.payload_index = payload_index;
     gzUnstack(gz);
 }
 
 // Mirrors GenZir.setTryBody (AstGen.zig:11997).
 // Writes Try payload (operand + body_len + instruction indices) to extra.
 // Sets the instruction's payload_index. Unstacks gz.
 static void setTryBody(
     AstGenCtx* ag, GenZir* gz, uint32_t inst, uint32_t operand) {
     uint32_t raw_body_len = gzInstructionsLen(gz);
     const uint32_t* body = gzInstructionsSlice(gz);
     uint32_t body_len = countBodyLenAfterFixups(ag, body, raw_body_len);
     ensureExtraCapacity(ag, 2 + body_len);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = operand; // Try.operand
     ag->extra[ag->extra_len++] = body_len; // Try.body_len
     for (uint32_t i = 0; i < raw_body_len; i++) {
         appendPossiblyRefdBodyInst(ag, body[i]);
     }
     ag->inst_datas[inst].pl_node.payload_index = payload_index;
     gzUnstack(gz);
 }
 
 // Mirrors GenZir.setBlockComptimeBody (AstGen.zig:11972).
 // Like setBlockBody but prepends comptime_reason before body_len.
 // Asserts inst is a BLOCK_COMPTIME.
 static void setBlockComptimeBody(
     AstGenCtx* ag, GenZir* gz, uint32_t inst, uint32_t comptime_reason) {
     uint32_t raw_body_len = gzInstructionsLen(gz);
     const uint32_t* body = gzInstructionsSlice(gz);
     uint32_t body_len = countBodyLenAfterFixups(ag, body, raw_body_len);
     ensureExtraCapacity(ag, 2 + body_len);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = comptime_reason;
     ag->extra[ag->extra_len++] = body_len;
     for (uint32_t i = 0; i < raw_body_len; i++) {
         appendPossiblyRefdBodyInst(ag, body[i]);
     }
     ag->inst_datas[inst].pl_node.payload_index = payload_index;
     gzUnstack(gz);
 }
 
 // Mirrors GenZir.addBreak (AstGen.zig:12623).
 // Creates a ZIR_INST_BREAK instruction.
 static uint32_t addBreak(GenZir* gz, ZirInstTag tag, uint32_t block_inst,
     uint32_t operand, int32_t operand_src_node) {
     AstGenCtx* ag = gz->astgen;
     ensureInstCapacity(ag, 1);
     ensureExtraCapacity(ag, 2);
 
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = (uint32_t)operand_src_node;
     ag->extra[ag->extra_len++] = block_inst;
 
     uint32_t idx = ag->inst_len;
     ag->inst_tags[idx] = tag;
     ZirInstData data;
     data.break_data.operand = operand;
     data.break_data.payload_index = payload_index;
     ag->inst_datas[idx] = data;
     ag->inst_len++;
     gzAppendInstruction(gz, idx);
     return idx;
 }
 
 // Mirrors GenZir.addCondBr (AstGen.zig:12834).
 // Creates condbr instruction placeholder with src_node set.
 // Payload is filled later by setCondBrPayload.
 static uint32_t addCondBr(GenZir* gz, ZirInstTag tag, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     ensureInstCapacity(ag, 1);
     uint32_t idx = ag->inst_len;
     ag->inst_tags[idx] = tag;
     ZirInstData data;
     memset(&data, 0, sizeof(data));
     data.pl_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
     data.pl_node.payload_index = 0; // set later
     ag->inst_datas[idx] = data;
     ag->inst_len++;
     gzAppendInstruction(gz, idx);
     return idx;
 }
 
 // Mirrors setCondBrPayload (AstGen.zig:6501).
 // Writes CondBr payload: {condition, then_body_len, else_body_len} then
 // then_body instructions, then else_body instructions. Unstacks both scopes.
 // IMPORTANT: then_gz and else_gz are stacked (else on top of then), so
 // then's instructions must use instructionsSliceUpto(else_gz) to avoid
 // including else_gz's instructions in then's body.
 static void setCondBrPayload(AstGenCtx* ag, uint32_t condbr_inst,
     uint32_t condition, GenZir* then_gz, GenZir* else_gz) {
     uint32_t raw_then_len = gzInstructionsLenUpto(then_gz, else_gz);
     const uint32_t* then_body = gzInstructionsSliceUpto(then_gz, else_gz);
     uint32_t raw_else_len = gzInstructionsLen(else_gz);
     const uint32_t* else_body = gzInstructionsSlice(else_gz);
 
     uint32_t then_len = countBodyLenAfterFixups(ag, then_body, raw_then_len);
     uint32_t else_len = countBodyLenAfterFixups(ag, else_body, raw_else_len);
 
     ensureExtraCapacity(ag, 3 + then_len + else_len);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = condition; // CondBr.condition
     ag->extra[ag->extra_len++] = then_len; // CondBr.then_body_len
     ag->extra[ag->extra_len++] = else_len; // CondBr.else_body_len
     for (uint32_t i = 0; i < raw_then_len; i++)
         appendPossiblyRefdBodyInst(ag, then_body[i]);
     for (uint32_t i = 0; i < raw_else_len; i++)
         appendPossiblyRefdBodyInst(ag, else_body[i]);
 
     ag->inst_datas[condbr_inst].pl_node.payload_index = payload_index;
     gzUnstack(else_gz);
     gzUnstack(then_gz);
 }
 
 // Does this Declaration.Flags.Id have a name? (Zir.zig:2762)
 static bool declIdHasName(DeclFlagsId id) {
     return id != DECL_ID_UNNAMED_TEST && id != DECL_ID_COMPTIME;
 }
 
 // Does this Declaration.Flags.Id have a lib name? (Zir.zig:2771)
 static bool declIdHasLibName(DeclFlagsId id) {
     switch (id) {
     case DECL_ID_EXTERN_CONST:
     case DECL_ID_PUB_EXTERN_CONST:
     case DECL_ID_EXTERN_VAR:
     case DECL_ID_EXTERN_VAR_THREADLOCAL:
     case DECL_ID_PUB_EXTERN_VAR:
     case DECL_ID_PUB_EXTERN_VAR_THREADLOCAL:
         return true;
     default:
         return false;
     }
 }
 
 // Does this Declaration.Flags.Id have a type body? (Zir.zig:2783)
 static bool declIdHasTypeBody(DeclFlagsId id) {
     switch (id) {
     case DECL_ID_UNNAMED_TEST:
     case DECL_ID_TEST:
     case DECL_ID_DECLTEST:
     case DECL_ID_COMPTIME:
     case DECL_ID_CONST_SIMPLE:
     case DECL_ID_PUB_CONST_SIMPLE:
     case DECL_ID_VAR_SIMPLE:
     case DECL_ID_PUB_VAR_SIMPLE:
         return false;
     default:
         return true;
     }
 }
 
 // Does this Declaration.Flags.Id have a value body? (Zir.zig:2800)
 static bool declIdHasValueBody(DeclFlagsId id) {
     switch (id) {
     case DECL_ID_EXTERN_CONST_SIMPLE:
     case DECL_ID_EXTERN_CONST:
     case DECL_ID_PUB_EXTERN_CONST_SIMPLE:
     case DECL_ID_PUB_EXTERN_CONST:
     case DECL_ID_EXTERN_VAR:
     case DECL_ID_EXTERN_VAR_THREADLOCAL:
     case DECL_ID_PUB_EXTERN_VAR:
     case DECL_ID_PUB_EXTERN_VAR_THREADLOCAL:
         return false;
     default:
         return true;
     }
 }
 
 // Does this Declaration.Flags.Id have special bodies? (Zir.zig:2815)
 static bool declIdHasSpecialBodies(DeclFlagsId id) {
     switch (id) {
     case DECL_ID_UNNAMED_TEST:
     case DECL_ID_TEST:
     case DECL_ID_DECLTEST:
     case DECL_ID_COMPTIME:
     case DECL_ID_CONST_SIMPLE:
     case DECL_ID_CONST_TYPED:
     case DECL_ID_PUB_CONST_SIMPLE:
     case DECL_ID_PUB_CONST_TYPED:
     case DECL_ID_EXTERN_CONST_SIMPLE:
     case DECL_ID_PUB_EXTERN_CONST_SIMPLE:
     case DECL_ID_VAR_SIMPLE:
     case DECL_ID_PUB_VAR_SIMPLE:
         return false;
     default:
         return true;
     }
 }
 
 // Mirrors setDeclaration (AstGen.zig:13883).
 // Full version with type/align/linksection/addrspace/value bodies.
 typedef struct {
     uint32_t src_line;
     uint32_t src_column;
     DeclFlagsId id;
     uint32_t name; // NullTerminatedString index
     uint32_t lib_name; // NullTerminatedString index (UINT32_MAX=none)
     const uint32_t* type_body;
     uint32_t type_body_len;
     const uint32_t* align_body;
     uint32_t align_body_len;
     const uint32_t* linksection_body;
     uint32_t linksection_body_len;
     const uint32_t* addrspace_body;
     uint32_t addrspace_body_len;
     const uint32_t* value_body;
     uint32_t value_body_len;
 } SetDeclArgs;
 
 static void setDeclaration(
     AstGenCtx* ag, uint32_t decl_inst, SetDeclArgs args) {
     DeclFlagsId id = args.id;
     bool has_name = declIdHasName(id);
     bool has_lib_name = declIdHasLibName(id);
     bool has_type_body_field = declIdHasTypeBody(id);
     bool has_special_bodies = declIdHasSpecialBodies(id);
     bool has_value_body_field = declIdHasValueBody(id);
 
     uint32_t type_len
         = countBodyLenAfterFixups(ag, args.type_body, args.type_body_len);
     uint32_t align_len
         = countBodyLenAfterFixups(ag, args.align_body, args.align_body_len);
     uint32_t linksection_len = countBodyLenAfterFixups(
         ag, args.linksection_body, args.linksection_body_len);
     uint32_t addrspace_len = countBodyLenAfterFixups(
         ag, args.addrspace_body, args.addrspace_body_len);
     uint32_t value_len
         = countBodyLenAfterFixups(ag, args.value_body, args.value_body_len);
 
     uint32_t need = 6; // src_hash[4] + flags[2]
     if (has_name)
         need++;
     if (has_lib_name)
         need++;
     if (has_type_body_field)
         need++;
     if (has_special_bodies)
         need += 3;
     if (has_value_body_field)
         need++;
     need += type_len + align_len + linksection_len + addrspace_len + value_len;
     ensureExtraCapacity(ag, need);
 
     uint32_t payload_start = ag->extra_len;
 
     // src_hash (4 words): zero-filled; hash comparison skipped in tests.
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
 
     // Declaration.Flags: packed struct(u64) { src_line: u30, src_column: u29,
     // id: u5 } (Zir.zig:2719)
     uint64_t flags = 0;
     flags |= (uint64_t)(args.src_line & 0x3FFFFFFFu);
     flags |= (uint64_t)(args.src_column & 0x1FFFFFFFu) << 30;
     flags |= (uint64_t)((uint32_t)id & 0x1Fu) << 59;
     ag->extra[ag->extra_len++] = (uint32_t)(flags & 0xFFFFFFFFu);
     ag->extra[ag->extra_len++] = (uint32_t)(flags >> 32);
 
     if (has_name)
         ag->extra[ag->extra_len++] = args.name;
     if (has_lib_name) {
         ag->extra[ag->extra_len++]
             = (args.lib_name != UINT32_MAX) ? args.lib_name : 0;
     }
     if (has_type_body_field)
         ag->extra[ag->extra_len++] = type_len;
     if (has_special_bodies) {
         ag->extra[ag->extra_len++] = align_len;
         ag->extra[ag->extra_len++] = linksection_len;
         ag->extra[ag->extra_len++] = addrspace_len;
     }
     if (has_value_body_field)
         ag->extra[ag->extra_len++] = value_len;
 
     for (uint32_t i = 0; i < args.type_body_len; i++)
         appendPossiblyRefdBodyInst(ag, args.type_body[i]);
     for (uint32_t i = 0; i < args.align_body_len; i++)
         appendPossiblyRefdBodyInst(ag, args.align_body[i]);
     for (uint32_t i = 0; i < args.linksection_body_len; i++)
         appendPossiblyRefdBodyInst(ag, args.linksection_body[i]);
     for (uint32_t i = 0; i < args.addrspace_body_len; i++)
         appendPossiblyRefdBodyInst(ag, args.addrspace_body[i]);
     for (uint32_t i = 0; i < args.value_body_len; i++)
         appendPossiblyRefdBodyInst(ag, args.value_body[i]);
 
     ag->inst_datas[decl_inst].declaration.payload_index = payload_start;
 }
 
 // --- StructDecl.Small packing (Zir.zig StructDecl.Small) ---
 
 typedef struct {
     bool has_captures_len;
     bool has_fields_len;
     bool has_decls_len;
     bool has_backing_int;
     bool known_non_opv;
     bool known_comptime_only;
     uint8_t name_strategy; // 2 bits
     uint8_t layout; // 2 bits
     bool any_default_inits;
     bool any_comptime_fields;
     bool any_aligned_fields;
 } StructDeclSmall;
 
 static uint16_t packStructDeclSmall(StructDeclSmall s) {
     uint16_t r = 0;
     if (s.has_captures_len)
         r |= (1u << 0);
     if (s.has_fields_len)
         r |= (1u << 1);
     if (s.has_decls_len)
         r |= (1u << 2);
     if (s.has_backing_int)
         r |= (1u << 3);
     if (s.known_non_opv)
         r |= (1u << 4);
     if (s.known_comptime_only)
         r |= (1u << 5);
     r |= (uint16_t)(s.name_strategy & 0x3u) << 6;
     r |= (uint16_t)(s.layout & 0x3u) << 8;
     if (s.any_default_inits)
         r |= (1u << 10);
     if (s.any_comptime_fields)
         r |= (1u << 11);
     if (s.any_aligned_fields)
         r |= (1u << 12);
     return r;
 }
 
 // Mirrors GenZir.setStruct (AstGen.zig:12935).
 // Writes StructDecl payload and optional length fields.
 // The caller appends captures, backing_int, decls, fields, bodies after.
 static void setStruct(AstGenCtx* ag, uint32_t inst, uint32_t src_node,
     StructDeclSmall small, uint32_t captures_len, uint32_t fields_len,
     uint32_t decls_len) {
     ensureExtraCapacity(ag, 6 + 3);
 
     uint32_t payload_index = ag->extra_len;
 
     // fields_hash (4 words): zero-filled; hash comparison skipped in tests.
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
 
     ag->extra[ag->extra_len++] = ag->source_line;
     ag->extra[ag->extra_len++] = src_node;
 
     if (small.has_captures_len)
         ag->extra[ag->extra_len++] = captures_len;
     if (small.has_fields_len)
         ag->extra[ag->extra_len++] = fields_len;
     if (small.has_decls_len)
         ag->extra[ag->extra_len++] = decls_len;
 
     ag->inst_tags[inst] = ZIR_INST_EXTENDED;
     ZirInstData data;
     memset(&data, 0, sizeof(data));
     data.extended.opcode = (uint16_t)ZIR_EXT_STRUCT_DECL;
     data.extended.small = packStructDeclSmall(small);
     data.extended.operand = payload_index;
     ag->inst_datas[inst] = data;
 }
 
 // --- scanContainer (AstGen.zig:13384) ---
 
 // Add a name→node entry to the decl table.
 static void addDeclToTable(
     AstGenCtx* ag, uint32_t name_str_index, uint32_t node) {
     if (ag->decl_table_len >= ag->decl_table_cap) {
         uint32_t new_cap = ag->decl_table_cap > 0 ? ag->decl_table_cap * 2 : 8;
         uint32_t* n = realloc(ag->decl_names, new_cap * sizeof(uint32_t));
         uint32_t* d = realloc(ag->decl_nodes, new_cap * sizeof(uint32_t));
         if (!n || !d)
             exit(1);
         ag->decl_names = n;
         ag->decl_nodes = d;
         ag->decl_table_cap = new_cap;
     }
     ag->decl_names[ag->decl_table_len] = name_str_index;
     ag->decl_nodes[ag->decl_table_len] = node;
     ag->decl_table_len++;
 }
 
 // Mirrors scanContainer (AstGen.zig:13384).
 // Also populates the decl table (namespace.decls) for identifier resolution.
 static uint32_t scanContainer(
     AstGenCtx* ag, const uint32_t* members, uint32_t member_count) {
     const Ast* tree = ag->tree;
     uint32_t decl_count = 0;
     for (uint32_t i = 0; i < member_count; i++) {
         uint32_t member = members[i];
         AstNodeTag tag = tree->nodes.tags[member];
         switch (tag) {
         case AST_NODE_GLOBAL_VAR_DECL:
         case AST_NODE_LOCAL_VAR_DECL:
         case AST_NODE_SIMPLE_VAR_DECL:
         case AST_NODE_ALIGNED_VAR_DECL: {
             decl_count++;
             uint32_t name_token = tree->nodes.main_tokens[member] + 1;
             uint32_t name_str = identAsString(ag, name_token);
             addDeclToTable(ag, name_str, member);
             break;
         }
         case AST_NODE_FN_PROTO_SIMPLE:
         case AST_NODE_FN_PROTO_MULTI:
         case AST_NODE_FN_PROTO_ONE:
         case AST_NODE_FN_PROTO:
         case AST_NODE_FN_DECL: {
             decl_count++;
             uint32_t name_token = tree->nodes.main_tokens[member] + 1;
             uint32_t name_str = identAsString(ag, name_token);
             addDeclToTable(ag, name_str, member);
             break;
         }
         // Container fields: add field name to string table for ordering
         // (AstGen.zig:13509).
         case AST_NODE_CONTAINER_FIELD_INIT:
         case AST_NODE_CONTAINER_FIELD_ALIGN:
         case AST_NODE_CONTAINER_FIELD: {
             uint32_t main_token = tree->nodes.main_tokens[member];
             identAsString(ag, main_token);
             break;
         }
         case AST_NODE_COMPTIME:
             decl_count++;
             break;
         case AST_NODE_TEST_DECL: {
             decl_count++;
             // Process test name string to match upstream string table
             // ordering (AstGen.zig:13465-13500).
             uint32_t test_name_token = tree->nodes.main_tokens[member] + 1;
             TokenizerTag tt = tree->tokens.tags[test_name_token];
             if (tt == TOKEN_STRING_LITERAL) {
                 uint32_t si, sl;
                 strLitAsString(ag, test_name_token, &si, &sl);
             } else if (tt == TOKEN_IDENTIFIER) {
                 identAsString(ag, test_name_token);
             }
             break;
         }
         default:
             break;
         }
     }
     return decl_count;
 }
 
 // --- Import tracking ---
 
 static void addImport(AstGenCtx* ag, uint32_t name_index, uint32_t token) {
     // Check for duplicates.
     for (uint32_t i = 0; i < ag->imports_len; i++) {
         if (ag->imports[i].name == name_index)
             return;
     }
     if (ag->imports_len >= ag->imports_cap) {
         uint32_t new_cap = ag->imports_cap > 0 ? ag->imports_cap * 2 : 4;
         ImportEntry* p = realloc(ag->imports, new_cap * sizeof(ImportEntry));
         if (!p)
             exit(1);
         ag->imports = p;
         ag->imports_cap = new_cap;
     }
     ag->imports[ag->imports_len].name = name_index;
     ag->imports[ag->imports_len].token = token;
     ag->imports_len++;
 }
 
 // Write imports list to extra (AstGen.zig:227-244).
 static void writeImports(AstGenCtx* ag) {
     if (ag->imports_len == 0) {
         ag->extra[ZIR_EXTRA_IMPORTS] = 0;
         return;
     }
     uint32_t need = 1 + ag->imports_len * 2;
     ensureExtraCapacity(ag, need);
     uint32_t imports_index = ag->extra_len;
     ag->extra[ag->extra_len++] = ag->imports_len;
     for (uint32_t i = 0; i < ag->imports_len; i++) {
         ag->extra[ag->extra_len++] = ag->imports[i].name;
         ag->extra[ag->extra_len++] = ag->imports[i].token;
     }
     ag->extra[ZIR_EXTRA_IMPORTS] = imports_index;
 }
 
 // ri.br() (AstGen.zig:274-282): convert coerced_ty to ty for branching.
 static inline ResultLoc rlBr(ResultLoc rl) {
     if (rl.tag == RL_COERCED_TY) {
         return (ResultLoc) {
             .tag = RL_TY, .data = rl.data, .src_node = 0, .ctx = rl.ctx
         };
     }
     return rl;
 }
 
 // setBreakResultInfo (AstGen.zig:11905-11926): compute break result info
 // from parent RL. Converts coerced_ty → ty, discard → discard, else passes
 // through. For ptr/inferred_ptr, converts to ty/none respectively.
 static ResultLoc breakResultInfo(
     GenZir* gz, ResultLoc parent_rl, uint32_t node, bool need_rl) {
     // First: compute block_ri (AstGen.zig:7639-7646).
     // When need_rl is true, forward the rl as-is (don't convert ptr→ty).
     ResultLoc block_ri;
     if (need_rl) {
         block_ri = parent_rl;
     } else {
         switch (parent_rl.tag) {
         case RL_PTR: {
             uint32_t ptr_ty
                 = addUnNode(gz, ZIR_INST_TYPEOF, parent_rl.data, node);
             uint32_t ty = addUnNode(gz, ZIR_INST_ELEM_TYPE, ptr_ty, node);
             block_ri = (ResultLoc) {
                 .tag = RL_TY, .data = ty, .src_node = 0, .ctx = parent_rl.ctx
             };
             break;
         }
         case RL_INFERRED_PTR:
             block_ri = (ResultLoc) {
                 .tag = RL_NONE, .data = 0, .src_node = 0, .ctx = parent_rl.ctx
             };
             break;
         default:
             block_ri = parent_rl;
             break;
         }
     }
     // Then: setBreakResultInfo (AstGen.zig:11910-11925).
     switch (block_ri.tag) {
     case RL_COERCED_TY:
         return (ResultLoc) { .tag = RL_TY,
             .data = block_ri.data,
             .src_node = 0,
             .ctx = block_ri.ctx };
     case RL_DISCARD:
         // Don't forward ctx (AstGen.zig:11916-11920).
         return RL_DISCARD_VAL;
     default:
         return block_ri;
     }
 }
 
 // resultType (AstGen.zig:341-351): extract result type from RL.
 // Returns 0 if no result type available.
 static uint32_t rlResultType(GenZir* gz, ResultLoc rl, uint32_t node) {
     switch (rl.tag) {
     case RL_TY:
     case RL_COERCED_TY:
         return rl.data;
     case RL_REF_COERCED_TY:
         // AstGen.zig:345: .ref_coerced_ty => |ptr_ty| gz.addUnNode(.elem_type,
         // ptr_ty, node)
         return addUnNode(gz, ZIR_INST_ELEM_TYPE, rl.data, node);
     case RL_PTR: {
         // typeof(ptr) -> elem_type (AstGen.zig:346-349).
         uint32_t ptr_ty = addUnNode(gz, ZIR_INST_TYPEOF, rl.data, node);
         return addUnNode(gz, ZIR_INST_ELEM_TYPE, ptr_ty, node);
     }
     default:
         return 0;
     }
 }
 
 // rvalue (AstGen.zig:11051-11224): apply result location wrapping.
 static uint32_t rvalue(
     GenZir* gz, ResultLoc rl, uint32_t result, uint32_t node) {
     switch (rl.tag) {
     case RL_NONE:
     case RL_COERCED_TY:
         return result;
     case RL_DISCARD:
         // ensure_result_non_error (AstGen.zig:11071-11074).
         addUnNode(gz, ZIR_INST_ENSURE_RESULT_NON_ERROR, result, node);
         return ZIR_REF_VOID_VALUE;
     case RL_REF:
     case RL_REF_COERCED_TY: {
         // coerce_ptr_elem_ty for ref_coerced_ty (AstGen.zig:11077-11083).
         uint32_t coerced_result = result;
         if (rl.tag == RL_REF_COERCED_TY) {
             coerced_result = addPlNodeBin(
                 gz, ZIR_INST_COERCE_PTR_ELEM_TY, node, rl.data, result);
         }
         AstGenCtx* ag = gz->astgen;
         uint32_t src_token = firstToken(ag->tree, node);
         // If result is not an instruction index (e.g. a well-known ref),
         // emit ref directly (AstGen.zig:11091-11092).
         if (coerced_result < ZIR_REF_START_INDEX) {
             return addUnTok(gz, ZIR_INST_REF, coerced_result, src_token);
         }
         // Deduplication via ref_table (AstGen.zig:11093-11097).
         uint32_t result_index = coerced_result - ZIR_REF_START_INDEX;
         bool found;
         uint32_t* val_ptr = refTableGetOrPut(ag, result_index, &found);
         if (!found) {
             *val_ptr = makeUnTok(gz, ZIR_INST_REF, coerced_result, src_token);
         }
         return *val_ptr + ZIR_REF_START_INDEX;
     }
     case RL_TY: {
         // Quick elimination of common, unnecessary type coercions
         // (AstGen.zig:11099-11209).
 #define RC(t, v) (((uint64_t)(t) << 32) | (uint64_t)(v))
         uint64_t combined = RC(rl.data, result);
         switch (combined) {
         // Identity: type of result is already correct
         // (AstGen.zig:11109-11176).
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_U1_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_U8_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_I8_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_U16_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_U29_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_I16_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_U32_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_I32_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_U64_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_I64_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_U128_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_I128_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_USIZE_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_ISIZE_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_C_CHAR_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_C_SHORT_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_C_USHORT_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_C_INT_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_C_UINT_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_C_LONG_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_C_ULONG_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_C_LONGLONG_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_C_ULONGLONG_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_C_LONGDOUBLE_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_F16_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_F32_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_F64_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_F80_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_F128_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_ANYOPAQUE_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_BOOL_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_VOID_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_TYPE_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_ANYERROR_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_COMPTIME_INT_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_COMPTIME_FLOAT_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_NORETURN_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_ANYFRAME_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_NULL_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_UNDEFINED_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_ENUM_LITERAL_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_PTR_USIZE_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_PTR_CONST_COMPTIME_INT_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_MANYPTR_U8_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_MANYPTR_CONST_U8_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_MANYPTR_CONST_U8_SENTINEL_0_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_SLICE_CONST_U8_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_SLICE_CONST_U8_SENTINEL_0_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_ANYERROR_VOID_ERROR_UNION_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_GENERIC_POISON_TYPE):
         case RC(ZIR_REF_TYPE_TYPE, ZIR_REF_EMPTY_TUPLE_TYPE):
         case RC(ZIR_REF_COMPTIME_INT_TYPE, ZIR_REF_ZERO):
         case RC(ZIR_REF_COMPTIME_INT_TYPE, ZIR_REF_ONE):
         case RC(ZIR_REF_COMPTIME_INT_TYPE, ZIR_REF_NEGATIVE_ONE):
         case RC(ZIR_REF_USIZE_TYPE, ZIR_REF_UNDEF_USIZE):
         case RC(ZIR_REF_USIZE_TYPE, ZIR_REF_ZERO_USIZE):
         case RC(ZIR_REF_USIZE_TYPE, ZIR_REF_ONE_USIZE):
         case RC(ZIR_REF_U1_TYPE, ZIR_REF_UNDEF_U1):
         case RC(ZIR_REF_U1_TYPE, ZIR_REF_ZERO_U1):
         case RC(ZIR_REF_U1_TYPE, ZIR_REF_ONE_U1):
         case RC(ZIR_REF_U8_TYPE, ZIR_REF_ZERO_U8):
         case RC(ZIR_REF_U8_TYPE, ZIR_REF_ONE_U8):
         case RC(ZIR_REF_U8_TYPE, ZIR_REF_FOUR_U8):
         case RC(ZIR_REF_BOOL_TYPE, ZIR_REF_UNDEF_BOOL):
         case RC(ZIR_REF_BOOL_TYPE, ZIR_REF_BOOL_TRUE):
         case RC(ZIR_REF_BOOL_TYPE, ZIR_REF_BOOL_FALSE):
         case RC(ZIR_REF_VOID_TYPE, ZIR_REF_VOID_VALUE):
             return result;
         // Conversions (AstGen.zig:11178-11202).
         case RC(ZIR_REF_BOOL_TYPE, ZIR_REF_UNDEF):
             return ZIR_REF_UNDEF_BOOL;
         case RC(ZIR_REF_USIZE_TYPE, ZIR_REF_UNDEF):
             return ZIR_REF_UNDEF_USIZE;
         case RC(ZIR_REF_USIZE_TYPE, ZIR_REF_UNDEF_U1):
             return ZIR_REF_UNDEF_USIZE;
         case RC(ZIR_REF_U1_TYPE, ZIR_REF_UNDEF):
             return ZIR_REF_UNDEF_U1;
         case RC(ZIR_REF_USIZE_TYPE, ZIR_REF_ZERO):
             return ZIR_REF_ZERO_USIZE;
         case RC(ZIR_REF_U1_TYPE, ZIR_REF_ZERO):
             return ZIR_REF_ZERO_U1;
         case RC(ZIR_REF_U8_TYPE, ZIR_REF_ZERO):
             return ZIR_REF_ZERO_U8;
         case RC(ZIR_REF_USIZE_TYPE, ZIR_REF_ONE):
             return ZIR_REF_ONE_USIZE;
         case RC(ZIR_REF_U1_TYPE, ZIR_REF_ONE):
             return ZIR_REF_ONE_U1;
         case RC(ZIR_REF_U8_TYPE, ZIR_REF_ONE):
             return ZIR_REF_ONE_U8;
         case RC(ZIR_REF_COMPTIME_INT_TYPE, ZIR_REF_ZERO_USIZE):
             return ZIR_REF_ZERO;
         case RC(ZIR_REF_U1_TYPE, ZIR_REF_ZERO_USIZE):
             return ZIR_REF_ZERO_U1;
         case RC(ZIR_REF_U8_TYPE, ZIR_REF_ZERO_USIZE):
             return ZIR_REF_ZERO_U8;
         case RC(ZIR_REF_COMPTIME_INT_TYPE, ZIR_REF_ONE_USIZE):
             return ZIR_REF_ONE;
         case RC(ZIR_REF_U1_TYPE, ZIR_REF_ONE_USIZE):
             return ZIR_REF_ONE_U1;
         case RC(ZIR_REF_U8_TYPE, ZIR_REF_ONE_USIZE):
             return ZIR_REF_ONE_U8;
         case RC(ZIR_REF_COMPTIME_INT_TYPE, ZIR_REF_ZERO_U1):
             return ZIR_REF_ZERO;
         case RC(ZIR_REF_COMPTIME_INT_TYPE, ZIR_REF_ZERO_U8):
             return ZIR_REF_ZERO;
         case RC(ZIR_REF_USIZE_TYPE, ZIR_REF_ZERO_U1):
             return ZIR_REF_ZERO_USIZE;
         case RC(ZIR_REF_USIZE_TYPE, ZIR_REF_ZERO_U8):
             return ZIR_REF_ZERO_USIZE;
         case RC(ZIR_REF_COMPTIME_INT_TYPE, ZIR_REF_ONE_U1):
             return ZIR_REF_ONE;
         case RC(ZIR_REF_COMPTIME_INT_TYPE, ZIR_REF_ONE_U8):
             return ZIR_REF_ONE;
         case RC(ZIR_REF_USIZE_TYPE, ZIR_REF_ONE_U1):
             return ZIR_REF_ONE_USIZE;
         case RC(ZIR_REF_USIZE_TYPE, ZIR_REF_ONE_U8):
             return ZIR_REF_ONE_USIZE;
         default: {
             ZirInstTag as_tag = (rl.ctx == RI_CTX_SHIFT_OP)
                 ? ZIR_INST_AS_SHIFT_OPERAND
                 : ZIR_INST_AS_NODE;
             return addPlNodeBin(gz, as_tag, node, rl.data, result);
         }
         }
 #undef RC
     }
     case RL_PTR:
         // store_node (AstGen.zig:11211-11216).
         addPlNodeBin(gz, ZIR_INST_STORE_NODE,
             rl.src_node != 0 ? rl.src_node : node, rl.data, result);
         return ZIR_REF_VOID_VALUE;
     case RL_INFERRED_PTR:
         // store_to_inferred_ptr (AstGen.zig:11218-11223).
         addPlNodeBin(
             gz, ZIR_INST_STORE_TO_INFERRED_PTR, node, rl.data, result);
         return ZIR_REF_VOID_VALUE;
     }
     return result;
 }
 
 // rvalueNoCoercePreRef (AstGen.zig:11042-11049): like rvalue but does NOT
 // emit coerce_ptr_elem_ty for RL_REF_COERCED_TY. Used for local var refs.
 static uint32_t rvalueNoCoercePreRef(
     GenZir* gz, ResultLoc rl, uint32_t result, uint32_t node) {
     if (rl.tag == RL_REF_COERCED_TY) {
         ResultLoc ref_rl = rl;
         ref_rl.tag = RL_REF;
         return rvalue(gz, ref_rl, result, node);
     }
     return rvalue(gz, rl, result, node);
 }
 
 // --- Expression evaluation (AstGen.zig:634) ---
 
 // Forward declarations.
 static uint32_t expr(GenZir* gz, Scope* scope, uint32_t node);
 // --- DefersToEmit (AstGen.zig:3008) ---
 #define DEFER_NORMAL_ONLY 0
 #define DEFER_BOTH_SANS_ERR 1
 
 // --- DeferCounts (AstGen.zig:2966) ---
 typedef struct {
     bool have_any;
     bool have_normal;
     bool have_err;
     bool need_err_code;
 } DeferCounts;
 static DeferCounts countDefers(const Scope* outer_scope, Scope* inner_scope);
 
 static uint32_t exprRl(GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node);
 static void assignStmt(GenZir* gz, Scope* scope, uint32_t infix_node);
 static void assignOp(
     GenZir* gz, Scope* scope, uint32_t infix_node, ZirInstTag op_tag);
 static uint32_t shiftOp(
     GenZir* gz, Scope* scope, uint32_t node, ZirInstTag tag);
 static void emitDbgStmt(GenZir* gz, uint32_t line, uint32_t column);
 static void genDefers(
     GenZir* gz, const Scope* outer_scope, Scope* inner_scope, int which);
 static void emitDbgStmtForceCurrentIndex(
     GenZir* gz, uint32_t line, uint32_t column);
 static void emitDbgNode(GenZir* gz, uint32_t node);
 static void addDbgVar(
     GenZir* gz, ZirInstTag tag, uint32_t name, uint32_t inst);
 static bool addEnsureResult(
     GenZir* gz, uint32_t maybe_unused_result, uint32_t statement);
 static void blockExprStmts(
     GenZir* gz, Scope* scope, const uint32_t* statements, uint32_t stmt_count);
 static uint32_t fullBodyExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node);
 static uint32_t containerDecl(GenZir* gz, Scope* scope, uint32_t node);
 static uint32_t structDeclInner(AstGenCtx* ag, GenZir* gz, uint32_t node,
     const uint32_t* members, uint32_t members_len);
 static uint32_t enumDeclInner(AstGenCtx* ag, GenZir* gz, uint32_t node,
     const uint32_t* members, uint32_t members_len);
 static uint32_t blockExprExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node);
 static uint32_t ifExpr(GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node);
 static uint32_t forExpr(
     GenZir* gz, Scope* scope, uint32_t node, bool is_statement);
 static uint32_t orelseCatchExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node, bool is_catch);
 static uint32_t arrayInitDotExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node);
 static uint32_t switchExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node);
 static uint32_t whileExpr(
     GenZir* gz, Scope* scope, uint32_t node, bool is_statement);
 #define EVAL_TO_ERROR_NEVER 0
 #define EVAL_TO_ERROR_ALWAYS 1
 #define EVAL_TO_ERROR_MAYBE 2
 static int nodeMayEvalToError(const Ast* tree, uint32_t node);
 static bool nodeMayAppendToErrorTrace(const Ast* tree, uint32_t node);
 static void addSaveErrRetIndex(GenZir* gz, uint32_t operand);
 static void addRestoreErrRetIndexBlock(
     GenZir* gz, uint32_t block_inst, uint32_t operand, uint32_t node);
 static void restoreErrRetIndex(GenZir* gz, uint32_t block_inst, ResultLoc rl,
     uint32_t node, uint32_t result);
 static uint32_t identAsString(AstGenCtx* ag, uint32_t token);
 static uint32_t lastToken(const Ast* tree, uint32_t node);
 static uint32_t simpleBinOp(
     GenZir* gz, Scope* scope, uint32_t node, ZirInstTag tag);
 
 // Mirrors GenZir.endsWithNoReturn (AstGen.zig:11770).
 static bool endsWithNoReturn(GenZir* gz) {
     uint32_t len = gzInstructionsLen(gz);
     if (len == 0)
         return false;
     uint32_t last = gzInstructionsSlice(gz)[len - 1];
     ZirInstTag tag = gz->astgen->inst_tags[last];
     switch (tag) {
     case ZIR_INST_BREAK:
     case ZIR_INST_BREAK_INLINE:
     case ZIR_INST_CONDBR:
     case ZIR_INST_CONDBR_INLINE:
     case ZIR_INST_COMPILE_ERROR:
     case ZIR_INST_RET_NODE:
     case ZIR_INST_RET_LOAD:
     case ZIR_INST_RET_IMPLICIT:
     case ZIR_INST_RET_ERR_VALUE:
     case ZIR_INST_UNREACHABLE:
     case ZIR_INST_REPEAT:
     case ZIR_INST_REPEAT_INLINE:
     case ZIR_INST_PANIC:
     case ZIR_INST_TRAP:
     case ZIR_INST_CHECK_COMPTIME_CONTROL_FLOW:
     case ZIR_INST_SWITCH_CONTINUE:
         return true;
     default:
         return false;
     }
 }
 
 // Mirrors GenZir.refIsNoReturn (AstGen.zig:11885).
 static bool refIsNoReturn(GenZir* gz, uint32_t inst_ref) {
     if (inst_ref == ZIR_REF_UNREACHABLE_VALUE)
         return true;
     if (inst_ref >= ZIR_REF_START_INDEX) {
         uint32_t inst_index = inst_ref - ZIR_REF_START_INDEX;
         ZirInstTag tag = gz->astgen->inst_tags[inst_index];
         switch (tag) {
         case ZIR_INST_BREAK:
         case ZIR_INST_BREAK_INLINE:
         case ZIR_INST_CONDBR:
         case ZIR_INST_CONDBR_INLINE:
         case ZIR_INST_COMPILE_ERROR:
         case ZIR_INST_RET_NODE:
         case ZIR_INST_RET_LOAD:
         case ZIR_INST_RET_IMPLICIT:
         case ZIR_INST_RET_ERR_VALUE:
         case ZIR_INST_UNREACHABLE:
         case ZIR_INST_REPEAT:
         case ZIR_INST_REPEAT_INLINE:
         case ZIR_INST_PANIC:
         case ZIR_INST_TRAP:
         case ZIR_INST_CHECK_COMPTIME_CONTROL_FLOW:
         case ZIR_INST_SWITCH_CONTINUE:
             return true;
         default:
             return false;
         }
     }
     return false;
 }
 
 static uint32_t tryResolvePrimitiveIdent(GenZir* gz, uint32_t node);
 
 // SimpleComptimeReason (std.zig:727) — values used in block_comptime payload.
 #define COMPTIME_REASON_TYPE 29
 #define COMPTIME_REASON_ARRAY_SENTINEL 30
 #define COMPTIME_REASON_POINTER_SENTINEL 31
 #define COMPTIME_REASON_SLICE_SENTINEL 32
 #define COMPTIME_REASON_ARRAY_LENGTH 33
 #define COMPTIME_REASON_ALIGN 50
 #define COMPTIME_REASON_ADDRSPACE 51
 #define COMPTIME_REASON_COMPTIME_KEYWORD 53
 #define COMPTIME_REASON_SWITCH_ITEM 56
 
 // Mirrors comptimeExpr2 (AstGen.zig:1982).
 // Evaluates a node in a comptime block_comptime scope.
 static uint32_t comptimeExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node, uint32_t reason) {
     // Skip wrapping when already in comptime context (AstGen.zig:1990).
     if (gz->is_comptime)
         return exprRl(gz, scope, rl, node);
     // Optimization: certain node types are trivially comptime and don't need
     // a block_comptime wrapper (AstGen.zig:1997-2046).
     AstGenCtx* ag = gz->astgen;
     AstNodeTag tag = ag->tree->nodes.tags[node];
     switch (tag) {
     // Identifier handling (AstGen.zig:2000-2003):
     // Upstream calls identifier() with force_comptime which resolves
     // primitives/int types directly and only wraps others in block_comptime.
     // We mirror this by resolving primitives here and falling through for
     // non-primitives.
     case AST_NODE_IDENTIFIER: {
         uint32_t prim = tryResolvePrimitiveIdent(gz, node);
         if (prim != ZIR_REF_NONE)
             return prim;
         break; // non-primitive: fall through to block_comptime wrapping
     }
     case AST_NODE_NUMBER_LITERAL:
     case AST_NODE_CHAR_LITERAL:
     case AST_NODE_STRING_LITERAL:
     case AST_NODE_MULTILINE_STRING_LITERAL:
     case AST_NODE_ENUM_LITERAL:
     case AST_NODE_ERROR_VALUE:
     // Type expressions that force comptime eval of sub-expressions
     // (AstGen.zig:2017-2042).
     case AST_NODE_ERROR_UNION:
     case AST_NODE_MERGE_ERROR_SETS:
     case AST_NODE_OPTIONAL_TYPE:
     case AST_NODE_PTR_TYPE_ALIGNED:
     case AST_NODE_PTR_TYPE_SENTINEL:
     case AST_NODE_PTR_TYPE:
     case AST_NODE_PTR_TYPE_BIT_RANGE:
     case AST_NODE_ARRAY_TYPE:
     case AST_NODE_ARRAY_TYPE_SENTINEL:
     case AST_NODE_FN_PROTO_SIMPLE:
     case AST_NODE_FN_PROTO_MULTI:
     case AST_NODE_FN_PROTO_ONE:
     case AST_NODE_FN_PROTO:
     case AST_NODE_CONTAINER_DECL:
     case AST_NODE_CONTAINER_DECL_TRAILING:
     case AST_NODE_CONTAINER_DECL_ARG:
     case AST_NODE_CONTAINER_DECL_ARG_TRAILING:
     case AST_NODE_CONTAINER_DECL_TWO:
     case AST_NODE_CONTAINER_DECL_TWO_TRAILING:
     case AST_NODE_TAGGED_UNION:
     case AST_NODE_TAGGED_UNION_TRAILING:
     case AST_NODE_TAGGED_UNION_ENUM_TAG:
     case AST_NODE_TAGGED_UNION_ENUM_TAG_TRAILING:
     case AST_NODE_TAGGED_UNION_TWO:
     case AST_NODE_TAGGED_UNION_TWO_TRAILING:
         return exprRl(gz, scope, rl, node);
     default:
         break;
     }
     // General case: wrap in block_comptime (AstGen.zig:2078-2096).
     uint32_t block_inst = makeBlockInst(ag, ZIR_INST_BLOCK_COMPTIME, gz, node);
     GenZir block_scope = makeSubBlock(gz, scope);
     block_scope.is_comptime = true;
     // Transform RL to type-only (AstGen.zig:2084-2090).
     ResultLoc ty_only_rl;
     uint32_t res_ty = rlResultType(gz, rl, node);
     if (res_ty != 0)
         ty_only_rl = (ResultLoc) {
             .tag = RL_COERCED_TY, .data = res_ty, .src_node = 0, .ctx = rl.ctx
         };
     else
         ty_only_rl = (ResultLoc) {
             .tag = RL_NONE, .data = 0, .src_node = 0, .ctx = rl.ctx
         };
     uint32_t result = exprRl(&block_scope, scope, ty_only_rl, node);
     addBreak(&block_scope, ZIR_INST_BREAK_INLINE, block_inst, result,
         AST_NODE_OFFSET_NONE);
     setBlockComptimeBody(ag, &block_scope, block_inst, reason);
     gzAppendInstruction(gz, block_inst);
     return rvalue(gz, rl, block_inst + ZIR_REF_START_INDEX, node);
 }
 
 // Mirrors typeExpr (AstGen.zig:394).
 static uint32_t typeExpr(GenZir* gz, Scope* scope, uint32_t node) {
     ResultLoc rl = { .tag = RL_COERCED_TY,
         .data = ZIR_REF_TYPE_TYPE,
         .src_node = 0,
         .ctx = RI_CTX_NONE };
     return comptimeExpr(gz, scope, rl, node, COMPTIME_REASON_TYPE);
 }
 
 // Mirrors numberLiteral (AstGen.zig:8544).
 // Parses integer and float literals, returns appropriate ZIR ref.
 static uint32_t numberLiteral(GenZir* gz, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     uint32_t num_token = ag->tree->nodes.main_tokens[node];
     uint32_t tok_start = ag->tree->tokens.starts[num_token];
     const char* source = ag->tree->source;
 
     // Determine token length by scanning to next non-number character.
     uint32_t tok_end = tok_start;
     while (tok_end < ag->tree->source_len
         && ((source[tok_end] >= '0' && source[tok_end] <= '9')
             || source[tok_end] == '_' || source[tok_end] == '.'
             || source[tok_end] == 'x' || source[tok_end] == 'o'
             || source[tok_end] == 'b'
             || (source[tok_end] >= 'a' && source[tok_end] <= 'f')
             || (source[tok_end] >= 'A' && source[tok_end] <= 'F'))) {
         tok_end++;
     }
 
     // Parse the integer value (simplified: decimal and hex).
     uint64_t value = 0;
     bool is_hex = false;
     uint32_t pos = tok_start;
     if (tok_end - tok_start >= 2 && source[tok_start] == '0'
         && source[tok_start + 1] == 'x') {
         is_hex = true;
         pos = tok_start + 2;
     }
 
     if (is_hex) {
         for (; pos < tok_end; pos++) {
             if (source[pos] == '_')
                 continue;
             if (source[pos] >= '0' && source[pos] <= '9')
                 value = value * 16 + (uint64_t)(source[pos] - '0');
             else if (source[pos] >= 'a' && source[pos] <= 'f')
                 value = value * 16 + 10 + (uint64_t)(source[pos] - 'a');
             else if (source[pos] >= 'A' && source[pos] <= 'F')
                 value = value * 16 + 10 + (uint64_t)(source[pos] - 'A');
         }
     } else {
         for (; pos < tok_end; pos++) {
             if (source[pos] == '_')
                 continue;
             if (source[pos] == '.')
                 break; // float — not handled yet
             if (source[pos] >= '0' && source[pos] <= '9')
                 value = value * 10 + (uint64_t)(source[pos] - '0');
         }
     }
 
     // Special cases for 0 and 1 (AstGen.zig:8687-8703).
     if (value == 0)
         return ZIR_REF_ZERO;
     if (value == 1)
         return ZIR_REF_ONE;
 
     return addInt(gz, value);
 }
 
 // Mirrors builtinCall (AstGen.zig:9191), @import case (AstGen.zig:9242).
 static uint32_t builtinCallImport(GenZir* gz, Scope* scope, uint32_t node) {
     (void)scope;
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
 
     // For builtin_call_two: data.lhs = first arg node.
     AstData node_data = tree->nodes.datas[node];
     uint32_t operand_node = node_data.lhs;
 
     assert(tree->nodes.tags[operand_node] == AST_NODE_STRING_LITERAL);
     uint32_t str_lit_token = tree->nodes.main_tokens[operand_node];
 
     uint32_t str_index, str_len;
     strLitAsString(ag, str_lit_token, &str_index, &str_len);
 
     // Write Import payload to extra (Zir.Inst.Import: res_ty, path).
     ensureExtraCapacity(ag, 2);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = ZIR_REF_NONE; // res_ty = .none
     ag->extra[ag->extra_len++] = str_index; // path
 
     // Create .import instruction with pl_tok data.
     ZirInstData data;
     data.pl_tok.src_tok = tokenIndexToRelative(gz, str_lit_token);
     data.pl_tok.payload_index = payload_index;
     uint32_t result_ref = addInstruction(gz, ZIR_INST_IMPORT, data);
 
     // Track import (AstGen.zig:9269).
     addImport(ag, str_index, str_lit_token);
 
     return result_ref;
 }
 
 // Mirrors cImport (AstGen.zig:10011).
 static uint32_t cImportExpr(GenZir* gz, Scope* scope, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     AstData nd = ag->tree->nodes.datas[node];
     uint32_t body_node = nd.lhs; // first arg = body
 
     uint32_t block_inst = makeBlockInst(ag, ZIR_INST_C_IMPORT, gz, node);
 
     GenZir block_scope = makeSubBlock(gz, scope);
     block_scope.is_comptime = true;
     block_scope.c_import = true;
 
     // Use fullBodyExpr to inline unlabeled block body (AstGen.zig:10028).
     fullBodyExpr(&block_scope, &block_scope.base, RL_NONE_VAL, body_node);
 
     // ensure_result_used on gz (parent), not block_scope (AstGen.zig:10029).
     addUnNode(gz, ZIR_INST_ENSURE_RESULT_USED, ZIR_REF_VOID_VALUE, node);
 
     // break_inline (AstGen.zig:10030-10032).
     makeBreakInline(
         &block_scope, block_inst, ZIR_REF_VOID_VALUE, AST_NODE_OFFSET_NONE);
 
     setBlockBody(ag, &block_scope, block_inst);
     // block_scope unstacked now, can add to gz.
     gzAppendInstruction(gz, block_inst);
 
     return block_inst + ZIR_REF_START_INDEX; // toRef()
 }
 
 // Mirrors simpleCBuiltin (AstGen.zig:9938).
 static uint32_t simpleCBuiltin(GenZir* gz, Scope* scope, uint32_t node,
     uint32_t operand_node, uint16_t ext_tag) {
     AstGenCtx* ag = gz->astgen;
 
     // Evaluate operand as comptime string.
     uint32_t operand = expr(gz, scope, operand_node);
 
     // Emit extended instruction with UnNode payload (AstGen.zig:9954).
     ensureExtraCapacity(ag, 2);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++]
         = (uint32_t)((int32_t)node - (int32_t)gz->decl_node_index);
     ag->extra[ag->extra_len++] = operand;
 
     ZirInstData data;
     data.extended.opcode = ext_tag;
     data.extended.small = 0xAAAAu; // undefined (addExtendedPayload passes
                                    // undefined for small)
     data.extended.operand = payload_index;
     addInstruction(gz, ZIR_INST_EXTENDED, data);
 
     return ZIR_REF_VOID_VALUE;
 }
 
 // Mirrors builtinCall (AstGen.zig:9191) dispatch.
 static uint32_t builtinCall(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
 
     uint32_t builtin_token = tree->nodes.main_tokens[node];
     uint32_t tok_start = tree->tokens.starts[builtin_token];
     const char* source = tree->source;
 
     // Identify builtin name from source.
     // Skip '@' prefix and scan identifier.
     uint32_t name_start = tok_start + 1; // skip '@'
     uint32_t name_end = name_start;
     while (name_end < tree->source_len
         && ((source[name_end] >= 'a' && source[name_end] <= 'z')
             || (source[name_end] >= 'A' && source[name_end] <= 'Z')
             || source[name_end] == '_')) {
         name_end++;
     }
     uint32_t name_len = name_end - name_start;
 
     // clang-format off
     if (name_len == 6 && memcmp(source + name_start, "import", 6) == 0)
         return builtinCallImport(gz, scope, node);
     if (name_len == 7 && memcmp(source + name_start, "cImport", 7) == 0)
         return cImportExpr(gz, scope, node);
     if (name_len == 8 && memcmp(source + name_start, "cInclude", 8) == 0) {
         AstData nd = tree->nodes.datas[node];
         return simpleCBuiltin(gz, scope, node, nd.lhs, (uint16_t)ZIR_EXT_C_INCLUDE);
     }
     // @intCast — typeCast pattern (AstGen.zig:9416, 9807-9826).
     if (name_len == 7 && memcmp(source + name_start, "intCast", 7) == 0) {
         advanceSourceCursorToMainToken(ag, gz, node);
         uint32_t saved_line = ag->source_line - gz->decl_line;
         uint32_t saved_col = ag->source_column;
         uint32_t result_type = rlResultType(gz, rl, node);
         AstData nd = tree->nodes.datas[node];
         uint32_t operand = expr(gz, scope, nd.lhs);
         emitDbgStmt(gz, saved_line, saved_col);
         return addPlNodeBin(gz, ZIR_INST_INT_CAST, node,
             result_type, operand);
     }
     // @embedFile (AstGen.zig:9626).
     if (name_len == 9 && memcmp(source + name_start, "embedFile", 9) == 0) {
         AstData nd = tree->nodes.datas[node];
         uint32_t operand = expr(gz, scope, nd.lhs);
         return addUnNode(gz, ZIR_INST_EMBED_FILE, operand, node);
     }
     // @intFromEnum (AstGen.zig:9478).
     if (name_len == 11 && memcmp(source + name_start, "intFromEnum", 11) == 0) {
         AstData nd = tree->nodes.datas[node];
         uint32_t operand = expr(gz, scope, nd.lhs);
         return addUnNode(gz, ZIR_INST_INT_FROM_ENUM, operand, node);
     }
     // @tagName (AstGen.zig:9407) — simpleUnOp with dbg_stmt.
     if (name_len == 7 && memcmp(source + name_start, "tagName", 7) == 0) {
         advanceSourceCursorToMainToken(ag, gz, node);
         uint32_t saved_line = ag->source_line - gz->decl_line;
         uint32_t saved_col = ag->source_column;
         AstData nd = tree->nodes.datas[node];
         uint32_t operand = expr(gz, scope, nd.lhs);
         emitDbgStmt(gz, saved_line, saved_col);
         return addUnNode(gz, ZIR_INST_TAG_NAME, operand, node);
     }
     // @as (AstGen.zig:8909-8920).
     if (name_len == 2 && memcmp(source + name_start, "as", 2) == 0) {
         AstData nd = tree->nodes.datas[node];
         uint32_t dest_type = typeExpr(gz, scope, nd.lhs);
         ResultLoc as_rl = { .tag = RL_TY, .data = dest_type, .src_node = 0,
             .ctx = rl.ctx };
         uint32_t operand = exprRl(gz, scope, as_rl, nd.rhs);
         return rvalue(gz, rl, operand, node);
     }
     // @truncate — typeCast pattern (AstGen.zig:9417, 9807-9826).
     if (name_len == 8 && memcmp(source + name_start, "truncate", 8) == 0) {
         advanceSourceCursorToMainToken(ag, gz, node);
         uint32_t saved_line = ag->source_line - gz->decl_line;
         uint32_t saved_col = ag->source_column;
         uint32_t result_type = rlResultType(gz, rl, node);
         AstData nd = tree->nodes.datas[node];
         uint32_t operand = expr(gz, scope, nd.lhs);
         emitDbgStmt(gz, saved_line, saved_col);
         return addPlNodeBin(gz, ZIR_INST_TRUNCATE, node,
             result_type, operand);
     }
     // @ptrCast — typeCast pattern (AstGen.zig:9056, 9807-9826).
     if (name_len == 7 && memcmp(source + name_start, "ptrCast", 7) == 0) {
         advanceSourceCursorToMainToken(ag, gz, node);
         uint32_t saved_line = ag->source_line - gz->decl_line;
         uint32_t saved_col = ag->source_column;
         uint32_t result_type = rlResultType(gz, rl, node);
         AstData nd = tree->nodes.datas[node];
         uint32_t operand = expr(gz, scope, nd.lhs);
         emitDbgStmt(gz, saved_line, saved_col);
         return addPlNodeBin(gz, ZIR_INST_PTR_CAST, node,
             result_type, operand);
     }
     // @enumFromInt — typeCast pattern (AstGen.zig:9414, 9807-9826).
     if (name_len == 11 && memcmp(source + name_start, "enumFromInt", 11) == 0) {
         advanceSourceCursorToMainToken(ag, gz, node);
         uint32_t saved_line = ag->source_line - gz->decl_line;
         uint32_t saved_col = ag->source_column;
         uint32_t result_type = rlResultType(gz, rl, node);
         AstData nd = tree->nodes.datas[node];
         uint32_t operand = expr(gz, scope, nd.lhs);
         emitDbgStmt(gz, saved_line, saved_col);
         return addPlNodeBin(gz, ZIR_INST_ENUM_FROM_INT, node,
             result_type, operand);
     }
     // @bitCast (AstGen.zig:8944-8958, dispatched at 9313).
     if (name_len == 7 && memcmp(source + name_start, "bitCast", 7) == 0) {
         uint32_t result_type = rlResultType(gz, rl, node);
         AstData nd = tree->nodes.datas[node];
         uint32_t operand = expr(gz, scope, nd.lhs);
         return addPlNodeBin(gz, ZIR_INST_BITCAST, node,
             result_type, operand);
     }
     // @memcpy (AstGen.zig:9631-9637).
     if (name_len == 6 && memcmp(source + name_start, "memcpy", 6) == 0) {
         AstData nd = tree->nodes.datas[node];
         uint32_t dst = expr(gz, scope, nd.lhs);
         uint32_t src = expr(gz, scope, nd.rhs);
         addPlNodeBin(gz, ZIR_INST_MEMCPY, node, dst, src);
         return ZIR_REF_VOID_VALUE;
     }
     // @memset (AstGen.zig:9638-9647).
     if (name_len == 6 && memcmp(source + name_start, "memset", 6) == 0) {
         AstData nd = tree->nodes.datas[node];
         uint32_t lhs = expr(gz, scope, nd.lhs);
         uint32_t lhs_ty = addUnNode(gz, ZIR_INST_TYPEOF, lhs, nd.lhs);
         uint32_t elem_ty =
             addUnNode(gz, ZIR_INST_INDEXABLE_PTR_ELEM_TYPE, lhs_ty, nd.lhs);
         ResultLoc val_rl = {
             .tag = RL_COERCED_TY, .data = elem_ty, .src_node = 0};
         uint32_t val = exprRl(gz, scope, val_rl, nd.rhs);
         addPlNodeBin(gz, ZIR_INST_MEMSET, node, lhs, val);
         return ZIR_REF_VOID_VALUE;
     }
     // @min (AstGen.zig:9155).
     if (name_len == 3 && memcmp(source + name_start, "min", 3) == 0) {
         AstData nd = tree->nodes.datas[node];
         uint32_t a = expr(gz, scope, nd.lhs);
         uint32_t b = expr(gz, scope, nd.rhs);
         return addPlNodeBin(gz, ZIR_INST_MIN, node, a, b);
     }
     // @max (AstGen.zig:9155).
     if (name_len == 3 && memcmp(source + name_start, "max", 3) == 0) {
         AstData nd = tree->nodes.datas[node];
         uint32_t a = expr(gz, scope, nd.lhs);
         uint32_t b = expr(gz, scope, nd.rhs);
         return addPlNodeBin(gz, ZIR_INST_MAX, node, a, b);
     }
     // clang-format on
 
     // TODO: handle other builtins.
     SET_ERROR(ag);
     return ZIR_REF_VOID_VALUE;
 }
 
 // --- identifier (AstGen.zig:8282) ---
 // Simplified: handles decl_val resolution for container-level declarations.
 
 // Tries to resolve an identifier as a primitive type or integer type.
 // Returns the ZIR ref if it's a primitive/int type, or ZIR_REF_NONE.
 // Mirrors primitive_instrs + integer type checks in identifier()
 // (AstGen.zig:8298-8337).
 static uint32_t tryResolvePrimitiveIdent(GenZir* gz, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     uint32_t ident_token = ag->tree->nodes.main_tokens[node];
     uint32_t tok_start = ag->tree->tokens.starts[ident_token];
     const char* source = ag->tree->source;
     uint32_t tok_end = tok_start;
     while (tok_end < ag->tree->source_len
         && ((source[tok_end] >= 'a' && source[tok_end] <= 'z')
             || (source[tok_end] >= 'A' && source[tok_end] <= 'Z')
             || (source[tok_end] >= '0' && source[tok_end] <= '9')
             || source[tok_end] == '_'))
         tok_end++;
     uint32_t tok_len = tok_end - tok_start;
 
     // Check well-known primitive refs (primitive_instrs map,
     // AstGen.zig:10236-10281).
     // clang-format off
     if (tok_len == 2 && memcmp(source+tok_start, "u1", 2) == 0) return ZIR_REF_U1_TYPE;
     if (tok_len == 2 && memcmp(source+tok_start, "u8", 2) == 0) return ZIR_REF_U8_TYPE;
     if (tok_len == 2 && memcmp(source+tok_start, "i8", 2) == 0) return ZIR_REF_I8_TYPE;
     if (tok_len == 3 && memcmp(source+tok_start, "u16", 3) == 0) return ZIR_REF_U16_TYPE;
     if (tok_len == 3 && memcmp(source+tok_start, "i16", 3) == 0) return ZIR_REF_I16_TYPE;
     if (tok_len == 3 && memcmp(source+tok_start, "u29", 3) == 0) return ZIR_REF_U29_TYPE;
     if (tok_len == 3 && memcmp(source+tok_start, "u32", 3) == 0) return ZIR_REF_U32_TYPE;
     if (tok_len == 3 && memcmp(source+tok_start, "i32", 3) == 0) return ZIR_REF_I32_TYPE;
     if (tok_len == 3 && memcmp(source+tok_start, "u64", 3) == 0) return ZIR_REF_U64_TYPE;
     if (tok_len == 3 && memcmp(source+tok_start, "i64", 3) == 0) return ZIR_REF_I64_TYPE;
     if (tok_len == 4 && memcmp(source+tok_start, "u128", 4) == 0) return ZIR_REF_U128_TYPE;
     if (tok_len == 4 && memcmp(source+tok_start, "i128", 4) == 0) return ZIR_REF_I128_TYPE;
     if (tok_len == 5 && memcmp(source+tok_start, "usize", 5) == 0) return ZIR_REF_USIZE_TYPE;
     if (tok_len == 5 && memcmp(source+tok_start, "isize", 5) == 0) return ZIR_REF_ISIZE_TYPE;
     if (tok_len == 6 && memcmp(source+tok_start, "c_char", 6) == 0) return ZIR_REF_C_CHAR_TYPE;
     if (tok_len == 7 && memcmp(source+tok_start, "c_short", 7) == 0) return ZIR_REF_C_SHORT_TYPE;
     if (tok_len == 8 && memcmp(source+tok_start, "c_ushort", 8) == 0) return ZIR_REF_C_USHORT_TYPE;
     if (tok_len == 5 && memcmp(source+tok_start, "c_int", 5) == 0) return ZIR_REF_C_INT_TYPE;
     if (tok_len == 6 && memcmp(source+tok_start, "c_uint", 6) == 0) return ZIR_REF_C_UINT_TYPE;
     if (tok_len == 6 && memcmp(source+tok_start, "c_long", 6) == 0) return ZIR_REF_C_LONG_TYPE;
     if (tok_len == 7 && memcmp(source+tok_start, "c_ulong", 7) == 0) return ZIR_REF_C_ULONG_TYPE;
     if (tok_len == 10 && memcmp(source+tok_start, "c_longlong", 10) == 0) return ZIR_REF_C_LONGLONG_TYPE;
     if (tok_len == 11 && memcmp(source+tok_start, "c_ulonglong", 11) == 0) return ZIR_REF_C_ULONGLONG_TYPE;
     if (tok_len == 14 && memcmp(source+tok_start, "comptime_float", 14) == 0) return ZIR_REF_COMPTIME_FLOAT_TYPE;
     if (tok_len == 12 && memcmp(source+tok_start, "comptime_int", 12) == 0) return ZIR_REF_COMPTIME_INT_TYPE;
     if (tok_len == 3 && memcmp(source+tok_start, "f16", 3) == 0) return ZIR_REF_F16_TYPE;
     if (tok_len == 3 && memcmp(source+tok_start, "f32", 3) == 0) return ZIR_REF_F32_TYPE;
     if (tok_len == 3 && memcmp(source+tok_start, "f64", 3) == 0) return ZIR_REF_F64_TYPE;
     if (tok_len == 3 && memcmp(source+tok_start, "f80", 3) == 0) return ZIR_REF_F80_TYPE;
     if (tok_len == 4 && memcmp(source+tok_start, "f128", 4) == 0) return ZIR_REF_F128_TYPE;
     if (tok_len == 9 && memcmp(source+tok_start, "anyopaque", 9) == 0) return ZIR_REF_ANYOPAQUE_TYPE;
     if (tok_len == 4 && memcmp(source+tok_start, "bool", 4) == 0) return ZIR_REF_BOOL_TYPE;
     if (tok_len == 4 && memcmp(source+tok_start, "void", 4) == 0) return ZIR_REF_VOID_TYPE;
     if (tok_len == 4 && memcmp(source+tok_start, "type", 4) == 0) return ZIR_REF_TYPE_TYPE;
     if (tok_len == 8 && memcmp(source+tok_start, "anyerror", 8) == 0) return ZIR_REF_ANYERROR_TYPE;
     if (tok_len == 8 && memcmp(source+tok_start, "noreturn", 8) == 0) return ZIR_REF_NORETURN_TYPE;
     if (tok_len == 4 && memcmp(source+tok_start, "true", 4) == 0) return ZIR_REF_BOOL_TRUE;
     if (tok_len == 5 && memcmp(source+tok_start, "false", 5) == 0) return ZIR_REF_BOOL_FALSE;
     if (tok_len == 4 && memcmp(source+tok_start, "null", 4) == 0) return ZIR_REF_NULL_VALUE;
     if (tok_len == 9 && memcmp(source+tok_start, "undefined", 9) == 0) return ZIR_REF_UNDEF;
     // clang-format on
 
     // Integer type detection: u29, i13, etc. (AstGen.zig:8304-8336).
     if (tok_len >= 2
         && (source[tok_start] == 'u' || source[tok_start] == 'i')) {
         // Zig Signedness enum: unsigned=1, signed=0
         uint8_t signedness = (source[tok_start] == 'u') ? 1 : 0;
         uint16_t bit_count = 0;
         bool valid = true;
         for (uint32_t k = tok_start + 1; k < tok_end; k++) {
             if (source[k] >= '0' && source[k] <= '9') {
                 bit_count
                     = (uint16_t)(bit_count * 10 + (uint16_t)(source[k] - '0'));
             } else {
                 valid = false;
                 break;
             }
         }
         if (valid && bit_count > 0) {
             ZirInstData data;
             data.int_type.src_node
                 = (int32_t)node - (int32_t)gz->decl_node_index;
             data.int_type.signedness = signedness;
             data.int_type._pad = 0;
             data.int_type.bit_count = bit_count;
             return addInstruction(gz, ZIR_INST_INT_TYPE, data);
         }
     }
     return ZIR_REF_NONE;
 }
 
 static uint32_t identifierExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     uint32_t ident_token = ag->tree->nodes.main_tokens[node];
 
     // Check for primitive types FIRST (AstGen.zig:8298-8338).
     uint32_t prim = tryResolvePrimitiveIdent(gz, node);
     if (prim != ZIR_REF_NONE)
         return rvalue(gz, rl, prim, node);
 
     // Scope chain walk (AstGen.zig:8340-8461).
     uint32_t name_str = identAsString(ag, ident_token);
     for (Scope* s = scope; s != NULL;) {
         switch (s->tag) {
         case SCOPE_LOCAL_VAL: {
             ScopeLocalVal* lv = (ScopeLocalVal*)s;
             if (lv->name == name_str)
                 return rvalueNoCoercePreRef(gz, rl, lv->inst, node);
             s = lv->parent;
             continue;
         }
         case SCOPE_LOCAL_PTR: {
             ScopeLocalPtr* lp = (ScopeLocalPtr*)s;
             if (lp->name == name_str) {
                 if (RL_IS_REF(rl))
                     return lp->ptr;
                 return addUnNode(gz, ZIR_INST_LOAD, lp->ptr, node);
             }
             s = lp->parent;
             continue;
         }
         case SCOPE_GEN_ZIR: {
             GenZir* gzs = (GenZir*)s;
             s = gzs->parent;
             continue;
         }
         case SCOPE_DEFER_NORMAL:
         case SCOPE_DEFER_ERROR: {
             ScopeDefer* sd = (ScopeDefer*)s;
             s = sd->parent;
             continue;
         }
         case SCOPE_LABEL: {
             ScopeLabel* sl = (ScopeLabel*)s;
             s = sl->parent;
             continue;
         }
         case SCOPE_NAMESPACE:
         case SCOPE_TOP:
             goto decl_table;
         }
     }
 decl_table:
 
     // Decl table lookup (AstGen.zig:8462-8520).
     for (uint32_t i = 0; i < ag->decl_table_len; i++) {
         if (ag->decl_names[i] == name_str) {
             ZirInstTag itag
                 = (RL_IS_REF(rl)) ? ZIR_INST_DECL_REF : ZIR_INST_DECL_VAL;
             ZirInstData data;
             data.str_tok.start = name_str;
             data.str_tok.src_tok = tokenIndexToRelative(gz, ident_token);
             return addInstruction(gz, itag, data);
         }
     }
 
     SET_ERROR(ag);
     return ZIR_REF_VOID_VALUE;
 }
 
 // --- fieldAccess (AstGen.zig:6154) ---
 // Simplified: emits field_val instruction with Field payload.
 
 static uint32_t fieldAccessExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstData nd = tree->nodes.datas[node];
 
     // data.lhs = object node, data.rhs = field identifier token.
     uint32_t object_node = nd.lhs;
     uint32_t field_ident = nd.rhs;
 
     // Get field name as string (AstGen.zig:6180).
     uint32_t str_index = identAsString(ag, field_ident);
 
     // Evaluate the LHS object expression (AstGen.zig:6181).
     // For .ref rl, LHS is also evaluated with .ref (AstGen.zig:6161).
     ResultLoc lhs_rl = (RL_IS_REF(rl)) ? RL_REF_VAL : RL_NONE_VAL;
     uint32_t lhs = exprRl(gz, scope, lhs_rl, object_node);
 
     // Emit dbg_stmt for the dot token (AstGen.zig:6183-6184).
     advanceSourceCursorToMainToken(ag, gz, node);
     {
         uint32_t line = ag->source_line - gz->decl_line;
         uint32_t column = ag->source_column;
         emitDbgStmt(gz, line, column);
     }
 
     // Emit field_val instruction with Field payload (AstGen.zig:6186-6189).
     ensureExtraCapacity(ag, 2);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = lhs; // Field.lhs
     ag->extra[ag->extra_len++] = str_index; // Field.field_name_start
 
     // .ref → field_ptr, else → field_val (AstGen.zig:6160-6164).
     ZirInstTag ftag
         = (RL_IS_REF(rl)) ? ZIR_INST_FIELD_PTR : ZIR_INST_FIELD_VAL;
     ZirInstData data;
     data.pl_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
     data.pl_node.payload_index = payload_index;
     uint32_t access = addInstruction(gz, ftag, data);
     // For ref, return directly; otherwise apply rvalue (AstGen.zig:6161-6164).
     if (RL_IS_REF(rl))
         return access;
     return rvalue(gz, rl, access, node);
 }
 
 // --- ptrType (AstGen.zig:3833) ---
 
 static uint32_t ptrTypeExpr(GenZir* gz, Scope* scope, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstNodeTag tag = tree->nodes.tags[node];
     AstData nd = tree->nodes.datas[node];
     uint32_t main_tok = tree->nodes.main_tokens[node];
 
     // child_type is always in rhs for all ptr_type variants.
     uint32_t child_type_node = nd.rhs;
 
     // Determine size from main_token (Ast.zig:2122-2131).
     // Pointer.Size: one=0, many=1, slice=2, c=3.
     uint8_t size;
     TokenizerTag main_tok_tag = tree->tokens.tags[main_tok];
     if (main_tok_tag == TOKEN_ASTERISK
         || main_tok_tag == TOKEN_ASTERISK_ASTERISK) {
         size = 0; // one
     } else {
         assert(main_tok_tag == TOKEN_L_BRACKET);
         TokenizerTag next_tag = tree->tokens.tags[main_tok + 1];
         if (next_tag == TOKEN_ASTERISK) {
             // [*c]T vs [*]T: c-pointer if next-next is identifier.
             if (tree->tokens.tags[main_tok + 2] == TOKEN_IDENTIFIER)
                 size = 3; // c
             else
                 size = 1; // many
         } else {
             size = 2; // slice
         }
     }
 
     // Determine sentinel, align, addrspace, bit_range nodes from AST variant
     // (Ast.zig:1656-1696).
     uint32_t sentinel_node = UINT32_MAX;
     uint32_t align_node = UINT32_MAX;
     uint32_t addrspace_node = UINT32_MAX;
     uint32_t bit_range_start = UINT32_MAX;
     uint32_t bit_range_end = UINT32_MAX;
 
     if (tag == AST_NODE_PTR_TYPE_ALIGNED) {
         // opt_node_and_node: lhs = optional align_node (0=none), rhs = child.
         if (nd.lhs != 0)
             align_node = nd.lhs;
     } else if (tag == AST_NODE_PTR_TYPE_SENTINEL) {
         // opt_node_and_node: lhs = optional sentinel (0=none), rhs = child.
         if (nd.lhs != 0)
             sentinel_node = nd.lhs;
     } else if (tag == AST_NODE_PTR_TYPE) {
         // extra_and_node: lhs = extra index to AstPtrType, rhs = child_type.
         const AstPtrType* pt
             = (const AstPtrType*)(tree->extra_data.arr + nd.lhs);
         if (pt->sentinel != UINT32_MAX)
             sentinel_node = pt->sentinel;
         if (pt->align_node != UINT32_MAX)
             align_node = pt->align_node;
         if (pt->addrspace_node != UINT32_MAX)
             addrspace_node = pt->addrspace_node;
     } else if (tag == AST_NODE_PTR_TYPE_BIT_RANGE) {
         // extra_and_node: lhs = extra index to AstPtrTypeBitRange.
         const AstPtrTypeBitRange* pt
             = (const AstPtrTypeBitRange*)(tree->extra_data.arr + nd.lhs);
         if (pt->sentinel != UINT32_MAX)
             sentinel_node = pt->sentinel;
         align_node = pt->align_node;
         if (pt->addrspace_node != UINT32_MAX)
             addrspace_node = pt->addrspace_node;
         bit_range_start = pt->bit_range_start;
         bit_range_end = pt->bit_range_end;
     }
 
     // Scan tokens between main_token and child_type to find const/volatile/
     // allowzero (Ast.zig:2139-2164).
     bool has_const = false;
     bool has_volatile = false;
     bool has_allowzero = false;
     {
         uint32_t i;
         if (sentinel_node != UINT32_MAX) {
             i = lastToken(tree, sentinel_node) + 1;
         } else if (size == 1 || size == 3) {
             // many or c: start after main_token.
             i = main_tok + 1;
         } else {
             i = main_tok;
         }
         uint32_t end = firstToken(tree, child_type_node);
         while (i < end) {
             TokenizerTag tt = tree->tokens.tags[i];
             if (tt == TOKEN_KEYWORD_ALLOWZERO) {
                 has_allowzero = true;
             } else if (tt == TOKEN_KEYWORD_CONST) {
                 has_const = true;
             } else if (tt == TOKEN_KEYWORD_VOLATILE) {
                 has_volatile = true;
             } else if (tt == TOKEN_KEYWORD_ALIGN) {
                 // Skip over align expression.
                 if (bit_range_end != UINT32_MAX)
                     i = lastToken(tree, bit_range_end) + 1;
                 else if (align_node != UINT32_MAX)
                     i = lastToken(tree, align_node) + 1;
             }
             i++;
         }
     }
 
     // Evaluate element type (AstGen.zig:3847).
     uint32_t elem_type = typeExpr(gz, scope, child_type_node);
 
     // Evaluate trailing expressions (AstGen.zig:3856-3897).
     uint32_t sentinel_ref = ZIR_REF_NONE;
     uint32_t align_ref = ZIR_REF_NONE;
     uint32_t addrspace_ref = ZIR_REF_NONE;
     uint32_t bit_start_ref = ZIR_REF_NONE;
     uint32_t bit_end_ref = ZIR_REF_NONE;
     uint32_t trailing_count = 0;
 
     if (sentinel_node != UINT32_MAX) {
         uint32_t reason = (size == 2) ? COMPTIME_REASON_SLICE_SENTINEL
                                       : COMPTIME_REASON_POINTER_SENTINEL;
         ResultLoc srl = {
             .tag = RL_TY, .data = elem_type, .src_node = 0, .ctx = RI_CTX_NONE
         };
         sentinel_ref = comptimeExpr(gz, scope, srl, sentinel_node, reason);
         trailing_count++;
     }
     if (addrspace_node != UINT32_MAX) {
         // Upstream creates addrspace_ty via addBuiltinValue, we don't have
         // that yet, so pass RL_NONE (matching previous behavior).
         addrspace_ref = comptimeExpr(
             gz, scope, RL_NONE_VAL, addrspace_node, COMPTIME_REASON_ADDRSPACE);
         trailing_count++;
     }
     if (align_node != UINT32_MAX) {
         ResultLoc arl = { .tag = RL_COERCED_TY,
             .data = ZIR_REF_U29_TYPE,
             .src_node = 0,
             .ctx = RI_CTX_NONE };
         align_ref
             = comptimeExpr(gz, scope, arl, align_node, COMPTIME_REASON_ALIGN);
         trailing_count++;
     }
     if (bit_range_start != UINT32_MAX) {
         ResultLoc brl = { .tag = RL_COERCED_TY,
             .data = ZIR_REF_U16_TYPE,
             .src_node = 0,
             .ctx = RI_CTX_NONE };
         bit_start_ref = comptimeExpr(
             gz, scope, brl, bit_range_start, COMPTIME_REASON_TYPE);
         bit_end_ref = comptimeExpr(
             gz, scope, brl, bit_range_end, COMPTIME_REASON_TYPE);
         trailing_count += 2;
     }
 
     // Build PtrType payload: { elem_type, src_node } + trailing
     // (AstGen.zig:3905-3921).
     ensureExtraCapacity(ag, 2 + trailing_count);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = elem_type;
     ag->extra[ag->extra_len++]
         = (uint32_t)((int32_t)node - (int32_t)gz->decl_node_index);
     if (sentinel_ref != ZIR_REF_NONE)
         ag->extra[ag->extra_len++] = sentinel_ref;
     if (align_ref != ZIR_REF_NONE)
         ag->extra[ag->extra_len++] = align_ref;
     if (addrspace_ref != ZIR_REF_NONE)
         ag->extra[ag->extra_len++] = addrspace_ref;
     if (bit_start_ref != ZIR_REF_NONE) {
         ag->extra[ag->extra_len++] = bit_start_ref;
         ag->extra[ag->extra_len++] = bit_end_ref;
     }
 
     // Build flags packed byte (AstGen.zig:3927-3934).
     uint8_t flags = 0;
     if (has_allowzero)
         flags |= (1 << 0); // is_allowzero
     if (!has_const)
         flags |= (1 << 1); // is_mutable
     if (has_volatile)
         flags |= (1 << 2); // is_volatile
     if (sentinel_ref != ZIR_REF_NONE)
         flags |= (1 << 3); // has_sentinel
     if (align_ref != ZIR_REF_NONE)
         flags |= (1 << 4); // has_align
     if (addrspace_ref != ZIR_REF_NONE)
         flags |= (1 << 5); // has_addrspace
     if (bit_start_ref != ZIR_REF_NONE)
         flags |= (1 << 6); // has_bit_range
 
     ZirInstData data;
     data.ptr_type.flags = flags;
     data.ptr_type.size = size;
     data.ptr_type._pad = 0;
     data.ptr_type.payload_index = payload_index;
     return addInstruction(gz, ZIR_INST_PTR_TYPE, data);
 }
 
 // --- arrayType (AstGen.zig:940) ---
 
 static uint32_t arrayTypeExpr(GenZir* gz, Scope* scope, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstData nd = tree->nodes.datas[node];
 
     // data.lhs = length expr node, data.rhs = element type node.
     // Check for `_` identifier → compile error (AstGen.zig:3950-3953).
     if (tree->nodes.tags[nd.lhs] == AST_NODE_IDENTIFIER
         && isUnderscoreIdent(tree, nd.lhs)) {
         SET_ERROR(ag);
         return ZIR_REF_VOID_VALUE;
     }
     ResultLoc len_rl = { .tag = RL_COERCED_TY,
         .data = ZIR_REF_USIZE_TYPE,
         .src_node = 0,
         .ctx = RI_CTX_NONE };
     uint32_t len
         = comptimeExpr(gz, scope, len_rl, nd.lhs, COMPTIME_REASON_TYPE);
     uint32_t elem_type = typeExpr(gz, scope, nd.rhs);
     return addPlNodeBin(gz, ZIR_INST_ARRAY_TYPE, node, len, elem_type);
 }
 
 // --- arrayInitExpr (AstGen.zig:1431) ---
 // Simplified: handles typed array init with inferred [_] length.
 
 static uint32_t arrayInitExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstNodeTag tag = tree->nodes.tags[node];
     AstData nd = tree->nodes.datas[node];
 
     // Get elements and type expression based on the variant.
     uint32_t type_expr_node = 0;
     uint32_t elem_buf[2];
     const uint32_t* elements = NULL;
     uint32_t elem_count = 0;
 
     switch (tag) {
     case AST_NODE_ARRAY_INIT_ONE:
     case AST_NODE_ARRAY_INIT_ONE_COMMA: {
         type_expr_node = nd.lhs;
         if (nd.rhs != 0) {
             elem_buf[0] = nd.rhs;
             elements = elem_buf;
             elem_count = 1;
         }
         break;
     }
     case AST_NODE_ARRAY_INIT:
     case AST_NODE_ARRAY_INIT_COMMA: {
         // data = node_and_extra: lhs = type_expr, rhs = extra_index.
         // extra[rhs] = SubRange.start, extra[rhs+1] = SubRange.end.
         // Elements are extra_data[start..end].
         type_expr_node = nd.lhs;
         uint32_t extra_idx = nd.rhs;
         uint32_t range_start = tree->extra_data.arr[extra_idx];
         uint32_t range_end = tree->extra_data.arr[extra_idx + 1];
         elements = tree->extra_data.arr + range_start;
         elem_count = range_end - range_start;
         break;
     }
     default:
         SET_ERROR(ag);
         return ZIR_REF_VOID_VALUE;
     }
 
     if (type_expr_node == 0 || elem_count == 0) {
         SET_ERROR(ag);
         return ZIR_REF_VOID_VALUE;
     }
 
     // Check if the type is [_]T (inferred length) (AstGen.zig:1446-1474).
     if (tree->nodes.tags[type_expr_node] == AST_NODE_ARRAY_TYPE) {
         AstData type_nd = tree->nodes.datas[type_expr_node];
         uint32_t elem_count_node = type_nd.lhs;
         uint32_t elem_type_node = type_nd.rhs;
 
         // Check if elem_count is `_` identifier.
         if (tree->nodes.tags[elem_count_node] == AST_NODE_IDENTIFIER
             && isUnderscoreIdent(tree, elem_count_node)) {
             // Inferred length: addInt(elem_count) (AstGen.zig:1452).
             uint32_t len_inst = addInt(gz, elem_count);
             uint32_t elem_type = typeExpr(gz, scope, elem_type_node);
             uint32_t array_type_inst = addPlNodeBin(
                 gz, ZIR_INST_ARRAY_TYPE, type_expr_node, len_inst, elem_type);
 
             // arrayInitExprTyped (AstGen.zig:1484-1513, 1598-1642).
             // Only RL_REF produces array_init_ref; all other RLs use
             // array_init + rvalue (AstGen.zig:1507-1511).
             bool is_ref = (rl.tag == RL_REF);
             uint32_t operands_len = elem_count + 1;
             ensureExtraCapacity(ag, 1 + operands_len);
             uint32_t payload_index = ag->extra_len;
             ag->extra[ag->extra_len++] = operands_len;
             ag->extra[ag->extra_len++] = array_type_inst;
             uint32_t extra_start = ag->extra_len;
             ag->extra_len += elem_count;
             for (uint32_t i = 0; i < elem_count; i++) {
                 // Use elem_type as coercion target for each element.
                 ResultLoc elem_rl = {
                     .tag = RL_COERCED_TY, .data = elem_type, .src_node = 0
                 };
                 uint32_t elem_ref = exprRl(gz, scope, elem_rl, elements[i]);
                 ag->extra[extra_start + i] = elem_ref;
             }
             ZirInstTag init_tag
                 = is_ref ? ZIR_INST_ARRAY_INIT_REF : ZIR_INST_ARRAY_INIT;
             ZirInstData idata;
             idata.pl_node.src_node
                 = (int32_t)node - (int32_t)gz->decl_node_index;
             idata.pl_node.payload_index = payload_index;
             uint32_t result = addInstruction(gz, init_tag, idata);
             if (is_ref)
                 return result;
             return rvalue(gz, rl, result, node);
         }
     }
 
     // Non-inferred length: evaluate type normally.
     SET_ERROR(ag);
     return ZIR_REF_VOID_VALUE;
 }
 
 // --- simpleBinOp (AstGen.zig:2204) ---
 
 static uint32_t simpleBinOp(
     GenZir* gz, Scope* scope, uint32_t node, ZirInstTag op_tag) {
     AstGenCtx* ag = gz->astgen;
     AstData nd = ag->tree->nodes.datas[node];
     uint32_t lhs = exprRl(gz, scope, RL_NONE_VAL, nd.lhs);
     // For arithmetic ops, advance cursor before RHS (AstGen.zig:6245-6256).
     uint32_t saved_line = 0, saved_col = 0;
     bool need_dbg = false;
     if (op_tag == ZIR_INST_ADD || op_tag == ZIR_INST_SUB
         || op_tag == ZIR_INST_MUL || op_tag == ZIR_INST_DIV
         || op_tag == ZIR_INST_MOD_REM) {
         if (!gz->is_comptime) {
             advanceSourceCursorToMainToken(ag, gz, node);
         }
         saved_line = ag->source_line - gz->decl_line;
         saved_col = ag->source_column;
         need_dbg = true;
     }
     uint32_t rhs = exprRl(gz, scope, RL_NONE_VAL, nd.rhs);
     if (need_dbg) {
         emitDbgStmt(gz, saved_line, saved_col);
     }
     return addPlNodeBin(gz, op_tag, node, lhs, rhs);
 }
 
 // --- shiftOp (AstGen.zig:9978) ---
 
 static uint32_t shiftOp(
     GenZir* gz, Scope* scope, uint32_t node, ZirInstTag tag) {
     AstGenCtx* ag = gz->astgen;
     AstData nd = ag->tree->nodes.datas[node];
     uint32_t lhs = exprRl(gz, scope, RL_NONE_VAL, nd.lhs);
 
     advanceSourceCursorToMainToken(ag, gz, node);
     uint32_t saved_line = ag->source_line - gz->decl_line;
     uint32_t saved_col = ag->source_column;
 
     uint32_t log2_int_type
         = addUnNode(gz, ZIR_INST_TYPEOF_LOG2_INT_TYPE, lhs, nd.lhs);
     ResultLoc rhs_rl = { .tag = RL_TY,
         .data = log2_int_type,
         .src_node = 0,
         .ctx = RI_CTX_SHIFT_OP };
     uint32_t rhs = exprRl(gz, scope, rhs_rl, nd.rhs);
 
     emitDbgStmt(gz, saved_line, saved_col);
 
     return addPlNodeBin(gz, tag, node, lhs, rhs);
 }
 
 // --- multilineStringLiteral (AstGen.zig:8645) ---
 // Port of strLitNodeAsString for multiline strings.
 static uint32_t multilineStringLiteral(
     GenZir* gz, Scope* scope, uint32_t node) {
     (void)scope;
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstData nd = tree->nodes.datas[node];
     uint32_t start_tok = nd.lhs;
     uint32_t end_tok = nd.rhs;
 
     uint32_t str_index = ag->string_bytes_len;
 
     // First line: no preceding newline.
     for (uint32_t tok_i = start_tok; tok_i <= end_tok; tok_i++) {
         uint32_t tok_start = tree->tokens.starts[tok_i];
         const char* source = tree->source;
         // Skip leading `\\` (2 chars).
         uint32_t content_start = tok_start + 2;
         // Find end of line.
         uint32_t content_end = content_start;
         while (content_end < tree->source_len && source[content_end] != '\n')
             content_end++;
         uint32_t line_len = content_end - content_start;
 
         if (tok_i > start_tok) {
             // Prepend newline for lines after the first.
             ensureStringBytesCapacity(ag, line_len + 1);
             ag->string_bytes[ag->string_bytes_len++] = '\n';
         } else {
             ensureStringBytesCapacity(ag, line_len);
         }
         memcpy(ag->string_bytes + ag->string_bytes_len, source + content_start,
             line_len);
         ag->string_bytes_len += line_len;
     }
 
     uint32_t len = ag->string_bytes_len - str_index;
     ensureStringBytesCapacity(ag, 1);
     ag->string_bytes[ag->string_bytes_len++] = 0; // null terminator
 
     ZirInstData data;
     data.str.start = str_index;
     data.str.len = len;
     return addInstruction(gz, ZIR_INST_STR, data);
 }
 
 // --- ret (AstGen.zig:8119) ---
 static uint32_t retExpr(GenZir* gz, Scope* scope, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
 
     // Ensure debug line/column information is emitted for this return
     // expression (AstGen.zig:8141-8144).
     if (!gz->is_comptime) {
         emitDbgNode(gz, node);
     }
     uint32_t ret_lc_line = ag->source_line - gz->decl_line;
     uint32_t ret_lc_column = ag->source_column;
 
     // AstGen.zig:8123: return outside function is an error.
     if (ag->fn_block == NULL) {
         SET_ERROR(ag);
         return ZIR_REF_UNREACHABLE_VALUE;
     }
     const Scope* defer_outer = &((GenZir*)ag->fn_block)->base;
 
     AstData nd = tree->nodes.datas[node];
     uint32_t operand_node = nd.lhs; // optional
 
     if (operand_node == 0) {
         // Void return (AstGen.zig:8148-8156).
         genDefers(gz, defer_outer, scope, DEFER_NORMAL_ONLY);
         // Restore error trace unconditionally (AstGen.zig:8153).
         ZirInstData rdata;
         rdata.un_node.operand = ZIR_REF_NONE;
         rdata.un_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
         addInstruction(
             gz, ZIR_INST_RESTORE_ERR_RET_INDEX_UNCONDITIONAL, rdata);
         addUnNode(gz, ZIR_INST_RET_NODE, ZIR_REF_VOID_VALUE, node);
         return ZIR_REF_UNREACHABLE_VALUE;
     }
 
     // Fast path: return error.Foo (AstGen.zig:8159-8175).
     if (tree->nodes.tags[operand_node] == AST_NODE_ERROR_VALUE) {
         uint32_t error_token = tree->nodes.main_tokens[operand_node] + 2;
         uint32_t err_name_str = identAsString(ag, error_token);
         DeferCounts dc = countDefers(defer_outer, scope);
         if (!dc.need_err_code) {
             genDefers(gz, defer_outer, scope, DEFER_BOTH_SANS_ERR);
             emitDbgStmt(gz, ret_lc_line, ret_lc_column);
             addStrTok(gz, ZIR_INST_RET_ERR_VALUE, err_name_str, error_token);
             return ZIR_REF_UNREACHABLE_VALUE;
         }
         // need_err_code path: not implemented yet, fall through to general.
     }
 
     // Evaluate operand with result location (AstGen.zig:8178-8186).
     // If nodes_need_rl contains this return node, use ptr-based RL;
     // otherwise use coerced_ty.
     ResultLoc ret_rl = RL_NONE_VAL;
     bool use_ptr = nodesNeedRlContains(ag, node);
     uint32_t ret_ptr_inst = 0;
     if (use_ptr) {
         // Create ret_ptr instruction (AstGen.zig:8179).
         ZirInstData rpdata;
         rpdata.node = (int32_t)node - (int32_t)gz->decl_node_index;
         ret_ptr_inst = addInstruction(gz, ZIR_INST_RET_PTR, rpdata);
         ret_rl.tag = RL_PTR;
         ret_rl.data = ret_ptr_inst;
     } else if (ag->fn_ret_ty != 0) {
         ret_rl.tag = RL_COERCED_TY;
         ret_rl.data = ag->fn_ret_ty;
     }
     ret_rl.ctx = RI_CTX_RETURN;
     uint32_t operand = exprRl(gz, scope, ret_rl, operand_node);
 
     // Emit RESTORE_ERR_RET_INDEX based on nodeMayEvalToError
     // (AstGen.zig:8188-8253).
     int eval_to_err = nodeMayEvalToError(tree, operand_node);
     if (eval_to_err == EVAL_TO_ERROR_NEVER) {
         // Returning non-error: pop error trace unconditionally
         // (AstGen.zig:8190-8198).
         genDefers(gz, defer_outer, scope, DEFER_NORMAL_ONLY);
         ZirInstData rdata;
         rdata.un_node.operand = ZIR_REF_NONE;
         rdata.un_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
         addInstruction(
             gz, ZIR_INST_RESTORE_ERR_RET_INDEX_UNCONDITIONAL, rdata);
         emitDbgStmt(gz, ret_lc_line, ret_lc_column);
         // addRet (AstGen.zig:13188-13194).
         if (use_ptr) {
             addUnNode(gz, ZIR_INST_RET_LOAD, ret_ptr_inst, node);
         } else {
             addUnNode(gz, ZIR_INST_RET_NODE, operand, node);
         }
         return ZIR_REF_UNREACHABLE_VALUE;
     } else if (eval_to_err == EVAL_TO_ERROR_ALWAYS) {
         // .always: emit both error defers and regular defers
         // (AstGen.zig:8200-8206).
         uint32_t err_code = use_ptr
             ? addUnNode(gz, ZIR_INST_LOAD, ret_ptr_inst, node)
             : operand;
         (void)err_code;
         // TODO: genDefers with .both = err_code when errdefer is implemented.
         genDefers(gz, defer_outer, scope, DEFER_NORMAL_ONLY);
         emitDbgStmt(gz, ret_lc_line, ret_lc_column);
         if (use_ptr) {
             addUnNode(gz, ZIR_INST_RET_LOAD, ret_ptr_inst, node);
         } else {
             addUnNode(gz, ZIR_INST_RET_NODE, operand, node);
         }
         return ZIR_REF_UNREACHABLE_VALUE;
     } else {
         // .maybe (AstGen.zig:8208-8252).
         DeferCounts dc = countDefers(defer_outer, scope);
         if (!dc.have_err) {
             // Only regular defers; no branch needed (AstGen.zig:8210-8220).
             genDefers(gz, defer_outer, scope, DEFER_NORMAL_ONLY);
             emitDbgStmt(gz, ret_lc_line, ret_lc_column);
             uint32_t result = use_ptr
                 ? addUnNode(gz, ZIR_INST_LOAD, ret_ptr_inst, node)
                 : operand;
             ZirInstData rdata;
             rdata.un_node.operand = result;
             rdata.un_node.src_node
                 = (int32_t)node - (int32_t)gz->decl_node_index;
             addInstruction(gz, ZIR_INST_RESTORE_ERR_RET_INDEX_FN_ENTRY, rdata);
             if (use_ptr) {
                 addUnNode(gz, ZIR_INST_RET_LOAD, ret_ptr_inst, node);
             } else {
                 addUnNode(gz, ZIR_INST_RET_NODE, operand, node);
             }
             return ZIR_REF_UNREACHABLE_VALUE;
         }
         // have_err path: emit conditional branch (not yet implemented).
         // Fall through to simplified path.
         genDefers(gz, defer_outer, scope, DEFER_NORMAL_ONLY);
         emitDbgStmt(gz, ret_lc_line, ret_lc_column);
         if (use_ptr) {
             addUnNode(gz, ZIR_INST_RET_LOAD, ret_ptr_inst, node);
         } else {
             addUnNode(gz, ZIR_INST_RET_NODE, operand, node);
         }
         return ZIR_REF_UNREACHABLE_VALUE;
     }
 }
 
 // --- calleeExpr (AstGen.zig:10183) ---
 // Returns: 0 = direct call, 1 = field call.
 
 typedef struct {
     bool is_field;
     uint32_t obj_ptr; // for field calls: ref to object
     uint32_t field_name_start; // for field calls: string index
     uint32_t direct; // for direct calls: ref to callee
 } Callee;
 
 static Callee calleeExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t fn_expr_node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstNodeTag tag = tree->nodes.tags[fn_expr_node];
 
     if (tag == AST_NODE_FIELD_ACCESS) {
         AstData nd = tree->nodes.datas[fn_expr_node];
         uint32_t object_node = nd.lhs;
         uint32_t field_ident = nd.rhs;
         uint32_t str_index = identAsString(ag, field_ident);
         // Evaluate object with .ref rl (AstGen.zig:10207).
         uint32_t lhs = exprRl(gz, scope, RL_REF_VAL, object_node);
 
         // Advance to main token (the `.` dot) — not first token
         // (AstGen.zig:10209).
         advanceSourceCursorToMainToken(ag, gz, fn_expr_node);
         {
             uint32_t line = ag->source_line - gz->decl_line;
             uint32_t column = ag->source_column;
             emitDbgStmt(gz, line, column);
         }
 
         Callee c;
         c.is_field = true;
         c.obj_ptr = lhs;
         c.field_name_start = str_index;
         c.direct = 0;
         return c;
     }
 
     // enum_literal callee: decl literal call syntax (AstGen.zig:10217-10233).
     if (tag == AST_NODE_ENUM_LITERAL) {
         uint32_t res_ty = rlResultType(gz, rl, fn_expr_node);
         if (res_ty != 0) {
             uint32_t str_index
                 = identAsString(ag, tree->nodes.main_tokens[fn_expr_node]);
             uint32_t callee = addPlNodeBin(gz, ZIR_INST_DECL_LITERAL_NO_COERCE,
                 fn_expr_node, res_ty, str_index);
             Callee c;
             c.is_field = false;
             c.direct = callee;
             c.obj_ptr = 0;
             c.field_name_start = 0;
             return c;
         }
         // No result type: fall through to expr with rl=none.
     }
 
     // Default: direct call (AstGen.zig:10235).
     Callee c;
     c.is_field = false;
     c.direct = expr(gz, scope, fn_expr_node);
     c.obj_ptr = 0;
     c.field_name_start = 0;
     return c;
 }
 
 // --- callExpr (AstGen.zig:10058) ---
 static uint32_t callExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstNodeTag tag = tree->nodes.tags[node];
     AstData nd = tree->nodes.datas[node];
 
     // Extract callee and args from AST.
     uint32_t fn_expr_node;
     uint32_t arg_buf[2];
     const uint32_t* args = NULL;
     uint32_t args_len = 0;
     uint32_t lparen_tok;
 
     switch (tag) {
     case AST_NODE_CALL_ONE:
     case AST_NODE_CALL_ONE_COMMA: {
         fn_expr_node = nd.lhs;
         lparen_tok = tree->nodes.main_tokens[node];
         if (nd.rhs != 0) {
             arg_buf[0] = nd.rhs;
             args = arg_buf;
             args_len = 1;
         }
         break;
     }
     case AST_NODE_CALL:
     case AST_NODE_CALL_COMMA: {
         fn_expr_node = nd.lhs;
         lparen_tok = tree->nodes.main_tokens[node];
         uint32_t extra_idx = nd.rhs;
         uint32_t range_start = tree->extra_data.arr[extra_idx];
         uint32_t range_end = tree->extra_data.arr[extra_idx + 1];
         args = tree->extra_data.arr + range_start;
         args_len = range_end - range_start;
         break;
     }
     default:
         SET_ERROR(ag);
         return ZIR_REF_VOID_VALUE;
     }
 
     Callee callee = calleeExpr(gz, scope, rl, fn_expr_node);
 
     // dbg_stmt before call (AstGen.zig:10078-10083).
     {
         advanceSourceCursor(ag, tree->tokens.starts[lparen_tok]);
         uint32_t line = ag->source_line - gz->decl_line;
         uint32_t column = ag->source_column;
         emitDbgStmtForceCurrentIndex(gz, line, column);
     }
 
     // Reserve instruction slot for call (AstGen.zig:10093).
     uint32_t call_index = ag->inst_len;
     ensureInstCapacity(ag, 1);
     memset(&ag->inst_datas[call_index], 0, sizeof(ZirInstData));
     ag->inst_tags[call_index] = (ZirInstTag)0;
     ag->inst_len++;
     gzAppendInstruction(gz, call_index);
 
     // Process arguments in sub-blocks (AstGen.zig:10096-10116).
     // Upstream uses a separate scratch array; we use a local buffer for body
     // lengths and append body instructions to scratch_extra, then copy all
     // to extra after the call payload.
     uint32_t call_inst = call_index + ZIR_REF_START_INDEX;
     ResultLoc arg_rl = { .tag = RL_COERCED_TY,
         .data = call_inst,
         .src_node = 0,
         .ctx = RI_CTX_FN_ARG };
 
     // Use scratch_extra to collect body lengths + body instructions,
     // mirroring upstream's scratch array (AstGen.zig:10096-10116).
     uint32_t scratch_top = ag->scratch_extra_len;
     // Reserve space for cumulative body lengths (one per arg).
     ensureScratchExtraCapacity(ag, args_len);
     ag->scratch_extra_len += args_len;
 
     for (uint32_t i = 0; i < args_len; i++) {
         GenZir arg_block = makeSubBlock(gz, scope);
         uint32_t arg_ref
             = exprRl(&arg_block, &arg_block.base, arg_rl, args[i]);
 
         // break_inline with param_node src (AstGen.zig:10108).
         int32_t param_src
             = (int32_t)args[i] - (int32_t)arg_block.decl_node_index;
         makeBreakInline(&arg_block, call_index, arg_ref, param_src);
 
         // Append arg_block body to scratch_extra (with ref_table fixups).
         uint32_t raw_body_len = gzInstructionsLen(&arg_block);
         const uint32_t* body = gzInstructionsSlice(&arg_block);
         uint32_t fixup_len = countBodyLenAfterFixups(ag, body, raw_body_len);
         ensureScratchExtraCapacity(ag, fixup_len);
         for (uint32_t j = 0; j < raw_body_len; j++) {
             appendPossiblyRefdBodyInstScratch(ag, body[j]);
         }
         // Record cumulative body length (AstGen.zig:10114).
         ag->scratch_extra[scratch_top + i]
             = ag->scratch_extra_len - scratch_top;
         gzUnstack(&arg_block);
     }
 
     // Build call payload (AstGen.zig:10118-10168).
     // Upstream layout: [flags, callee/obj_ptr, field_name_start], then
     // body_lengths + body_instructions from scratch.
     // Flags layout (packed): modifier:u3, ensure_result_used:bool,
     // pop_error_return_trace:bool, args_len:u27.
     // pop_error_return_trace = !propagate_error_trace
     // (AstGen.zig:10121-10124).
     bool propagate_error_trace
         = (rl.ctx == RI_CTX_ERROR_HANDLING_EXPR || rl.ctx == RI_CTX_RETURN
             || rl.ctx == RI_CTX_FN_ARG || rl.ctx == RI_CTX_CONST_INIT);
     uint32_t flags = (propagate_error_trace ? 0u : (1u << 4))
         | ((args_len & 0x7FFFFFFu) << 5); // args_len
 
     if (callee.is_field) {
         // FieldCall: {flags, obj_ptr, field_name_start} (AstGen.zig:10148).
         ensureExtraCapacity(ag, 3 + (ag->scratch_extra_len - scratch_top));
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = flags;
         ag->extra[ag->extra_len++] = callee.obj_ptr;
         ag->extra[ag->extra_len++] = callee.field_name_start;
         // Append scratch data (body lengths + body instructions).
         if (args_len != 0) {
             memcpy(ag->extra + ag->extra_len, ag->scratch_extra + scratch_top,
                 (ag->scratch_extra_len - scratch_top) * sizeof(uint32_t));
             ag->extra_len += ag->scratch_extra_len - scratch_top;
         }
         ag->inst_tags[call_index] = ZIR_INST_FIELD_CALL;
         ag->inst_datas[call_index].pl_node.src_node
             = (int32_t)node - (int32_t)gz->decl_node_index;
         ag->inst_datas[call_index].pl_node.payload_index = payload_index;
     } else {
         // Call: {flags, callee} (AstGen.zig:10128).
         ensureExtraCapacity(ag, 2 + (ag->scratch_extra_len - scratch_top));
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = flags;
         ag->extra[ag->extra_len++] = callee.direct;
         // Append scratch data (body lengths + body instructions).
         if (args_len != 0) {
             memcpy(ag->extra + ag->extra_len, ag->scratch_extra + scratch_top,
                 (ag->scratch_extra_len - scratch_top) * sizeof(uint32_t));
             ag->extra_len += ag->scratch_extra_len - scratch_top;
         }
         ag->inst_tags[call_index] = ZIR_INST_CALL;
         ag->inst_datas[call_index].pl_node.src_node
             = (int32_t)node - (int32_t)gz->decl_node_index;
         ag->inst_datas[call_index].pl_node.payload_index = payload_index;
     }
 
     // Restore scratch (AstGen.zig:10097 defer).
     ag->scratch_extra_len = scratch_top;
 
     return call_index + ZIR_REF_START_INDEX;
 }
 
 // --- structInitExpr (AstGen.zig:1674) ---
 // Simplified: handles .{} (empty tuple), .{.a = b} (anon init).
 static uint32_t structInitExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstNodeTag tag = tree->nodes.tags[node];
     AstData nd = tree->nodes.datas[node];
 
     // Extract type_expr and fields.
     uint32_t type_expr_node = 0; // 0 = anonymous (.{...})
     uint32_t field_buf[2];
     const uint32_t* fields = NULL;
     uint32_t fields_len = 0;
 
     switch (tag) {
     case AST_NODE_STRUCT_INIT_DOT_TWO:
     case AST_NODE_STRUCT_INIT_DOT_TWO_COMMA: {
         // .{.a = lhs, .b = rhs}
         uint32_t idx = 0;
         if (nd.lhs != 0)
             field_buf[idx++] = nd.lhs;
         if (nd.rhs != 0)
             field_buf[idx++] = nd.rhs;
         fields = field_buf;
         fields_len = idx;
         break;
     }
     case AST_NODE_STRUCT_INIT_DOT:
     case AST_NODE_STRUCT_INIT_DOT_COMMA: {
         uint32_t start = nd.lhs;
         uint32_t end = nd.rhs;
         fields = tree->extra_data.arr + start;
         fields_len = end - start;
         break;
     }
     case AST_NODE_STRUCT_INIT_ONE:
     case AST_NODE_STRUCT_INIT_ONE_COMMA: {
         type_expr_node = nd.lhs;
         if (nd.rhs != 0) {
             field_buf[0] = nd.rhs;
             fields = field_buf;
             fields_len = 1;
         }
         break;
     }
     case AST_NODE_STRUCT_INIT:
     case AST_NODE_STRUCT_INIT_COMMA: {
         type_expr_node = nd.lhs;
         uint32_t extra_idx = nd.rhs;
         uint32_t range_start = tree->extra_data.arr[extra_idx];
         uint32_t range_end = tree->extra_data.arr[extra_idx + 1];
         fields = tree->extra_data.arr + range_start;
         fields_len = range_end - range_start;
         break;
     }
     default:
         SET_ERROR(ag);
         return ZIR_REF_VOID_VALUE;
     }
 
     if (type_expr_node == 0 && fields_len == 0) {
         // .{} — depends on result location (AstGen.zig:1687-1698).
         if (rl.tag == RL_REF_COERCED_TY) {
             return addUnNode(
                 gz, ZIR_INST_STRUCT_INIT_EMPTY_REF_RESULT, rl.data, node);
         }
         if (rl.tag == RL_TY || rl.tag == RL_COERCED_TY) {
             return addUnNode(
                 gz, ZIR_INST_STRUCT_INIT_EMPTY_RESULT, rl.data, node);
         }
         if (rl.tag == RL_DISCARD) {
             return ZIR_REF_VOID_VALUE;
         }
         return ZIR_REF_EMPTY_TUPLE;
     }
 
     // Pre-register all field names to match upstream string ordering.
     // Upstream has a duplicate name check (AstGen.zig:1756-1806) that
     // adds all field names to string_bytes before evaluating values.
     for (uint32_t i = 0; i < fields_len; i++) {
         uint32_t name_token = firstToken(tree, fields[i]) - 2;
         identAsString(ag, name_token);
     }
 
     if (type_expr_node == 0 && fields_len > 0) {
         // structInitExprPtr for RL_PTR (AstGen.zig:1843-1846, 1934-1964).
         if (rl.tag == RL_PTR) {
             uint32_t struct_ptr_inst
                 = addUnNode(gz, ZIR_INST_OPT_EU_BASE_PTR_INIT, rl.data, node);
             // Block payload: body_len = fields_len.
             ensureExtraCapacity(ag, 1 + fields_len);
             uint32_t payload_index = ag->extra_len;
             ag->extra[ag->extra_len++] = fields_len;
             uint32_t items_start = ag->extra_len;
             ag->extra_len += fields_len;
 
             for (uint32_t i = 0; i < fields_len; i++) {
                 uint32_t field_init = fields[i];
                 uint32_t name_token = firstToken(tree, field_init) - 2;
                 uint32_t str_index = identAsString(ag, name_token);
                 // struct_init_field_ptr (AstGen.zig:1954-1957).
                 uint32_t field_ptr
                     = addPlNodeBin(gz, ZIR_INST_STRUCT_INIT_FIELD_PTR,
                         field_init, struct_ptr_inst, str_index);
                 ag->extra[items_start + i]
                     = field_ptr - ZIR_REF_START_INDEX; // .toIndex()
                 // Evaluate init with ptr RL (AstGen.zig:1960).
                 ResultLoc ptr_rl = { .tag = RL_PTR,
                     .data = field_ptr,
                     .src_node = 0,
                     .ctx = rl.ctx };
                 exprRl(gz, scope, ptr_rl, field_init);
             }
             addPlNodePayloadIndex(
                 gz, ZIR_INST_VALIDATE_PTR_STRUCT_INIT, node, payload_index);
             return ZIR_REF_VOID_VALUE;
         }
         // Anonymous struct init with RL type (AstGen.zig:1706-1731).
         if (rl.tag == RL_TY || rl.tag == RL_COERCED_TY) {
             uint32_t ty_inst = rl.data;
             // validate_struct_init_result_ty (AstGen.zig:1840).
             addUnNode(
                 gz, ZIR_INST_VALIDATE_STRUCT_INIT_RESULT_TY, ty_inst, node);
             // structInitExprTyped (AstGen.zig:1896-1931).
             ensureExtraCapacity(ag, 3 + fields_len * 2);
             uint32_t payload_index = ag->extra_len;
             ag->extra[ag->extra_len++] = node;
             ag->extra[ag->extra_len++] = ag->source_line;
             ag->extra[ag->extra_len++] = fields_len;
             uint32_t items_start = ag->extra_len;
             ag->extra_len += fields_len * 2;
             for (uint32_t i = 0; i < fields_len; i++) {
                 uint32_t field_init = fields[i];
                 uint32_t name_token = firstToken(tree, field_init) - 2;
                 uint32_t str_index = identAsString(ag, name_token);
                 uint32_t field_ty_inst
                     = addPlNodeBin(gz, ZIR_INST_STRUCT_INIT_FIELD_TYPE,
                         field_init, ty_inst, str_index);
                 ResultLoc elem_rl = {
                     .tag = RL_COERCED_TY, .data = field_ty_inst, .src_node = 0
                 };
                 uint32_t init_ref = exprRl(gz, scope, elem_rl, field_init);
                 ag->extra[items_start + i * 2]
                     = field_ty_inst - ZIR_REF_START_INDEX;
                 ag->extra[items_start + i * 2 + 1] = init_ref;
             }
             return addPlNodePayloadIndex(
                 gz, ZIR_INST_STRUCT_INIT, node, payload_index);
         }
         // Anonymous struct init without RL type (AstGen.zig:1864).
         // StructInitAnon payload: abs_node, abs_line, fields_len.
         ensureExtraCapacity(ag, 3 + fields_len * 2);
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = node; // abs_node
         ag->extra[ag->extra_len++] = ag->source_line; // abs_line
         ag->extra[ag->extra_len++] = fields_len;
         // Reserve space for field entries.
         uint32_t items_start = ag->extra_len;
         ag->extra_len += fields_len * 2;
 
         for (uint32_t i = 0; i < fields_len; i++) {
             uint32_t field_init = fields[i];
             // field name is 2 tokens before the field init's first token.
             uint32_t name_token = firstToken(tree, field_init) - 2;
             uint32_t str_index = identAsString(ag, name_token);
             uint32_t init_ref = expr(gz, scope, field_init);
             ag->extra[items_start + i * 2] = str_index;
             ag->extra[items_start + i * 2 + 1] = init_ref;
         }
 
         return addPlNodePayloadIndex(
             gz, ZIR_INST_STRUCT_INIT_ANON, node, payload_index);
     }
 
     // Typed init: evaluate type, emit struct_init_empty or struct_init.
     if (type_expr_node != 0 && fields_len == 0) {
         // Check for [_]T{} pattern (AstGen.zig:1707-1753).
         AstNodeTag type_tag = tree->nodes.tags[type_expr_node];
         if (type_tag == AST_NODE_ARRAY_TYPE
             || type_tag == AST_NODE_ARRAY_TYPE_SENTINEL) {
             AstData type_nd = tree->nodes.datas[type_expr_node];
             uint32_t elem_count_node = type_nd.lhs;
             if (tree->nodes.tags[elem_count_node] == AST_NODE_IDENTIFIER
                 && isUnderscoreIdent(tree, elem_count_node)) {
                 // Inferred length with 0 fields → length 0.
                 if (type_tag == AST_NODE_ARRAY_TYPE) {
                     uint32_t elem_type = typeExpr(gz, scope, type_nd.rhs);
                     uint32_t array_type_inst
                         = addPlNodeBin(gz, ZIR_INST_ARRAY_TYPE, type_expr_node,
                             ZIR_REF_ZERO_USIZE, elem_type);
                     return rvalue(gz, rl,
                         addUnNode(gz, ZIR_INST_STRUCT_INIT_EMPTY,
                             array_type_inst, node),
                         node);
                 }
                 // ARRAY_TYPE_SENTINEL: extra[rhs] = sentinel, extra[rhs+1]
                 // = elem_type
                 uint32_t sentinel_node = tree->extra_data.arr[type_nd.rhs];
                 uint32_t elem_type_node
                     = tree->extra_data.arr[type_nd.rhs + 1];
                 uint32_t elem_type = typeExpr(gz, scope, elem_type_node);
                 ResultLoc sent_rl = { .tag = RL_COERCED_TY,
                     .data = elem_type,
                     .src_node = 0,
                     .ctx = RI_CTX_NONE };
                 uint32_t sentinel = comptimeExpr(gz, scope, sent_rl,
                     sentinel_node, COMPTIME_REASON_ARRAY_SENTINEL);
                 uint32_t array_type_inst = addPlNodeTriple(gz,
                     ZIR_INST_ARRAY_TYPE_SENTINEL, type_expr_node,
                     ZIR_REF_ZERO_USIZE, elem_type, sentinel);
                 return rvalue(gz, rl,
                     addUnNode(
                         gz, ZIR_INST_STRUCT_INIT_EMPTY, array_type_inst, node),
                     node);
             }
         }
         uint32_t ty_inst = typeExpr(gz, scope, type_expr_node);
         return rvalue(gz, rl,
             addUnNode(gz, ZIR_INST_STRUCT_INIT_EMPTY, ty_inst, node), node);
     }
 
     // Typed struct init with fields (AstGen.zig:1808-1818).
     if (type_expr_node != 0 && fields_len > 0) {
         uint32_t ty_inst = typeExpr(gz, scope, type_expr_node);
         addUnNode(gz, ZIR_INST_VALIDATE_STRUCT_INIT_TY, ty_inst, node);
 
         // structInitExprTyped (AstGen.zig:1896-1931).
         // StructInit payload: abs_node, abs_line, fields_len.
         ensureExtraCapacity(ag, 3 + fields_len * 2);
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = node; // abs_node
         ag->extra[ag->extra_len++] = ag->source_line; // abs_line
         ag->extra[ag->extra_len++] = fields_len;
         // Reserve space for field items (field_type + init each).
         uint32_t items_start = ag->extra_len;
         ag->extra_len += fields_len * 2;
 
         for (uint32_t i = 0; i < fields_len; i++) {
             uint32_t field_init = fields[i];
             uint32_t name_token = firstToken(tree, field_init) - 2;
             uint32_t str_index = identAsString(ag, name_token);
             // struct_init_field_type (AstGen.zig:1918-1921).
             uint32_t field_ty_inst
                 = addPlNodeBin(gz, ZIR_INST_STRUCT_INIT_FIELD_TYPE, field_init,
                     ty_inst, str_index);
             // Evaluate init with coerced_ty (AstGen.zig:1924).
             ResultLoc elem_rl = { .tag = RL_COERCED_TY,
                 .data = field_ty_inst,
                 .src_node = 0,
                 .ctx = rl.ctx };
             uint32_t init_ref = exprRl(gz, scope, elem_rl, field_init);
             ag->extra[items_start + i * 2]
                 = field_ty_inst - ZIR_REF_START_INDEX; // .toIndex()
             ag->extra[items_start + i * 2 + 1] = init_ref;
         }
 
         bool is_ref = (RL_IS_REF(rl));
         ZirInstTag init_tag
             = is_ref ? ZIR_INST_STRUCT_INIT_REF : ZIR_INST_STRUCT_INIT;
         return addPlNodePayloadIndex(gz, init_tag, node, payload_index);
     }
 
     SET_ERROR(ag);
     return ZIR_REF_VOID_VALUE;
 }
 
 // --- tryExpr (AstGen.zig:5957) ---
 static uint32_t tryExpr(GenZir* gz, Scope* scope, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     AstData nd = ag->tree->nodes.datas[node];
     uint32_t operand_node = nd.lhs;
 
     if (!gz->is_comptime) {
         emitDbgNode(gz, node);
     }
     uint32_t try_lc_line = ag->source_line - gz->decl_line;
     uint32_t try_lc_column = ag->source_column;
 
     // Evaluate operand (AstGen.zig:5993-6001).
     ResultLoc operand_rl = RL_NONE_VAL;
     operand_rl.ctx = RI_CTX_ERROR_HANDLING_EXPR;
     uint32_t operand = exprRl(gz, scope, operand_rl, operand_node);
 
     // Create try block instruction (AstGen.zig:6007).
     uint32_t try_inst = makeBlockInst(ag, ZIR_INST_TRY, gz, node);
     gzAppendInstruction(gz, try_inst);
 
     // Else scope: extract error code, return it (AstGen.zig:6012-6025).
     GenZir else_scope = makeSubBlock(gz, scope);
 
     uint32_t err_code
         = addUnNode(&else_scope, ZIR_INST_ERR_UNION_CODE, operand, node);
 
     // Emit defers for error path (AstGen.zig:6019).
     if (ag->fn_block != NULL) {
         const Scope* fn_block_scope = &((GenZir*)ag->fn_block)->base;
         genDefers(&else_scope, fn_block_scope, scope, DEFER_BOTH_SANS_ERR);
     }
 
     // Emit dbg_stmt at try keyword for error return tracing (AstGen.zig:6020).
     emitDbgStmt(&else_scope, try_lc_line, try_lc_column);
 
     // ret_node with error code (AstGen.zig:6021).
     addUnNode(&else_scope, ZIR_INST_RET_NODE, err_code, node);
 
     setTryBody(ag, &else_scope, try_inst, operand);
     // else_scope unstacked by setTryBody.
 
     return try_inst + ZIR_REF_START_INDEX; // toRef()
 }
 
 // --- boolBinOp (AstGen.zig:6274) ---
 // Short-circuiting boolean and/or.
 
 static uint32_t boolBinOp(
     GenZir* gz, Scope* scope, uint32_t node, ZirInstTag zir_tag) {
     AstGenCtx* ag = gz->astgen;
     AstData nd = ag->tree->nodes.datas[node];
     uint32_t lhs_node = nd.lhs;
     uint32_t rhs_node = nd.rhs;
 
     // Evaluate LHS (AstGen.zig:6285).
     uint32_t lhs = expr(gz, scope, lhs_node);
 
     // Reserve the bool_br instruction (payload set later)
     // (AstGen.zig:6286).
     uint32_t bool_br = reserveInstructionIndex(ag);
     gzAppendInstruction(gz, bool_br);
 
     // Evaluate RHS in sub-block (AstGen.zig:6288-6293).
     GenZir rhs_scope = makeSubBlock(gz, scope);
     uint32_t rhs = expr(&rhs_scope, &rhs_scope.base, rhs_node);
 
     if (!ag->has_compile_errors) {
         // break_inline from rhs to bool_br (AstGen.zig:6292).
         makeBreakInline(&rhs_scope, bool_br, rhs,
             (int32_t)rhs_node - (int32_t)rhs_scope.decl_node_index);
     }
 
     // setBoolBrBody (AstGen.zig:6294, 11929-11944).
     uint32_t raw_body_len = gzInstructionsLen(&rhs_scope);
     const uint32_t* body = gzInstructionsSlice(&rhs_scope);
     uint32_t body_len = countBodyLenAfterFixups(ag, body, raw_body_len);
     ensureExtraCapacity(ag, 2 + body_len);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = lhs; // BoolBr.lhs
     ag->extra[ag->extra_len++] = body_len; // BoolBr.body_len
     for (uint32_t i = 0; i < raw_body_len; i++)
         appendPossiblyRefdBodyInst(ag, body[i]);
     gzUnstack(&rhs_scope);
 
     // Fill in the bool_br instruction.
     ag->inst_tags[bool_br] = zir_tag;
     ag->inst_datas[bool_br].pl_node.src_node
         = (int32_t)node - (int32_t)gz->decl_node_index;
     ag->inst_datas[bool_br].pl_node.payload_index = payload_index;
 
     return bool_br + ZIR_REF_START_INDEX;
 }
 
 // Mirrors expr (AstGen.zig:634) — main expression dispatcher.
 static uint32_t exprRl(GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     if (node == 0) {
         SET_ERROR(ag);
         return ZIR_REF_VOID_VALUE;
     }
     AstNodeTag tag = ag->tree->nodes.tags[node];
     AstData nd = ag->tree->nodes.datas[node];
 
     switch (tag) {
     case AST_NODE_NUMBER_LITERAL:
         return rvalue(gz, rl, numberLiteral(gz, node), node);
     case AST_NODE_BUILTIN_CALL_TWO:
     case AST_NODE_BUILTIN_CALL_TWO_COMMA:
         return rvalue(gz, rl, builtinCall(gz, scope, rl, node), node);
     case AST_NODE_FIELD_ACCESS:
         return fieldAccessExpr(gz, scope, rl, node);
     case AST_NODE_IDENTIFIER:
         return identifierExpr(gz, scope, rl, node);
     case AST_NODE_STRING_LITERAL: {
         // Mirrors stringLiteral (AstGen.zig:8626).
         uint32_t str_lit_token = ag->tree->nodes.main_tokens[node];
         uint32_t str_index, str_len;
         strLitAsString(ag, str_lit_token, &str_index, &str_len);
         ZirInstData data;
         data.str.start = str_index;
         data.str.len = str_len;
         uint32_t str_result = addInstruction(gz, ZIR_INST_STR, data);
         return rvalue(gz, rl, str_result, node);
     }
     // address_of (AstGen.zig:953-960): evaluate operand with .ref rl.
     case AST_NODE_ADDRESS_OF: {
         uint32_t operand_node = ag->tree->nodes.datas[node].lhs;
         // Check for result type to emit validate_ref_ty (AstGen.zig:954-956).
         uint32_t res_ty = rlResultType(gz, rl, node);
         ResultLoc operand_rl;
         if (res_ty != 0) {
             addUnTok(gz, ZIR_INST_VALIDATE_REF_TY, res_ty,
                 firstToken(ag->tree, node));
             // Pass ref_coerced_ty so init expressions can use the type
             // (AstGen.zig:958).
             operand_rl = (ResultLoc) {
                 .tag = RL_REF_COERCED_TY, .data = res_ty, .src_node = 0
             };
         } else {
             operand_rl = RL_REF_VAL;
         }
         uint32_t result = exprRl(gz, scope, operand_rl, operand_node);
         return rvalue(gz, rl, result, node);
     }
     // ptr_type (AstGen.zig:1077-1081).
     case AST_NODE_PTR_TYPE_ALIGNED:
     case AST_NODE_PTR_TYPE_SENTINEL:
     case AST_NODE_PTR_TYPE:
     case AST_NODE_PTR_TYPE_BIT_RANGE:
         return rvalue(gz, rl, ptrTypeExpr(gz, scope, node), node);
     // array_type (AstGen.zig:940).
     case AST_NODE_ARRAY_TYPE:
         return rvalue(gz, rl, arrayTypeExpr(gz, scope, node), node);
     // array_init variants (AstGen.zig:836-856).
     case AST_NODE_ARRAY_INIT:
     case AST_NODE_ARRAY_INIT_COMMA:
     case AST_NODE_ARRAY_INIT_ONE:
     case AST_NODE_ARRAY_INIT_ONE_COMMA:
         return arrayInitExpr(gz, scope, rl, node);
     // array_cat (AstGen.zig:772): ++ binary operator.
     case AST_NODE_ARRAY_CAT:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_ARRAY_CAT), node);
     // grouped_expression (AstGen.zig:1100): passthrough.
     case AST_NODE_GROUPED_EXPRESSION:
         return exprRl(gz, scope, rl, ag->tree->nodes.datas[node].lhs);
     // unreachable_literal (AstGen.zig:846-854).
     case AST_NODE_UNREACHABLE_LITERAL: {
         emitDbgNode(gz, node);
         ZirInstData udata;
         memset(&udata, 0, sizeof(udata));
         udata.unreachable_data.src_node
             = (int32_t)node - (int32_t)gz->decl_node_index;
         addInstruction(gz, ZIR_INST_UNREACHABLE, udata);
         return ZIR_REF_UNREACHABLE_VALUE;
     }
     // enum_literal (AstGen.zig:993).
     case AST_NODE_ENUM_LITERAL: {
         uint32_t ident_token = ag->tree->nodes.main_tokens[node];
         uint32_t str_index = identAsString(ag, ident_token);
         // If result type available, emit decl_literal (AstGen.zig:993-1003).
         uint32_t res_ty = rlResultType(gz, rl, node);
         if (res_ty != 0) {
             uint32_t res = addPlNodeBin(
                 gz, ZIR_INST_DECL_LITERAL, node, res_ty, str_index);
             // decl_literal does the coercion for us (AstGen.zig:1001).
             // Only need rvalue for ptr/inferred_ptr/ref_coerced_ty.
             if (rl.tag == RL_TY || rl.tag == RL_COERCED_TY)
                 return res;
             return rvalue(gz, rl, res, node);
         }
         return rvalue(gz, rl,
             addStrTok(gz, ZIR_INST_ENUM_LITERAL, str_index, ident_token),
             node);
     }
     // multiline_string_literal (AstGen.zig:8645).
     case AST_NODE_MULTILINE_STRING_LITERAL:
         return rvalue(gz, rl, multilineStringLiteral(gz, scope, node), node);
     // return (AstGen.zig:856).
     case AST_NODE_RETURN:
         return retExpr(gz, scope, node);
     // call (AstGen.zig:783-790).
     case AST_NODE_CALL_ONE:
     case AST_NODE_CALL_ONE_COMMA:
     case AST_NODE_CALL:
     case AST_NODE_CALL_COMMA:
         return rvalue(gz, rl, callExpr(gz, scope, rl, node), node);
     // struct_init (AstGen.zig:836-839).
     case AST_NODE_STRUCT_INIT_DOT_TWO:
     case AST_NODE_STRUCT_INIT_DOT_TWO_COMMA:
     case AST_NODE_STRUCT_INIT_DOT:
     case AST_NODE_STRUCT_INIT_DOT_COMMA:
     case AST_NODE_STRUCT_INIT_ONE:
     case AST_NODE_STRUCT_INIT_ONE_COMMA:
     case AST_NODE_STRUCT_INIT:
     case AST_NODE_STRUCT_INIT_COMMA:
         return structInitExpr(gz, scope, rl, node);
     // container_decl (AstGen.zig:1083-1098).
     case AST_NODE_CONTAINER_DECL:
     case AST_NODE_CONTAINER_DECL_TRAILING:
     case AST_NODE_CONTAINER_DECL_TWO:
     case AST_NODE_CONTAINER_DECL_TWO_TRAILING:
     case AST_NODE_CONTAINER_DECL_ARG:
     case AST_NODE_CONTAINER_DECL_ARG_TRAILING:
     case AST_NODE_TAGGED_UNION:
     case AST_NODE_TAGGED_UNION_TRAILING:
     case AST_NODE_TAGGED_UNION_TWO:
     case AST_NODE_TAGGED_UNION_TWO_TRAILING:
     case AST_NODE_TAGGED_UNION_ENUM_TAG:
     case AST_NODE_TAGGED_UNION_ENUM_TAG_TRAILING:
         return rvalue(gz, rl, containerDecl(gz, scope, node), node);
     // try (AstGen.zig:831).
     case AST_NODE_TRY:
         return rvalue(gz, rl, tryExpr(gz, scope, node), node);
     // Comparison operators (AstGen.zig:714-726).
     case AST_NODE_EQUAL_EQUAL:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_CMP_EQ), node);
     case AST_NODE_BANG_EQUAL:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_CMP_NEQ), node);
     case AST_NODE_LESS_THAN:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_CMP_LT), node);
     case AST_NODE_GREATER_THAN:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_CMP_GT), node);
     case AST_NODE_LESS_OR_EQUAL:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_CMP_LTE), node);
     case AST_NODE_GREATER_OR_EQUAL:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_CMP_GTE), node);
     // Arithmetic (AstGen.zig:656-698).
     case AST_NODE_ADD:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_ADD), node);
     case AST_NODE_SUB:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_SUB), node);
     case AST_NODE_MUL:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_MUL), node);
     case AST_NODE_DIV:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_DIV), node);
     case AST_NODE_MOD:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_MOD), node);
     // Bitwise (AstGen.zig:700-712).
     case AST_NODE_BIT_AND:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_BIT_AND), node);
     case AST_NODE_BIT_OR:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_BIT_OR), node);
     case AST_NODE_BIT_XOR:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_XOR), node);
     case AST_NODE_SHL:
         return rvalue(gz, rl, shiftOp(gz, scope, node, ZIR_INST_SHL), node);
     case AST_NODE_SHR:
         return rvalue(gz, rl, shiftOp(gz, scope, node, ZIR_INST_SHR), node);
     // Boolean operators (AstGen.zig:728-731) — special: boolBinOp.
     case AST_NODE_BOOL_AND:
         return rvalue(
             gz, rl, boolBinOp(gz, scope, node, ZIR_INST_BOOL_BR_AND), node);
     case AST_NODE_BOOL_OR:
         return rvalue(
             gz, rl, boolBinOp(gz, scope, node, ZIR_INST_BOOL_BR_OR), node);
     // Unary operators (AstGen.zig:919-938).
     case AST_NODE_BOOL_NOT:
         return rvalue(gz, rl,
             addUnNode(gz, ZIR_INST_BOOL_NOT, expr(gz, scope, nd.lhs), node),
             node);
     case AST_NODE_BIT_NOT:
         return rvalue(gz, rl,
             addUnNode(gz, ZIR_INST_BIT_NOT, expr(gz, scope, nd.lhs), node),
             node);
     case AST_NODE_NEGATION:
         return rvalue(gz, rl,
             addUnNode(gz, ZIR_INST_NEGATE, expr(gz, scope, nd.lhs), node),
             node);
     case AST_NODE_NEGATION_WRAP:
         return rvalue(gz, rl,
             addUnNode(gz, ZIR_INST_NEGATE_WRAP, expr(gz, scope, nd.lhs), node),
             node);
     // deref (AstGen.zig:942-951).
     case AST_NODE_DEREF: {
         uint32_t lhs = expr(gz, scope, nd.lhs);
         addUnNode(gz, ZIR_INST_VALIDATE_DEREF, lhs, node);
         if (RL_IS_REF(rl))
             return lhs;
         return rvalue(gz, rl, addUnNode(gz, ZIR_INST_LOAD, lhs, node), node);
     }
     // optional_type (AstGen.zig:961-964).
     case AST_NODE_OPTIONAL_TYPE:
         return rvalue(gz, rl,
             addUnNode(
                 gz, ZIR_INST_OPTIONAL_TYPE, typeExpr(gz, scope, nd.lhs), node),
             node);
     // unwrap_optional (AstGen.zig:966-985).
     case AST_NODE_UNWRAP_OPTIONAL: {
         uint32_t lhs = expr(gz, scope, nd.lhs);
         advanceSourceCursorToMainToken(ag, gz, node);
         uint32_t saved_line = ag->source_line - gz->decl_line;
         uint32_t saved_col = ag->source_column;
         emitDbgStmt(gz, saved_line, saved_col);
         return rvalue(gz, rl,
             addUnNode(gz, ZIR_INST_OPTIONAL_PAYLOAD_SAFE, lhs, node), node);
     }
     // error_union type (AstGen.zig:788-797).
     case AST_NODE_ERROR_UNION: {
         uint32_t lhs = typeExpr(gz, scope, nd.lhs);
         uint32_t rhs = typeExpr(gz, scope, nd.rhs);
         return rvalue(gz, rl,
             addPlNodeBin(gz, ZIR_INST_ERROR_UNION_TYPE, node, lhs, rhs), node);
     }
     // char_literal (AstGen.zig:8662-8675).
     case AST_NODE_CHAR_LITERAL: {
         uint32_t main_tok = ag->tree->nodes.main_tokens[node];
         uint32_t tok_start = ag->tree->tokens.starts[main_tok];
         const char* src = ag->tree->source;
         uint32_t ci = tok_start + 1; // skip opening quote
         uint64_t char_val;
         if (src[ci] == '\\') {
             // Escape sequence (AstGen.zig:8668-8675).
             ci++;
             switch (src[ci]) {
             case 'n':
                 char_val = '\n';
                 break;
             case 'r':
                 char_val = '\r';
                 break;
             case 't':
                 char_val = '\t';
                 break;
             case '\\':
                 char_val = '\\';
                 break;
             case '\'':
                 char_val = '\'';
                 break;
             case '"':
                 char_val = '"';
                 break;
             case 'x': {
                 // \xNN hex escape.
                 uint8_t val = 0;
                 for (int k = 0; k < 2; k++) {
                     ci++;
                     char c = src[ci];
                     if (c >= '0' && c <= '9')
                         val = (uint8_t)(val * 16 + (uint8_t)(c - '0'));
                     else if (c >= 'a' && c <= 'f')
                         val = (uint8_t)(val * 16 + 10 + (uint8_t)(c - 'a'));
                     else if (c >= 'A' && c <= 'F')
                         val = (uint8_t)(val * 16 + 10 + (uint8_t)(c - 'A'));
                 }
                 char_val = val;
                 break;
             }
             case 'u': {
                 // \u{NNNNNN} unicode escape (string_literal.zig:194-231).
                 // Skip past '{'.
                 ci++;
                 uint32_t codepoint = 0;
                 while (true) {
                     ci++;
                     char c = src[ci];
                     if (c >= '0' && c <= '9')
                         codepoint = codepoint * 16 + (uint32_t)(c - '0');
                     else if (c >= 'a' && c <= 'f')
                         codepoint = codepoint * 16 + 10 + (uint32_t)(c - 'a');
                     else if (c >= 'A' && c <= 'F')
                         codepoint = codepoint * 16 + 10 + (uint32_t)(c - 'A');
                     else
                         break; // Must be '}'.
                 }
                 char_val = codepoint;
                 break;
             }
             default:
                 char_val = (uint8_t)src[ci];
                 break;
             }
         } else {
             char_val = (uint64_t)(uint8_t)src[ci];
         }
         return rvalue(gz, rl, addInt(gz, char_val), node);
     }
     // arrayAccess (AstGen.zig:6192-6221).
     case AST_NODE_ARRAY_ACCESS: {
         if (RL_IS_REF(rl)) {
             uint32_t lhs = exprRl(gz, scope, RL_REF_VAL, nd.lhs);
             advanceSourceCursorToMainToken(ag, gz, node);
             uint32_t saved_line = ag->source_line - gz->decl_line;
             uint32_t saved_col = ag->source_column;
             uint32_t rhs = expr(gz, scope, nd.rhs);
             emitDbgStmt(gz, saved_line, saved_col);
             return addPlNodeBin(gz, ZIR_INST_ELEM_PTR_NODE, node, lhs, rhs);
         }
         uint32_t lhs = expr(gz, scope, nd.lhs);
         advanceSourceCursorToMainToken(ag, gz, node);
         uint32_t saved_line = ag->source_line - gz->decl_line;
         uint32_t saved_col = ag->source_column;
         uint32_t rhs = expr(gz, scope, nd.rhs);
         emitDbgStmt(gz, saved_line, saved_col);
         return rvalue(gz, rl,
             addPlNodeBin(gz, ZIR_INST_ELEM_VAL_NODE, node, lhs, rhs), node);
     }
     // slice (AstGen.zig:882-939).
     case AST_NODE_SLICE_OPEN: {
         // (AstGen.zig:908-937).
         uint32_t lhs = exprRl(gz, scope, RL_REF_VAL, nd.lhs);
         advanceSourceCursorToMainToken(ag, gz, node);
         uint32_t saved_line = ag->source_line - gz->decl_line;
         uint32_t saved_col = ag->source_column;
         ResultLoc usize_rl = { .tag = RL_COERCED_TY,
             .data = ZIR_REF_USIZE_TYPE,
             .src_node = 0,
             .ctx = RI_CTX_NONE };
         uint32_t start = exprRl(gz, scope, usize_rl, nd.rhs);
         emitDbgStmt(gz, saved_line, saved_col);
         return rvalue(gz, rl,
             addPlNodeBin(gz, ZIR_INST_SLICE_START, node, lhs, start), node);
     }
     case AST_NODE_SLICE: {
         // Slice[rhs]: { start, end } (AstGen.zig:908-937).
         const Ast* stree = ag->tree;
         uint32_t lhs = exprRl(gz, scope, RL_REF_VAL, nd.lhs);
         advanceSourceCursorToMainToken(ag, gz, node);
         uint32_t saved_line = ag->source_line - gz->decl_line;
         uint32_t saved_col = ag->source_column;
         uint32_t start_node = stree->extra_data.arr[nd.rhs];
         uint32_t end_node = stree->extra_data.arr[nd.rhs + 1];
         ResultLoc usize_rl = { .tag = RL_COERCED_TY,
             .data = ZIR_REF_USIZE_TYPE,
             .src_node = 0,
             .ctx = RI_CTX_NONE };
         uint32_t start_ref = exprRl(gz, scope, usize_rl, start_node);
         uint32_t end_ref = exprRl(gz, scope, usize_rl, end_node);
         emitDbgStmt(gz, saved_line, saved_col);
         ensureExtraCapacity(ag, 3);
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = lhs;
         ag->extra[ag->extra_len++] = start_ref;
         ag->extra[ag->extra_len++] = end_ref;
         ZirInstData data;
         data.pl_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
         data.pl_node.payload_index = payload_index;
         return rvalue(
             gz, rl, addInstruction(gz, ZIR_INST_SLICE_END, data), node);
     }
     case AST_NODE_SLICE_SENTINEL: {
         // SliceSentinel[rhs]: { start, end, sentinel }
         // (AstGen.zig:908-925).
         const Ast* stree = ag->tree;
         uint32_t lhs = exprRl(gz, scope, RL_REF_VAL, nd.lhs);
         advanceSourceCursorToMainToken(ag, gz, node);
         uint32_t saved_line = ag->source_line - gz->decl_line;
         uint32_t saved_col = ag->source_column;
         uint32_t start_node = stree->extra_data.arr[nd.rhs];
         uint32_t end_node = stree->extra_data.arr[nd.rhs + 1];
         uint32_t sentinel_node = stree->extra_data.arr[nd.rhs + 2];
         // start/end coerced to usize (AstGen.zig:911-912).
         ResultLoc usize_rl = { .tag = RL_COERCED_TY,
             .data = ZIR_REF_USIZE_TYPE,
             .src_node = 0,
             .ctx = RI_CTX_NONE };
         uint32_t start_ref = exprRl(gz, scope, usize_rl, start_node);
         uint32_t end_ref = (end_node != 0)
             ? exprRl(gz, scope, usize_rl, end_node)
             : ZIR_REF_NONE;
         // sentinel: create slice_sentinel_ty and coerce (AstGen.zig:913-916).
         uint32_t sentinel_ty
             = addUnNode(gz, ZIR_INST_SLICE_SENTINEL_TY, lhs, node);
         ResultLoc sent_rl = { .tag = RL_COERCED_TY,
             .data = sentinel_ty,
             .src_node = 0,
             .ctx = RI_CTX_NONE };
         uint32_t sentinel_ref = exprRl(gz, scope, sent_rl, sentinel_node);
         emitDbgStmt(gz, saved_line, saved_col);
         ensureExtraCapacity(ag, 4);
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = lhs;
         ag->extra[ag->extra_len++] = start_ref;
         ag->extra[ag->extra_len++] = end_ref;
         ag->extra[ag->extra_len++] = sentinel_ref;
         ZirInstData data;
         data.pl_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
         data.pl_node.payload_index = payload_index;
         return rvalue(
             gz, rl, addInstruction(gz, ZIR_INST_SLICE_SENTINEL, data), node);
     }
     // orelse (AstGen.zig:6031-6142).
     case AST_NODE_ORELSE:
         return orelseCatchExpr(gz, scope, rl, node, false);
     // catch (AstGen.zig:6031-6142).
     case AST_NODE_CATCH:
         return orelseCatchExpr(gz, scope, rl, node, true);
     // Block expressions (AstGen.zig:984-992).
     case AST_NODE_BLOCK_TWO:
     case AST_NODE_BLOCK_TWO_SEMICOLON:
     case AST_NODE_BLOCK:
     case AST_NODE_BLOCK_SEMICOLON:
         return rvalue(gz, rl, blockExprExpr(gz, scope, rl, node), node);
     // Anonymous array init (AstGen.zig:1119-1127).
     case AST_NODE_ARRAY_INIT_DOT_TWO:
     case AST_NODE_ARRAY_INIT_DOT_TWO_COMMA:
     case AST_NODE_ARRAY_INIT_DOT:
     case AST_NODE_ARRAY_INIT_DOT_COMMA:
         return arrayInitDotExpr(gz, scope, rl, node);
     // if (AstGen.zig:1013-1024).
     case AST_NODE_IF_SIMPLE:
     case AST_NODE_IF:
         return ifExpr(gz, scope, rlBr(rl), node);
     // for (AstGen.zig:1043-1060).
     case AST_NODE_FOR_SIMPLE:
     case AST_NODE_FOR:
         return rvalue(gz, rl, forExpr(gz, scope, node, false), node);
     // Merge error sets (AstGen.zig:788-797).
     case AST_NODE_MERGE_ERROR_SETS: {
         uint32_t lhs = typeExpr(gz, scope, nd.lhs);
         uint32_t rhs = typeExpr(gz, scope, nd.rhs);
         return rvalue(gz, rl,
             addPlNodeBin(gz, ZIR_INST_MERGE_ERROR_SETS, node, lhs, rhs), node);
     }
     // Wrapping arithmetic.
     case AST_NODE_ADD_WRAP:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_ADDWRAP), node);
     case AST_NODE_SUB_WRAP:
         return rvalue(
             gz, rl, simpleBinOp(gz, scope, node, ZIR_INST_SUBWRAP), node);
     // break (AstGen.zig:2150-2237).
     case AST_NODE_BREAK: {
         uint32_t opt_break_label = nd.lhs; // UINT32_MAX = none
         uint32_t opt_rhs = nd.rhs; // 0 = none
 
         // Walk scope chain to find target block (AstGen.zig:2157-2187).
         for (Scope* s = scope; s != NULL;) {
             if (s->tag == SCOPE_GEN_ZIR) {
                 GenZir* block_gz = (GenZir*)s;
                 uint32_t block_inst = UINT32_MAX;
                 if (opt_break_label != UINT32_MAX) {
                     // Labeled break: check label on GenZir.
                     // Use direct source text comparison, not identAsString,
                     // to avoid adding label names to string_bytes
                     // (AstGen.zig:2176 uses tokenIdentEql).
                     if (block_gz->label_token != UINT32_MAX
                         && tokenIdentEql(ag->tree, opt_break_label,
                             block_gz->label_token)) {
                         block_inst = block_gz->label_block_inst;
                     }
                 } else {
                     // Unlabeled break: check break_block.
                     if (block_gz->break_block != UINT32_MAX)
                         block_inst = block_gz->break_block;
                 }
                 if (block_inst != UINT32_MAX) {
                     // Found target (AstGen.zig:2188-2228).
                     ZirInstTag break_tag = block_gz->is_inline
                         ? ZIR_INST_BREAK_INLINE
                         : ZIR_INST_BREAK;
                     if (opt_rhs == 0) {
                         // Void break (AstGen.zig:2195-2206).
                         rvalue(gz, block_gz->break_result_info,
                             ZIR_REF_VOID_VALUE, node);
                         genDefers(gz, s, scope, DEFER_NORMAL_ONLY);
                         if (!block_gz->is_comptime) {
                             ZirInstData rdata;
                             rdata.un_node.operand
                                 = block_inst + ZIR_REF_START_INDEX;
                             rdata.un_node.src_node
                                 = (int32_t)node - (int32_t)gz->decl_node_index;
                             addInstruction(gz,
                                 ZIR_INST_RESTORE_ERR_RET_INDEX_UNCONDITIONAL,
                                 rdata);
                         }
                         addBreak(gz, break_tag, block_inst, ZIR_REF_VOID_VALUE,
                             AST_NODE_OFFSET_NONE);
                     } else {
                         // Value break (AstGen.zig:2208-2228).
                         uint32_t operand = exprRl(
                             gz, scope, block_gz->break_result_info, opt_rhs);
                         genDefers(gz, s, scope, DEFER_NORMAL_ONLY);
                         if (!block_gz->is_comptime)
                             restoreErrRetIndex(gz, block_inst,
                                 block_gz->break_result_info, opt_rhs, operand);
                         switch (block_gz->break_result_info.tag) {
                         case RL_PTR:
                         case RL_DISCARD:
                             addBreak(gz, break_tag, block_inst,
                                 ZIR_REF_VOID_VALUE, AST_NODE_OFFSET_NONE);
                             break;
                         default:
                             addBreak(gz, break_tag, block_inst, operand,
                                 (int32_t)opt_rhs
                                     - (int32_t)gz->decl_node_index);
                             break;
                         }
                     }
                     return ZIR_REF_UNREACHABLE_VALUE;
                 }
                 s = block_gz->parent;
             } else if (s->tag == SCOPE_LOCAL_VAL) {
                 s = ((ScopeLocalVal*)s)->parent;
             } else if (s->tag == SCOPE_LOCAL_PTR) {
                 s = ((ScopeLocalPtr*)s)->parent;
             } else if (s->tag == SCOPE_DEFER_NORMAL
                 || s->tag == SCOPE_DEFER_ERROR) {
                 s = ((ScopeDefer*)s)->parent;
             } else if (s->tag == SCOPE_LABEL) {
                 s = ((ScopeLabel*)s)->parent;
             } else {
                 break;
             }
         }
         SET_ERROR(ag);
         return ZIR_REF_UNREACHABLE_VALUE;
     }
     // continue (AstGen.zig:2246-2340).
     case AST_NODE_CONTINUE: {
         // Walk scope chain to find GenZir with continue_block.
         for (Scope* s = scope; s != NULL;) {
             if (s->tag == SCOPE_GEN_ZIR) {
                 GenZir* gz2 = (GenZir*)s;
                 if (gz2->continue_block != UINT32_MAX) {
                     genDefers(gz, s, scope, DEFER_NORMAL_ONLY);
                     ZirInstTag break_tag = gz2->is_inline
                         ? ZIR_INST_BREAK_INLINE
                         : ZIR_INST_BREAK;
                     if (break_tag == ZIR_INST_BREAK_INLINE) {
                         // AstGen.zig:2328-2330.
                         addUnNode(gz, ZIR_INST_CHECK_COMPTIME_CONTROL_FLOW,
                             gz2->continue_block + ZIR_REF_START_INDEX, node);
                     }
                     // Restore error return index (AstGen.zig:2333-2334).
                     if (!gz2->is_comptime) {
                         ZirInstData rdata;
                         rdata.un_node.operand
                             = gz2->continue_block + ZIR_REF_START_INDEX;
                         rdata.un_node.src_node
                             = (int32_t)node - (int32_t)gz->decl_node_index;
                         addInstruction(gz,
                             ZIR_INST_RESTORE_ERR_RET_INDEX_UNCONDITIONAL,
                             rdata);
                     }
                     addBreak(gz, break_tag, gz2->continue_block,
                         ZIR_REF_VOID_VALUE, AST_NODE_OFFSET_NONE);
                     return ZIR_REF_UNREACHABLE_VALUE;
                 }
                 s = gz2->parent;
             } else if (s->tag == SCOPE_LOCAL_VAL) {
                 s = ((ScopeLocalVal*)s)->parent;
             } else if (s->tag == SCOPE_LOCAL_PTR) {
                 s = ((ScopeLocalPtr*)s)->parent;
             } else if (s->tag == SCOPE_DEFER_NORMAL
                 || s->tag == SCOPE_DEFER_ERROR) {
                 s = ((ScopeDefer*)s)->parent;
             } else if (s->tag == SCOPE_LABEL) {
                 s = ((ScopeLabel*)s)->parent;
             } else {
                 break;
             }
         }
         SET_ERROR(ag);
         return ZIR_REF_UNREACHABLE_VALUE;
     }
     // comptime (AstGen.zig:1104-1105).
     case AST_NODE_COMPTIME: {
         // comptimeExprAst / comptimeExpr2 (AstGen.zig:2104, 1982).
         uint32_t body_node = nd.lhs;
 
         // If already comptime, just pass through (AstGen.zig:1990-1992).
         if (gz->is_comptime)
             return exprRl(gz, scope, rl, body_node);
 
         // Create comptime block (AstGen.zig:2078-2098).
         uint32_t block_inst
             = makeBlockInst(ag, ZIR_INST_BLOCK_COMPTIME, gz, node);
         GenZir block_scope = makeSubBlock(gz, scope);
         block_scope.is_comptime = true;
 
         // Transform RL to type-only (AstGen.zig:2084-2090).
         // Runtime-to-comptime boundary: can't pass runtime pointers.
         ResultLoc ty_only_rl;
         uint32_t res_ty = rlResultType(gz, rl, node);
         if (res_ty != 0)
             ty_only_rl = (ResultLoc) { .tag = RL_COERCED_TY,
                 .data = res_ty,
                 .src_node = 0,
                 .ctx = rl.ctx };
         else
             ty_only_rl = (ResultLoc) {
                 .tag = RL_NONE, .data = 0, .src_node = 0, .ctx = rl.ctx
             };
 
         uint32_t result = exprRl(&block_scope, scope, ty_only_rl, body_node);
         addBreak(&block_scope, ZIR_INST_BREAK_INLINE, block_inst, result,
             AST_NODE_OFFSET_NONE);
         setBlockComptimeBody(
             ag, &block_scope, block_inst, COMPTIME_REASON_COMPTIME_KEYWORD);
         gzAppendInstruction(gz, block_inst);
 
         // Apply rvalue to handle RL_PTR etc (AstGen.zig:2098).
         return rvalue(gz, rl, block_inst + ZIR_REF_START_INDEX, node);
     }
     // switch (AstGen.zig:1072-1078).
     case AST_NODE_SWITCH:
     case AST_NODE_SWITCH_COMMA:
         return switchExpr(gz, scope, rlBr(rl), node);
     // while (AstGen.zig:1037-1042).
     case AST_NODE_WHILE_SIMPLE:
     case AST_NODE_WHILE_CONT:
     case AST_NODE_WHILE:
         return rvalue(gz, rl, whileExpr(gz, scope, node, false), node);
     // error_value (AstGen.zig:1005-1010).
     case AST_NODE_ERROR_VALUE: {
         uint32_t error_token = nd.rhs;
         uint32_t str = identAsString(ag, error_token);
         return rvalue(gz, rl,
             addStrTok(gz, ZIR_INST_ERROR_VALUE, str, error_token), node);
     }
     // error_set_decl (AstGen.zig:5905-5955).
     case AST_NODE_ERROR_SET_DECL: {
         AstData esd = ag->tree->nodes.datas[node];
         uint32_t lbrace = esd.lhs;
         uint32_t rbrace = esd.rhs;
         // Reserve 1 extra word for ErrorSetDecl.fields_len.
         ensureExtraCapacity(ag, 1 + (rbrace - lbrace));
         uint32_t payload_index = ag->extra_len;
         ag->extra_len++; // placeholder for fields_len
         uint32_t fields_len = 0;
         for (uint32_t tok = lbrace + 1; tok < rbrace; tok++) {
             TokenizerTag ttag = ag->tree->tokens.tags[tok];
             if (ttag == TOKEN_DOC_COMMENT || ttag == TOKEN_COMMA)
                 continue;
             if (ttag == TOKEN_IDENTIFIER) {
                 uint32_t str_index = identAsString(ag, tok);
                 ensureExtraCapacity(ag, 1);
                 ag->extra[ag->extra_len++] = str_index;
                 fields_len++;
             }
         }
         ag->extra[payload_index] = fields_len;
         return rvalue(gz, rl,
             addPlNodePayloadIndex(
                 gz, ZIR_INST_ERROR_SET_DECL, node, payload_index),
             node);
     }
     // assign in expr context (AstGen.zig:1011-1014).
     case AST_NODE_ASSIGN:
         assignStmt(gz, scope, node);
         return rvalue(gz, rl, ZIR_REF_VOID_VALUE, node);
     // Compound assignment operators (AstGen.zig:685-744).
     case AST_NODE_ASSIGN_ADD:
         assignOp(gz, scope, node, ZIR_INST_ADD);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_SUB:
         assignOp(gz, scope, node, ZIR_INST_SUB);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_MUL:
         assignOp(gz, scope, node, ZIR_INST_MUL);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_DIV:
         assignOp(gz, scope, node, ZIR_INST_DIV);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_MOD:
         assignOp(gz, scope, node, ZIR_INST_MOD_REM);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_BIT_AND:
         assignOp(gz, scope, node, ZIR_INST_BIT_AND);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_BIT_OR:
         assignOp(gz, scope, node, ZIR_INST_BIT_OR);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_BIT_XOR:
         assignOp(gz, scope, node, ZIR_INST_XOR);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_ADD_WRAP:
         assignOp(gz, scope, node, ZIR_INST_ADDWRAP);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_SUB_WRAP:
         assignOp(gz, scope, node, ZIR_INST_SUBWRAP);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_MUL_WRAP:
         assignOp(gz, scope, node, ZIR_INST_MULWRAP);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_ADD_SAT:
         assignOp(gz, scope, node, ZIR_INST_ADD_SAT);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_SUB_SAT:
         assignOp(gz, scope, node, ZIR_INST_SUB_SAT);
         return ZIR_REF_VOID_VALUE;
     case AST_NODE_ASSIGN_MUL_SAT:
         assignOp(gz, scope, node, ZIR_INST_MUL_SAT);
         return ZIR_REF_VOID_VALUE;
     default:
         SET_ERROR(ag);
         return ZIR_REF_VOID_VALUE;
     }
 }
 
 static uint32_t expr(GenZir* gz, Scope* scope, uint32_t node) {
     return exprRl(gz, scope, RL_NONE_VAL, node);
 }
 
 // --- blockExprExpr (AstGen.zig:2388-2536) ---
 // Handles block expressions (labeled and unlabeled).
 // Unlabeled blocks just execute statements and return void.
 // Labeled blocks (blk: { ... break :blk val; }) need a block instruction.
 
 static uint32_t blockExprExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     (void)rl;
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstNodeTag tag = tree->nodes.tags[node];
     AstData nd = tree->nodes.datas[node];
 
     // Extract statements.
     uint32_t stmt_buf[2];
     const uint32_t* statements = NULL;
     uint32_t stmt_count = 0;
 
     switch (tag) {
     case AST_NODE_BLOCK_TWO:
     case AST_NODE_BLOCK_TWO_SEMICOLON: {
         uint32_t idx = 0;
         if (nd.lhs != 0)
             stmt_buf[idx++] = nd.lhs;
         if (nd.rhs != 0)
             stmt_buf[idx++] = nd.rhs;
         statements = stmt_buf;
         stmt_count = idx;
         break;
     }
     case AST_NODE_BLOCK:
     case AST_NODE_BLOCK_SEMICOLON: {
         uint32_t start = nd.lhs;
         uint32_t end = nd.rhs;
         statements = tree->extra_data.arr + start;
         stmt_count = end - start;
         break;
     }
     default:
         SET_ERROR(ag);
         return ZIR_REF_VOID_VALUE;
     }
 
     // Check if labeled (AstGen.zig:2397-2402).
     // A labeled block has: identifier colon before the lbrace.
     uint32_t lbrace = tree->nodes.main_tokens[node];
     bool is_labeled
         = (lbrace >= 2 && tree->tokens.tags[lbrace - 1] == TOKEN_COLON
             && tree->tokens.tags[lbrace - 2] == TOKEN_IDENTIFIER);
 
     if (!is_labeled) {
         if (!gz->is_comptime) {
             // Non-comptime unlabeled block (AstGen.zig:2404-2425).
             // Create block_inst FIRST, add to gz, then process body.
             uint32_t block_inst = makeBlockInst(ag, ZIR_INST_BLOCK, gz, node);
             gzAppendInstruction(gz, block_inst);
 
             GenZir block_scope = makeSubBlock(gz, scope);
             blockExprStmts(
                 &block_scope, &block_scope.base, statements, stmt_count);
 
             if (!endsWithNoReturn(&block_scope)) {
                 // restore_err_ret_index on gz (AstGen.zig:2420).
                 ZirInstData rdata;
                 rdata.un_node.operand = block_inst + ZIR_REF_START_INDEX;
                 rdata.un_node.src_node
                     = (int32_t)node - (int32_t)gz->decl_node_index;
                 addInstruction(
                     gz, ZIR_INST_RESTORE_ERR_RET_INDEX_UNCONDITIONAL, rdata);
                 // break on block_scope (AstGen.zig:2422).
                 addBreak(&block_scope, ZIR_INST_BREAK, block_inst,
                     ZIR_REF_VOID_VALUE, AST_NODE_OFFSET_NONE);
             }
             setBlockBody(ag, &block_scope, block_inst);
         } else {
             // Comptime unlabeled block: inline statements
             // (AstGen.zig:2426-2429).
             GenZir sub_gz = makeSubBlock(gz, scope);
             blockExprStmts(&sub_gz, &sub_gz.base, statements, stmt_count);
         }
         return ZIR_REF_VOID_VALUE;
     }
 
     // Labeled block (AstGen.zig:2466-2536).
     // Note: upstream blockExpr always passes force_comptime=false.
     uint32_t label_token = lbrace - 2;
 
     // Compute break result info (AstGen.zig:2484-2492).
     bool need_rl = nodesNeedRlContains(ag, node);
     ResultLoc break_ri = breakResultInfo(gz, rl, node, need_rl);
     bool need_result_rvalue = (break_ri.tag != rl.tag);
 
     // Reserve the block instruction (AstGen.zig:2500-2501).
     uint32_t block_inst = makeBlockInst(ag, ZIR_INST_BLOCK, gz, node);
     gzAppendInstruction(gz, block_inst);
 
     GenZir block_scope = makeSubBlock(gz, scope);
     // Set label on block_scope (AstGen.zig:2504-2508).
     block_scope.label_token = label_token;
     block_scope.label_block_inst = block_inst;
     block_scope.break_result_info = break_ri;
 
     // Process statements (AstGen.zig:2512).
     blockExprStmts(&block_scope, &block_scope.base, statements, stmt_count);
 
     if (!endsWithNoReturn(&block_scope)) {
         // Emit restore_err_ret_index (AstGen.zig:2515).
         ZirInstData rdata;
         rdata.un_node.operand = block_inst + ZIR_REF_START_INDEX;
         rdata.un_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
         addInstruction(
             gz, ZIR_INST_RESTORE_ERR_RET_INDEX_UNCONDITIONAL, rdata);
         // rvalue + break (AstGen.zig:2516-2518).
         uint32_t result = rvalue(
             gz, block_scope.break_result_info, ZIR_REF_VOID_VALUE, node);
         addBreak(&block_scope, ZIR_INST_BREAK, block_inst, result,
             AST_NODE_OFFSET_NONE);
     }
 
     setBlockBody(ag, &block_scope, block_inst);
 
     // AstGen.zig:2531-2534.
     if (need_result_rvalue)
         return rvalue(gz, rl, block_inst + ZIR_REF_START_INDEX, node);
     return block_inst + ZIR_REF_START_INDEX;
 }
 
 // --- arrayInitDotExpr (AstGen.zig:1576-1595) ---
 // Handles anonymous array init: `.{a, b, c}`.
 // Emits array_init_anon instruction with MultiOp payload.
 
 static uint32_t arrayInitDotExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstNodeTag tag = tree->nodes.tags[node];
     AstData nd = tree->nodes.datas[node];
 
     // Extract elements.
     uint32_t elem_buf[2];
     const uint32_t* elements = NULL;
     uint32_t elem_count = 0;
 
     switch (tag) {
     case AST_NODE_ARRAY_INIT_DOT_TWO:
     case AST_NODE_ARRAY_INIT_DOT_TWO_COMMA: {
         uint32_t idx = 0;
         if (nd.lhs != 0)
             elem_buf[idx++] = nd.lhs;
         if (nd.rhs != 0)
             elem_buf[idx++] = nd.rhs;
         elements = elem_buf;
         elem_count = idx;
         break;
     }
     case AST_NODE_ARRAY_INIT_DOT:
     case AST_NODE_ARRAY_INIT_DOT_COMMA: {
         uint32_t start = nd.lhs;
         uint32_t end = nd.rhs;
         elements = tree->extra_data.arr + start;
         elem_count = end - start;
         break;
     }
     default:
         SET_ERROR(ag);
         return ZIR_REF_VOID_VALUE;
     }
 
     // Dispatch based on RL (AstGen.zig:1515-1572).
     switch (rl.tag) {
     case RL_NONE: {
         // arrayInitExprAnon (AstGen.zig:1576-1595).
         ensureExtraCapacity(ag, 1 + elem_count);
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = elem_count;
         uint32_t extra_start = ag->extra_len;
         ag->extra_len += elem_count;
         for (uint32_t i = 0; i < elem_count; i++) {
             uint32_t elem_ref = expr(gz, scope, elements[i]);
             ag->extra[extra_start + i] = elem_ref;
         }
         return addPlNodePayloadIndex(
             gz, ZIR_INST_ARRAY_INIT_ANON, node, payload_index);
     }
     case RL_TY:
     case RL_COERCED_TY: {
         // validate_array_init_result_ty + arrayInitExprTyped
         // (AstGen.zig:1534-1539).
         uint32_t result_ty = rl.data;
         // Emit ArrayInit { ty, init_count } payload for
         // validate_array_init_result_ty.
         ensureExtraCapacity(ag, 2);
         uint32_t val_payload = ag->extra_len;
         ag->extra[ag->extra_len++] = result_ty;
         ag->extra[ag->extra_len++] = elem_count;
         addPlNodePayloadIndex(
             gz, ZIR_INST_VALIDATE_ARRAY_INIT_RESULT_TY, node, val_payload);
 
         // arrayInitExprTyped (AstGen.zig:1598-1642) with elem_ty=none.
         uint32_t operands_len = elem_count + 1; // +1 for type
         ensureExtraCapacity(ag, 1 + operands_len);
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = operands_len;
         ag->extra[ag->extra_len++] = result_ty;
         uint32_t extra_start = ag->extra_len;
         ag->extra_len += elem_count;
         for (uint32_t i = 0; i < elem_count; i++) {
             // array_init_elem_type uses bin data (AstGen.zig:1626-1632).
             uint32_t elem_ty
                 = addBin(gz, ZIR_INST_ARRAY_INIT_ELEM_TYPE, result_ty, i);
             ResultLoc elem_rl
                 = { .tag = RL_COERCED_TY, .data = elem_ty, .src_node = 0 };
             uint32_t elem_ref = exprRl(gz, scope, elem_rl, elements[i]);
             ag->extra[extra_start + i] = elem_ref;
         }
         return addPlNodePayloadIndex(
             gz, ZIR_INST_ARRAY_INIT, node, payload_index);
     }
     case RL_INFERRED_PTR: {
         // arrayInitExprAnon + rvalue (AstGen.zig:1545-1551).
         ensureExtraCapacity(ag, 1 + elem_count);
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = elem_count;
         uint32_t extra_start = ag->extra_len;
         ag->extra_len += elem_count;
         for (uint32_t i = 0; i < elem_count; i++) {
             uint32_t elem_ref = expr(gz, scope, elements[i]);
             ag->extra[extra_start + i] = elem_ref;
         }
         uint32_t result = addPlNodePayloadIndex(
             gz, ZIR_INST_ARRAY_INIT_ANON, node, payload_index);
         return rvalue(gz, rl, result, node);
     }
     case RL_DISCARD: {
         // Evaluate and discard each element (AstGen.zig:1517-1522).
         for (uint32_t i = 0; i < elem_count; i++) {
             exprRl(gz, scope, RL_DISCARD_VAL, elements[i]);
         }
         return ZIR_REF_VOID_VALUE;
     }
     case RL_REF: {
         // arrayInitExprAnon + ref (AstGen.zig:1523-1526).
         ensureExtraCapacity(ag, 1 + elem_count);
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = elem_count;
         uint32_t extra_start = ag->extra_len;
         ag->extra_len += elem_count;
         for (uint32_t i = 0; i < elem_count; i++) {
             uint32_t elem_ref = expr(gz, scope, elements[i]);
             ag->extra[extra_start + i] = elem_ref;
         }
         uint32_t result = addPlNodePayloadIndex(
             gz, ZIR_INST_ARRAY_INIT_ANON, node, payload_index);
         return rvalue(gz, rl, result, node);
     }
     case RL_REF_COERCED_TY: {
         // validate_array_init_ref_ty + arrayInitExprTyped
         // (AstGen.zig:1527-1532).
         uint32_t ptr_ty_inst = rl.data;
         ensureExtraCapacity(ag, 2);
         uint32_t val_payload = ag->extra_len;
         ag->extra[ag->extra_len++] = ptr_ty_inst;
         ag->extra[ag->extra_len++] = elem_count;
         uint32_t dest_arr_ty_inst = addPlNodePayloadIndex(
             gz, ZIR_INST_VALIDATE_ARRAY_INIT_REF_TY, node, val_payload);
 
         // arrayInitExprTyped with elem_ty=none, is_ref=true.
         uint32_t operands_len = elem_count + 1;
         ensureExtraCapacity(ag, 1 + operands_len);
         uint32_t ai_payload = ag->extra_len;
         ag->extra[ag->extra_len++] = operands_len;
         ag->extra[ag->extra_len++] = dest_arr_ty_inst;
         uint32_t extra_start2 = ag->extra_len;
         ag->extra_len += elem_count;
         for (uint32_t i = 0; i < elem_count; i++) {
             // array_init_elem_type uses bin data (AstGen.zig:1626-1632).
             uint32_t elem_ty = addBin(
                 gz, ZIR_INST_ARRAY_INIT_ELEM_TYPE, dest_arr_ty_inst, i);
             ResultLoc elem_rl
                 = { .tag = RL_COERCED_TY, .data = elem_ty, .src_node = 0 };
             uint32_t elem_ref = exprRl(gz, scope, elem_rl, elements[i]);
             ag->extra[extra_start2 + i] = elem_ref;
         }
         return addPlNodePayloadIndex(
             gz, ZIR_INST_ARRAY_INIT_REF, node, ai_payload);
     }
     case RL_PTR: {
         // arrayInitExprPtr (AstGen.zig:1541-1543, 1645-1672).
         uint32_t array_ptr_inst
             = addUnNode(gz, ZIR_INST_OPT_EU_BASE_PTR_INIT, rl.data, node);
         // Block payload: body_len = elem_count.
         ensureExtraCapacity(ag, 1 + elem_count);
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = elem_count;
         uint32_t items_start = ag->extra_len;
         ag->extra_len += elem_count;
 
         for (uint32_t i = 0; i < elem_count; i++) {
             // array_init_elem_ptr: ElemPtrImm{ptr, index}.
             uint32_t elem_ptr_inst = addPlNodeBin(gz,
                 ZIR_INST_ARRAY_INIT_ELEM_PTR, elements[i], array_ptr_inst, i);
             ag->extra[items_start + i]
                 = elem_ptr_inst - ZIR_REF_START_INDEX; // .toIndex()
             // Evaluate element with ptr RL (AstGen.zig:1668).
             ResultLoc ptr_rl = { .tag = RL_PTR,
                 .data = elem_ptr_inst,
                 .src_node = 0,
                 .ctx = rl.ctx };
             exprRl(gz, scope, ptr_rl, elements[i]);
         }
         addPlNodePayloadIndex(
             gz, ZIR_INST_VALIDATE_PTR_ARRAY_INIT, node, payload_index);
         return ZIR_REF_VOID_VALUE;
     }
     }
 
     // Fallback: anon init + rvalue.
     ensureExtraCapacity(ag, 1 + elem_count);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = elem_count;
     uint32_t extra_start = ag->extra_len;
     ag->extra_len += elem_count;
     for (uint32_t i = 0; i < elem_count; i++) {
         uint32_t elem_ref = expr(gz, scope, elements[i]);
         ag->extra[extra_start + i] = elem_ref;
     }
     uint32_t result = addPlNodePayloadIndex(
         gz, ZIR_INST_ARRAY_INIT_ANON, node, payload_index);
     return rvalue(gz, rl, result, node);
 }
 
 // --- ifExpr (AstGen.zig:6300-6528) ---
 // Handles if and if_simple expressions.
 // Pattern: block_scope with condbr → then/else branches → setCondBrPayload.
 
 static uint32_t ifExpr(GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     bool need_rl = nodesNeedRlContains(ag, node);
     ResultLoc break_rl = breakResultInfo(gz, rl, node, need_rl);
     AstNodeTag tag = tree->nodes.tags[node];
     AstData nd = tree->nodes.datas[node];
 
     uint32_t cond_node = nd.lhs;
     uint32_t then_node, else_node;
 
     if (tag == AST_NODE_IF_SIMPLE) {
         then_node = nd.rhs;
         else_node = 0;
     } else {
         // AST_NODE_IF: rhs is index into extra → If{then_expr, else_expr}
         then_node = tree->extra_data.arr[nd.rhs];
         else_node = tree->extra_data.arr[nd.rhs + 1];
     }
 
     // Detect payload capture: if (cond) |x| (AstGen.zig Ast.fullIf).
     // payload_pipe = lastToken(cond_expr) + 2; if pipe → payload_token + 1.
     uint32_t payload_token = 0; // 0 = no payload
     uint32_t last_cond_tok = lastToken(tree, cond_node);
     uint32_t pipe_tok = last_cond_tok + 2;
     if (pipe_tok < tree->tokens.len
         && tree->tokens.tags[pipe_tok] == TOKEN_PIPE) {
         payload_token = pipe_tok + 1; // identifier token
     }
 
     // Detect error token: then_expr else |e| (AstGen.zig Ast.fullIf).
     uint32_t error_token = 0;
     if (else_node != 0) {
         uint32_t else_tok = lastToken(tree, then_node) + 1; // "else" keyword
         if (else_tok + 1 < tree->tokens.len
             && tree->tokens.tags[else_tok + 1] == TOKEN_PIPE) {
             error_token = else_tok + 2;
         }
     }
 
     // Create block_scope (AstGen.zig:6326-6328).
     GenZir block_scope = makeSubBlock(gz, scope);
 
     // Emit DBG_STMT for condition (AstGen.zig:6335).
     // NOTE: upstream emits into parent_gz AFTER block_scope is created,
     // so the dbg_stmt ends up in block_scope's range (shared array).
     emitDbgNode(gz, cond_node);
 
     // Evaluate condition (AstGen.zig:6335-6363).
     uint32_t cond_inst; // the value (optional/err-union/bool)
     uint32_t bool_bit; // the boolean for condbr
     if (error_token != 0) {
         // Error union condition: if (err_union) |val| else |err|.
         // (AstGen.zig:6341).
         ResultLoc cond_rl = RL_NONE_VAL;
         cond_rl.ctx = RI_CTX_ERROR_HANDLING_EXPR;
         cond_inst
             = exprRl(&block_scope, &block_scope.base, cond_rl, cond_node);
         bool_bit = addUnNode(
             &block_scope, ZIR_INST_IS_NON_ERR, cond_inst, cond_node);
     } else if (payload_token != 0) {
         // Optional condition: if (optional) |val|.
         cond_inst = expr(&block_scope, &block_scope.base, cond_node);
         bool_bit = addUnNode(
             &block_scope, ZIR_INST_IS_NON_NULL, cond_inst, cond_node);
     } else {
         // Bool condition (AstGen.zig:6356-6362).
         cond_inst = expr(&block_scope, &block_scope.base, cond_node);
         bool_bit = cond_inst;
     }
 
     uint32_t condbr = addCondBr(&block_scope, ZIR_INST_CONDBR, node);
     uint32_t block_inst = makeBlockInst(ag, ZIR_INST_BLOCK, gz, node);
     setBlockBody(ag, &block_scope, block_inst);
     gzAppendInstruction(gz, block_inst);
 
     // Then branch (AstGen.zig:6372-6441).
     GenZir then_scope = makeSubBlock(gz, scope);
     Scope* then_sub_scope = &then_scope.base;
     ScopeLocalVal payload_val_scope;
     memset(&payload_val_scope, 0, sizeof(payload_val_scope));
 
     if (error_token != 0 && payload_token != 0) {
         // Error union with payload: unwrap payload (AstGen.zig:6379-6407).
         uint32_t payload_inst = addUnNode(&then_scope,
             ZIR_INST_ERR_UNION_PAYLOAD_UNSAFE, cond_inst, then_node);
         uint32_t ident_name = identAsString(ag, payload_token);
         payload_val_scope = (ScopeLocalVal) {
             .base = { .tag = SCOPE_LOCAL_VAL },
             .parent = &then_scope.base,
             .gen_zir = &then_scope,
             .inst = payload_inst,
             .token_src = payload_token,
             .name = ident_name,
         };
         addDbgVar(&then_scope, ZIR_INST_DBG_VAR_VAL, ident_name, payload_inst);
         then_sub_scope = &payload_val_scope.base;
     } else if (payload_token != 0) {
         // Optional with payload: unwrap optional (AstGen.zig:6408-6431).
         uint32_t payload_inst = addUnNode(&then_scope,
             ZIR_INST_OPTIONAL_PAYLOAD_UNSAFE, cond_inst, then_node);
         uint32_t ident_name = identAsString(ag, payload_token);
         payload_val_scope = (ScopeLocalVal) {
             .base = { .tag = SCOPE_LOCAL_VAL },
             .parent = &then_scope.base,
             .gen_zir = &then_scope,
             .inst = payload_inst,
             .token_src = payload_token,
             .name = ident_name,
         };
         addDbgVar(&then_scope, ZIR_INST_DBG_VAR_VAL, ident_name, payload_inst);
         then_sub_scope = &payload_val_scope.base;
     }
 
     // Use fullBodyExpr for then body (AstGen.zig:6437).
     uint32_t then_result
         = fullBodyExpr(&then_scope, then_sub_scope, break_rl, then_node);
     if (!endsWithNoReturn(&then_scope)) {
         addBreak(&then_scope, ZIR_INST_BREAK, block_inst, then_result,
             (int32_t)then_node - (int32_t)gz->decl_node_index);
     }
 
     // Else branch (AstGen.zig:6443-6489).
     GenZir else_scope = makeSubBlock(gz, scope);
 
     // save_err_ret_index (AstGen.zig:6448-6449).
     bool do_err_trace = ag->fn_ret_ty != 0 && error_token != 0;
     if (do_err_trace && nodeMayAppendToErrorTrace(tree, cond_node))
         addSaveErrRetIndex(&else_scope, ZIR_REF_NONE);
 
     if (else_node != 0) {
         Scope* else_sub_scope = &else_scope.base;
         ScopeLocalVal error_val_scope;
         memset(&error_val_scope, 0, sizeof(error_val_scope));
 
         if (error_token != 0) {
             // Error capture: else |err| (AstGen.zig:6452-6475).
             uint32_t err_inst = addUnNode(
                 &else_scope, ZIR_INST_ERR_UNION_CODE, cond_inst, cond_node);
             uint32_t err_name = identAsString(ag, error_token);
             error_val_scope = (ScopeLocalVal) {
                 .base = { .tag = SCOPE_LOCAL_VAL },
                 .parent = &else_scope.base,
                 .gen_zir = &else_scope,
                 .inst = err_inst,
                 .token_src = error_token,
                 .name = err_name,
             };
             addDbgVar(&else_scope, ZIR_INST_DBG_VAR_VAL, err_name, err_inst);
             else_sub_scope = &error_val_scope.base;
         }
 
         // Use fullBodyExpr for else body (AstGen.zig:6478).
         uint32_t else_result
             = fullBodyExpr(&else_scope, else_sub_scope, break_rl, else_node);
         if (!endsWithNoReturn(&else_scope)) {
             // Restore error return index (AstGen.zig:6480-6482).
             if (do_err_trace)
                 restoreErrRetIndex(
                     &else_scope, block_inst, break_rl, else_node, else_result);
             addBreak(&else_scope, ZIR_INST_BREAK, block_inst, else_result,
                 (int32_t)else_node - (int32_t)gz->decl_node_index);
         }
     } else {
         addBreak(&else_scope, ZIR_INST_BREAK, block_inst, ZIR_REF_VOID_VALUE,
             AST_NODE_OFFSET_NONE);
     }
 
     // Wire up condbr (AstGen.zig:6491).
     setCondBrPayload(ag, condbr, bool_bit, &then_scope, &else_scope);
 
     // AstGen.zig:6493-6497.
     bool need_result_rvalue = (break_rl.tag != rl.tag);
     if (need_result_rvalue)
         return rvalue(gz, rl, block_inst + ZIR_REF_START_INDEX, node);
     return block_inst + ZIR_REF_START_INDEX;
 }
 
 // --- forExpr (AstGen.zig:6819-7125) ---
 // Handles for_simple and for (multi-input).
 // Supports both indexable and for_range inputs.
 
 #define FOR_MAX_INPUTS 16
 
 static uint32_t forExpr(
     GenZir* gz, Scope* scope, uint32_t node, bool is_statement) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstData nd = tree->nodes.datas[node];
     AstNodeTag node_tag = tree->nodes.tags[node];
 
     // Detect inline keyword (AstGen.zig:6847).
     uint32_t main_token = tree->nodes.main_tokens[node];
     bool is_inline = (main_token > 0
         && tree->tokens.tags[main_token - 1] == TOKEN_KEYWORD_INLINE);
 
     // Extract input nodes and body/else nodes.
     // FOR_SIMPLE: lhs = input node, rhs = body (Ast.zig:1960-1968).
     // FOR: lhs = extra_data index, rhs = packed AstFor (Ast.zig:1970-1981).
     uint32_t input_nodes[FOR_MAX_INPUTS];
     uint32_t num_inputs;
     uint32_t body_node;
     if (node_tag == AST_NODE_FOR_SIMPLE) {
         input_nodes[0] = nd.lhs;
         num_inputs = 1;
         body_node = nd.rhs;
     } else {
         uint32_t extra_idx = nd.lhs;
         AstFor for_data;
         memcpy(&for_data, &nd.rhs, sizeof(AstFor));
         num_inputs = for_data.inputs;
         if (num_inputs == 0 || num_inputs > FOR_MAX_INPUTS) {
             SET_ERROR(ag);
             return ZIR_REF_VOID_VALUE;
         }
         for (uint32_t i = 0; i < num_inputs; i++)
             input_nodes[i] = tree->extra_data.arr[extra_idx + i];
         body_node = tree->extra_data.arr[extra_idx + num_inputs];
     }
 
     // Per-input arrays (AstGen.zig:6858-6862).
     uint32_t indexables[FOR_MAX_INPUTS];
     uint32_t lens[FOR_MAX_INPUTS][2]; // [ref0, ref1] per input
 
     // Allocate index counter (AstGen.zig:6865-6874).
     ZirInstTag alloc_tag
         = is_inline ? ZIR_INST_ALLOC_COMPTIME_MUT : ZIR_INST_ALLOC;
     uint32_t index_ptr = addUnNode(gz, alloc_tag, ZIR_REF_USIZE_TYPE, node);
     addPlNodeBin(gz, ZIR_INST_STORE_NODE, node, index_ptr, ZIR_REF_ZERO_USIZE);
 
     // Compute payload_token (AstGen.zig fullForComponents:2349-2350).
     // payload_token = lastToken(inputs[last]) + 3 + has_comma
     uint32_t last_cond_tok = lastToken(tree, input_nodes[num_inputs - 1]);
     bool has_comma = (last_cond_tok + 1 < tree->tokens.len
         && tree->tokens.tags[last_cond_tok + 1] == TOKEN_COMMA);
     uint32_t payload_token = last_cond_tok + 3 + (has_comma ? 1 : 0);
 
     // Process each input (AstGen.zig:6878-6925).
     uint32_t capture_token = payload_token;
     for (uint32_t i = 0; i < num_inputs; i++) {
         uint32_t input = input_nodes[i];
         // Advance capture_token past this capture's ident (+comma).
         bool capture_is_ref
             = (tree->tokens.tags[capture_token] == TOKEN_ASTERISK);
         uint32_t ident_tok = capture_token + (capture_is_ref ? 1u : 0u);
         capture_token = ident_tok + 2; // skip ident + comma/pipe
 
         emitDbgNode(gz, input);
 
         if (tree->nodes.tags[input] == AST_NODE_FOR_RANGE) {
             // Range input (AstGen.zig:6892-6916).
             AstData range_nd = tree->nodes.datas[input];
             uint32_t start_node = range_nd.lhs;
             uint32_t end_node = range_nd.rhs;
 
             // AstGen.zig:6897-6902: expr with .rl = .{ .ty = .usize_type }
             ResultLoc usize_rl
                 = { .tag = RL_TY, .data = ZIR_REF_USIZE_TYPE, .src_node = 0 };
             uint32_t start_val = exprRl(gz, scope, usize_rl, start_node);
 
             uint32_t end_val = ZIR_REF_NONE;
             if (end_node != 0) {
                 end_val = exprRl(gz, scope, usize_rl, end_node);
             }
 
             if (end_val == ZIR_REF_NONE) {
                 lens[i][0] = ZIR_REF_NONE;
                 lens[i][1] = ZIR_REF_NONE;
             } else {
                 lens[i][0] = start_val;
                 lens[i][1] = end_val;
             }
 
             // Check if start is trivially zero.
             bool start_is_zero = false;
             if (tree->nodes.tags[start_node] == AST_NODE_NUMBER_LITERAL) {
                 uint32_t tok = tree->nodes.main_tokens[start_node];
                 uint32_t ts = tree->tokens.starts[tok];
                 if (tree->source[ts] == '0'
                     && (ts + 1 >= tree->source_len
                         || tree->source[ts + 1] < '0'
                         || tree->source[ts + 1] > '9'))
                     start_is_zero = true;
             }
             indexables[i] = start_is_zero ? ZIR_REF_NONE : start_val;
         } else {
             // Regular indexable (AstGen.zig:6918-6923).
             uint32_t indexable = expr(gz, scope, input);
             indexables[i] = indexable;
             lens[i][0] = indexable;
             lens[i][1] = ZIR_REF_NONE;
         }
     }
 
     // Emit for_len as MultiOp (AstGen.zig:6933-6942).
     uint32_t len;
     {
         uint32_t operands_len = num_inputs * 2;
         ensureExtraCapacity(ag, 1 + operands_len);
         uint32_t payload_index = ag->extra_len;
         ag->extra[ag->extra_len++] = operands_len;
         for (uint32_t i = 0; i < num_inputs; i++) {
             ag->extra[ag->extra_len++] = lens[i][0];
             ag->extra[ag->extra_len++] = lens[i][1];
         }
         ZirInstData data;
         data.pl_node.src_node = (int32_t)node - (int32_t)gz->decl_node_index;
         data.pl_node.payload_index = payload_index;
         len = addInstruction(gz, ZIR_INST_FOR_LEN, data);
     }
 
     // Create loop (AstGen.zig:6944-6956).
     ZirInstTag loop_tag = is_inline ? ZIR_INST_BLOCK_INLINE : ZIR_INST_LOOP;
     uint32_t loop_inst = makeBlockInst(ag, loop_tag, gz, node);
 
     GenZir loop_scope = makeSubBlock(gz, scope);
     loop_scope.is_inline = is_inline;
 
     // Load index (AstGen.zig:6955-6956).
     // We need to finish loop_scope later once we have the deferred refs from
     // then_scope. However, the load must be removed from instructions in the
     // meantime or it appears to be part of parent_gz.
     uint32_t index = addUnNode(&loop_scope, ZIR_INST_LOAD, index_ptr, node);
     ag->scratch_inst_len--; // pop from loop_scope (AstGen.zig:6956)
 
     // Condition: added to cond_scope (AstGen.zig:6958-6962).
     GenZir cond_scope = makeSubBlock(gz, &loop_scope.base);
     uint32_t cond
         = addPlNodeBin(&cond_scope, ZIR_INST_CMP_LT, node, index, len);
 
     // Create condbr + block (AstGen.zig:6967-6974).
     ZirInstTag condbr_tag
         = is_inline ? ZIR_INST_CONDBR_INLINE : ZIR_INST_CONDBR;
     uint32_t condbr = addCondBr(&cond_scope, condbr_tag, node);
     ZirInstTag block_tag = is_inline ? ZIR_INST_BLOCK_INLINE : ZIR_INST_BLOCK;
     uint32_t cond_block = makeBlockInst(ag, block_tag, &loop_scope, node);
     setBlockBody(ag, &cond_scope, cond_block);
 
     loop_scope.break_block = loop_inst;
     loop_scope.continue_block = cond_block; // AstGen.zig:6974
 
     // Then branch: loop body (AstGen.zig:6982-7065).
     GenZir then_scope = makeSubBlock(gz, &cond_scope.base);
 
     // Set up capture scopes for all inputs (AstGen.zig:6986-7045).
     ScopeLocalVal capture_scopes[FOR_MAX_INPUTS];
     Scope* body_scope_parent = &then_scope.base;
     {
         capture_token = payload_token;
         for (uint32_t i = 0; i < num_inputs; i++) {
             uint32_t input = input_nodes[i];
             bool capture_is_ref
                 = (tree->tokens.tags[capture_token] == TOKEN_ASTERISK);
             uint32_t ident_tok = capture_token + (capture_is_ref ? 1u : 0u);
             capture_token = ident_tok + 2;
 
             // Check if discard (AstGen.zig:6999).
             uint32_t ts = tree->tokens.starts[ident_tok];
             bool is_discard = (tree->source[ts] == '_'
                 && (ts + 1 >= tree->source_len
                     || !((tree->source[ts + 1] >= 'a'
                              && tree->source[ts + 1] <= 'z')
                         || (tree->source[ts + 1] >= 'A'
                             && tree->source[ts + 1] <= 'Z')
                         || tree->source[ts + 1] == '_'
                         || (tree->source[ts + 1] >= '0'
                             && tree->source[ts + 1] <= '9'))));
             if (is_discard)
                 continue;
 
             // Compute capture inst (AstGen.zig:7004-7028).
             uint32_t capture_inst;
             bool is_counter = (tree->nodes.tags[input] == AST_NODE_FOR_RANGE);
 
             if (indexables[i] == ZIR_REF_NONE) {
                 // Start=0 counter: use index directly.
                 capture_inst = index;
             } else if (is_counter) {
                 // Counter with nonzero start: add.
                 capture_inst = addPlNodeBin(
                     &then_scope, ZIR_INST_ADD, input, indexables[i], index);
             } else if (capture_is_ref) {
                 // Indexable by ref: elem_ptr.
                 capture_inst = addPlNodeBin(&then_scope, ZIR_INST_ELEM_PTR,
                     input, indexables[i], index);
             } else {
                 // Indexable by val: elem_val.
                 capture_inst = addPlNodeBin(&then_scope, ZIR_INST_ELEM_VAL,
                     input, indexables[i], index);
             }
 
             uint32_t name_str = identAsString(ag, ident_tok);
             capture_scopes[i] = (ScopeLocalVal) {
                 .base = { .tag = SCOPE_LOCAL_VAL },
                 .parent = body_scope_parent,
                 .gen_zir = &then_scope,
                 .inst = capture_inst,
                 .token_src = ident_tok,
                 .name = name_str,
             };
             // AstGen.zig:7040.
             addDbgVar(
                 &then_scope, ZIR_INST_DBG_VAR_VAL, name_str, capture_inst);
             body_scope_parent = &capture_scopes[i].base;
         }
     }
 
     // Execute body (AstGen.zig:7047-7048).
     uint32_t then_result
         = fullBodyExpr(&then_scope, body_scope_parent, RL_NONE_VAL, body_node);
     addEnsureResult(&then_scope, then_result, body_node);
 
     // dbg_stmt + dbg_empty_stmt (AstGen.zig:7052-7061).
     advanceSourceCursor(ag, tree->tokens.starts[lastToken(tree, body_node)]);
     emitDbgStmt(gz, ag->source_line - gz->decl_line, ag->source_column);
     {
         ZirInstData ext_data;
         ext_data.extended.opcode = (uint16_t)ZIR_EXT_DBG_EMPTY_STMT;
         ext_data.extended.small = 0;
         ext_data.extended.operand = 0;
         addInstruction(gz, ZIR_INST_EXTENDED, ext_data);
     }
 
     ZirInstTag break_tag = is_inline ? ZIR_INST_BREAK_INLINE : ZIR_INST_BREAK;
     addBreak(&then_scope, break_tag, cond_block, ZIR_REF_VOID_VALUE,
         AST_NODE_OFFSET_NONE);
 
     // Else branch: break out of loop (AstGen.zig:7066-7091).
     GenZir else_scope = makeSubBlock(gz, &cond_scope.base);
     addBreak(&else_scope, break_tag, loop_inst, ZIR_REF_VOID_VALUE,
         AST_NODE_OFFSET_NONE);
 
     setCondBrPayload(ag, condbr, cond, &then_scope, &else_scope);
 
     // then_scope and else_scope unstacked now. Resurrect loop_scope to
     // finally finish it (AstGen.zig:7095-7113).
     {
         // Reset loop_scope instructions and re-add index + cond_block.
         loop_scope.instructions_top = ag->scratch_inst_len;
         gzAppendInstruction(&loop_scope, index - ZIR_REF_START_INDEX);
         gzAppendInstruction(&loop_scope, cond_block);
 
         // Increment the index variable (AstGen.zig:7100-7108).
         uint32_t index_plus_one = addPlNodeBin(
             &loop_scope, ZIR_INST_ADD_UNSAFE, node, index, ZIR_REF_ONE_USIZE);
         addPlNodeBin(
             &loop_scope, ZIR_INST_STORE_NODE, node, index_ptr, index_plus_one);
 
         // Repeat (AstGen.zig:7110-7111).
         ZirInstTag repeat_tag
             = is_inline ? ZIR_INST_REPEAT_INLINE : ZIR_INST_REPEAT;
         ZirInstData repeat_data;
         memset(&repeat_data, 0, sizeof(repeat_data));
         repeat_data.node = (int32_t)node - (int32_t)loop_scope.decl_node_index;
         addInstruction(&loop_scope, repeat_tag, repeat_data);
 
         setBlockBody(ag, &loop_scope, loop_inst);
     }
     gzAppendInstruction(gz, loop_inst);
 
     uint32_t result = loop_inst + ZIR_REF_START_INDEX;
 
     // Emit ensure_result_used when used as statement (AstGen.zig:7121-7123).
     if (is_statement) {
         addUnNode(gz, ZIR_INST_ENSURE_RESULT_USED, result, node);
     }
 
     return result;
 }
 
 // --- orelseCatchExpr (AstGen.zig:6031-6142) ---
 // Handles `lhs orelse rhs` and `lhs catch rhs`.
 
 static uint32_t orelseCatchExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node, bool is_catch) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstData nd = tree->nodes.datas[node];
 
     bool do_err_trace = is_catch && ag->fn_ret_ty != 0;
 
     // breakResultInfo (AstGen.zig:6046-6058).
     bool need_rl = nodesNeedRlContains(ag, node);
     ResultLoc break_rl = breakResultInfo(gz, rl, node, need_rl);
     bool need_result_rvalue = (break_rl.tag != rl.tag);
 
     // Create block_scope (AstGen.zig:6062-6063).
     GenZir block_scope = makeSubBlock(gz, scope);
 
     // Evaluate operand in block_scope (AstGen.zig:6066-6074).
     ResultLoc operand_rl = RL_NONE_VAL;
     if (do_err_trace) {
         operand_rl.ctx = RI_CTX_ERROR_HANDLING_EXPR;
     }
     uint32_t operand
         = exprRl(&block_scope, &block_scope.base, operand_rl, nd.lhs);
 
     // Check condition in block_scope (AstGen.zig:6075).
     ZirInstTag test_tag
         = is_catch ? ZIR_INST_IS_NON_ERR : ZIR_INST_IS_NON_NULL;
     uint32_t condition = addUnNode(&block_scope, test_tag, operand, node);
 
     // condbr in block_scope (AstGen.zig:6076).
     uint32_t condbr = addCondBr(&block_scope, ZIR_INST_CONDBR, node);
 
     // Create block in parent gz (AstGen.zig:6078-6081).
     uint32_t block_inst = makeBlockInst(ag, ZIR_INST_BLOCK, gz, node);
     setBlockBody(ag, &block_scope, block_inst);
     // block_scope unstacked now.
     gzAppendInstruction(gz, block_inst);
 
     // Then branch: unwrap payload (AstGen.zig:6083-6092).
     GenZir then_scope = makeSubBlock(&block_scope, scope);
     ZirInstTag unwrap_tag = is_catch ? ZIR_INST_ERR_UNION_PAYLOAD_UNSAFE
                                      : ZIR_INST_OPTIONAL_PAYLOAD_UNSAFE;
     uint32_t unwrapped = addUnNode(&then_scope, unwrap_tag, operand, node);
     // Apply rvalue coercion unless rl is ref/ref_coerced_ty
     // (AstGen.zig:6088-6091).
     uint32_t then_result = (rl.tag == RL_REF || rl.tag == RL_REF_COERCED_TY)
         ? unwrapped
         : rvalue(&then_scope, break_rl, unwrapped, node);
     addBreak(&then_scope, ZIR_INST_BREAK, block_inst, then_result,
         (int32_t)node - (int32_t)gz->decl_node_index);
 
     // Else branch: evaluate RHS (AstGen.zig:6094-6131).
     GenZir else_scope = makeSubBlock(&block_scope, scope);
 
     // save_err_ret_index (AstGen.zig:6099-6100).
     if (do_err_trace && nodeMayAppendToErrorTrace(tree, nd.lhs))
         addSaveErrRetIndex(&else_scope, ZIR_REF_NONE);
 
     // Use fullBodyExpr (not expr) to inline unlabeled blocks
     // (AstGen.zig:6125).
     uint32_t else_result
         = fullBodyExpr(&else_scope, &else_scope.base, break_rl, nd.rhs);
     if (!endsWithNoReturn(&else_scope)) {
         // restoreErrRetIndex (AstGen.zig:6128-6129).
         if (do_err_trace)
             restoreErrRetIndex(
                 &else_scope, block_inst, break_rl, nd.rhs, else_result);
         addBreak(&else_scope, ZIR_INST_BREAK, block_inst, else_result,
             (int32_t)nd.rhs - (int32_t)gz->decl_node_index);
     }
 
     setCondBrPayload(ag, condbr, condition, &then_scope, &else_scope);
 
     // AstGen.zig:6137-6141.
     if (need_result_rvalue)
         return rvalue(gz, rl, block_inst + ZIR_REF_START_INDEX, node);
     return block_inst + ZIR_REF_START_INDEX;
 }
 
 // --- whileExpr (AstGen.zig:6529-6805) ---
 // Handles while_simple.
 // Structure: loop { cond_block { cond, condbr }, repeat }
 // condbr → then { continue_block { body, break continue }, break cond }
 //        → else { break loop }
 
 static uint32_t whileExpr(
     GenZir* gz, Scope* scope, uint32_t node, bool is_statement) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstData nd = tree->nodes.datas[node];
 
     // Detect inline keyword (AstGen.zig:6558).
     uint32_t main_token = tree->nodes.main_tokens[node];
     bool is_inline = (main_token > 0
         && tree->tokens.tags[main_token - 1] == TOKEN_KEYWORD_INLINE);
 
     // WHILE_SIMPLE: lhs = cond_expr, rhs = body.
     uint32_t cond_node = nd.lhs;
     uint32_t body_node = nd.rhs;
 
     // Create loop instruction (AstGen.zig:6562-6564).
     ZirInstTag loop_tag = is_inline ? ZIR_INST_BLOCK_INLINE : ZIR_INST_LOOP;
     uint32_t loop_inst = makeBlockInst(ag, loop_tag, gz, node);
     gzAppendInstruction(gz, loop_inst);
 
     GenZir loop_scope = makeSubBlock(gz, scope);
     loop_scope.is_inline = is_inline;
 
     // Evaluate condition in cond_scope (AstGen.zig:6571-6607).
     GenZir cond_scope = makeSubBlock(&loop_scope, &loop_scope.base);
     // Emit debug node for the condition expression (AstGen.zig:6579).
     emitDbgNode(&cond_scope, cond_node);
     uint32_t cond = expr(&cond_scope, &cond_scope.base, cond_node);
 
     // Create condbr + cond_block (AstGen.zig:6609-6615).
     ZirInstTag condbr_tag
         = is_inline ? ZIR_INST_CONDBR_INLINE : ZIR_INST_CONDBR;
     uint32_t condbr = addCondBr(&cond_scope, condbr_tag, node);
     ZirInstTag block_tag = is_inline ? ZIR_INST_BLOCK_INLINE : ZIR_INST_BLOCK;
     uint32_t cond_block = makeBlockInst(ag, block_tag, &loop_scope, node);
     setBlockBody(ag, &cond_scope, cond_block); // unstacks cond_scope
     gzAppendInstruction(&loop_scope, cond_block);
 
     // Create continue_block (AstGen.zig:6694).
     uint32_t continue_block = makeBlockInst(ag, block_tag, &loop_scope, node);
 
     // Add repeat to loop_scope (AstGen.zig:6696-6697).
     {
         ZirInstTag repeat_tag
             = is_inline ? ZIR_INST_REPEAT_INLINE : ZIR_INST_REPEAT;
         ZirInstData repeat_data;
         memset(&repeat_data, 0, sizeof(repeat_data));
         repeat_data.node = (int32_t)node - (int32_t)loop_scope.decl_node_index;
         addInstruction(&loop_scope, repeat_tag, repeat_data);
     }
 
     // Set loop body and configure break/continue (AstGen.zig:6699-6701).
     setBlockBody(ag, &loop_scope, loop_inst); // unstacks loop_scope
     loop_scope.break_block = loop_inst;
     loop_scope.continue_block = continue_block;
 
     // Stack then_scope (AstGen.zig:6708-6709).
     GenZir then_scope = makeSubBlock(gz, &cond_scope.base);
 
     // Add continue_block to then_scope (AstGen.zig:6716).
     gzAppendInstruction(&then_scope, continue_block);
 
     // Create continue_scope inside then_scope (AstGen.zig:6725).
     GenZir continue_scope = makeSubBlock(&then_scope, &then_scope.base);
 
     // Execute body (AstGen.zig:6727-6730).
     emitDbgNode(&continue_scope, body_node);
     fullBodyExpr(
         &continue_scope, &continue_scope.base, RL_NONE_VAL, body_node);
 
     // Break continue_block if not noreturn (AstGen.zig:6735-6747).
     if (!endsWithNoReturn(&continue_scope)) {
         // dbg_stmt + dbg_empty_stmt (AstGen.zig:6737-6745).
         advanceSourceCursor(
             ag, tree->tokens.starts[lastToken(tree, body_node)]);
         emitDbgStmt(gz, ag->source_line - gz->decl_line, ag->source_column);
         {
             ZirInstData ext_data;
             ext_data.extended.opcode = (uint16_t)ZIR_EXT_DBG_EMPTY_STMT;
             ext_data.extended.small = 0;
             ext_data.extended.operand = 0;
             addInstruction(gz, ZIR_INST_EXTENDED, ext_data);
         }
         ZirInstTag break_tag
             = is_inline ? ZIR_INST_BREAK_INLINE : ZIR_INST_BREAK;
         addBreak(&continue_scope, break_tag, continue_block,
             ZIR_REF_VOID_VALUE, AST_NODE_OFFSET_NONE);
     }
     setBlockBody(ag, &continue_scope, continue_block);
 
     // Break cond_block from then_scope (AstGen.zig:7064).
     {
         ZirInstTag break_tag
             = is_inline ? ZIR_INST_BREAK_INLINE : ZIR_INST_BREAK;
         addBreak(&then_scope, break_tag, cond_block, ZIR_REF_VOID_VALUE,
             AST_NODE_OFFSET_NONE);
     }
 
     // Else scope: break loop with void (AstGen.zig:6785-6788).
     GenZir else_scope = makeSubBlock(gz, &cond_scope.base);
     {
         ZirInstTag break_tag
             = is_inline ? ZIR_INST_BREAK_INLINE : ZIR_INST_BREAK;
         addBreak(&else_scope, break_tag, loop_inst, ZIR_REF_VOID_VALUE,
             AST_NODE_OFFSET_NONE);
     }
 
     // Wire up condbr (AstGen.zig:6795).
     setCondBrPayload(ag, condbr, cond, &then_scope, &else_scope);
 
     uint32_t result = loop_inst + ZIR_REF_START_INDEX;
 
     // Emit ensure_result_used when used as statement (AstGen.zig:6812-6813).
     if (is_statement) {
         addUnNode(gz, ZIR_INST_ENSURE_RESULT_USED, result, node);
     }
 
     return result;
 }
 
 // --- switchExpr (AstGen.zig:7625-8117) ---
 // Handles switch and switch_comma expressions.
 // Encoding: switch_block pl_node with SwitchBlock extra payload.
 
 static uint32_t switchExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     bool need_rl = nodesNeedRlContains(ag, node);
     ResultLoc break_rl = breakResultInfo(gz, rl, node, need_rl);
     AstData nd = tree->nodes.datas[node];
 
     // AST_NODE_SWITCH: lhs = condition node, rhs = extra index for SubRange.
     // SubRange[rhs] = { cases_start, cases_end }.
     // Case nodes are at extra_data[cases_start..cases_end].
     uint32_t cond_node = nd.lhs;
     uint32_t extra_idx = nd.rhs;
     uint32_t cases_start = tree->extra_data.arr[extra_idx];
     uint32_t cases_end = tree->extra_data.arr[extra_idx + 1];
     const uint32_t* case_nodes_arr = tree->extra_data.arr + cases_start;
     uint32_t case_count = cases_end - cases_start;
 
     // Save operand source location before evaluating (AstGen.zig:7774-7775).
     advanceSourceCursorToNode(ag, cond_node);
     uint32_t operand_lc_line = ag->source_line - gz->decl_line;
     uint32_t operand_lc_col = ag->source_column;
 
     // Evaluate switch operand (AstGen.zig:7777).
     uint32_t cond_ref = expr(gz, scope, cond_node);
 
     // --- First pass: categorize cases (AstGen.zig:7671-7762) ---
     uint32_t scalar_cases_len = 0;
     uint32_t multi_cases_len = 0;
     bool has_else = false;
 
     for (uint32_t ci = 0; ci < case_count; ci++) {
         uint32_t cn = case_nodes_arr[ci];
         AstNodeTag ct = tree->nodes.tags[cn];
         AstData cd = tree->nodes.datas[cn];
 
         switch (ct) {
         case AST_NODE_SWITCH_CASE_ONE:
         case AST_NODE_SWITCH_CASE_INLINE_ONE:
             if (cd.lhs == 0)
                 has_else = true;
             else if (tree->nodes.tags[cd.lhs] == AST_NODE_SWITCH_RANGE)
                 multi_cases_len++;
             else
                 scalar_cases_len++;
             break;
         case AST_NODE_SWITCH_CASE:
         case AST_NODE_SWITCH_CASE_INLINE:
             multi_cases_len++;
             break;
         default:
             break;
         }
     }
 
     // Sema expects a dbg_stmt immediately before switch_block
     // (AstGen.zig:7806).
     emitDbgStmtForceCurrentIndex(gz, operand_lc_line, operand_lc_col);
     // --- Create switch_block instruction (AstGen.zig:7809) ---
     uint32_t switch_inst = makeBlockInst(ag, ZIR_INST_SWITCH_BLOCK, gz, node);
 
     // --- Single-pass evaluation in source order (AstGen.zig:7849-8027) ---
     // Case table + payload buffer pattern (like upstream scratch).
     // Table layout: [else?] [scalar_0..N] [multi_0..N]
     // Each entry points to the start of that case's data in the buffer.
     uint32_t table_size
         = (has_else ? 1 : 0) + scalar_cases_len + multi_cases_len;
     uint32_t else_tbl = 0;
     uint32_t scalar_tbl = (has_else ? 1 : 0);
     uint32_t multi_tbl = scalar_tbl + scalar_cases_len;
 
     uint32_t pay_cap = table_size + case_count * 16;
     uint32_t* pay = malloc(pay_cap * sizeof(uint32_t));
     uint32_t pay_len = table_size;
 
     uint32_t scalar_ci = 0;
     uint32_t multi_ci = 0;
 
     for (uint32_t ci = 0; ci < case_count; ci++) {
         uint32_t cn = case_nodes_arr[ci];
         AstNodeTag ct = tree->nodes.tags[cn];
         AstData cd = tree->nodes.datas[cn];
         uint32_t hdr = pay_len;
         uint32_t prong_info_slot = 0;
 
         // Ensure capacity for items (generous estimate).
         if (pay_len + 32 > pay_cap) {
             pay_cap *= 2;
             uint32_t* p = realloc(pay, pay_cap * sizeof(uint32_t));
             if (!p)
                 abort();
             pay = p;
         }
 
         switch (ct) {
         case AST_NODE_SWITCH_CASE_ONE:
         case AST_NODE_SWITCH_CASE_INLINE_ONE:
             if (cd.lhs == 0) {
                 // Else: [prong_info, body...]
                 pay[else_tbl] = hdr;
                 prong_info_slot = pay_len++;
             } else if (tree->nodes.tags[cd.lhs] == AST_NODE_SWITCH_RANGE) {
                 // Single range → multi case:
                 // [items_len=0, ranges_len=1, prong_info, first, last]
                 pay[multi_tbl + multi_ci++] = hdr;
                 pay[pay_len++] = 0;
                 pay[pay_len++] = 1;
                 prong_info_slot = pay_len++;
                 AstData rng = tree->nodes.datas[cd.lhs];
                 pay[pay_len++] = comptimeExpr(gz, scope, RL_NONE_VAL, rng.lhs,
                     COMPTIME_REASON_SWITCH_ITEM);
                 pay[pay_len++] = comptimeExpr(gz, scope, RL_NONE_VAL, rng.rhs,
                     COMPTIME_REASON_SWITCH_ITEM);
             } else {
                 // Scalar: [item_ref, prong_info, body...]
                 pay[scalar_tbl + scalar_ci++] = hdr;
                 pay[pay_len++] = comptimeExpr(gz, scope, RL_NONE_VAL, cd.lhs,
                     COMPTIME_REASON_SWITCH_ITEM);
                 prong_info_slot = pay_len++;
             }
             break;
         case AST_NODE_SWITCH_CASE:
         case AST_NODE_SWITCH_CASE_INLINE: {
             // Multi-item: SubRange[lhs] of items, rhs = body.
             pay[multi_tbl + multi_ci++] = hdr;
             uint32_t ist = tree->extra_data.arr[cd.lhs];
             uint32_t ien = tree->extra_data.arr[cd.lhs + 1];
             uint32_t nitems = 0, nranges = 0;
             for (uint32_t j = ist; j < ien; j++) {
                 if (tree->nodes.tags[tree->extra_data.arr[j]]
                     == AST_NODE_SWITCH_RANGE)
                     nranges++;
                 else
                     nitems++;
             }
             pay[pay_len++] = nitems;
             pay[pay_len++] = nranges;
             prong_info_slot = pay_len++;
             // Non-range items.
             for (uint32_t j = ist; j < ien; j++) {
                 uint32_t item = tree->extra_data.arr[j];
                 if (tree->nodes.tags[item] != AST_NODE_SWITCH_RANGE) {
                     if (pay_len + 2 > pay_cap) {
                         pay_cap *= 2;
                         uint32_t* p = realloc(pay, pay_cap * sizeof(uint32_t));
                         if (!p)
                             abort();
                         pay = p;
                     }
                     pay[pay_len++] = comptimeExpr(gz, scope, RL_NONE_VAL, item,
                         COMPTIME_REASON_SWITCH_ITEM);
                 }
             }
             // Range pairs.
             for (uint32_t j = ist; j < ien; j++) {
                 uint32_t item = tree->extra_data.arr[j];
                 if (tree->nodes.tags[item] == AST_NODE_SWITCH_RANGE) {
                     AstData rng = tree->nodes.datas[item];
                     if (pay_len + 2 > pay_cap) {
                         pay_cap *= 2;
                         uint32_t* p = realloc(pay, pay_cap * sizeof(uint32_t));
                         if (!p)
                             abort();
                         pay = p;
                     }
                     pay[pay_len++] = comptimeExpr(gz, scope, RL_NONE_VAL,
                         rng.lhs, COMPTIME_REASON_SWITCH_ITEM);
                     pay[pay_len++] = comptimeExpr(gz, scope, RL_NONE_VAL,
                         rng.rhs, COMPTIME_REASON_SWITCH_ITEM);
                 }
             }
             break;
         }
         default:
             continue;
         }
 
         // Evaluate body (AstGen.zig:7997-8026).
         uint32_t body_node = cd.rhs;
         GenZir case_scope = makeSubBlock(gz, scope);
 
         // Note: upstream regular switchExpr (AstGen.zig:7625) does NOT emit
         // save_err_ret_index. Only switchExprErrUnion (AstGen.zig:7524) does.
 
         // Use fullBodyExpr to process body inline (AstGen.zig:8009).
         uint32_t result
             = fullBodyExpr(&case_scope, &case_scope.base, break_rl, body_node);
         if (!refIsNoReturn(gz, result)) {
             addBreak(&case_scope, ZIR_INST_BREAK, switch_inst, result,
                 (int32_t)body_node - (int32_t)gz->decl_node_index);
         }
         uint32_t body_len = gzInstructionsLen(&case_scope);
         const uint32_t* body = gzInstructionsSlice(&case_scope);
 
         pay[prong_info_slot] = body_len & 0x0FFFFFFFu;
 
         if (pay_len + body_len > pay_cap) {
             while (pay_len + body_len > pay_cap)
                 pay_cap *= 2;
             uint32_t* p = realloc(pay, pay_cap * sizeof(uint32_t));
             if (!p)
                 abort();
             pay = p;
         }
         for (uint32_t i = 0; i < body_len; i++)
             pay[pay_len++] = body[i];
         gzUnstack(&case_scope);
     }
 
     // --- Serialize to extra in payload order (AstGen.zig:8036-8110) ---
     ensureExtraCapacity(ag,
         2 + (uint32_t)(multi_cases_len > 0 ? 1 : 0) + pay_len - table_size);
     uint32_t payload_index = ag->extra_len;
 
     ag->extra[ag->extra_len++] = cond_ref;
 
     uint32_t bits = 0;
     if (multi_cases_len > 0)
         bits |= 1u;
     if (has_else)
         bits |= (1u << 1);
     bits |= (scalar_cases_len & 0x1FFFFFFu) << 7;
     ag->extra[ag->extra_len++] = bits;
 
     if (multi_cases_len > 0)
         ag->extra[ag->extra_len++] = multi_cases_len;
 
     // Else prong.
     if (has_else) {
         uint32_t si = pay[else_tbl];
         uint32_t bl = pay[si] & 0x0FFFFFFFu;
         for (uint32_t i = 0; i < 1 + bl; i++)
             ag->extra[ag->extra_len++] = pay[si + i];
     }
     // Scalar cases.
     for (uint32_t i = 0; i < scalar_cases_len; i++) {
         uint32_t si = pay[scalar_tbl + i];
         uint32_t bl = pay[si + 1] & 0x0FFFFFFFu;
         for (uint32_t j = 0; j < 2 + bl; j++)
             ag->extra[ag->extra_len++] = pay[si + j];
     }
     // Multi cases.
     for (uint32_t i = 0; i < multi_cases_len; i++) {
         uint32_t si = pay[multi_tbl + i];
         uint32_t ni = pay[si];
         uint32_t nr = pay[si + 1];
         uint32_t bl = pay[si + 2] & 0x0FFFFFFFu;
         uint32_t total = 3 + ni + nr * 2 + bl;
         for (uint32_t j = 0; j < total; j++)
             ag->extra[ag->extra_len++] = pay[si + j];
     }
 
     free(pay);
 
     ag->inst_datas[switch_inst].pl_node.payload_index = payload_index;
     gzAppendInstruction(gz, switch_inst);
 
     // AstGen.zig:8112-8115.
     bool need_result_rvalue = (break_rl.tag != rl.tag);
     if (need_result_rvalue)
         return rvalue(gz, rl, switch_inst + ZIR_REF_START_INDEX, node);
     return switch_inst + ZIR_REF_START_INDEX;
 }
 
 // --- rvalue (AstGen.zig:11029) ---
 // Simplified: handles .none and .discard result locations.
 
 static uint32_t rvalueDiscard(GenZir* gz, uint32_t result, uint32_t src_node) {
     // .discard => emit ensure_result_non_error, return .void_value
     // (AstGen.zig:11071-11074)
     ZirInstData data;
     data.un_node.src_node = (int32_t)src_node - (int32_t)gz->decl_node_index;
     data.un_node.operand = result;
     addInstruction(gz, ZIR_INST_ENSURE_RESULT_NON_ERROR, data);
     return ZIR_REF_VOID_VALUE;
 }
 
 // --- emitDbgNode / emitDbgStmt (AstGen.zig:3422, 13713) ---
 
 static void emitDbgStmt(GenZir* gz, uint32_t line, uint32_t column) {
     if (gz->is_comptime)
         return;
     // Check if last instruction is already dbg_stmt; if so, update it.
     // (AstGen.zig:13715-13724)
     AstGenCtx* ag = gz->astgen;
     uint32_t gz_len = gzInstructionsLen(gz);
     if (gz_len > 0) {
         uint32_t last = gzInstructionsSlice(gz)[gz_len - 1];
         if (ag->inst_tags[last] == ZIR_INST_DBG_STMT) {
             ag->inst_datas[last].dbg_stmt.line = line;
             ag->inst_datas[last].dbg_stmt.column = column;
             return;
         }
     }
     ZirInstData data;
     data.dbg_stmt.line = line;
     data.dbg_stmt.column = column;
     addInstruction(gz, ZIR_INST_DBG_STMT, data);
 }
 
 // Mirrors emitDbgStmtForceCurrentIndex (AstGen.zig:13739-13760).
 static void emitDbgStmtForceCurrentIndex(
     GenZir* gz, uint32_t line, uint32_t column) {
     AstGenCtx* ag = gz->astgen;
     uint32_t gz_len = gzInstructionsLen(gz);
     if (gz_len > 0
         && gzInstructionsSlice(gz)[gz_len - 1] == ag->inst_len - 1) {
         uint32_t last = ag->inst_len - 1;
         if (ag->inst_tags[last] == ZIR_INST_DBG_STMT) {
             ag->inst_datas[last].dbg_stmt.line = line;
             ag->inst_datas[last].dbg_stmt.column = column;
             return;
         }
     }
     ZirInstData data;
     data.dbg_stmt.line = line;
     data.dbg_stmt.column = column;
     addInstruction(gz, ZIR_INST_DBG_STMT, data);
 }
 
 static void emitDbgNode(GenZir* gz, uint32_t node) {
     if (gz->is_comptime)
         return;
     AstGenCtx* ag = gz->astgen;
     advanceSourceCursorToNode(ag, node);
     uint32_t line = ag->source_line - gz->decl_line;
     uint32_t column = ag->source_column;
     emitDbgStmt(gz, line, column);
 }
 
 // --- assign (AstGen.zig:3434) ---
 // Handles `_ = expr` discard pattern.
 
 static void assignStmt(GenZir* gz, Scope* scope, uint32_t infix_node) {
     emitDbgNode(gz, infix_node);
     const AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
 
     AstData nd = tree->nodes.datas[infix_node];
     uint32_t lhs = nd.lhs;
     uint32_t rhs = nd.rhs;
 
     // Check if LHS is `_` identifier for discard (AstGen.zig:3440-3446).
     if (tree->nodes.tags[lhs] == AST_NODE_IDENTIFIER) {
         uint32_t ident_tok = tree->nodes.main_tokens[lhs];
         uint32_t tok_start = tree->tokens.starts[ident_tok];
         if (tree->source[tok_start] == '_'
             && (tok_start + 1 >= tree->source_len
                 || !((tree->source[tok_start + 1] >= 'a'
                          && tree->source[tok_start + 1] <= 'z')
                     || (tree->source[tok_start + 1] >= 'A'
                         && tree->source[tok_start + 1] <= 'Z')
                     || tree->source[tok_start + 1] == '_'
                     || (tree->source[tok_start + 1] >= '0'
                         && tree->source[tok_start + 1] <= '9')))) {
             // Discard: evaluate RHS with .discard result location.
             uint32_t result = expr(gz, scope, rhs);
             rvalueDiscard(gz, result, rhs);
             return;
         }
     }
 
     // Non-discard assignment: evaluate LHS as lvalue, pass ptr rl to RHS.
     // (AstGen.zig:3448-3452).
     {
         uint32_t lhs_ptr = exprRl(gz, scope, RL_REF_VAL, lhs);
         ResultLoc ptr_rl
             = { .tag = RL_PTR, .data = lhs_ptr, .src_node = infix_node };
         (void)exprRl(gz, scope, ptr_rl, rhs);
     }
 }
 
 // --- assignOp (AstGen.zig:3731) ---
 // Handles compound assignment operators (+=, -=, *=, etc.).
 
 static void assignOp(
     GenZir* gz, Scope* scope, uint32_t infix_node, ZirInstTag op_tag) {
     emitDbgNode(gz, infix_node);
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
 
     AstData nd = tree->nodes.datas[infix_node];
     uint32_t lhs_node = nd.lhs;
     uint32_t rhs_node = nd.rhs;
 
     // Evaluate LHS as lvalue pointer (AstGen.zig:3742).
     uint32_t lhs_ptr = exprRl(gz, scope, RL_REF_VAL, lhs_node);
 
     // Advance cursor for add/sub/mul/div/mod_rem (AstGen.zig:3744-3747).
     uint32_t cursor_line = 0, cursor_col = 0;
     bool need_dbg = false;
     if (op_tag == ZIR_INST_ADD || op_tag == ZIR_INST_SUB
         || op_tag == ZIR_INST_MUL || op_tag == ZIR_INST_DIV
         || op_tag == ZIR_INST_MOD_REM) {
         if (!gz->is_comptime) {
             advanceSourceCursorToMainToken(ag, gz, infix_node);
         }
         cursor_line = ag->source_line - gz->decl_line;
         cursor_col = ag->source_column;
         need_dbg = true;
     }
 
     // Load current value (AstGen.zig:3748).
     uint32_t lhs = addUnNode(gz, ZIR_INST_LOAD, lhs_ptr, infix_node);
 
     // Determine RHS result type (AstGen.zig:3750-3766).
     uint32_t rhs_res_ty;
     if (op_tag == ZIR_INST_ADD || op_tag == ZIR_INST_SUB) {
         // Emit inplace_arith_result_ty extended instruction.
         uint16_t inplace_op
             = (op_tag == ZIR_INST_ADD) ? 0 : 1; // add_eq=0, sub_eq=1
         ZirInstData ext_data;
         memset(&ext_data, 0, sizeof(ext_data));
         ext_data.extended.opcode = (uint16_t)ZIR_EXT_INPLACE_ARITH_RESULT_TY;
         ext_data.extended.small = inplace_op;
         ext_data.extended.operand = lhs;
         rhs_res_ty = addInstruction(gz, ZIR_INST_EXTENDED, ext_data);
     } else {
         rhs_res_ty = addUnNode(gz, ZIR_INST_TYPEOF, lhs, infix_node);
     }
 
     // Evaluate RHS with type coercion (AstGen.zig:3768).
     uint32_t rhs_raw = expr(gz, scope, rhs_node);
     uint32_t rhs
         = addPlNodeBin(gz, ZIR_INST_AS_NODE, rhs_node, rhs_res_ty, rhs_raw);
 
     // Emit debug statement for arithmetic ops (AstGen.zig:3770-3775).
     if (need_dbg) {
         emitDbgStmt(gz, cursor_line, cursor_col);
     }
 
     // Emit the operation (AstGen.zig:3776-3779).
     uint32_t result = addPlNodeBin(gz, op_tag, infix_node, lhs, rhs);
 
     // Store result back (AstGen.zig:3780-3783).
     addPlNodeBin(gz, ZIR_INST_STORE_NODE, infix_node, lhs_ptr, result);
 }
 
 // --- builtinEvalToError (BuiltinFn.zig) ---
 // Returns per-builtin eval_to_error. Default is .never; only a few are
 // .maybe or .always. Mirrors BuiltinFn.list lookup in AstGen.zig:10539.
 static int builtinEvalToError(const Ast* tree, uint32_t node) {
     uint32_t main_tok = tree->nodes.main_tokens[node];
     uint32_t tok_start = tree->tokens.starts[main_tok];
     const char* source = tree->source;
     uint32_t name_start = tok_start + 1; // skip '@'
     uint32_t name_end = name_start;
     while (name_end < tree->source_len
         && ((source[name_end] >= 'a' && source[name_end] <= 'z')
             || (source[name_end] >= 'A' && source[name_end] <= 'Z')
             || source[name_end] == '_')) {
         name_end++;
     }
     uint32_t name_len = name_end - name_start;
     const char* name = source + name_start;
     // clang-format off
     // .always:
     if (name_len == 12 && memcmp(name, "errorFromInt", 12) == 0)
         return 1; // EVAL_TO_ERROR_ALWAYS
     // .maybe:
     if (name_len == 2 && memcmp(name, "as", 2) == 0) return 2;
     if (name_len == 4 && memcmp(name, "call", 4) == 0) return 2;
     if (name_len == 5 && memcmp(name, "field", 5) == 0) return 2;
     if (name_len == 9 && memcmp(name, "errorCast", 9) == 0) return 2;
     // clang-format on
     // Default: .never
     return 0;
 }
 
 // --- nodeMayEvalToError (AstGen.zig:10340) ---
 // Three-way result: 0=never, 1=always, 2=maybe.
 #define EVAL_TO_ERROR_NEVER 0
 #define EVAL_TO_ERROR_ALWAYS 1
 #define EVAL_TO_ERROR_MAYBE 2
 
 static int nodeMayEvalToError(const Ast* tree, uint32_t node) {
     uint32_t n = node;
     while (true) {
         AstNodeTag tag = tree->nodes.tags[n];
         switch (tag) {
         case AST_NODE_ERROR_VALUE:
             return EVAL_TO_ERROR_ALWAYS;
         // These may evaluate to errors.
         case AST_NODE_IDENTIFIER:
         case AST_NODE_FIELD_ACCESS:
         case AST_NODE_DEREF:
         case AST_NODE_ARRAY_ACCESS:
         case AST_NODE_WHILE_SIMPLE:
         case AST_NODE_WHILE_CONT:
         case AST_NODE_WHILE:
         case AST_NODE_FOR_SIMPLE:
         case AST_NODE_FOR:
         case AST_NODE_IF_SIMPLE:
         case AST_NODE_IF:
         case AST_NODE_SWITCH:
         case AST_NODE_SWITCH_COMMA:
         case AST_NODE_CALL_ONE:
         case AST_NODE_CALL_ONE_COMMA:
         case AST_NODE_CALL:
         case AST_NODE_CALL_COMMA:
         case AST_NODE_ASM_SIMPLE:
         case AST_NODE_ASM_LEGACY:
         case AST_NODE_ASM:
         case AST_NODE_CATCH:
         case AST_NODE_ORELSE:
             return EVAL_TO_ERROR_MAYBE;
         // Forward to sub-expression.
         case AST_NODE_TRY:
         case AST_NODE_COMPTIME:
         case AST_NODE_NOSUSPEND:
             n = tree->nodes.datas[n].lhs;
             continue;
         case AST_NODE_GROUPED_EXPRESSION:
         case AST_NODE_UNWRAP_OPTIONAL:
             n = tree->nodes.datas[n].lhs;
             continue;
         // Labeled blocks may need a memory location.
         case AST_NODE_BLOCK_TWO:
         case AST_NODE_BLOCK_TWO_SEMICOLON:
         case AST_NODE_BLOCK:
         case AST_NODE_BLOCK_SEMICOLON: {
             uint32_t lbrace = tree->nodes.main_tokens[n];
             if (lbrace > 0 && tree->tokens.tags[lbrace - 1] == TOKEN_COLON)
                 return EVAL_TO_ERROR_MAYBE;
             return EVAL_TO_ERROR_NEVER;
         }
         // Builtins: look up per-builtin eval_to_error
         // (AstGen.zig:10530-10541).
         case AST_NODE_BUILTIN_CALL:
         case AST_NODE_BUILTIN_CALL_COMMA:
         case AST_NODE_BUILTIN_CALL_TWO:
         case AST_NODE_BUILTIN_CALL_TWO_COMMA:
             return builtinEvalToError(tree, n);
         // Everything else: .never
         default:
             return EVAL_TO_ERROR_NEVER;
         }
     }
 }
 
 // --- nodeMayAppendToErrorTrace (AstGen.zig:10315) ---
 // Returns true if the expression may append to the error return trace.
 static bool nodeMayAppendToErrorTrace(const Ast* tree, uint32_t node) {
     uint32_t n = node;
     while (true) {
         AstNodeTag tag = tree->nodes.tags[n];
         switch (tag) {
         // These don't call runtime functions.
         case AST_NODE_ERROR_VALUE:
         case AST_NODE_IDENTIFIER:
         case AST_NODE_COMPTIME:
             return false;
         // Forward to sub-expression.
         case AST_NODE_TRY:
         case AST_NODE_NOSUSPEND:
             n = tree->nodes.datas[n].lhs;
             continue;
         case AST_NODE_GROUPED_EXPRESSION:
         case AST_NODE_UNWRAP_OPTIONAL:
             n = tree->nodes.datas[n].lhs;
             continue;
         // Anything else: check if it may eval to error.
         default:
             return nodeMayEvalToError(tree, n) != EVAL_TO_ERROR_NEVER;
         }
     }
 }
 
 // --- addSaveErrRetIndex (AstGen.zig:12556) ---
 // Emits SAVE_ERR_RET_INDEX instruction.
 // operand is the init inst ref (or ZIR_REF_NONE for .always).
 static void addSaveErrRetIndex(GenZir* gz, uint32_t operand) {
     ZirInstData data;
     data.save_err_ret_index.operand = operand;
     data.save_err_ret_index._pad = 0;
     addInstruction(gz, ZIR_INST_SAVE_ERR_RET_INDEX, data);
 }
 
 // --- addRestoreErrRetIndexBlock (AstGen.zig:12607-12614) ---
 // Emits extended RESTORE_ERR_RET_INDEX with block target (if_non_error
 // condition). Payload: src_node, block_ref, operand.
 static void addRestoreErrRetIndexBlock(
     GenZir* gz, uint32_t block_inst, uint32_t operand, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     ensureExtraCapacity(ag, 3);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++]
         = (uint32_t)((int32_t)node - (int32_t)gz->decl_node_index);
     ag->extra[ag->extra_len++] = block_inst + ZIR_REF_START_INDEX;
     ag->extra[ag->extra_len++] = operand;
 
     ZirInstData ext_data;
     ext_data.extended.opcode = (uint16_t)ZIR_EXT_RESTORE_ERR_RET_INDEX;
     ext_data.extended.small = 0;
     ext_data.extended.operand = payload_index;
     addInstruction(gz, ZIR_INST_EXTENDED, ext_data);
 }
 
 // --- restoreErrRetIndex (AstGen.zig:2121-2148) ---
 // Emits restore_err_ret_index for block target based on nodeMayEvalToError.
 static void restoreErrRetIndex(GenZir* gz, uint32_t block_inst, ResultLoc rl,
     uint32_t node, uint32_t result) {
     const Ast* tree = gz->astgen->tree;
     int eval = nodeMayEvalToError(tree, node);
     if (eval == EVAL_TO_ERROR_ALWAYS)
         return; // never restore/pop
     uint32_t op;
     if (eval == EVAL_TO_ERROR_NEVER) {
         op = ZIR_REF_NONE; // always restore/pop
     } else {
         // EVAL_TO_ERROR_MAYBE
         // Simplified: without ri.ctx, treat non-ptr RL as result
         // (AstGen.zig:2131-2144).
         if (rl.tag == RL_PTR) {
             op = addUnNode(gz, ZIR_INST_LOAD, rl.data, node);
         } else if (rl.tag == RL_INFERRED_PTR) {
             op = ZIR_REF_NONE;
         } else {
             op = result;
         }
     }
     addRestoreErrRetIndexBlock(gz, block_inst, op, node);
 }
 
 // --- varDecl (AstGen.zig:3189) ---
 // Handles local const/var declarations. Returns new scope with the variable.
 // scope_out: set to new scope if variable is added; unchanged otherwise.
 
 static void varDecl(GenZir* gz, Scope* scope, uint32_t node,
     ScopeLocalVal* val_out, ScopeLocalPtr* ptr_out, Scope** scope_out) {
     AstGenCtx* ag = gz->astgen;
     emitDbgNode(gz, node); // AstGen.zig:3196
     const Ast* tree = ag->tree;
     AstData nd = tree->nodes.datas[node];
     AstNodeTag tag = tree->nodes.tags[node];
 
     uint32_t mut_token = tree->nodes.main_tokens[node];
     uint32_t name_token = mut_token + 1;
     bool is_const = (tree->source[tree->tokens.starts[mut_token]] == 'c');
 
     uint32_t ident_name = identAsString(ag, name_token);
 
     // Extract type_node and init_node based on variant.
     uint32_t type_node = 0;
     uint32_t init_node = 0;
 
     if (tag == AST_NODE_SIMPLE_VAR_DECL) {
         // lhs = type (optional), rhs = init (optional).
         type_node = nd.lhs;
         init_node = nd.rhs;
     } else if (tag == AST_NODE_LOCAL_VAR_DECL) {
         // lhs = extra_data index, rhs = init.
         // extra: {type_node, align_node, addrspace_node, section_node}
         // Simplified: just extract type_node.
         uint32_t extra_idx = nd.lhs;
         type_node = tree->extra_data.arr[extra_idx]; // type_node
         init_node = nd.rhs;
     } else if (tag == AST_NODE_ALIGNED_VAR_DECL) {
         // lhs = align expr, rhs = init.
         // No type node in this variant.
         init_node = nd.rhs;
     } else {
         // global_var_decl or unknown — bail.
         SET_ERROR(ag);
         return;
     }
 
     if (init_node == 0) {
         // Variables must be initialized (AstGen.zig:3228).
         SET_ERROR(ag);
         return;
     }
 
     if (is_const) {
         // --- CONST path (AstGen.zig:3232-3340) ---
         if (!nodesNeedRlContains(ag, node)) {
             // Rvalue path (AstGen.zig:3246-3271).
             // Evaluate type annotation and build result_info
             // (AstGen.zig:3247-3250).
             ResultLoc result_info;
             if (type_node != 0) {
                 uint32_t type_ref = typeExpr(gz, scope, type_node);
                 result_info = (ResultLoc) { .tag = RL_TY,
                     .data = type_ref,
                     .src_node = 0,
                     .ctx = RI_CTX_CONST_INIT };
             } else {
                 result_info = (ResultLoc) { .tag = RL_NONE,
                     .data = 0,
                     .src_node = 0,
                     .ctx = RI_CTX_CONST_INIT };
             }
 
             // Evaluate init expression (AstGen.zig:3251-3252).
             uint32_t init_ref = exprRl(gz, scope, result_info, init_node);
 
             if (ag->has_compile_errors)
                 return;
 
             // validate_const (AstGen.zig:3266).
             addUnNode(gz, ZIR_INST_VALIDATE_CONST, init_ref, init_node);
 
             // dbg_var_val (AstGen.zig:3269).
             addDbgVar(gz, ZIR_INST_DBG_VAR_VAL, ident_name, init_ref);
 
             // save_err_ret_index (AstGen.zig:3259-3260).
             if (nodeMayAppendToErrorTrace(tree, init_node))
                 addSaveErrRetIndex(gz, init_ref);
 
             // Create ScopeLocalVal (AstGen.zig:3276-3284).
             val_out->base.tag = SCOPE_LOCAL_VAL;
             val_out->parent = *scope_out;
             val_out->gen_zir = gz;
             val_out->inst = init_ref;
             val_out->token_src = name_token;
             val_out->name = ident_name;
             *scope_out = &val_out->base;
         } else {
             // Alloc path (AstGen.zig:3277-3340).
             // The init expression needs a result pointer (nodes_need_rl).
             bool is_comptime_init = gz->is_comptime
                 || tree->nodes.tags[init_node] == AST_NODE_COMPTIME;
 
             uint32_t var_ptr;
             bool resolve_inferred;
 
             if (type_node != 0) {
                 // Typed const: alloc (AstGen.zig:3280).
                 uint32_t type_ref = typeExpr(gz, scope, type_node);
                 var_ptr = addUnNode(gz, ZIR_INST_ALLOC, type_ref, node);
                 resolve_inferred = false;
             } else {
                 // Inferred type: alloc_inferred (AstGen.zig:3291-3296).
                 ZirInstTag alloc_tag = is_comptime_init
                     ? ZIR_INST_ALLOC_INFERRED_COMPTIME
                     : ZIR_INST_ALLOC_INFERRED;
                 ZirInstData adata;
                 adata.node = (int32_t)node - (int32_t)gz->decl_node_index;
                 var_ptr = addInstruction(gz, alloc_tag, adata);
                 resolve_inferred = true;
             }
 
             // Evaluate init with RL pointing to alloc (AstGen.zig:3313-3316).
             ResultLoc init_rl;
             if (type_node != 0) {
                 init_rl.tag = RL_PTR;
                 init_rl.data = var_ptr;
                 init_rl.src_node = 0; // upstream: .none (PtrResultLoc.src_node
                                       // defaults to null)
             } else {
                 init_rl.tag = RL_INFERRED_PTR;
                 init_rl.data = var_ptr;
                 init_rl.src_node = 0;
             }
             init_rl.ctx = RI_CTX_CONST_INIT;
             uint32_t init_ref = exprRl(gz, scope, init_rl, init_node);
 
             if (ag->has_compile_errors)
                 return;
 
             // save_err_ret_index (AstGen.zig:3320-3321).
             if (nodeMayAppendToErrorTrace(tree, init_node))
                 addSaveErrRetIndex(gz, init_ref);
 
             // resolve_inferred_alloc or make_ptr_const (AstGen.zig:3323-3326).
             uint32_t const_ptr;
             if (resolve_inferred)
                 const_ptr = addUnNode(
                     gz, ZIR_INST_RESOLVE_INFERRED_ALLOC, var_ptr, node);
             else
                 const_ptr
                     = addUnNode(gz, ZIR_INST_MAKE_PTR_CONST, var_ptr, node);
 
             // dbg_var_ptr (AstGen.zig:3328).
             addDbgVar(gz, ZIR_INST_DBG_VAR_PTR, ident_name, const_ptr);
 
             // Create ScopeLocalPtr (AstGen.zig:3330-3340).
             ptr_out->base.tag = SCOPE_LOCAL_PTR;
             ptr_out->parent = *scope_out;
             ptr_out->gen_zir = gz;
             ptr_out->ptr = const_ptr;
             ptr_out->token_src = name_token;
             ptr_out->name = ident_name;
             ptr_out->maybe_comptime = true;
             *scope_out = &ptr_out->base;
         }
     } else {
         // --- VAR path (AstGen.zig:3342-3416) ---
 
         uint32_t alloc_ref;
         bool resolve_inferred = false;
 
         if (type_node != 0) {
             // Typed var: alloc_mut (AstGen.zig:3361-3375).
             uint32_t type_ref = typeExpr(gz, scope, type_node);
             ZirInstTag alloc_tag = gz->is_comptime
                 ? ZIR_INST_ALLOC_COMPTIME_MUT
                 : ZIR_INST_ALLOC_MUT;
             alloc_ref = addUnNode(gz, alloc_tag, type_ref, node);
         } else {
             // Inferred type var: alloc_inferred_mut
             // (AstGen.zig:3384-3392).
             ZirInstTag alloc_tag = gz->is_comptime
                 ? ZIR_INST_ALLOC_INFERRED_COMPTIME_MUT
                 : ZIR_INST_ALLOC_INFERRED_MUT;
             ZirInstData adata;
             adata.node = (int32_t)node - (int32_t)gz->decl_node_index;
             alloc_ref = addInstruction(gz, alloc_tag, adata);
             resolve_inferred = true;
         }
 
         // Evaluate init with RL pointing to alloc (AstGen.zig:3395-3402).
         ResultLoc var_init_rl;
         if (type_node != 0) {
             var_init_rl.tag = RL_PTR;
             var_init_rl.data = alloc_ref;
             var_init_rl.src_node = 0; // upstream: .none (PtrResultLoc.src_node
                                       // defaults to null)
         } else {
             var_init_rl.tag = RL_INFERRED_PTR;
             var_init_rl.data = alloc_ref;
             var_init_rl.src_node = 0;
         }
         var_init_rl.ctx = RI_CTX_NONE;
         uint32_t init_ref = exprRl(gz, scope, var_init_rl, init_node);
         (void)init_ref;
 
         if (ag->has_compile_errors)
             return;
 
         // resolve_inferred_alloc if type was inferred
         // (AstGen.zig:3407-3408).
         uint32_t final_ptr = alloc_ref;
         if (resolve_inferred)
             final_ptr = addUnNode(
                 gz, ZIR_INST_RESOLVE_INFERRED_ALLOC, alloc_ref, node);
 
         // dbg_var_ptr (AstGen.zig:3411).
         addDbgVar(gz, ZIR_INST_DBG_VAR_PTR, ident_name, final_ptr);
 
         // Create ScopeLocalPtr (AstGen.zig:3413-3422).
         ptr_out->base.tag = SCOPE_LOCAL_PTR;
         ptr_out->parent = *scope_out;
         ptr_out->gen_zir = gz;
         ptr_out->ptr = final_ptr;
         ptr_out->token_src = name_token;
         ptr_out->name = ident_name;
         ptr_out->maybe_comptime = gz->is_comptime;
         *scope_out = &ptr_out->base;
     }
 }
 
 // --- addEnsureResult (AstGen.zig:2649) ---
 // After evaluating an expression as a statement, optionally emits
 // ensure_result_used. For call/field_call, sets flag in extra data instead.
 // Returns true if the result is noreturn (AstGen.zig:2909).
 static bool addEnsureResult(
     GenZir* gz, uint32_t maybe_unused_result, uint32_t statement) {
     AstGenCtx* ag = gz->astgen;
     bool elide_check;
     bool is_noreturn = false;
     if (maybe_unused_result >= ZIR_REF_START_INDEX) {
         uint32_t inst = maybe_unused_result - ZIR_REF_START_INDEX;
         ZirInstTag tag = ag->inst_tags[inst];
         switch (tag) {
         // For call/field_call: set ensure_result_used flag
         // (bit 3 of flags at offset 0). Flags *must* be at offset 0
         // (AstGen.zig:2658-2665, Zir.zig:3022).
         case ZIR_INST_CALL:
         case ZIR_INST_FIELD_CALL: {
             uint32_t pi = ag->inst_datas[inst].pl_node.payload_index;
             ag->extra[pi] |= (1u << 3); // ensure_result_used
             elide_check = true;
             break;
         }
         // For builtin_call: ensure_result_used is at bit 1, not bit 3.
         case ZIR_INST_BUILTIN_CALL: {
             uint32_t pi = ag->inst_datas[inst].pl_node.payload_index;
             ag->extra[pi] |= (1u << 1); // ensure_result_used
             elide_check = true;
             break;
         }
         // Always noreturn → elide (AstGen.zig:2909).
         case ZIR_INST_BREAK:
         case ZIR_INST_BREAK_INLINE:
         case ZIR_INST_CONDBR:
         case ZIR_INST_CONDBR_INLINE:
         case ZIR_INST_RET_NODE:
         case ZIR_INST_RET_LOAD:
         case ZIR_INST_RET_IMPLICIT:
         case ZIR_INST_RET_ERR_VALUE:
         case ZIR_INST_UNREACHABLE:
         case ZIR_INST_REPEAT:
         case ZIR_INST_REPEAT_INLINE:
         case ZIR_INST_PANIC:
         case ZIR_INST_TRAP:
         case ZIR_INST_CHECK_COMPTIME_CONTROL_FLOW:
         case ZIR_INST_SWITCH_CONTINUE:
         case ZIR_INST_COMPILE_ERROR:
             is_noreturn = true;
             elide_check = true;
             break;
         // Always void → elide.
         case ZIR_INST_DBG_STMT:
         case ZIR_INST_DBG_VAR_PTR:
         case ZIR_INST_DBG_VAR_VAL:
         case ZIR_INST_ENSURE_RESULT_USED:
         case ZIR_INST_ENSURE_RESULT_NON_ERROR:
         case ZIR_INST_ENSURE_ERR_UNION_PAYLOAD_VOID:
         case ZIR_INST_EXPORT:
         case ZIR_INST_SET_EVAL_BRANCH_QUOTA:
         case ZIR_INST_ATOMIC_STORE:
         case ZIR_INST_STORE_NODE:
         case ZIR_INST_STORE_TO_INFERRED_PTR:
         case ZIR_INST_RESOLVE_INFERRED_ALLOC:
         case ZIR_INST_SET_RUNTIME_SAFETY:
         case ZIR_INST_MEMCPY:
         case ZIR_INST_MEMSET:
         case ZIR_INST_MEMMOVE:
         case ZIR_INST_VALIDATE_DEREF:
         case ZIR_INST_VALIDATE_DESTRUCTURE:
         case ZIR_INST_SAVE_ERR_RET_INDEX:
         case ZIR_INST_RESTORE_ERR_RET_INDEX_UNCONDITIONAL:
         case ZIR_INST_RESTORE_ERR_RET_INDEX_FN_ENTRY:
         case ZIR_INST_VALIDATE_STRUCT_INIT_TY:
         case ZIR_INST_VALIDATE_STRUCT_INIT_RESULT_TY:
         case ZIR_INST_VALIDATE_PTR_STRUCT_INIT:
         case ZIR_INST_VALIDATE_ARRAY_INIT_TY:
         case ZIR_INST_VALIDATE_ARRAY_INIT_RESULT_TY:
         case ZIR_INST_VALIDATE_PTR_ARRAY_INIT:
         case ZIR_INST_VALIDATE_REF_TY:
         case ZIR_INST_VALIDATE_CONST:
             elide_check = true;
             break;
         // Extended: check opcode.
         case ZIR_INST_EXTENDED: {
             uint32_t opcode = ag->inst_datas[inst].extended.opcode;
             elide_check = (opcode == ZIR_EXT_BREAKPOINT
                 || opcode == ZIR_EXT_BRANCH_HINT
                 || opcode == ZIR_EXT_SET_FLOAT_MODE
                 || opcode == ZIR_EXT_DISABLE_INSTRUMENTATION
                 || opcode == ZIR_EXT_DISABLE_INTRINSICS);
             break;
         }
         // Everything else: might produce non-void result → emit check.
         default:
             elide_check = false;
             break;
         }
     } else {
         // Named ref constant.
         is_noreturn = (maybe_unused_result == ZIR_REF_UNREACHABLE_VALUE);
         elide_check
             = (is_noreturn || maybe_unused_result == ZIR_REF_VOID_VALUE);
     }
     if (!elide_check) {
         addUnNode(
             gz, ZIR_INST_ENSURE_RESULT_USED, maybe_unused_result, statement);
     }
     return is_noreturn;
 }
 
 // --- countDefers (AstGen.zig:2966) ---
 // Walk scope chain and count defer types.
 
 static DeferCounts countDefers(const Scope* outer_scope, Scope* inner_scope) {
     DeferCounts c = { false, false, false, false };
     Scope* s = inner_scope;
     while (s != outer_scope) {
         switch (s->tag) {
         case SCOPE_GEN_ZIR:
             s = ((GenZir*)s)->parent;
             break;
         case SCOPE_LOCAL_VAL:
             s = ((ScopeLocalVal*)s)->parent;
             break;
         case SCOPE_LOCAL_PTR:
             s = ((ScopeLocalPtr*)s)->parent;
             break;
         case SCOPE_DEFER_NORMAL: {
             ScopeDefer* d = (ScopeDefer*)s;
             s = d->parent;
             c.have_normal = true;
             break;
         }
         case SCOPE_DEFER_ERROR: {
             ScopeDefer* d = (ScopeDefer*)s;
             s = d->parent;
             c.have_err = true;
             // need_err_code if remapped_err_code exists (we don't
             // implement err capture yet, so always false).
             break;
         }
         default:
             return c;
         }
     }
     c.have_any = c.have_normal || c.have_err;
     return c;
 }
 
 // --- genDefers (AstGen.zig:3014) ---
 // Walk scope chain from inner to outer, emitting .defer instructions.
 // which: DEFER_NORMAL_ONLY or DEFER_BOTH_SANS_ERR.
 
 static void genDefers(
     GenZir* gz, const Scope* outer_scope, Scope* inner_scope, int which) {
     Scope* s = inner_scope;
     while (s != outer_scope) {
         switch (s->tag) {
         case SCOPE_GEN_ZIR: {
             GenZir* g = (GenZir*)s;
             s = g->parent;
             break;
         }
         case SCOPE_LOCAL_VAL: {
             ScopeLocalVal* lv = (ScopeLocalVal*)s;
             s = lv->parent;
             break;
         }
         case SCOPE_LOCAL_PTR: {
             ScopeLocalPtr* lp = (ScopeLocalPtr*)s;
             s = lp->parent;
             break;
         }
         case SCOPE_DEFER_NORMAL: {
             ScopeDefer* d = (ScopeDefer*)s;
             s = d->parent;
             // Emit ZIR_INST_DEFER (AstGen.zig:3031).
             ZirInstData data;
             data.defer_data.index = d->index;
             data.defer_data.len = d->len;
             addInstruction(gz, ZIR_INST_DEFER, data);
             break;
         }
         case SCOPE_DEFER_ERROR: {
             ScopeDefer* d = (ScopeDefer*)s;
             s = d->parent;
             if (which == DEFER_BOTH_SANS_ERR) {
                 // Emit regular DEFER for error defers too (AstGen.zig:3038).
                 ZirInstData data;
                 data.defer_data.index = d->index;
                 data.defer_data.len = d->len;
                 addInstruction(gz, ZIR_INST_DEFER, data);
             }
             // DEFER_NORMAL_ONLY: skip error defers (AstGen.zig:3063).
             break;
         }
         case SCOPE_LABEL: {
             // Labels store parent in the GenZir they're attached to.
             // Just skip by going to the parent scope stored in parent.
             // Actually labels don't have a separate parent pointer in our
             // representation; they're part of GenZir. This case shouldn't
             // appear when walking from blockExprStmts scope.
             return;
         }
         case SCOPE_NAMESPACE:
         case SCOPE_TOP:
         default:
             return;
         }
     }
 }
 
 // --- blockExprStmts (AstGen.zig:2538) ---
 // Processes block statements sequentially, threading scope.
 
 static void blockExprStmts(GenZir* gz, Scope* scope,
     const uint32_t* statements, uint32_t stmt_count) {
     AstGenCtx* ag = gz->astgen;
     // Stack-allocated scope storage for local variables and defers.
     // Max 64 local variable declarations and 64 defers per block.
     ScopeLocalVal val_scopes[64];
     ScopeLocalPtr ptr_scopes[64];
     ScopeDefer defer_scopes[64];
     uint32_t val_idx = 0;
     uint32_t ptr_idx = 0;
     uint32_t defer_idx = 0;
     Scope* cur_scope = scope;
     bool noreturn_stmt = false;
 
     for (uint32_t i = 0; i < stmt_count; i++) {
         if (ag->has_compile_errors)
             return;
         uint32_t stmt = statements[i];
         AstNodeTag tag = ag->tree->nodes.tags[stmt];
         switch (tag) {
         case AST_NODE_ASSIGN:
             assignStmt(gz, cur_scope, stmt);
             break;
         // Compound assignment operators (AstGen.zig:2588-2607).
         case AST_NODE_ASSIGN_ADD:
             assignOp(gz, cur_scope, stmt, ZIR_INST_ADD);
             break;
         case AST_NODE_ASSIGN_SUB:
             assignOp(gz, cur_scope, stmt, ZIR_INST_SUB);
             break;
         case AST_NODE_ASSIGN_MUL:
             assignOp(gz, cur_scope, stmt, ZIR_INST_MUL);
             break;
         case AST_NODE_ASSIGN_DIV:
             assignOp(gz, cur_scope, stmt, ZIR_INST_DIV);
             break;
         case AST_NODE_ASSIGN_MOD:
             assignOp(gz, cur_scope, stmt, ZIR_INST_MOD_REM);
             break;
         case AST_NODE_ASSIGN_BIT_AND:
             assignOp(gz, cur_scope, stmt, ZIR_INST_BIT_AND);
             break;
         case AST_NODE_ASSIGN_BIT_OR:
             assignOp(gz, cur_scope, stmt, ZIR_INST_BIT_OR);
             break;
         case AST_NODE_ASSIGN_BIT_XOR:
             assignOp(gz, cur_scope, stmt, ZIR_INST_XOR);
             break;
         case AST_NODE_ASSIGN_ADD_WRAP:
             assignOp(gz, cur_scope, stmt, ZIR_INST_ADDWRAP);
             break;
         case AST_NODE_ASSIGN_SUB_WRAP:
             assignOp(gz, cur_scope, stmt, ZIR_INST_SUBWRAP);
             break;
         case AST_NODE_ASSIGN_MUL_WRAP:
             assignOp(gz, cur_scope, stmt, ZIR_INST_MULWRAP);
             break;
         case AST_NODE_ASSIGN_ADD_SAT:
             assignOp(gz, cur_scope, stmt, ZIR_INST_ADD_SAT);
             break;
         case AST_NODE_ASSIGN_SUB_SAT:
             assignOp(gz, cur_scope, stmt, ZIR_INST_SUB_SAT);
             break;
         case AST_NODE_ASSIGN_MUL_SAT:
             assignOp(gz, cur_scope, stmt, ZIR_INST_MUL_SAT);
             break;
         case AST_NODE_SIMPLE_VAR_DECL:
         case AST_NODE_LOCAL_VAR_DECL:
         case AST_NODE_ALIGNED_VAR_DECL:
             if (val_idx < 64 && ptr_idx < 64) {
                 varDecl(gz, cur_scope, stmt, &val_scopes[val_idx],
                     &ptr_scopes[ptr_idx], &cur_scope);
                 // Check which one was used: if scope now points to
                 // val_scopes[val_idx], advance val_idx; same for ptr.
                 if (cur_scope == &val_scopes[val_idx].base)
                     val_idx++;
                 else if (cur_scope == &ptr_scopes[ptr_idx].base)
                     ptr_idx++;
             } else {
                 SET_ERROR(ag);
             }
             break;
         // defer/errdefer (AstGen.zig:2580-2581).
         case AST_NODE_DEFER:
         case AST_NODE_ERRDEFER: {
             if (defer_idx >= 64) {
                 SET_ERROR(ag);
                 break;
             }
             ScopeTag scope_tag = (tag == AST_NODE_DEFER) ? SCOPE_DEFER_NORMAL
                                                          : SCOPE_DEFER_ERROR;
             // Create sub-block for defer body (AstGen.zig:3123-3126).
             GenZir defer_gen = makeSubBlock(gz, cur_scope);
 
             // Evaluate deferred expression (AstGen.zig:3165).
             // DEFER: lhs is the deferred expression, rhs = 0.
             // ERRDEFER: lhs is optional error capture token, rhs is expr.
             AstData dnd = ag->tree->nodes.datas[stmt];
             uint32_t expr_node;
             if (tag == AST_NODE_DEFER) {
                 expr_node = dnd.lhs;
             } else {
                 expr_node = dnd.rhs;
             }
             // unusedResultExpr pattern (AstGen.zig:3165, 2641-2646).
             emitDbgNode(&defer_gen, expr_node);
             uint32_t defer_result
                 = expr(&defer_gen, &defer_gen.base, expr_node);
             addEnsureResult(&defer_gen, defer_result, expr_node);
 
             // Add break_inline at end (AstGen.zig:3167).
             addBreak(&defer_gen, ZIR_INST_BREAK_INLINE, 0, ZIR_REF_VOID_VALUE,
                 AST_NODE_OFFSET_NONE);
 
             // Write body to extra (AstGen.zig:3173-3175).
             uint32_t raw_body_len = gzInstructionsLen(&defer_gen);
             const uint32_t* body = gzInstructionsSlice(&defer_gen);
             uint32_t extra_index = ag->extra_len;
             uint32_t fixup_len
                 = countBodyLenAfterFixups(ag, body, raw_body_len);
             ensureExtraCapacity(ag, fixup_len);
             for (uint32_t b = 0; b < raw_body_len; b++)
                 appendPossiblyRefdBodyInst(ag, body[b]);
             gzUnstack(&defer_gen);
 
             // Create scope (AstGen.zig:3179-3185).
             defer_scopes[defer_idx] = (ScopeDefer) {
                 .base = { .tag = scope_tag },
                 .parent = cur_scope,
                 .index = extra_index,
                 .len = fixup_len,
             };
             cur_scope = &defer_scopes[defer_idx].base;
             defer_idx++;
             break;
         }
         // while/for as statements (AstGen.zig:2605-2610).
         // These do NOT get emitDbgNode; they emit their own dbg_stmt.
         case AST_NODE_WHILE_SIMPLE:
         case AST_NODE_WHILE_CONT:
         case AST_NODE_WHILE:
             (void)whileExpr(gz, cur_scope, stmt, true);
             break;
         case AST_NODE_FOR_SIMPLE:
         case AST_NODE_FOR:
             (void)forExpr(gz, cur_scope, stmt, true);
             break;
         default: {
             // Expression statement (AstGen.zig:2627 unusedResultExpr).
             emitDbgNode(gz, stmt);
             uint32_t result = expr(gz, cur_scope, stmt);
             noreturn_stmt = addEnsureResult(gz, result, stmt);
             break;
         }
         }
     }
     // Emit normal defers at block exit (AstGen.zig:2633-2634).
     if (!noreturn_stmt) {
         genDefers(gz, scope, cur_scope, DEFER_NORMAL_ONLY);
     }
 }
 
 // --- fullBodyExpr (AstGen.zig:2358) ---
 // Processes a body expression. If it's an unlabeled block, processes
 // statements inline without creating a BLOCK instruction (unlike blockExprExpr
 // which wraps in BLOCK). Returns the result ref.
 
 static uint32_t fullBodyExpr(
     GenZir* gz, Scope* scope, ResultLoc rl, uint32_t node) {
     const Ast* tree = gz->astgen->tree;
     AstNodeTag tag = tree->nodes.tags[node];
 
     // Extract block statements (AstGen.zig:2368).
     AstData nd = tree->nodes.datas[node];
     uint32_t stmt_buf[2];
     const uint32_t* statements = NULL;
     uint32_t stmt_count = 0;
 
     switch (tag) {
     case AST_NODE_BLOCK_TWO:
     case AST_NODE_BLOCK_TWO_SEMICOLON: {
         uint32_t idx = 0;
         if (nd.lhs != 0)
             stmt_buf[idx++] = nd.lhs;
         if (nd.rhs != 0)
             stmt_buf[idx++] = nd.rhs;
         statements = stmt_buf;
         stmt_count = idx;
         break;
     }
     case AST_NODE_BLOCK:
     case AST_NODE_BLOCK_SEMICOLON: {
         uint32_t start = nd.lhs;
         uint32_t end = nd.rhs;
         statements = tree->extra_data.arr + start;
         stmt_count = end - start;
         break;
     }
     default:
         // Not a block — treat as single expression (AstGen.zig:2369).
         return exprRl(gz, scope, rl, node);
     }
 
     // Check if labeled (AstGen.zig:2373-2377).
     uint32_t lbrace = tree->nodes.main_tokens[node];
     bool is_labeled
         = (lbrace >= 2 && tree->tokens.tags[lbrace - 1] == TOKEN_COLON
             && tree->tokens.tags[lbrace - 2] == TOKEN_IDENTIFIER);
     if (is_labeled) {
         // Labeled blocks need a proper block instruction.
         return blockExprExpr(gz, scope, rl, node);
     }
 
     // Unlabeled block: process statements inline (AstGen.zig:2380-2383).
     GenZir sub_gz = makeSubBlock(gz, scope);
     blockExprStmts(&sub_gz, &sub_gz.base, statements, stmt_count);
     return rvalue(gz, rl, ZIR_REF_VOID_VALUE, node);
 }
 
 // --- lastToken (Ast.zig:874) ---
 // Mechanical port of Ast.lastToken. Uses iterative end_offset accumulation.
 
 static uint32_t lastToken(const Ast* tree, uint32_t node) {
     uint32_t n = node;
     uint32_t end_offset = 0;
     while (1) {
         AstNodeTag tag = tree->nodes.tags[n];
         AstData nd = tree->nodes.datas[n];
         switch (tag) {
         case AST_NODE_ROOT:
             return tree->tokens.len - 1;
 
         // Binary ops: recurse into RHS (Ast.zig:893-948).
         case AST_NODE_ASSIGN:
         case AST_NODE_ADD:
         case AST_NODE_SUB:
         case AST_NODE_MUL:
         case AST_NODE_DIV:
         case AST_NODE_MOD:
         case AST_NODE_BIT_AND:
         case AST_NODE_BIT_OR:
         case AST_NODE_BIT_XOR:
         case AST_NODE_SHL:
         case AST_NODE_SHR:
         case AST_NODE_ARRAY_CAT:
         case AST_NODE_ARRAY_MULT:
         case AST_NODE_ADD_WRAP:
         case AST_NODE_SUB_WRAP:
         case AST_NODE_ADD_SAT:
         case AST_NODE_SUB_SAT:
         case AST_NODE_MUL_WRAP:
         case AST_NODE_MUL_SAT:
         case AST_NODE_MERGE_ERROR_SETS:
         case AST_NODE_EQUAL_EQUAL:
         case AST_NODE_BANG_EQUAL:
         case AST_NODE_LESS_THAN:
         case AST_NODE_GREATER_THAN:
         case AST_NODE_LESS_OR_EQUAL:
         case AST_NODE_GREATER_OR_EQUAL:
         case AST_NODE_BOOL_AND:
         case AST_NODE_BOOL_OR:
         case AST_NODE_ORELSE:
         case AST_NODE_CATCH:
         case AST_NODE_ERROR_UNION:
         case AST_NODE_SHL_SAT:
             n = nd.rhs;
             continue;
 
         // field_access: return field token + end_offset (Ast.zig:979).
         case AST_NODE_FIELD_ACCESS:
             return nd.rhs + end_offset;
 
         // test_decl: recurse into body node (Ast.zig:950).
         case AST_NODE_TEST_DECL:
             n = nd.rhs;
             continue;
 
         // defer: recurse into body (lhs) (Ast.zig:951).
         case AST_NODE_DEFER:
             n = nd.lhs;
             continue;
 
         // errdefer: recurse into body (rhs) (Ast.zig:950).
         case AST_NODE_ERRDEFER:
             n = nd.rhs;
             continue;
 
         // block (Ast.zig:1085): end_offset += 1 (rbrace), recurse into last.
         case AST_NODE_BLOCK: {
             uint32_t start = nd.lhs;
             uint32_t end = nd.rhs;
             assert(start != end);
             end_offset += 1;
             n = tree->extra_data.arr[end - 1];
             continue;
         }
 
         // block_semicolon (Ast.zig:1097): += 2 (semicolon + rbrace).
         case AST_NODE_BLOCK_SEMICOLON: {
             uint32_t start = nd.lhs;
             uint32_t end = nd.rhs;
             assert(start != end);
             end_offset += 2;
             n = tree->extra_data.arr[end - 1];
             continue;
         }
 
         // block_two (Ast.zig:1117): if rhs, recurse rhs +1; if lhs, +1; else
         // +1. Note: C parser uses 0 for "none" (OptionalIndex), not
         // UINT32_MAX.
         case AST_NODE_BLOCK_TWO: {
             if (nd.rhs != 0) {
                 end_offset += 1;
                 n = nd.rhs;
             } else if (nd.lhs != 0) {
                 end_offset += 1;
                 n = nd.lhs;
             } else {
                 end_offset += 1;
                 return tree->nodes.main_tokens[n] + end_offset;
             }
             continue;
         }
 
         // block_two_semicolon (Ast.zig:1153).
         case AST_NODE_BLOCK_TWO_SEMICOLON: {
             if (nd.rhs != 0) {
                 end_offset += 2;
                 n = nd.rhs;
             } else if (nd.lhs != 0) {
                 end_offset += 2;
                 n = nd.lhs;
             } else {
                 end_offset += 1;
                 return tree->nodes.main_tokens[n] + end_offset;
             }
             continue;
         }
 
         // builtin_call_two (Ast.zig:1118): recurse into args + rparen.
         case AST_NODE_BUILTIN_CALL_TWO: {
             if (nd.rhs != 0) {
                 end_offset += 1;
                 n = nd.rhs;
             } else if (nd.lhs != 0) {
                 end_offset += 1;
                 n = nd.lhs;
             } else {
                 end_offset += 2; // lparen + rparen
                 return tree->nodes.main_tokens[n] + end_offset;
             }
             continue;
         }
 
         case AST_NODE_BUILTIN_CALL_TWO_COMMA: {
             if (nd.rhs != 0) {
                 end_offset += 2; // comma + rparen
                 n = nd.rhs;
             } else if (nd.lhs != 0) {
                 end_offset += 2;
                 n = nd.lhs;
             } else {
                 end_offset += 1;
                 return tree->nodes.main_tokens[n] + end_offset;
             }
             continue;
         }
 
         // Unary ops: recurse into lhs (Ast.zig:895-910).
         case AST_NODE_BOOL_NOT:
         case AST_NODE_BIT_NOT:
         case AST_NODE_NEGATION:
         case AST_NODE_NEGATION_WRAP:
         case AST_NODE_ADDRESS_OF:
         case AST_NODE_TRY:
         case AST_NODE_AWAIT:
         case AST_NODE_OPTIONAL_TYPE:
         case AST_NODE_COMPTIME:
         case AST_NODE_NOSUSPEND:
         case AST_NODE_RESUME:
             n = nd.lhs;
             continue;
 
         // return: optional operand (Ast.zig:998-1002).
         case AST_NODE_RETURN:
             if (nd.lhs != 0) {
                 n = nd.lhs;
                 continue;
             }
             return tree->nodes.main_tokens[n] + end_offset;
 
         // deref: main_token is the dot, +1 for '*' (Ast.zig:974).
         case AST_NODE_DEREF:
             return tree->nodes.main_tokens[n] + 1 + end_offset;
 
         // unwrap_optional: +1 for '?' (Ast.zig:971).
         case AST_NODE_UNWRAP_OPTIONAL:
             return tree->nodes.main_tokens[n] + 1 + end_offset;
 
         // for_range: recurse into rhs if present, else lhs.
         case AST_NODE_FOR_RANGE:
             if (nd.rhs != 0) {
                 n = nd.rhs;
             } else {
                 // Unbounded range: last token is the '..' operator.
                 // main_token + 1 (the second dot of ..)
                 return tree->nodes.main_tokens[n] + 1 + end_offset;
             }
             continue;
 
         // error_value: main_token is `error`, last token is name (+2)
         // (Ast.zig:986).
         case AST_NODE_ERROR_VALUE:
             return tree->nodes.main_tokens[n] + 2 + end_offset;
 
         // Terminals: return main_token + end_offset (Ast.zig:988-996).
         case AST_NODE_NUMBER_LITERAL:
         case AST_NODE_STRING_LITERAL:
         case AST_NODE_IDENTIFIER:
         case AST_NODE_ENUM_LITERAL:
         case AST_NODE_CHAR_LITERAL:
         case AST_NODE_UNREACHABLE_LITERAL:
         case AST_NODE_ANYFRAME_LITERAL:
             return tree->nodes.main_tokens[n] + end_offset;
 
         // call_one: recurse into lhs, +1 for ')'.
         case AST_NODE_CALL_ONE:
             end_offset += 1; // rparen
             if (nd.rhs != 0) {
                 n = nd.rhs;
             } else {
                 n = nd.lhs;
             }
             continue;
         case AST_NODE_CALL_ONE_COMMA:
             end_offset += 2; // comma + rparen
             if (nd.rhs != 0) {
                 n = nd.rhs;
             } else {
                 n = nd.lhs;
             }
             continue;
 
         // array_access: end_offset += 1 (rbracket), recurse rhs.
         case AST_NODE_ARRAY_ACCESS:
             end_offset += 1;
             n = nd.rhs;
             continue;
 
         // simple_var_decl: recurse into init/type (Ast.zig:1169-1178).
         case AST_NODE_SIMPLE_VAR_DECL:
             if (nd.rhs != 0) {
                 n = nd.rhs; // init expr
             } else if (nd.lhs != 0) {
                 n = nd.lhs; // type expr
             } else {
                 end_offset += 1; // from mut token to name
                 return tree->nodes.main_tokens[n] + end_offset;
             }
             continue;
 
         // aligned_var_decl: recurse into init/align (Ast.zig:1180-1187).
         case AST_NODE_ALIGNED_VAR_DECL:
             if (nd.rhs != 0) {
                 n = nd.rhs; // init expr
             } else {
                 end_offset += 1; // rparen
                 n = nd.lhs; // align expr
             }
             continue;
 
         // local_var_decl (Ast.zig:1209-1217).
         case AST_NODE_LOCAL_VAR_DECL:
             if (nd.rhs != 0) {
                 n = nd.rhs; // init expr
             } else {
                 // extra[lhs] has align_node
                 end_offset += 1; // rparen
                 n = tree->extra_data.arr[nd.lhs]; // align_node
             }
             continue;
 
         // global_var_decl (Ast.zig:1189-1207).
         case AST_NODE_GLOBAL_VAR_DECL:
             if (nd.rhs != 0) {
                 n = nd.rhs; // init expr
             } else {
                 // extra[lhs] = {type_node, align_node, ...}
                 // complex; approximate by using main_token
                 end_offset += 1;
                 return tree->nodes.main_tokens[n] + end_offset;
             }
             continue;
 
         // slice_open: end_offset += 2 (ellipsis2 + rbracket), recurse rhs
         // (Ast.zig:1245-1248).
         case AST_NODE_SLICE_OPEN:
             end_offset += 2;
             n = nd.rhs;
             continue;
 
         // grouped_expression: end_offset += 1 (rparen), recurse lhs.
         case AST_NODE_GROUPED_EXPRESSION:
             end_offset += 1;
             n = nd.lhs;
             continue;
 
         // if_simple: recurse into body (rhs) (Ast.zig:942).
         case AST_NODE_IF_SIMPLE:
         case AST_NODE_WHILE_SIMPLE:
         case AST_NODE_FOR_SIMPLE:
         case AST_NODE_FN_DECL:
         case AST_NODE_ARRAY_TYPE:
             n = nd.rhs;
             continue;
 
         // if: recurse into else_expr (Ast.zig:1295).
         case AST_NODE_IF: {
             // If[rhs]: { then_expr, else_expr }
             n = tree->extra_data.arr[nd.rhs + 1]; // else_expr
             continue;
         }
 
         // while: recurse into else_expr (Ast.zig:1290).
         case AST_NODE_WHILE: {
             // While[rhs]: { cont_expr, then_expr, else_expr }
             n = tree->extra_data.arr[nd.rhs + 2]; // else_expr
             continue;
         }
 
         // while_cont: recurse into then_expr (Ast.zig:943-like).
         case AST_NODE_WHILE_CONT: {
             // WhileCont[rhs]: { cont_expr, then_expr }
             n = tree->extra_data.arr[nd.rhs + 1]; // then_expr
             continue;
         }
 
         // switch: recurse into last case (Ast.zig:1031-1041).
         case AST_NODE_SWITCH: {
             uint32_t ei = nd.rhs;
             uint32_t cs = tree->extra_data.arr[ei];
             uint32_t ce = tree->extra_data.arr[ei + 1];
             if (cs == ce) {
                 end_offset += 3; // rparen, lbrace, rbrace
                 n = nd.lhs;
             } else {
                 end_offset += 1; // rbrace
                 n = tree->extra_data.arr[ce - 1];
             }
             continue;
         }
         case AST_NODE_SWITCH_COMMA: {
             uint32_t ei = nd.rhs;
             uint32_t cs = tree->extra_data.arr[ei];
             uint32_t ce = tree->extra_data.arr[ei + 1];
             assert(cs != ce);
             end_offset += 2; // comma + rbrace
             n = tree->extra_data.arr[ce - 1];
             continue;
         }
 
         // switch_case_one: recurse into rhs (body) (Ast.zig:942).
         case AST_NODE_SWITCH_CASE_ONE:
         case AST_NODE_SWITCH_CASE_INLINE_ONE:
         case AST_NODE_SWITCH_CASE:
         case AST_NODE_SWITCH_CASE_INLINE:
             n = nd.rhs;
             continue;
 
         // switch_range: recurse into rhs (Ast.zig: binary op pattern).
         case AST_NODE_SWITCH_RANGE:
             n = nd.rhs;
             continue;
 
         // struct_init_one: recurse into field if present, +1.
         case AST_NODE_STRUCT_INIT_ONE:
             end_offset += 1; // rbrace
             if (nd.rhs != 0) {
                 n = nd.rhs;
             } else {
                 return tree->nodes.main_tokens[n] + end_offset;
             }
             continue;
         case AST_NODE_STRUCT_INIT_ONE_COMMA:
             end_offset += 2; // comma + rbrace
             n = nd.rhs;
             continue;
 
         // struct_init_dot_two: similar to block_two.
         case AST_NODE_STRUCT_INIT_DOT_TWO:
             if (nd.rhs != 0) {
                 end_offset += 1;
                 n = nd.rhs;
             } else if (nd.lhs != 0) {
                 end_offset += 1;
                 n = nd.lhs;
             } else {
                 end_offset += 1; // rbrace
                 return tree->nodes.main_tokens[n] + end_offset;
             }
             continue;
         case AST_NODE_STRUCT_INIT_DOT_TWO_COMMA:
             end_offset += 2;
             if (nd.rhs != 0) {
                 n = nd.rhs;
             } else {
                 n = nd.lhs;
             }
             continue;
 
         // struct_init_dot: SubRange pattern.
         case AST_NODE_STRUCT_INIT_DOT:
             assert(nd.lhs != nd.rhs);
             end_offset += 1;
             n = tree->extra_data.arr[nd.rhs - 1];
             continue;
 
         // struct_init: node_and_extra SubRange pattern.
         case AST_NODE_STRUCT_INIT: {
             uint32_t si = tree->extra_data.arr[nd.rhs];
             uint32_t se = tree->extra_data.arr[nd.rhs + 1];
             assert(si != se);
             end_offset += 1;
             n = tree->extra_data.arr[se - 1];
             continue;
         }
 
         // call: SubRange pattern.
         case AST_NODE_CALL: {
             uint32_t si = tree->extra_data.arr[nd.rhs];
             uint32_t se = tree->extra_data.arr[nd.rhs + 1];
             assert(si != se);
             end_offset += 1;
             n = tree->extra_data.arr[se - 1];
             continue;
         }
         case AST_NODE_CALL_COMMA: {
             uint32_t si = tree->extra_data.arr[nd.rhs];
             uint32_t se = tree->extra_data.arr[nd.rhs + 1];
             assert(si != se);
             end_offset += 2;
             n = tree->extra_data.arr[se - 1];
             continue;
         }
 
         // fn_proto_simple: recurse into rhs (return type).
         case AST_NODE_FN_PROTO_SIMPLE:
         case AST_NODE_FN_PROTO_ONE:
         case AST_NODE_FN_PROTO_MULTI:
         case AST_NODE_FN_PROTO:
             n = nd.rhs;
             continue;
 
         // error_set_decl: rhs is the closing rbrace token.
         case AST_NODE_ERROR_SET_DECL:
             return nd.rhs + end_offset;
 
         // ptr_type variants: recurse into rhs (child type).
         case AST_NODE_PTR_TYPE_ALIGNED:
         case AST_NODE_PTR_TYPE_SENTINEL:
         case AST_NODE_PTR_TYPE:
         case AST_NODE_PTR_TYPE_BIT_RANGE:
             n = nd.rhs;
             continue;
 
         // container_decl: extra_range pattern.
         case AST_NODE_CONTAINER_DECL:
         case AST_NODE_TAGGED_UNION:
             assert(nd.lhs != nd.rhs);
             end_offset += 1;
             n = tree->extra_data.arr[nd.rhs - 1];
             continue;
         case AST_NODE_CONTAINER_DECL_TRAILING:
         case AST_NODE_TAGGED_UNION_TRAILING:
             assert(nd.lhs != nd.rhs);
             end_offset += 2;
             n = tree->extra_data.arr[nd.rhs - 1];
             continue;
 
         // container_decl_two: like block_two.
         case AST_NODE_CONTAINER_DECL_TWO:
         case AST_NODE_TAGGED_UNION_TWO:
             if (nd.rhs != 0) {
                 end_offset += 1;
                 n = nd.rhs;
             } else if (nd.lhs != 0) {
                 end_offset += 1;
                 n = nd.lhs;
             } else {
                 end_offset += 2; // lbrace + rbrace
                 return tree->nodes.main_tokens[n] + end_offset;
             }
             continue;
         case AST_NODE_CONTAINER_DECL_TWO_TRAILING:
         case AST_NODE_TAGGED_UNION_TWO_TRAILING:
             end_offset += 2;
             if (nd.rhs != 0) {
                 n = nd.rhs;
             } else {
                 n = nd.lhs;
             }
             continue;
 
         // container_decl_arg: node_and_extra SubRange.
         case AST_NODE_CONTAINER_DECL_ARG: {
             uint32_t si = tree->extra_data.arr[nd.rhs];
             uint32_t se = tree->extra_data.arr[nd.rhs + 1];
             if (si == se) {
                 end_offset += 3; // rparen + lbrace + rbrace
                 n = nd.lhs;
             } else {
                 end_offset += 1;
                 n = tree->extra_data.arr[se - 1];
             }
             continue;
         }
         case AST_NODE_CONTAINER_DECL_ARG_TRAILING: {
             uint32_t si = tree->extra_data.arr[nd.rhs];
             uint32_t se = tree->extra_data.arr[nd.rhs + 1];
             assert(si != se);
             end_offset += 2;
             n = tree->extra_data.arr[se - 1];
             continue;
         }
 
         // slice: extra data pattern.
         case AST_NODE_SLICE: {
             // Slice[rhs]: { start, end }
             end_offset += 1;
             n = tree->extra_data.arr[nd.rhs + 1]; // end
             continue;
         }
         case AST_NODE_SLICE_SENTINEL: {
             // SliceSentinel[rhs]: { start, end, sentinel }
             end_offset += 1;
             n = tree->extra_data.arr[nd.rhs + 2]; // sentinel
             continue;
         }
 
         // array_type_sentinel: extra data.
         case AST_NODE_ARRAY_TYPE_SENTINEL: {
             // ArrayTypeSentinel[rhs]: { sentinel, elem_type }
             n = tree->extra_data.arr[nd.rhs + 1]; // elem_type
             continue;
         }
 
         // multiline_string_literal: main_token + end_offset.
         case AST_NODE_MULTILINE_STRING_LITERAL:
             return nd.rhs + end_offset;
 
         // break/continue (Ast.zig:1275-1283).
         // lhs is opt_token (null_token = UINT32_MAX), rhs is opt_node (0 =
         // none).
         case AST_NODE_BREAK:
         case AST_NODE_CONTINUE:
             if (nd.rhs != 0) {
                 n = nd.rhs; // optional rhs expression
             } else if (nd.lhs != UINT32_MAX) {
                 return nd.lhs + end_offset; // label token
             } else {
                 return tree->nodes.main_tokens[n] + end_offset;
             }
             continue;
 
         // array_init_one: end_offset += 1 (rbrace), recurse rhs
         // (Ast.zig:1224-1230).
         case AST_NODE_ARRAY_INIT_ONE:
             end_offset += 1;
             n = nd.rhs;
             continue;
 
         case AST_NODE_ARRAY_INIT_ONE_COMMA:
             end_offset += 2; // comma + rbrace
             n = nd.rhs;
             continue;
 
         // struct_init_dot_comma: SubRange pattern.
         case AST_NODE_STRUCT_INIT_DOT_COMMA:
             assert(nd.lhs != nd.rhs);
             end_offset += 2; // comma + rbrace
             n = tree->extra_data.arr[nd.rhs - 1];
             continue;
 
         // struct_init_comma: node_and_extra SubRange.
         case AST_NODE_STRUCT_INIT_COMMA: {
             uint32_t si = tree->extra_data.arr[nd.rhs];
             uint32_t se = tree->extra_data.arr[nd.rhs + 1];
             assert(si != se);
             end_offset += 2;
             n = tree->extra_data.arr[se - 1];
             continue;
         }
 
         // array_init variants.
         case AST_NODE_ARRAY_INIT: {
             uint32_t si = tree->extra_data.arr[nd.rhs];
             uint32_t se = tree->extra_data.arr[nd.rhs + 1];
             assert(si != se);
             end_offset += 1;
             n = tree->extra_data.arr[se - 1];
             continue;
         }
         case AST_NODE_ARRAY_INIT_COMMA: {
             uint32_t si = tree->extra_data.arr[nd.rhs];
             uint32_t se = tree->extra_data.arr[nd.rhs + 1];
             assert(si != se);
             end_offset += 2;
             n = tree->extra_data.arr[se - 1];
             continue;
         }
 
         // array_init_dot variants.
         case AST_NODE_ARRAY_INIT_DOT_TWO:
             if (nd.rhs != 0) {
                 end_offset += 1;
                 n = nd.rhs;
             } else if (nd.lhs != 0) {
                 end_offset += 1;
                 n = nd.lhs;
             } else {
                 end_offset += 1;
                 return tree->nodes.main_tokens[n] + end_offset;
             }
             continue;
         case AST_NODE_ARRAY_INIT_DOT_TWO_COMMA:
             end_offset += 2;
             if (nd.rhs != 0) {
                 n = nd.rhs;
             } else {
                 n = nd.lhs;
             }
             continue;
         case AST_NODE_ARRAY_INIT_DOT:
             assert(nd.lhs != nd.rhs);
             end_offset += 1;
             n = tree->extra_data.arr[nd.rhs - 1];
             continue;
         case AST_NODE_ARRAY_INIT_DOT_COMMA:
             assert(nd.lhs != nd.rhs);
             end_offset += 2;
             n = tree->extra_data.arr[nd.rhs - 1];
             continue;
 
         // builtin_call (Ast.zig:1083-1105).
         case AST_NODE_BUILTIN_CALL: {
             uint32_t si = tree->extra_data.arr[nd.rhs];
             uint32_t se = tree->extra_data.arr[nd.rhs + 1];
             assert(si != se);
             end_offset += 1;
             n = tree->extra_data.arr[se - 1];
             continue;
         }
         case AST_NODE_BUILTIN_CALL_COMMA: {
             uint32_t si = tree->extra_data.arr[nd.rhs];
             uint32_t se = tree->extra_data.arr[nd.rhs + 1];
             assert(si != se);
             end_offset += 2;
             n = tree->extra_data.arr[se - 1];
             continue;
         }
 
         // for (Ast.zig:1300-1303): complex extra data.
         case AST_NODE_FOR: {
             // lhs = span.start (extra_data index),
             // rhs = packed(inputs:u31, has_else:u1 at bit 31).
             // extra[lhs..] = input nodes, then_body, [else_body].
             uint32_t span_start = nd.lhs;
             uint32_t for_packed = nd.rhs;
             uint32_t inputs = for_packed & 0x7FFFFFFFu;
             bool has_else = (for_packed >> 31) != 0;
             uint32_t last_idx = span_start + inputs + (has_else ? 1 : 0);
             n = tree->extra_data.arr[last_idx];
             continue;
         }
 
         default:
             // Fallback: return main_token + end_offset.
             return tree->nodes.main_tokens[n] + end_offset;
         }
     }
 }
 
 // --- addParam (AstGen.zig:12390) ---
 // Creates a param instruction with pl_tok data and type body in extra.
 
 static uint32_t addParam(GenZir* gz, GenZir* param_gz, ZirInstTag tag,
     uint32_t abs_tok_index, uint32_t name) {
     AstGenCtx* ag = gz->astgen;
 
     uint32_t body_len = gzInstructionsLen(param_gz);
     const uint32_t* param_body = gzInstructionsSlice(param_gz);
 
     // Param payload: name, type{body_len:u31|is_generic:u1}
     ensureExtraCapacity(ag, 2 + body_len);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = name;
     ag->extra[ag->extra_len++] = body_len & 0x7FFFFFFFu; // is_generic = false
     for (uint32_t i = 0; i < body_len; i++) {
         ag->extra[ag->extra_len++] = param_body[i];
     }
     gzUnstack(param_gz);
 
     // Emit the param instruction.
     ensureInstCapacity(ag, 1);
     uint32_t idx = ag->inst_len;
     ag->inst_tags[idx] = tag;
     ZirInstData data;
     data.pl_tok.src_tok = tokenIndexToRelative(gz, abs_tok_index);
     data.pl_tok.payload_index = payload_index;
     ag->inst_datas[idx] = data;
     ag->inst_len++;
     gzAppendInstruction(gz, idx);
     return idx;
 }
 
 // --- addDbgVar (AstGen.zig:13196) ---
 
 static void addDbgVar(
     GenZir* gz, ZirInstTag tag, uint32_t name, uint32_t inst) {
     if (gz->is_comptime)
         return;
     ZirInstData data;
     data.str_op.str = name;
     data.str_op.operand = inst;
     addInstruction(gz, tag, data);
 }
 
 // --- addFunc (AstGen.zig:12023) ---
 // Handles non-fancy func/func_inferred instructions.
 // ret_body/ret_body_len: instructions for the return type sub-block (may be
 // 0). ret_ref: if ret_body_len==0, the return type as a simple Ref.
 
 static uint32_t addFunc(GenZir* gz, uint32_t src_node, uint32_t block_node,
     uint32_t param_block, uint32_t ret_ref, const uint32_t* ret_body,
     uint32_t ret_body_len, const uint32_t* body, uint32_t body_len,
     const uint32_t* param_insts, uint32_t param_insts_len,
     uint32_t lbrace_line, uint32_t lbrace_column, bool is_inferred_error) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     uint32_t rbrace_tok = lastToken(tree, block_node);
     uint32_t rbrace_start = tree->tokens.starts[rbrace_tok];
     advanceSourceCursor(ag, rbrace_start);
     uint32_t rbrace_line = ag->source_line - gz->decl_line;
     uint32_t rbrace_column = ag->source_column;
 
     // Build Func payload (Zir.Inst.Func: ret_ty, param_block, body_len).
     // (AstGen.zig:12187-12194)
     uint32_t ret_ty_packed_len;
     if (ret_body_len > 0) {
         ret_ty_packed_len = ret_body_len; // body-based return type
     } else if (ret_ref != ZIR_REF_NONE) {
         ret_ty_packed_len = 1; // simple Ref
     } else {
         ret_ty_packed_len = 0; // void return
     }
     // Pack RetTy: body_len:u31 | is_generic:bool(u1) = just body_len.
     uint32_t ret_ty_packed
         = ret_ty_packed_len & 0x7FFFFFFFu; // is_generic=false
 
     uint32_t fixup_body_len = countBodyLenAfterFixupsExtraRefs(
         ag, body, body_len, param_insts, param_insts_len);
     ensureExtraCapacity(ag, 3 + ret_ty_packed_len + fixup_body_len + 7);
     uint32_t payload_index = ag->extra_len;
     ag->extra[ag->extra_len++] = ret_ty_packed; // Func.ret_ty
     ag->extra[ag->extra_len++] = param_block; // Func.param_block
     ag->extra[ag->extra_len++] = fixup_body_len; // Func.body_len
 
     // Trailing ret_ty: either body instructions or a single ref.
     if (ret_body_len > 0) {
         for (uint32_t i = 0; i < ret_body_len; i++)
             ag->extra[ag->extra_len++] = ret_body[i];
     } else if (ret_ref != ZIR_REF_NONE) {
         ag->extra[ag->extra_len++] = ret_ref;
     }
 
     // Body instructions with extra_refs for param_insts
     // (AstGen.zig:12206).
     appendBodyWithFixupsExtraRefs(
         ag, body, body_len, param_insts, param_insts_len);
 
     // SrcLocs (AstGen.zig:12098-12106).
     uint32_t columns = (lbrace_column & 0xFFFFu) | (rbrace_column << 16);
     ag->extra[ag->extra_len++] = lbrace_line;
     ag->extra[ag->extra_len++] = rbrace_line;
     ag->extra[ag->extra_len++] = columns;
     // proto_hash (4 words): zero for now.
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
 
     // Emit the func instruction (AstGen.zig:12220-12226).
     ZirInstTag tag
         = is_inferred_error ? ZIR_INST_FUNC_INFERRED : ZIR_INST_FUNC;
     ZirInstData data;
     data.pl_node.src_node = (int32_t)src_node - (int32_t)gz->decl_node_index;
     data.pl_node.payload_index = payload_index;
     return addInstruction(gz, tag, data);
 }
 
 // --- testDecl (AstGen.zig:4708) ---
 
 static void testDecl(AstGenCtx* ag, GenZir* gz, uint32_t* wip_decl_insts,
     uint32_t* decl_idx, uint32_t node) {
     const Ast* tree = ag->tree;
     AstData nd = tree->nodes.datas[node];
     uint32_t body_node = nd.rhs;
 
     // makeDeclaration before advanceSourceCursorToNode (AstGen.zig:4726-4729).
     uint32_t decl_inst = makeDeclaration(ag, node);
     wip_decl_insts[*decl_idx] = decl_inst;
     (*decl_idx)++;
     advanceSourceCursorToNode(ag, node);
 
     uint32_t decl_line = ag->source_line;
     uint32_t decl_column = ag->source_column;
 
     // Extract test name (AstGen.zig:4748-4835).
     uint32_t test_token = tree->nodes.main_tokens[node];
     uint32_t test_name_token = test_token + 1;
     uint32_t test_name = 0; // NullTerminatedString.empty
     DeclFlagsId decl_id = DECL_ID_UNNAMED_TEST;
 
     // Check if the token after 'test' is a string literal.
     // We identify string literals by checking the source character.
     uint32_t name_tok_start = tree->tokens.starts[test_name_token];
     if (name_tok_start < tree->source_len
         && tree->source[name_tok_start] == '"') {
         // String literal name.
         uint32_t name_len;
         strLitAsString(ag, test_name_token, &test_name, &name_len);
         decl_id = DECL_ID_TEST;
     }
     // TODO: handle identifier test names (decltest).
 
     // Set up decl_block GenZir (AstGen.zig:4735-4743).
     GenZir decl_block;
     memset(&decl_block, 0, sizeof(decl_block));
     decl_block.base.tag = SCOPE_GEN_ZIR;
     decl_block.parent = NULL;
     decl_block.astgen = ag;
     decl_block.decl_node_index = node;
     decl_block.decl_line = decl_line;
     decl_block.is_comptime = true;
     decl_block.instructions_top = ag->scratch_inst_len;
     decl_block.break_block = UINT32_MAX;
 
     // Set up fn_block GenZir (AstGen.zig:4837-4845).
     GenZir fn_block;
     memset(&fn_block, 0, sizeof(fn_block));
     fn_block.base.tag = SCOPE_GEN_ZIR;
     fn_block.parent = &decl_block.base;
     fn_block.astgen = ag;
     fn_block.decl_node_index = node;
     fn_block.decl_line = decl_line;
     fn_block.is_comptime = false;
     fn_block.instructions_top = ag->scratch_inst_len;
     fn_block.break_block = UINT32_MAX;
 
     // Set fn_block and fn_ret_ty for the body (AstGen.zig:4849-4853).
     void* prev_fn_block = ag->fn_block;
     uint32_t prev_fn_ret_ty = ag->fn_ret_ty;
     setFnBlock(ag, &fn_block);
     ag->fn_ret_ty = ZIR_REF_ANYERROR_VOID_ERROR_UNION_TYPE;
 
     // Compute lbrace source location (AstGen.zig:4860-4862).
     advanceSourceCursorToNode(ag, body_node);
     uint32_t lbrace_line = ag->source_line - decl_line;
     uint32_t lbrace_column = ag->source_column;
 
     // Process test body (AstGen.zig:4864).
     uint32_t block_result
         = fullBodyExpr(&fn_block, &fn_block.base, RL_NONE_VAL, body_node);
 
     ag->fn_block = prev_fn_block;
     ag->fn_ret_ty = prev_fn_ret_ty;
 
     // If we hit unimplemented features, bail out.
     if (ag->has_compile_errors)
         return;
 
     // Add restore_err_ret_index + ret_implicit (AstGen.zig:4865-4871).
     if (gzInstructionsLen(&fn_block) == 0
         || !refIsNoReturn(&fn_block, block_result)) {
         ZirInstData rdata;
         rdata.un_node.operand = ZIR_REF_NONE; // .none for .ret
         rdata.un_node.src_node
             = (int32_t)node - (int32_t)fn_block.decl_node_index;
         addInstruction(
             &fn_block, ZIR_INST_RESTORE_ERR_RET_INDEX_UNCONDITIONAL, rdata);
 
         uint32_t body_last_tok = lastToken(tree, body_node);
         ZirInstData rdata2;
         rdata2.un_tok.operand = ZIR_REF_VOID_VALUE;
         rdata2.un_tok.src_tok = tokenIndexToRelative(&fn_block, body_last_tok);
         addInstruction(&fn_block, ZIR_INST_RET_IMPLICIT, rdata2);
     }
 
     // Read fn_block body before unstacking (AstGen.zig:4874).
     // Upstream unstacks fn_block inside addFunc before appending the func
     // instruction to decl_block. We must unstack fn_block first so that
     // addFunc's addInstruction goes into decl_block's range.
     const uint32_t* fn_body = gzInstructionsSlice(&fn_block);
     uint32_t fn_body_len = gzInstructionsLen(&fn_block);
     gzUnstack(&fn_block);
 
     // Create func instruction (AstGen.zig:4874-4897).
     uint32_t func_ref = addFunc(&decl_block, node, body_node, decl_inst,
         ZIR_REF_ANYERROR_VOID_ERROR_UNION_TYPE, NULL, 0, fn_body, fn_body_len,
         NULL, 0, lbrace_line, lbrace_column, false);
 
     // break_inline returning func to declaration (AstGen.zig:4899).
     makeBreakInline(&decl_block, decl_inst, func_ref, AST_NODE_OFFSET_NONE);
 
     // setDeclaration (AstGen.zig:4903-4923).
     setDeclaration(ag, decl_inst,
         (SetDeclArgs) { .src_line = decl_line,
             .src_column = decl_column,
             .id = decl_id,
             .name = test_name,
             .lib_name = UINT32_MAX,
             .value_body = gzInstructionsSlice(&decl_block),
             .value_body_len = gzInstructionsLen(&decl_block) });
     gzUnstack(&decl_block);
 
     (void)gz;
 }
 
 // --- fnDecl (AstGen.zig:4067) / fnDeclInner (AstGen.zig:4228) ---
 // Handles non-extern function declarations with bodies, including params.
 
 static void fnDecl(AstGenCtx* ag, GenZir* gz, uint32_t* wip_decl_insts,
     uint32_t* decl_idx, uint32_t node) {
     const Ast* tree = ag->tree;
     AstData nd = tree->nodes.datas[node];
 
     // For fn_decl: data.lhs = fn_proto node, data.rhs = body node.
     uint32_t proto_node = nd.lhs;
     uint32_t body_node = nd.rhs;
 
     // Get function name token (main_token of proto + 1 = fn name).
     uint32_t fn_token = tree->nodes.main_tokens[proto_node];
     uint32_t fn_name_token = fn_token + 1;
 
     // Check for 'pub' modifier (Ast.zig:2003-2025).
     bool is_pub = (fn_token > 0
         && tree->tokens.tags[fn_token - 1] == TOKEN_KEYWORD_PUB);
 
     // makeDeclaration on fn_proto node (AstGen.zig:4090).
     uint32_t decl_inst = makeDeclaration(ag, proto_node);
     wip_decl_insts[*decl_idx] = decl_inst;
     (*decl_idx)++;
 
     advanceSourceCursorToNode(ag, node);
     uint32_t decl_line = ag->source_line;
     uint32_t decl_column = ag->source_column;
 
     // Save source cursor for restoring after ret_gz (AstGen.zig:4387-4388).
     uint32_t saved_source_offset = ag->source_offset;
     uint32_t saved_source_line = ag->source_line;
     uint32_t saved_source_column = ag->source_column;
 
     AstNodeTag proto_tag = tree->nodes.tags[proto_node];
     AstData proto_data = tree->nodes.datas[proto_node];
 
     // Extract return type node (rhs for all fn_proto variants).
     uint32_t return_type_node = proto_data.rhs;
 
     // Detect inferred error set: token before return type is '!'
     // (AstGen.zig:4249-4251).
     bool is_inferred_error = false;
     if (return_type_node != 0) {
         uint32_t ret_first_tok = firstToken(tree, return_type_node);
         if (ret_first_tok > 0) {
             uint32_t maybe_bang = ret_first_tok - 1;
             uint32_t bang_start = tree->tokens.starts[maybe_bang];
             if (tree->source[bang_start] == '!')
                 is_inferred_error = true;
         }
     }
 
     // Extract param type nodes from proto variant (AstGen.zig:4253-4254).
     uint32_t param_nodes_buf[1]; // buffer for fn_proto_simple/fn_proto_one
     const uint32_t* param_nodes = NULL;
     uint32_t params_len = 0;
 
     if (proto_tag == AST_NODE_FN_PROTO_SIMPLE) {
         // data.lhs = optional param node, data.rhs = return type.
         if (proto_data.lhs != 0) {
             param_nodes_buf[0] = proto_data.lhs;
             param_nodes = param_nodes_buf;
             params_len = 1;
         }
     } else if (proto_tag == AST_NODE_FN_PROTO_ONE) {
         // data.lhs = extra_data index → AstFnProtoOne.
         uint32_t extra_idx = proto_data.lhs;
         uint32_t param
             = tree->extra_data.arr[extra_idx]; // AstFnProtoOne.param
         if (param != 0) {
             param_nodes_buf[0] = param;
             param_nodes = param_nodes_buf;
             params_len = 1;
         }
     } else if (proto_tag == AST_NODE_FN_PROTO_MULTI) {
         // data.lhs = extra_data index → SubRange{start, end}.
         uint32_t extra_idx = proto_data.lhs;
         uint32_t range_start = tree->extra_data.arr[extra_idx];
         uint32_t range_end = tree->extra_data.arr[extra_idx + 1];
         param_nodes = tree->extra_data.arr + range_start;
         params_len = range_end - range_start;
     } else if (proto_tag == AST_NODE_FN_PROTO) {
         // data.lhs = extra_data index → AstFnProto{params_start, params_end,
         // ...}.
         uint32_t extra_idx = proto_data.lhs;
         uint32_t pstart = tree->extra_data.arr[extra_idx]; // params_start
         uint32_t pend = tree->extra_data.arr[extra_idx + 1]; // params_end
         param_nodes = tree->extra_data.arr + pstart;
         params_len = pend - pstart;
     }
 
     // decl_gz (called value_gz in caller, decl_gz in fnDeclInner)
     // (AstGen.zig:4194-4201).
     GenZir decl_gz;
     memset(&decl_gz, 0, sizeof(decl_gz));
     decl_gz.base.tag = SCOPE_GEN_ZIR;
     decl_gz.parent = NULL;
     decl_gz.astgen = ag;
     decl_gz.decl_node_index = proto_node;
     decl_gz.decl_line = decl_line;
     decl_gz.is_comptime = true;
     decl_gz.instructions_top = ag->scratch_inst_len;
     decl_gz.break_block = UINT32_MAX;
 
     // --- Parameter iteration (AstGen.zig:4260-4363) ---
     // Walk params, creating param instructions and ScopeLocalVal entries.
     // We keep param scopes on the C stack (max 32 params like upstream).
     Scope* params_scope = &decl_gz.base;
     ScopeLocalVal param_scopes[32];
     uint32_t param_scope_count = 0;
     // Collect param instruction indices (AstGen.zig:4254, 4360).
     uint32_t param_insts[32];
     uint32_t param_insts_len = 0;
 
     for (uint32_t param_i = 0; param_i < params_len; param_i++) {
         uint32_t param_type_node = param_nodes[param_i];
 
         // Find param name token by scanning backwards from firstToken of
         // type expression (mirrors FnProto.Iterator.next, Ast.zig:2687).
         // Layout: [comptime] [name] [:] type_expr
         // So: type_first_tok - 1 is ':', type_first_tok - 2 is name.
         uint32_t type_first_tok = firstToken(tree, param_type_node);
         uint32_t name_token = 0; // 0 = no name found
         bool is_comptime_param = false;
         if (type_first_tok >= 2
             && tree->tokens.tags[type_first_tok - 1] == TOKEN_COLON) {
             // Named parameter: name is at type_first_tok - 2.
             uint32_t maybe_name = type_first_tok - 2;
             uint32_t name_start = tree->tokens.starts[maybe_name];
             char ch = tree->source[name_start];
             if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
                 || ch == '_' || ch == '@') {
                 // Could be name or comptime/noalias keyword.
                 if (name_start + 8 <= tree->source_len
                     && memcmp(tree->source + name_start, "comptime", 8) == 0) {
                     is_comptime_param = true;
                 } else if (name_start + 7 <= tree->source_len
                     && memcmp(tree->source + name_start, "noalias", 7) == 0) {
                     // noalias keyword, not a name.
                 } else {
                     name_token = maybe_name;
                     // Check for preceding comptime keyword.
                     if (maybe_name > 0) {
                         uint32_t prev = maybe_name - 1;
                         uint32_t prev_start = tree->tokens.starts[prev];
                         if (prev_start + 8 <= tree->source_len
                             && memcmp(tree->source + prev_start, "comptime", 8)
                                 == 0)
                             is_comptime_param = true;
                     }
                 }
             }
         }
 
         // Determine param name string (AstGen.zig:4283-4321).
         // Must be resolved BEFORE type expression to match upstream string
         // table ordering.
         uint32_t param_name_str = 0; // NullTerminatedString.empty
         if (name_token != 0) {
             uint32_t name_start = tree->tokens.starts[name_token];
             char nch = tree->source[name_start];
             // Skip "_" params (AstGen.zig:4285-4286).
             if (nch == '_') {
                 uint32_t next_start = tree->tokens.starts[name_token + 1];
                 if (next_start == name_start + 1) {
                     // Single underscore: empty name.
                     param_name_str = 0;
                 } else {
                     param_name_str = identAsString(ag, name_token);
                 }
             } else {
                 param_name_str = identAsString(ag, name_token);
             }
         }
 
         // Evaluate param type expression in a sub-block
         // (AstGen.zig:4333-4337).
         GenZir param_gz = makeSubBlock(&decl_gz, params_scope);
         uint32_t param_type_ref
             = expr(&param_gz, params_scope, param_type_node);
 
         if (ag->has_compile_errors)
             return;
 
         // The break_inline target is the param instruction we're about to
         // create (AstGen.zig:4336-4337).
         uint32_t param_inst_expected = ag->inst_len + 1;
         // +1 because: the break_inline is emitted first (uses inst_len),
         // then addParam emits the param instruction at inst_len.
         // Actually, addParam emits the param after break_inline. The
         // break_inline's block_inst field should point to the param inst.
         // We know it will be at ag->inst_len after the break_inline.
         makeBreakInline(&param_gz, param_inst_expected, param_type_ref,
             (int32_t)param_type_node - (int32_t)param_gz.decl_node_index);
 
         // Create param instruction (AstGen.zig:4341-4343).
         ZirInstTag param_tag
             = is_comptime_param ? ZIR_INST_PARAM_COMPTIME : ZIR_INST_PARAM;
         uint32_t name_tok_for_src = name_token != 0
             ? name_token
             : tree->nodes.main_tokens[param_type_node];
         uint32_t param_inst = addParam(
             &decl_gz, &param_gz, param_tag, name_tok_for_src, param_name_str);
         (void)param_inst_expected;
         // Record param instruction index (AstGen.zig:4360).
         if (param_insts_len < 32)
             param_insts[param_insts_len++] = param_inst;
 
         // Create ScopeLocalVal for this param (AstGen.zig:4349-4359).
         if (param_name_str != 0 && param_scope_count < 32) {
             ScopeLocalVal* lv = &param_scopes[param_scope_count++];
             lv->base.tag = SCOPE_LOCAL_VAL;
             lv->parent = params_scope;
             lv->gen_zir = &decl_gz;
             lv->inst = param_inst + ZIR_REF_START_INDEX; // toRef()
             lv->token_src = name_token;
             lv->name = param_name_str;
             params_scope = &lv->base;
         }
     }
 
     // --- Return type (AstGen.zig:4369-4383) ---
     GenZir ret_gz = makeSubBlock(&decl_gz, params_scope);
     uint32_t ret_ref = ZIR_REF_NONE;
     if (return_type_node != 0) {
         ret_ref = expr(&ret_gz, params_scope, return_type_node);
         if (ag->has_compile_errors)
             return;
         // If ret_gz produced instructions, add break_inline
         // (AstGen.zig:4377-4381).
         if (gzInstructionsLen(&ret_gz) > 0) {
             // break_inline targets the func instruction (which doesn't
             // exist yet). We use 0 as placeholder and patch later.
             makeBreakInline(&ret_gz, 0, ret_ref, AST_NODE_OFFSET_NONE);
         }
     }
     // Map void_type → .none (AstGen.zig:12054).
     if (ret_ref == ZIR_REF_VOID_TYPE)
         ret_ref = ZIR_REF_NONE;
 
     uint32_t ret_body_len = gzInstructionsLen(&ret_gz);
     // Copy ret_body before unstacking: body_gz reuses the same scratch area.
     uint32_t* ret_body = NULL;
     if (ret_body_len > 0) {
         ret_body = malloc(ret_body_len * sizeof(uint32_t));
         if (!ret_body)
             abort();
         memcpy(ret_body, gzInstructionsSlice(&ret_gz),
             ret_body_len * sizeof(uint32_t));
     }
     gzUnstack(&ret_gz);
 
     // Restore source cursor (AstGen.zig:4387-4388).
     ag->source_offset = saved_source_offset;
     ag->source_line = saved_source_line;
     ag->source_column = saved_source_column;
 
     // --- Body (AstGen.zig:4415-4424) ---
     GenZir body_gz;
     memset(&body_gz, 0, sizeof(body_gz));
     body_gz.base.tag = SCOPE_GEN_ZIR;
     body_gz.parent = params_scope;
     body_gz.astgen = ag;
     body_gz.decl_node_index = proto_node;
     body_gz.decl_line = decl_line;
     body_gz.is_comptime = false;
     body_gz.instructions_top = ag->scratch_inst_len;
 
     // Set fn_block and fn_ret_ty for the body (AstGen.zig:4442-4455).
     void* prev_fn_block = ag->fn_block;
     setFnBlock(ag, &body_gz);
     uint32_t prev_fn_ret_ty = ag->fn_ret_ty;
     if (is_inferred_error || ret_ref == ZIR_REF_NONE) {
         // Non-void non-trivial return type: emit ret_type instruction.
         if (ret_body_len > 0 || is_inferred_error) {
             ZirInstData rtdata;
             memset(&rtdata, 0, sizeof(rtdata));
             rtdata.node = (int32_t)node - (int32_t)body_gz.decl_node_index;
             ag->fn_ret_ty
                 = addInstruction(&body_gz, ZIR_INST_RET_TYPE, rtdata);
         } else {
             ag->fn_ret_ty = ret_ref; // void
         }
     } else {
         // ret_ref is a simple ref (not void, not inferred error).
         // Still need ret_type instruction if it resolved to an inst.
         if (ret_ref >= ZIR_REF_START_INDEX) {
             ZirInstData rtdata;
             memset(&rtdata, 0, sizeof(rtdata));
             rtdata.node = (int32_t)node - (int32_t)body_gz.decl_node_index;
             ag->fn_ret_ty
                 = addInstruction(&body_gz, ZIR_INST_RET_TYPE, rtdata);
         } else {
             ag->fn_ret_ty = ret_ref;
         }
     }
 
     // Process function body (AstGen.zig:4461-4465).
     advanceSourceCursorToNode(ag, body_node);
     uint32_t lbrace_line = ag->source_line - decl_line;
     uint32_t lbrace_column = ag->source_column;
 
     fullBodyExpr(&body_gz, &body_gz.base, RL_NONE_VAL, body_node);
 
     ag->fn_block = prev_fn_block;
     ag->fn_ret_ty = prev_fn_ret_ty;
 
     if (ag->has_compile_errors) {
         free(ret_body);
         return;
     }
 
     // Add implicit return at end of function body
     // (AstGen.zig:4465-4871).
     if (!endsWithNoReturn(&body_gz)) {
         ZirInstData rdata;
         rdata.un_node.operand = ZIR_REF_NONE;
         rdata.un_node.src_node
             = (int32_t)node - (int32_t)body_gz.decl_node_index;
         addInstruction(
             &body_gz, ZIR_INST_RESTORE_ERR_RET_INDEX_UNCONDITIONAL, rdata);
 
         uint32_t body_last_tok = lastToken(tree, body_node);
         ZirInstData rdata2;
         rdata2.un_tok.operand = ZIR_REF_VOID_VALUE;
         rdata2.un_tok.src_tok = tokenIndexToRelative(&body_gz, body_last_tok);
         addInstruction(&body_gz, ZIR_INST_RET_IMPLICIT, rdata2);
     }
 
     // Read body before unstacking (AstGen.zig:12215-12218).
     const uint32_t* fn_body = gzInstructionsSlice(&body_gz);
     uint32_t fn_body_len = gzInstructionsLen(&body_gz);
     gzUnstack(&body_gz);
 
     // Create func instruction (AstGen.zig:4476-4494).
     uint32_t func_ref = addFunc(&decl_gz, node, body_node, decl_inst, ret_ref,
         ret_body, ret_body_len, fn_body, fn_body_len, param_insts,
         param_insts_len, lbrace_line, lbrace_column, is_inferred_error);
 
     // Patch ret_body break_inline to point to func instruction
     // (AstGen.zig:12199-12202).
     if (ret_body_len > 0) {
         uint32_t break_inst = ret_body[ret_body_len - 1];
         // The break_inline payload is at payload_index; block_inst is at
         // offset 1 in the Break struct.
         uint32_t break_payload
             = ag->inst_datas[break_inst].break_data.payload_index;
         ag->extra[break_payload + 1] = func_ref - ZIR_REF_START_INDEX;
     }
     free(ret_body);
 
     // break_inline returning func to declaration (AstGen.zig:4495).
     // nodeIndexToRelative(decl_node) = node - decl_gz.decl_node_index.
     makeBreakInline(
         &decl_gz, decl_inst, func_ref, (int32_t)node - (int32_t)proto_node);
 
     // setDeclaration (AstGen.zig:4208-4225).
     DeclFlagsId decl_id
         = is_pub ? DECL_ID_PUB_CONST_SIMPLE : DECL_ID_CONST_SIMPLE;
     uint32_t name_str = identAsString(ag, fn_name_token);
     setDeclaration(ag, decl_inst,
         (SetDeclArgs) { .src_line = decl_line,
             .src_column = decl_column,
             .id = decl_id,
             .name = name_str,
             .lib_name = UINT32_MAX,
             .value_body = gzInstructionsSlice(&decl_gz),
             .value_body_len = gzInstructionsLen(&decl_gz) });
     gzUnstack(&decl_gz);
 
     (void)gz;
 }
 
 // --- comptimeDecl (AstGen.zig:4645) ---
 
 static void comptimeDecl(AstGenCtx* ag, GenZir* gz, uint32_t* wip_decl_insts,
     uint32_t* decl_idx, uint32_t node) {
     // makeDeclaration before advanceSourceCursorToNode (AstGen.zig:4663-4665).
     uint32_t decl_inst = makeDeclaration(ag, node);
     wip_decl_insts[*decl_idx] = decl_inst;
     (*decl_idx)++;
 
     advanceSourceCursorToNode(ag, node);
 
     uint32_t decl_line = ag->source_line;
     uint32_t decl_column = ag->source_column;
 
     // Value sub-block (AstGen.zig:4675-4686).
     GenZir value_gz;
     memset(&value_gz, 0, sizeof(value_gz));
     value_gz.base.tag = SCOPE_GEN_ZIR;
     value_gz.parent = NULL;
     value_gz.astgen = ag;
     value_gz.decl_node_index = node;
     value_gz.decl_line = decl_line;
     value_gz.is_comptime = true;
     value_gz.instructions_top = ag->scratch_inst_len;
 
     // For comptime {}: body is empty block → no instructions generated.
     // comptime_gz.isEmpty() == true → addBreak(.break_inline, decl_inst,
     // .void_value) (AstGen.zig:4685-4686)
     makeBreakInline(
         &value_gz, decl_inst, ZIR_REF_VOID_VALUE, AST_NODE_OFFSET_NONE);
 
     setDeclaration(ag, decl_inst,
         (SetDeclArgs) { .src_line = decl_line,
             .src_column = decl_column,
             .id = DECL_ID_COMPTIME,
             .name = 0,
             .lib_name = UINT32_MAX,
             .value_body = gzInstructionsSlice(&value_gz),
             .value_body_len = gzInstructionsLen(&value_gz) });
     gzUnstack(&value_gz);
 
     (void)gz;
 }
 
 // --- globalVarDecl (AstGen.zig:4498) ---
 
 // Extract VarDecl fields from an AST node (Ast.zig:1326-1380).
 typedef struct {
     uint32_t mut_token;
     uint32_t type_node; // 0 = none
     uint32_t align_node; // 0 = none
     uint32_t addrspace_node; // 0 = none
     uint32_t section_node; // 0 = none
     uint32_t init_node; // UINT32_MAX = none
     bool is_pub;
     bool is_extern;
     bool is_export;
     bool is_mutable;
     bool is_threadlocal;
     uint32_t lib_name_token; // UINT32_MAX = none
 } VarDeclInfo;
 
 static VarDeclInfo extractVarDecl(const Ast* tree, uint32_t node) {
     AstNodeTag tag = tree->nodes.tags[node];
     AstData nd = tree->nodes.datas[node];
     uint32_t mut_token = tree->nodes.main_tokens[node];
     VarDeclInfo info;
     memset(&info, 0, sizeof(info));
     info.mut_token = mut_token;
     info.init_node = UINT32_MAX;
     info.lib_name_token = UINT32_MAX;
 
     switch (tag) {
     case AST_NODE_SIMPLE_VAR_DECL:
         // lhs = type_node (optional), rhs = init_node (optional)
         info.type_node = nd.lhs;
         info.init_node = nd.rhs;
         break;
     case AST_NODE_ALIGNED_VAR_DECL:
         // lhs = align_node, rhs = init_node (optional)
         info.align_node = nd.lhs;
         info.init_node = nd.rhs;
         break;
     case AST_NODE_GLOBAL_VAR_DECL: {
         // lhs = extra_data index, rhs = init_node (optional)
         uint32_t ei = nd.lhs;
         info.type_node = tree->extra_data.arr[ei + 0];
         info.align_node = tree->extra_data.arr[ei + 1];
         info.addrspace_node = tree->extra_data.arr[ei + 2];
         info.section_node = tree->extra_data.arr[ei + 3];
         info.init_node = nd.rhs;
         break;
     }
     case AST_NODE_LOCAL_VAR_DECL: {
         // lhs = extra_data index, rhs = init_node (optional)
         uint32_t ei = nd.lhs;
         info.type_node = tree->extra_data.arr[ei + 0];
         info.align_node = tree->extra_data.arr[ei + 1];
         info.init_node = nd.rhs;
         break;
     }
     default:
         break;
     }
 
     // Scan backwards from mut_token to find modifiers (Ast.zig:2003-2025).
     info.is_mutable = (tree->tokens.tags[mut_token] == TOKEN_KEYWORD_VAR);
     for (uint32_t i = mut_token; i > 0;) {
         i--;
         TokenizerTag ttag = tree->tokens.tags[i];
         if (ttag == TOKEN_KEYWORD_EXTERN)
             info.is_extern = true;
         else if (ttag == TOKEN_KEYWORD_EXPORT)
             info.is_export = true;
         else if (ttag == TOKEN_KEYWORD_PUB)
             info.is_pub = true;
         else if (ttag == TOKEN_KEYWORD_THREADLOCAL)
             info.is_threadlocal = true;
         else if (ttag == TOKEN_STRING_LITERAL)
             info.lib_name_token = i;
         else
             break;
     }
     return info;
 }
 
 // Compute DeclFlagsId from VarDecl properties (AstGen.zig:13916-13972).
 static DeclFlagsId computeVarDeclId(bool is_mutable, bool is_pub,
     bool is_extern, bool is_export, bool is_threadlocal, bool has_type_body,
     bool has_special_body, bool has_lib_name) {
     if (!is_mutable) {
         // const
         if (is_extern) {
             if (is_pub) {
                 if (has_lib_name || has_special_body)
                     return DECL_ID_PUB_EXTERN_CONST;
                 return DECL_ID_PUB_EXTERN_CONST_SIMPLE;
             }
             if (has_lib_name || has_special_body)
                 return DECL_ID_EXTERN_CONST;
             return DECL_ID_EXTERN_CONST_SIMPLE;
         }
         if (is_export)
             return is_pub ? DECL_ID_PUB_EXPORT_CONST : DECL_ID_EXPORT_CONST;
         if (is_pub) {
             if (has_special_body)
                 return DECL_ID_PUB_CONST;
             if (has_type_body)
                 return DECL_ID_PUB_CONST_TYPED;
             return DECL_ID_PUB_CONST_SIMPLE;
         }
         if (has_special_body)
             return DECL_ID_CONST;
         if (has_type_body)
             return DECL_ID_CONST_TYPED;
         return DECL_ID_CONST_SIMPLE;
     }
     // var
     if (is_extern) {
         if (is_pub) {
             if (is_threadlocal)
                 return DECL_ID_PUB_EXTERN_VAR_THREADLOCAL;
             return DECL_ID_PUB_EXTERN_VAR;
         }
         if (is_threadlocal)
             return DECL_ID_EXTERN_VAR_THREADLOCAL;
         return DECL_ID_EXTERN_VAR;
     }
     if (is_export) {
         if (is_pub) {
             if (is_threadlocal)
                 return DECL_ID_PUB_EXPORT_VAR_THREADLOCAL;
             return DECL_ID_PUB_EXPORT_VAR;
         }
         if (is_threadlocal)
             return DECL_ID_EXPORT_VAR_THREADLOCAL;
         return DECL_ID_EXPORT_VAR;
     }
     if (is_pub) {
         if (is_threadlocal)
             return DECL_ID_PUB_VAR_THREADLOCAL;
         if (has_special_body || has_type_body)
             return DECL_ID_PUB_VAR;
         return DECL_ID_PUB_VAR_SIMPLE;
     }
     if (is_threadlocal)
         return DECL_ID_VAR_THREADLOCAL;
     if (has_special_body || has_type_body)
         return DECL_ID_VAR;
     return DECL_ID_VAR_SIMPLE;
 }
 
 static void globalVarDecl(AstGenCtx* ag, GenZir* gz, uint32_t* wip_decl_insts,
     uint32_t* decl_idx, uint32_t node) {
     const Ast* tree = ag->tree;
     VarDeclInfo vd = extractVarDecl(tree, node);
     uint32_t name_token = vd.mut_token + 1;
 
     // advanceSourceCursorToNode before makeDeclaration (AstGen.zig:4542-4546).
     advanceSourceCursorToNode(ag, node);
     uint32_t decl_column = ag->source_column;
 
     uint32_t decl_inst = makeDeclaration(ag, node);
     wip_decl_insts[*decl_idx] = decl_inst;
     (*decl_idx)++;
 
     // Set up type sub-block (AstGen.zig:4574-4582).
     GenZir type_gz;
     memset(&type_gz, 0, sizeof(type_gz));
     type_gz.base.tag = SCOPE_GEN_ZIR;
     type_gz.astgen = ag;
     type_gz.decl_node_index = node;
     type_gz.instructions_top = ag->scratch_inst_len;
     type_gz.decl_line = ag->source_line;
     type_gz.is_comptime = true;
 
     if (vd.type_node != 0) {
         uint32_t type_inst = typeExpr(&type_gz, &type_gz.base, vd.type_node);
         makeBreakInline(&type_gz, decl_inst, type_inst, 0);
     }
 
     // Record type_gz boundary for slicing.
     uint32_t type_top = ag->scratch_inst_len;
 
     // Align sub-block (AstGen.zig:4592-4596).
     GenZir align_gz;
     memset(&align_gz, 0, sizeof(align_gz));
     align_gz.base.tag = SCOPE_GEN_ZIR;
     align_gz.astgen = ag;
     align_gz.decl_node_index = node;
     align_gz.instructions_top = type_top;
     align_gz.decl_line = ag->source_line;
     align_gz.is_comptime = true;
 
     if (vd.align_node != 0) {
         uint32_t align_inst = expr(&align_gz, &align_gz.base, vd.align_node);
         makeBreakInline(&align_gz, decl_inst, align_inst, 0);
     }
 
     uint32_t align_top = ag->scratch_inst_len;
 
     // Linksection sub-block (AstGen.zig:4598-4602).
     GenZir linksection_gz;
     memset(&linksection_gz, 0, sizeof(linksection_gz));
     linksection_gz.base.tag = SCOPE_GEN_ZIR;
     linksection_gz.astgen = ag;
     linksection_gz.decl_node_index = node;
     linksection_gz.instructions_top = align_top;
     linksection_gz.decl_line = ag->source_line;
     linksection_gz.is_comptime = true;
 
     if (vd.section_node != 0) {
         uint32_t ls_inst
             = expr(&linksection_gz, &linksection_gz.base, vd.section_node);
         makeBreakInline(&linksection_gz, decl_inst, ls_inst, 0);
     }
 
     uint32_t linksection_top = ag->scratch_inst_len;
 
     // Addrspace sub-block (AstGen.zig:4604-4608).
     GenZir addrspace_gz;
     memset(&addrspace_gz, 0, sizeof(addrspace_gz));
     addrspace_gz.base.tag = SCOPE_GEN_ZIR;
     addrspace_gz.astgen = ag;
     addrspace_gz.decl_node_index = node;
     addrspace_gz.instructions_top = linksection_top;
     addrspace_gz.decl_line = ag->source_line;
     addrspace_gz.is_comptime = true;
 
     if (vd.addrspace_node != 0) {
         uint32_t as_inst
             = expr(&addrspace_gz, &addrspace_gz.base, vd.addrspace_node);
         makeBreakInline(&addrspace_gz, decl_inst, as_inst, 0);
     }
 
     uint32_t addrspace_top = ag->scratch_inst_len;
 
     // Value sub-block (AstGen.zig:4610-4620).
     GenZir value_gz;
     memset(&value_gz, 0, sizeof(value_gz));
     value_gz.base.tag = SCOPE_GEN_ZIR;
     value_gz.astgen = ag;
     value_gz.decl_node_index = node;
     value_gz.instructions_top = addrspace_top;
     value_gz.decl_line = ag->source_line;
     value_gz.is_comptime = true;
 
     if (vd.init_node != UINT32_MAX && vd.init_node != 0) {
         uint32_t init_ref = expr(&value_gz, &value_gz.base, vd.init_node);
         makeBreakInline(&value_gz, decl_inst, init_ref, 0);
     }
 
     // Compute body slices (instructionsSliceUpto).
     const uint32_t* type_body
         = ag->scratch_instructions + type_gz.instructions_top;
     uint32_t type_body_len = type_top - type_gz.instructions_top;
     const uint32_t* align_body
         = ag->scratch_instructions + align_gz.instructions_top;
     uint32_t align_body_len = align_top - align_gz.instructions_top;
     const uint32_t* ls_body
         = ag->scratch_instructions + linksection_gz.instructions_top;
     uint32_t ls_body_len = linksection_top - linksection_gz.instructions_top;
     const uint32_t* as_body
         = ag->scratch_instructions + addrspace_gz.instructions_top;
     uint32_t as_body_len = addrspace_top - addrspace_gz.instructions_top;
     const uint32_t* val_body = gzInstructionsSlice(&value_gz);
     uint32_t val_body_len = gzInstructionsLen(&value_gz);
 
     bool has_type_body = (type_body_len > 0);
     bool has_special_body
         = (align_body_len > 0 || ls_body_len > 0 || as_body_len > 0);
     bool has_lib_name = (vd.lib_name_token != UINT32_MAX);
 
     uint32_t name_str = identAsString(ag, name_token);
 
     DeclFlagsId decl_id = computeVarDeclId(vd.is_mutable, vd.is_pub,
         vd.is_extern, vd.is_export, vd.is_threadlocal, has_type_body,
         has_special_body, has_lib_name);
 
     // Compute lib_name string index.
     uint32_t lib_name = UINT32_MAX;
     if (has_lib_name) {
         uint32_t li, ll;
         strLitAsString(ag, vd.lib_name_token, &li, &ll);
         lib_name = li;
     }
 
     setDeclaration(ag, decl_inst,
         (SetDeclArgs) { .src_line = ag->source_line,
             .src_column = decl_column,
             .id = decl_id,
             .name = name_str,
             .lib_name = lib_name,
             .type_body = type_body,
             .type_body_len = type_body_len,
             .align_body = align_body,
             .align_body_len = align_body_len,
             .linksection_body = ls_body,
             .linksection_body_len = ls_body_len,
             .addrspace_body = as_body,
             .addrspace_body_len = as_body_len,
             .value_body = val_body,
             .value_body_len = val_body_len });
 
     gzUnstack(&value_gz);
 
     (void)gz;
 }
 
 // --- nodeImpliesMoreThanOnePossibleValue (AstGen.zig:10548) ---
 // Check if an identifier is a primitive type with more than one value.
 static bool identImpliesMoreThanOnePossibleValue(
     const Ast* tree, uint32_t main_token) {
     uint32_t start = tree->tokens.starts[main_token];
     const char* src = tree->source + start;
     // Match known primitive types that have more than one possible value.
     // (AstGen.zig:10729-10766)
     if (src[0] == 'u' || src[0] == 'i') {
         // u8, u16, u32, u64, u128, u1, u29, usize, i8, i16, i32, i64, i128,
         // isize
         char c1 = src[1];
         if (c1 >= '0' && c1 <= '9')
             return true;
         if (c1 == 's') // usize, isize
             return (src[2] == 'i' && src[3] == 'z' && src[4] == 'e');
     }
     if (src[0] == 'f') {
         // f16, f32, f64, f80, f128
         char c1 = src[1];
         if (c1 >= '0' && c1 <= '9')
             return true;
     }
     if (src[0] == 'b' && src[1] == 'o' && src[2] == 'o' && src[3] == 'l'
         && !(src[4] >= 'a' && src[4] <= 'z')
         && !(src[4] >= 'A' && src[4] <= 'Z')
         && !(src[4] >= '0' && src[4] <= '9') && src[4] != '_')
         return true;
     if (src[0] == 'c' && src[1] == '_')
         return true; // c_int, c_long, etc.
     if (src[0] == 'a' && src[1] == 'n' && src[2] == 'y') {
         // anyerror, anyframe, anyopaque
         return true;
     }
     if (src[0] == 'c' && src[1] == 'o' && src[2] == 'm' && src[3] == 'p'
         && src[4] == 't' && src[5] == 'i' && src[6] == 'm' && src[7] == 'e')
         return true; // comptime_float, comptime_int
     if (src[0] == 't' && src[1] == 'y' && src[2] == 'p' && src[3] == 'e'
         && !(src[4] >= 'a' && src[4] <= 'z')
         && !(src[4] >= 'A' && src[4] <= 'Z')
         && !(src[4] >= '0' && src[4] <= '9') && src[4] != '_')
         return true;
     return false;
 }
 
 static bool nodeImpliesMoreThanOnePossibleValue(
     const Ast* tree, uint32_t node) {
     uint32_t cur = node;
     while (1) {
         AstNodeTag tag = tree->nodes.tags[cur];
         switch (tag) {
         // Pointer/optional/array/anyframe types → true
         // (AstGen.zig:10718-10725)
         case AST_NODE_PTR_TYPE_ALIGNED:
         case AST_NODE_PTR_TYPE_SENTINEL:
         case AST_NODE_PTR_TYPE:
         case AST_NODE_PTR_TYPE_BIT_RANGE:
         case AST_NODE_OPTIONAL_TYPE:
         case AST_NODE_ANYFRAME_TYPE:
         case AST_NODE_ARRAY_TYPE_SENTINEL:
             return true;
         // Forward to LHS: try, comptime, nosuspend
         // (AstGen.zig:10710-10713)
         case AST_NODE_TRY:
         case AST_NODE_COMPTIME:
         case AST_NODE_NOSUSPEND:
             cur = tree->nodes.datas[cur].lhs;
             continue;
         // Forward to LHS: grouped_expression, unwrap_optional
         // (AstGen.zig:10714-10716)
         case AST_NODE_GROUPED_EXPRESSION:
         case AST_NODE_UNWRAP_OPTIONAL:
             cur = tree->nodes.datas[cur].lhs;
             continue;
         // Identifier: check primitives (AstGen.zig:10727-10780)
         case AST_NODE_IDENTIFIER:
             return identImpliesMoreThanOnePossibleValue(
                 tree, tree->nodes.main_tokens[cur]);
         default:
             return false;
         }
     }
 }
 
 // --- nodeImpliesComptimeOnly (AstGen.zig:10787) ---
 
 static bool identImpliesComptimeOnly(const Ast* tree, uint32_t main_token) {
     uint32_t start = tree->tokens.starts[main_token];
     const char* src = tree->source + start;
     // Only comptime_float, comptime_int, type → true
     // (AstGen.zig:11010-11013)
     if (src[0] == 'c' && src[1] == 'o' && src[2] == 'm' && src[3] == 'p'
         && src[4] == 't' && src[5] == 'i' && src[6] == 'm' && src[7] == 'e')
         return true; // comptime_float, comptime_int
     if (src[0] == 't' && src[1] == 'y' && src[2] == 'p' && src[3] == 'e'
         && !(src[4] >= 'a' && src[4] <= 'z')
         && !(src[4] >= 'A' && src[4] <= 'Z')
         && !(src[4] >= '0' && src[4] <= '9') && src[4] != '_')
         return true;
     return false;
 }
 
 static bool nodeImpliesComptimeOnly(const Ast* tree, uint32_t node) {
     uint32_t cur = node;
     while (1) {
         AstNodeTag tag = tree->nodes.tags[cur];
         switch (tag) {
         // Function prototypes → true (AstGen.zig:10950-10955)
         case AST_NODE_FN_PROTO_SIMPLE:
         case AST_NODE_FN_PROTO_MULTI:
         case AST_NODE_FN_PROTO_ONE:
         case AST_NODE_FN_PROTO:
             return true;
         // Forward to LHS: try, comptime, nosuspend
         case AST_NODE_TRY:
         case AST_NODE_COMPTIME:
         case AST_NODE_NOSUSPEND:
             cur = tree->nodes.datas[cur].lhs;
             continue;
         case AST_NODE_GROUPED_EXPRESSION:
         case AST_NODE_UNWRAP_OPTIONAL:
             cur = tree->nodes.datas[cur].lhs;
             continue;
         // Identifier: check primitives
         case AST_NODE_IDENTIFIER:
             return identImpliesComptimeOnly(
                 tree, tree->nodes.main_tokens[cur]);
         default:
             return false;
         }
     }
 }
 
 // --- WipMembers (AstGen.zig:3989) ---
 // Tracks decl indices, field bit-flags, and per-field data during container
 // processing. All data lives in a single malloc'd array laid out as:
 //   [decls (decl_count)] [field_bits (ceil)] [fields (up to field_count*max)]
 // Bodies are tracked separately in a dynamic array.
 
 typedef struct {
     uint32_t* payload; // malloc'd array
     uint32_t payload_top; // always 0 (start of decls region)
     uint32_t field_bits_start;
     uint32_t fields_start;
     uint32_t fields_end;
     uint32_t decl_index;
     uint32_t field_index;
     // Bodies scratch: dynamically grown array for field type/align/init
     // bodies.
     uint32_t* bodies;
     uint32_t bodies_len;
     uint32_t bodies_cap;
 } WipMembers;
 
 static WipMembers wipMembersInit(uint32_t decl_count, uint32_t field_count) {
     // bits_per_field = 4, max_field_size = 5
     uint32_t fields_per_u32 = 8; // 32 / 4
     uint32_t field_bits_start = decl_count;
     uint32_t bit_words = field_count > 0
         ? (field_count + fields_per_u32 - 1) / fields_per_u32
         : 0;
     uint32_t fields_start = field_bits_start + bit_words;
     uint32_t payload_end = fields_start + field_count * 5;
     uint32_t alloc_size = payload_end > 0 ? payload_end : 1;
     uint32_t* payload = calloc(alloc_size, sizeof(uint32_t));
     if (!payload)
         exit(1);
     WipMembers wm;
     memset(&wm, 0, sizeof(wm));
     wm.payload = payload;
     wm.payload_top = 0;
     wm.field_bits_start = field_bits_start;
     wm.fields_start = fields_start;
     wm.fields_end = fields_start;
     wm.decl_index = 0;
     wm.field_index = 0;
     wm.bodies = NULL;
     wm.bodies_len = 0;
     wm.bodies_cap = 0;
     return wm;
 }
 
 static void wipMembersDeinit(WipMembers* wm) {
     free(wm->payload);
     free(wm->bodies);
 }
 
 static void wipMembersNextDecl(WipMembers* wm, uint32_t decl_inst) {
     wm->payload[wm->payload_top + wm->decl_index] = decl_inst;
     wm->decl_index++;
 }
 
 // bits_per_field = 4: bits[0]=have_align, bits[1]=have_value,
 // bits[2]=is_comptime, bits[3]=have_type_body
 static void wipMembersNextField(WipMembers* wm, bool bits[4]) {
     uint32_t fields_per_u32 = 8; // 32 / 4
     uint32_t index = wm->field_bits_start + wm->field_index / fields_per_u32;
     uint32_t bit_bag
         = (wm->field_index % fields_per_u32 == 0) ? 0 : wm->payload[index];
     bit_bag >>= 4;
     for (int i = 0; i < 4; i++) {
         bit_bag |= ((uint32_t)(bits[i] ? 1 : 0)) << (32 - 4 + i);
     }
     wm->payload[index] = bit_bag;
     wm->field_index++;
 }
 
 static void wipMembersAppendToField(WipMembers* wm, uint32_t data) {
     wm->payload[wm->fields_end] = data;
     wm->fields_end++;
 }
 
 static void wipMembersFinishBits(WipMembers* wm) {
     uint32_t fields_per_u32 = 8; // 32 / 4
     uint32_t empty_field_slots
         = fields_per_u32 - (wm->field_index % fields_per_u32);
     if (wm->field_index > 0 && empty_field_slots < fields_per_u32) {
         uint32_t index
             = wm->field_bits_start + wm->field_index / fields_per_u32;
         wm->payload[index] >>= (empty_field_slots * 4);
     }
 }
 
 // Returns pointer to decls region and its length.
 static const uint32_t* wipMembersDeclsSlice(
     const WipMembers* wm, uint32_t* out_len) {
     *out_len = wm->decl_index;
     return wm->payload + wm->payload_top;
 }
 
 // Returns pointer to fields region (field_bits + field_data) and its length.
 static const uint32_t* wipMembersFieldsSlice(
     const WipMembers* wm, uint32_t* out_len) {
     *out_len = wm->fields_end - wm->field_bits_start;
     return wm->payload + wm->field_bits_start;
 }
 
 // Append body instructions to the WipMembers bodies scratch.
 static void wipMembersBodiesAppend(
     WipMembers* wm, const uint32_t* data, uint32_t len) {
     if (wm->bodies_len + len > wm->bodies_cap) {
         uint32_t new_cap = wm->bodies_cap == 0 ? 64 : wm->bodies_cap * 2;
         while (new_cap < wm->bodies_len + len)
             new_cap *= 2;
         wm->bodies = realloc(wm->bodies, new_cap * sizeof(uint32_t));
         if (!wm->bodies)
             exit(1);
         wm->bodies_cap = new_cap;
     }
     memcpy(wm->bodies + wm->bodies_len, data, len * sizeof(uint32_t));
     wm->bodies_len += len;
 }
 
 // Append body instructions with ref_table fixups to wm->bodies.
 static void wipMembersBodiesAppendWithFixups(
     WipMembers* wm, AstGenCtx* ag, const uint32_t* body, uint32_t body_len) {
     for (uint32_t i = 0; i < body_len; i++) {
         uint32_t inst = body[i];
         // Grow if needed.
         if (wm->bodies_len + 1 > wm->bodies_cap) {
             uint32_t new_cap = wm->bodies_cap == 0 ? 64 : wm->bodies_cap * 2;
             wm->bodies = realloc(wm->bodies, new_cap * sizeof(uint32_t));
             if (!wm->bodies)
                 exit(1);
             wm->bodies_cap = new_cap;
         }
         wm->bodies[wm->bodies_len++] = inst;
         // Check for ref fixup.
         uint32_t ref_inst;
         while (refTableFetchRemove(ag, inst, &ref_inst)) {
             if (wm->bodies_len + 1 > wm->bodies_cap) {
                 uint32_t new_cap = wm->bodies_cap * 2;
                 wm->bodies = realloc(wm->bodies, new_cap * sizeof(uint32_t));
                 if (!wm->bodies)
                     exit(1);
                 wm->bodies_cap = new_cap;
             }
             wm->bodies[wm->bodies_len++] = ref_inst;
             inst = ref_inst;
         }
     }
 }
 
 // --- containerDecl (AstGen.zig:5468) ---
 // Handles container declarations as expressions (struct{}, enum{}, etc.).
 
 static uint32_t containerDecl(GenZir* gz, Scope* scope, uint32_t node) {
     AstGenCtx* ag = gz->astgen;
     const Ast* tree = ag->tree;
     AstNodeTag tag = tree->nodes.tags[node];
     AstData nd = tree->nodes.datas[node];
 
     // Extract members based on node type (Ast.zig:2459-2470).
     uint32_t members_buf[2];
     const uint32_t* members;
     uint32_t members_len;
 
     switch (tag) {
     case AST_NODE_CONTAINER_DECL_TWO:
     case AST_NODE_CONTAINER_DECL_TWO_TRAILING:
     case AST_NODE_TAGGED_UNION_TWO:
     case AST_NODE_TAGGED_UNION_TWO_TRAILING: {
         // lhs and rhs are optional member nodes (0 = none).
         members_len = 0;
         if (nd.lhs != 0)
             members_buf[members_len++] = nd.lhs;
         if (nd.rhs != 0)
             members_buf[members_len++] = nd.rhs;
         members = members_buf;
         break;
     }
     case AST_NODE_CONTAINER_DECL:
     case AST_NODE_CONTAINER_DECL_TRAILING:
     case AST_NODE_TAGGED_UNION:
     case AST_NODE_TAGGED_UNION_TRAILING: {
         // extra_data[lhs..rhs] contains members.
         members = tree->extra_data.arr + nd.lhs;
         members_len = nd.rhs - nd.lhs;
         break;
     }
     case AST_NODE_CONTAINER_DECL_ARG:
     case AST_NODE_CONTAINER_DECL_ARG_TRAILING:
     case AST_NODE_TAGGED_UNION_ENUM_TAG:
     case AST_NODE_TAGGED_UNION_ENUM_TAG_TRAILING: {
         // lhs is arg node, rhs is extra index → SubRange(start, end).
         uint32_t start = tree->extra_data.arr[nd.rhs];
         uint32_t end = tree->extra_data.arr[nd.rhs + 1];
         members = tree->extra_data.arr + start;
         members_len = end - start;
         break;
     }
     default:
         SET_ERROR(ag);
         return ZIR_REF_VOID_VALUE;
     }
 
     // Save/clear fn_block for nested containers (AstGen.zig:5480-5482).
     void* prev_fn_block = ag->fn_block;
     ag->fn_block = NULL;
 
     // Dispatch based on container keyword (AstGen.zig:5485-5536).
     uint32_t main_token = tree->nodes.main_tokens[node];
     TokenizerTag kw_tag = tree->tokens.tags[main_token];
     uint32_t decl_inst;
     switch (kw_tag) {
     case TOKEN_KEYWORD_STRUCT:
         decl_inst = structDeclInner(ag, gz, node, members, members_len);
         break;
     case TOKEN_KEYWORD_ENUM:
         decl_inst = enumDeclInner(ag, gz, node, members, members_len);
         break;
     default:
         // union/opaque: fall back to struct for now.
         decl_inst = structDeclInner(ag, gz, node, members, members_len);
         break;
     }
     (void)scope;
 
     ag->fn_block = prev_fn_block;
     return decl_inst + ZIR_REF_START_INDEX;
 }
 
 // --- EnumDecl.Small packing (Zir.zig EnumDecl.Small) ---
 
 typedef struct {
     bool has_tag_type;
     bool has_captures_len;
     bool has_body_len;
     bool has_fields_len;
     bool has_decls_len;
     uint8_t name_strategy; // 2 bits
     bool nonexhaustive;
 } EnumDeclSmall;
 
 static uint16_t packEnumDeclSmall(EnumDeclSmall s) {
     uint16_t r = 0;
     if (s.has_tag_type)
         r |= (1u << 0);
     if (s.has_captures_len)
         r |= (1u << 1);
     if (s.has_body_len)
         r |= (1u << 2);
     if (s.has_fields_len)
         r |= (1u << 3);
     if (s.has_decls_len)
         r |= (1u << 4);
     r |= (uint16_t)(s.name_strategy & 0x3u) << 5;
     if (s.nonexhaustive)
         r |= (1u << 7);
     return r;
 }
 
 // Mirrors GenZir.setEnum (AstGen.zig:13080).
 static void setEnum(AstGenCtx* ag, uint32_t inst, uint32_t src_node,
     EnumDeclSmall small, uint32_t fields_len, uint32_t decls_len) {
     ensureExtraCapacity(ag, 6 + 3);
 
     uint32_t payload_index = ag->extra_len;
 
     // fields_hash (4 words): zero-filled.
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
     ag->extra[ag->extra_len++] = 0;
 
     ag->extra[ag->extra_len++] = ag->source_line;
     ag->extra[ag->extra_len++] = src_node;
 
     if (small.has_fields_len)
         ag->extra[ag->extra_len++] = fields_len;
     if (small.has_decls_len)
         ag->extra[ag->extra_len++] = decls_len;
 
     ag->inst_tags[inst] = ZIR_INST_EXTENDED;
     ZirInstData data;
     memset(&data, 0, sizeof(data));
     data.extended.opcode = (uint16_t)ZIR_EXT_ENUM_DECL;
     data.extended.small = packEnumDeclSmall(small);
     data.extended.operand = payload_index;
     ag->inst_datas[inst] = data;
 }
 
 // --- enumDeclInner (AstGen.zig:5508) ---
 
 static uint32_t enumDeclInner(AstGenCtx* ag, GenZir* gz, uint32_t node,
     const uint32_t* members, uint32_t members_len) {
     const Ast* tree = ag->tree;
     uint32_t decl_inst = reserveInstructionIndex(ag);
     gzAppendInstruction(gz, decl_inst);
 
     if (members_len == 0) {
         EnumDeclSmall small;
         memset(&small, 0, sizeof(small));
         setEnum(ag, decl_inst, node, small, 0, 0);
         return decl_inst;
     }
 
     advanceSourceCursorToNode(ag, node);
 
     uint32_t decl_count = scanContainer(ag, members, members_len);
     uint32_t field_count = members_len - decl_count;
 
     // Use WipMembers for decls and field data.
     // Enum fields: 1 bit per field (has_value), max 2 words per field
     // (name + value).
     WipMembers wm = wipMembersInit(decl_count, field_count);
 
     // Enum fields use 1 bit per field: has_value.
     // We use the same WipMembers but with 1-bit fields.
     // Actually, upstream uses bits_per_field=1, max_field_size=2.
     // Re-init with correct params would be better but let's reuse.
     // For simplicity: track field data manually.
     uint32_t* field_names = NULL;
     uint32_t field_names_len = 0;
     uint32_t field_names_cap = 0;
 
     for (uint32_t i = 0; i < members_len; i++) {
         uint32_t member_node = members[i];
         AstNodeTag mtag = tree->nodes.tags[member_node];
         switch (mtag) {
         case AST_NODE_COMPTIME:
             comptimeDecl(ag, gz, wm.payload, &wm.decl_index, member_node);
             break;
         case AST_NODE_SIMPLE_VAR_DECL:
         case AST_NODE_GLOBAL_VAR_DECL:
         case AST_NODE_LOCAL_VAR_DECL:
         case AST_NODE_ALIGNED_VAR_DECL:
             globalVarDecl(ag, gz, wm.payload, &wm.decl_index, member_node);
             break;
         case AST_NODE_FN_DECL:
             fnDecl(ag, gz, wm.payload, &wm.decl_index, member_node);
             break;
         case AST_NODE_TEST_DECL:
             testDecl(ag, gz, wm.payload, &wm.decl_index, member_node);
             break;
         case AST_NODE_CONTAINER_FIELD_INIT:
         case AST_NODE_CONTAINER_FIELD_ALIGN:
         case AST_NODE_CONTAINER_FIELD: {
             // Enum field: just a name (AstGen.zig:5617-5670).
             uint32_t main_token = tree->nodes.main_tokens[member_node];
             uint32_t field_name = identAsString(ag, main_token);
             // Grow field_names array.
             if (field_names_len >= field_names_cap) {
                 uint32_t new_cap
                     = field_names_cap == 0 ? 8 : field_names_cap * 2;
                 field_names = realloc(field_names, new_cap * sizeof(uint32_t));
                 if (!field_names)
                     exit(1);
                 field_names_cap = new_cap;
             }
             field_names[field_names_len++] = field_name;
             break;
         }
         default:
             SET_ERROR(ag);
             break;
         }
     }
 
     EnumDeclSmall small;
     memset(&small, 0, sizeof(small));
     small.has_fields_len = (field_count > 0);
     small.has_decls_len = (decl_count > 0);
     setEnum(ag, decl_inst, node, small, field_count, decl_count);
 
     // Append: decls, field_bits, field_names (AstGen.zig:5724-5729).
     uint32_t decls_len_out;
     const uint32_t* decls_slice = wipMembersDeclsSlice(&wm, &decls_len_out);
 
     // Field bits: 1 bit per field (has_value = false for simple enums).
     uint32_t fields_per_u32 = 32;
     uint32_t bit_words = field_count > 0
         ? (field_count + fields_per_u32 - 1) / fields_per_u32
         : 0;
 
     ensureExtraCapacity(ag, decls_len_out + bit_words + field_names_len);
     for (uint32_t i = 0; i < decls_len_out; i++)
         ag->extra[ag->extra_len++] = decls_slice[i];
     // Field bits: all zero (no values).
     for (uint32_t i = 0; i < bit_words; i++)
         ag->extra[ag->extra_len++] = 0;
     // Field names.
     for (uint32_t i = 0; i < field_names_len; i++)
         ag->extra[ag->extra_len++] = field_names[i];
 
     free(field_names);
     wipMembersDeinit(&wm);
     return decl_inst;
 }
 
 // --- structDeclInner (AstGen.zig:4926) ---
 
 static uint32_t structDeclInner(AstGenCtx* ag, GenZir* gz, uint32_t node,
     const uint32_t* members, uint32_t members_len) {
     const Ast* tree = ag->tree;
     uint32_t decl_inst = reserveInstructionIndex(ag);
     gzAppendInstruction(gz, decl_inst);
 
     // Fast path: no members, no backing int (AstGen.zig:4954-4970).
     if (members_len == 0) {
         StructDeclSmall small;
         memset(&small, 0, sizeof(small));
         setStruct(ag, decl_inst, node, small, 0, 0, 0);
         return decl_inst;
     }
 
     // Non-empty container (AstGen.zig:4973-5189).
     advanceSourceCursorToNode(ag, node);
 
     uint32_t decl_count = scanContainer(ag, members, members_len);
     uint32_t field_count = members_len - decl_count;
 
     WipMembers wm = wipMembersInit(decl_count, field_count);
 
     // Set up block_scope for field type/align/init expressions.
     // (AstGen.zig:4983-4992)
     GenZir block_scope;
     memset(&block_scope, 0, sizeof(block_scope));
     block_scope.base.tag = SCOPE_GEN_ZIR;
     block_scope.parent = NULL;
     block_scope.astgen = ag;
     block_scope.decl_node_index = node;
     block_scope.decl_line = ag->source_line;
     block_scope.is_comptime = true;
     block_scope.instructions_top = ag->scratch_inst_len;
 
     bool known_non_opv = false;
     bool known_comptime_only = false;
     bool any_comptime_fields = false;
     bool any_aligned_fields = false;
     bool any_default_inits = false;
 
     // Process each member (AstGen.zig:5060-5147).
     for (uint32_t i = 0; i < members_len; i++) {
         uint32_t member_node = members[i];
         AstNodeTag mtag = tree->nodes.tags[member_node];
         switch (mtag) {
         case AST_NODE_COMPTIME:
             comptimeDecl(ag, gz, wm.payload, &wm.decl_index, member_node);
             break;
         case AST_NODE_SIMPLE_VAR_DECL:
             globalVarDecl(ag, gz, wm.payload, &wm.decl_index, member_node);
             break;
         case AST_NODE_TEST_DECL:
             testDecl(ag, gz, wm.payload, &wm.decl_index, member_node);
             break;
         case AST_NODE_FN_DECL:
             fnDecl(ag, gz, wm.payload, &wm.decl_index, member_node);
             break;
         case AST_NODE_USINGNAMESPACE:
         case AST_NODE_GLOBAL_VAR_DECL:
         case AST_NODE_LOCAL_VAR_DECL:
         case AST_NODE_ALIGNED_VAR_DECL:
             globalVarDecl(ag, gz, wm.payload, &wm.decl_index, member_node);
             break;
         case AST_NODE_CONTAINER_FIELD_INIT:
         case AST_NODE_CONTAINER_FIELD_ALIGN:
         case AST_NODE_CONTAINER_FIELD: {
             // Extract field info from AST node (Ast.zig:1413-1454).
             uint32_t main_token = tree->nodes.main_tokens[member_node];
             AstData nd = tree->nodes.datas[member_node];
             uint32_t type_node = nd.lhs;
             uint32_t align_node = 0;
             uint32_t value_node = 0;
             bool has_comptime_token = false;
 
             switch (mtag) {
             case AST_NODE_CONTAINER_FIELD_INIT:
                 // lhs = type_expr, rhs = value_expr (optional, 0=none)
                 value_node = nd.rhs;
                 break;
             case AST_NODE_CONTAINER_FIELD_ALIGN:
                 // lhs = type_expr, rhs = align_expr
                 align_node = nd.rhs;
                 break;
             case AST_NODE_CONTAINER_FIELD:
                 // lhs = type_expr, rhs = extra index to {align, value}
                 if (nd.rhs != 0) {
                     align_node = tree->extra_data.arr[nd.rhs];
                     value_node = tree->extra_data.arr[nd.rhs + 1];
                 }
                 break;
             default:
                 break;
             }
 
             // Check for comptime token preceding main_token
             // (Ast.zig:2071-2082).
             if (main_token > 0
                 && tree->tokens.tags[main_token - 1]
                     == TOKEN_KEYWORD_COMPTIME) {
                 has_comptime_token = true;
             }
 
             // Field name (AstGen.zig:5080).
             uint32_t field_name = identAsString(ag, main_token);
             wipMembersAppendToField(&wm, field_name);
 
             // Type expression (AstGen.zig:5089-5109).
             bool have_type_body = false;
             uint32_t field_type = 0;
             if (type_node != 0) {
                 field_type
                     = typeExpr(&block_scope, &block_scope.base, type_node);
                 have_type_body = (gzInstructionsLen(&block_scope) > 0);
             }
 
             bool have_align = (align_node != 0);
             bool have_value = (value_node != 0);
             bool is_comptime = has_comptime_token;
 
             if (is_comptime) {
                 any_comptime_fields = true;
             } else {
                 // (AstGen.zig:5106-5109)
                 if (type_node != 0) {
                     known_non_opv = known_non_opv
                         || nodeImpliesMoreThanOnePossibleValue(
                             tree, type_node);
                     known_comptime_only = known_comptime_only
                         || nodeImpliesComptimeOnly(tree, type_node);
                 }
             }
 
             bool field_bits[4]
                 = { have_align, have_value, is_comptime, have_type_body };
             wipMembersNextField(&wm, field_bits);
 
             if (have_type_body) {
                 // Emit break_inline to carry the type value
                 // (AstGen.zig:5097-5099).
                 if (!endsWithNoReturn(&block_scope)) {
                     makeBreakInline(&block_scope, decl_inst, field_type,
                         AST_NODE_OFFSET_NONE);
                 }
                 uint32_t raw_len = gzInstructionsLen(&block_scope);
                 const uint32_t* body = gzInstructionsSlice(&block_scope);
                 uint32_t body_len = countBodyLenAfterFixups(ag, body, raw_len);
                 uint32_t bodies_before = wm.bodies_len;
                 wipMembersBodiesAppendWithFixups(&wm, ag, body, raw_len);
                 (void)bodies_before;
                 wipMembersAppendToField(&wm, body_len);
                 // Reset block_scope.
                 ag->scratch_inst_len = block_scope.instructions_top;
             } else {
                 wipMembersAppendToField(&wm, field_type);
             }
 
             if (have_align) {
                 any_aligned_fields = true;
                 uint32_t align_ref
                     = expr(&block_scope, &block_scope.base, align_node);
                 if (!endsWithNoReturn(&block_scope)) {
                     makeBreakInline(&block_scope, decl_inst, align_ref,
                         AST_NODE_OFFSET_NONE);
                 }
                 uint32_t raw_len = gzInstructionsLen(&block_scope);
                 const uint32_t* body = gzInstructionsSlice(&block_scope);
                 uint32_t body_len = countBodyLenAfterFixups(ag, body, raw_len);
                 wipMembersBodiesAppendWithFixups(&wm, ag, body, raw_len);
                 wipMembersAppendToField(&wm, body_len);
                 ag->scratch_inst_len = block_scope.instructions_top;
             }
 
             if (have_value) {
                 any_default_inits = true;
                 uint32_t default_ref
                     = expr(&block_scope, &block_scope.base, value_node);
                 if (!endsWithNoReturn(&block_scope)) {
                     makeBreakInline(&block_scope, decl_inst, default_ref,
                         AST_NODE_OFFSET_NONE);
                 }
                 uint32_t raw_len = gzInstructionsLen(&block_scope);
                 const uint32_t* body = gzInstructionsSlice(&block_scope);
                 uint32_t body_len = countBodyLenAfterFixups(ag, body, raw_len);
                 wipMembersBodiesAppendWithFixups(&wm, ag, body, raw_len);
                 wipMembersAppendToField(&wm, body_len);
                 ag->scratch_inst_len = block_scope.instructions_top;
             }
             break;
         }
         default:
             SET_ERROR(ag);
             break;
         }
     }
 
     wipMembersFinishBits(&wm);
 
     // setStruct (AstGen.zig:5152-5166).
     StructDeclSmall small;
     memset(&small, 0, sizeof(small));
     small.has_decls_len = (decl_count > 0);
     small.has_fields_len = (field_count > 0);
     small.known_non_opv = known_non_opv;
     small.known_comptime_only = known_comptime_only;
     small.any_comptime_fields = any_comptime_fields;
     small.any_default_inits = any_default_inits;
     small.any_aligned_fields = any_aligned_fields;
     setStruct(ag, decl_inst, node, small, 0, field_count, decl_count);
 
     // Append: captures (none), backing_int (none), decls, fields, bodies
     // (AstGen.zig:5176-5189).
     uint32_t decls_len;
     const uint32_t* decls_slice = wipMembersDeclsSlice(&wm, &decls_len);
     uint32_t fields_len;
     const uint32_t* fields_slice = wipMembersFieldsSlice(&wm, &fields_len);
 
     ensureExtraCapacity(ag, decls_len + fields_len + wm.bodies_len);
     for (uint32_t i = 0; i < decls_len; i++)
         ag->extra[ag->extra_len++] = decls_slice[i];
     for (uint32_t i = 0; i < fields_len; i++)
         ag->extra[ag->extra_len++] = fields_slice[i];
     for (uint32_t i = 0; i < wm.bodies_len; i++)
         ag->extra[ag->extra_len++] = wm.bodies[i];
 
     gzUnstack(&block_scope);
     wipMembersDeinit(&wm);
     return decl_inst;
 }
 
 // --- AstRlAnnotate (AstRlAnnotate.zig) ---
 // Pre-pass to determine which AST nodes need result locations.
 
 typedef struct {
     bool have_type;
     bool have_ptr;
 } RlResultInfo;
 
 #define RL_RI_NONE ((RlResultInfo) { false, false })
 #define RL_RI_TYPED_PTR ((RlResultInfo) { true, true })
 #define RL_RI_INFERRED_PTR ((RlResultInfo) { false, true })
 #define RL_RI_TYPE_ONLY ((RlResultInfo) { true, false })
 
 // Block for label tracking (AstRlAnnotate.zig:56-62).
 typedef struct RlBlock {
     struct RlBlock* parent;
     uint32_t label_token; // UINT32_MAX = no label
     bool is_loop;
     RlResultInfo ri;
     bool consumes_res_ptr;
 } RlBlock;
 
 static void nodesNeedRlAdd(AstGenCtx* ag, uint32_t node) {
     if (ag->nodes_need_rl_len >= ag->nodes_need_rl_cap) {
         uint32_t new_cap
             = ag->nodes_need_rl_cap == 0 ? 16 : ag->nodes_need_rl_cap * 2;
         ag->nodes_need_rl
             = realloc(ag->nodes_need_rl, new_cap * sizeof(uint32_t));
         ag->nodes_need_rl_cap = new_cap;
     }
     ag->nodes_need_rl[ag->nodes_need_rl_len++] = node;
 }
 
 static bool nodesNeedRlContains(const AstGenCtx* ag, uint32_t node) {
     for (uint32_t i = 0; i < ag->nodes_need_rl_len; i++) {
         if (ag->nodes_need_rl[i] == node)
             return true;
     }
     return false;
 }
 
 // Compare two identifier tokens by their source text.
 static bool rlTokenIdentEqual(
     const Ast* tree, uint32_t tok_a, uint32_t tok_b) {
     const char* src = tree->source;
     uint32_t a_start = tree->tokens.starts[tok_a];
     uint32_t b_start = tree->tokens.starts[tok_b];
     for (uint32_t i = 0;; i++) {
         char ca = src[a_start + i];
         char cb = src[b_start + i];
         bool a_id = (ca >= 'a' && ca <= 'z') || (ca >= 'A' && ca <= 'Z')
             || (ca >= '0' && ca <= '9') || ca == '_';
         bool b_id = (cb >= 'a' && cb <= 'z') || (cb >= 'A' && cb <= 'Z')
             || (cb >= '0' && cb <= '9') || cb == '_';
         if (!a_id && !b_id)
             return true;
         if (!a_id || !b_id)
             return false;
         if (ca != cb)
             return false;
     }
 }
 
 // Forward declarations.
 static bool rlExpr(
     AstGenCtx* ag, uint32_t node, RlBlock* block, RlResultInfo ri);
 static void rlContainerDecl(AstGenCtx* ag, RlBlock* block, uint32_t node);
 static bool rlBlockExpr(AstGenCtx* ag, RlBlock* parent_block, RlResultInfo ri,
     uint32_t node, const uint32_t* stmts, uint32_t count);
 static bool rlBuiltinCall(AstGenCtx* ag, RlBlock* block, uint32_t node,
     const uint32_t* args, uint32_t nargs);
 
 // containerDecl (AstRlAnnotate.zig:89-127).
 static void rlContainerDecl(AstGenCtx* ag, RlBlock* block, uint32_t node) {
     const Ast* tree = ag->tree;
     AstNodeTag tag = tree->nodes.tags[node];
     AstData nd = tree->nodes.datas[node];
 
     // Extract arg and members depending on variant.
     // All container decls: recurse arg with type_only, members with none.
     // (The keyword type — struct/union/enum/opaque — doesn't matter for RL.)
     uint32_t member_buf[2];
     const uint32_t* members = NULL;
     uint32_t members_len = 0;
     uint32_t arg_node = 0; // 0 = no arg
 
     switch (tag) {
     case AST_NODE_CONTAINER_DECL_TWO:
     case AST_NODE_CONTAINER_DECL_TWO_TRAILING:
     case AST_NODE_TAGGED_UNION_TWO:
     case AST_NODE_TAGGED_UNION_TWO_TRAILING: {
         uint32_t idx = 0;
         if (nd.lhs != 0)
             member_buf[idx++] = nd.lhs;
         if (nd.rhs != 0)
             member_buf[idx++] = nd.rhs;
         members = member_buf;
         members_len = idx;
         break;
     }
     case AST_NODE_CONTAINER_DECL:
     case AST_NODE_CONTAINER_DECL_TRAILING:
     case AST_NODE_TAGGED_UNION:
     case AST_NODE_TAGGED_UNION_TRAILING:
         members = tree->extra_data.arr + nd.lhs;
         members_len = nd.rhs - nd.lhs;
         break;
     case AST_NODE_CONTAINER_DECL_ARG:
     case AST_NODE_CONTAINER_DECL_ARG_TRAILING:
     case AST_NODE_TAGGED_UNION_ENUM_TAG:
     case AST_NODE_TAGGED_UNION_ENUM_TAG_TRAILING: {
         arg_node = nd.lhs;
         uint32_t extra_idx = nd.rhs;
         uint32_t start = tree->extra_data.arr[extra_idx];
         uint32_t end = tree->extra_data.arr[extra_idx + 1];
         members = tree->extra_data.arr + start;
         members_len = end - start;
         break;
     }
     default:
         return;
     }
 
     if (arg_node != 0)
         (void)rlExpr(ag, arg_node, block, RL_RI_TYPE_ONLY);
     for (uint32_t i = 0; i < members_len; i++)
         (void)rlExpr(ag, members[i], block, RL_RI_NONE);
 }
 
 // blockExpr (AstRlAnnotate.zig:787-814).
 static bool rlBlockExpr(AstGenCtx* ag, RlBlock* parent_block, RlResultInfo ri,
     uint32_t node, const uint32_t* stmts, uint32_t count) {
     const Ast* tree = ag->tree;
     uint32_t lbrace = tree->nodes.main_tokens[node];
     bool is_labeled
         = (lbrace >= 2 && tree->tokens.tags[lbrace - 1] == TOKEN_COLON
             && tree->tokens.tags[lbrace - 2] == TOKEN_IDENTIFIER);
 
     if (is_labeled) {
         RlBlock new_block;
         new_block.parent = parent_block;
         new_block.label_token = lbrace - 2;
         new_block.is_loop = false;
         new_block.ri = ri;
         new_block.consumes_res_ptr = false;
         for (uint32_t i = 0; i < count; i++)
             (void)rlExpr(ag, stmts[i], &new_block, RL_RI_NONE);
         if (new_block.consumes_res_ptr)
             nodesNeedRlAdd(ag, node);
         return new_block.consumes_res_ptr;
     } else {
         for (uint32_t i = 0; i < count; i++)
             (void)rlExpr(ag, stmts[i], parent_block, RL_RI_NONE);
         return false;
     }
 }
 
 // builtinCall (AstRlAnnotate.zig:816-1100).
 // Simplified: no builtin currently consumes its result location,
 // so we just recurse into all args with RL_RI_NONE.
 static bool rlBuiltinCall(AstGenCtx* ag, RlBlock* block, uint32_t node,
     const uint32_t* args, uint32_t nargs) {
     (void)node;
     for (uint32_t i = 0; i < nargs; i++)
         (void)rlExpr(ag, args[i], block, RL_RI_NONE);
     return false;
 }
 
 // expr (AstRlAnnotate.zig:130-771).
 static bool rlExpr(
     AstGenCtx* ag, uint32_t node, RlBlock* block, RlResultInfo ri) {
     const Ast* tree = ag->tree;
     AstNodeTag tag = tree->nodes.tags[node];
     AstData nd = tree->nodes.datas[node];
 
     switch (tag) {
     // Unreachable nodes (AstRlAnnotate.zig:133-142).
     case AST_NODE_ROOT:
     case AST_NODE_SWITCH_CASE_ONE:
     case AST_NODE_SWITCH_CASE_INLINE_ONE:
     case AST_NODE_SWITCH_CASE:
     case AST_NODE_SWITCH_CASE_INLINE:
     case AST_NODE_SWITCH_RANGE:
     case AST_NODE_FOR_RANGE:
     case AST_NODE_ASM_OUTPUT:
     case AST_NODE_ASM_INPUT:
         return false; // unreachable in upstream
 
     // errdefer (AstRlAnnotate.zig:144-147).
     case AST_NODE_ERRDEFER:
         (void)rlExpr(ag, nd.rhs, block, RL_RI_NONE);
         return false;
 
     // defer (AstRlAnnotate.zig:148-151).
     case AST_NODE_DEFER:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         return false;
 
     // container_field (AstRlAnnotate.zig:153-167).
     case AST_NODE_CONTAINER_FIELD_INIT: {
         // lhs = type_expr, rhs = value_expr
         if (nd.lhs != 0)
             (void)rlExpr(ag, nd.lhs, block, RL_RI_TYPE_ONLY);
         if (nd.rhs != 0)
             (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
     }
     case AST_NODE_CONTAINER_FIELD_ALIGN: {
         // lhs = type_expr, rhs = align_expr
         if (nd.lhs != 0)
             (void)rlExpr(ag, nd.lhs, block, RL_RI_TYPE_ONLY);
         if (nd.rhs != 0)
             (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
     }
     case AST_NODE_CONTAINER_FIELD: {
         // lhs = type_expr, rhs = extra index to {align_expr, value_expr}
         if (nd.lhs != 0)
             (void)rlExpr(ag, nd.lhs, block, RL_RI_TYPE_ONLY);
         if (nd.rhs != 0) {
             uint32_t align_node = tree->extra_data.arr[nd.rhs];
             uint32_t value_node = tree->extra_data.arr[nd.rhs + 1];
             if (align_node != 0)
                 (void)rlExpr(ag, align_node, block, RL_RI_TYPE_ONLY);
             if (value_node != 0)
                 (void)rlExpr(ag, value_node, block, RL_RI_TYPE_ONLY);
         }
         return false;
     }
 
     // test_decl (AstRlAnnotate.zig:168-171).
     case AST_NODE_TEST_DECL:
         (void)rlExpr(ag, nd.rhs, block, RL_RI_NONE);
         return false;
 
     // var_decl (AstRlAnnotate.zig:172-202).
     case AST_NODE_GLOBAL_VAR_DECL:
     case AST_NODE_LOCAL_VAR_DECL:
     case AST_NODE_SIMPLE_VAR_DECL:
     case AST_NODE_ALIGNED_VAR_DECL: {
         uint32_t type_node = 0;
         uint32_t init_node = 0;
         uint32_t mut_token = tree->nodes.main_tokens[node];
         if (tag == AST_NODE_SIMPLE_VAR_DECL) {
             type_node = nd.lhs;
             init_node = nd.rhs;
         } else if (tag == AST_NODE_LOCAL_VAR_DECL
             || tag == AST_NODE_GLOBAL_VAR_DECL) {
             type_node = tree->extra_data.arr[nd.lhs];
             init_node = nd.rhs;
         } else { // ALIGNED_VAR_DECL
             init_node = nd.rhs;
         }
         RlResultInfo init_ri;
         if (type_node != 0) {
             (void)rlExpr(ag, type_node, block, RL_RI_TYPE_ONLY);
             init_ri = RL_RI_TYPED_PTR;
         } else {
             init_ri = RL_RI_INFERRED_PTR;
         }
         if (init_node == 0)
             return false;
         bool is_const = (tree->source[tree->tokens.starts[mut_token]] == 'c');
         if (is_const) {
             bool init_consumes_rl = rlExpr(ag, init_node, block, init_ri);
             if (init_consumes_rl)
                 nodesNeedRlAdd(ag, node);
             return false;
         } else {
             (void)rlExpr(ag, init_node, block, init_ri);
             return false;
         }
     }
 
     // assign (AstRlAnnotate.zig:212-217).
     case AST_NODE_ASSIGN:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPED_PTR);
         return false;
 
     // compound assign (AstRlAnnotate.zig:218-240).
     case AST_NODE_ASSIGN_SHL:
     case AST_NODE_ASSIGN_SHL_SAT:
     case AST_NODE_ASSIGN_SHR:
     case AST_NODE_ASSIGN_BIT_AND:
     case AST_NODE_ASSIGN_BIT_OR:
     case AST_NODE_ASSIGN_BIT_XOR:
     case AST_NODE_ASSIGN_DIV:
     case AST_NODE_ASSIGN_SUB:
     case AST_NODE_ASSIGN_SUB_WRAP:
     case AST_NODE_ASSIGN_SUB_SAT:
     case AST_NODE_ASSIGN_MOD:
     case AST_NODE_ASSIGN_ADD:
     case AST_NODE_ASSIGN_ADD_WRAP:
     case AST_NODE_ASSIGN_ADD_SAT:
     case AST_NODE_ASSIGN_MUL:
     case AST_NODE_ASSIGN_MUL_WRAP:
     case AST_NODE_ASSIGN_MUL_SAT:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_NONE);
         return false;
 
     // shl/shr (AstRlAnnotate.zig:241-246).
     case AST_NODE_SHL:
     case AST_NODE_SHR:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
 
     // binary arithmetic/comparison (AstRlAnnotate.zig:247-274).
     case AST_NODE_ADD:
     case AST_NODE_ADD_WRAP:
     case AST_NODE_ADD_SAT:
     case AST_NODE_SUB:
     case AST_NODE_SUB_WRAP:
     case AST_NODE_SUB_SAT:
     case AST_NODE_MUL:
     case AST_NODE_MUL_WRAP:
     case AST_NODE_MUL_SAT:
     case AST_NODE_DIV:
     case AST_NODE_MOD:
     case AST_NODE_SHL_SAT:
     case AST_NODE_BIT_AND:
     case AST_NODE_BIT_OR:
     case AST_NODE_BIT_XOR:
     case AST_NODE_BANG_EQUAL:
     case AST_NODE_EQUAL_EQUAL:
     case AST_NODE_GREATER_THAN:
     case AST_NODE_GREATER_OR_EQUAL:
     case AST_NODE_LESS_THAN:
     case AST_NODE_LESS_OR_EQUAL:
     case AST_NODE_ARRAY_CAT:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_NONE);
         return false;
 
     // array_mult (AstRlAnnotate.zig:276-281).
     case AST_NODE_ARRAY_MULT:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
 
     // error_union, merge_error_sets (AstRlAnnotate.zig:282-287).
     case AST_NODE_ERROR_UNION:
     case AST_NODE_MERGE_ERROR_SETS:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_NONE);
         return false;
 
     // bool_and, bool_or (AstRlAnnotate.zig:288-295).
     case AST_NODE_BOOL_AND:
     case AST_NODE_BOOL_OR:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_TYPE_ONLY);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
 
     // bool_not (AstRlAnnotate.zig:296-299).
     case AST_NODE_BOOL_NOT:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_TYPE_ONLY);
         return false;
 
     // bit_not, negation, negation_wrap (AstRlAnnotate.zig:300-303).
     case AST_NODE_BIT_NOT:
     case AST_NODE_NEGATION:
     case AST_NODE_NEGATION_WRAP:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         return false;
 
     // Leaves (AstRlAnnotate.zig:305-320).
     case AST_NODE_IDENTIFIER:
     case AST_NODE_STRING_LITERAL:
     case AST_NODE_MULTILINE_STRING_LITERAL:
     case AST_NODE_NUMBER_LITERAL:
     case AST_NODE_UNREACHABLE_LITERAL:
     case AST_NODE_ASM_SIMPLE:
     case AST_NODE_ASM:
     case AST_NODE_ASM_LEGACY:
     case AST_NODE_ENUM_LITERAL:
     case AST_NODE_ERROR_VALUE:
     case AST_NODE_ANYFRAME_LITERAL:
     case AST_NODE_CONTINUE:
     case AST_NODE_CHAR_LITERAL:
     case AST_NODE_ERROR_SET_DECL:
         return false;
 
     // builtin_call (AstRlAnnotate.zig:322-330).
     case AST_NODE_BUILTIN_CALL_TWO:
     case AST_NODE_BUILTIN_CALL_TWO_COMMA: {
         uint32_t args[2];
         uint32_t nargs = 0;
         if (nd.lhs != 0)
             args[nargs++] = nd.lhs;
         if (nd.rhs != 0)
             args[nargs++] = nd.rhs;
         return rlBuiltinCall(ag, block, node, args, nargs);
     }
     case AST_NODE_BUILTIN_CALL:
     case AST_NODE_BUILTIN_CALL_COMMA: {
         uint32_t start = nd.lhs;
         uint32_t end = nd.rhs;
         return rlBuiltinCall(
             ag, block, node, tree->extra_data.arr + start, end - start);
     }
 
     // call (AstRlAnnotate.zig:332-351).
     case AST_NODE_CALL_ONE:
     case AST_NODE_CALL_ONE_COMMA: {
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         if (nd.rhs != 0)
             (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
     }
     case AST_NODE_CALL:
     case AST_NODE_CALL_COMMA: {
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         uint32_t start = tree->extra_data.arr[nd.rhs];
         uint32_t end = tree->extra_data.arr[nd.rhs + 1];
         for (uint32_t i = start; i < end; i++)
             (void)rlExpr(ag, tree->extra_data.arr[i], block, RL_RI_TYPE_ONLY);
         return false;
     }
 
     // return (AstRlAnnotate.zig:353-361).
     case AST_NODE_RETURN:
         if (nd.lhs != 0) {
             bool ret_consumes_rl = rlExpr(ag, nd.lhs, block, RL_RI_TYPED_PTR);
             if (ret_consumes_rl)
                 nodesNeedRlAdd(ag, node);
         }
         return false;
 
     // field_access (AstRlAnnotate.zig:363-367).
     case AST_NODE_FIELD_ACCESS:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         return false;
 
     // if_simple, if (AstRlAnnotate.zig:369-387).
     case AST_NODE_IF_SIMPLE:
     case AST_NODE_IF: {
         uint32_t cond_node = nd.lhs;
         uint32_t then_node, else_node = 0;
         if (tag == AST_NODE_IF_SIMPLE) {
             then_node = nd.rhs;
         } else {
             then_node = tree->extra_data.arr[nd.rhs];
             else_node = tree->extra_data.arr[nd.rhs + 1];
         }
         // Detect payload/error token.
         uint32_t last_cond_tok = lastToken(tree, cond_node);
         uint32_t pipe_tok = last_cond_tok + 2;
         bool has_payload = (pipe_tok < tree->tokens.len
             && tree->tokens.tags[pipe_tok] == TOKEN_PIPE);
         bool has_error = false;
         if (else_node != 0) {
             uint32_t else_tok = lastToken(tree, then_node) + 1;
             has_error = (else_tok + 1 < tree->tokens.len
                 && tree->tokens.tags[else_tok + 1] == TOKEN_PIPE);
         }
         if (has_error || has_payload)
             (void)rlExpr(ag, cond_node, block, RL_RI_NONE);
         else
             (void)rlExpr(ag, cond_node, block, RL_RI_TYPE_ONLY);
 
         if (else_node != 0) {
             bool then_uses = rlExpr(ag, then_node, block, ri);
             bool else_uses = rlExpr(ag, else_node, block, ri);
             bool uses_rl = then_uses || else_uses;
             if (uses_rl)
                 nodesNeedRlAdd(ag, node);
             return uses_rl;
         } else {
             (void)rlExpr(ag, then_node, block, RL_RI_NONE);
             return false;
         }
     }
 
     // while (AstRlAnnotate.zig:389-419).
     case AST_NODE_WHILE_SIMPLE:
     case AST_NODE_WHILE_CONT:
     case AST_NODE_WHILE: {
         uint32_t cond_node = nd.lhs;
         uint32_t body_node, cont_node = 0, else_node = 0;
         if (tag == AST_NODE_WHILE_SIMPLE) {
             body_node = nd.rhs;
         } else if (tag == AST_NODE_WHILE_CONT) {
             cont_node = tree->extra_data.arr[nd.rhs];
             body_node = tree->extra_data.arr[nd.rhs + 1];
         } else {
             cont_node = tree->extra_data.arr[nd.rhs];
             body_node = tree->extra_data.arr[nd.rhs + 1];
             else_node = tree->extra_data.arr[nd.rhs + 2];
         }
         uint32_t main_tok = tree->nodes.main_tokens[node];
         bool is_labeled
             = (main_tok >= 2 && tree->tokens.tags[main_tok - 1] == TOKEN_COLON
                 && tree->tokens.tags[main_tok - 2] == TOKEN_IDENTIFIER);
         uint32_t label_token = is_labeled ? main_tok - 2 : UINT32_MAX;
 
         // Detect payload/error.
         uint32_t last_cond_tok = lastToken(tree, cond_node);
         uint32_t pipe_tok = last_cond_tok + 2;
         bool has_payload = (pipe_tok < tree->tokens.len
             && tree->tokens.tags[pipe_tok] == TOKEN_PIPE);
         // Error token detection for while: check for else |err|.
         bool has_error = false;
         if (else_node != 0) {
             uint32_t else_tok = lastToken(tree, body_node) + 1;
             has_error = (else_tok + 1 < tree->tokens.len
                 && tree->tokens.tags[else_tok + 1] == TOKEN_PIPE);
         }
         if (has_error || has_payload)
             (void)rlExpr(ag, cond_node, block, RL_RI_NONE);
         else
             (void)rlExpr(ag, cond_node, block, RL_RI_TYPE_ONLY);
 
         RlBlock new_block;
         new_block.parent = block;
         new_block.label_token = label_token;
         new_block.is_loop = true;
         new_block.ri = ri;
         new_block.consumes_res_ptr = false;
 
         if (cont_node != 0)
             (void)rlExpr(ag, cont_node, &new_block, RL_RI_NONE);
         (void)rlExpr(ag, body_node, &new_block, RL_RI_NONE);
         bool else_consumes = false;
         if (else_node != 0)
             else_consumes = rlExpr(ag, else_node, block, ri);
         if (new_block.consumes_res_ptr || else_consumes) {
             nodesNeedRlAdd(ag, node);
             return true;
         }
         return false;
     }
 
     // for (AstRlAnnotate.zig:421-454).
     case AST_NODE_FOR_SIMPLE:
     case AST_NODE_FOR: {
         uint32_t input_buf[16];
         const uint32_t* inputs = NULL;
         uint32_t num_inputs = 0;
         uint32_t body_node = 0;
         uint32_t else_node = 0;
 
         if (tag == AST_NODE_FOR_SIMPLE) {
             input_buf[0] = nd.lhs;
             inputs = input_buf;
             num_inputs = 1;
             body_node = nd.rhs;
         } else {
             AstFor for_data;
             memcpy(&for_data, &nd.rhs, sizeof(AstFor));
             num_inputs = for_data.inputs;
             if (num_inputs > 16)
                 num_inputs = 16;
             for (uint32_t i = 0; i < num_inputs; i++)
                 input_buf[i] = tree->extra_data.arr[nd.lhs + i];
             inputs = input_buf;
             body_node = tree->extra_data.arr[nd.lhs + num_inputs];
             if (for_data.has_else)
                 else_node = tree->extra_data.arr[nd.lhs + num_inputs + 1];
         }
 
         uint32_t main_tok = tree->nodes.main_tokens[node];
         bool is_labeled
             = (main_tok >= 2 && tree->tokens.tags[main_tok - 1] == TOKEN_COLON
                 && tree->tokens.tags[main_tok - 2] == TOKEN_IDENTIFIER);
         uint32_t label_token = is_labeled ? main_tok - 2 : UINT32_MAX;
 
         for (uint32_t i = 0; i < num_inputs; i++) {
             uint32_t input = inputs[i];
             if (tree->nodes.tags[input] == AST_NODE_FOR_RANGE) {
                 AstData range_nd = tree->nodes.datas[input];
                 (void)rlExpr(ag, range_nd.lhs, block, RL_RI_TYPE_ONLY);
                 if (range_nd.rhs != 0)
                     (void)rlExpr(ag, range_nd.rhs, block, RL_RI_TYPE_ONLY);
             } else {
                 (void)rlExpr(ag, input, block, RL_RI_NONE);
             }
         }
 
         RlBlock new_block;
         new_block.parent = block;
         new_block.label_token = label_token;
         new_block.is_loop = true;
         new_block.ri = ri;
         new_block.consumes_res_ptr = false;
 
         (void)rlExpr(ag, body_node, &new_block, RL_RI_NONE);
         bool else_consumes = false;
         if (else_node != 0)
             else_consumes = rlExpr(ag, else_node, block, ri);
         if (new_block.consumes_res_ptr || else_consumes) {
             nodesNeedRlAdd(ag, node);
             return true;
         }
         return false;
     }
 
     // slice (AstRlAnnotate.zig:456-480).
     case AST_NODE_SLICE_OPEN:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
     case AST_NODE_SLICE: {
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         uint32_t start = tree->extra_data.arr[nd.rhs];
         uint32_t end = tree->extra_data.arr[nd.rhs + 1];
         (void)rlExpr(ag, start, block, RL_RI_TYPE_ONLY);
         (void)rlExpr(ag, end, block, RL_RI_TYPE_ONLY);
         return false;
     }
     case AST_NODE_SLICE_SENTINEL: {
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         AstSliceSentinel ss;
         ss.start = tree->extra_data.arr[nd.rhs];
         ss.end = tree->extra_data.arr[nd.rhs + 1];
         ss.sentinel = tree->extra_data.arr[nd.rhs + 2];
         (void)rlExpr(ag, ss.start, block, RL_RI_TYPE_ONLY);
         if (ss.end != 0)
             (void)rlExpr(ag, ss.end, block, RL_RI_TYPE_ONLY);
         (void)rlExpr(ag, ss.sentinel, block, RL_RI_NONE);
         return false;
     }
 
     // deref (AstRlAnnotate.zig:481-484).
     case AST_NODE_DEREF:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         return false;
 
     // address_of (AstRlAnnotate.zig:485-488).
     case AST_NODE_ADDRESS_OF:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         return false;
 
     // optional_type (AstRlAnnotate.zig:489-492).
     case AST_NODE_OPTIONAL_TYPE:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_TYPE_ONLY);
         return false;
 
     // try, nosuspend (AstRlAnnotate.zig:493-495).
     case AST_NODE_TRY:
     case AST_NODE_NOSUSPEND:
         return rlExpr(ag, nd.lhs, block, ri);
 
     // grouped_expression, unwrap_optional (AstRlAnnotate.zig:496-498).
     case AST_NODE_GROUPED_EXPRESSION:
     case AST_NODE_UNWRAP_OPTIONAL:
         return rlExpr(ag, nd.lhs, block, ri);
 
     // block (AstRlAnnotate.zig:500-508).
     case AST_NODE_BLOCK_TWO:
     case AST_NODE_BLOCK_TWO_SEMICOLON: {
         uint32_t stmts[2];
         uint32_t count = 0;
         if (nd.lhs != 0)
             stmts[count++] = nd.lhs;
         if (nd.rhs != 0)
             stmts[count++] = nd.rhs;
         return rlBlockExpr(ag, block, ri, node, stmts, count);
     }
     case AST_NODE_BLOCK:
     case AST_NODE_BLOCK_SEMICOLON:
         return rlBlockExpr(ag, block, ri, node, tree->extra_data.arr + nd.lhs,
             nd.rhs - nd.lhs);
 
     // anyframe_type (AstRlAnnotate.zig:509-513).
     case AST_NODE_ANYFRAME_TYPE:
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
 
     // catch/orelse (AstRlAnnotate.zig:514-522).
     case AST_NODE_CATCH:
     case AST_NODE_ORELSE: {
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         bool rhs_consumes = rlExpr(ag, nd.rhs, block, ri);
         if (rhs_consumes)
             nodesNeedRlAdd(ag, node);
         return rhs_consumes;
     }
 
     // ptr_type (AstRlAnnotate.zig:524-546).
     case AST_NODE_PTR_TYPE_ALIGNED:
         if (nd.lhs != 0)
             (void)rlExpr(ag, nd.lhs, block, RL_RI_TYPE_ONLY);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
     case AST_NODE_PTR_TYPE_SENTINEL:
         if (nd.lhs != 0)
             (void)rlExpr(ag, nd.lhs, block, RL_RI_TYPE_ONLY);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
     case AST_NODE_PTR_TYPE: {
         AstPtrType pt;
         pt.sentinel = tree->extra_data.arr[nd.lhs];
         pt.align_node = tree->extra_data.arr[nd.lhs + 1];
         pt.addrspace_node = tree->extra_data.arr[nd.lhs + 2];
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         if (pt.sentinel != 0)
             (void)rlExpr(ag, pt.sentinel, block, RL_RI_TYPE_ONLY);
         if (pt.align_node != 0)
             (void)rlExpr(ag, pt.align_node, block, RL_RI_TYPE_ONLY);
         if (pt.addrspace_node != 0)
             (void)rlExpr(ag, pt.addrspace_node, block, RL_RI_TYPE_ONLY);
         return false;
     }
     case AST_NODE_PTR_TYPE_BIT_RANGE: {
         AstPtrTypeBitRange pt;
         pt.sentinel = tree->extra_data.arr[nd.lhs];
         pt.align_node = tree->extra_data.arr[nd.lhs + 1];
         pt.addrspace_node = tree->extra_data.arr[nd.lhs + 2];
         pt.bit_range_start = tree->extra_data.arr[nd.lhs + 3];
         pt.bit_range_end = tree->extra_data.arr[nd.lhs + 4];
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         if (pt.sentinel != 0)
             (void)rlExpr(ag, pt.sentinel, block, RL_RI_TYPE_ONLY);
         if (pt.align_node != 0)
             (void)rlExpr(ag, pt.align_node, block, RL_RI_TYPE_ONLY);
         if (pt.addrspace_node != 0)
             (void)rlExpr(ag, pt.addrspace_node, block, RL_RI_TYPE_ONLY);
         if (pt.bit_range_start != 0) {
             (void)rlExpr(ag, pt.bit_range_start, block, RL_RI_TYPE_ONLY);
             (void)rlExpr(ag, pt.bit_range_end, block, RL_RI_TYPE_ONLY);
         }
         return false;
     }
 
     // container_decl (AstRlAnnotate.zig:548-564).
     case AST_NODE_CONTAINER_DECL:
     case AST_NODE_CONTAINER_DECL_TRAILING:
     case AST_NODE_CONTAINER_DECL_ARG:
     case AST_NODE_CONTAINER_DECL_ARG_TRAILING:
     case AST_NODE_CONTAINER_DECL_TWO:
     case AST_NODE_CONTAINER_DECL_TWO_TRAILING:
     case AST_NODE_TAGGED_UNION:
     case AST_NODE_TAGGED_UNION_TRAILING:
     case AST_NODE_TAGGED_UNION_ENUM_TAG:
     case AST_NODE_TAGGED_UNION_ENUM_TAG_TRAILING:
     case AST_NODE_TAGGED_UNION_TWO:
     case AST_NODE_TAGGED_UNION_TWO_TRAILING:
         rlContainerDecl(ag, block, node);
         return false;
 
     // break (AstRlAnnotate.zig:566-596).
     case AST_NODE_BREAK: {
         uint32_t opt_label_tok = nd.lhs; // 0 = no label
         uint32_t rhs_node = nd.rhs; // 0 = void break
         if (rhs_node == 0)
             return false;
 
         RlBlock* opt_cur_block = block;
         if (opt_label_tok != 0) {
             // Labeled break: find matching block.
             while (opt_cur_block != NULL) {
                 if (opt_cur_block->label_token != UINT32_MAX
                     && rlTokenIdentEqual(
                         tree, opt_cur_block->label_token, opt_label_tok))
                     break;
                 opt_cur_block = opt_cur_block->parent;
             }
         } else {
             // No label: breaking from innermost loop.
             while (opt_cur_block != NULL) {
                 if (opt_cur_block->is_loop)
                     break;
                 opt_cur_block = opt_cur_block->parent;
             }
         }
 
         if (opt_cur_block != NULL) {
             bool consumes = rlExpr(ag, rhs_node, block, opt_cur_block->ri);
             if (consumes)
                 opt_cur_block->consumes_res_ptr = true;
         } else {
             (void)rlExpr(ag, rhs_node, block, RL_RI_NONE);
         }
         return false;
     }
 
     // array_type (AstRlAnnotate.zig:598-611).
     case AST_NODE_ARRAY_TYPE:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_TYPE_ONLY);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
     case AST_NODE_ARRAY_TYPE_SENTINEL: {
         (void)rlExpr(ag, nd.lhs, block, RL_RI_TYPE_ONLY);
         uint32_t elem_type = tree->extra_data.arr[nd.rhs + 1];
         uint32_t sentinel = tree->extra_data.arr[nd.rhs];
         (void)rlExpr(ag, elem_type, block, RL_RI_TYPE_ONLY);
         (void)rlExpr(ag, sentinel, block, RL_RI_TYPE_ONLY);
         return false;
     }
 
     // array_access (AstRlAnnotate.zig:612-617).
     case AST_NODE_ARRAY_ACCESS:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         (void)rlExpr(ag, nd.rhs, block, RL_RI_TYPE_ONLY);
         return false;
 
     // comptime (AstRlAnnotate.zig:618-623).
     case AST_NODE_COMPTIME:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         return false;
 
     // switch (AstRlAnnotate.zig:624-650).
     case AST_NODE_SWITCH:
     case AST_NODE_SWITCH_COMMA: {
         uint32_t cond_node = nd.lhs;
         uint32_t extra_idx = nd.rhs;
         uint32_t cases_start = tree->extra_data.arr[extra_idx];
         uint32_t cases_end = tree->extra_data.arr[extra_idx + 1];
 
         (void)rlExpr(ag, cond_node, block, RL_RI_NONE);
 
         bool any_consumed = false;
         for (uint32_t ci = cases_start; ci < cases_end; ci++) {
             uint32_t case_node = tree->extra_data.arr[ci];
             AstNodeTag ct = tree->nodes.tags[case_node];
             AstData cd = tree->nodes.datas[case_node];
 
             // Process case values.
             if (ct == AST_NODE_SWITCH_CASE_ONE
                 || ct == AST_NODE_SWITCH_CASE_INLINE_ONE) {
                 if (cd.lhs != 0) {
                     if (tree->nodes.tags[cd.lhs] == AST_NODE_SWITCH_RANGE) {
                         AstData rd = tree->nodes.datas[cd.lhs];
                         (void)rlExpr(ag, rd.lhs, block, RL_RI_NONE);
                         (void)rlExpr(ag, rd.rhs, block, RL_RI_NONE);
                     } else {
                         (void)rlExpr(ag, cd.lhs, block, RL_RI_NONE);
                     }
                 }
             } else {
                 // SWITCH_CASE / SWITCH_CASE_INLINE: SubRange[lhs]
                 uint32_t items_start = tree->extra_data.arr[cd.lhs];
                 uint32_t items_end = tree->extra_data.arr[cd.lhs + 1];
                 for (uint32_t ii = items_start; ii < items_end; ii++) {
                     uint32_t item = tree->extra_data.arr[ii];
                     if (tree->nodes.tags[item] == AST_NODE_SWITCH_RANGE) {
                         AstData rd = tree->nodes.datas[item];
                         (void)rlExpr(ag, rd.lhs, block, RL_RI_NONE);
                         (void)rlExpr(ag, rd.rhs, block, RL_RI_NONE);
                     } else {
                         (void)rlExpr(ag, item, block, RL_RI_NONE);
                     }
                 }
             }
             // Process case target expr.
             if (rlExpr(ag, cd.rhs, block, ri))
                 any_consumed = true;
         }
         if (any_consumed)
             nodesNeedRlAdd(ag, node);
         return any_consumed;
     }
 
     // suspend (AstRlAnnotate.zig:651-654).
     case AST_NODE_SUSPEND:
         if (nd.lhs != 0)
             (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         return false;
 
     // resume (AstRlAnnotate.zig:655-658).
     case AST_NODE_RESUME:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         return false;
 
     // array_init (AstRlAnnotate.zig:660-695).
     case AST_NODE_ARRAY_INIT_ONE:
     case AST_NODE_ARRAY_INIT_ONE_COMMA:
     case AST_NODE_ARRAY_INIT_DOT_TWO:
     case AST_NODE_ARRAY_INIT_DOT_TWO_COMMA:
     case AST_NODE_ARRAY_INIT_DOT:
     case AST_NODE_ARRAY_INIT_DOT_COMMA:
     case AST_NODE_ARRAY_INIT:
     case AST_NODE_ARRAY_INIT_COMMA: {
         // Extract type_expr and elements.
         uint32_t type_expr = 0;
         uint32_t elem_buf[2];
         const uint32_t* elems = NULL;
         uint32_t nelem = 0;
         switch (tag) {
         case AST_NODE_ARRAY_INIT_ONE:
         case AST_NODE_ARRAY_INIT_ONE_COMMA:
             type_expr = nd.lhs;
             if (nd.rhs != 0) {
                 elem_buf[0] = nd.rhs;
                 elems = elem_buf;
                 nelem = 1;
             }
             break;
         case AST_NODE_ARRAY_INIT_DOT_TWO:
         case AST_NODE_ARRAY_INIT_DOT_TWO_COMMA: {
             uint32_t idx = 0;
             if (nd.lhs != 0)
                 elem_buf[idx++] = nd.lhs;
             if (nd.rhs != 0)
                 elem_buf[idx++] = nd.rhs;
             elems = elem_buf;
             nelem = idx;
             break;
         }
         case AST_NODE_ARRAY_INIT_DOT:
         case AST_NODE_ARRAY_INIT_DOT_COMMA:
             elems = tree->extra_data.arr + nd.lhs;
             nelem = nd.rhs - nd.lhs;
             break;
         case AST_NODE_ARRAY_INIT:
         case AST_NODE_ARRAY_INIT_COMMA: {
             type_expr = nd.lhs;
             uint32_t start = tree->extra_data.arr[nd.rhs];
             uint32_t end = tree->extra_data.arr[nd.rhs + 1];
             elems = tree->extra_data.arr + start;
             nelem = end - start;
             break;
         }
         default:
             break;
         }
         if (type_expr != 0) {
             (void)rlExpr(ag, type_expr, block, RL_RI_NONE);
             for (uint32_t i = 0; i < nelem; i++)
                 (void)rlExpr(ag, elems[i], block, RL_RI_TYPE_ONLY);
             return false;
         }
         if (ri.have_type) {
             for (uint32_t i = 0; i < nelem; i++)
                 (void)rlExpr(ag, elems[i], block, ri);
             return ri.have_ptr;
         } else {
             for (uint32_t i = 0; i < nelem; i++)
                 (void)rlExpr(ag, elems[i], block, RL_RI_NONE);
             return false;
         }
     }
 
     // struct_init (AstRlAnnotate.zig:697-732).
     case AST_NODE_STRUCT_INIT_ONE:
     case AST_NODE_STRUCT_INIT_ONE_COMMA:
     case AST_NODE_STRUCT_INIT_DOT_TWO:
     case AST_NODE_STRUCT_INIT_DOT_TWO_COMMA:
     case AST_NODE_STRUCT_INIT_DOT:
     case AST_NODE_STRUCT_INIT_DOT_COMMA:
     case AST_NODE_STRUCT_INIT:
     case AST_NODE_STRUCT_INIT_COMMA: {
         uint32_t type_expr = 0;
         uint32_t field_buf[2];
         const uint32_t* fields = NULL;
         uint32_t nfields = 0;
         switch (tag) {
         case AST_NODE_STRUCT_INIT_ONE:
         case AST_NODE_STRUCT_INIT_ONE_COMMA:
             type_expr = nd.lhs;
             if (nd.rhs != 0) {
                 field_buf[0] = nd.rhs;
                 fields = field_buf;
                 nfields = 1;
             }
             break;
         case AST_NODE_STRUCT_INIT_DOT_TWO:
         case AST_NODE_STRUCT_INIT_DOT_TWO_COMMA: {
             uint32_t idx = 0;
             if (nd.lhs != 0)
                 field_buf[idx++] = nd.lhs;
             if (nd.rhs != 0)
                 field_buf[idx++] = nd.rhs;
             fields = field_buf;
             nfields = idx;
             break;
         }
         case AST_NODE_STRUCT_INIT_DOT:
         case AST_NODE_STRUCT_INIT_DOT_COMMA:
             fields = tree->extra_data.arr + nd.lhs;
             nfields = nd.rhs - nd.lhs;
             break;
         case AST_NODE_STRUCT_INIT:
         case AST_NODE_STRUCT_INIT_COMMA: {
             type_expr = nd.lhs;
             uint32_t start = tree->extra_data.arr[nd.rhs];
             uint32_t end = tree->extra_data.arr[nd.rhs + 1];
             fields = tree->extra_data.arr + start;
             nfields = end - start;
             break;
         }
         default:
             break;
         }
         if (type_expr != 0) {
             (void)rlExpr(ag, type_expr, block, RL_RI_NONE);
             for (uint32_t i = 0; i < nfields; i++)
                 (void)rlExpr(ag, fields[i], block, RL_RI_TYPE_ONLY);
             return false;
         }
         if (ri.have_type) {
             for (uint32_t i = 0; i < nfields; i++)
                 (void)rlExpr(ag, fields[i], block, ri);
             return ri.have_ptr;
         } else {
             for (uint32_t i = 0; i < nfields; i++)
                 (void)rlExpr(ag, fields[i], block, RL_RI_NONE);
             return false;
         }
     }
 
     // fn_proto, fn_decl (AstRlAnnotate.zig:734-770).
     case AST_NODE_FN_PROTO_SIMPLE:
     case AST_NODE_FN_PROTO_MULTI:
     case AST_NODE_FN_PROTO_ONE:
     case AST_NODE_FN_PROTO:
     case AST_NODE_FN_DECL: {
         // Extract return type and body.
         uint32_t return_type = 0;
         uint32_t body_node = 0;
 
         if (tag == AST_NODE_FN_DECL) {
             body_node = nd.rhs;
             // fn_proto is nd.lhs
             uint32_t proto = nd.lhs;
             AstNodeTag ptag = tree->nodes.tags[proto];
             AstData pnd = tree->nodes.datas[proto];
             if (ptag == AST_NODE_FN_PROTO_SIMPLE) {
                 return_type = pnd.rhs;
                 if (pnd.lhs != 0)
                     (void)rlExpr(ag, pnd.lhs, block, RL_RI_TYPE_ONLY);
             } else if (ptag == AST_NODE_FN_PROTO_MULTI) {
                 return_type = pnd.rhs;
                 uint32_t ps = tree->extra_data.arr[pnd.lhs];
                 uint32_t pe = tree->extra_data.arr[pnd.lhs + 1];
                 for (uint32_t i = ps; i < pe; i++)
                     (void)rlExpr(
                         ag, tree->extra_data.arr[i], block, RL_RI_TYPE_ONLY);
             } else if (ptag == AST_NODE_FN_PROTO_ONE) {
                 return_type = pnd.rhs;
                 AstFnProtoOne fp;
                 fp.param = tree->extra_data.arr[pnd.lhs];
                 fp.align_expr = tree->extra_data.arr[pnd.lhs + 1];
                 fp.addrspace_expr = tree->extra_data.arr[pnd.lhs + 2];
                 fp.section_expr = tree->extra_data.arr[pnd.lhs + 3];
                 fp.callconv_expr = tree->extra_data.arr[pnd.lhs + 4];
                 if (fp.param != 0)
                     (void)rlExpr(ag, fp.param, block, RL_RI_TYPE_ONLY);
                 if (fp.align_expr != 0)
                     (void)rlExpr(ag, fp.align_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.addrspace_expr != 0)
                     (void)rlExpr(
                         ag, fp.addrspace_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.section_expr != 0)
                     (void)rlExpr(ag, fp.section_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.callconv_expr != 0)
                     (void)rlExpr(ag, fp.callconv_expr, block, RL_RI_TYPE_ONLY);
             } else if (ptag == AST_NODE_FN_PROTO) {
                 return_type = pnd.rhs;
                 AstFnProto fp;
                 fp.params_start = tree->extra_data.arr[pnd.lhs];
                 fp.params_end = tree->extra_data.arr[pnd.lhs + 1];
                 fp.align_expr = tree->extra_data.arr[pnd.lhs + 2];
                 fp.addrspace_expr = tree->extra_data.arr[pnd.lhs + 3];
                 fp.section_expr = tree->extra_data.arr[pnd.lhs + 4];
                 fp.callconv_expr = tree->extra_data.arr[pnd.lhs + 5];
                 for (uint32_t i = fp.params_start; i < fp.params_end; i++)
                     (void)rlExpr(
                         ag, tree->extra_data.arr[i], block, RL_RI_TYPE_ONLY);
                 if (fp.align_expr != 0)
                     (void)rlExpr(ag, fp.align_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.addrspace_expr != 0)
                     (void)rlExpr(
                         ag, fp.addrspace_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.section_expr != 0)
                     (void)rlExpr(ag, fp.section_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.callconv_expr != 0)
                     (void)rlExpr(ag, fp.callconv_expr, block, RL_RI_TYPE_ONLY);
             }
         } else {
             // Standalone fn_proto (no body).
             if (tag == AST_NODE_FN_PROTO_SIMPLE) {
                 return_type = nd.rhs;
                 if (nd.lhs != 0)
                     (void)rlExpr(ag, nd.lhs, block, RL_RI_TYPE_ONLY);
             } else if (tag == AST_NODE_FN_PROTO_MULTI) {
                 return_type = nd.rhs;
                 uint32_t ps = tree->extra_data.arr[nd.lhs];
                 uint32_t pe = tree->extra_data.arr[nd.lhs + 1];
                 for (uint32_t i = ps; i < pe; i++)
                     (void)rlExpr(
                         ag, tree->extra_data.arr[i], block, RL_RI_TYPE_ONLY);
             } else if (tag == AST_NODE_FN_PROTO_ONE) {
                 return_type = nd.rhs;
                 AstFnProtoOne fp;
                 fp.param = tree->extra_data.arr[nd.lhs];
                 fp.align_expr = tree->extra_data.arr[nd.lhs + 1];
                 fp.addrspace_expr = tree->extra_data.arr[nd.lhs + 2];
                 fp.section_expr = tree->extra_data.arr[nd.lhs + 3];
                 fp.callconv_expr = tree->extra_data.arr[nd.lhs + 4];
                 if (fp.param != 0)
                     (void)rlExpr(ag, fp.param, block, RL_RI_TYPE_ONLY);
                 if (fp.align_expr != 0)
                     (void)rlExpr(ag, fp.align_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.addrspace_expr != 0)
                     (void)rlExpr(
                         ag, fp.addrspace_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.section_expr != 0)
                     (void)rlExpr(ag, fp.section_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.callconv_expr != 0)
                     (void)rlExpr(ag, fp.callconv_expr, block, RL_RI_TYPE_ONLY);
             } else if (tag == AST_NODE_FN_PROTO) {
                 return_type = nd.rhs;
                 AstFnProto fp;
                 fp.params_start = tree->extra_data.arr[nd.lhs];
                 fp.params_end = tree->extra_data.arr[nd.lhs + 1];
                 fp.align_expr = tree->extra_data.arr[nd.lhs + 2];
                 fp.addrspace_expr = tree->extra_data.arr[nd.lhs + 3];
                 fp.section_expr = tree->extra_data.arr[nd.lhs + 4];
                 fp.callconv_expr = tree->extra_data.arr[nd.lhs + 5];
                 for (uint32_t i = fp.params_start; i < fp.params_end; i++)
                     (void)rlExpr(
                         ag, tree->extra_data.arr[i], block, RL_RI_TYPE_ONLY);
                 if (fp.align_expr != 0)
                     (void)rlExpr(ag, fp.align_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.addrspace_expr != 0)
                     (void)rlExpr(
                         ag, fp.addrspace_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.section_expr != 0)
                     (void)rlExpr(ag, fp.section_expr, block, RL_RI_TYPE_ONLY);
                 if (fp.callconv_expr != 0)
                     (void)rlExpr(ag, fp.callconv_expr, block, RL_RI_TYPE_ONLY);
             }
         }
 
         if (return_type != 0)
             (void)rlExpr(ag, return_type, block, RL_RI_TYPE_ONLY);
         if (body_node != 0)
             (void)rlExpr(ag, body_node, block, RL_RI_NONE);
         return false;
     }
 
     // Remaining: usingnamespace, await, assign_destructure, async calls.
     case AST_NODE_USINGNAMESPACE:
         return false;
     case AST_NODE_AWAIT:
         (void)rlExpr(ag, nd.lhs, block, RL_RI_NONE);
         return false;
     case AST_NODE_ASSIGN_DESTRUCTURE:
         return false; // TODO if needed
     case AST_NODE_ASYNC_CALL_ONE:
     case AST_NODE_ASYNC_CALL_ONE_COMMA:
     case AST_NODE_ASYNC_CALL:
     case AST_NODE_ASYNC_CALL_COMMA:
         return false; // async not relevant
 
     default:
         return false;
     }
 }
 
 // astRlAnnotate (AstRlAnnotate.zig:64-83).
 // Entry point: run the RL annotation pre-pass.
 static void astRlAnnotate(AstGenCtx* ag) {
     const Ast* tree = ag->tree;
     if (tree->has_error)
         return;
 
     // Get root container members (same as in astGen).
     AstData root_data = tree->nodes.datas[0];
     uint32_t members_start = root_data.lhs;
     uint32_t members_end = root_data.rhs;
     const uint32_t* members = tree->extra_data.arr + members_start;
     uint32_t members_len = members_end - members_start;
 
     for (uint32_t i = 0; i < members_len; i++)
         (void)rlExpr(ag, members[i], NULL, RL_RI_NONE);
 }
 
 // --- Public API: astGen (AstGen.zig:144) ---
 
 Zir astGen(const Ast* ast) {
     AstGenCtx ag;
     memset(&ag, 0, sizeof(ag));
     ag.tree = ast;
 
     // Initial allocations (AstGen.zig:162-172).
     uint32_t nodes_len = ast->nodes.len;
     uint32_t init_cap = nodes_len > 8 ? nodes_len : 8;
 
     ag.inst_cap = init_cap;
     ag.inst_tags = ARR_INIT(ZirInstTag, ag.inst_cap);
     ag.inst_datas = ARR_INIT(ZirInstData, ag.inst_cap);
 
     ag.extra_cap = init_cap + ZIR_EXTRA_RESERVED_COUNT;
     ag.extra = ARR_INIT(uint32_t, ag.extra_cap);
 
     ag.string_bytes_cap = 16;
     ag.string_bytes = ARR_INIT(uint8_t, ag.string_bytes_cap);
 
     // String table index 0 is reserved for NullTerminatedString.empty
     // (AstGen.zig:163).
     ag.string_bytes[0] = 0;
     ag.string_bytes_len = 1;
 
     // Reserve extra[0..1] (AstGen.zig:170-172).
     ag.extra[ZIR_EXTRA_COMPILE_ERRORS] = 0;
     ag.extra[ZIR_EXTRA_IMPORTS] = 0;
     ag.extra_len = ZIR_EXTRA_RESERVED_COUNT;
 
     // Run AstRlAnnotate pre-pass (AstGen.zig:150-151).
     astRlAnnotate(&ag);
 
     // Set up root GenZir scope (AstGen.zig:176-185).
     GenZir gen_scope;
     memset(&gen_scope, 0, sizeof(gen_scope));
     gen_scope.base.tag = SCOPE_GEN_ZIR;
     gen_scope.parent = NULL;
     gen_scope.astgen = &ag;
     gen_scope.is_comptime = true;
     gen_scope.decl_node_index = 0; // root
     gen_scope.decl_line = 0;
     gen_scope.break_block = UINT32_MAX;
 
     // Get root container members: containerDeclRoot (AstGen.zig:191-195).
     AstData root_data = ast->nodes.datas[0];
     uint32_t members_start = root_data.lhs;
     uint32_t members_end = root_data.rhs;
     const uint32_t* members = ast->extra_data.arr + members_start;
     uint32_t members_len = members_end - members_start;
 
     structDeclInner(&ag, &gen_scope, 0, members, members_len);
 
     // Write imports list (AstGen.zig:227-244).
     writeImports(&ag);
 
     // Build output Zir (AstGen.zig:211-239).
     Zir zir;
     zir.inst_len = ag.inst_len;
     zir.inst_cap = ag.inst_cap;
     zir.inst_tags = ag.inst_tags;
     zir.inst_datas = ag.inst_datas;
     zir.extra_len = ag.extra_len;
     zir.extra_cap = ag.extra_cap;
     zir.extra = ag.extra;
     zir.string_bytes_len = ag.string_bytes_len;
     zir.string_bytes_cap = ag.string_bytes_cap;
     zir.string_bytes = ag.string_bytes;
     zir.has_compile_errors = ag.has_compile_errors;
 
     free(ag.imports);
     free(ag.decl_names);
     free(ag.decl_nodes);
     free(ag.scratch_instructions);
     free(ag.scratch_extra);
     free(ag.ref_table_keys);
     free(ag.ref_table_vals);
     free(ag.nodes_need_rl);
     free(ag.string_table);
 
     return zir;
 }