unconditional_recursion lint doesn't work with struct update syntax

[keiichiw]

Code

I tried this code which causes a stack overflow due to a recursive call of Default::default() I mistakenly added.

struct S {
    x: i32,
    y: i32,
}

fn f() -> i32 {
    42
}

impl Default for S {
    fn default() -> S {
        S {
            x: f(),
            ..Default::default() // cause stack overflow
        }
    }
}

fn main() {
    let _ = S::default();
}

I expected to see the unconditional_recursion warning. However, the compiler didn't complain it.

Version it worked on

It most recently worked on: 1.43.0 showed the warning. (ref. the compiler explorer)

Version with regression

The warning isn't shown on 1.44.0 or later, including the current stable 1.47.0.

[jonas-schievink]

I think this was caused by #70822, but it looks like expected behavior: If f diverges, the self-recursion never happens.

[jonas-schievink]

Though maybe the lint should assume that functions returning an inhabited type won't diverge (since otherwise they should be marked -> !). I can definitely see why people would write code like this, so linting on it makes sense.

[lcnr]

I personally feel that we should lint for functions if they don't return an uninhabited type.
Even if someone wants to exit recursion by unwinding I do feel that a lint is still appropriate here
as it is really bad style imo.

[keiichiw]

Thanks for the quick response. Yeah, it'd be natural to expect a function whose return type is not ! to return eventually.

Probably, we might want to have the following rules?:

1. Lint for self-recursion unless a function returning an uninhabited type is called in advance.
2. If a non-diverge function is called before a self-recursion, show a message like "if this f diverges, please annotate it." in addition to the unconditional_recursion warning.

1 would help my case and 2 would help the case of #54444. (2 is not necessary, though.)

[spastorino]

Assigning P-medium as discussed as part of the Prioritization Working Group procedure and removing I-prioritize.