@zigc/lib 0.16.0 → 0.17.0-dev.135

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", .{});

package/compiler/aro/aro/Compilation.zig

@@ -1761,8 +1761,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 +1977,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 +2070,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")) {

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);
@@ -607,7 +607,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);

package/compiler/test_runner.zig

@@ -488,7 +488,7 @@ var fuzz_runner: if (builtin.fuzz) struct {
     fn inputPoller() Io.Cancelable!void {
         @disableInstrumentation();
         switch (inputPollerInner()) {
-            error.Canceled => return error.Canceled,
+            error.Canceled => |e| return e,
             error.ReadFailed => {
                 if (stdin_reader.err.? == error.Canceled) return error.Canceled;
                 panic("failed to read from stdin: {t}", .{stdin_reader.err.?});
@@ -563,7 +563,7 @@ pub fn fuzz(
                     const stderr = std.debug.lockStderr(&.{}).terminal();
                     p: {
                         if (@errorReturnTrace()) |trace| {
-                            std.debug.writeStackTrace(trace, stderr) catch break :p;
+                            std.debug.writeErrorReturnTrace(trace, stderr) catch break :p;
                         }
                         stderr.writer.print("failed with error.{t}\n", .{err}) catch break :p;
                     }

package/compiler/translate-c/Translator.zig

@@ -475,8 +475,12 @@ pub const builtin_typedef_map = std.StaticStringMap([]const u8).initComptime(.{
     .{ "int8_t", "i8" },
     .{ "uint16_t", "u16" },
     .{ "int16_t", "i16" },
+    .{ "uint24_t", "u24" },
+    .{ "int24_t", "i24" },
     .{ "uint32_t", "u32" },
     .{ "int32_t", "i32" },
+    .{ "uint48_t", "u48" },
+    .{ "int48_t", "i48" },
     .{ "uint64_t", "u64" },
     .{ "int64_t", "i64" },
     .{ "intptr_t", "isize" },
@@ -1293,7 +1297,7 @@ fn transType(t: *Translator, scope: *Scope, qt: QualType, source_loc: TokenIndex
                     error.SelfReferential => {},
                     error.UnsupportedTranslation => {},
                     error.UnsupportedType => {},
-                    error.OutOfMemory => return error.OutOfMemory,
+                    error.OutOfMemory => |e| return e,
                 }
             }
             continue :loop typeof_ty.base.type(t.comp);
@@ -4095,7 +4099,7 @@ fn createIntNode(t: *Translator, int: aro.Value) !ZigNode {
     big.positive = true;
 
     const str = big.toStringAlloc(t.arena, 10, .lower) catch |err| switch (err) {
-        error.OutOfMemory => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
     };
     const res = try ZigTag.integer_literal.create(t.arena, str);
     if (is_negative) return ZigTag.negate.create(t.arena, res);

package/compiler/translate-c/main.zig

@@ -225,7 +225,7 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: []const [:0]const u8, zig
     const source = d.inputs.items[0];
 
     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", .{}),
     };
     try tc.defineSystemIncludes();

package/compiler_rt/cos.zig

@@ -173,8 +173,6 @@ pub fn cosq(x: f128) callconv(.c) f128 {
 
 pub fn cosl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return cosh(x),
-        32 => return cosf(x),
         64 => return cos(x),
         80 => return cosx(x),
         128 => return cosq(x),