impl From<T> for U triggers infinite recursion via .into() — not detected by unconditional_recursion

Safe Rust code using impl From for String recursively calls .into() on a fresh E {} instance, leading to a stack overflow at runtime. The compiler does not emit a warning or lint, even though the recursion is unconditional and deterministic. This bypasses the compiler recursion check.

Example:

struct E;
impl E {
    fn new() -> Self {
        E {

        }
    }
}
impl From<E> for String {
    fn from(value: E) -> Self {
        E {}.into()
    }
}

fn main() {    
    let v = String::from(E {});
}

When i run this i get

thread 'main' (6844) has overflowed its stack

I suggest to Emit a warning when From calls .into() on a fresh T without branching.

Reproduce the Rust example and compare its behavior with the existing unconditional_recursion compiler check. Determine how From and .into() calls are analyzed, then define tests showing the warning is emitted for unconditional recursion without incorrectly flagging valid conversions; done means the regression is covered and the diagnostic behavior is agreed.