typeOf

pub fn typeOf(self: Constant, builder: *Builder) Type {
    switch (self.unwrap()) {
        .constant => |constant| {
            const item = builder.constant_items.get(constant);
            return switch (item.tag) {
                .positive_integer,
                .negative_integer,
                => @as(
                    *align(@alignOf(std.math.big.Limb)) Integer,
                    @ptrCast(builder.constant_limbs.items[item.data..][0..Integer.limbs]),
                ).type,
                .half => .half,
                .bfloat => .bfloat,
                .float => .float,
                .double => .double,
                .fp128 => .fp128,
                .x86_fp80 => .x86_fp80,
                .ppc_fp128 => .ppc_fp128,
                .null,
                .none,
                .zeroinitializer,
                .undef,
                .poison,
                => @enumFromInt(item.data),
                .structure,
                .packed_structure,
                .array,
                .vector,
                => builder.constantExtraData(Aggregate, item.data).type,
                .splat => builder.constantExtraData(Splat, item.data).type,
                .string => builder.arrayTypeAssumeCapacity(
                    @as(String, @enumFromInt(item.data)).slice(builder).?.len,
                    .i8,
                ),
                .blockaddress => builder.ptrTypeAssumeCapacity(
                    builder.constantExtraData(BlockAddress, item.data)
                        .function.ptrConst(builder).global.ptrConst(builder).addr_space,
                ),
                .dso_local_equivalent,
                .no_cfi,
                => builder.ptrTypeAssumeCapacity(@as(Function.Index, @enumFromInt(item.data))
                    .ptrConst(builder).global.ptrConst(builder).addr_space),
                .trunc,
                .ptrtoint,
                .inttoptr,
                .bitcast,
                .addrspacecast,
                => builder.constantExtraData(Cast, item.data).type,
                .getelementptr,
                .@"getelementptr inbounds",
                => {
                    var extra = builder.constantExtraDataTrail(GetElementPtr, item.data);
                    const indices =
                        extra.trail.next(extra.data.info.indices_len, Constant, builder);
                    const base_ty = extra.data.base.typeOf(builder);
                    if (!base_ty.isVector(builder)) for (indices) |index| {
                        const index_ty = index.typeOf(builder);
                        if (!index_ty.isVector(builder)) continue;
                        return index_ty.changeScalarAssumeCapacity(base_ty, builder);
                    };
                    return base_ty;
                },
                .add,
                .@"add nsw",
                .@"add nuw",
                .sub,
                .@"sub nsw",
                .@"sub nuw",
                .shl,
                .xor,
                => builder.constantExtraData(Binary, item.data).lhs.typeOf(builder),
                .@"asm",
                .@"asm sideeffect",
                .@"asm alignstack",
                .@"asm sideeffect alignstack",
                .@"asm inteldialect",
                .@"asm sideeffect inteldialect",
                .@"asm alignstack inteldialect",
                .@"asm sideeffect alignstack inteldialect",
                .@"asm unwind",
                .@"asm sideeffect unwind",
                .@"asm alignstack unwind",
                .@"asm sideeffect alignstack unwind",
                .@"asm inteldialect unwind",
                .@"asm sideeffect inteldialect unwind",
                .@"asm alignstack inteldialect unwind",
                .@"asm sideeffect alignstack inteldialect unwind",
                => .ptr,
            };
        },
        .global => |global| return builder.ptrTypeAssumeCapacity(
            global.ptrConst(builder).addr_space,
        ),
    }
}