Invalid slice assignment

[hsyl20]

Zig Version

0.15.0-dev.77+aa8aa6625

Steps to Reproduce and Observed Behavior

Consider the following reproducer (minimized from a larger codebase):

const std = @import("std");

const Foo = enum { x, y };
const Bar = union(enum) { a: void, b: void, v: u8 };

fn mk(u: u8) Bar {
    return .{ .v = u };
}

fn foo(f: Foo) !void {
    //const e:[]const Bar = switch (f) { 
    const e = switch (f) {
        .x => &.{ .a, mk(1) },
        .y => &.{ .b, mk(2) },
    };
    try std.testing.expectEqualSlices(Bar, &.{ .b, .{ .v = 2 } }, e);
}

test "bug" {
    try foo(.y);
}

It fails with:

> zig test test.zig
slices differ. first difference occurs at index 0 (0x0)

============ expected this output: =============  len: 2 (0x2)

[0]: test.Bar{ .b = void }
[1]: test.Bar{ .v = 2 }

============= instead found this: ==============  len: 2 (0x2)

[0]: test.Bar{ .a = void } <--- WRONG! Should be `.b`
[1]: test.Bar{ .v = 2 }

================================================

I've looked at the assembly and indeed the same literal value is assigned as first element in both cases.

	.type	.L__unnamed_6,@object
	.section	.rodata,"a",@progbits
.L__unnamed_6:
	.byte	0
	.zero	1
	.size	.L__unnamed_6, 2

       ...

	mov	cx, word ptr [rip + .L__unnamed_6] ; BAR's tag literal
	mov	word ptr [rbp - 8], cx
	mov	ax, word ptr [rax]
	mov	word ptr [rbp - 6], ax
	mov	eax, dword ptr [rbp - 8]
	mov	dword ptr [rbp - 4], eax
	mov	r8d, 2
	lea	rcx, [rbp - 4]
	mov	esi, offset __anon_561
	mov	rdx, r8
	call	testing.expectEqualSlices__anon_570

Notes:

• adding a type ascription to const e (see the comment) seems to workaround the issue.
• reversing the order of the switch alternatives changes the common tag that is used.

Expected Behavior

Assigned value should be correct.

[mlugg]

This should be a compile error due to incompatible types *const struct { comptime @Type(.enum_literal) = .a, Bar } and *const struct { comptime @Type(.enum_literal) = .b, Bar }.

[g-logunov]

Investigated the code path, I believe that .x and .y branches have distinct and correct pointer-to-struct types until:
https://github.com/ziglang/zig/blob/master/src/Sema.zig#L34021

if (try sema.resolvePairInMemoryCoercible(block, src, Type.fromInterned(ptr_info.child), Type.fromInterned(peer_info.child))) |pointee| {
    ptr_info.child = pointee.toIntern();
    break :good;
}

Where sema.resolvePairInMemoryCoercible returns exactly one of: lhs (ty_a), rhs (ty_b) or null.

fn resolvePairInMemoryCoercible(sema: *Sema, block: *Block, src: LazySrcLoc, ty_a: Type, ty_b: Type) !?Type {
    const target = sema.pt.zcu.getTarget();

    // ty_b -> ty_a
    if (.ok == try sema.coerceInMemoryAllowed(block, ty_a, ty_b, false, target, src, src, null)) {
        return ty_a;
    }

    // ty_a -> ty_b
    if (.ok == try sema.coerceInMemoryAllowed(block, ty_b, ty_a, false, target, src, src, null)) {
        return ty_b;
    }

    return null;
}

After the break :good modifications are for sentinel, empty-struct .{} and alignment optional cases, that I believe don't kick in.

So the result is return .{ .success = try pt.ptrTypeSema(opt_ptr_info.?) };, where opt_ptr_info is exactly first (.x) branch return type.

[g-logunov]

I believe, the function resolvePairInMemoryCoercible is not used outside of resolvePeerTypesInner, which in turn is not used outside of resolvePeerTypes.

As possible way forward, could resolvePairInMemoryCoercible return a generalised type?