Union enums, @TagType, and "error: runtime cast to union '…' which has non-void fields" or "error: cast to union '…' must initialize '…' field '…'"

[kivikakk]

This one caught me by surprise:

const std = @import("std");

const UnionEnum = union(enum) {
    A: u8,

    pub fn format(self: UnionEnum, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
        try std.fmt.format(writer, "Fancy {}", .{self.A});
    }
};

test "" {
    const x = UnionEnum{ .A = 123 };
    std.debug.print("{}\n", .{x});
    std.debug.print("{}\n", .{@as(@TagType(UnionEnum), x)});
}

zig test example.zig gives:

/Users/kameliya/Code/zig/build-native/lib/zig/std/fmt.zig:386:20: error: cast to union 'UnionEnum' must initialize 'u8' field 'A'
        return try value.format(fmt, options, writer);
                   ^
/Users/kameliya/Code/zig/build-native/lib/zig/std/fmt.zig:356:23: note: called from here
        try formatType(
                      ^
/Users/kameliya/Code/zig/build-native/lib/zig/std/io/writer.zig:33:34: note: called from here
            return std.fmt.format(self, format, args);
                                 ^
/Users/kameliya/Code/zig/build-native/lib/zig/std/debug.zig:65:27: note: called from here
    nosuspend stderr.print(fmt, args) catch return;
                          ^
./example.zig:14:20: note: called from here
    std.debug.print("{}\n", .{@as(@TagType(UnionEnum), x)});

I hit this through many more layers of comptime parameters so it was super cryptic what was happening at first. Now it's pretty clear:

• std.fmt.formatType checks if (comptime std.meta.trait.hasFn("format")(T))
• this is true even for the @TagType(…) variant, i.e. the enum — it shares its decls with the union (? wording?)
• it then calls the user-supplied format function with the enum value as the first argument, which attempts and fails the enum-to-union cast

I think in my mental model I assumed the enum wouldn't also possess the decls, but it's not really clear that they should belong to one and not the other.

I don't know exactly what might've made this easier; perhaps std.fmt.format could check the signature of the format function it's calling? Really bad hack that catches this kind of error:

    if (comptime std.meta.trait.hasFn("format")(T)) {
        const formatFn = @typeInfo(@TypeOf(@field(T, "format"))).Fn;
        if (formatFn.args.len != 4 or formatFn.args[0].arg_type != T) { 
            @compileError("NOPE");
        }    
        return try value.format(fmt, options, writer);
    }    

But maybe this would reject some valid cases I'm not thinking about right now.

[Vexu]

The issues is indeed with @TagType(U) also having the decls of U which seems like a bug to me.

const U = union(enum) {
    a: u8,
    const foo = 1;
};
test "" {
    @import("std").testing.expect(!@hasDecl(@TagType(U), "foo"));
}