Zig 0.15: zig build test

Author: mitchellh

build.zig

@@ -276,6 +276,8 @@ pub fn build(b: *std.Build) !void {
                 .omit_frame_pointer = false,
                 .unwind_tables = .sync,
             }),
+            // Crash on x86_64 without this
+            .use_llvm = true,
         });
         if (config.emit_test_exe) b.installArtifact(test_exe);
         _ = try deps.add(test_exe);
@@ -285,7 +287,7 @@ pub fn build(b: *std.Build) !void {
         test_step.dependOn(&test_run.step);
 
         // Normal tests always test our libghostty modules
-        test_step.dependOn(test_lib_vt_step);
+        //test_step.dependOn(test_lib_vt_step);
 
         // Valgrind test running
         const valgrind_run = b.addSystemCommand(&.{

src/Command.zig

@@ -194,7 +194,9 @@ fn startPosix(self: *Command, arena: Allocator) !void {
     // child process so there isn't much we can do. We try to output
     // something reasonable. Its important to note we MUST NOT return
     // any other error condition from here on out.
-    const stderr = std.io.getStdErr().writer();
+    var stderr_buf: [1024]u8 = undefined;
+    var stderr_writer = std.fs.File.stderr().writer(&stderr_buf);
+    const stderr = &stderr_writer.interface;
     switch (err) {
         error.FileNotFound => stderr.print(
             \\Requested executable not found. Please verify the command is on
@@ -211,6 +213,7 @@ fn startPosix(self: *Command, arena: Allocator) !void {
             .{err},
         ) catch {},
     }
+    stderr.flush() catch {};
 
     // We return a very specific error that can be detected to determine
     // we're in the child.
@@ -464,34 +467,35 @@ fn createWindowsEnvBlock(allocator: mem.Allocator, env_map: *const EnvMap) ![]u1
 
 /// Copied from Zig. This function could be made public in child_process.zig instead.
 fn windowsCreateCommandLine(allocator: mem.Allocator, argv: []const []const u8) ![:0]u8 {
-    var buf = std.ArrayList(u8).init(allocator);
+    var buf: std.Io.Writer.Allocating = .init(allocator);
     defer buf.deinit();
+    const writer = &buf.writer;
 
     for (argv, 0..) |arg, arg_i| {
-        if (arg_i != 0) try buf.append(' ');
+        if (arg_i != 0) try writer.writeByte(' ');
         if (mem.indexOfAny(u8, arg, " \t\n\"") == null) {
-            try buf.appendSlice(arg);
+            try writer.writeAll(arg);
             continue;
         }
-        try buf.append('"');
+        try writer.writeByte('"');
         var backslash_count: usize = 0;
         for (arg) |byte| {
             switch (byte) {
                 '\\' => backslash_count += 1,
                 '"' => {
-                    try buf.appendNTimes('\\', backslash_count * 2 + 1);
-                    try buf.append('"');
+                    try writer.splatByteAll('\\', backslash_count * 2 + 1);
+                    try writer.writeByte('"');
                     backslash_count = 0;
                 },
                 else => {
-                    try buf.appendNTimes('\\', backslash_count);
-                    try buf.append(byte);
+                    try writer.splatByteAll('\\', backslash_count);
+                    try writer.writeByte(byte);
                     backslash_count = 0;
                 },
             }
         }
-        try buf.appendNTimes('\\', backslash_count * 2);
-        try buf.append('"');
+        try writer.splatByteAll('\\', backslash_count * 2);
+        try writer.writeByte('"');
     }
 
     return buf.toOwnedSliceSentinel(0);

src/apprt/gtk/build/blueprint.zig

@@ -45,7 +45,7 @@ pub fn main() !void {
         std.debug.print(
             \\`libadwaita` is too old.
             \\
-            \\Ghostty requires a version {} or newer of `libadwaita` to
+            \\Ghostty requires a version {f} or newer of `libadwaita` to
             \\compile this blueprint. Please install it, ensure that it is
             \\available on your PATH, and then retry building Ghostty.
         , .{required_adwaita_version});
@@ -80,7 +80,7 @@ pub fn main() !void {
                 std.debug.print(
                     \\`blueprint-compiler` not found.
                     \\
-                    \\Ghostty requires version {} or newer of
+                    \\Ghostty requires version {f} or newer of
                     \\`blueprint-compiler` as a build-time dependency starting
                     \\from version 1.2. Please install it, ensure that it is
                     \\available on your PATH, and then retry building Ghostty.
@@ -104,7 +104,7 @@ pub fn main() !void {
             std.debug.print(
                 \\`blueprint-compiler` is the wrong version.
                 \\
-                \\Ghostty requires version {} or newer of
+                \\Ghostty requires version {f} or newer of
                 \\`blueprint-compiler` as a build-time dependency starting
                 \\from version 1.2. Please install it, ensure that it is
                 \\available on your PATH, and then retry building Ghostty.
@@ -145,7 +145,7 @@ pub fn main() !void {
                 std.debug.print(
                     \\`blueprint-compiler` not found.
                     \\
-                    \\Ghostty requires version {} or newer of
+                    \\Ghostty requires version {f} or newer of
                     \\`blueprint-compiler` as a build-time dependency starting
                     \\from version 1.2. Please install it, ensure that it is
                     \\available on your PATH, and then retry building Ghostty.

src/apprt/gtk/build/gresource.zig

@@ -142,7 +142,9 @@ pub fn main() !void {
         );
     }
 
-    const writer = std.io.getStdOut().writer();
+    var buf: [4096]u8 = undefined;
+    var stdout = std.fs.File.stdout().writer(&buf);
+    const writer = &stdout.interface;
     try writer.writeAll(
         \\<?xml version="1.0" encoding="UTF-8"?>
         \\<gresources>
@@ -157,6 +159,8 @@ pub fn main() !void {
         \\</gresources>
         \\
     );
+
+    try stdout.end();
 }
 
 /// Generate the icon resources. This works by looking up all the icons

src/apprt/gtk/class/config.zig

@@ -117,18 +117,18 @@ pub const Config = extern struct {
         errdefer text_buf.unref();
 
         var buf: [4095:0]u8 = undefined;
-        var fbs = std.io.fixedBufferStream(&buf);
+        var writer: std.Io.Writer = .fixed(&buf);
         for (config._diagnostics.items()) |diag| {
-            fbs.reset();
-            diag.write(fbs.writer()) catch |err| {
+            writer.end = 0;
+            diag.format(&writer) catch |err| {
                 log.warn(
                     "error writing diagnostic to buffer err={}",
                     .{err},
                 );
                 continue;
             };
 
-            text_buf.insertAtCursor(&buf, @intCast(fbs.pos));
+            text_buf.insertAtCursor(&buf, @intCast(writer.end));
             text_buf.insertAtCursor("\n", 1);
         }
 

src/apprt/gtk/ipc/DBus.zig

@@ -29,15 +29,18 @@ payload_builder: *glib.VariantBuilder,
 parameters_builder: *glib.VariantBuilder,
 
 /// Initialize the helper.
-pub fn init(alloc: Allocator, target: apprt.ipc.Target, action: [:0]const u8) (Allocator.Error || std.posix.WriteError || apprt.ipc.Errors)!Self {
+pub fn init(alloc: Allocator, target: apprt.ipc.Target, action: [:0]const u8) (Allocator.Error || std.Io.Writer.Error || apprt.ipc.Errors)!Self {
+    var buf: [256]u8 = undefined;
+    var stderr_writer = std.fs.File.stderr().writer(&buf);
+    const stderr = &stderr_writer.interface;
 
     // Get the appropriate bus name and object path for contacting the
     // Ghostty instance we're interested in.
     const bus_name: [:0]const u8, const object_path: [:0]const u8 = switch (target) {
         .class => |class| result: {
             // Force the usage of the class specified on the CLI to determine the
             // bus name and object path.
-            const object_path = try std.fmt.allocPrintZ(alloc, "/{s}", .{class});
+            const object_path = try std.fmt.allocPrintSentinel(alloc, "/{s}", .{class}, 0);
 
             std.mem.replaceScalar(u8, object_path, '.', '/');
             std.mem.replaceScalar(u8, object_path, '-', '_');
@@ -54,14 +57,14 @@ pub fn init(alloc: Allocator, target: apprt.ipc.Target, action: [:0]const u8) (A
     }
 
     if (gio.Application.idIsValid(bus_name.ptr) == 0) {
-        const stderr = std.io.getStdErr().writer();
         try stderr.print("D-Bus bus name is not valid: {s}\n", .{bus_name});
+        try stderr.flush();
         return error.IPCFailed;
     }
 
     if (glib.Variant.isObjectPath(object_path.ptr) == 0) {
-        const stderr = std.io.getStdErr().writer();
         try stderr.print("D-Bus object path is not valid: {s}\n", .{object_path});
+        try stderr.flush();
         return error.IPCFailed;
     }
 
@@ -72,17 +75,17 @@ pub fn init(alloc: Allocator, target: apprt.ipc.Target, action: [:0]const u8) (A
 
         const dbus_ = gio.busGetSync(.session, null, &err_);
         if (err_) |err| {
-            const stderr = std.io.getStdErr().writer();
             try stderr.print(
                 "Unable to establish connection to D-Bus session bus: {s}\n",
                 .{err.f_message orelse "(unknown)"},
             );
+            try stderr.flush();
             return error.IPCFailed;
         }
 
         break :dbus dbus_ orelse {
-            const stderr = std.io.getStdErr().writer();
             try stderr.print("gio.busGetSync returned null\n", .{});
+            try stderr.flush();
             return error.IPCFailed;
         };
     };
@@ -128,7 +131,11 @@ pub fn addParameter(self: *Self, variant: *glib.Variant) void {
 
 /// Send the IPC to the remote Ghostty. Once it completes, nothing further
 /// should be done with this object other than call `deinit`.
-pub fn send(self: *Self) (std.posix.WriteError || apprt.ipc.Errors)!void {
+pub fn send(self: *Self) (std.Io.Writer.Error || apprt.ipc.Errors)!void {
+    var buf: [256]u8 = undefined;
+    var stderr_writer = std.fs.File.stderr().writer(&buf);
+    const stderr = &stderr_writer.interface;
+
     // finish building the parameters
     const parameters = self.parameters_builder.end();
 
@@ -167,11 +174,11 @@ pub fn send(self: *Self) (std.posix.WriteError || apprt.ipc.Errors)!void {
         defer if (result_) |result| result.unref();
 
         if (err_) |err| {
-            const stderr = std.io.getStdErr().writer();
             try stderr.print(
                 "D-Bus method call returned an error err={s}\n",
                 .{err.f_message orelse "(unknown)"},
             );
+            try stderr.flush();
             return error.IPCFailed;
         }
     }

src/apprt/gtk/ipc/new_window.zig

@@ -20,7 +20,7 @@ const DBus = @import("DBus.zig");
 // ```
 // gdbus call --session --dest com.mitchellh.ghostty --object-path /com/mitchellh/ghostty --method org.gtk.Actions.Activate new-window-command '[<@as ["echo" "hello"]>]' []
 // ```
-pub fn newWindow(alloc: Allocator, target: apprt.ipc.Target, value: apprt.ipc.Action.NewWindow) (Allocator.Error || std.posix.WriteError || apprt.ipc.Errors)!bool {
+pub fn newWindow(alloc: Allocator, target: apprt.ipc.Target, value: apprt.ipc.Action.NewWindow) (Allocator.Error || std.Io.Writer.Error || apprt.ipc.Errors)!bool {
     var dbus = try DBus.init(
         alloc,
         target,

src/benchmark/CodepointWidth.zig

@@ -10,7 +10,6 @@ const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const Benchmark = @import("Benchmark.zig");
 const options = @import("options.zig");
-const uucode = @import("uucode");
 const UTF8Decoder = @import("../terminal/UTF8Decoder.zig");
 const simd = @import("../simd/main.zig");
 const table = @import("../unicode/main.zig").table;
@@ -48,9 +47,6 @@ pub const Mode = enum {
 
     /// Test our lookup table implementation.
     table,
-
-    /// Using uucode, with custom `width` extension based on `wcwidth`.
-    uucode,
 };
 
 /// Create a new terminal stream handler for the given arguments.
@@ -75,7 +71,6 @@ pub fn benchmark(self: *CodepointWidth) Benchmark {
             .wcwidth => stepWcwidth,
             .table => stepTable,
             .simd => stepSimd,
-            .uucode => stepUucode,
         },
         .setupFn = setup,
         .teardownFn = teardown,
@@ -112,12 +107,15 @@ fn stepWcwidth(ptr: *anyopaque) Benchmark.Error!void {
     const self: *CodepointWidth = @ptrCast(@alignCast(ptr));
 
     const f = self.data_f orelse return;
-    var r = std.io.bufferedReader(f.reader());
+    var read_buf: [4096]u8 = undefined;
+    var f_reader = f.reader(&read_buf);
+    var r = &f_reader.interface;
+
     var d: UTF8Decoder = .{};
     var buf: [4096]u8 align(std.atomic.cache_line) = undefined;
     while (true) {
-        const n = r.read(&buf) catch |err| {
-            log.warn("error reading data file err={}", .{err});
+        const n = r.readSliceShort(&buf) catch {
+            log.warn("error reading data file err={?}", .{f_reader.err});
             return error.BenchmarkFailed;
         };
         if (n == 0) break; // EOF reached
@@ -136,12 +134,15 @@ fn stepTable(ptr: *anyopaque) Benchmark.Error!void {
     const self: *CodepointWidth = @ptrCast(@alignCast(ptr));
 
     const f = self.data_f orelse return;
-    var r = std.io.bufferedReader(f.reader());
+    var read_buf: [4096]u8 = undefined;
+    var f_reader = f.reader(&read_buf);
+    var r = &f_reader.interface;
+
     var d: UTF8Decoder = .{};
     var buf: [4096]u8 align(std.atomic.cache_line) = undefined;
     while (true) {
-        const n = r.read(&buf) catch |err| {
-            log.warn("error reading data file err={}", .{err});
+        const n = r.readSliceShort(&buf) catch {
+            log.warn("error reading data file err={?}", .{f_reader.err});
             return error.BenchmarkFailed;
         };
         if (n == 0) break; // EOF reached
@@ -165,36 +166,15 @@ fn stepSimd(ptr: *anyopaque) Benchmark.Error!void {
     const self: *CodepointWidth = @ptrCast(@alignCast(ptr));
 
     const f = self.data_f orelse return;
-    var r = std.io.bufferedReader(f.reader());
-    var d: UTF8Decoder = .{};
-    var buf: [4096]u8 align(std.atomic.cache_line) = undefined;
-    while (true) {
-        const n = r.read(&buf) catch |err| {
-            log.warn("error reading data file err={}", .{err});
-            return error.BenchmarkFailed;
-        };
-        if (n == 0) break; // EOF reached
-
-        for (buf[0..n]) |c| {
-            const cp_, const consumed = d.next(c);
-            assert(consumed);
-            if (cp_) |cp| {
-                std.mem.doNotOptimizeAway(simd.codepointWidth(cp));
-            }
-        }
-    }
-}
-
-fn stepUucode(ptr: *anyopaque) Benchmark.Error!void {
-    const self: *CodepointWidth = @ptrCast(@alignCast(ptr));
+    var read_buf: [4096]u8 = undefined;
+    var f_reader = f.reader(&read_buf);
+    var r = &f_reader.interface;
 
-    const f = self.data_f orelse return;
-    var r = std.io.bufferedReader(f.reader());
     var d: UTF8Decoder = .{};
     var buf: [4096]u8 align(std.atomic.cache_line) = undefined;
     while (true) {
-        const n = r.read(&buf) catch |err| {
-            log.warn("error reading data file err={}", .{err});
+        const n = r.readSliceShort(&buf) catch {
+            log.warn("error reading data file err={?}", .{f_reader.err});
             return error.BenchmarkFailed;
         };
         if (n == 0) break; // EOF reached
@@ -203,12 +183,7 @@ fn stepUucode(ptr: *anyopaque) Benchmark.Error!void {
             const cp_, const consumed = d.next(c);
             assert(consumed);
             if (cp_) |cp| {
-                // This is the same trick we do in terminal.zig so we
-                // keep it here.
-                std.mem.doNotOptimizeAway(if (cp <= 0xFF)
-                    1
-                else
-                    uucode.get(.width, @intCast(cp)));
+                std.mem.doNotOptimizeAway(simd.codepointWidth(cp));
             }
         }
     }