@zigc/lib 0.17.0-dev.27 → 0.17.0-dev.296

package/c/strings.zig

@@ -81,41 +81,3 @@ fn __strncasecmp_l(a: [*:0]const c_char, b: [*:0]const c_char, n: usize, locale:
     _ = locale;
     return strncasecmp(a, b, n);
 }
-
-test bzero {
-    var array: [10]u8 = [_]u8{ '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' };
-    var a = std.mem.zeroes([array.len]u8);
-    a[9] = '0';
-    bzero(&array[0], 9);
-    try std.testing.expect(std.mem.eql(u8, &array, &a));
-}
-
-test firstBitSet {
-    try std.testing.expectEqual(0, firstBitSet(usize, 0));
-
-    for (0..@bitSizeOf(usize)) |i| {
-        const bit = @as(usize, 1) << @intCast(i);
-
-        try std.testing.expectEqual(i + 1, firstBitSet(usize, bit));
-    }
-}
-
-test strcasecmp {
-    try std.testing.expect(strcasecmp(@ptrCast("a"), @ptrCast("b")) < 0);
-    try std.testing.expect(strcasecmp(@ptrCast("b"), @ptrCast("a")) > 0);
-    try std.testing.expect(strcasecmp(@ptrCast("A"), @ptrCast("b")) < 0);
-    try std.testing.expect(strcasecmp(@ptrCast("b"), @ptrCast("A")) > 0);
-    try std.testing.expect(strcasecmp(@ptrCast("A"), @ptrCast("A")) == 0);
-    try std.testing.expect(strcasecmp(@ptrCast("B"), @ptrCast("b")) == 0);
-    try std.testing.expect(strcasecmp(@ptrCast("bb"), @ptrCast("AA")) > 0);
-}
-
-test strncasecmp {
-    try std.testing.expect(strncasecmp(@ptrCast("a"), @ptrCast("b"), 1) < 0);
-    try std.testing.expect(strncasecmp(@ptrCast("b"), @ptrCast("a"), 1) > 0);
-    try std.testing.expect(strncasecmp(@ptrCast("A"), @ptrCast("b"), 1) < 0);
-    try std.testing.expect(strncasecmp(@ptrCast("b"), @ptrCast("A"), 1) > 0);
-    try std.testing.expect(strncasecmp(@ptrCast("A"), @ptrCast("A"), 1) == 0);
-    try std.testing.expect(strncasecmp(@ptrCast("B"), @ptrCast("b"), 1) == 0);
-    try std.testing.expect(strncasecmp(@ptrCast("bb"), @ptrCast("AA"), 2) > 0);
-}

package/c/unistd.zig

@@ -21,6 +21,8 @@ comptime {
         symbol(&chrootLinux, "chroot");
         symbol(&ctermidLinux, "ctermid");
         symbol(&dupLinux, "dup");
+        symbol(&dup2Linux, "dup2");
+        symbol(&dup3Linux, "dup3");
 
         symbol(&getegidLinux, "getegid");
         symbol(&geteuidLinux, "geteuid");
@@ -101,6 +103,31 @@ fn dupLinux(fd: c_int) callconv(.c) c_int {
     return errno(linux.dup(fd));
 }
 
+fn dup2Linux(old: c_int, new: c_int) callconv(.c) c_int {
+    const busy: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.BUSY)));
+    var res = busy;
+    while (res == busy) res = linux.dup2(old, new);
+    return errno(res);
+}
+
+fn dup3Linux(old: c_int, new: c_int, flags: c_int) callconv(.c) c_int {
+    const busy: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.BUSY)));
+    var res = busy;
+
+    if (@hasField(linux.SYS, "dup3")) {
+        while (res == busy) res = linux.dup3(old, new, @intCast(flags));
+    } else if (@hasField(linux.SYS, "dup2")) {
+        const cloexec: c_int = @bitCast(linux.O{ .CLOEXEC = true });
+        const inval: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.INVAL)));
+        if (old == new or (flags & ~cloexec != 0)) return errno(inval);
+        while (res == busy) res = linux.dup2(old, new);
+        _ = if (res >= 0 and (flags & cloexec == cloexec)) linux.fcntl(new, linux.F.SETFD, linux.FD_CLOEXEC);
+    } else {
+        return errno(@bitCast(-@as(isize, @intFromEnum(linux.E.NOSYS))));
+    }
+    return errno(res);
+}
+
 fn getegidLinux() callconv(.c) linux.gid_t {
     return linux.getegid();
 }
