feat: Reject programs with unconditional recursion

[aakoshh]

Description

Problem*

Related to #4828
Followup to #6291

Summary*

Added a new ResolutionError::UnconditionalRecursion which should result in a warning or compilation error where the function body recurses into the defining function with no alternative way to return.

Additional Context

Documentation*

Check one:

• No documentation needed.
• Documentation included in this PR.
• [For Experimental Features] Documentation to be submitted in a separate PR.

PR Checklist*

• I have tested the changes locally.
• I have formatted the changes with Prettier and/or cargo fmt on default settings.

[asterite]

I wonder if this error should be produced on the SSA side instead of panicking when the "too much recursion" is detected. That way it would detect mutual recursion too.

[aakoshh]

You mean to change the return value into Result? I didn’t investigate the impact, or if it has any other panics that could be covered. There was another PR with a similar case where I changed the panic message and added some CLI side filtering, but didn’t want to cause too much churn by changing the entire call stack.

I’ll defer to @TomAFrench

[aakoshh]

Ah, you mean that instead of a warning, we could rely purely on the SSA.

I did it this way so it can be a warning during compilation, like the unused variables. Rust has this warning too, so why not? I didn't implement mutual recursion because Rust doesn't seem to have it either, but in theory I think we could: if we detect a cycle where none of the code paths can return without calling any of the FuncId we collected along the way, then it could reject that case too.

[TomAFrench]

It seems like we're going to end up with false positives so we may want to soften this warning to "potential unconditional recursion" if we're not going to track down all of these?

[aakoshh]

We may want to soften this warning to "potential unconditional recursion".

I agree that we can tweak the error message. For the record Rust says:

function cannot return without recursing
a `loop` may express intention better if this is on purpose
`#[warn(unconditional_recursion)]` on by default

That hint about the loop is indicative why mutual recursion isn't covered for example. Basically anything where the shape looks like we might not end up recursing disables this warning.