fixup compile errors after rebase

Khitiara · Khitiara · commit 0235548fe736 · 2026-02-03T22:19:37.000-05:00
diff --git a/src/BuildInterface.zig b/src/BuildInterface.zig
@@ -26,7 +26,7 @@ pub fn createDisk(dimmer: Interface, size: u64, content: Content) std.Build.Lazy
 
     const write_files = b.addWriteFiles();
 
-    const script_source, const variables = renderContent(write_files, b.allocator, content);
+    const script_source, const variables = renderContent(write_files, b.allocator, content, dimmer.builder.graph.io);
 
     const script_file = write_files.add("image.dis", script_source);
 
@@ -69,6 +69,7 @@ fn renderContent(
     wfs: *std.Build.Step.WriteFile,
     allocator: std.mem.Allocator,
     content: Content,
+    io: std.Io,
 ) struct { []const u8, ContentWriter.VariableMap } {
     var code: std.Io.Writer.Allocating = .init(allocator);
     defer code.deinit();
@@ -81,7 +82,7 @@ fn renderContent(
         .vars = &variables,
     };
 
-    cw.render(content) catch @panic("out of memory");
+    cw.render(content, io) catch @panic("out of memory");
 
     const source = std.mem.trim(
         u8,
@@ -109,7 +110,7 @@ const ContentWriter = struct {
     code: *std.Io.Writer,
     vars: *VariableMap,
 
-    fn render(cw: ContentWriter, content: Content) !void {
+    fn render(cw: ContentWriter, content: Content, io: std.Io) !void {
         // Always insert some padding before and after:
         try cw.code.writeAll(" ");
         errdefer cw.code.writeAll(" ") catch {};
@@ -124,15 +125,15 @@ const ContentWriter = struct {
             },
 
             .paste_file => |data| {
-                try cw.code.print("paste-file {f}", .{cw.fmtLazyPath(data, .file)});
+                try cw.code.print("paste-file {f}", .{cw.fmtLazyPath(data, .file, io)});
             },
 
             .mbr_part_table => |data| {
                 try cw.code.writeAll("mbr-part\n");
 
                 if (data.bootloader) |loader| {
                     try cw.code.writeAll("  bootloader ");
-                    try cw.render(loader.*);
+                    try cw.render(loader.*, io);
                     try cw.code.writeAll("\n");
                 }
 
@@ -153,7 +154,7 @@ const ContentWriter = struct {
                             try cw.code.print("    size {d}\n", .{size});
                         }
                         try cw.code.writeAll("    contains");
-                        try cw.render(part.data);
+                        try cw.render(part.data, io);
                         try cw.code.writeAll("\n");
                         try cw.code.writeAll("  endpart\n");
                     } else {
@@ -195,7 +196,7 @@ const ContentWriter = struct {
                         try cw.code.print("    size {d}\n", .{size});
                     }
                     try cw.code.writeAll("    contains");
-                    try cw.render(part.data);
+                    try cw.render(part.data, io);
                     try cw.code.writeAll("\n");
                     try cw.code.writeAll("  endpart\n");
                 }
@@ -213,14 +214,14 @@ const ContentWriter = struct {
                     });
                 }
 
-                try cw.renderFileSystemTree(data.tree);
+                try cw.renderFileSystemTree(data.tree, io);
 
                 try cw.code.writeAll("endfat\n");
             },
         }
     }
 
