std.heap.DebugAllocator: never detect TTY config

instead, allow the user to set it as a field.

this fixes a bug where leak printing and error printing would run tty
config detection for stderr, and then emit a log, which is not necessary
going to print to stderr.

however, the nice defaults are gone; the user must explicitly assign the
tty_config field during initialization or else the logging will not have
color.

related: https://github.com/ziglang/zig/issues/24510

3 files changed, 12 insertions, 11 deletions

diff --git a/lib/std/Build/Fuzz.zig b/lib/std/Build/Fuzz.zig
index 8fedb7e067..8837d7d527 100644
--- a/lib/std/Build/Fuzz.zig
+++ b/lib/std/Build/Fuzz.zig
@@ -360,12 +360,13 @@ fn coverageRunCancelable(fuzz: *Fuzz) Io.Cancelable!void {
 fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutOfMemory, AlreadyReported, Canceled }!void {
     assert(fuzz.mode == .forever);
     const ws = fuzz.mode.forever.ws;
+    const gpa = fuzz.gpa;
     const io = fuzz.io;
 
     try fuzz.coverage_mutex.lock(io);
     defer fuzz.coverage_mutex.unlock(io);
 
-    const gop = try fuzz.coverage_files.getOrPut(fuzz.gpa, coverage_id);
+    const gop = try fuzz.coverage_files.getOrPut(gpa, coverage_id);
     if (gop.found_existing) {
         // We are fuzzing the same executable with multiple threads.
         // Perhaps the same unit test; perhaps a different one. In any
@@ -383,12 +384,12 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
         .entry_points = .{},
         .start_timestamp = ws.now(),
     };
-    errdefer gop.value_ptr.coverage.deinit(fuzz.gpa);
+    errdefer gop.value_ptr.coverage.deinit(gpa);
 
     const rebuilt_exe_path = run_step.rebuilt_executable.?;
     const target = run_step.producer.?.rootModuleTarget();
     var debug_info = std.debug.Info.load(
-        fuzz.gpa,
+        gpa,
         io,
         rebuilt_exe_path,
         &gop.value_ptr.coverage,
@@ -400,7 +401,7 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
         });
         return error.AlreadyReported;
     };
-    defer debug_info.deinit(fuzz.gpa);
+    defer debug_info.deinit(gpa);
 
     const coverage_file_path: Build.Cache.Path = .{
         .root_dir = run_step.step.owner.cache_root,
@@ -434,14 +435,14 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
 
     const header: *const abi.SeenPcsHeader = @ptrCast(mapped_memory[0..@sizeOf(abi.SeenPcsHeader)]);
     const pcs = header.pcAddrs();
-    const source_locations = try fuzz.gpa.alloc(Coverage.SourceLocation, pcs.len);
-    errdefer fuzz.gpa.free(source_locations);
+    const source_locations = try gpa.alloc(Coverage.SourceLocation, pcs.len);
+    errdefer gpa.free(source_locations);
 
     // Unfortunately the PCs array that LLVM gives us from the 8-bit PC
     // counters feature is not sorted.
     var sorted_pcs: std.MultiArrayList(struct { pc: u64, index: u32, sl: Coverage.SourceLocation }) = .{};
-    defer sorted_pcs.deinit(fuzz.gpa);
-    try sorted_pcs.resize(fuzz.gpa, pcs.len);
+    defer sorted_pcs.deinit(gpa);
+    try sorted_pcs.resize(gpa, pcs.len);
     @memcpy(sorted_pcs.items(.pc), pcs);
     for (sorted_pcs.items(.index), 0..) |*v, i| v.* = @intCast(i);
     sorted_pcs.sortUnstable(struct {
@@ -452,7 +453,7 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
         }
     }{ .addrs = sorted_pcs.items(.pc) });
 
-    debug_info.resolveAddresses(fuzz.gpa, sorted_pcs.items(.pc), sorted_pcs.items(.sl)) catch |err| {
+    debug_info.resolveAddresses(gpa, io, sorted_pcs.items(.pc), sorted_pcs.items(.sl)) catch |err| {
         log.err("failed to resolve addresses to source locations: {t}", .{err});
         return error.AlreadyReported;
     };
diff --git a/lib/std/Build/Step/InstallArtifact.zig b/lib/std/Build/Step/InstallArtifact.zig
index 4c1506aa33..019d465f01 100644
--- a/lib/std/Build/Step/InstallArtifact.zig
+++ b/lib/std/Build/Step/InstallArtifact.zig
@@ -172,7 +172,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
                 defer src_dir.close(io);
 
                 var it = try src_dir.walk(b.allocator);
-                next_entry: while (try it.next()) |entry| {
+                next_entry: while (try it.next(io)) |entry| {
                     for (dir.options.exclude_extensions) |ext| {
                         if (std.mem.endsWith(u8, entry.path, ext)) continue :next_entry;
                     }
diff --git a/lib/std/Build/Step/WriteFile.zig b/lib/std/Build/Step/WriteFile.zig
index 3d712fa1d4..53222289e6 100644
--- a/lib/std/Build/Step/WriteFile.zig
+++ b/lib/std/Build/Step/WriteFile.zig
@@ -309,7 +309,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
 
         var it = try already_open_dir.walk(gpa);
         defer it.deinit();
-        while (try it.next()) |entry| {
+        while (try it.next(io)) |entry| {
             if (!dir.options.pathIncluded(entry.path)) continue;
 
             const src_entry_path = try src_dir_path.join(arena, entry.path);