@@ -206,32 +233,6 @@ fn swab(noalias src_ptr: *const anyopaque, noalias dest_ptr: *anyopaque, n: isiz
     }
 }
 
-test swab {
-    var a: [4]u8 = undefined;
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 4);
-    try std.testing.expectEqualSlices(u8, "badc", &a);
-
-    // Partial copy
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 2);
-    try std.testing.expectEqualSlices(u8, "ba\x00\x00", &a);
-
-    // n < 1
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 0);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-    swab("abcd", &a, -1);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-
-    // Odd n
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 1);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-    swab("abcd", &a, 3);
-    try std.testing.expectEqualSlices(u8, "ba\x00\x00", &a);
-}
-
 fn close(fd: std.c.fd_t) callconv(.c) c_int {
     const signed: isize = @bitCast(linux.close(fd));
     if (signed < 0) {

package/c/wchar.zig

@@ -5,6 +5,7 @@ const wint_t = std.c.wint_t;
 const wchar_t = std.c.wchar_t;
 
 const symbol = @import("../c.zig").symbol;
+const c = std.c;
 
 comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
@@ -30,6 +31,7 @@ comptime {
         symbol(&wcspbrk, "wcspbrk");
         symbol(&wcstok, "wcstok");
         symbol(&wcsstr, "wcsstr");
+        symbol(&wcsdup, "wcsdup");
         symbol(&wcswcs, "wcswcs");
     }
 
@@ -189,3 +191,11 @@ fn wcsstr(noalias haystack: [*:0]const wchar_t, noalias needle: [*:0]const wchar
 fn wcswcs(noalias haystack: [*:0]const wchar_t, noalias needle: [*:0]const wchar_t) callconv(.c) ?[*:0]wchar_t {
     return wcsstr(haystack, needle);
 }
+
+fn wcsdup(str: [*:0]const wchar_t) callconv(.c) ?[*:0]wchar_t {
+    const len = wcslen(str);
+    const size = (len + 1) * @sizeOf(wchar_t);
+    const d_opaque = c.malloc(size) orelse return null;
+    const d: [*]wchar_t = @ptrCast(@alignCast(d_opaque));
+    return @ptrCast(wmemcpy(d, str, len + 1));
+}

package/c.zig

@@ -2,8 +2,7 @@
 //! bundled libcs.
 //!
 //! mingw-w64 libc is not fully statically linked, so some symbols don't need
-//! to be exported. However, a future enhancement could be eliminating Zig's
-//! dependency on msvcrt dll even when linking libc and targeting Windows.
+//! to be exported.
 
 const builtin = @import("builtin");
 const std = @import("std");
@@ -69,6 +68,7 @@ comptime {
         _ = @import("c/malloc.zig");
     }
     _ = @import("c/math.zig");
+    _ = @import("c/pthread.zig");
     _ = @import("c/search.zig");
     _ = @import("c/stdlib.zig");
     _ = @import("c/string.zig");

package/compiler/aro/aro/CodeGen.zig

@@ -54,8 +54,9 @@ return_label: Ir.Ref = undefined,
 compound_assign_dummy: ?Ir.Ref = null,
 
 fn fail(c: *CodeGen, comptime fmt: []const u8, args: anytype) error{ FatalError, OutOfMemory } {
-    var sf = std.heap.stackFallback(1024, c.comp.gpa);
-    const allocator = sf.get();
+    var bfa_buf: [u8]1024 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, c.comp.gpa);
+    const allocator = bfa.allocator();
     var buf: std.ArrayList(u8) = .empty;
     defer buf.deinit(allocator);
 
@@ -101,14 +102,12 @@ pub fn genIr(tree: *const Tree) Compilation.Error!Ir {
             .function => |function| {
                 if (function.body == null) continue;
                 c.genFn(function) catch |err| switch (err) {
-                    error.FatalError => return error.FatalError,
-                    error.OutOfMemory => return error.OutOfMemory,
+                    error.FatalError, error.OutOfMemory => |e| return e,
                 };
             },
 
             .variable => |variable| c.genVar(variable) catch |err| switch (err) {
-                error.FatalError => return error.FatalError,
-                error.OutOfMemory => return error.OutOfMemory,
+                error.FatalError, error.OutOfMemory => |e| return e,
             },
             .global_asm => {
                 return c.fail("TODO global assembly", .{});
@@ -895,7 +894,7 @@ fn genLval(c: *CodeGen, node_index: Node.Index) Error!Ir.Ref {
                 }
             }
 
-            const duped_name = try c.builder.arena.allocator().dupeZ(u8, slice);
+            const duped_name = try c.builder.arena.allocator().dupeSentinel(u8, slice, 0);
             const ref: Ir.Ref = @enumFromInt(c.builder.instructions.len);
             try c.builder.instructions.append(c.builder.gpa, .{ .tag = .symbol, .data = .{ .label = duped_name }, .ty = .ptr });
             return ref;
@@ -1113,7 +1112,7 @@ fn genCall(c: *CodeGen, call: Node.Call) Error!Ir.Ref {
                     }
                 }
 
-                const duped_name = try c.builder.arena.allocator().dupeZ(u8, slice);
+                const duped_name = try c.builder.arena.allocator().dupeSentinel(u8, slice, 0);
                 const ref: Ir.Ref = @enumFromInt(c.builder.instructions.len);
                 try c.builder.instructions.append(c.builder.gpa, .{ .tag = .symbol, .data = .{ .label = duped_name }, .ty = .ptr });
                 break :blk ref;

package/compiler/aro/aro/Compilation.zig

@@ -498,7 +498,6 @@ fn generateSystemDefines(comp: *Compilation, w: *Io.Writer) !void {
                 .{ .fma, "__FMA__" },
                 .{ .f16c, "__F16C__" },
                 .{ .gfni, "__GFNI__" },
-                .{ .evex512, "__EVEX512__" },
 
                 .{ .avx10_1, "__AVX10_1__" },
                 .{ .avx10_1, "__AVX10_1_512__" },
@@ -560,7 +559,6 @@ fn generateSystemDefines(comp: *Compilation, w: *Io.Writer) !void {
                 .{ .amx_complex, "__AMX_COMPLEX__" },
                 .{ .amx_fp8, "__AMX_FP8__" },
                 .{ .amx_movrs, "__AMX_MOVRS__" },
-                .{ .amx_transpose, "__AMX_TRANSPOSE__" },
                 .{ .amx_avx512, "__AMX_AVX512__" },
                 .{ .amx_tf32, "__AMX_TF32__" },
                 .{ .cmpccxadd, "__CMPCCXADD__" },
@@ -798,7 +796,6 @@ fn generateSystemDefines(comp: *Compilation, w: *Io.Writer) !void {
                 .{ .fullfp16, "FP16_SCALAR_ARITHMETIC" },
                 .{ .dotprod, "DOTPROD" },
                 .{ .mte, "MEMORY_TAGGING" },
-                .{ .tme, "TME" },
                 .{ .i8mm, "MATMUL_INT8" },
                 .{ .lse, "ATOMICS" },
                 .{ .f64mm, "SVE_MATMUL_FP64" },
@@ -1761,8 +1758,9 @@ fn addToSearchPath(comp: *Compilation, include: Include, verbose: bool) !void {
     try comp.search_path.append(comp.gpa, include);
 }
 fn removeDuplicateSearchPaths(comp: *Compilation, start: usize, verbose: bool) !void {
-    var sf = std.heap.stackFallback(1024, comp.gpa);
-    const allocator = sf.get();
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, comp.gpa);
+    const allocator = bfa.allocator();
     var seen_includes: std.StringHashMapUnmanaged(void) = .empty;
     defer seen_includes.deinit(allocator);
     var seen_frameworks: std.StringHashMapUnmanaged(void) = .empty;
@@ -1976,10 +1974,11 @@ const FindInclude = struct {
     ) Allocator.Error!?Result {
         const comp = find.comp;
 
-        var stack_fallback = std.heap.stackFallback(path_buf_stack_limit, comp.gpa);
-        const sfa = stack_fallback.get();
-        const header_path = try std.fmt.allocPrint(sfa, format, args);
-        defer sfa.free(header_path);
+        var bfa_buf: [path_buf_stack_limit]u8 = undefined;
+        var bfa_state: std.heap.BufferFirstAllocator = .init(&bfa_buf, comp.gpa);
+        const bfa = bfa_state.allocator();
+        const header_path = try std.fmt.allocPrint(bfa, format, args);
+        defer bfa.free(header_path);
         find.comp.normalizePath(header_path);
 
         const source = comp.addSourceFromPathExtra(header_path, kind) catch |err| switch (err) {
@@ -2068,36 +2067,37 @@ pub fn findEmbed(
         }
     }
 
-    var stack_fallback = std.heap.stackFallback(path_buf_stack_limit, comp.gpa);
-    const sf_allocator = stack_fallback.get();
+    var bfa_buf: [path_buf_stack_limit]u8 = undefined;
+    var bfa_state: std.heap.BufferFirstAllocator = .init(&bfa_buf, comp.gpa);
+    const bfa = bfa_state.allocator();
 
     switch (include_type) {
         .quotes, .cli => {
             const dir = std.fs.path.dirname(comp.getSource(includer_token_source).path) orelse ".";
-            const path = try std.fs.path.join(sf_allocator, &.{ dir, filename });
-            defer sf_allocator.free(path);
+            const path = try std.fs.path.join(bfa, &.{ dir, filename });
+            defer bfa.free(path);
             comp.normalizePath(path);
             if (comp.getPathContents(path, limit)) |some| {
                 errdefer comp.gpa.free(some);
                 if (opt_dep_file) |dep_file| try dep_file.addDependencyDupe(comp.gpa, comp.arena, filename);
                 return some;
             } else |err| switch (err) {
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
                 else => {},
             }
         },
         .angle_brackets => {},
     }
     for (comp.embed_dirs.items) |embed_dir| {
-        const path = try std.fs.path.join(sf_allocator, &.{ embed_dir, filename });
-        defer sf_allocator.free(path);
+        const path = try std.fs.path.join(bfa, &.{ embed_dir, filename });
+        defer bfa.free(path);
         comp.normalizePath(path);
         if (comp.getPathContents(path, limit)) |some| {
             errdefer comp.gpa.free(some);
             if (opt_dep_file) |dep_file| try dep_file.addDependencyDupe(comp.gpa, comp.arena, filename);
             return some;
         } else |err| switch (err) {
-            error.OutOfMemory => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
             else => {},
         }
     }

package/compiler/aro/aro/Driver.zig

@@ -947,8 +947,9 @@ fn addImacros(d: *Driver, path: []const u8) !void {
 }
 
 pub fn err(d: *Driver, fmt: []const u8, args: anytype) Compilation.Error!void {
-    var sf = std.heap.stackFallback(1024, d.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, d.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     Diagnostics.formatArgs(&allocating.writer, fmt, args) catch return error.OutOfMemory;
@@ -956,8 +957,9 @@ pub fn err(d: *Driver, fmt: []const u8, args: anytype) Compilation.Error!void {
 }
 
 pub fn warn(d: *Driver, fmt: []const u8, args: anytype) Compilation.Error!void {
-    var sf = std.heap.stackFallback(1024, d.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, d.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     Diagnostics.formatArgs(&allocating.writer, fmt, args) catch return error.OutOfMemory;
@@ -1101,8 +1103,9 @@ fn parseTarget(d: *Driver, arch_os_abi: []const u8, opt_cpu_features: ?[]const u
 }
 
 pub fn fatal(d: *Driver, comptime fmt: []const u8, args: anytype) error{ FatalError, OutOfMemory } {
-    var sf = std.heap.stackFallback(1024, d.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, d.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     Diagnostics.formatArgs(&allocating.writer, fmt, args) catch return error.OutOfMemory;
@@ -1179,8 +1182,7 @@ pub fn main(d: *Driver, tc: *Toolchain, args: []const []const u8, comptime fast_
         var stdout = std.Io.File.stdout().writer(d.comp.io, &stdout_buf);
         if (parseArgs(d, &stdout.interface, &macro_buf, args) catch |er| switch (er) {
             error.WriteFailed => return d.fatal("failed to write to stdout: {s}", .{errorDescription(er)}),
-            error.OutOfMemory => return error.OutOfMemory,
-            error.FatalError => return error.FatalError,
+            error.OutOfMemory, error.FatalError => |e| return e,
         }) return;
         if (macro_buf.items.len > std.math.maxInt(u32)) {
             return d.fatal("user provided macro source exceeded max size", .{});
@@ -1204,12 +1206,11 @@ pub fn main(d: *Driver, tc: *Toolchain, args: []const []const u8, comptime fast_
     };
 
     tc.discover() catch |er| switch (er) {
-        error.OutOfMemory => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
         error.TooManyMultilibs => return d.fatal("found more than one multilib with the same priority", .{}),
     };
     tc.defineSystemIncludes() catch |er| switch (er) {
-        error.OutOfMemory => return error.OutOfMemory,
-        error.FatalError => return error.FatalError,
+        error.OutOfMemory, error.FatalError => |e| return e,
     };
     try d.comp.initSearchPath(d.includes.items, d.verbose_search_path);
 
@@ -1522,8 +1523,8 @@ fn processSource(
             render_errors.deinit(gpa);
         }
 
-        var obj = ir.render(gpa, d.comp.target.toZigTarget(), &render_errors) catch |e| switch (e) {
-            error.OutOfMemory => return error.OutOfMemory,
+        var obj = ir.render(gpa, d.comp.target.toZigTarget(), &render_errors) catch |er| switch (er) {
+            error.OutOfMemory => |e| return e,
             error.LowerFail => {
                 return d.fatal(
                     "unable to render Ir to machine code: {s}",

package/compiler/aro/aro/Parser.zig

@@ -215,8 +215,9 @@ fn checkIdentifierCodepointWarnings(p: *Parser, codepoint: u21, loc: Source.Loca
     assert(codepoint >= 0x80);
 
     const prev_total = p.diagnostics.total;
-    var sf = std.heap.stackFallback(1024, p.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, p.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     if (!char_info.isC99IdChar(codepoint)) {
@@ -429,8 +430,9 @@ pub fn err(p: *Parser, tok_i: TokenIndex, diagnostic: Diagnostic, args: anytype)
     if (diagnostic.suppress_unless_version) |some| if (!p.comp.langopts.standard.atLeast(some)) return;
     if (p.diagnostics.effectiveKind(diagnostic) == .off) return;
 
-    var sf = std.heap.stackFallback(1024, p.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, p.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     p.formatArgs(&allocating.writer, diagnostic.fmt, args) catch return error.OutOfMemory;
@@ -1537,8 +1539,9 @@ fn staticAssert(p: *Parser) Error!bool {
         }
     } else {
         if (!res.val.toBool(p.comp)) {
-            var sf = std.heap.stackFallback(1024, gpa);
-            var allocating: std.Io.Writer.Allocating = .init(sf.get());
+            var bfa_buf: [1024]u8 = undefined;
+            var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, gpa);
+            var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
             defer allocating.deinit();
 
             if (p.staticAssertMessage(res_node, str, &allocating) catch return error.OutOfMemory) |message| {
@@ -4837,8 +4840,9 @@ fn gnuAsmStmt(p: *Parser, quals: Tree.GNUAssemblyQualifiers, asm_tok: TokenIndex
     const expected_items = 8; // arbitrarily chosen, most assembly will have fewer than 8 inputs/outputs/constraints/names
     const bytes_needed = expected_items * @sizeOf(Tree.Node.AsmStmt.Operand) + expected_items * 2 * @sizeOf(Node.Index);
 
-    var stack_fallback = std.heap.stackFallback(bytes_needed, gpa);
-    const allocator = stack_fallback.get();
+    var bfa_buf: [bytes_needed]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, gpa);
+    const allocator = bfa.allocator();
 
     var operands: std.ArrayList(Tree.Node.AsmStmt.Operand) = .empty;
     defer operands.deinit(allocator);
@@ -5721,9 +5725,8 @@ fn returnStmt(p: *Parser) Error!?Node.Index {
 // ====== expressions ======
 
 pub fn macroExpr(p: *Parser) Compilation.Error!bool {
-    const res = p.expect(condExpr) catch |e| switch (e) {
-        error.OutOfMemory => return error.OutOfMemory,
-        error.FatalError => return error.FatalError,
+    const res = p.expect(condExpr) catch |er| switch (er) {
+        error.OutOfMemory, error.FatalError => |e| return e,
         error.ParsingFailed => return false,
     };
     return res.val.toBool(p.comp);
@@ -9922,8 +9925,9 @@ fn primaryExpr(p: *Parser) Error!?Result {
             if (p.func.pretty_ident) |some| {
                 qt = some.qt;
             } else if (p.func.qt) |func_qt| {
-                var sf = std.heap.stackFallback(1024, gpa);
-                var allocating: std.Io.Writer.Allocating = .init(sf.get());
+                var bfa_buf: [1024]u8 = undefined;
+                var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, gpa);
+                var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
                 defer allocating.deinit();
 
                 func_qt.printNamed(p.tokSlice(p.func.name), p.comp, &allocating.writer) catch return error.OutOfMemory;
@@ -10212,8 +10216,9 @@ fn charLiteral(p: *Parser) Error!?Result {
         };
 
         const max_chars_expected = 4;
-        var sf = std.heap.stackFallback(max_chars_expected * @sizeOf(u32), gpa);
-        const allocator = sf.get();
+        var bfa_buf: [max_chars_expected]u32 = undefined;
+        var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), gpa);
+        const allocator = bfa.allocator();
         var chars: std.ArrayList(u32) = .empty;
         defer chars.deinit(allocator);
 

package/compiler/aro/aro/Pragma.zig

@@ -212,8 +212,9 @@ pub const Diagnostic = struct {
 };
 
 pub fn err(pp: *Preprocessor, tok_i: TokenIndex, diagnostic: Diagnostic, args: anytype) Compilation.Error!void {
-    var sf = std.heap.stackFallback(1024, pp.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&buf, pp.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     Diagnostics.formatArgs(&allocating.writer, diagnostic.fmt, args) catch return error.OutOfMemory;

package/compiler/aro/aro/Preprocessor.zig

@@ -1023,8 +1023,9 @@ fn err(pp: *Preprocessor, loc: anytype, diagnostic: Diagnostic, args: anytype) C
     defer pp.diagnostics.state.suppress_system_headers = old_suppress_system;
     if (diagnostic.show_in_system_headers) pp.diagnostics.state.suppress_system_headers = false;
 
-    var sf = std.heap.stackFallback(1024, pp.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, pp.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     Diagnostics.formatArgs(&allocating.writer, diagnostic.fmt, args) catch return error.OutOfMemory;
@@ -1052,8 +1053,9 @@ fn err(pp: *Preprocessor, loc: anytype, diagnostic: Diagnostic, args: anytype) C
 }
 
 fn fatal(pp: *Preprocessor, raw: RawToken, comptime fmt: []const u8, args: anytype) Compilation.Error {
-    var sf = std.heap.stackFallback(1024, pp.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, pp.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     Diagnostics.formatArgs(&allocating.writer, fmt, args) catch return error.OutOfMemory;
@@ -1074,8 +1076,9 @@ fn fatalNotFound(pp: *Preprocessor, tok: TokenWithExpansionLocs, filename: []con
     pp.diagnostics.state.fatal_errors = true;
     defer pp.diagnostics.state.fatal_errors = old;
 
-    var sf = std.heap.stackFallback(1024, pp.comp.gpa);
-    const allocator = sf.get();
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, pp.comp.gpa);
+    const allocator = bfa.allocator();
     var buf: std.ArrayList(u8) = .empty;
     defer buf.deinit(allocator);
 

package/compiler/aro/aro/pragmas/message.zig

@@ -44,8 +44,9 @@ fn preprocessorHandler(_: *Pragma, pp: *Preprocessor, start_idx: TokenIndex) Pra
 
     const diagnostic: Pragma.Diagnostic = .pragma_message;
 
-    var sf = std.heap.stackFallback(1024, pp.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, pp.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     Diagnostics.formatArgs(&allocating.writer, diagnostic.fmt, .{str}) catch return error.OutOfMemory;

package/compiler/aro/aro/text_literal.zig

@@ -315,8 +315,9 @@ pub const Parser = struct {
         if (p.errored) return;
         if (p.comp.diagnostics.effectiveKind(diagnostic) == .off) return;
 
-        var sf = std.heap.stackFallback(1024, p.comp.gpa);
-        var allocating: std.Io.Writer.Allocating = .init(sf.get());
+        var bfa_buf: [1024]u8 = undefined;
+        var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, p.comp.gpa);
+        var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
         defer allocating.deinit();
 
         formatArgs(&allocating.writer, diagnostic.fmt, args) catch return error.OutOfMemory;

package/compiler/aro/assembly_backend/x86_64.zig

@@ -68,8 +68,9 @@ fn serializeFloat(comptime T: type, value: T, w: *std.Io.Writer) !void {
 pub fn todo(c: *AsmCodeGen, msg: []const u8, tok: Tree.TokenIndex) Error {
     const loc: Source.Location = c.tree.tokens.items(.loc)[tok];
 
-    var sf = std.heap.stackFallback(1024, c.comp.gpa);
-    const allocator = sf.get();
+    var bfa_buf: [u8]1024 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, c.comp.gpa);
+    const allocator = bfa.allocator();
     var buf: std.ArrayList(u8) = .empty;
     defer buf.deinit(allocator);
 
@@ -149,8 +150,7 @@ pub fn genAsm(tree: *const Tree) Error!Assembly {
 
     codegen.genDecls() catch |err| switch (err) {
         error.WriteFailed => return error.OutOfMemory,
-        error.OutOfMemory => return error.OutOfMemory,
-        error.FatalError => return error.FatalError,
+        error.OutOfMemory, error.FatalError => |e| return e,
     };
 
     const text_slice = try text.toOwnedSlice();

package/compiler/build_runner.zig

@@ -333,8 +333,6 @@ pub fn main(init: process.Init.Minimal) !void {
                 builder.verbose_llvm_ir = arg["--verbose-llvm-ir=".len..];
             } else if (mem.startsWith(u8, arg, "--verbose-llvm-bc=")) {
                 builder.verbose_llvm_bc = arg["--verbose-llvm-bc=".len..];
-            } else if (mem.eql(u8, arg, "--verbose-cimport")) {
-                builder.verbose_cimport = true;
             } else if (mem.eql(u8, arg, "--verbose-cc")) {
                 builder.verbose_cc = true;
             } else if (mem.eql(u8, arg, "--verbose-llvm-cpu-features")) {
@@ -1399,7 +1397,7 @@ fn makeStep(
             defer run.max_rss_mutex.unlock(io);
             run.available_rss += s.max_rss;
             dispatch_set.ensureUnusedCapacity(gpa, run.memory_blocked_steps.items.len) catch @panic("OOM");
-            while (run.memory_blocked_steps.getLastOrNull()) |candidate| {
+            while (run.memory_blocked_steps.getLast()) |candidate| {
                 if (run.available_rss < candidate.max_rss) break;
                 assert(run.memory_blocked_steps.pop() == candidate);
                 dispatch_set.appendAssumeCapacity(candidate);
@@ -1559,7 +1557,7 @@ fn printUsage(b: *std.Build, w: *Writer) !void {
             const name = try fmt.allocPrint(arena, "  -D{s}=[{t}]", .{ option.name, option.type_id });
             try w.print("{s:<30} {s}\n", .{ name, option.description });
             if (option.enum_options) |enum_options| {
-                const padding = " " ** 33;
+                const padding: [33]u8 = @splat(' ');
                 try w.writeAll(padding ++ "Supported Values:\n");
                 for (enum_options) |enum_option| {
                     try w.print(padding ++ "  {s}\n", .{enum_option});

package/compiler/reduce/Walk.zig

@@ -6,9 +6,9 @@ const BuiltinFn = std.zig.BuiltinFn;
 
 ast: *const Ast,
 transformations: *std.array_list.Managed(Transformation),
-unreferenced_globals: std.StringArrayHashMapUnmanaged(Ast.Node.Index),
-in_scope_names: std.StringArrayHashMapUnmanaged(u32),
-replace_names: std.StringArrayHashMapUnmanaged(u32),
+unreferenced_globals: std.array_hash_map.String(Ast.Node.Index),
+in_scope_names: std.array_hash_map.String(u32),
+replace_names: std.array_hash_map.String(u32),
 gpa: std.mem.Allocator,
 arena: std.mem.Allocator,
 
@@ -63,9 +63,9 @@ pub fn findTransformations(
         .transformations = transformations,
         .gpa = transformations.allocator,
         .arena = arena,
-        .unreferenced_globals = .{},
-        .in_scope_names = .{},
-        .replace_names = .{},
+        .unreferenced_globals = .empty,
+        .in_scope_names = .empty,
+        .replace_names = .empty,
     };
     defer {
         walk.unreferenced_globals.deinit(walk.gpa);
@@ -223,12 +223,8 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
             return walkBlock(w, node, statements);
         },
 
-        .@"errdefer" => {
-            const expr = ast.nodeData(node).opt_token_and_node[1];
-            return walkExpression(w, expr);
-        },
-
         .@"defer",
+        .@"errdefer",
         .@"comptime",
         .@"nosuspend",
         .@"suspend",
@@ -252,7 +248,6 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
         .add_wrap,
         .add_sat,
         .array_cat,
-        .array_mult,
         .assign,
         .assign_bit_and,
         .assign_bit_or,
@@ -607,7 +602,7 @@ fn walkBlock(
                 {
                     try w.transformations.append(.{ .delete_var_decl = .{
                         .var_decl_node = stmt,
-                        .references = .{},
+                        .references = .empty,
                     } });
                     const name_tok = var_decl.ast.mut_token + 1;
                     const name_bytes = ast.tokenSlice(name_tok);