-    fn renderFileSystemTree(cw: ContentWriter, fs: FileSystem) !void {
+    fn renderFileSystemTree(cw: ContentWriter, fs: FileSystem, io: std.Io) !void {
         for (fs.items) |item| {
             switch (item) {
                 .empty_dir => |dir| try cw.code.print("mkdir {f}\n", .{
@@ -229,16 +230,16 @@ const ContentWriter = struct {
 
                 .copy_dir => |copy| try cw.code.print("copy-dir {f} {f}\n", .{
                     fmtPath(copy.destination),
-                    cw.fmtLazyPath(copy.source, .directory),
+                    cw.fmtLazyPath(copy.source, .directory, io),
                 }),
 
                 .copy_file => |copy| try cw.code.print("copy-file {f} {f}\n", .{
                     fmtPath(copy.destination),
-                    cw.fmtLazyPath(copy.source, .file),
+                    cw.fmtLazyPath(copy.source, .file, io),
                 }),
 
                 .include_script => |script| try cw.code.print("!include {f}\n", .{
-                    cw.fmtLazyPath(script, .file),
+                    cw.fmtLazyPath(script, .file, io),
                 }),
             }
         }
@@ -285,7 +286,7 @@ const ContentWriter = struct {
         }
     };
     const LazyPathFormatter = std.fmt.Alt(
-        struct { ContentWriter, std.Build.LazyPath, UsageHint },
+        struct { ContentWriter, std.Build.LazyPath, UsageHint, std.Io },
         formatLazyPath,
     );
     const UsageHint = enum { file, directory };
@@ -294,19 +295,20 @@ const ContentWriter = struct {
         cw: ContentWriter,
         path: std.Build.LazyPath,
         hint: UsageHint,
+        io: std.Io,
     ) LazyPathFormatter {
-        return .{ .data = .{ cw, path, hint } };
+        return .{ .data = .{ cw, path, hint, io } };
     }
 
     fn fmtPath(path: []const u8) PathFormatter {
         return .{ .path = path };
     }
 
     fn formatLazyPath(
-        data: struct { ContentWriter, std.Build.LazyPath, UsageHint },
+        data: struct { ContentWriter, std.Build.LazyPath, UsageHint, std.Io },
         writer: *std.Io.Writer,
     ) std.Io.Writer.Error!void {
-        const cw, const path, const hint = data;
+        const cw, const path, const hint, const io = data;
 
         switch (path) {
             .cwd_relative,
@@ -319,12 +321,12 @@ const ContentWriter = struct {
                 const rel_path = path.getPath2(cw.wfs.step.owner, &cw.wfs.step);
 
                 const full_path = if (!std.fs.path.isAbsolute(rel_path))
-                    std.fs.cwd().realpathAlloc(cw.wfs.step.owner.allocator, rel_path) catch @panic("oom")
+                    std.Io.Dir.cwd().realPathFileAlloc(io, rel_path, cw.wfs.step.owner.allocator) catch @panic("oom")
                 else
                     rel_path;
 
                 if (!std.fs.path.isAbsolute(full_path)) {
-                    const cwd = std.fs.cwd().realpathAlloc(cw.wfs.step.owner.allocator, ".") catch @panic("oom");
+                    const cwd = std.Io.Dir.cwd().realPathFileAlloc(io, ".", cw.wfs.step.owner.allocator) catch @panic("oom");
                     std.debug.print("non-absolute path detected for {t}: cwd=\"{f}\" path=\"{f}\"\n", .{
                         path,
                         std.zig.fmtString(cwd),
diff --git a/src/components/FillData.zig b/src/components/FillData.zig
@@ -20,7 +20,7 @@ pub fn parse(ctx: dim.Context, stdio: std.Io) !dim.Content {
 }
 
 fn render(self: *FillData, io: std.Io,  stream: *dim.BinaryStream) dim.Content.RenderError!void {
-    var writer = stream.writer(io);
+    var writer = stream.writer(io, &.{});
     writer.interface.splatByteAll(
         self.fill_value,
         stream.length,
diff --git a/src/components/fs/FatFileSystem.zig b/src/components/fs/FatFileSystem.zig
@@ -242,11 +242,11 @@ const AtomicOps = struct {
         defer fs_file.close();
 
         var fs_file_buffer: [1024]u8 = undefined;
-        var adapter = fs_file.writer(io, &fs_file_buffer);
+        var adapter = fs_file.writer( &fs_file_buffer);
 
-        _ = try reader.streamRemaining(&adapter.writer);
+        _ = try reader.streamRemaining(&adapter.interface);
 
-        try adapter.writer.flush();
+        try adapter.interface.flush();
     }
 };
 
diff --git a/src/dim.zig b/src/dim.zig
@@ -63,7 +63,7 @@ const VariableMap = std.StringArrayHashMapUnmanaged([]const u8);
 
 var global_deps_file: ?std.Io.File = null;
 var global_deps_buffer: []u8 = undefined;
-var global_deps_file_writer: std.fs.File.Writer = undefined;
+var global_deps_file_writer: std.Io.File.Writer = undefined;
 var global_deps_writer: *std.Io.Writer = undefined;
 
 pub fn main(init: std.process.Init) !u8 {
@@ -453,7 +453,7 @@ const Environment = struct {
 ///
 ///
 pub const Content = struct {
-    pub const RenderError = FileName.OpenError || std.Io.Reader.Error || BinaryStream.WriteError || error{
+    pub const RenderError = FileName.OpenError || std.Io.Reader.Error || std.Io.Writer.Error || BinaryStream.WriteError || error{
         ConfigurationError,
         OutOfBounds,
         OutOfMemory,
@@ -511,7 +511,7 @@ pub const FileName = struct {
         const file = name.root_dir.openFile(stdio, name.rel_path, .{}) catch |err| switch (err) {
             error.FileNotFound => {
                 var buffer: [std.fs.max_path_bytes]u8 = undefined;
-                name.env.report_error("failed to open \"{f}/{f}\": not found", .{
+                name.env.report_error("failed to open \"{f}\": not found", .{
                     std.zig.fmtString(if (name.root_dir.realPath(stdio, &buffer)) |l| buffer[0..l] else |e| @errorName(e)),
                 }) catch |e| std.debug.assert(e == error.OutOfMemory);
                 return error.FileNotFound;
@@ -641,9 +641,9 @@ pub const FileName = struct {
         var file_reader = handle.file.reader(io, &.{});
 
         var buffer: [8192]u8 = undefined;
-        var writer = stream.writer(io).adaptToNewApi(&buffer);
+        var writer = stream.writer(io,&buffer);
 
-        _ = try file_reader.interface.streamRemaining(&writer.new_interface);
+        _ = try file_reader.interface.streamRemaining(&writer.interface);
     }
 };
 
@@ -655,7 +655,7 @@ pub const FileHandle = struct {
         fd.* = undefined;
     }
 
-    pub fn reader(fd: FileHandle, io: std.Io, buffer: []u8) std.fs.File.Reader {
+    pub fn reader(fd: FileHandle, io: std.Io, buffer: []u8) std.Io.File.Reader {
         return fd.file.reader(io, buffer);
     }
 };
@@ -723,7 +723,7 @@ pub const BinaryStream = struct {
         switch (bs.backing) {
             .buffer => |ptr| @memcpy(data, ptr[@intCast(offset)..][0..data.len]),
             .file => |state| {
-                const len = state.file.pread(data, state.base + offset) catch return error.IoError;
+                const len = state.file.readPositionalAll(io, data, state.base + offset) catch return error.IoError;
                 if (len != data.len)
                     return error.Overflow;
             },
@@ -738,9 +738,7 @@ pub const BinaryStream = struct {
         switch (bs.backing) {
             .buffer => |ptr| @memcpy(ptr[@intCast(offset)..][0..data.len], data),
             .file => |state| {
-                const len = state.file.pwrite(data, state.base + offset) catch return error.IoError;
-                if (len != data.len)
-                    return error.Overflow;
+                state.file.writePositionalAll(io,data, state.base + offset) catch return error.IoError;
             },
         }
     }
@@ -751,13 +749,13 @@ pub const BinaryStream = struct {
         bs.virtual_offset = offset;
     }
 
-    pub fn writer(bs: *BinaryStream, stdio: std.Io) Writer {
+    pub fn writer(bs: *BinaryStream, stdio: std.Io, buffer: []u8) Writer {
         return .{
             .interface = .{
                 .vtable = &.{
                     .drain = Writer.drain,
                 },
-                .buffer = &.{},
+                .buffer = buffer,
             },
             .stream = bs,
             .stdio = stdio,

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ pub fn parse(ctx: dim.Context, stdio: std.Io) !dim.Content {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`fn render(self: FillData, io: std.Io, stream: dim.BinaryStream) dim.Content.RenderError!void {`
`23`		`- var writer = stream.writer(io);`
	`23`	`+ var writer = stream.writer(io, &.{});`
`24`	`24`	`writer.interface.splatByteAll(`
`25`	`25`	`self.fill_value,`
`26`	`26`	`stream.length,`