The zig compiler never stops

[sdzx-1]

Zig Version

0.14.1

Steps to Reproduce and Observed Behavior

code

Steps to reproduce:

1. git clone -b bug https://github.com/sdzx-1/polystate-examples.git
2. cd polystate-examples
3. zig build

The compiler will never stop.

Expected Behavior

I would say the compiler is behaving correctly here, I have created an infinite recursive state and it has indeed looped infinitely.
A more detailed explanation

I'm curious, is there any way to set a maximum value for such a loop at the compiler level?

[AndrewKraevskii]

Multiple reductions all failing to compile with different errors. They mostly different in Witness function.

This one causes infinite linking:

pub fn main() !void {
    Example.Wit(Example.a).handler();
}
const E =
    union(enum) {
        Term: Example,
        Fun: struct { fun: Example, args: []const E },

        pub fn C(fun: Example, args: []const E) E {
            return .{ .Fun = .{ .fun = fun, .args = args } };
        }
    };

const Example = enum {
    exit,
    a,
    yes_or_no,

    pub fn Wit(val: anytype) type {
        const sdzx: E = blk: {
            if (@TypeOf(val) == Example) break :blk .{ .Term = val };
            const args_type_info = @typeInfo(@TypeOf(val));

            const fields = args_type_info.@"struct".fields;

            const tmp_args: [fields.len - 1]E = undefined;

            break :blk .{ .Fun = .{ .fun = undefined, .args = &tmp_args } };
        };
        return Witness(sdzx);
    }

    pub const aST = union(enum) {
        pub const handler = Example.Wit(.{
            Example.yes_or_no,
            Example.exit,
            Example.a,
        }).handler;
    };

    pub fn yes_or_noST(
        yes: E,
        no: E,
    ) fn () void {
        return Witness(E.C(
            Example.yes_or_no,
            &.{
                E.C(Example.yes_or_no, &.{ yes, no }),
                no,
            },
        )).handler;
    }
};

pub fn Witness(
    val: E,
) type {
    return struct {
        pub const CST = switch (val) {
            .Term => |_| Example.aST,
            .Fun => |fun_stru| struct {
                const handler = Example.yes_or_noST(fun_stru.args[0], fun_stru.args[1]);
            },
        };

        pub fn handler() void {
            return CST.handler();
        }
    };
}

And this one a little bit more reduced causes infinite semantic analizis but linking stops at some point:

pub fn main() !void {
    Example.Wit(Example.a).handler();
}
const E =
    union(enum) {
        Term: Example,
        Fun: struct { fun: Example, args: []const E },

        pub fn C(fun: Example, args: []const E) E {
            return .{ .Fun = .{ .fun = fun, .args = args } };
        }
    };

const Example = enum {
    exit,
    a,
    yes_or_no,

    pub fn Wit(val: anytype) type {
        const sdzx: E = blk: {
            if (@TypeOf(val) == Example) break :blk .{ .Term = val };
            const args_type_info = @typeInfo(@TypeOf(val));

            const fields = args_type_info.@"struct".fields;

            const tmp_args: [fields.len - 1]E = undefined;

            break :blk .{ .Fun = .{ .fun = undefined, .args = &tmp_args } };
        };
        return Witness(sdzx);
    }

    pub const aST = Example.Wit(.{
        Example.yes_or_no,
        Example.exit,
        Example.a,
    }).handler;

    pub fn yes_or_noST(
        yes: E,
        no: E,
    ) fn () void {
        return Witness(E.C(
            Example.yes_or_no,
            &.{
                E.C(Example.yes_or_no, &.{ yes, no }),
                no,
            },
        )).handler;
    }
};

pub fn Witness(
    val: E,
) type {
    return struct {
        pub fn handler() void {
            const CST = switch (val) {
                .Term => |_| Example.aST,
                .Fun => |fun_stru| Example.yes_or_noST(fun_stru.args[0], fun_stru.args[1]),
            };
            return CST.handler();
        }
    };
}

And even more reduced version just segfaults.

pub fn main() !void {
    Example.Wit(Example.a).handler();
}
const E =
    union(enum) {
        Term: Example,
        Fun: struct { fun: Example, args: []const E },

        pub fn C(fun: Example, args: []const E) E {
            return .{ .Fun = .{ .fun = fun, .args = args } };
        }
    };

const Example = enum {
    exit,
    a,
    yes_or_no,

    pub fn Wit(val: anytype) type {
        const sdzx: E = blk: {
            if (@TypeOf(val) == Example) break :blk .{ .Term = val };
            const args_type_info = @typeInfo(@TypeOf(val));

            const fields = args_type_info.@"struct".fields;

            const tmp_args: [fields.len - 1]E = undefined;

            break :blk .{ .Fun = .{ .fun = undefined, .args = &tmp_args } };
        };
        return Witness(sdzx);
    }

    pub const aST = Example.Wit(.{
        Example.yes_or_no,
        Example.exit,
        Example.a,
    }).handler;

    pub fn yes_or_noST(
        yes: E,
        no: E,
    ) fn () void {
        return Witness(E.C(
            Example.yes_or_no,
            &.{
                E.C(Example.yes_or_no, &.{ yes, no }),
                no,
            },
        )).handler;
    }
};

pub fn Witness(
    val: E,
) type {
    return struct {
        const handler = blk: {
            const CST = switch (val) {
                .Term => |_| Example.aST,
                .Fun => |fun_stru| Example.yes_or_noST(fun_stru.args[0], fun_stru.args[1]),
            };
            break :blk CST.handler;
        };
    };
}

Final reduce. This one correctly stops with "evaluation exceeded 1000 backwards branches error"

pub fn main() !void {
    Example.Wit(Example.a).handler();
}
const E =
    union(enum) {
        Term: Example,
        Fun: struct { fun: Example, args: []const E },

        pub fn C(fun: Example, args: []const E) E {
            return .{ .Fun = .{ .fun = fun, .args = args } };
        }
    };

const Example = enum {
    exit,
    a,
    yes_or_no,

    pub fn Wit(val: anytype) type {
        const sdzx: E = blk: {
            if (@TypeOf(val) == Example) break :blk .{ .Term = val };
            const args_type_info = @typeInfo(@TypeOf(val));

            const fields = args_type_info.@"struct".fields;

            const tmp_args: [fields.len - 1]E = undefined;

            break :blk .{ .Fun = .{ .fun = undefined, .args = &tmp_args } };
        };
        return Witness(sdzx);
    }

    pub const aST = Example.Wit(.{
        Example.yes_or_no,
        Example.exit,
        Example.a,
    }).handler;

    pub fn yes_or_noST(
        yes: E,
        no: E,
    ) fn () void {
        return Witness(E.C(
            Example.yes_or_no,
            &.{
                E.C(Example.yes_or_no, &.{ yes, no }),
                no,
            },
        )).handler;
    }
};

pub fn Witness(
    val: E,
) type {
    return switch (val) {
        .Term => |_| Example.aST,
        .Fun => |fun_stru| Example.yes_or_noST(fun_stru.args[0], fun_stru.args[1]),
    };
}

Why github formats foldable blocks so strangly? It leaves super big empty gap
Edit: oh gap only appeared in preview. When posted it vanished.