Compiler Explorer

Source code

const std = @import("std");

fn newIntToEnum(
    comptime EnumTag: type,
    tag_int: anytype,
) std.meta.IntToEnumError!EnumTag {
    const enum_info = @typeInfo(EnumTag).Enum;

if (!enum_info.is_exhaustive) {
        if (std.math.cast(enum_info.tag_type, tag_int)) |tag| {
            return @as(EnumTag, @enumFromInt(tag));
        }
        return error.InvalidEnumTag;
    }

if (comptime enum_info.tag_type == comptime_int) {
        inline for (enum_info.fields) |f| {
            const this_tag_value = @field(EnumTag, f.name);
            if (tag_int == @intFromEnum(this_tag_value)) {
                return this_tag_value;
            }
            return error.InvalidEnumTag;
        }
    }

// We don't directly iterate over the fields of EnumTag, as that
    // would require an inline loop. Instead, we create an array of
    // values that is comptime-known, but can be iterated at runtime
    // without requiring an inline loop. This generates better machine
    // code.
    const values = comptime blk: {
        var result: [enum_info.fields.len]enum_info.tag_type = undefined;
        for (&result, enum_info.fields) |*dst, src| {
            dst.* = src.value;
        }
        break :blk result;
    };

for (values) |v| {
        if (tag_int == v) return @enumFromInt(tag_int);
    }

return error.InvalidEnumTag;
}

const Contiguous = enum(u8) {
    a = 0,
    b,
    c,
    d,
    e,
    f,
    g,
};

const NonContiguous = enum(u8) {
    a = 1,
    b = 100,
    c = 255,
    d = 120,
    e = 50,
    f = 35,
    g = 2,
};

pub fn main() !void {
    // Random value to prevent the compiler from being smart.
    const rawValue = std.process.argsAlloc(std.heap.page_allocator) catch unreachable;
    const value = rawValue[0][2];

std.mem.doNotOptimizeAway(
        try @call(.never_inline, newIntToEnum, .{
            Contiguous,
            value,
        }),
    );
    std.mem.doNotOptimizeAway(
        try @call(.never_inline, std.meta.intToEnum, .{
            Contiguous,
            value,
        }),
    );
    std.mem.doNotOptimizeAway(
        try @call(.never_inline, newIntToEnum, .{
            NonContiguous,
            value,
        }),
    );
    std.mem.doNotOptimizeAway(
        try @call(.never_inline, std.meta.intToEnum, .{
            NonContiguous,
            value,
        }),
    );
}