astgen: add unionDeclInner, @hasDecl, @hasField, bitBuiltins

Implement unionDeclInner (AstGen.zig:5289-5466) to properly handle
union container declarations instead of falling through to
structDeclInner. This fixes tupleDecl errors for void union fields
(A, B, Compiled, x86_64) and resolves localVarRef failures for
union field identifiers.

Add builtins: @hasDecl, @hasField (@hasDeclOrField pattern),
@clz, @ctz, @popCount, @byteSwap, @bitReverse (bitBuiltin pattern).

Add setUnion with UnionDeclSmall packing for ZIR_EXT_UNION_DECL.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

stage0/astgen.c

@@ -2069,6 +2069,79 @@ static void setStruct(AstGenCtx* ag, uint32_t inst, uint32_t src_node,
     ag->inst_datas[inst] = data;
 }
 
+// --- setUnion (AstGen.zig:12999) ---
+
+// UnionDecl.Small bit packing (Zir.zig:3573-3590).
+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
+    uint8_t layout; // 2 bits
+    bool auto_enum_tag;
+    bool any_aligned_fields;
+} UnionDeclSmall;
+
+static uint16_t packUnionDeclSmall(UnionDeclSmall 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;
+    r |= (uint16_t)(s.layout & 0x3u) << 7;
+    if (s.auto_enum_tag)
+        r |= (1u << 9);
+    if (s.any_aligned_fields)
+        r |= (1u << 10);
+    return r;
+}
+
+// Mirrors GenZir.setUnion (AstGen.zig:12999-13062).
+static void setUnion(AstGenCtx* ag, uint32_t inst, uint32_t src_node,
+    UnionDeclSmall small, uint32_t tag_type, uint32_t captures_len,
+    uint32_t body_len, uint32_t fields_len, uint32_t decls_len) {
+    ensureExtraCapacity(ag, 6 + 5);
+
+    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_tag_type)
+        ag->extra[ag->extra_len++] = tag_type;
+    if (small.has_captures_len)
+        ag->extra[ag->extra_len++] = captures_len;
+    if (small.has_body_len)
+        ag->extra[ag->extra_len++] = body_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_UNION_DECL;
+    data.extended.small = packUnionDeclSmall(small);
+    data.extended.operand = payload_index;
+    ag->inst_datas[inst] = data;
+}
+
 // --- scanContainer (AstGen.zig:13384) ---
 
 // Mirrors scanContainer (AstGen.zig:13384).
