From b5ed0ae2cecb96adca7b259f7054519c92a3283f Mon Sep 17 00:00:00 2001 From: Krzysztof Wolicki Date: Fri, 23 Oct 2026 09:03:25 +0200 Subject: [PATCH 1/4] Remove usages of array_list.Managed in lib/compiler/Maker --- lib/compiler/Maker.zig | 19 +++++++++++-------- lib/compiler/Maker/Fetch.zig | 12 ++++++------ lib/compiler/Maker/Step/Compile.zig | 2 +- 3 files changed, 18 insertions(+), 15 deletions(-) diff --git a/lib/compiler/Maker.zig b/lib/compiler/Maker.zig index e0ce8142628ad4aac0466293869eaa9f7bab225d..d4f9723fcb4c6315faaa74e6e24e785d2942ac8d 100644 --- a/lib/compiler/Maker.zig +++ b/lib/compiler/Maker.zig @@ -4677,12 +4677,13 @@ test sanitizeExampleName { const Templates = struct { zig_lib_directory: Cache.Directory, dir: Io.Dir, - buffer: std.array_list.Managed(u8), + buffer: std.ArrayList(u8), + gpa: Allocator, fn deinit(templates: *Templates, io: Io) void { templates.zig_lib_directory.handle.close(io); templates.dir.close(io); - templates.buffer.deinit(); + templates.buffer.deinit(templates.gpa); templates.* = undefined; } @@ -4705,29 +4706,30 @@ const Templates = struct { const contents = templates.dir.readFileAlloc(io, template_path, arena, .limited(max_bytes)) catch |err| { fatal("unable to read template file {q}: {t}", .{ template_path, err }); }; + const gpa = templates.gpa; templates.buffer.clearRetainingCapacity(); - try templates.buffer.ensureUnusedCapacity(contents.len); + try templates.buffer.ensureUnusedCapacity(gpa, contents.len); var i: usize = 0; while (i < contents.len) { if (contents[i] == '_' or contents[i] == '.') { // Both '_' and '.' are allowed because depending on the context // one prefix will be valid, while the other might not. if (std.mem.startsWith(u8, contents[i + 1 ..], "NAME")) { - try templates.buffer.appendSlice(root_name); + try templates.buffer.appendSlice(gpa, root_name); i += "_NAME".len; continue; } else if (std.mem.startsWith(u8, contents[i + 1 ..], "FINGERPRINT")) { - try templates.buffer.print("0x{x}", .{fingerprint.int()}); + try templates.buffer.print(gpa, "0x{x}", .{fingerprint.int()}); i += "_FINGERPRINT".len; continue; } else if (std.mem.startsWith(u8, contents[i + 1 ..], "ZIGVER")) { - try templates.buffer.appendSlice(builtin.zig_version_string); + try templates.buffer.appendSlice(gpa, builtin.zig_version_string); i += "_ZIGVER".len; continue; } } - try templates.buffer.append(contents[i]); + try templates.buffer.append(gpa, contents[i]); i += 1; } @@ -4748,7 +4750,8 @@ const Templates = struct { return .{ .zig_lib_directory = zig_lib_directory, .dir = template_dir, - .buffer = std.array_list.Managed(u8).init(gpa), + .buffer = .empty, + .gpa = gpa, }; } diff --git a/lib/compiler/Maker/Fetch.zig b/lib/compiler/Maker/Fetch.zig index c1bc153056854864050ef8a0656255b2541b57a5..a376f96a61805b6bad5185a556eaa5b1f6fe9133 100644 --- a/lib/compiler/Maker/Fetch.zig +++ b/lib/compiler/Maker/Fetch.zig @@ -1756,11 +1756,11 @@ fn computeHash(f: *Fetch, pkg_path: Path, filter: Filter) RunError!ComputedHash const root_dir = pkg_path.root_dir.handle; // Collect all files, recursively, then sort. - var all_files = std.array_list.Managed(*HashedFile).init(gpa); - defer all_files.deinit(); + var all_files: std.ArrayList(*HashedFile) = .empty; + defer all_files.deinit(gpa); - var deleted_files = std.array_list.Managed(*DeletedFile).init(gpa); - defer deleted_files.deinit(); + var deleted_files: std.ArrayList(*DeletedFile) = .empty; + defer deleted_files.deinit(gpa); // Track directories which had any files deleted from them so that empty directories // can be deleted. @@ -1803,7 +1803,7 @@ fn computeHash(f: *Fetch, pkg_path: Path, filter: Filter) RunError!ComputedHash .failure = undefined, // to be populated by the worker }; group.async(io, workerDeleteFile, .{ io, root_dir, deleted_file }); - try deleted_files.append(deleted_file); + try deleted_files.append(gpa, deleted_file); continue; } @@ -1831,7 +1831,7 @@ fn computeHash(f: *Fetch, pkg_path: Path, filter: Filter) RunError!ComputedHash .size = undefined, // to be populated by the worker }; group.async(io, workerHashFile, .{ io, root_dir, hashed_file }); - try all_files.append(hashed_file); + try all_files.append(gpa, hashed_file); } try group.await(io); diff --git a/lib/compiler/Maker/Step/Compile.zig b/lib/compiler/Maker/Step/Compile.zig index 8c6ab5fe30c55becc28af17276c89b3f4baca121..396af76a5e9cfb70bc841f8f4d2405785d7eb67f 100644 --- a/lib/compiler/Maker/Step/Compile.zig +++ b/lib/compiler/Maker/Step/Compile.zig @@ -867,7 +867,7 @@ fn lowerZigArgs( return step.fail(maker, "failed creating directory {f}: {t}", .{ args_path, err }); const args_to_escape = zig_args.items[2..]; - var escaped_args = try std.array_list.Managed([]const u8).initCapacity(arena, args_to_escape.len); + var escaped_args: std.ArrayList([]const u8) = try .initCapacity(arena, args_to_escape.len); arg_blk: for (args_to_escape) |arg| { for (arg, 0..) |c, arg_idx| { if (c == '\\' or c == '"') { -- 2.54.0 From 1c26a0e8dd32c38df5a751d33456c7ed0da29006 Mon Sep 17 00:00:00 2001 From: Krzysztof Wolicki Date: Fri, 23 Oct 2026 09:39:42 +0200 Subject: [PATCH 2/4] Remove usages of array_list.Managed in docs/wasm/markdown --- lib/docs/wasm/markdown.zig | 6 +++--- lib/docs/wasm/markdown/Document.zig | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/lib/docs/wasm/markdown.zig b/lib/docs/wasm/markdown.zig index a15af8869c68183a0d8029a857798da093591180..a9ac0aec85fad8229c1b8f988db38435ee4a2a29 100644 --- a/lib/docs/wasm/markdown.zig +++ b/lib/docs/wasm/markdown.zig @@ -1119,9 +1119,9 @@ fn testRender(input: []const u8, expected: []const u8) !void { var doc = try parser.endInput(); defer doc.deinit(testing.allocator); - var actual = std.array_list.Managed(u8).init(testing.allocator); + var actual: std.Io.Writer.Allocating = .init(testing.allocator); defer actual.deinit(); - try doc.render(actual.writer()); + try doc.render(&actual.writer); - try testing.expectEqualStrings(expected, actual.items); + try testing.expectEqualStrings(expected, actual.written()); } diff --git a/lib/docs/wasm/markdown/Document.zig b/lib/docs/wasm/markdown/Document.zig index 7cde78f32b5ca948ab6e940f558a43dcd9d9bacc..fb24fea8338e3f28340e8aadadd2cfbaf099b1b0 100644 --- a/lib/docs/wasm/markdown/Document.zig +++ b/lib/docs/wasm/markdown/Document.zig @@ -160,8 +160,8 @@ pub fn deinit(doc: *Document, allocator: Allocator) void { } /// Renders a document directly to a writer using the default renderer. -pub fn render(doc: Document, writer: anytype) @TypeOf(writer).Error!void { - const renderer: Renderer(@TypeOf(writer), void) = .{ .context = {} }; +pub fn render(doc: Document, writer: *std.Io.Writer) std.Io.Writer.Error!void { + const renderer: Renderer(void) = .{ .context = {} }; try renderer.render(doc, writer); } -- 2.54.0 From fdb4cdfff1efb93eda20bf8033c7b3fd4366e688 Mon Sep 17 00:00:00 2001 From: Krzysztof Wolicki Date: Fri, 23 Oct 2026 10:08:11 +0200 Subject: [PATCH 3/4] Remove usages of array_list.Managed in std/zig/llvm --- lib/std/zig/llvm/BitcodeReader.zig | 30 ++++++++--------- lib/std/zig/llvm/Builder.zig | 50 ++++++++++++++--------------- lib/std/zig/llvm/bitcode_writer.zig | 16 +++++---- 3 files changed, 50 insertions(+), 46 deletions(-) diff --git a/lib/std/zig/llvm/BitcodeReader.zig b/lib/std/zig/llvm/BitcodeReader.zig index 0e96d0ac5963d405384674d49bd94eeb88e017dc..4c990e30229f4b028c61b091de87ae0eeeea12fe 100644 --- a/lib/std/zig/llvm/BitcodeReader.zig +++ b/lib/std/zig/llvm/BitcodeReader.zig @@ -60,40 +60,40 @@ pub const Record = struct { blob: []const u8, fn toOwnedAbbrev(record: Record, allocator: std.mem.Allocator) !Abbrev { - var operands = std.array_list.Managed(Abbrev.Operand).init(allocator); - defer operands.deinit(); + var operands: std.ArrayList(Abbrev.Operand) = .empty; + defer operands.deinit(allocator); assert(record.id == Abbrev.Builtin.define_abbrev.toRecordId()); var i: usize = 0; while (i < record.operands.len) switch (record.operands[i]) { Abbrev.Operand.literal_id => { - try operands.append(.{ .literal = record.operands[i + 1] }); + try operands.append(allocator, .{ .literal = record.operands[i + 1] }); i += 2; }, @backingInt(Abbrev.Operand.Encoding.fixed) => { - try operands.append(.{ .encoding = .{ .fixed = @intCast(record.operands[i + 1]) } }); + try operands.append(allocator, .{ .encoding = .{ .fixed = @intCast(record.operands[i + 1]) } }); i += 2; }, @backingInt(Abbrev.Operand.Encoding.vbr) => { - try operands.append(.{ .encoding = .{ .vbr = @intCast(record.operands[i + 1]) } }); + try operands.append(allocator, .{ .encoding = .{ .vbr = @intCast(record.operands[i + 1]) } }); i += 2; }, @backingInt(Abbrev.Operand.Encoding.array) => { - try operands.append(.{ .encoding = .{ .array = 6 } }); + try operands.append(allocator, .{ .encoding = .{ .array = 6 } }); i += 1; }, @backingInt(Abbrev.Operand.Encoding.char6) => { - try operands.append(.{ .encoding = .char6 }); + try operands.append(allocator, .{ .encoding = .char6 }); i += 1; }, @backingInt(Abbrev.Operand.Encoding.blob) => { - try operands.append(.{ .encoding = .{ .blob = 6 } }); + try operands.append(allocator, .{ .encoding = .{ .blob = 6 } }); i += 1; }, else => unreachable, }; - return .{ .operands = try operands.toOwnedSlice() }; + return .{ .operands = try operands.toOwnedSlice(allocator) }; } }; @@ -198,8 +198,8 @@ fn nextRecord(bc: *BitcodeReader) !?Record { defer bc.record_arena = record_arena.state; _ = record_arena.reset(.retain_capacity); - var operands = try std.array_list.Managed(u64).initCapacity(record_arena.allocator(), abbrev.operands.len); - var blob = std.array_list.Managed(u8).init(record_arena.allocator()); + var operands: std.ArrayList(u64) = try .initCapacity(record_arena.allocator(), abbrev.operands.len); + var blob: std.ArrayList(u8) = .empty; for (abbrev.operands, 0..) |abbrev_operand, abbrev_operand_i| switch (abbrev_operand) { .literal => |value| operands.appendAssumeCapacity(value), .encoding => |abbrev_encoding| switch (abbrev_encoding) { @@ -208,7 +208,7 @@ fn nextRecord(bc: *BitcodeReader) !?Record { .array => |len_width| { assert(abbrev_operand_i + 2 == abbrev.operands.len); const len: usize = @intCast(try bc.readVbr(u32, len_width)); - try operands.ensureUnusedCapacity(len); + try operands.ensureUnusedCapacity(record_arena.allocator(), len); for (0..len) |_| switch (abbrev.operands[abbrev.operands.len - 1]) { .literal => |elem_value| operands.appendAssumeCapacity(elem_value), .encoding => |elem_encoding| switch (elem_encoding) { @@ -219,14 +219,14 @@ fn nextRecord(bc: *BitcodeReader) !?Record { }, .align_32_bits, .block_len => return error.UnsupportedArrayElement, .abbrev_op => switch (try bc.readFixed(u1, 1)) { - 1 => try operands.appendSlice(&.{ + 1 => try operands.appendSlice(record_arena.allocator(), &.{ Abbrev.Operand.literal_id, try bc.readVbr(u64, 8), }), 0 => { const encoding: Abbrev.Operand.Encoding = @fromBackingInt(@intCast(try bc.readFixed(u3, 3))); - try operands.append(@backingInt(encoding)); + try operands.append(record_arena.allocator(), @backingInt(encoding)); switch (encoding) { .fixed, .vbr => try operands.append(try bc.readVbr(u7, 5)), .array, .char6, .blob => {}, @@ -243,7 +243,7 @@ fn nextRecord(bc: *BitcodeReader) !?Record { const len = std.math.cast(usize, try bc.readVbr(u32, len_width)) orelse return error.Overflow; bc.align32Bits(); - try bc.readBytes(try blob.addManyAsSlice(len)); + try bc.readBytes(try blob.addManyAsSlice(record_arena.allocator(), len)); bc.align32Bits(); }, }, diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig index 5cf1765116b517eafe92790d5cb2542ede043b83..87df03af0909cd3369498d3f9d5a0d93fa5c7e45 100644 --- a/lib/std/zig/llvm/Builder.zig +++ b/lib/std/zig/llvm/Builder.zig @@ -95,8 +95,8 @@ fn subArchName(target: *const std.Target, comptime family: std.Target.Cpu.Arch.F } pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const u8 { - var llvm_triple = std.array_list.Managed(u8).init(allocator); - defer llvm_triple.deinit(); + var llvm_triple: std.ArrayList(u8) = .empty; + defer llvm_triple.deinit(allocator); const llvm_arch = switch (target.cpu.arch) { .arm => "arm", @@ -168,7 +168,7 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const => unreachable, // Gated by hasLlvmSupport(). }; - try llvm_triple.appendSlice(llvm_arch); + try llvm_triple.appendSlice(allocator, llvm_arch); const llvm_sub_arch: ?[]const u8 = switch (target.cpu.arch) { .arm, .armeb, .thumb, .thumbeb => subArchName(target, .arm, .{ @@ -223,10 +223,10 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const else => null, }; - if (llvm_sub_arch) |sub| try llvm_triple.appendSlice(sub); - try llvm_triple.append('-'); + if (llvm_sub_arch) |sub| try llvm_triple.appendSlice(allocator, sub); + try llvm_triple.append(allocator, '-'); - try llvm_triple.appendSlice(switch (target.os.tag) { + try llvm_triple.appendSlice(allocator, switch (target.os.tag) { .driverkit, .ios, .maccatalyst, @@ -248,7 +248,7 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const => "mesa", else => "unknown", }); - try llvm_triple.append('-'); + try llvm_triple.append(allocator, '-'); const llvm_os = switch (target.os.tag) { .dragonfly => "dragonfly", @@ -298,28 +298,28 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const .ashetos, => "unknown", }; - try llvm_triple.appendSlice(llvm_os); + try llvm_triple.appendSlice(allocator, llvm_os); switch (target.os.versionRange()) { .none, .windows, => {}, .semver => |ver| if (target.os.tag == .wasi and ver.min.major == 0) { - try llvm_triple.print("p{d}", .{ver.min.minor}); + try llvm_triple.print(allocator, "p{d}", .{ver.min.minor}); } else if (target.os.tag != .amdhsa) { - try llvm_triple.print("{d}.{d}.{d}", .{ + try llvm_triple.print(allocator, "{d}.{d}.{d}", .{ ver.min.major, ver.min.minor, ver.min.patch, }); }, - inline .linux, .hurd => |ver| try llvm_triple.print("{d}.{d}.{d}", .{ + inline .linux, .hurd => |ver| try llvm_triple.print(allocator, "{d}.{d}.{d}", .{ ver.range.min.major, ver.range.min.minor, ver.range.min.patch, }), } - try llvm_triple.append('-'); + try llvm_triple.append(allocator, '-'); const llvm_abi = switch (target.abi) { .none => if (target.os.tag == .maccatalyst) "macabi" else "unknown", @@ -357,7 +357,7 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const .ohos, .ohoseabi => "ohos", .call0 => "unknown", }; - try llvm_triple.appendSlice(llvm_abi); + try llvm_triple.appendSlice(allocator, llvm_abi); switch (target.os.versionRange()) { .none, @@ -365,17 +365,17 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const .windows, => {}, inline .hurd, .linux => |ver| if (target.abi.isGnu()) { - try llvm_triple.print("{d}.{d}.{d}", .{ + try llvm_triple.print(allocator, "{d}.{d}.{d}", .{ ver.glibc.major, ver.glibc.minor, ver.glibc.patch, }); } else if (@TypeOf(ver) == std.Target.Os.LinuxVersionRange and target.abi.isAndroid()) { - try llvm_triple.print("{d}", .{ver.android}); + try llvm_triple.print(allocator, "{d}", .{ver.android}); }, } - return llvm_triple.toOwnedSlice(); + return llvm_triple.toOwnedSlice(allocator); } pub const DataLayout = struct { @@ -10442,24 +10442,24 @@ pub fn getIntrinsic( var attributes: struct { builder: *Builder, - list: std.array_list.Managed(Attribute.Index), + list: std.ArrayList(Attribute.Index), - fn deinit(state: *@This()) void { - state.list.deinit(); + fn deinit(state: *@This(), gpa: Allocator) void { + state.list.deinit(gpa); state.* = undefined; } - fn get(state: *@This(), attributes: []const Attribute) Allocator.Error!Attributes { - try state.list.resize(attributes.len); + fn get(state: *@This(), gpa: Allocator, attributes: []const Attribute) Allocator.Error!Attributes { + try state.list.resize(gpa, attributes.len); for (state.list.items, attributes) |*item, attribute| item.* = try state.builder.attr(attribute); return state.builder.attrs(state.list.items); } - } = .{ .builder = self, .list = std.array_list.Managed(Attribute.Index).init(allocator) }; - defer attributes.deinit(); + } = .{ .builder = self, .list = .empty }; + defer attributes.deinit(allocator); var overload_index: usize = 0; - function_attributes[FunctionAttributes.function_index] = try attributes.get(signature.attrs); + function_attributes[FunctionAttributes.function_index] = try attributes.get(allocator, signature.attrs); function_attributes[FunctionAttributes.return_index] = .none; // needed for void return for (0.., param_types, signature.params) |param_index, *param_type, signature_param| { switch (signature_param.kind) { @@ -10475,7 +10475,7 @@ pub fn getIntrinsic( FunctionAttributes.return_index else FunctionAttributes.params_index + (param_index - signature.ret_len) - ] = try attributes.get(signature_param.attrs); + ] = try attributes.get(allocator, signature_param.attrs); } assert(overload_index == overload.len); for (param_types, signature.params) |*param_type, signature_param| { diff --git a/lib/std/zig/llvm/bitcode_writer.zig b/lib/std/zig/llvm/bitcode_writer.zig index 9c9e9d4473c26e2c1b9fa0e63befb5bbc420fc02..819ac61d9e7a1e705fedba68164664773aa007c3 100644 --- a/lib/std/zig/llvm/bitcode_writer.zig +++ b/lib/std/zig/llvm/bitcode_writer.zig @@ -19,7 +19,8 @@ pub fn BitcodeWriter(comptime types: []const type) type { return struct { const BcWriter = @This(); - buffer: std.array_list.Managed(u32), + buffer: std.ArrayList(u32), + allocator: std.mem.Allocator, bit_buffer: u32 = 0, bit_count: u5 = 0, @@ -31,18 +32,19 @@ pub fn BitcodeWriter(comptime types: []const type) type { pub fn init(allocator: std.mem.Allocator, widths: [types.len]u16) BcWriter { return .{ - .buffer = std.array_list.Managed(u32).init(allocator), + .buffer = .empty, + .allocator = allocator, .widths = widths, }; } pub fn deinit(self: BcWriter) void { - self.buffer.deinit(); + self.buffer.deinit(self.allocator); } pub fn toOwnedSlice(self: *BcWriter) Error![]const u32 { std.debug.assert(self.bit_count == 0); - return self.buffer.toOwnedSlice(); + return self.buffer.toOwnedSlice(self.allocator); } pub fn length(self: BcWriter) usize { @@ -53,6 +55,8 @@ pub fn BitcodeWriter(comptime types: []const type) type { pub fn writeBits(self: *BcWriter, value: anytype, bits: u16) Error!void { if (bits == 0) return; + const allocator = self.allocator; + var in_buffer = bufValue(value, 32); var in_bits = bits; @@ -68,13 +72,13 @@ pub fn BitcodeWriter(comptime types: []const type) type { in_bits -= n; if (self.bit_count != 0) return; - try self.buffer.append(std.mem.nativeToLittle(u32, self.bit_buffer)); + try self.buffer.append(allocator, std.mem.nativeToLittle(u32, self.bit_buffer)); self.bit_buffer = 0; } // Write 32-bit chunks of input bits while (in_bits >= 32) { - try self.buffer.append(std.mem.nativeToLittle(u32, @truncate(in_buffer))); + try self.buffer.append(allocator, std.mem.nativeToLittle(u32, @truncate(in_buffer))); in_buffer >>= 31; in_buffer >>= 1; -- 2.54.0 From bc2c709e18b72b31b4f65ff6b9b14b9229da491e Mon Sep 17 00:00:00 2001 From: Krzysztof Wolicki Date: Fri, 23 Oct 2026 10:34:40 +0200 Subject: [PATCH 4/4] Fix missing argument changes --- lib/std/zig/llvm/BitcodeReader.zig | 2 +- lib/std/zig/llvm/bitcode_writer.zig | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/lib/std/zig/llvm/BitcodeReader.zig b/lib/std/zig/llvm/BitcodeReader.zig index 4c990e30229f4b028c61b091de87ae0eeeea12fe..345b0e40c630e854dcb35b3f75201946733817d7 100644 --- a/lib/std/zig/llvm/BitcodeReader.zig +++ b/lib/std/zig/llvm/BitcodeReader.zig @@ -228,7 +228,7 @@ fn nextRecord(bc: *BitcodeReader) !?Record { @fromBackingInt(@intCast(try bc.readFixed(u3, 3))); try operands.append(record_arena.allocator(), @backingInt(encoding)); switch (encoding) { - .fixed, .vbr => try operands.append(try bc.readVbr(u7, 5)), + .fixed, .vbr => try operands.append(record_arena.allocator(), try bc.readVbr(u7, 5)), .array, .char6, .blob => {}, _ => return error.UnsuportedAbbrevEncoding, } diff --git a/lib/std/zig/llvm/bitcode_writer.zig b/lib/std/zig/llvm/bitcode_writer.zig index 819ac61d9e7a1e705fedba68164664773aa007c3..05966f6213bc4820994e02cecea236b6f9d53e1a 100644 --- a/lib/std/zig/llvm/bitcode_writer.zig +++ b/lib/std/zig/llvm/bitcode_writer.zig @@ -38,7 +38,7 @@ pub fn BitcodeWriter(comptime types: []const type) type { }; } - pub fn deinit(self: BcWriter) void { + pub fn deinit(self: *BcWriter) void { self.buffer.deinit(self.allocator); } @@ -145,7 +145,7 @@ pub fn BitcodeWriter(comptime types: []const type) type { pub fn writeBlob(self: *BcWriter, blob: []const u8) Error!void { const blob_word_size = std.mem.alignForward(usize, blob.len, 4); - try self.buffer.ensureUnusedCapacity(blob_word_size + 1); + try self.buffer.ensureUnusedCapacity(self.allocator, blob_word_size + 1); self.alignTo32() catch unreachable; const slice = self.buffer.addManyAsSliceAssumeCapacity(blob_word_size / 4); @@ -157,7 +157,7 @@ pub fn BitcodeWriter(comptime types: []const type) type { pub fn alignTo32(self: *BcWriter) Error!void { if (self.bit_count == 0) return; - try self.buffer.append(std.mem.nativeToLittle(u32, self.bit_buffer)); + try self.buffer.append(self.allocator, std.mem.nativeToLittle(u32, self.bit_buffer)); self.bit_buffer = 0; self.bit_count = 0; } -- 2.54.0