reintegrate #58981 into if/match logic and extend to if-let.

Author: Centril

Diff for: src/librustc_typeck/check/_match.rs

@@ -661,9 +661,25 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
             use ObligationCauseCode::*;
 
             if is_if_fallback {
+                let then_expr = &arms[0].body;
+                // If this `if` expr is the parent's function return expr,
+                // the cause of the type coercion is the return type, point at it. (#25228)
+                let ret_reason = self.maybe_get_coercion_reason(then_expr.hir_id, expr.span);
+
                 let cause = self.cause(expr.span, IfExpressionWithNoElse);
                 assert!(arm_ty.is_unit());
-                coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
+
+                coercion.coerce_forced_unit(self, &cause, &mut |err| {
+                    if let Some((span, msg)) = &ret_reason {
+                        err.span_label(*span, msg.as_str());
+                    } else if let ExprKind::Block(block, _) = &then_expr.node {
+                        if let Some(expr) = &block.expr {
+                            err.span_label(expr.span, "found here".to_string());
+                        }
+                    }
+                    err.note("`if` expressions without `else` evaluate to `()`");
+                    err.help("consider adding an `else` block that evaluates to the expected type");
+                }, ret_reason.is_none());
             } else {
                 let cause = if source_if {
                     match i {
@@ -700,6 +716,39 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
         coercion.complete(self)
     }
 
+    fn maybe_get_coercion_reason(&self, hir_id: hir::HirId, span: Span) -> Option<(Span, String)> {
+        use hir::Node::{Block, Item};
+
+        let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(
+            self.tcx.hir().get_parent_node_by_hir_id(hir_id),
+        ));
+        if let Block(block) = node {
+            // check that the body's parent is an fn
+            let parent = self.tcx.hir().get_by_hir_id(
+                self.tcx.hir().get_parent_node_by_hir_id(
+                    self.tcx.hir().get_parent_node_by_hir_id(block.hir_id),
+                ),
+            );
+            if let (Some(expr), Item(hir::Item {
+                node: hir::ItemKind::Fn(..), ..
+            })) = (&block.expr, parent) {
+                // check that the `if` expr without `else` is the fn body's expr
+                if expr.span == span {
+                    return self.get_fn_decl(hir_id).map(|(fn_decl, _)| (
+                        fn_decl.output.span(),
+                        format!("expected `{}` because of this return type", fn_decl.output),
+                    ));
+                }
+            }
+        }
+        if let hir::Node::Local(hir::Local {
+            ty: Some(_), pat, ..
+        }) = node {
+            return Some((pat.span, "expected because of this assignment".to_string()));
+        }
+        None
+    }
+
     fn if_cause(
         &self,
         expr: &'gcx hir::Expr,
@@ -708,6 +757,19 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
         else_ty: Ty<'tcx>,
     ) -> ObligationCause<'tcx> {
         let mut outer_sp = if self.tcx.sess.source_map().is_multiline(expr.span) {
+            // The `if`/`else` isn't in one line in the output, include some context to make it
+            // clear it is an if/else expression:
+            // ```
+            // LL |      let x = if true {
+            //    | _____________-
+            // LL ||         10i32
+            //    ||         ----- expected because of this
+            // LL ||     } else {
+            // LL ||         10u32
+            //    ||         ^^^^^ expected i32, found u32
+            // LL ||     };
+            //    ||_____- if and else have incompatible types
+            // ```
             Some(expr.span)
         } else {
             // The entire expression is in one line, only point at the arms
@@ -770,7 +832,7 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
         };
 
         // Compute `Span` of `then` part of `if`-expression:
-        let then_sp: Span = if let ExprKind::Block(block, _) = &then_expr.node {
+        let then_sp = if let ExprKind::Block(block, _) = &then_expr.node {
             if let Some(expr) = &block.expr {
                 expr.span
             } else if let Some(stmt) = block.stmts.last() {

Diff for: src/test/ui/if/if-without-else-as-fn-expr.rs

@@ -20,6 +20,29 @@ fn foo3(bar: usize) -> usize {
     //~^^^ ERROR if may be missing an else clause
 }
 
+fn foo_let(bar: usize) -> usize {
+    if let 0 = 1 {
+        return 3;
+    }
+    //~^^^ ERROR if may be missing an else clause
+}
+
+fn foo2_let(bar: usize) -> usize {
+    let x: usize = if let 0 = 1 {
+        return 3;
+    };
+    //~^^^ ERROR if may be missing an else clause
+    x
+}
+
+fn foo3_let(bar: usize) -> usize {
+    if let 0 = 1 {
+        3
+    }
+    //~^^^ ERROR if may be missing an else clause
+}
+
 fn main() {
     let _ = foo(1);
 }
+

Diff for: src/test/ui/if/if-without-else-as-fn-expr.stderr

@@ -44,6 +44,52 @@ LL | |     }
    = note: `if` expressions without `else` evaluate to `()`
    = help: consider adding an `else` block that evaluates to the expected type
 
-error: aborting due to 3 previous errors
+error[E0317]: if may be missing an else clause
+  --> $DIR/if-without-else-as-fn-expr.rs:24:5
+   |
+LL |   fn foo_let(bar: usize) -> usize {
+   |                             ----- expected `usize` because of this return type
+LL | /     if let 0 = 1 {
+LL | |         return 3;
+LL | |     }
+   | |_____^ expected usize, found ()
+   |
+   = note: expected type `usize`
+              found type `()`
+   = note: `if` expressions without `else` evaluate to `()`
+   = help: consider adding an `else` block that evaluates to the expected type
+
+error[E0317]: if may be missing an else clause
+  --> $DIR/if-without-else-as-fn-expr.rs:31:20
+   |
+LL |       let x: usize = if let 0 = 1 {
+   |  _________-__________^
+   | |         |
+   | |         expected because of this assignment
+LL | |         return 3;
+LL | |     };
+   | |_____^ expected usize, found ()
+   |
+   = note: expected type `usize`
+              found type `()`
+   = note: `if` expressions without `else` evaluate to `()`
+   = help: consider adding an `else` block that evaluates to the expected type
+
+error[E0317]: if may be missing an else clause
+  --> $DIR/if-without-else-as-fn-expr.rs:39:5
+   |
+LL |   fn foo3_let(bar: usize) -> usize {
+   |                              ----- expected `usize` because of this return type
+LL | /     if let 0 = 1 {
+LL | |         3
+LL | |     }
+   | |_____^ expected usize, found ()
+   |
+   = note: expected type `usize`
+              found type `()`
+   = note: `if` expressions without `else` evaluate to `()`
+   = help: consider adding an `else` block that evaluates to the expected type
+
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0317`.

Diff for: src/test/ui/issues/issue-19991.stderr

@@ -6,11 +6,14 @@ LL | |
 LL | |
 LL | |
 LL | |         765
+   | |         --- found here
 LL | |     };
    | |_____^ expected (), found integer
    |
    = note: expected type `()`
               found type `{integer}`
+   = note: `if` expressions without `else` evaluate to `()`
+   = help: consider adding an `else` block that evaluates to the expected type
 
 error: aborting due to previous error