add a compile error for using @bitCast to convert an enum to an integer

[andrewrk]

const std = @import("std");

const Number = enum(u32) {
    one,
    two,
};

test "passes but should be a compile error" {
    const x: Number = .one;
    const y = @bitCast(u32, x);
}

The proper cast is @enumToInt:

const std = @import("std");

const Number = enum(u32) {
    one,
    two,
};

test "enum to int" {
    const x: Number = .one;
    const y = @enumToInt(x);
}

[SpexGuy]

const Foo = enum(u32) { A, B, C };
const Wrapped = struct { val: Foo };
const a = Foo.A;
const wrappedA = Wrapped{ .val = a };
const compiles = @bitCast(u32, wrappedA);
const fails = @bitCast(u32, a);

This seems like a totally arbitrary compile failure. A rule like this can cause unnecessary complexity in generic code. I don't really see a good reason why @bitCast shouldn't be defined in this case.

[daurnimator]

I don't really see a good reason why @bitCast shouldn't be defined in this case.

Struct layout for non extern structs is not defined: for certain debug features or other purposes in the future, the struct may have hidden members.

[SpexGuy]

That's a good point, but the struct cast is the one that compiles. This issue would make the enum cast invalid. On a related note though, does that mean this is UB?

comptime assert(@sizeOf(Wrapped) == @sizeOf(u32));
const a = Wrapped { .val = .A };
const b = @bitCast(u32, a);
const c = @bitCast(Wrapped, b);
const d = c.val; // undefined?

[SpexGuy]

Wait a minute... Struct layout is not guaranteed to be in any consistent order, but it must be defined. Otherwise @offsetOf would be UB.

[SpexGuy]

Ah, nevermind. I misunderstood the intent of bitCast. Sorry for the fuss.

[eriksik2]

This would force any generic function dealing with bit casts to add a special case for enums. If anything I think @enumToInt(...) should be removed in favor of the more general @bitCast(@tagType(...), ...), instead of forcing a special case.

[tadeokondrak]

Does this conflict with #1467?

[WoodyAtHome]

If I access microcontroller peripheral I use packed structs with enums inside for register access. E.g. STM32:

const EPxR = packed struct {
    const Stat = enum(u2) {
        disabled = 0, stall = 1, nak = 2, valid = 3
    };
    const EpType = enum(u2) {
        bulk = 0, control = 1, iso = 2, interrupt = 3
    };

    EA: u4 = 0,
    STAT_TX: Stat = Stat.disabled,
    DTOG_TX: bool = false,
    CTR_TX: bool = false,
    EP_KIND: bool = false,
    EP_TYPE: EpType = EpType.bulk,
    SETUP: bool = false,
    STAT_RX: Stat = Stat.disabled,
    DTOG_RX: bool = false,
    CTR_RX: bool = false,

    pub fn toInt(self: @This()) u16 {
        return @bitCast(u16, self);
    }
};

How can I do this without enums if bitCast doesn't work? I agree with @eriksik2: It is better to drop enumToInt and always use bitCast.

[alichraghi]

Compile error has been implemented

test.zig:10:23: error: cannot @bitCast from 'z.Number'
    _ = @bitCast(u32, x);
                      ^
test.zig:10:23: note: use @enumToInt to cast to 'u32'

[Vexu]

There's even a test.