zig build progress

src/verbose_air.zig

@@ -39,6 +39,7 @@ const AirCollector = struct {
     err_buf: *[err_buf_size]u8,
     callback_count: u32 = 0,
     comp: ?*Compilation = null,
+    progress_node: std.Progress.Node = .none,
 
     fn hasError(self: *const AirCollector) bool {
         return self.err_buf[0] != 0;
@@ -47,6 +48,7 @@ const AirCollector = struct {
     fn collectFunc(ctx: *anyopaque, name: []const u8, air: *const Air) void {
         const self: *AirCollector = @ptrCast(@alignCast(ctx));
         self.callback_count += 1;
+        self.progress_node.completeOne();
         self.collectFuncInner(name, air) catch |err| {
             if (!self.hasError()) {
                 setErr(self.err_buf, "collectFunc '{s}': {s}", .{ name, @errorName(err) });
@@ -132,12 +134,15 @@ export fn zig_compile_air(
 ) CompileAirResult {
     const err_buf: *[err_buf_size]u8 = err_buf_ptr[0..err_buf_size];
     err_buf[0] = 0;
+    const root_progress = std.Progress.start(.{});
+    defer root_progress.end();
     return zigCompileAirImpl(
         std.mem.span(src_path_ptr),
         if (module_root_ptr) |p| std.mem.span(p) else null,
         err_buf,
         false,
         false,
+        root_progress,
     ) catch |err| {
         setErr(err_buf, "{s}", .{@errorName(err)});
         return .{ .items = null, .len = 0, .callback_count = 0 };
@@ -171,6 +176,7 @@ pub fn zigCompileAirImpl(
     err_buf: *[err_buf_size]u8,
     is_test: bool,
     use_root_as_std: bool,
+    progress_node: std.Progress.Node,
 ) !CompileAirResult {
     const gpa = std.heap.c_allocator;
 
@@ -259,7 +265,9 @@ pub fn zigCompileAirImpl(
         gpa.destroy(thread_pool);
     }
 
-    var collector: AirCollector = .{ .err_buf = err_buf };
+    const func_progress = progress_node.start("Functions", 0);
+
+    var collector: AirCollector = .{ .err_buf = err_buf, .progress_node = func_progress };
 
     var create_diag: Compilation.CreateDiagnostic = undefined;
     const comp = Compilation.create(gpa, arena, &create_diag, .{
@@ -285,7 +293,9 @@ pub fn zigCompileAirImpl(
     defer comp.destroy();
     collector.comp = comp;
 
-    try comp.update(std.Progress.Node.none);
+    try comp.update(progress_node);
+
+    func_progress.end();
 
     var error_bundle = try comp.getAllErrorsAlloc();
     defer error_bundle.deinit(gpa);

src/verbose_air_gen.zig

@@ -14,6 +14,9 @@ const zig_internals = @import("zig_internals");
 const Air = zig_internals.Air;
 
 pub fn main() !void {
+    const root_progress = std.Progress.start(.{});
+    defer root_progress.end();
+
     const gpa = std.heap.c_allocator;
     const args = try std.process.argsAlloc(gpa);
     if (args.len < 2) {
@@ -57,7 +60,7 @@ pub fn main() !void {
         const std_src = try std.fmt.allocPrint(gpa, "{s}lib/std/std.zig", .{repo_root});
         defer gpa.free(std_src);
 
-        const data = processSource(gpa, std_src, std_root, false, true) catch |err| {
+        const data = processSource(gpa, std_src, std_root, false, true, root_progress) catch |err| {
             std.debug.print("FAIL: lib/std/std.zig ({s}): {s}\n", .{ std_src, @errorName(err) });
             return err;
         };
@@ -90,7 +93,7 @@ pub fn main() !void {
 
         const module_root = std.fs.path.dirname(resolved) orelse ".";
 
-        const data = processSource(gpa, resolved, module_root, false, false) catch |err| {
+        const data = processSource(gpa, resolved, module_root, false, false, root_progress) catch |err| {
             std.debug.print("FAIL: {s} ({s}): {s}\n", .{ name, resolved, @errorName(err) });
             return err;
         };
@@ -169,7 +172,7 @@ pub fn main() !void {
 ///     inst_datas: [inst_len * 8]u8
 ///     extra_len: u32
 ///     extra: [extra_len * 4]u8
-fn processSource(gpa: std.mem.Allocator, src_path: []const u8, module_root: []const u8, is_test: bool, use_root_as_std: bool) ![]const u8 {
+fn processSource(gpa: std.mem.Allocator, src_path: []const u8, module_root: []const u8, is_test: bool, use_root_as_std: bool, progress_node: std.Progress.Node) ![]const u8 {
     var err_buf: [256]u8 = .{0} ** 256;
 
     const result = verbose_air.zigCompileAirImpl(
@@ -178,6 +181,7 @@ fn processSource(gpa: std.mem.Allocator, src_path: []const u8, module_root: []co
         &err_buf,
         is_test,
         use_root_as_std,
+        progress_node,
     ) catch |err| {
         std.debug.print("zigCompileAirImpl error for {s}: {s} ({s})\n", .{
             src_path,