Missing source location for `enum` literal that can't coerce into `union(enum)`

Zig Version

0.11.0-dev.4059+17255bed4

Steps to Reproduce and Observed Output

const Opcode = enum {
    i32_const,
    i32_add,
};
const Operand = union(enum) {
    none: void,
    i32: i32,
};

const Instruction = struct {
    opcode: Opcode,
    operand: Operand,
};

fn test_execute(comptime instructions: []const struct { Opcode, Operand }) void {
    comptime var real_instructions: []const Instruction = &.{};
    inline for (instructions) |instruction| {
        real_instructions = real_instructions ++ .{.{ .opcode = instruction[0], .operand = instruction[1] }};
    }
}

test {
    test_execute(&.{
        .{ .i32_const, .{ .i32 = 64 } },
        .{ .i32_const, .{ .i32 = 64 } },
        .{ .i32_add, .{ .none } },
        .{ .i32_const, .{ .i32 = 128 } },
        .{ .i32_add, .{ .none = {} } },
    });
}

$ zig test x.zig -freference-trace
x.zig:25:18: error: expected type 'x.Operand', found 'struct{comptime @TypeOf(.enum_literal) = .none}'
    test_execute(&.{
                 ^
x.zig:5:17: note: union declared here
const Operand = union(enum) {
                ^~~~~
referenced by:
    test_0: x.zig:25:5

Can you spot the mistake?

In

        .{ .i32_add, .{ .none } },

.none has to be .none = {} and then:

$ zig test x.zig -freference-trace
All 1 tests passed.

If I have a much longer list of instructions, this would be even more confusing. It would be really helpful if the compiler pointed at the line where something didn't coerce right.

Expected Output

It might be enough if it just points at a different line instead of the top &.{:

$ zig test x.zig -freference-trace
x.zig:28:25: error: expected type 'x.Operand', found 'struct{comptime @TypeOf(.enum_literal) = .none}'
        .{ .i32_add, .{ .none } },
                     ^~~~~~~~~
x.zig:5:17: note: union declared here
const Operand = union(enum) {
                ^~~~~
referenced by:
    test_0: x.zig:25:5

Even nicer would be if it checks if the union(enum) has a field of the name of the enum literal and if the type is void so it can directly tell you to note: use '.none = {}' instead.

This might be a duplicate of something else but I think the example I provided certainly makes for a nice test case when this is fixed.

[xdBronch]

even better (imo), it could tell you to do .{ .i32_add, .none },

[mlugg]

Be warned: mildly off-topic implementation details lie here

The difficulty here is that the expression is evaluated as a whole before being passed as a parameter. The use of & means RLS doesn't come into play, that is, the type coercion only happens after the expression is completely evaluated. To make this work we'd need to somehow special-case passing literals of this form as parameters. If RLS is extended slightly to contain an expected type (or similar) for ri.rl == .ref, we may be able to improve this. For example, if &expr has result loc .{ .ty = *T }, then expr has result loc .{ .ref_ty = T }; if &expr has result loc []T, then expr has result loc .{ .ref_arr_ty = T } (or something like that).

Preserving this type information is useful outside of the context of error messages. Consider a call f(&.{@intCast(x)}) where f: fn ([]const u16) void. The & here means the @intCast has ri.rl == .ref, so has no known result type. Adding this type information - if it can be done unambiguously (I'm uncertain as of yet, I'd need to think about allowed coercions) - seems like an objective improvement.

[Vexu]

Fixed by #16512:

a.zig:26:23: error: type 'a.Operand' does not support array initialization syntax
        .{ .i32_add, .{ .none } },
                     ~^~~~~~~~~