10 files changed, 439 insertions, 64 deletions

diff --git a/tests/ui/coercion/coerce-loop-issue-122561.rs b/tests/ui/coercion/coerce-loop-issue-122561.rs
new file mode 100644
index 00000000000..e08884ad6a4
--- /dev/null
+++ b/tests/ui/coercion/coerce-loop-issue-122561.rs
@@ -0,0 +1,110 @@
+// Regression test for #122561
+
+fn for_infinite() -> bool {
+    for i in 0.. {
+    //~^ ERROR mismatched types
+        return false;
+    }
+}
+
+fn for_finite() -> String {
+    for i in 0..5 {
+    //~^ ERROR mismatched types
+        return String::from("test");
+    }
+}
+
+fn for_zero_times() -> bool {
+    for i in 0..0 {
+    //~^ ERROR mismatched types
+        return true;
+    }
+}
+
+fn for_never_type() -> ! {
+    for i in 0..5 {
+    //~^ ERROR mismatched types
+    }
+}
+
+// Entire function on a single line.
+// Tests that we format the suggestion
+// correctly in this case
+fn for_single_line() -> bool { for i in 0.. { return false; } }
+//~^ ERROR mismatched types
+
+// Loop in an anon const in function args
+// Tests that we:
+// a. deal properly with this complex case
+// b. format the suggestion correctly so
+//    that it's readable
+fn for_in_arg(a: &[(); for x in 0..2 {}]) -> bool {
+//~^ ERROR `for` is not allowed in a `const`
+//~| ERROR mismatched types
+    true
+}
+
+fn while_inifinite() -> bool {
+    while true {
+    //~^ ERROR mismatched types
+    //~| WARN denote infinite loops with `loop { ... }` [while_true]
+        return true;
+    }
+}
+
+fn while_finite() -> bool {
+    let mut i = 0;
+    while i < 3 {
+    //~^ ERROR mismatched types
+        i += 1;
+        return true;
+    }
+}
+
+fn while_zero_times() -> bool {
+    while false {
+    //~^ ERROR mismatched types
+        return true;
+    }
+}
+
+fn while_never_type() -> ! {
+    while true {
+    //~^ ERROR mismatched types
+    //~| WARN denote infinite loops with `loop { ... }` [while_true]
+    }
+}
+
+// No type mismatch error in this case
+fn loop_() -> bool {
+    loop {
+        return true;
+    }
+}
+
+const C: i32 = {
+    for i in 0.. {
+    //~^ ERROR `for` is not allowed in a `const`
+    //~| ERROR mismatched types
+    }
+};
+
+fn main() {
+    let _ = [10; {
+        for i in 0..5 {
+        //~^ ERROR `for` is not allowed in a `const`
+        //~| ERROR mismatched types
+        }
+    }];
+
+    let _ = [10; {
+        while false {
+        //~^ ERROR mismatched types
+        }
+    }];
+
+
+    let _ = |a: &[(); for x in 0..2 {}]| {};
+    //~^ ERROR `for` is not allowed in a `const`
+    //~| ERROR mismatched types
+}
diff --git a/tests/ui/coercion/coerce-loop-issue-122561.stderr b/tests/ui/coercion/coerce-loop-issue-122561.stderr
new file mode 100644
index 00000000000..0f77fd1364d
--- /dev/null
+++ b/tests/ui/coercion/coerce-loop-issue-122561.stderr
@@ -0,0 +1,299 @@
+warning: denote infinite loops with `loop { ... }`
+  --> $DIR/coerce-loop-issue-122561.rs:48:5
+   |
+LL |     while true {
+   |     ^^^^^^^^^^ help: use `loop`
+   |
+   = note: `#[warn(while_true)]` on by default
+
+warning: denote infinite loops with `loop { ... }`
+  --> $DIR/coerce-loop-issue-122561.rs:72:5
+   |
+LL |     while true {
+   |     ^^^^^^^^^^ help: use `loop`
+
+error[E0658]: `for` is not allowed in a `const`
+  --> $DIR/coerce-loop-issue-122561.rs:41:24
+   |
+LL | fn for_in_arg(a: &[(); for x in 0..2 {}]) -> bool {
+   |                        ^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #87575 <https://github.com/rust-lang/rust/issues/87575> for more information
+   = help: add `#![feature(const_for)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `for` is not allowed in a `const`
+  --> $DIR/coerce-loop-issue-122561.rs:86:5
+   |
+LL | /     for i in 0.. {
+LL | |
+LL | |
+LL | |     }
+   | |_____^
+   |
+   = note: see issue #87575 <https://github.com/rust-lang/rust/issues/87575> for more information
+   = help: add `#![feature(const_for)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `for` is not allowed in a `const`
+  --> $DIR/coerce-loop-issue-122561.rs:94:9
+   |
+LL | /         for i in 0..5 {
+LL | |
+LL | |
+LL | |         }
+   | |_________^
+   |
+   = note: see issue #87575 <https://github.com/rust-lang/rust/issues/87575> for more information
+   = help: add `#![feature(const_for)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `for` is not allowed in a `const`
+  --> $DIR/coerce-loop-issue-122561.rs:107:23
+   |
+LL |     let _ = |a: &[(); for x in 0..2 {}]| {};
+   |                       ^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #87575 <https://github.com/rust-lang/rust/issues/87575> for more information
+   = help: add `#![feature(const_for)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:41:24
+   |
+LL | fn for_in_arg(a: &[(); for x in 0..2 {}]) -> bool {
+   |                        ^^^^^^^^^^^^^^^^ expected `usize`, found `()`
+   |
+   = note: `for` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL | fn for_in_arg(a: &[(); for x in 0..2 {} /* `usize` value */]) -> bool {
+   |                                         +++++++++++++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:86:5
+   |
+LL | /     for i in 0.. {
+LL | |
+LL | |
+LL | |     }
+   | |_____^ expected `i32`, found `()`
+   |
+   = note: `for` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL ~     }
+LL +     /* `i32` value */
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:4:5
+   |
+LL |   fn for_infinite() -> bool {
+   |                        ---- expected `bool` because of return type
+LL | /     for i in 0.. {
+LL | |
+LL | |         return false;
+LL | |     }
+   | |_____^ expected `bool`, found `()`
+   |
+   = note: `for` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL ~     }
+LL +     /* `bool` value */
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:11:5
+   |
+LL |   fn for_finite() -> String {
+   |                      ------ expected `String` because of return type
+LL | /     for i in 0..5 {
+LL | |
+LL | |         return String::from("test");
+LL | |     }
+   | |_____^ expected `String`, found `()`
+   |
+   = note: `for` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL ~     }
+LL +     /* `String` value */
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:18:5
+   |
+LL |   fn for_zero_times() -> bool {
+   |                          ---- expected `bool` because of return type
+LL | /     for i in 0..0 {
+LL | |
+LL | |         return true;
+LL | |     }
+   | |_____^ expected `bool`, found `()`
+   |
+   = note: `for` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL ~     }
+LL +     /* `bool` value */
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:25:5
+   |
+LL |   fn for_never_type() -> ! {
+   |                          - expected `!` because of return type
+LL | /     for i in 0..5 {
+LL | |
+LL | |     }
+   | |_____^ expected `!`, found `()`
+   |
+   = note:   expected type `!`
+           found unit type `()`
+   = note: `for` loops evaluate to unit type `()`
+help: consider adding a diverging expression here
+   |
+LL ~     }
+LL +     /* `loop {}` or `panic!("...")` */
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:33:32
+   |
+LL | fn for_single_line() -> bool { for i in 0.. { return false; } }
+   |                         ----   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`
+   |                         |
+   |                         expected `bool` because of return type
+   |
+   = note: `for` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL | fn for_single_line() -> bool { for i in 0.. { return false; } /* `bool` value */ }
+   |                                                               ++++++++++++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:48:5
+   |
+LL |   fn while_inifinite() -> bool {
+   |                           ---- expected `bool` because of return type
+LL | /     while true {
+LL | |
+LL | |
+LL | |         return true;
+LL | |     }
+   | |_____^ expected `bool`, found `()`
+   |
+   = note: `while` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL ~     }
+LL +     /* `bool` value */
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:57:5
+   |
+LL |   fn while_finite() -> bool {
+   |                        ---- expected `bool` because of return type
+LL |       let mut i = 0;
+LL | /     while i < 3 {
+LL | |
+LL | |         i += 1;
+LL | |         return true;
+LL | |     }
+   | |_____^ expected `bool`, found `()`
+   |
+   = note: `while` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL ~     }
+LL +     /* `bool` value */
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:65:5
+   |
+LL |   fn while_zero_times() -> bool {
+   |                            ---- expected `bool` because of return type
+LL | /     while false {
+LL | |
+LL | |         return true;
+LL | |     }
+   | |_____^ expected `bool`, found `()`
+   |
+   = note: `while` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL ~     }
+LL +     /* `bool` value */
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:72:5
+   |
+LL |   fn while_never_type() -> ! {
+   |                            - expected `!` because of return type
+LL | /     while true {
+LL | |
+LL | |
+LL | |     }
+   | |_____^ expected `!`, found `()`
+   |
+   = note:   expected type `!`
+           found unit type `()`
+   = note: `while` loops evaluate to unit type `()`
+help: consider adding a diverging expression here
+   |
+LL ~     }
+LL +     /* `loop {}` or `panic!("...")` */
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:94:9
+   |
+LL | /         for i in 0..5 {
+LL | |
+LL | |
+LL | |         }
+   | |_________^ expected `usize`, found `()`
+   |
+   = note: `for` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL ~         }
+LL +         /* `usize` value */
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:101:9
+   |
+LL | /         while false {
+LL | |
+LL | |         }
+   | |_________^ expected `usize`, found `()`
+   |
+   = note: `while` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL ~         }
+LL +         /* `usize` value */
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/coerce-loop-issue-122561.rs:107:23
+   |
+LL |     let _ = |a: &[(); for x in 0..2 {}]| {};
+   |                       ^^^^^^^^^^^^^^^^ expected `usize`, found `()`
+   |
+   = note: `for` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL |     let _ = |a: &[(); for x in 0..2 {} /* `usize` value */]| {};
+   |                                        +++++++++++++++++++
+
+error: aborting due to 18 previous errors; 2 warnings emitted
+
+Some errors have detailed explanations: E0308, E0658.
+For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/did_you_mean/compatible-variants.stderr b/tests/ui/did_you_mean/compatible-variants.stderr
index f2bbd8ced8f..2c75537ca19 100644
--- a/tests/ui/did_you_mean/compatible-variants.stderr
+++ b/tests/ui/did_you_mean/compatible-variants.stderr
@@ -11,6 +11,7 @@ LL | |     }
    |
    = note:   expected enum `Option<()>`
            found unit type `()`
+   = note: `while` loops evaluate to unit type `()`
 help: try adding an expression at the end of the block
    |
 LL ~     }
@@ -49,6 +50,7 @@ LL | |     }
    |
    = note:   expected enum `Option<()>`
            found unit type `()`
+   = note: `for` loops evaluate to unit type `()`
 help: try adding an expression at the end of the block
    |
 LL ~     }
@@ -106,6 +108,7 @@ LL |         while false {}
    |
    = note:   expected enum `Option<()>`
            found unit type `()`
+   = note: `while` loops evaluate to unit type `()`
 help: try adding an expression at the end of the block
    |
 LL ~         while false {}
diff --git a/tests/ui/for-loop-while/break-while-condition.stderr b/tests/ui/for-loop-while/break-while-condition.stderr
index 48b29f44fa1..07a57424575 100644
--- a/tests/ui/for-loop-while/break-while-condition.stderr
+++ b/tests/ui/for-loop-while/break-while-condition.stderr
@@ -20,6 +20,12 @@ LL | |             }
    |
    = note:   expected type `!`
            found unit type `()`
+   = note: `while` loops evaluate to unit type `()`
+help: consider adding a diverging expression here
+   |
+LL ~             }
+LL +             /* `loop {}` or `panic!("...")` */
+   |
 
 error[E0308]: mismatched types
   --> $DIR/break-while-condition.rs:24:13
@@ -31,14 +37,12 @@ LL | |             }
    |
    = note:   expected type `!`
            found unit type `()`
-note: the function expects a value to always be returned, but loops might run zero times
-  --> $DIR/break-while-condition.rs:24:13
+   = note: `while` loops evaluate to unit type `()`
+help: consider adding a diverging expression here
+   |
+LL ~             }
+LL +             /* `loop {}` or `panic!("...")` */
    |
-LL |             while false {
-   |             ^^^^^^^^^^^ this might have zero elements to iterate on
-LL |                 return
-   |                 ------ if the loop doesn't execute, this value would never get returned
-   = help: return a value for the case when the loop has zero elements to iterate on, otherwise consider changing the return type to account for that possibility
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/issues/issue-27042.stderr b/tests/ui/issues/issue-27042.stderr
index ba39399e46e..6586e61f2f6 100644
--- a/tests/ui/issues/issue-27042.stderr
+++ b/tests/ui/issues/issue-27042.stderr
@@ -40,6 +40,8 @@ error[E0308]: mismatched types
 LL | /         'c:
 LL | |         for _ in None { break }; // but here we cite the whole loop
    | |_______________________________^ expected `i32`, found `()`
+   |
+   = note: `for` loops evaluate to unit type `()`
 
 error[E0308]: mismatched types
   --> $DIR/issue-27042.rs:15:9
diff --git a/tests/ui/issues/issue-50585.stderr b/tests/ui/issues/issue-50585.stderr
index 13181f1cf7f..e7f13e63475 100644
--- a/tests/ui/issues/issue-50585.stderr
+++ b/tests/ui/issues/issue-50585.stderr
@@ -13,6 +13,12 @@ error[E0308]: mismatched types
    |
 LL |     |y: Vec<[(); for x in 0..2 {}]>| {};
    |                  ^^^^^^^^^^^^^^^^ expected `usize`, found `()`
+   |
+   = note: `for` loops evaluate to unit type `()`
+help: consider returning a value here
+   |
+LL |     |y: Vec<[(); for x in 0..2 {} /* `usize` value */]>| {};
+   |                                   +++++++++++++++++++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/typeck/issue-100285.rs b/tests/ui/typeck/issue-100285.rs
index 460e0457105..bea4b2bc2bb 100644
--- a/tests/ui/typeck/issue-100285.rs
+++ b/tests/ui/typeck/issue-100285.rs
@@ -1,4 +1,4 @@
-fn foo(n: i32) -> i32 { //~ HELP otherwise consider changing the return type to account for that possibility
+fn foo(n: i32) -> i32 {
     for i in 0..0 { //~ ERROR mismatched types [E0308]
        if n < 0 {
         return i;
@@ -14,7 +14,7 @@ fn foo(n: i32) -> i32 { //~ HELP otherwise consider changing the return type to
           return 5;
         }
 
-    } //~ HELP return a value for the case when the loop has zero elements to iterate on
+    } //~ HELP consider returning a value here
 }
 
 fn main() {}
diff --git a/tests/ui/typeck/issue-100285.stderr b/tests/ui/typeck/issue-100285.stderr
index c0deb63af59..6f86fd18e0f 100644
--- a/tests/ui/typeck/issue-100285.stderr
+++ b/tests/ui/typeck/issue-100285.stderr
@@ -12,47 +12,12 @@ LL | |
 LL | |     }
    | |_____^ expected `i32`, found `()`
    |
-note: the function expects a value to always be returned, but loops might run zero times
-  --> $DIR/issue-100285.rs:2:5
-   |
-LL |     for i in 0..0 {
-   |     ^^^^^^^^^^^^^ this might have zero elements to iterate on
-LL |        if n < 0 {
-LL |         return i;
-   |         -------- if the loop doesn't execute, this value would never get returned
-LL |         } else if n < 10 {
-LL |           return 1;
-   |           -------- if the loop doesn't execute, this value would never get returned
-LL |         } else if n < 20 {
-LL |           return 2;
-   |           -------- if the loop doesn't execute, this value would never get returned
-   = note: if the loop doesn't execute, 3 other values would never get returned
-help: return a value for the case when the loop has zero elements to iterate on
+   = note: `for` loops evaluate to unit type `()`
+help: consider returning a value here
    |
 LL ~     }
 LL ~     /* `i32` value */
    |
-help: otherwise consider changing the return type to account for that possibility
-   |
-LL ~ fn foo(n: i32) -> Option<i32> {
-LL |     for i in 0..0 {
-LL |        if n < 0 {
-LL ~         return Some(i);
-LL |         } else if n < 10 {
-LL ~           return Some(1);
-LL |         } else if n < 20 {
-LL ~           return Some(2);
-LL |         } else if n < 30 {
-LL ~           return Some(3);
-LL |         } else if n < 40 {
-LL ~           return Some(4);
-LL |         } else {
-LL ~           return Some(5);
-LL |         }
-LL |
-LL ~     }
-LL ~     None
-   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/typeck/issue-98982.rs b/tests/ui/typeck/issue-98982.rs
index f875d20fa4c..3eff9fbe360 100644
--- a/tests/ui/typeck/issue-98982.rs
+++ b/tests/ui/typeck/issue-98982.rs
@@ -1,7 +1,7 @@
-fn foo() -> i32 { //~ HELP otherwise consider changing the return type to account for that possibility
+fn foo() -> i32 {
     for i in 0..0 { //~ ERROR mismatched types [E0308]
         return i;
-    } //~ HELP return a value for the case when the loop has zero elements to iterate on
+    } //~ HELP consider returning a value here
 }
 
 fn main() {}
diff --git a/tests/ui/typeck/issue-98982.stderr b/tests/ui/typeck/issue-98982.stderr
index d8d5a86b157..3d40ff4d5af 100644
--- a/tests/ui/typeck/issue-98982.stderr
+++ b/tests/ui/typeck/issue-98982.stderr
@@ -8,26 +8,12 @@ LL | |         return i;
 LL | |     }
    | |_____^ expected `i32`, found `()`
    |
-note: the function expects a value to always be returned, but loops might run zero times
-  --> $DIR/issue-98982.rs:2:5
-   |
-LL |     for i in 0..0 {
-   |     ^^^^^^^^^^^^^ this might have zero elements to iterate on
-LL |         return i;
-   |         -------- if the loop doesn't execute, this value would never get returned
-help: return a value for the case when the loop has zero elements to iterate on
+   = note: `for` loops evaluate to unit type `()`
+help: consider returning a value here
    |
 LL ~     }
 LL ~     /* `i32` value */
    |
-help: otherwise consider changing the return type to account for that possibility
-   |
-LL ~ fn foo() -> Option<i32> {
-LL |     for i in 0..0 {
-LL ~         return Some(i);
-LL ~     }
-LL ~     None
-   |
 
 error: aborting due to 1 previous error