@zigc/lib 0.17.0-dev.39 → 0.17.0-dev.420

package/std/zig/Zir.zig

@@ -250,9 +250,6 @@ pub const Inst = struct {
         /// Array concatenation. `a ++ b`
         /// Uses the `pl_node` union field. Payload is `Bin`.
         array_cat,
-        /// Array multiplication `a ** b`
-        /// Uses the `pl_node` union field. Payload is `ArrayMul`.
-        array_mul,
         /// `[N]T` syntax. No source location provided.
         /// Uses the `pl_node` union field. Payload is `Bin`. lhs is length, rhs is element type.
         array_type,
@@ -597,13 +594,6 @@ pub const Inst = struct {
         /// name is added to it.
         /// Uses the `str_tok` union field.
         ret_err_value,
-        /// A string name is provided which is an anonymous error set value.
-        /// If the current function has an inferred error set, the error given by the
-        /// name is added to it.
-        /// Results in the error code. Note that control flow is not diverted with
-        /// this instruction; a following 'ret' instruction will do the diversion.
-        /// Uses the `str_tok` union field.
-        ret_err_value_code,
         /// Obtains a pointer to the return value.
         /// Uses the `node` union field.
         ret_ptr,
@@ -1066,9 +1056,6 @@ pub const Inst = struct {
         /// A defer statement.
         /// Uses the `defer` union field.
         @"defer",
-        /// An errdefer statement with a code.
-        /// Uses the `err_defer_code` union field.
-        defer_err_code,
 
         /// Requests that Sema update the saved error return trace index for the enclosing
         /// block, if the operand is .none or of an error/error-union type.
@@ -1112,7 +1099,6 @@ pub const Inst = struct {
                 .alloc_inferred_comptime_mut,
                 .make_ptr_const,
                 .array_cat,
-                .array_mul,
                 .array_type,
                 .array_type_sentinel,
                 .reify_int,
@@ -1295,14 +1281,12 @@ pub const Inst = struct {
                 .memmove,
                 .min,
                 .@"resume",
-                .ret_err_value_code,
                 .extended,
                 .ret_ptr,
                 .ret_type,
                 .@"try",
                 .try_ptr,
                 .@"defer",
-                .defer_err_code,
                 .save_err_ret_index,
                 .for_len,
                 .opt_eu_base_ptr_init,
@@ -1377,7 +1361,6 @@ pub const Inst = struct {
                 .memmove,
                 .check_comptime_control_flow,
                 .@"defer",
-                .defer_err_code,
                 .save_err_ret_index,
                 .restore_err_ret_index_unconditional,
                 .restore_err_ret_index_fn_entry,
@@ -1409,7 +1392,6 @@ pub const Inst = struct {
                 .resolve_inferred_alloc,
                 .make_ptr_const,
                 .array_cat,
-                .array_mul,
                 .array_type,
                 .array_type_sentinel,
                 .reify_int,
@@ -1574,7 +1556,6 @@ pub const Inst = struct {
                 .max,
                 .min,
                 .@"resume",
-                .ret_err_value_code,
                 .@"break",
                 .break_inline,
                 .condbr,
@@ -1644,7 +1625,6 @@ pub const Inst = struct {
                 .param_anytype = .str_tok,
                 .param_anytype_comptime = .str_tok,
                 .array_cat = .pl_node,
-                .array_mul = .pl_node,
                 .array_type = .pl_node,
                 .array_type_sentinel = .pl_node,
                 .reify_int = .pl_node,
@@ -1732,7 +1712,6 @@ pub const Inst = struct {
                 .ret_load = .un_node,
                 .ret_implicit = .un_tok,
                 .ret_err_value = .str_tok,
-                .ret_err_value_code = .str_tok,
                 .ret_ptr = .node,
                 .ret_type = .node,
                 .ptr_type = .ptr_type,
@@ -1866,7 +1845,6 @@ pub const Inst = struct {
                 .@"resume" = .un_node,
 
                 .@"defer" = .@"defer",
-                .defer_err_code = .defer_err_code,
 
                 .save_err_ret_index = .save_err_ret_index,
                 .restore_err_ret_index_unconditional = .un_node,
@@ -2141,10 +2119,10 @@ pub const Inst = struct {
         /// Guaranteed to not have the `ptr_cast` flag.
         /// Uses the `pl_node` union field with payload `FieldParentPtr`.
         field_parent_ptr,
-        /// Get a type or value from `std.builtin`.
+        /// Get a type or value from `std.lang`.
         /// `operand` is `src_node: Ast.Node.Offset`.
-        /// `small` is an `Inst.BuiltinValue`.
-        builtin_value,
+        /// `small` is an `Inst.StdLangValue`.
+        std_lang_value,
         /// Provide a `@branchHint` for the current block.
         /// `operand` is payload index to `UnNode`.
         /// `small` is unused.
@@ -2213,7 +2191,6 @@ pub const Inst = struct {
     /// and `[]Ref`.
     pub const Ref = enum(u32) {
         u0_type,
-        i0_type,
         u1_type,
         u8_type,
         i8_type,
@@ -2441,7 +2418,7 @@ pub const Inst = struct {
                 has_bit_range: bool,
                 _: u1 = 0,
             },
-            size: std.builtin.Type.Pointer.Size,
+            size: std.lang.Type.Pointer.Size,
             /// Index into extra. See `PtrType`.
             payload_index: u32,
         },
@@ -2449,7 +2426,7 @@ pub const Inst = struct {
             /// Offset from Decl AST node index.
             /// `Tag` determines which kind of AST node this points to.
             src_node: Ast.Node.Offset,
-            signedness: std.builtin.Signedness,
+            signedness: std.lang.Signedness,
             bit_count: u16,
         },
         @"unreachable": struct {
@@ -2484,10 +2461,6 @@ pub const Inst = struct {
             index: u32,
             len: u32,
         },
-        defer_err_code: struct {
-            err_code: Ref,
-            payload_index: u32,
-        },
         save_err_ret_index: struct {
             operand: Ref, // If error type (or .none), save new trace index
         },
@@ -2538,7 +2511,6 @@ pub const Inst = struct {
             inst_node,
             str_op,
             @"defer",
-            defer_err_code,
             save_err_ret_index,
             elem_val_imm,
             declaration,
@@ -3079,7 +3051,7 @@ pub const Inst = struct {
         callee: Ref,
 
         pub const Flags = packed struct {
-            /// std.builtin.CallModifier in packed form
+            /// std.lang.CallModifier in packed form
             pub const PackedModifier = u3;
             pub const PackedArgsLen = u27;
 
@@ -3091,7 +3063,7 @@ pub const Inst = struct {
             comptime {
                 if (@sizeOf(Flags) != 4 or @bitSizeOf(Flags) != 32)
                     @compileError("Layout of Call.Flags needs to be updated!");
-                if (@bitSizeOf(std.builtin.CallModifier) != @bitSizeOf(PackedModifier))
+                if (@bitSizeOf(std.lang.CallModifier) != @bitSizeOf(PackedModifier))
                     @compileError("Call.Flags.PackedModifier needs to be updated!");
             }
         };
@@ -3214,7 +3186,7 @@ pub const Inst = struct {
 
     pub const ReifySliceArgInfo = enum(u16) {
         /// Input element type is `type`.
-        /// Output element type is `std.builtin.Type.Fn.Param.Attributes`.
+        /// Output element type is `std.lang.Type.Fn.Param.Attributes`.
         type_to_fn_param_attrs,
         /// Input element type is `[]const u8`.
         /// Output element type is `type`.
@@ -3222,10 +3194,10 @@ pub const Inst = struct {
         /// Identical to `string_to_struct_field_type` aside from emitting slightly different error messages.
         string_to_union_field_type,
         /// Input element type is `[]const u8`.
-        /// Output element type is `std.builtin.Type.StructField.Attributes`.
+        /// Output element type is `std.lang.Type.StructField.Attributes`.
         string_to_struct_field_attrs,
         /// Input element type is `[]const u8`.
-        /// Output element type is `std.builtin.Type.UnionField.Attributes`.
+        /// Output element type is `std.lang.Type.UnionField.Attributes`.
         string_to_union_field_attrs,
     };
 
@@ -3496,7 +3468,7 @@ pub const Inst = struct {
             has_decls_len: bool,
             has_fields_len: bool,
             name_strategy: NameStrategy,
-            layout: std.builtin.Type.ContainerLayout,
+            layout: std.lang.Type.ContainerLayout,
             /// Always `false` if `layout != .@"packed"`.
             has_backing_int_type: bool,
             any_field_aligns: bool,
@@ -3592,7 +3564,7 @@ pub const Inst = struct {
         }
     };
 
-    pub const BuiltinValue = enum(u16) {
+    pub const StdLangValue = enum(u16) {
         // Types
         atomic_order,
         atomic_rmw_op,
@@ -3716,7 +3688,7 @@ pub const Inst = struct {
                 };
             }
 
-            pub fn layout(k: Kind) std.builtin.Type.ContainerLayout {
+            pub fn layout(k: Kind) std.lang.Type.ContainerLayout {
                 return switch (k) {
                     .auto, .tagged_explicit, .tagged_enum, .tagged_enum_explicit => .auto,
                     .@"extern" => .@"extern",
@@ -3974,12 +3946,6 @@ pub const Inst = struct {
         column: u32,
     };
 
-    pub const DeferErrCode = struct {
-        remapped_err_code: Index,
-        index: u32,
-        len: u32,
-    };
-
     pub const ValidateDestructure = struct {
         /// The value being destructured.
         operand: Ref,
@@ -3989,15 +3955,6 @@ pub const Inst = struct {
         expect_len: u32,
     };
 
-    pub const ArrayMul = struct {
-        /// The result type of the array multiplication operation, or `.none` if none was available.
-        res_ty: Ref,
-        /// The LHS of the array multiplication.
-        lhs: Ref,
-        /// The RHS of the array multiplication.
-        rhs: Ref,
-    };
-
     pub const RestoreErrRetIndex = struct {
         src_node: Ast.Node.Offset,
         /// If `.none`, restore the trace to its state upon function entry.
@@ -4149,7 +4106,6 @@ fn findTrackableInner(
         .param_anytype,
         .param_anytype_comptime,
         .array_cat,
-        .array_mul,
         .array_type,
         .array_type_sentinel,
         .reify_int,
@@ -4222,7 +4178,6 @@ fn findTrackableInner(
         .ret_load,
         .ret_implicit,
         .ret_err_value,
-        .ret_err_value_code,
         .ret_ptr,
         .ret_type,
         .ptr_type,
@@ -4413,7 +4368,7 @@ fn findTrackableInner(
                 .restore_err_ret_index,
                 .closure_get,
                 .field_parent_ptr,
-                .builtin_value,
+                .std_lang_value,
                 .branch_hint,
                 .inplace_arith_result_ty,
                 .tuple_decl,
@@ -4621,15 +4576,6 @@ fn findTrackableInner(
                 try zir.findTrackableBody(gpa, contents, defers, body);
             }
         },
-        .defer_err_code => {
-            const inst_data = datas[@intFromEnum(inst)].defer_err_code;
-            const extra = zir.extraData(Inst.DeferErrCode, inst_data.payload_index).data;
-            const gop = try defers.getOrPut(gpa, extra.index);
-            if (!gop.found_existing) {
-                const body = zir.bodySlice(extra.index, extra.len);
-                try zir.findTrackableBody(gpa, contents, defers, body);
-            }
-        },
     }
 }
 
@@ -5340,7 +5286,7 @@ pub const UnwrappedStructDecl = struct {
 
     decls: []const Inst.Index,
 
-    layout: std.builtin.Type.ContainerLayout,
+    layout: std.lang.Type.ContainerLayout,
     backing_int_type_body: ?[]const Inst.Index,
 
     field_names: []const NullTerminatedString,

package/std/zig/ZonGen.zig

@@ -67,38 +67,30 @@ pub fn generate(gpa: Allocator, tree: Ast, options: Options) Allocator.Error!Zoi
     }
 
     if (zg.compile_errors.items.len > 0) {
-        const string_bytes = try zg.string_bytes.toOwnedSlice(gpa);
-        errdefer gpa.free(string_bytes);
-        const compile_errors = try zg.compile_errors.toOwnedSlice(gpa);
-        errdefer gpa.free(compile_errors);
-        const error_notes = try zg.error_notes.toOwnedSlice(gpa);
-        errdefer gpa.free(error_notes);
+        try zg.string_bytes.shrinkToLen(gpa);
+        try zg.compile_errors.shrinkToLen(gpa);
+        try zg.error_notes.shrinkToLen(gpa);
 
         return .{
             .nodes = .empty,
             .extra = &.{},
             .limbs = &.{},
-            .string_bytes = string_bytes,
-            .compile_errors = compile_errors,
-            .error_notes = error_notes,
+            .string_bytes = zg.string_bytes.toOwnedSliceAssert(),
+            .compile_errors = zg.compile_errors.toOwnedSliceAssert(),
+            .error_notes = zg.error_notes.toOwnedSliceAssert(),
         };
     } else {
         assert(zg.error_notes.items.len == 0);
 
-        var nodes = zg.nodes.toOwnedSlice();
-        errdefer nodes.deinit(gpa);
-        const extra = try zg.extra.toOwnedSlice(gpa);
-        errdefer gpa.free(extra);
-        const limbs = try zg.limbs.toOwnedSlice(gpa);
-        errdefer gpa.free(limbs);
-        const string_bytes = try zg.string_bytes.toOwnedSlice(gpa);
-        errdefer gpa.free(string_bytes);
+        try zg.extra.shrinkToLen(gpa);
+        try zg.limbs.shrinkToLen(gpa);
+        try zg.string_bytes.shrinkToLen(gpa);
 
         return .{
-            .nodes = nodes,
-            .extra = extra,
-            .limbs = limbs,
-            .string_bytes = string_bytes,
+            .nodes = zg.nodes.toOwnedSlice(),
+            .extra = zg.extra.toOwnedSliceAssert(),
+            .limbs = zg.limbs.toOwnedSliceAssert(),
+            .string_bytes = zg.string_bytes.toOwnedSliceAssert(),
             .compile_errors = &.{},
             .error_notes = &.{},
         };
@@ -174,7 +166,6 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator
         .less_than,
         .less_or_equal,
         .array_cat,
-        .array_mult,
         .bool_and,
         .bool_or,
         .bool_not,
@@ -427,10 +418,11 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator
             });
 
             // For short initializers, track the names on the stack rather than going through gpa.
-            var sfba_state = std.heap.stackFallback(256, gpa);
-            const sfba = sfba_state.get();
+            var bfa_buf: [256]u8 = undefined;
+            var bfa_state: std.heap.BufferFirstAllocator = .init(&bfa_buf, gpa);
+            const bfa = bfa_state.allocator();
             var field_names: std.AutoHashMapUnmanaged(Zoir.NullTerminatedString, Ast.TokenIndex) = .empty;
-            defer field_names.deinit(sfba);
+            defer field_names.deinit(bfa);
 
             var reported_any_duplicate = false;
 
@@ -438,7 +430,7 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator
                 const name_token = tree.firstToken(elem_node) - 2;
                 if (zg.identAsString(name_token)) |name_str| {
                     zg.extra.items[extra_name_idx] = @intFromEnum(name_str);
-                    const gop = try field_names.getOrPut(sfba, name_str);
+                    const gop = try field_names.getOrPut(bfa, name_str);
                     if (gop.found_existing and !reported_any_duplicate) {
                         reported_any_duplicate = true;
                         const earlier_token = gop.value_ptr.*;
@@ -667,7 +659,7 @@ fn numberLiteral(zg: *ZonGen, num_node: Ast.Node.Index, src_node: Ast.Node.Index
             big_int.setString(@intFromEnum(base), num_without_prefix) catch |err| switch (err) {
                 error.InvalidCharacter => unreachable, // caught in `parseNumberLiteral`
                 error.InvalidBase => unreachable, // we only pass 16, 8, 2, see above
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
             };
             switch (sign) {
                 .positive => {},

package/std/zig/llvm/Builder.zig

@@ -1830,7 +1830,7 @@ pub const Visibility = enum(u2) {
     hidden = 1,
     protected = 2,
 
-    pub fn fromSymbolVisibility(sv: std.builtin.SymbolVisibility) Visibility {
+    pub fn fromSymbolVisibility(sv: std.lang.SymbolVisibility) Visibility {
         return switch (sv) {
             .default => .default,
             .hidden => .hidden,
@@ -2310,7 +2310,7 @@ pub fn trailingStrtabString(self: *Builder) Allocator.Error!StrtabString {
 }
 
 pub fn trailingStrtabStringAssumeCapacity(self: *Builder) StrtabString {
-    const start = self.strtab_string_indices.getLast();
+    const start = self.strtab_string_indices.getLast().?;
     const bytes: []const u8 = self.strtab_string_bytes.items[start..];
     const gop = self.strtab_string_map.getOrPutAssumeCapacityAdapted(bytes, StrtabString.Adapter{ .builder = self });
     if (gop.found_existing) {
@@ -7628,9 +7628,7 @@ pub const Constant = enum(u32) {
                             const expected_limbs = @divExact(512, @bitSizeOf(std.math.big.Limb));
                             string: [
                                 (std.math.big.int.Const{
-                                    .limbs = &([1]std.math.big.Limb{
-                                        maxInt(std.math.big.Limb),
-                                    } ** expected_limbs),
+                                    .limbs = &@as([expected_limbs]std.math.big.Limb, @splat(maxInt(std.math.big.Limb))),
                                     .positive = false,
                                 }).sizeInBaseUpperBound(10)
                             ]u8,
@@ -7638,9 +7636,9 @@ pub const Constant = enum(u32) {
                                 std.math.big.int.calcToStringLimbsBufferLen(expected_limbs, 10)
                             ]std.math.big.Limb,
                         };
-                        var stack align(@alignOf(ExpectedContents)) =
-                            std.heap.stackFallback(@sizeOf(ExpectedContents), data.builder.gpa);
-                        const allocator = stack.get();
+                        var bfa_buf: ExpectedContents = undefined;
+                        var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), data.builder.gpa);
+                        const allocator = bfa.allocator();
                         const str = bigint.toStringAlloc(allocator, 10, undefined) catch return error.WriteFailed;
                         defer allocator.free(str);
                         try w.writeAll(str);
@@ -7659,9 +7657,9 @@ pub const Constant = enum(u32) {
                     .float => {
                         const Float = struct {
                             fn Repr(comptime T: type) type {
-                                return packed struct(std.meta.Int(.unsigned, @bitSizeOf(T))) {
-                                    mantissa: std.meta.Int(.unsigned, std.math.floatMantissaBits(T)),
-                                    exponent: std.meta.Int(.unsigned, std.math.floatExponentBits(T)),
+                                return packed struct(@Int(.unsigned, @bitSizeOf(T))) {
+                                    mantissa: @Int(.unsigned, std.math.floatMantissaBits(T)),
+                                    exponent: @Int(.unsigned, std.math.floatExponentBits(T)),
                                     sign: u1,
                                 };
                             }
@@ -8907,7 +8905,7 @@ pub fn deinit(self: *Builder) void {
 
 pub fn finishModuleAsm(self: *Builder, aw: *Writer.Allocating) Allocator.Error!void {
     self.module_asm = aw.toArrayList();
-    if (self.module_asm.getLastOrNull()) |last| if (last != '\n')
+    if (self.module_asm.getLast()) |last| if (last != '\n')
         try self.module_asm.append(self.gpa, '\n');
 }
 
@@ -8953,7 +8951,7 @@ pub fn trailingString(self: *Builder) Allocator.Error!String {
 }
 
 pub fn trailingStringAssumeCapacity(self: *Builder) String {
-    const start = self.string_indices.getLast();
+    const start = self.string_indices.getLast().?;
     const bytes: []const u8 = self.string_bytes.items[start..];
     const gop = self.string_map.getOrPutAssumeCapacityAdapted(bytes, String.Adapter{ .builder = self });
     if (gop.found_existing) {
@@ -9209,9 +9207,9 @@ pub fn getIntrinsic(
             fields: [expected_fields_len]Type,
         },
     };
-    var stack align(@max(@alignOf(std.heap.StackFallbackAllocator(0)), @alignOf(ExpectedContents))) =
-        std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
-    const allocator = stack.get();
+    var bfa_buf: ExpectedContents = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), self.gpa);
+    const allocator = bfa.allocator();
 
     const name = name: {
         {
@@ -9347,7 +9345,7 @@ pub fn nanConst(self: *Builder, ty: Type) Allocator.Error!Constant {
         .double => try self.doubleConst(std.math.nan(f64)),
         .fp128 => try self.fp128Const(std.math.nan(f128)),
         .x86_fp80 => try self.x86_fp80Const(std.math.nan(f80)),
-        .ppc_fp128 => try self.ppc_fp128Const(.{std.math.nan(f64)} ** 2),
+        .ppc_fp128 => try self.ppc_fp128Const(@splat(.{std.math.nan(f64)})),
         else => unreachable,
     };
 }
@@ -9720,8 +9718,7 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
             metadata_formatter.need_comma = true;
             defer metadata_formatter.need_comma = undefined;
             try w.print(
-                \\{f} ={f}{f}{f}{f}{f}{f}{f}{f} {s} {f}{f}{f}{f}
-                \\
+                \\{f} ={f}{f}{f}{f}{f}{f}{f}{f} {s} {f}{f}
             , .{
                 variable.global.fmt(self),
                 Linkage.fmtOptional(
@@ -9737,6 +9734,14 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
                 @tagName(variable.mutability),
                 global.type.fmt(self, .percent),
                 variable.init.fmt(self, .{ .space = true }),
+            });
+            if (variable.section != .none) {
+                try w.print(", section {f}", .{variable.section.fmtQ(self)});
+            }
+            try w.print(
+                \\{f}{f}
+                \\
+            , .{
                 variable.alignment.fmt(", "),
                 try metadata_formatter.fmt("!dbg ", global.dbg, null),
             });
@@ -9830,6 +9835,9 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
         {
             metadata_formatter.need_comma = false;
             defer metadata_formatter.need_comma = undefined;
+            if (function.section != .none) {
+                try w.print(" section {f}", .{function.section.fmtQ(self)});
+            }
             try w.print("{f}{f}", .{
                 function.alignment.fmt(" "),
                 try metadata_formatter.fmt(" !dbg ", global.dbg, null),
@@ -10024,9 +10032,9 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
                         defer metadata_formatter.need_comma = undefined;
                         switch (extra.weights) {
                             .none => {},
-                            .unpredictable => try w.writeAll("!unpredictable !{}"),
+                            .unpredictable => try w.writeAll(", !unpredictable !{}"),
                             _ => try w.print("{f}", .{
-                                try metadata_formatter.fmt("!prof ", extra.weights.toMetadata(), null),
+                                try metadata_formatter.fmt(", !prof ", extra.weights.toMetadata(), null),
                             }),
                         }
                     },
@@ -10597,9 +10605,7 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
                         const expected_limbs = @divExact(512, @bitSizeOf(std.math.big.Limb));
                         string: [
                             (std.math.big.int.Const{
-                                .limbs = &([1]std.math.big.Limb{
-                                    maxInt(std.math.big.Limb),
-                                } ** expected_limbs),
+                                .limbs = &@as([expected_limbs]std.math.big.Limb, @splat(maxInt(std.math.big.Limb))),
                                 .positive = false,
                             }).sizeInBaseUpperBound(10)
                         ]u8,
@@ -10607,9 +10613,9 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
                             std.math.big.int.calcToStringLimbsBufferLen(expected_limbs, 10)
                         ]std.math.big.Limb,
                     };
-                    var stack align(@alignOf(ExpectedContents)) =
-                        std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
-                    const allocator = stack.get();
+                    var bfa_buf: ExpectedContents = undefined;
+                    var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), self.gpa);
+                    const allocator = bfa.allocator();
 
                     const limbs = self.metadata_limbs.items[extra.limbs_index..][0..extra.limbs_len];
                     const bigint: std.math.big.int.Const = .{
@@ -11129,9 +11135,9 @@ fn bigIntConstAssumeCapacity(
     const bits = type_item.data;
 
     const ExpectedContents = [64 / @sizeOf(std.math.big.Limb)]std.math.big.Limb;
-    var stack align(@alignOf(ExpectedContents)) =
-        std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
-    const allocator = stack.get();
+    var bfa_buf: ExpectedContents = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), self.gpa);
+    const allocator = bfa.allocator();
 
     var limbs: []std.math.big.Limb = &.{};
     defer allocator.free(limbs);
@@ -12154,7 +12160,7 @@ pub fn trailingMetadataString(self: *Builder) Allocator.Error!Metadata.String {
 }
 
 pub fn trailingMetadataStringAssumeCapacity(self: *Builder) Metadata.String {
-    const start = self.metadata_string_indices.getLast();
+    const start = self.metadata_string_indices.getLast().?;
     const bytes: []const u8 = self.metadata_string_bytes.items[start..];
     assert(bytes.len > 0);
     const gop = self.metadata_string_map.getOrPutAssumeCapacityAdapted(bytes, Metadata.String.Adapter{ .builder = self });
@@ -13947,8 +13953,8 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
                         const bit_count = extra.type.scalarBits(self);
                         const val: i64 = if (bit_count <= 64)
                             bigint.toInt(i64) catch unreachable
-                        else if (bigint.toInt(u64)) |val|
-                            @bitCast(val)
+                        else if (bigint.toInt(u63)) |val|
+                            @bitCast(@as(u64, val))
                         else |_| {
                             const limbs = try record.addManyAsSlice(
                                 self.gpa,

package/std/zig/llvm/bitcode_writer.zig

@@ -404,7 +404,7 @@ fn charTo6Bit(c: u8) u8 {
 }
 
 fn BufType(comptime T: type, comptime min_len: usize) type {
-    return std.meta.Int(.unsigned, @max(min_len, @bitSizeOf(switch (@typeInfo(T)) {
+    return @Int(.unsigned, @max(min_len, @bitSizeOf(switch (@typeInfo(T)) {
         .comptime_int => u32,
         .int => |info| if (info.signedness == .unsigned)
             T
@@ -414,7 +414,7 @@ fn BufType(comptime T: type, comptime min_len: usize) type {
         .bool => u1,
         .@"struct" => |info| switch (info.layout) {
             .auto, .@"extern" => @compileError("Unsupported type: " ++ @typeName(T)),
-            .@"packed" => std.meta.Int(.unsigned, @bitSizeOf(T)),
+            .@"packed" => @Int(.unsigned, @bitSizeOf(T)),
         },
         else => @compileError("Unsupported type: " ++ @typeName(T)),
     })));
@@ -425,7 +425,7 @@ fn bufValue(value: anytype, comptime min_len: usize) BufType(@TypeOf(value), min
         .comptime_int, .int => @intCast(value),
         .@"enum" => @intFromEnum(value),
         .bool => @intFromBool(value),
-        .@"struct" => @intCast(@as(std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(value))), @bitCast(value))),
+        .@"struct" => @intCast(@as(@Int(.unsigned, @bitSizeOf(@TypeOf(value))), @bitCast(value))),
         else => unreachable,
     };
 }