Support inferred error sets in recursion

[hryx]

This is a proposal based on the question raised in #763. (If #763 is considered the tracking issue or the final word, please feel free to close this one -- I didn't interpret any of the comments there as conclusive.)

Thanks @rjtobin for resurfacing the issue in IRC.

Summary

If a call graph is recursive, a return type with inferred error set may trigger this compile error:

cannot resolve inferred error set 'glarf': function 'kloyp' not fully analyzed yet

If all functions in that cycle use inferred error sets, the error is guaranteed to happen.

pub fn main() void {
    f1(false) catch {};
}

fn f1(x: bool) !void { // recurses
    return if (x) error.Bad else f1(x);
}

fn f2(x: bool) !void { // recurses
    return if (x) f2(x) else error.Bad;
}

If at least one of the functions in the cycle has an inferred error set, the error may happen. Given this error set:

const E = error{Bad};

Changing f1 to return E!void prevents the error. Leaving f1 alone and instead changing f2 to return E!void does not prevent the error. The outcome may be deterministic or it may be based on the color of the giant spaghetti monster's mood ring, I dunno.

Proposal

Guarantee that inferred error sets are allowed even in cyclic call graphs.

Alternatives

Explicitly state that recursion is incompatible with inferred error sets. "Wait!" I hear you cry, "the documentation already says exactly that". It sure does, but it is also acknowledges that this limitation may be removed in the future. We just need to decide (eventually) whether to add support or officially make it unsupported for the language specification (#75).

Note: Currently, I am neutral on this enhancement. It's not blocking me. This issue is just meant to track it and aggregate potential use cases.

[andrewrk]

This is implemented and working in self-hosted, only thing left to close the issue is ensure we have behavior test coverage.

[mlugg]

Note that this works for plain recursion, but not mutual recursion:

fn f() !void {
    try g(false);
}

fn g(b: bool) !void {
    if (b) {
        try f();
    } else {
        return error.Foo;
    }
}

comptime {
    _ = f; // or g
}

thing.zig:7:14: error: unable to resolve inferred error set
        try f();
            ~^~