@@ -2619,6 +2692,10 @@ static uint32_t structDeclInner(AstGenCtx* ag, GenZir* gz, Scope* scope,
 static uint32_t tupleDecl(AstGenCtx* ag, GenZir* gz, Scope* scope,
     uint32_t node, const uint32_t* members, uint32_t members_len,
     uint8_t layout, uint32_t backing_int_node);
+static uint32_t unionDeclInner(AstGenCtx* ag, GenZir* gz, Scope* scope,
+    uint32_t node, const uint32_t* members, uint32_t members_len,
+    uint8_t layout, uint32_t arg_node, bool auto_enum_tag,
+    uint8_t name_strategy);
 static uint32_t enumDeclInner(AstGenCtx* ag, GenZir* gz, Scope* scope,
     uint32_t node, const uint32_t* members, uint32_t members_len,
     uint32_t arg_node, uint8_t name_strategy);
@@ -2793,6 +2870,7 @@ static uint32_t tryResolvePrimitiveIdent(GenZir* gz, uint32_t node);
 #define COMPTIME_REASON_EXPORT_OPTIONS 15
 #define COMPTIME_REASON_CALL_MODIFIER 18
 #define COMPTIME_REASON_SHUFFLE_MASK 11
+#define COMPTIME_REASON_DECL_NAME 41
 
 // Mirrors comptimeExpr2 (AstGen.zig:1982).
 // Evaluates a node in a comptime block_comptime scope.
@@ -4007,6 +4085,45 @@ static uint32_t builtinCall(
             = addPlNodeBin(gz, ZIR_INST_DIV_EXACT, node, lhs, rhs);
         return rvalue(gz, rl, result, node);
     }
+    // @clz — bitBuiltin (AstGen.zig:9475, 9907-9918).
+    if (name_len == 3 && memcmp(source + name_start, "clz", 3) == 0) {
+        AstData nd = tree->nodes.datas[node];
+        uint32_t operand = expr(gz, scope, nd.lhs);
+        uint32_t result = addUnNode(gz, ZIR_INST_CLZ, operand, node);
+        return rvalue(gz, rl, result, node);
+    }
+    // @ctz — bitBuiltin (AstGen.zig:9476, 9907-9918).
+    if (name_len == 3 && memcmp(source + name_start, "ctz", 3) == 0) {
+        AstData nd = tree->nodes.datas[node];
+        uint32_t operand = expr(gz, scope, nd.lhs);
+        uint32_t result = addUnNode(gz, ZIR_INST_CTZ, operand, node);
+        return rvalue(gz, rl, result, node);
+    }
+    // @popCount — bitBuiltin (AstGen.zig:9477, 9907-9918).
+    if (name_len == 8
+        && memcmp(source + name_start, "popCount", 8) == 0) {
+        AstData nd = tree->nodes.datas[node];
+        uint32_t operand = expr(gz, scope, nd.lhs);
+        uint32_t result = addUnNode(gz, ZIR_INST_POP_COUNT, operand, node);
+        return rvalue(gz, rl, result, node);
+    }
+    // @byteSwap — bitBuiltin (AstGen.zig:9478, 9907-9918).
+    if (name_len == 8
+        && memcmp(source + name_start, "byteSwap", 8) == 0) {
+        AstData nd = tree->nodes.datas[node];
+        uint32_t operand = expr(gz, scope, nd.lhs);
+        uint32_t result = addUnNode(gz, ZIR_INST_BYTE_SWAP, operand, node);
+        return rvalue(gz, rl, result, node);
+    }
+    // @bitReverse — bitBuiltin (AstGen.zig:9479, 9907-9918).
+    if (name_len == 10
+        && memcmp(source + name_start, "bitReverse", 10) == 0) {
+        AstData nd = tree->nodes.datas[node];
+        uint32_t operand = expr(gz, scope, nd.lhs);
+        uint32_t result
+            = addUnNode(gz, ZIR_INST_BIT_REVERSE, operand, node);
+        return rvalue(gz, rl, result, node);
+    }
     // @bitOffsetOf — AstGen.zig:9490, 9962-9978.
     if (name_len == 11
         && memcmp(source + name_start, "bitOffsetOf", 11) == 0) {
@@ -4044,6 +4161,34 @@ static uint32_t builtinCall(
         addInstruction(gz, ZIR_INST_EXPORT, data);
         return rvalue(gz, rl, ZIR_REF_VOID_VALUE, node);
     }
+    // @hasDecl — hasDeclOrField (AstGen.zig:9472, 9783-9805).
+    if (name_len == 7
+        && memcmp(source + name_start, "hasDecl", 7) == 0) {
+        AstData nd = tree->nodes.datas[node];
+        uint32_t container_type = typeExpr(gz, scope, nd.lhs);
+        ResultLoc name_rl = { .tag = RL_COERCED_TY,
+            .data = ZIR_REF_SLICE_CONST_U8_TYPE,
+            .src_node = 0, .ctx = RI_CTX_NONE };
+        uint32_t name_inst = comptimeExpr(
+            gz, scope, name_rl, nd.rhs, COMPTIME_REASON_DECL_NAME);
+        uint32_t result = addPlNodeBin(
+            gz, ZIR_INST_HAS_DECL, node, container_type, name_inst);
+        return rvalue(gz, rl, result, node);
+    }
+    // @hasField — hasDeclOrField (AstGen.zig:9473, 9783-9805).
+    if (name_len == 8
+        && memcmp(source + name_start, "hasField", 8) == 0) {
+        AstData nd = tree->nodes.datas[node];
+        uint32_t container_type = typeExpr(gz, scope, nd.lhs);
+        ResultLoc name_rl = { .tag = RL_COERCED_TY,
+            .data = ZIR_REF_SLICE_CONST_U8_TYPE,
+            .src_node = 0, .ctx = RI_CTX_NONE };
+        uint32_t name_inst = comptimeExpr(
+            gz, scope, name_rl, nd.rhs, COMPTIME_REASON_FIELD_NAME);
+        uint32_t result = addPlNodeBin(
+            gz, ZIR_INST_HAS_FIELD, node, container_type, name_inst);
+        return rvalue(gz, rl, result, node);
+    }
     // clang-format on
 
     // TODO: handle other builtins.
@@ -14093,8 +14238,36 @@ static uint32_t containerDecl(
         decl_inst = enumDeclInner(ag, gz, scope, node, members, members_len,
             arg_node, name_strategy);
         break;
+    case TOKEN_KEYWORD_UNION: {
+        // Extract layout (AstGen.zig:5499-5503).
+        uint8_t layout = 0; // auto
+        if (main_token > 0) {
+            TokenizerTag prev_tag = tree->tokens.tags[main_token - 1];
+            if (prev_tag == TOKEN_KEYWORD_PACKED)
+                layout = 2;
+            else if (prev_tag == TOKEN_KEYWORD_EXTERN)
+                layout = 1;
+        }
+        // Determine auto_enum_tag from node type (AstGen.zig:5505).
+        bool auto_enum_tag = false;
+        switch (tag) {
+        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:
+            auto_enum_tag = true;
+            break;
+        default:
+            break;
+        }
+        decl_inst = unionDeclInner(ag, gz, scope, node, members, members_len,
+            layout, arg_node, auto_enum_tag, name_strategy);
+        break;
+    }
     default:
-        // union/opaque: fall back to struct for now.
+        // opaque: fall back to struct for now.
         decl_inst = structDeclInner(
             ag, gz, scope, node, members, members_len, 0, 0, name_strategy);
         break;
@@ -14545,6 +14718,267 @@ static uint32_t tupleDecl(AstGenCtx* ag, GenZir* gz, Scope* scope,
     return idx;
 }
 
+// --- unionDeclInner (AstGen.zig:5289) ---
+
+static uint32_t unionDeclInner(AstGenCtx* ag, GenZir* gz, Scope* scope,
+    uint32_t node, const uint32_t* members, uint32_t members_len,
+    uint8_t layout, uint32_t arg_node, bool auto_enum_tag,
+    uint8_t name_strategy) {
+    const Ast* tree = ag->tree;
+
+    uint32_t decl_inst = reserveInstructionIndex(ag);
+    gzAppendInstruction(gz, decl_inst);
+
+    // Create namespace scope (AstGen.zig:5304-5310).
+    ScopeNamespace namespace;
+    scopeNamespaceInit(&namespace, scope, node, decl_inst, gz, ag->within_fn);
+
+    // Create block scope (AstGen.zig:5317-5325).
+    advanceSourceCursorToNode(ag, node);
+    GenZir block_scope;
+    memset(&block_scope, 0, sizeof(block_scope));
+    block_scope.base.tag = SCOPE_GEN_ZIR;
+    block_scope.parent = &namespace.base;
+    block_scope.astgen = ag;
+    block_scope.decl_node_index = node;
+    block_scope.decl_line = gz->decl_line;
+    block_scope.is_comptime = true;
+    block_scope.instructions_top = ag->scratch_inst_len;
+    block_scope.any_defer_node = UINT32_MAX;
+
+    // Scan container (AstGen.zig:5328).
+    uint32_t decl_count = scanContainer(ag, &namespace, members, members_len);
+    uint32_t field_count = members_len - decl_count;
+
+    // Layout validation (AstGen.zig:5331-5337).
+    if (layout != 0 && (auto_enum_tag || arg_node != 0)) {
+        SET_ERROR(ag);
+    }
+
+    // Process arg instruction (AstGen.zig:5339-5342).
+    uint32_t arg_inst = ZIR_REF_NONE;
+    if (arg_node != 0) {
+        arg_inst = typeExpr(&block_scope, &namespace.base, arg_node);
+    }
+
+    // WipMembers with bits_per_field=4, max_field_size=4 (AstGen.zig:5347).
+    WipMembers wm = wipMembersInitEx(decl_count, field_count, 4, 4);
+
+    bool any_aligned_fields = false;
+
+    // Process each member (AstGen.zig:5359-5428).
+    for (uint32_t i = 0; i < members_len; i++) {
+        uint32_t member_node = members[i];
+        AstNodeTag mtag = tree->nodes.tags[member_node];
+
+        switch (mtag) {
+        // Declarations (containerMember AstGen.zig:5809-5901).
+        case AST_NODE_COMPTIME:
+            comptimeDecl(ag, gz, &namespace.base, wm.payload, &wm.decl_index,
+                member_node);
+            break;
+        case AST_NODE_SIMPLE_VAR_DECL:
+            globalVarDecl(ag, gz, &namespace.base, wm.payload, &wm.decl_index,
+                member_node);
+            break;
+        case AST_NODE_TEST_DECL:
+            testDecl(ag, gz, &namespace.base, wm.payload, &wm.decl_index,
+                member_node);
+            break;
+        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:
+            fnDecl(ag, gz, &namespace.base, 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, &namespace.base, wm.payload, &wm.decl_index,
+                member_node);
+            break;
+
+        // Fields (AstGen.zig:5359-5427).
+        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_node];
+            AstData nd = tree->nodes.datas[member_node];
+            uint32_t type_node = nd.lhs;
+            uint32_t align_node = 0;
+            uint32_t value_node = 0;
+
+            switch (mtag) {
+            case AST_NODE_CONTAINER_FIELD_INIT:
+                value_node = nd.rhs;
+                break;
+            case AST_NODE_CONTAINER_FIELD_ALIGN:
+                align_node = nd.rhs;
+                break;
+            case AST_NODE_CONTAINER_FIELD:
+                if (nd.rhs != 0) {
+                    align_node = tree->extra_data.arr[nd.rhs];
+                    value_node = tree->extra_data.arr[nd.rhs + 1];
+                }
+                break;
+            default:
+                break;
+            }
+
+            // convertToNonTupleLike (AstGen.zig:5365, Ast.zig:2635-2641).
+            bool tuple_like = tree->tokens.tags[main_token] != TOKEN_IDENTIFIER
+                || tree->tokens.tags[main_token + 1] != TOKEN_COLON;
+            if (tuple_like && type_node != 0
+                && tree->nodes.tags[type_node] == AST_NODE_IDENTIFIER) {
+                type_node = 0;
+                tuple_like = false;
+            }
+
+            // Still tuple-like after conversion: error (AstGen.zig:5366-5368).
+            if (tuple_like) {
+                SET_ERROR(ag);
+                break;
+            }
+
+            // Comptime check (AstGen.zig:5369-5371).
+            if (main_token > 0
+                && tree->tokens.tags[main_token - 1]
+                    == TOKEN_KEYWORD_COMPTIME) {
+                SET_ERROR(ag); // union fields cannot be marked comptime
+                break;
+            }
+
+            // Field name (AstGen.zig:5373).
+            uint32_t field_name = identAsString(ag, main_token);
+            wipMembersAppendToField(&wm, field_name);
+
+            bool have_type = (type_node != 0);
+            bool have_align = (align_node != 0);
+            bool have_value = (value_node != 0);
+            bool field_bits[4] = { have_type, have_align, have_value, false };
+            wipMembersNextField(&wm, field_bits);
+
+            // Type expression (AstGen.zig:5382-5387).
+            if (have_type) {
+                uint32_t field_type
+                    = typeExpr(&block_scope, &namespace.base, type_node);
+                wipMembersAppendToField(&wm, field_type);
+            } else if (arg_inst == ZIR_REF_NONE && !auto_enum_tag) {
+                SET_ERROR(ag); // union field missing type
+                break;
+            }
+
+            // Alignment (AstGen.zig:5388-5395).
+            if (have_align) {
+                if (layout == 2) { // packed
+                    SET_ERROR(ag);
+                    break;
+                }
+                ResultLoc align_rl = { .tag = RL_COERCED_TY,
+                    .data = ZIR_REF_U29_TYPE,
+                    .src_node = 0,
+                    .ctx = RI_CTX_NONE };
+                uint32_t align_ref = exprRl(
+                    &block_scope, &block_scope.base, align_rl, align_node);
+                wipMembersAppendToField(&wm, align_ref);
+                any_aligned_fields = true;
+            }
+
+            // Value expression / tag value (AstGen.zig:5396-5427).
+            if (have_value) {
+                if (arg_inst == ZIR_REF_NONE) {
+                    SET_ERROR(ag);
+                    break;
+                }
+                if (!auto_enum_tag) {
+                    SET_ERROR(ag);
+                    break;
+                }
+                ResultLoc val_rl = { .tag = RL_COERCED_TY,
+                    .data = arg_inst,
+                    .src_node = 0,
+                    .ctx = RI_CTX_NONE };
+                uint32_t tag_value = exprRl(
+                    &block_scope, &block_scope.base, val_rl, value_node);
+                wipMembersAppendToField(&wm, tag_value);
+            }
+            break;
+        }
+        default:
+            SET_ERROR(ag);
+            break;
+        }
+    }
+
+    wipMembersFinishBits(&wm);
+
+    // Handle block scope body (AstGen.zig:5433-5438).
+    uint32_t body_len = 0;
+    if (gzInstructionsLen(&block_scope) > 0) {
+        if (!endsWithNoReturn(&block_scope)) {
+            makeBreakInline(&block_scope, decl_inst, ZIR_REF_VOID_VALUE,
+                AST_NODE_OFFSET_NONE);
+        }
+        uint32_t raw_len = gzInstructionsLen(&block_scope);
+        const uint32_t* body_slice = gzInstructionsSlice(&block_scope);
+        body_len = countBodyLenAfterFixups(ag, body_slice, raw_len);
+    }
+
+    // setUnion (AstGen.zig:5440-5452).
+    UnionDeclSmall small;
+    memset(&small, 0, sizeof(small));
+    small.has_tag_type = (arg_inst != ZIR_REF_NONE);
+    small.has_captures_len = (namespace.captures_len > 0);
+    small.has_body_len = (body_len > 0);
+    small.has_fields_len = (field_count > 0);
+    small.has_decls_len = (decl_count > 0);
+    small.name_strategy = name_strategy;
+    small.layout = layout;
+    small.auto_enum_tag = auto_enum_tag;
+    small.any_aligned_fields = any_aligned_fields;
+    setUnion(ag, decl_inst, node, small, arg_inst, namespace.captures_len,
+        body_len, field_count, decl_count);
+
+    // Append trailing data (AstGen.zig:5454-5462).
+    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, namespace.captures_len * 2 + decls_len + body_len + fields_len);
+
+    // Captures (AstGen.zig:5458-5459).
+    for (uint32_t j = 0; j < namespace.captures_len; j++)
+        ag->extra[ag->extra_len++] = namespace.capture_keys[j];
+    for (uint32_t j = 0; j < namespace.captures_len; j++)
+        ag->extra[ag->extra_len++] = namespace.capture_vals[j];
+
+    // Decls (AstGen.zig:5460).
+    for (uint32_t j = 0; j < decls_len; j++)
+        ag->extra[ag->extra_len++] = decls_slice[j];
+
+    // Body (AstGen.zig:5461).
+    if (body_len > 0) {
+        uint32_t raw_len = gzInstructionsLen(&block_scope);
+        const uint32_t* body_data = gzInstructionsSlice(&block_scope);
+        for (uint32_t j = 0; j < raw_len; j++)
+            appendPossiblyRefdBodyInst(ag, body_data[j]);
+    }
+
+    // Fields (AstGen.zig:5462).
+    for (uint32_t j = 0; j < fields_len; j++)
+        ag->extra[ag->extra_len++] = fields_slice[j];
+
+    gzUnstack(&block_scope);
+    wipMembersDeinit(&wm);
+    scopeNamespaceDeinit(&namespace);
+    return decl_inst;
+}
+
 // --- structDeclInner (AstGen.zig:4926) ---
 
 static uint32_t structDeclInner(AstGenCtx* ag, GenZir* gz, Scope* scope,