- Rework translate-c to integrate with the build system (by outputing error bundles on stdout) via --zig-integration

kcbanner · kcbanner · commit 4aa4d80ec640 · 2025-10-09T01:06:09.000-04:00
- Revive some of the removed cache integration logic in `cmdTranslateC` now that `translate-c` can return error bundles
- Fixup inconsistent path separators (on Windows) when building the aro include path
- Move some error bundle logic from resinator into aro.Diagnostics
- Add `ErrorBundle.addRootErrorMessageWithNotes` (extracted from resinator)
diff --git a/lib/compiler/aro/aro/Diagnostics.zig b/lib/compiler/aro/aro/Diagnostics.zig
@@ -562,3 +562,79 @@ fn addMessage(d: *Diagnostics, msg: Message) Compilation.Error!void {
         },
     }
 }
+
+const ErrorBundle = std.zig.ErrorBundle;
+
+pub fn toErrorBundle(
+    d: *const Diagnostics,
+    gpa: std.mem.Allocator,
+    fail_msg: ?[]const u8,
+) !ErrorBundle {
+    @branchHint(.cold);
+
+    var bundle: ErrorBundle.Wip = undefined;
+    try bundle.init(gpa);
+    errdefer bundle.deinit();
+
+    if (fail_msg) |msg| {
+        try bundle.addRootErrorMessage(.{
+            .msg = try bundle.addString(msg),
+        });
+    }
+
+    var cur_err: ?ErrorBundle.ErrorMessage = null;
+    var cur_notes: std.ArrayList(ErrorBundle.ErrorMessage) = .empty;
+    defer cur_notes.deinit(gpa);
+    for (d.output.to_list.messages.items) |msg| {
+        switch (msg.kind) {
+            // Clear the current error so that notes don't bleed into unassociated errors
+            .off, .warning => {
+                cur_err = null;
+                continue;
+            },
+            .note => if (cur_err == null) continue,
+            .@"fatal error", .@"error" => {},
+        }
+
+        const src_loc = src_loc: {
+            if (msg.location) |location| {
+                break :src_loc try bundle.addSourceLocation(.{
+                    .src_path = try bundle.addString(location.path),
+                    .line = location.line_no - 1, // 1-based -> 0-based
+                    .column = location.col - 1, // 1-based -> 0-based
+                    .span_start = location.width,
+                    .span_main = location.width,
+                    .span_end = location.width,
+                    .source_line = try bundle.addString(location.line),
+                });
+            }
+            break :src_loc ErrorBundle.SourceLocationIndex.none;
+        };
+
+        switch (msg.kind) {
+            .@"fatal error", .@"error" => {
+                if (cur_err) |err| {
+                    try bundle.addRootErrorMessageWithNotes(err, cur_notes.items);
+                }
+                cur_err = .{
+                    .msg = try bundle.addString(msg.text),
+                    .src_loc = src_loc,
+                };
+                cur_notes.clearRetainingCapacity();
+            },
+            .note => {
+                cur_err.?.notes_len += 1;
+                try cur_notes.append(gpa, .{
+                    .msg = try bundle.addString(msg.text),
+                    .src_loc = src_loc,
+                });
+            },
+            .off, .warning => unreachable,
+        }
+    }
+    if (cur_err) |err| {
+        try bundle.addRootErrorMessageWithNotes(err, cur_notes.items);
+    }
+
+    return try bundle.toOwnedBundle("");
+}
diff --git a/lib/compiler/resinator/main.zig b/lib/compiler/resinator/main.zig
@@ -671,7 +671,7 @@ const ErrorHandler = union(enum) {
     ) !void {
         switch (self.*) {
             .server => |*server| {
-                var error_bundle = try aroDiagnosticsToErrorBundle(allocator, fail_msg, comp);
+                var error_bundle = try comp.diagnostics.toErrorBundle(allocator, fail_msg);
                 defer error_bundle.deinit(allocator);
 
                 try server.serveErrorBundle(error_bundle);
@@ -753,7 +753,7 @@ fn cliDiagnosticsToErrorBundle(
         switch (err_details.type) {
             .err => {
                 if (cur_err) |err| {
-                    try flushErrorMessageIntoBundle(&bundle, err, cur_notes.items);
+                    try bundle.addRootErrorMessageWithNotes(err, cur_notes.items);
                 }
                 cur_err = .{
                     .msg = try bundle.addString(err_details.msg.items),
@@ -771,7 +771,7 @@ fn cliDiagnosticsToErrorBundle(
         }
     }
     if (cur_err) |err| {
-        try flushErrorMessageIntoBundle(&bundle, err, cur_notes.items);
+        try bundle.addRootErrorMessageWithNotes(err, cur_notes.items);
     }
 
     return try bundle.toOwnedBundle("");
@@ -840,7 +840,7 @@ fn diagnosticsToErrorBundle(
         switch (err_details.type) {
             .err => {
                 if (cur_err) |err| {
-                    try flushErrorMessageIntoBundle(&bundle, err, cur_notes.items);
+                    try bundle.addRootErrorMessageWithNotes(err, cur_notes.items);
                 }
                 cur_err = .{
                     .msg = try bundle.addString(msg_buf.written()),
@@ -859,20 +859,12 @@ fn diagnosticsToErrorBundle(
         }
     }
     if (cur_err) |err| {
-        try flushErrorMessageIntoBundle(&bundle, err, cur_notes.items);
+        try bundle.addRootErrorMessageWithNotes(err, cur_notes.items);
     }
 
     return try bundle.toOwnedBundle("");
 }
 
-fn flushErrorMessageIntoBundle(wip: *ErrorBundle.Wip, msg: ErrorBundle.ErrorMessage, notes: []const ErrorBundle.ErrorMessage) !void {
-    try wip.addRootErrorMessage(msg);
-    const notes_start = try wip.reserveNotes(@intCast(notes.len));
-    for (notes_start.., notes) |i, note| {
-        wip.extra.items[i] = @intFromEnum(wip.addErrorMessageAssumeCapacity(note));
-    }
-}
-
 fn errorStringToErrorBundle(allocator: std.mem.Allocator, comptime format: []const u8, args: anytype) !ErrorBundle {
     @branchHint(.cold);
     var bundle: ErrorBundle.Wip = undefined;
@@ -883,75 +875,3 @@ fn errorStringToErrorBundle(allocator: std.mem.Allocator, comptime format: []con
     });
     return try bundle.toOwnedBundle("");
 }
-
-fn aroDiagnosticsToErrorBundle(
-    gpa: std.mem.Allocator,
-    fail_msg: []const u8,
-    comp: *aro.Compilation,
-) !ErrorBundle {
-    @branchHint(.cold);
-
-    var bundle: ErrorBundle.Wip = undefined;
-    try bundle.init(gpa);
-    errdefer bundle.deinit();
-
-    try bundle.addRootErrorMessage(.{
-        .msg = try bundle.addString(fail_msg),
-    });
-
-    var cur_err: ?ErrorBundle.ErrorMessage = null;
-    var cur_notes: std.ArrayList(ErrorBundle.ErrorMessage) = .empty;
-    defer cur_notes.deinit(gpa);
-    for (comp.diagnostics.output.to_list.messages.items) |msg| {
-        switch (msg.kind) {
-            // Clear the current error so that notes don't bleed into unassociated errors
-            .off, .warning => {
-                cur_err = null;
-                continue;
-            },
-            .note => if (cur_err == null) continue,
-            .@"fatal error", .@"error" => {},
-        }
-
-        const src_loc = src_loc: {
-            if (msg.location) |location| {
-                break :src_loc try bundle.addSourceLocation(.{
-                    .src_path = try bundle.addString(location.path),
-                    .line = location.line_no - 1, // 1-based -> 0-based
-                    .column = location.col - 1, // 1-based -> 0-based
-                    .span_start = location.width,
-                    .span_main = location.width,
-                    .span_end = location.width,
-                    .source_line = try bundle.addString(location.line),
-                });
-            }
-            break :src_loc ErrorBundle.SourceLocationIndex.none;
-        };
-
-        switch (msg.kind) {
-            .@"fatal error", .@"error" => {
-                if (cur_err) |err| {
-                    try flushErrorMessageIntoBundle(&bundle, err, cur_notes.items);
-                }
-                cur_err = .{
-                    .msg = try bundle.addString(msg.text),
-                    .src_loc = src_loc,
-                };
-                cur_notes.clearRetainingCapacity();
-            },
-            .note => {
-                cur_err.?.notes_len += 1;
-                try cur_notes.append(gpa, .{
-                    .msg = try bundle.addString(msg.text),
-                    .src_loc = src_loc,
-                });
-            },
-            .off, .warning => unreachable,
-        }
-    }
-    if (cur_err) |err| {
-        try flushErrorMessageIntoBundle(&bundle, err, cur_notes.items);
-    }
-
-    return try bundle.toOwnedBundle("");
-}
diff --git a/lib/compiler/translate-c/main.zig b/lib/compiler/translate-c/main.zig
@@ -13,24 +13,33 @@ pub fn main() u8 {
     const gpa = general_purpose_allocator.allocator();
     defer _ = general_purpose_allocator.deinit();
 
-    var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    var arena_instance = std.heap.ArenaAllocator.init(gpa);
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
 
-    const args = process.argsAlloc(arena) catch {
+    var args = process.argsAlloc(arena) catch {
         std.debug.print("ran out of memory allocating arguments\n", .{});
         if (fast_exit) process.exit(1);
         return 1;
     };
 
+    var zig_integration = false;
+    if (args.len > 1 and std.mem.eql(u8, args[1], "--zig-integration")) {
+        zig_integration = true;
+    }
+
     var stderr_buf: [1024]u8 = undefined;
     var stderr = std.fs.File.stderr().writer(&stderr_buf);
-    var diagnostics: aro.Diagnostics = .{
-        .output = .{ .to_writer = .{
+    var diagnostics: aro.Diagnostics = switch (zig_integration) {
+        false => .{ .output = .{ .to_writer = .{
             .color = .detect(stderr.file),
             .writer = &stderr.interface,
-        } },
+        } } },
+        true => .{ .output = .{ .to_list = .{
+            .arena = .init(gpa),
+        } } },
     };
+    defer diagnostics.deinit();
 
     var comp = aro.Compilation.initDefault(gpa, arena, &diagnostics, std.fs.cwd()) catch |err| switch (err) {
         error.OutOfMemory => {
@@ -47,13 +56,22 @@ pub fn main() u8 {
     var toolchain: aro.Toolchain = .{ .driver = &driver, .filesystem = .{ .real = comp.cwd } };
     defer toolchain.deinit();
 
-    translate(&driver, &toolchain, args) catch |err| switch (err) {
+    translate(&driver, &toolchain, args, zig_integration) catch |err| switch (err) {
         error.OutOfMemory => {
             std.debug.print("ran out of memory translating\n", .{});
             if (fast_exit) process.exit(1);
             return 1;
         },
-        error.FatalError => {
+        error.FatalError => if (zig_integration) {
+            serveErrorBundle(arena, &diagnostics) catch |bundle_err| {
+                std.debug.print("unable to serve error bundle: {}\n", .{bundle_err});
+                if (fast_exit) process.exit(1);
+                return 1;
+            };
+
+            if (fast_exit) process.exit(0);
+            return 0;
+        } else {
             if (fast_exit) process.exit(1);
             return 1;
         },
@@ -63,10 +81,23 @@ pub fn main() u8 {
             return 1;
         },
     };
+
+    assert(comp.diagnostics.errors == 0 or !zig_integration);
     if (fast_exit) process.exit(@intFromBool(comp.diagnostics.errors != 0));
     return @intFromBool(comp.diagnostics.errors != 0);
 }
 
+fn serveErrorBundle(arena: std.mem.Allocator, diagnostics: *const aro.Diagnostics) !void {
+    const error_bundle = try diagnostics.toErrorBundle(arena, "failed during translation");
+    var stdout_buffer: [1024]u8 = undefined;
+    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var server: std.zig.Server = .{
+        .out = &stdout_writer.interface,
+        .in = undefined,
+    };
+    try server.serveErrorBundle(error_bundle);
+}
+
 pub const usage =
     \\Usage {s}: [options] file [CC options]
     \\
@@ -79,7 +110,7 @@ pub const usage =
     \\
 ;
 
-fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8) !void {
+fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8, zig_integration: bool) !void {
     const gpa = d.comp.gpa;
 
     const aro_args = args: {
@@ -99,6 +130,9 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8) !void {
                 try stdout.interface.writeAll("0.0.0-dev\n");
                 try stdout.interface.flush();
                 return;
+            } else if (mem.eql(u8, arg, "--zig-integration")) {
+                if (i != 1 or !zig_integration)
+                    return d.fatal("--zig-integration must be the first argument", .{});
             } else {
                 i += 1;
             }
@@ -116,6 +150,14 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8) !void {
             return d.fatal("user provided macro source exceeded max size", .{});
         }
 
+        const has_output_file = if (d.output_name) |path|
+            !std.mem.eql(u8, path, "-")
+        else
+            false;
+        if (zig_integration and !has_output_file) {
+            return d.fatal("--zig-integration requires specifying an output file", .{});
+        }
+
         const content = try macro_buf.toOwnedSlice(gpa);
         errdefer gpa.free(content);
 
@@ -160,7 +202,7 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8) !void {
     defer c_tree.deinit();
 
     if (d.diagnostics.errors != 0) {
-        if (fast_exit) process.exit(1);
+        if (fast_exit and !zig_integration) process.exit(1);
         return error.FatalError;
     }
 
@@ -212,7 +254,7 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8) !void {
     if (out_writer.err) |write_err|
         return d.fatal("failed to write result to '{s}': {s}", .{ out_file_path, aro.Driver.errorDescription(write_err) });
 
-    if (fast_exit) process.exit(0);
+    if (fast_exit and !zig_integration) process.exit(0);
 }
 
 test {
diff --git a/lib/std/zig/ErrorBundle.zig b/lib/std/zig/ErrorBundle.zig
@@ -416,6 +416,18 @@ pub const Wip = struct {
         wip.root_list.appendAssumeCapacity(try addErrorMessage(wip, em));
     }
 
+    pub fn addRootErrorMessageWithNotes(
+        wip: *Wip,
+        msg: ErrorMessage,
+        notes: []const ErrorMessage,
+    ) !void {
+        try wip.addRootErrorMessage(msg);
+        const notes_start = try wip.reserveNotes(@intCast(notes.len));
+        for (notes_start.., notes) |i, note| {
+            wip.extra.items[i] = @intFromEnum(wip.addErrorMessageAssumeCapacity(note));
+        }
+    }
+
     pub fn addErrorMessage(wip: *Wip, em: ErrorMessage) Allocator.Error!MessageIndex {
         return @enumFromInt(try addExtra(wip, em));
     }
diff --git a/src/Compilation.zig b/src/Compilation.zig
@@ -3398,7 +3398,7 @@ fn flush(
 /// Linker backends which do not have this requirement can fall back to the simple
 /// implementation at the bottom of this function.
 /// This function is only called when CacheMode is `whole`.
-fn renameTmpIntoCache(
+pub fn renameTmpIntoCache(
     cache_directory: Cache.Directory,
     tmp_dir_sub_path: []const u8,
     o_sub_path: []const u8,
@@ -6684,7 +6684,7 @@ pub fn addTranslateCCArgs(
 
     try argv.appendSlice(&.{ "-x", "c" });
 
-    const resource_path = try comp.dirs.zig_lib.join(arena, &.{"compiler/aro/include"});
+    const resource_path = try comp.dirs.zig_lib.join(arena, &.{ "compiler", "aro", "include" });
     try argv.appendSlice(&.{ "-isystem", resource_path });
 
     try comp.addCommonCCArgs(arena, argv, ext, out_dep_path, owner_mod, .aro);
diff --git a/src/main.zig b/src/main.zig
