design flaw with equality comparison of tagged unions

[shawnl]

see #2251 (comment)

---

This is currently breaking the tests on Arm64 because builtin.arch is a union(enum) and the tests try to do an equality comparison on it.

/home/shawn/build-refs/heads/builtins/test/tests.zig:171:78: error: operator not allowed for type 'builtin.Arch'
        const is_native = (test_target.os == builtin.os and test_target.arch == builtin.arch);
                                                                             ^

It is slightly weird to do a comparison on a union as it would always bit a bit-wise comparison, and not a float comparison.

Perhaps there is another way to fix this.

[tiehuis]

You can compare tags of union(enum) by using @enumToInt.

const Foo = union(enum) {
    A: usize,
    B: []const u8,
    C,
};

test "example" {
    var a = Foo{ .A = 0 };
    var b = Foo{ .B = "here" };

    @import("std").debug.assert(@enumToInt(a) != @enumToInt(b));
}

[andrewrk]

This is tested and working in master branch now.

[andrewrk]

Apologies - spoke too soon. Not sure what I was thinking of here.

[andrewrk]

Anyway aarch64 has test coverage in the CI now; this is a different issue. I'll retitle it.

const std = @import("std");
const builtin = @import("builtin");

test "" {
    var arch: builtin.Arch = undefined;
    var os: builtin.Os = undefined;
    const is_native = (os == builtin.os and arch == builtin.arch);
    std.debug.warn("is_native = {}\n", is_native);
}

The issue is that it's weird that this test passes for -target x86_64-linux but it fails for -target aarch64-linux:

[nix-shell:~/Downloads/zig/build]$ ./zig test test.zig 
1/1 test "oaeu"...is_native = false
OK
All tests passed.

[nix-shell:~/Downloads/zig/build]$ ./zig test test.zig -target aarch64v8-linux
/home/andy/Downloads/zig/build/test.zig:7:50: error: operator not allowed for type 'builtin.Arch'
    const is_native = (os == builtin.os and arch == builtin.arch);
                                                 ^

I think this is a flaw in the language.

[shawnl]

(not relevant, see below)

[andrewrk]

That's #3330

[shawnl]

x86_64 actually has three abis when it comes to vectors: sse2 (128-bit), avx2 (256-bit), and avx512f (512-bit): %xmm, %ymm, %zmm, and I'd like to extend the ABI enum so that we can forbid exporting vector widths that the current ABI can't handle.

[ghost]

This example posted by Andrew no longer works:

const std = @import("std");
const builtin = @import("builtin");

test "" {
    var arch: builtin.Arch = undefined;
    var os: builtin.Os = undefined;
    const is_native = (os == builtin.os and arch == builtin.arch);
    std.debug.warn("is_native = {}\n", is_native);
}

First an error saying that the test can't have an empty name, then an error saying that builtin.Arch doesn't exist

But I'm wondering about the ability to compare tagged unions in general, because this example seems to show that in the past you could compare tagged unions, but now you can't?

const U = union(enum) {
    a: u8,
    b: i8,
};
pub fn main() void {
    const a = U{ .a = 4 };
    const b = U{ .b = -4 };
    _ = a == b;
}

This fails for me with operator == not allowed for type U.

Was the ability to compare tagged unions removed? If so, why?!?

[nurpax]

It would really be useful to be able to compare tagged unions. For example, I worked around this limitation just now with code like this:

pub const RenderModeTag = enum(u32) { image, constant };
pub const RenderMode = union(RenderModeTag) {
    image: struct { image_id: u32 },
    constant: u32,

    pub fn eq(a: RenderMode, b: RenderMode) bool {
        if (a == .image and b == .image) {
            return a.image.image_id == b.image.image_id;
        } else if (a == .constant and b == .constant) {
            return a.constant == b.constant;
        }
        return false;
    }
};

[kcbanner]

std.meta.eql might work for that case - it compares first the tag, then recurses to compare the values if the tag was equal.

[ghost]

So what is the status of this issue? If not being able to compare tagged unions is intended (it shouldn't be), what's the bug?

[Vexu]

Looking at 0.4.0 codegen.cpp builtin.arch used to be defined as Arch.%s for arches with no subarches and as Arch{ .%s = Arch.%s.%s } for ones with subarches. As a result test_target.arch == builtin.arch worked for x86_64 but not arm since builtin.arch was an enum for x86_64 and a union on arm:

const U = union(enum) {
    a: u8,
    b,
};
const b = U.b; // for x86_64
const b = U{ .b =  {} }; // for arm
pub fn main() void {
    var a = U{ .a = 4 };
    _ = a == b;
}