switch exhaustion error has wrong type name

[nektro]

Zig Version

0.10.0-dev.208+dd076d8cb

Steps to Reproduce

test {
    foo(u8);
}

fn foo(comptime T: type) void {
    return switch (@typeInfo(T)) {
        .Type => {},
        .Void => {},
        .Bool => {},
        .NoReturn => {},
        .Int => {},
        .Float => {},
        .Pointer => {},
        .Array => {},
        .Struct => {},
        .ComptimeFloat => {},
        .ComptimeInt => {},
        .Undefined => {},
        .Null => {},
        .Optional => {},
        .ErrorUnion => {},
        .ErrorSet => {},
        .Enum => {},
        .Union => {},
        .Fn => {},
        .BoundFn => {},
        .Opaque => {},
        .Frame => {},
        .AnyFrame => {},
        .Vector => {},
        // .EnumLiteral => {},
    };
}

Expected Behavior

./test.zig:6:12: error: enumeration value 'std.builtin.TypeInfo.EnumLiteral' not handled in switch
    return switch (@typeInfo(T)) {
           ^

Actual Behavior

./test.zig:6:12: error: enumeration value '@typeInfo(std.builtin.TypeInfo).Union.tag_type.?.EnumLiteral' not handled in switch
    return switch (@typeInfo(T)) {
           ^

[enkore]

The expected behavior is nicer to read but as far as I can tell the actual behavior is not wrong, just verbose.

[nektro]

error now

test.zig:6:12: error: switch must handle all possibilities
    return switch (@typeInfo(T)) {
           ^~~~~~
/home/meghan/.local/share/zig/lib/std/builtin.zig:251:5: note: unhandled enumeration value: 'EnumLiteral'
    EnumLiteral: void,
    ^~~~~~~~~~~~~~~~~
/home/meghan/.local/share/zig/lib/std/builtin.zig:227:18: note: enum '@typeInfo(builtin.Type).Union.tag_type.?' declared here
pub const Type = union(enum) {
                 ^~~~~

[nektro]

note this is only happening because the union has an inferred tag type, so the ideal is still the title but status quo is acceptable

test {
    foo(.{ .a = 4 });
}

const E = enum {
    a,
    b,
    c,
};

const U = union(E) {
    a: u8,
    b: u16,
    c: u32,
};

fn foo(u: U) void {
    return switch (u) {
        .a => {},
        .b => {},
    };
}

test.zig:18:12: error: switch must handle all possibilities
    return switch (u) {
           ^~~~~~
test.zig:8:5: note: unhandled enumeration value: 'c'
    c,
    ^
test.zig:5:11: note: enum 'test.E' declared here
const E = enum {
          ^~~~