update the codebase for the new std.Progress API

1 files changed, 38 insertions, 63 deletions

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 03b981812e..512ceeabbd 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1273,8 +1273,8 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
         if (options.verbose_llvm_cpu_features) {
             if (options.root_mod.resolved_target.llvm_cpu_features) |cf| print: {
                 const target = options.root_mod.resolved_target.result;
-                std.debug.getStderrMutex().lock();
-                defer std.debug.getStderrMutex().unlock();
+                std.debug.lockStdErr();
+                defer std.debug.unlockStdErr();
                 const stderr = std.io.getStdErr().writer();
                 nosuspend {
                     stderr.print("compilation: {s}\n", .{options.root_name}) catch break :print;
@@ -1934,7 +1934,7 @@ pub fn getTarget(self: Compilation) Target {
 /// Only legal to call when cache mode is incremental and a link file is present.
 pub fn hotCodeSwap(
     comp: *Compilation,
-    prog_node: *std.Progress.Node,
+    prog_node: std.Progress.Node,
     pid: std.process.Child.Id,
 ) !void {
     const lf = comp.bin_file.?;
@@ -1966,7 +1966,7 @@ fn cleanupAfterUpdate(comp: *Compilation) void {
 }
 
 /// Detect changes to source files, perform semantic analysis, and update the output files.
-pub fn update(comp: *Compilation, main_progress_node: *std.Progress.Node) !void {
+pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
     const tracy_trace = trace(@src());
     defer tracy_trace.end();
 
@@ -2256,7 +2256,7 @@ pub fn update(comp: *Compilation, main_progress_node: *std.Progress.Node) !void
     }
 }
 
-fn flush(comp: *Compilation, arena: Allocator, prog_node: *std.Progress.Node) !void {
+fn flush(comp: *Compilation, arena: Allocator, prog_node: std.Progress.Node) !void {
     if (comp.bin_file) |lf| {
         // This is needed before reading the error flags.
         lf.flush(arena, prog_node) catch |err| switch (err) {
@@ -2566,13 +2566,11 @@ pub fn emitLlvmObject(
     default_emit: Emit,
     bin_emit_loc: ?EmitLoc,
     llvm_object: *LlvmObject,
-    prog_node: *std.Progress.Node,
+    prog_node: std.Progress.Node,
 ) !void {
     if (build_options.only_c) @compileError("unreachable");
 
-    var sub_prog_node = prog_node.start("LLVM Emit Object", 0);
-    sub_prog_node.activate();
-    sub_prog_node.context.refresh();
+    const sub_prog_node = prog_node.start("LLVM Emit Object", 0);
     defer sub_prog_node.end();
 
     try llvm_object.emit(.{
@@ -3249,23 +3247,23 @@ pub fn addZirErrorMessages(eb: *ErrorBundle.Wip, file: *Module.File) !void {
 
 pub fn performAllTheWork(
     comp: *Compilation,
-    main_progress_node: *std.Progress.Node,
+    main_progress_node: std.Progress.Node,
 ) error{ TimerUnsupported, OutOfMemory }!void {
     // Here we queue up all the AstGen tasks first, followed by C object compilation.
     // We wait until the AstGen tasks are all completed before proceeding to the
     // (at least for now) single-threaded main work queue. However, C object compilation
     // only needs to be finished by the end of this function.
 
-    var zir_prog_node = main_progress_node.start("AST Lowering", 0);
+    const zir_prog_node = main_progress_node.start("AST Lowering", 0);
     defer zir_prog_node.end();
 
-    var wasm_prog_node = main_progress_node.start("Compile Autodocs", 0);
+    const wasm_prog_node = main_progress_node.start("Compile Autodocs", 0);
     defer wasm_prog_node.end();
 
-    var c_obj_prog_node = main_progress_node.start("Compile C Objects", comp.c_source_files.len);
+    const c_obj_prog_node = main_progress_node.start("Compile C Objects", comp.c_source_files.len);
     defer c_obj_prog_node.end();
 
-    var win32_resource_prog_node = main_progress_node.start("Compile Win32 Resources", comp.rc_source_files.len);
+    const win32_resource_prog_node = main_progress_node.start("Compile Win32 Resources", comp.rc_source_files.len);
     defer win32_resource_prog_node.end();
 
     comp.work_queue_wait_group.reset();
@@ -3274,7 +3272,7 @@ pub fn performAllTheWork(
     if (!build_options.only_c and !build_options.only_core_functionality) {
         if (comp.docs_emit != null) {
             comp.thread_pool.spawnWg(&comp.work_queue_wait_group, workerDocsCopy, .{comp});
-            comp.work_queue_wait_group.spawnManager(workerDocsWasm, .{ comp, &wasm_prog_node });
+            comp.work_queue_wait_group.spawnManager(workerDocsWasm, .{ comp, wasm_prog_node });
         }
     }
 
@@ -3313,7 +3311,7 @@ pub fn performAllTheWork(
 
         while (comp.astgen_work_queue.readItem()) |file| {
             comp.thread_pool.spawnWg(&comp.astgen_wait_group, workerAstGenFile, .{
-                comp, file, &zir_prog_node, &comp.astgen_wait_group, .root,
+                comp, file, zir_prog_node, &comp.astgen_wait_group, .root,
             });
         }
 
@@ -3325,14 +3323,14 @@ pub fn performAllTheWork(
 
         while (comp.c_object_work_queue.readItem()) |c_object| {
             comp.thread_pool.spawnWg(&comp.work_queue_wait_group, workerUpdateCObject, .{
-                comp, c_object, &c_obj_prog_node,
+                comp, c_object, c_obj_prog_node,
             });
         }
 
         if (!build_options.only_core_functionality) {
             while (comp.win32_resource_work_queue.readItem()) |win32_resource| {
                 comp.thread_pool.spawnWg(&comp.work_queue_wait_group, workerUpdateWin32Resource, .{
-                    comp, win32_resource, &win32_resource_prog_node,
+                    comp, win32_resource, win32_resource_prog_node,
                 });
             }
         }
@@ -3342,7 +3340,6 @@ pub fn performAllTheWork(
         try reportMultiModuleErrors(mod);
         try mod.flushRetryableFailures();
         mod.sema_prog_node = main_progress_node.start("Semantic Analysis", 0);
-        mod.sema_prog_node.activate();
     }
     defer if (comp.module) |mod| {
         mod.sema_prog_node.end();
@@ -3379,7 +3376,7 @@ pub fn performAllTheWork(
     }
 }
 
-fn processOneJob(comp: *Compilation, job: Job, prog_node: *std.Progress.Node) !void {
+fn processOneJob(comp: *Compilation, job: Job, prog_node: std.Progress.Node) !void {
     switch (job) {
         .codegen_decl => |decl_index| {
             const module = comp.module.?;
@@ -3803,7 +3800,7 @@ fn docsCopyModule(comp: *Compilation, module: *Package.Module, name: []const u8,
     }
 }
 
-fn workerDocsWasm(comp: *Compilation, prog_node: *std.Progress.Node) void {
+fn workerDocsWasm(comp: *Compilation, prog_node: std.Progress.Node) void {
     workerDocsWasmFallible(comp, prog_node) catch |err| {
         comp.lockAndSetMiscFailure(.docs_wasm, "unable to build autodocs: {s}", .{
             @errorName(err),
@@ -3811,7 +3808,7 @@ fn workerDocsWasm(comp: *Compilation, prog_node: *std.Progress.Node) void {
     };
 }
 
-fn workerDocsWasmFallible(comp: *Compilation, prog_node: *std.Progress.Node) anyerror!void {
+fn workerDocsWasmFallible(comp: *Compilation, prog_node: std.Progress.Node) anyerror!void {
     const gpa = comp.gpa;
 
     var arena_allocator = std.heap.ArenaAllocator.init(gpa);
@@ -3952,12 +3949,11 @@ const AstGenSrc = union(enum) {
 fn workerAstGenFile(
     comp: *Compilation,
     file: *Module.File,
-    prog_node: *std.Progress.Node,
+    prog_node: std.Progress.Node,
     wg: *WaitGroup,
     src: AstGenSrc,
 ) void {
-    var child_prog_node = prog_node.start(file.sub_file_path, 0);
-    child_prog_node.activate();
+    const child_prog_node = prog_node.start(file.sub_file_path, 0);
     defer child_prog_node.end();
 
     const mod = comp.module.?;
@@ -4265,7 +4261,7 @@ pub fn cImport(comp: *Compilation, c_src: []const u8, owner_mod: *Package.Module
 fn workerUpdateCObject(
     comp: *Compilation,
     c_object: *CObject,
-    progress_node: *std.Progress.Node,
+    progress_node: std.Progress.Node,
 ) void {
     comp.updateCObject(c_object, progress_node) catch |err| switch (err) {
         error.AnalysisFail => return,
@@ -4282,7 +4278,7 @@ fn workerUpdateCObject(
 fn workerUpdateWin32Resource(
     comp: *Compilation,
     win32_resource: *Win32Resource,
-    progress_node: *std.Progress.Node,
+    progress_node: std.Progress.Node,
 ) void {
     comp.updateWin32Resource(win32_resource, progress_node) catch |err| switch (err) {
         error.AnalysisFail => return,
@@ -4300,7 +4296,7 @@ fn buildCompilerRtOneShot(
     comp: *Compilation,
     output_mode: std.builtin.OutputMode,
     out: *?CRTFile,
-    prog_node: *std.Progress.Node,
+    prog_node: std.Progress.Node,
 ) void {
     comp.buildOutputFromZig(
         "compiler_rt.zig",
@@ -4427,7 +4423,7 @@ fn reportRetryableEmbedFileError(
     }
 }
 
-fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.Progress.Node) !void {
+fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Progress.Node) !void {
     if (comp.config.c_frontend == .aro) {
         return comp.failCObj(c_object, "aro does not support compiling C objects yet", .{});
     }
@@ -4467,9 +4463,7 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
 
     const c_source_basename = std.fs.path.basename(c_object.src.src_path);
 
-    c_obj_prog_node.activate();
-    var child_progress_node = c_obj_prog_node.start(c_source_basename, 0);
-    child_progress_node.activate();
+    const child_progress_node = c_obj_prog_node.start(c_source_basename, 0);
     defer child_progress_node.end();
 
     // Special case when doing build-obj for just one C file. When there are more than one object
@@ -4731,7 +4725,7 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
     };
 }
 
-fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32_resource_prog_node: *std.Progress.Node) !void {
+fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32_resource_prog_node: std.Progress.Node) !void {
     if (!std.process.can_spawn) {
         return comp.failWin32Resource(win32_resource, "{s} does not support spawning a child process", .{@tagName(builtin.os.tag)});
     }
@@ -4763,9 +4757,7 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
         _ = comp.failed_win32_resources.swapRemove(win32_resource);
     }
 
-    win32_resource_prog_node.activate();
-    var child_progress_node = win32_resource_prog_node.start(src_basename, 0);
-    child_progress_node.activate();
+    const child_progress_node = win32_resource_prog_node.start(src_basename, 0);
     defer child_progress_node.end();
 
     var man = comp.obtainWin32ResourceCacheManifest();
@@ -4833,7 +4825,7 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
             });
             try argv.appendSlice(&.{ "--", in_rc_path, out_res_path });
 
-            try spawnZigRc(comp, win32_resource, src_basename, arena, argv.items, &child_progress_node);
+            try spawnZigRc(comp, win32_resource, arena, argv.items, child_progress_node);
 
             break :blk digest;
         };
@@ -4901,7 +4893,7 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
         try argv.appendSlice(rc_src.extra_flags);
         try argv.appendSlice(&.{ "--", rc_src.src_path, out_res_path });
 
-        try spawnZigRc(comp, win32_resource, src_basename, arena, argv.items, &child_progress_node);
+        try spawnZigRc(comp, win32_resource, arena, argv.items, child_progress_node);
 
         // Read depfile and update cache manifest
         {
@@ -4966,10 +4958,9 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
 fn spawnZigRc(
     comp: *Compilation,
     win32_resource: *Win32Resource,
-    src_basename: []const u8,
     arena: Allocator,
     argv: []const []const u8,
-    child_progress_node: *std.Progress.Node,
+    child_progress_node: std.Progress.Node,
 ) !void {
     var node_name: std.ArrayListUnmanaged(u8) = .{};
     defer node_name.deinit(arena);
@@ -4978,6 +4969,7 @@ fn spawnZigRc(
     child.stdin_behavior = .Ignore;
     child.stdout_behavior = .Pipe;
     child.stderr_behavior = .Pipe;
+    child.progress_node = child_progress_node;
 
     child.spawn() catch |err| {
         return comp.failWin32Resource(win32_resource, "unable to spawn {s} rc: {s}", .{ argv[0], @errorName(err) });
@@ -5019,22 +5011,6 @@ fn spawnZigRc(
                 };
                 return comp.failWin32ResourceWithOwnedBundle(win32_resource, error_bundle);
             },
-            .progress => {
-                node_name.clearRetainingCapacity();
-                // <resinator> is a special string that indicates that the child
-                // process has reached resinator's main function
-                if (std.mem.eql(u8, body, "<resinator>")) {
-                    child_progress_node.setName(src_basename);
-                }
-                // Ignore 0-length strings since if multiple zig rc commands
-                // are executed at the same time, only one will send progress strings
-                // while the other(s) will send empty strings.
-                else if (body.len > 0) {
-                    try node_name.appendSlice(arena, "build 'zig rc'... ");
-                    try node_name.appendSlice(arena, body);
-                    child_progress_node.setName(node_name.items);
-                }
-            },
             else => {}, // ignore other messages
         }
 
@@ -5937,8 +5913,8 @@ pub fn lockAndParseLldStderr(comp: *Compilation, prefix: []const u8, stderr: []c
 }
 
 pub fn dump_argv(argv: []const []const u8) void {
-    std.debug.getStderrMutex().lock();
-    defer std.debug.getStderrMutex().unlock();
+    std.debug.lockStdErr();
+    defer std.debug.unlockStdErr();
     const stderr = std.io.getStdErr().writer();
     for (argv[0 .. argv.len - 1]) |arg| {
         nosuspend stderr.print("{s} ", .{arg}) catch return;
@@ -5989,11 +5965,10 @@ pub fn updateSubCompilation(
     parent_comp: *Compilation,
     sub_comp: *Compilation,
     misc_task: MiscTask,
-    prog_node: *std.Progress.Node,
+    prog_node: std.Progress.Node,
 ) !void {
     {
-        var sub_node = prog_node.start(@tagName(misc_task), 0);
-        sub_node.activate();
+        const sub_node = prog_node.start(@tagName(misc_task), 0);
         defer sub_node.end();
 
         try sub_comp.update(prog_node);
@@ -6024,7 +5999,7 @@ fn buildOutputFromZig(
     output_mode: std.builtin.OutputMode,
     out: *?CRTFile,
     misc_task_tag: MiscTask,
-    prog_node: *std.Progress.Node,
+    prog_node: std.Progress.Node,
 ) !void {
     const tracy_trace = trace(@src());
     defer tracy_trace.end();
@@ -6131,7 +6106,7 @@ pub fn build_crt_file(
     root_name: []const u8,
     output_mode: std.builtin.OutputMode,
     misc_task_tag: MiscTask,
-    prog_node: *std.Progress.Node,
+    prog_node: std.Progress.Node,
     /// These elements have to get mutated to add the owner module after it is
     /// created within this function.
     c_source_files: []CSourceFile,