Inline loop over functions where one returns empty error set gives compiler error

[Hejsil]

I would expect this to work, but it doesn't.

const T1 = struct {
    pub fn v() error{}!usize {
        return usize(0);
    }
};

const T2 = struct {
    pub fn v() error{Error}!usize {
        return usize(1);
    }
};

test "" {
    const ts = []type{
        T1,
        T2,
    };
    inline for (ts) |T|
        _ = try T.v();
}

test.zig:19:13: error: control flow attempts to use compile-time variable at runtime
        _ = try T.v();
            ^
test.zig:18:12: note: compile-time variable assigned here
    inline for (ts) |T|

[Hejsil]

Flipping the order of T1 and T2 in ts makes the code work.

[jeffkdev]

I'll add another test case for this one. Looks like there are a few different open bugs for this error, but this issue seems to be the most similar. Running zig test on the below code I get:
error: control flow attempts to use compile-time variable at runtime try serialize(@field(value, fieldType.name), output);

I found that removing the bool type in Vec3 so all code paths for the inline-for loop will have the same error type will let it compile. Also specifying the error set manually will workaround the issue as well.

const std = @import("std");
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;

// Workaround #1: Change return type to specific error set
//pub fn serialize(value: var, output: *ArrayList(u8)) error{OutOfMemory}!void {
pub fn serialize(value: var, output: *ArrayList(u8)) !void {
    switch (@typeInfo(@TypeOf(value))) {
        .Int, .Float,  => {
            try output.appendSlice(std.mem.asBytes(&value).*[0..]);
        },
        .Struct => {
            const T = @TypeOf(value);
            inline for (@typeInfo(T).Struct.fields) |fieldType| {
                // Workaround #2:  instead of 'try' handle error
                // serialize(@field(value, fieldType.name), output) catch unreachable;
                try serialize(@field(value, fieldType.name), output);
            }        
        },
        .Bool => { },
        else => @compileError("Unable to serialize type'" ++ @typeName(@TypeOf(value)) ++ "'"),
    }
}

test "Test" {
    const alloactor = std.testing.allocator;
    const Vec2 = struct {
        x: i32,
        y: i32,
    };
    const Vec3 = struct {
        // Workaround #3: remove bool type (comment out line)
        some_bool: bool = false,
        x: i32,
        y: i32,
        z: i32,
    };

    const vec2 = Vec2{.x=1, .y=2};
    const vec3 = Vec3{.x=1, .y=2,.z=3};
    var buffer1 = ArrayList(u8).init(alloactor);
    defer buffer1.deinit();

    var buffer2 = ArrayList(u8).init(alloactor);
    defer buffer2.deinit();

    try serialize(vec2, &buffer1);
    try serialize(vec3, &buffer2);

    std.testing.expectEqualSlices(u8, buffer1.items, buffer2.items[0..8]);
}