Use a more accurate span for the implicit block return assignment

Author: jamie-osec

compiler/rustc_mir_build/src/builder/block.rs

@@ -64,10 +64,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // By doing so, we can be sure that even temporaries that receive extended lifetime
         // assignments are dropped, too.
         let mut last_remainder_scope = region_scope;
-
+        let mut last_span = None;
         let source_info = this.source_info(span);
         for stmt in stmts {
             let Stmt { ref kind } = this.thir[*stmt];
+            last_span = match kind {
+                StmtKind::Expr { expr, .. } => Some(this.thir[*expr].span),
+                StmtKind::Let { span, .. } => Some(*span),
+            };
+
             match kind {
                 StmtKind::Expr { scope, expr } => {
                     this.block_context.push(BlockFrame::Statement { ignores_expr_result: true });
@@ -334,6 +339,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             {
                 // We only want to assign an implicit `()` as the return value of the block if the
                 // block does not diverge. (Otherwise, we may try to assign a unit to a `!`-type.)
+                // Shrink the span to the tail of the block to avoid confusing diagnostics highlighting the entire block
+                let source_info = if let Some(span) = last_span {
+                    SourceInfo { span: span.shrink_to_hi(), ..source_info }
+                } else {
+                    source_info
+                };
                 this.cfg.push_assign_unit(block, source_info, destination, this.tcx);
             }
         }

tests/ui/uninhabited/void-branch.rs

@@ -6,8 +6,8 @@ enum Void {}
 fn with_void() {
     if false {
         unsafe {
-            //~^ ERROR unreachable expression
             std::mem::uninitialized::<Void>();
+            //~^ ERROR unreachable expression
         }
     }
 
@@ -20,8 +20,8 @@ fn infallible() -> std::convert::Infallible {
 
 fn with_infallible() {
     if false {
-        //~^ ERROR unreachable expression
         infallible();
+        //~^ ERROR unreachable expression
     }
 
     println!()

tests/ui/uninhabited/void-branch.stderr

@@ -1,15 +1,13 @@
 error: unreachable expression
-  --> $DIR/void-branch.rs:8:9
+  --> $DIR/void-branch.rs:9:46
    |
-LL | /         unsafe {
-LL | |
-LL | |             std::mem::uninitialized::<Void>();
-   | |             --------------------------------- any code following this expression is unreachable
-LL | |         }
-   | |_________^ unreachable expression
+LL |             std::mem::uninitialized::<Void>();
+   |             ---------------------------------^ unreachable expression
+   |             |
+   |             any code following this expression is unreachable
    |
 note: this expression has type `Void`, which is uninhabited
-  --> $DIR/void-branch.rs:10:13
+  --> $DIR/void-branch.rs:9:13
    |
 LL |             std::mem::uninitialized::<Void>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,18 +18,15 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable expression
-  --> $DIR/void-branch.rs:22:14
+  --> $DIR/void-branch.rs:23:21
    |
-LL |       if false {
-   |  ______________^
-LL | |
-LL | |         infallible();
-   | |         ------------ any code following this expression is unreachable
-LL | |     }
-   | |_____^ unreachable expression
+LL |         infallible();
+   |         ------------^ unreachable expression
+   |         |
+   |         any code following this expression is unreachable
    |
 note: this expression has type `Infallible`, which is uninhabited
-  --> $DIR/void-branch.rs:24:9
+  --> $DIR/void-branch.rs:23:9
    |
 LL |         infallible();
    |         ^^^^^^^^^^^^