1 files changed, 62 insertions, 66 deletions

diff --git a/clap.zig b/clap.zig
index b666f56..3863087 100644
--- a/clap.zig
+++ b/clap.zig
@@ -542,7 +542,7 @@ pub const Diagnostic = struct {
 
     /// Default diagnostics reporter when all you want is English with no colors.
     /// Use this as a reference for implementing your own if needed.
-    pub fn report(diag: Diagnostic, stream: anytype, err: anyerror) !void {
+    pub fn report(diag: Diagnostic, stream: *std.Io.Writer, err: anyerror) !void {
         var longest = diag.name.longest();
         if (longest.kind == .positional)
             longest.name = diag.arg;
@@ -567,9 +567,9 @@ pub const Diagnostic = struct {
 
 fn testDiag(diag: Diagnostic, err: anyerror, expected: []const u8) !void {
     var buf: [1024]u8 = undefined;
-    var slice_stream = std.io.fixedBufferStream(&buf);
-    diag.report(slice_stream.writer(), err) catch unreachable;
-    try std.testing.expectEqualStrings(expected, slice_stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buf);
+    diag.report(&writer, err) catch unreachable;
+    try std.testing.expectEqualStrings(expected, writer.buffered());
 }
 
 test "Diagnostic.report" {
@@ -1263,9 +1263,9 @@ fn testErr(
         .diagnostic = &diag,
     }) catch |err| {
         var buf: [1024]u8 = undefined;
-        var fbs = std.io.fixedBufferStream(&buf);
-        diag.report(fbs.writer(), err) catch return error.TestFailed;
-        try std.testing.expectEqualStrings(expected, fbs.getWritten());
+        var writer = std.Io.Writer.fixed(&buf);
+        diag.report(&writer, err) catch return error.TestFailed;
+        try std.testing.expectEqualStrings(expected, writer.buffered());
         return;
     };
 
@@ -1366,7 +1366,7 @@ pub const HelpOptions = struct {
 /// The output can be constumized with the `opt` parameter. For default formatting `.{}` can
 /// be passed.
 pub fn help(
-    writer: anytype,
+    writer: *std.Io.Writer,
     comptime Id: type,
     params: []const Param(Id),
     opt: HelpOptions,
@@ -1374,8 +1374,9 @@ pub fn help(
     const max_spacing = blk: {
         var res: usize = 0;
         for (params) |param| {
-            var cs = ccw.codepointCountingWriter(std.io.null_writer);
-            try printParam(cs.writer(), Id, param);
+            var discarding = std.Io.Writer.Discarding.init(&.{});
+            var cs = ccw.CodepointCountingWriter.init(&discarding.writer);
+            try printParam(&cs.interface, Id, param);
             if (res < cs.codepoints_written)
                 res = @intCast(cs.codepoints_written);
         }
@@ -1390,16 +1391,15 @@ pub fn help(
     var first_parameter: bool = true;
     for (params) |param| {
         if (!first_parameter)
-            try writer.writeByteNTimes('\n', opt.spacing_between_parameters);
+            try writer.splatByteAll('\n', opt.spacing_between_parameters);
 
         first_parameter = false;
-        try writer.writeByteNTimes(' ', opt.indent);
+        try writer.splatByteAll(' ', opt.indent);
 
-        var cw = ccw.codepointCountingWriter(writer);
-        try printParam(cw.writer(), Id, param);
+        var cw = ccw.CodepointCountingWriter.init(writer);
+        try printParam(&cw.interface, Id, param);
 
-        const Writer = DescriptionWriter(@TypeOf(writer));
-        var description_writer = Writer{
+        var description_writer = DescriptionWriter{
             .underlying_writer = writer,
             .indentation = description_indentation,
             .printed_chars = @intCast(cw.codepoints_written),
@@ -1498,57 +1498,53 @@ pub fn help(
     }
 }
 
-fn DescriptionWriter(comptime UnderlyingWriter: type) type {
-    return struct {
-        pub const WriteError = UnderlyingWriter.Error;
-
-        underlying_writer: UnderlyingWriter,
-
-        indentation: usize,
-        max_width: usize,
-        printed_chars: usize,
-
-        pub fn writeWord(writer: *@This(), word: []const u8) !void {
-            std.debug.assert(word.len != 0);
+const DescriptionWriter = struct {
+    underlying_writer: *std.Io.Writer,
 
-            var first_word = writer.printed_chars <= writer.indentation;
-            const chars_to_write = try std.unicode.utf8CountCodepoints(word) + @intFromBool(!first_word);
-            if (chars_to_write + writer.printed_chars > writer.max_width) {
-                // If the word does not fit on this line, then we insert a new line and print
-                // it on that line. The only exception to this is if this was the first word.
-                // If the first word does not fit on this line, then it will also not fit on the
-                // next one. In that case, all we can really do is just output the word.
-                if (!first_word)
-                    try writer.newline();
+    indentation: usize,
+    max_width: usize,
+    printed_chars: usize,
 
-                first_word = true;
-            }
+    pub fn writeWord(writer: *@This(), word: []const u8) !void {
+        std.debug.assert(word.len != 0);
 
+        var first_word = writer.printed_chars <= writer.indentation;
+        const chars_to_write = try std.unicode.utf8CountCodepoints(word) + @intFromBool(!first_word);
+        if (chars_to_write + writer.printed_chars > writer.max_width) {
+            // If the word does not fit on this line, then we insert a new line and print
+            // it on that line. The only exception to this is if this was the first word.
+            // If the first word does not fit on this line, then it will also not fit on the
+            // next one. In that case, all we can really do is just output the word.
             if (!first_word)
-                try writer.underlying_writer.writeAll(" ");
+                try writer.newline();
 
-            try writer.ensureIndented();
-            try writer.underlying_writer.writeAll(word);
-            writer.printed_chars += chars_to_write;
+            first_word = true;
         }
 
-        pub fn newline(writer: *@This()) !void {
-            try writer.underlying_writer.writeAll("\n");
-            writer.printed_chars = 0;
-        }
+        if (!first_word)
+            try writer.underlying_writer.writeAll(" ");
 
-        fn ensureIndented(writer: *@This()) !void {
-            if (writer.printed_chars < writer.indentation) {
-                const to_indent = writer.indentation - writer.printed_chars;
-                try writer.underlying_writer.writeByteNTimes(' ', to_indent);
-                writer.printed_chars += to_indent;
-            }
+        try writer.ensureIndented();
+        try writer.underlying_writer.writeAll(word);
+        writer.printed_chars += chars_to_write;
+    }
+
+    pub fn newline(writer: *@This()) !void {
+        try writer.underlying_writer.writeAll("\n");
+        writer.printed_chars = 0;
+    }
+
+    fn ensureIndented(writer: *@This()) !void {
+        if (writer.printed_chars < writer.indentation) {
+            const to_indent = writer.indentation - writer.printed_chars;
+            try writer.underlying_writer.splatByteAll(' ', to_indent);
+            writer.printed_chars += to_indent;
         }
-    };
-}
+    }
+};
 
 fn printParam(
-    stream: anytype,
+    stream: *std.Io.Writer,
     comptime Id: type,
     param: Param(Id),
 ) !void {
@@ -1583,9 +1579,9 @@ fn testHelp(opt: HelpOptions, str: []const u8) !void {
     defer std.testing.allocator.free(params);
 
     var buf: [2048]u8 = undefined;
-    var fbs = std.io.fixedBufferStream(&buf);
-    try help(fbs.writer(), Help, params, opt);
-    try std.testing.expectEqualStrings(str, fbs.getWritten());
+    var writer = std.Io.Writer.fixed(&buf);
+    try help(&writer, Help, params, opt);
+    try std.testing.expectEqualStrings(str, writer.buffered());
 }
 
 test "clap.help" {
@@ -2015,9 +2011,9 @@ test "clap.help" {
 ///
 /// First all none value taking parameters, which have a short name are printed, then non
 /// positional parameters and finally the positional.
-pub fn usage(stream: anytype, comptime Id: type, params: []const Param(Id)) !void {
-    var cos = ccw.codepointCountingWriter(stream);
-    const cs = cos.writer();
+pub fn usage(stream: *std.Io.Writer, comptime Id: type, params: []const Param(Id)) !void {
+    var cos = ccw.CodepointCountingWriter.init(stream);
+    const cs = &cos.interface;
     for (params) |param| {
         const name = param.names.short orelse continue;
         if (param.takes_value != .none)
@@ -2060,7 +2056,7 @@ pub fn usage(stream: anytype, comptime Id: type, params: []const Param(Id)) !voi
                 try cs.writeAll("...");
         }
 
-        try cs.writeByte(']');
+        try cs.writeAll("]");
     }
 
     if (!has_positionals)
@@ -2083,9 +2079,9 @@ pub fn usage(stream: anytype, comptime Id: type, params: []const Param(Id)) !voi
 
 fn testUsage(expected: []const u8, params: []const Param(Help)) !void {
     var buf: [1024]u8 = undefined;
-    var fbs = std.io.fixedBufferStream(&buf);
-    try usage(fbs.writer(), Help, params);
-    try std.testing.expectEqualStrings(expected, fbs.getWritten());
+    var writer = std.Io.Writer.fixed(&buf);
+    try usage(&writer, Help, params);
+    try std.testing.expectEqualStrings(expected, writer.buffered());
 }
 
 test "usage" {