feat(anytype): make format working

Author: RossComputerGuy

any+/anytype.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 const Self = @This();
 
 // TODO: use any-writer when it exists
-const PointerFormat = *const fn (*Self, options: std.fmt.FormatOptions, *std.io.FixedBufferStream([]u8)) anyerror!void;
+const PointerFormat = *const fn (*const Self, options: std.fmt.FormatOptions, *std.io.FixedBufferStream([]u8)) error{ NoSpaceLeft, InvalidCast }!void;
 
 type: []const u8,
 size: usize = 0,
@@ -18,8 +18,8 @@ pub inline fn init(value: anytype) Self {
 pub inline fn initExplicit(comptime T: type, value: T) Self {
     var size: usize = @sizeOf(T);
     var ptrFormat: PointerFormat = (struct {
-        fn func(t: *Self, options: std.fmt.FormatOptions, stream: *std.io.FixedBufferStream([]u8)) !void {
-            const self: T = try t.cast(T);
+        fn func(t: *const Self, options: std.fmt.FormatOptions, stream: *std.io.FixedBufferStream([]u8)) !void {
+            const self: T = t.cast(T) catch return error.NoSpaceLeft;
             return std.fmt.formatType(self, "", options, stream.writer(), 3);
         }
     }).func;
@@ -30,8 +30,8 @@ pub inline fn initExplicit(comptime T: type, value: T) Self {
         .Enum => @ptrFromInt(@intFromEnum(value)),
         .Struct, .Union => blk: {
             ptrFormat = (struct {
-                fn func(t: *Self, options: std.fmt.FormatOptions, stream: *std.io.FixedBufferStream([]u8)) !void {
-                    const self: T = try t.cast(T);
+                fn func(t: *const Self, options: std.fmt.FormatOptions, stream: *std.io.FixedBufferStream([]u8)) !void {
+                    const self: T = t.cast(T) catch return error.NoSpaceLeft;
                     return if (@hasDecl(T, "format")) self.format("", options, stream.writer()) else std.fmt.formatType(self, "", options, stream.writer(), 3);
                 }
             }).func;
@@ -90,31 +90,24 @@ pub inline fn len(self: Self, comptime T: type) usize {
     return @divExact(self.size, size);
 }
 
-pub inline fn format(self: Self, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
-    if (self.ptrFormat) |ptrFormat| {
-        const size = comptime if (std.mem.indexOf(u8, fmt, "%")) |sizeStart| std.fmt.parseInt(comptime_int, fmt[sizeStart..]) else 0x1000;
+pub inline fn format(self: *const Self, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+    const size = comptime if (std.mem.indexOf(u8, fmt, "%")) |sizeStart| std.fmt.parseInt(comptime_int, fmt[sizeStart..]) else 0x1000;
 
-        const trunc_msg = "(msg truncated)";
-        var buf: [size + trunc_msg.len]u8 = undefined;
+    const trunc_msg = "(msg truncated)";
+    var buf: [size + trunc_msg.len]u8 = undefined;
+    @memset(&buf, 0);
 
-        var stream = std.io.fixedBufferStream(buf[0..size]);
-        ptrFormat(self, options, &stream) catch |err| switch (err) {
-            error.NoSpaceLeft => blk: {
-                @memcpy(buf[size..], trunc_msg);
-                break :blk &buf;
-            },
-            else => return err,
-        };
+    var stream = std.io.fixedBufferStream(buf[0..size]);
+    const result = self.ptrFormat(self, options, &stream);
 
-        try writer.writeAll(buf);
+    if (result == error.NoSpaceLeft) {
+        @memcpy(buf[size..], trunc_msg);
+        try writer.writeAll(&buf);
+    } else if (result == error.InvalidCast) {
+        std.debug.panic("Failed to cast {s}", .{self.type});
     } else {
-        try writer.writeAll(@typeName(Self));
-        try writer.print("{{ .size = {}, .len = {}, .type = \"{s}\", .ptr = {*} }}", .{
-            self.size,
-            self.len(),
-            self.type,
-            self.ptr,
-        });
+        const end = std.mem.indexOf(u8, &buf, &[_]u8{0}) orelse buf.len;
+        try writer.writeAll(buf[0..end]);
     }
 }
 
@@ -162,3 +155,8 @@ test "Invalid casts" {
     try std.testing.expectError(error.InvalidCast, initExplicit(f32, 123.456).cast(u8));
     try std.testing.expectError(error.InvalidCast, initExplicit(f32, 123.456).cast(f128));
 }
+
+test "Anytype formatting" {
+    try std.testing.expectFmt("255", "{}", .{initExplicit(u8, 255)});
+    try std.testing.expectFmt("123.456", "{}", .{initExplicit(f32, 123.456)});
+}