UnwrappedStructDecl

pub const UnwrappedStructDecl = struct {
    src_line: u32,
    src_column: u32,
    src_node: Ast.Node.Index,
    name_strategy: Inst.NameStrategy,

    captures: []const Inst.Capture,
    capture_names: []const NullTerminatedString,

    decls: []const Inst.Index,

    layout: std.lang.Type.ContainerLayout,
    backing_int_type_body: ?[]const Inst.Index,

    field_names: []const NullTerminatedString,
    field_type_body_lens: []const u32,
    field_align_body_lens: ?[]const u32,
    field_default_body_lens: ?[]const u32,
    field_comptime_bits: ?[]const u32,
    field_bodies_overlong: []const Inst.Index,

    pub fn iterateFields(struct_decl: UnwrappedStructDecl) FieldIterator {
        return .{
            .next_idx = 0,
            .names = struct_decl.field_names,
            .type_body_lens = struct_decl.field_type_body_lens,
            .align_body_lens = struct_decl.field_align_body_lens,
            .default_body_lens = struct_decl.field_default_body_lens,
            .comptime_bits = struct_decl.field_comptime_bits,
            .bodies_overlong = struct_decl.field_bodies_overlong,
        };
    }

    pub const FieldIterator = struct {
        next_idx: u32,
        names: []const NullTerminatedString,
        type_body_lens: []const u32,
        align_body_lens: ?[]const u32,
        default_body_lens: ?[]const u32,
        comptime_bits: ?[]const u32,
        bodies_overlong: []const Inst.Index,
        pub const Field = struct {
            idx: u32,
            name: NullTerminatedString,
            type_body: []const Inst.Index,
            align_body: ?[]const Inst.Index,
            default_body: ?[]const Inst.Index,
            is_comptime: bool,
        };
        pub fn next(it: *FieldIterator) ?Field {
            const idx = it.next_idx;
            if (idx == it.names.len) return null;
            it.next_idx += 1;
            return .{
                .idx = idx,
                .name = it.names[idx],
                .type_body = it.body(it.type_body_lens[idx]).?,
                .align_body = it.body(if (it.align_body_lens) |l| l[idx] else 0),
                .default_body = it.body(if (it.default_body_lens) |l| l[idx] else 0),
                .is_comptime = ct: {
                    const bits = it.comptime_bits orelse break :ct false;
                    const big = bits[idx / 32];
                    const shifted = big >> @intCast(idx % 32);
                    break :ct @as(u1, @truncate(shifted)) == 1;
                },
            };
        }
        fn body(it: *FieldIterator, len: u32) ?[]const Inst.Index {
            if (len == 0) return null;
            const b = it.bodies_overlong[0..len];
            it.bodies_overlong = it.bodies_overlong[len..];
            return b;
        }
    };
}