rust/tests/ui/recursion/issue-83150.rs

// build-fail
// compile-flags: -Copt-level=0
// normalize-stderr-test: "long-type-\d+" -> "long-type-hash"
//~^^^ ERROR overflow evaluating the requirement

fn main() {
    let mut iter = 0u8..1;
    func(&mut iter)
}

fn func<T: Iterator<Item = u8>>(iter: &mut T) { //~ WARN function cannot return without recursing
    func(&mut iter.map(|x| x + 1))
}
prevent very long compilation runtimes in LateBoundRegionNameCollector 2021-03-23 12:41:26 +01:00			`// build-fail`
Specialize a few tests depending on opt-level. 2022-05-17 16:18:40 +02:00			`// compile-flags: -Copt-level=0`
On overflow errors, do not print out long types 2022-11-16 19:09:57 -08:00			`// normalize-stderr-test: "long-type-\d+" -> "long-type-hash"`
			`//~^^^ ERROR overflow evaluating the requirement`
prevent very long compilation runtimes in LateBoundRegionNameCollector 2021-03-23 12:41:26 +01:00
			`fn main() {`
			`let mut iter = 0u8..1;`
			`func(&mut iter)`
			`}`

Ignore unwinding edges when checking for unconditional recursion The unconditional recursion lint determines if all execution paths eventually lead to a self-recursive call. The implementation always follows unwinding edges which limits its practical utility. For example, it would not lint function `f` because a call to `g` might unwind. It also wouldn't lint function `h` because an overflow check preceding the self-recursive call might unwind: ```rust pub fn f() { g(); f(); } pub fn g() { /* ... */ } pub fn h(a: usize) { h(a + 1); } ``` To avoid the issue, assume that terminators that might continue execution along non-unwinding edges do so. 2022-01-14 00:00:00 +00:00			`fn func<T: Iterator<Item = u8>>(iter: &mut T) { //~ WARN function cannot return without recursing`
prevent very long compilation runtimes in LateBoundRegionNameCollector 2021-03-23 12:41:26 +01:00			`func(&mut iter.map(\|x\| x + 1))`
			`}`