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

warning: function cannot return without recursing
  --> $DIR/issue-83150.rs:11:1
   |
LL | fn func<T: Iterator<Item = u8>>(iter: &mut T) {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
LL |     func(&mut iter.map(|x| x + 1))
   |     ------------------------------ recursive call site
   |
   = help: a `loop` may express intention better if this is on purpose
   = note: `#[warn(unconditional_recursion)]` on by default

error[E0275]: overflow evaluating the requirement `Map<&mut Map<&mut Map<&mut Map<..., ...>, ...>, ...>, ...>: Iterator`
   |
   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`issue_83150`)
   = note: required for `&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<..., ...>, ...>, ...>, ...>, ...>, ...>, ...>` to implement `Iterator`
   = note: the full type name has been written to '$TEST_BUILD_DIR/recursion/issue-83150/issue-83150.long-type-hash.txt'

error: aborting due to previous error; 1 warning emitted

For more information about this error, try `rustc --explain E0275`.
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-13 18:00:00 -06:00			`warning: function cannot return without recursing`
On overflow errors, do not print out long types 2022-11-16 21:09:57 -06:00			`--> $DIR/issue-83150.rs:11:1`
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-13 18:00:00 -06:00			`\|`
			`LL \| fn func<T: Iterator<Item = u8>>(iter: &mut T) {`
			`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing`
			`LL \| func(&mut iter.map(\|x\| x + 1))`
			`\| ------------------------------ recursive call site`
			`\|`
			= help: a `loop` may express intention better if this is on purpose
bless ui tests 2022-09-18 10:55:36 -05:00			= note: `#[warn(unconditional_recursion)]` on by default
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-13 18:00:00 -06:00
revert-overflow 2022-11-19 13:43:12 -06:00			error[E0275]: overflow evaluating the requirement `Map<&mut Map<&mut Map<&mut Map<..., ...>, ...>, ...>, ...>: Iterator`
prevent very long compilation runtimes in LateBoundRegionNameCollector 2021-03-23 06:41:26 -05:00			`\|`
Specialize a few tests depending on opt-level. 2022-05-17 09:18:40 -05:00			= help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`issue_83150`)
Further tweak the type shortening logic 2022-11-25 21:08:46 -06:00			= note: required for `&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<..., ...>, ...>, ...>, ...>, ...>, ...>, ...>` to implement `Iterator`
On overflow errors, do not print out long types 2022-11-16 21:09:57 -06:00			`= note: the full type name has been written to '$TEST_BUILD_DIR/recursion/issue-83150/issue-83150.long-type-hash.txt'`
prevent very long compilation runtimes in LateBoundRegionNameCollector 2021-03-23 06:41:26 -05:00
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-13 18:00:00 -06:00			`error: aborting due to previous error; 1 warning emitted`
prevent very long compilation runtimes in LateBoundRegionNameCollector 2021-03-23 06:41:26 -05:00
Specialize a few tests depending on opt-level. 2022-05-17 09:18:40 -05:00			For more information about this error, try `rustc --explain E0275`.