Remove span from hir::Stmt.

cjgillot · cjgillot · commit 76f16ed71fb6 · 2020-06-23T09:49:46.000+02:00
diff --git a/src/librustc_ast_lowering/lib.rs b/src/librustc_ast_lowering/lib.rs
@@ -2385,7 +2385,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     hir::Stmt {
                         hir_id: self.lower_node_id(s.id, s.span),
                         kind: hir::StmtKind::Local(self.arena.alloc(l)),
-                        span: s.span,
                     }
                 });
                 return ids;
@@ -2402,7 +2401,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             .map(|id| self.lower_node_id(id, s.span))
                             .unwrap_or_else(|| self.next_id(s.span));
 
-                        hir::Stmt { hir_id, kind: hir::StmtKind::Item(item_id), span: s.span }
+                        hir::Stmt { hir_id, kind: hir::StmtKind::Item(item_id) }
                     })
                     .collect();
             }
@@ -2411,7 +2410,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             StmtKind::Empty => return smallvec![],
             StmtKind::MacCall(..) => panic!("shouldn't exist here"),
         };
-        smallvec![hir::Stmt { hir_id: self.lower_node_id(s.id, s.span), kind, span: s.span }]
+        smallvec![hir::Stmt { hir_id: self.lower_node_id(s.id, s.span), kind }]
     }
 
     fn lower_block_check_mode(&mut self, b: &BlockCheckMode) -> hir::BlockCheckMode {
@@ -2446,7 +2445,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     // Helper methods for building HIR.
 
     fn stmt(&mut self, span: Span, kind: hir::StmtKind<'hir>) -> hir::Stmt<'hir> {
-        hir::Stmt { span, kind, hir_id: self.next_id(span) }
+        hir::Stmt { kind, hir_id: self.next_id(span) }
     }
 
     fn stmt_expr(&mut self, span: Span, expr: hir::Expr<'hir>) -> hir::Stmt<'hir> {
diff --git a/src/librustc_hir/hir.rs b/src/librustc_hir/hir.rs
@@ -1103,7 +1103,6 @@ impl UnOp {
 pub struct Stmt<'hir> {
     pub hir_id: HirId,
     pub kind: StmtKind<'hir>,
-    pub span: Span,
 }
 
 /// The contents of a statement.
diff --git a/src/librustc_hir_pretty/lib.rs b/src/librustc_hir_pretty/lib.rs
@@ -1040,7 +1040,8 @@ impl<'a> State<'a> {
     }
 
     pub fn print_stmt(&mut self, st: &hir::Stmt<'_>) {
-        self.maybe_print_comment(st.span.lo());
+        let span = self.span(st.hir_id);
+        self.maybe_print_comment(span.lo());
         match st.kind {
             hir::StmtKind::Local(ref loc) => {
                 self.print_local(loc.init.as_deref(), |this| this.print_local_decl(&loc));
@@ -1059,7 +1060,7 @@ impl<'a> State<'a> {
         if stmt_ends_with_semi(&st.kind) {
             self.s.word(";");
         }
-        self.maybe_print_trailing_comment(st.span, None)
+        self.maybe_print_trailing_comment(span, None)
     }
 
     pub fn print_block(&mut self, blk: &hir::Block<'_>) {
diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs
@@ -47,7 +47,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedResults {
         }
 
         let ty = cx.tables.expr_ty(&expr);
-        let type_permits_lack_of_use = check_must_use_ty(cx, ty, &expr, s.span, "", "", 1);
+        let span = cx.tcx.hir().span(s.hir_id);
+        let type_permits_lack_of_use = check_must_use_ty(cx, ty, &expr, span, "", "", 1);
 
         let mut fn_warned = false;
         let mut op_warned = false;
@@ -69,7 +70,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedResults {
             _ => None,
         };
         if let Some(def_id) = maybe_def_id {
-            fn_warned = check_must_use_def(cx, def_id, s.span, "return value of ", "");
+            fn_warned = check_must_use_def(cx, def_id, span, "return value of ", "");
         } else if type_permits_lack_of_use {
             // We don't warn about unused unit or uninhabited types.
             // (See https://github.com/rust-lang/rust/issues/43806 for details.)
@@ -111,7 +112,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedResults {
         }
 
         if !(type_permits_lack_of_use || fn_warned || op_warned) {
-            cx.struct_span_lint(UNUSED_RESULTS, s.span, |lint| lint.build("unused result").emit());
+            cx.struct_span_lint(UNUSED_RESULTS, span, |lint| lint.build("unused result").emit());
         }
 
         // Returns whether an error has been emitted (and thus another does not need to be later).
@@ -255,7 +256,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PathStatements {
     fn check_stmt(&mut self, cx: &LateContext<'_, '_>, s: &hir::Stmt<'_>) {
         if let hir::StmtKind::Semi(ref expr) = s.kind {
             if let hir::ExprKind::Path(_) = expr.kind {
-                cx.struct_span_lint(PATH_STATEMENTS, s.span, |lint| {
+                let span = cx.tcx.hir().span(s.hir_id);
+                cx.struct_span_lint(PATH_STATEMENTS, span, |lint| {
                     lint.build("path statement with no effect").emit()
                 });
             }
diff --git a/src/librustc_middle/hir/map/collector.rs b/src/librustc_middle/hir/map/collector.rs
@@ -444,7 +444,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
     }
 
     fn visit_stmt(&mut self, stmt: &'hir Stmt<'hir>) {
-        self.insert(stmt.span, stmt.hir_id, Node::Stmt(stmt));
+        self.insert(DUMMY_SP, stmt.hir_id, Node::Stmt(stmt));
 
         self.with_parent(stmt.hir_id, |this| {
             intravisit::walk_stmt(this, stmt);
diff --git a/src/librustc_middle/middle/region.rs b/src/librustc_middle/middle/region.rs
@@ -184,7 +184,7 @@ impl Scope {
                 // (This is the special case alluded to in the
                 // doc-comment for this method)
 
-                let stmt_span = blk.stmts[first_statement_index.index()].span;
+                let stmt_span = tcx.hir().span(blk.stmts[first_statement_index.index()].hir_id);
 
                 // To avoid issues with macro-generated spans, the span
                 // of the statement must be nested in that of the block.
diff --git a/src/librustc_passes/check_attr.rs b/src/librustc_passes/check_attr.rs
@@ -357,12 +357,14 @@ impl CheckAttrVisitor<'tcx> {
         if let hir::StmtKind::Local(ref l) = stmt.kind {
             for attr in l.attrs.iter() {
                 if attr.check_name(sym::inline) {
-                    self.check_inline(l.hir_id, attr, &stmt.span, Target::Statement);
+                    let span = self.tcx.hir().span(stmt.hir_id);
+                    self.check_inline(l.hir_id, attr, &span, Target::Statement);
                 }
                 if attr.check_name(sym::repr) {
+                    let span = self.tcx.hir().span(stmt.hir_id);
                     self.emit_repr_error(
                         attr.span,
-                        stmt.span,
+                        span,
                         "attribute should not be applied to a statement",
                         "not a struct, enum, or union",
                     );
diff --git a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs
@@ -922,7 +922,8 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                     // no return, suggest removal of semicolon on last statement.
                     // Once that is added, close #54771.
                     if let Some(ref stmt) = blk.stmts.last() {
-                        let sp = self.tcx.sess.source_map().end_point(stmt.span);
+                        let span = self.tcx.hir().span(stmt.hir_id);
+                        let sp = self.tcx.sess.source_map().end_point(span);
                         err.span_label(sp, "consider removing this semicolon");
                     }
                 }
diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs
@@ -300,7 +300,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             } else if let Some(stmt) = block.stmts.last() {
                 // possibly incorrect trailing `;` in the else arm
                 remove_semicolon = self.could_remove_semicolon(block, then_ty);
-                stmt.span
+                self.tcx.hir().span(stmt.hir_id)
             } else {
                 // empty block; point at its entirety
                 // Avoid overlapping spans that aren't as readable:
@@ -347,7 +347,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             } else if let Some(stmt) = block.stmts.last() {
                 // possibly incorrect trailing `;` in the else arm
                 remove_semicolon = remove_semicolon.or(self.could_remove_semicolon(block, else_ty));
-                stmt.span
+                self.tcx.hir().span(stmt.hir_id)
             } else {
                 // empty block; point at its entirety
                 outer_sp = None; // same as in `error_sp`; cleanup output
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -4618,7 +4618,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
         }
 
-        self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
+        let span = self.tcx.hir().span(stmt.hir_id);
+        self.warn_if_unreachable(stmt.hir_id, span, "statement");
 
         // Hide the outer diverging and `has_errors` flags.
         let old_diverges = self.diverges.replace(Diverges::Maybe);
@@ -5406,7 +5407,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         {
             return None;
         }
-        let original_span = original_sp(last_stmt.span, blk.span);
+        let last_stmt_span = self.tcx.hir().span(last_stmt.hir_id);
+        let original_span = original_sp(last_stmt_span, blk.span);
         Some(original_span.with_lo(original_span.hi() - BytePos(1)))
     }
 
diff --git a/src/tools/clippy/clippy_lints/src/blocks_in_if_conditions.rs b/src/tools/clippy/clippy_lints/src/blocks_in_if_conditions.rs
@@ -107,7 +107,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlocksInIfConditions {
                             );
                         }
                     } else {
-                        let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span, |e| e.span);
+                        let span = block.expr.as_ref().map_or_else(|| cx.tcx.hir().span(block.stmts[0].hir_id), |e| e.span);
                         if span.from_expansion() || differing_macro_contexts(expr.span, span) {
                             return;
                         }
diff --git a/src/tools/clippy/clippy_lints/src/let_if_seq.rs b/src/tools/clippy/clippy_lints/src/let_if_seq.rs
@@ -71,7 +71,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetIfSeq {
                 if let Some(value) = check_assign(cx, canonical_id, &*then);
                 if !used_in_expr(cx, canonical_id, value);
                 then {
-                    let span = stmt.span.to(if_.span);
+                    let span = cx.tcx.hir().span(stmt.hir_id).to(if_.span);
 
                     let has_interior_mutability = !cx.tables.node_type(canonical_id).is_freeze(
                         cx.tcx,
diff --git a/src/tools/clippy/clippy_lints/src/map_unit_fn.rs b/src/tools/clippy/clippy_lints/src/map_unit_fn.rs
@@ -142,7 +142,7 @@ fn reduce_unit_expression<'a>(cx: &LateContext<'_, '_>, expr: &'a hir::Expr<'_>)
                     match inner_stmt.kind {
                         hir::StmtKind::Local(ref local) => Some(local.span),
                         hir::StmtKind::Expr(ref e) => Some(e.span),
-                        hir::StmtKind::Semi(..) => Some(inner_stmt.span),
+                        hir::StmtKind::Semi(..) => Some(cx.tcx.hir().span(inner_stmt.hir_id)),
                         hir::StmtKind::Item(..) => None,
                     }
                 },
@@ -214,6 +214,7 @@ fn lint_map_unit_fn(cx: &LateContext<'_, '_>, stmt: &hir::Stmt<'_>, expr: &hir::
     };
     let fn_arg = &map_args[1];
 
+    let stmt_span = cx.tcx.hir().span(stmt.hir_id);
     if is_unit_function(cx, fn_arg) {
         let msg = suggestion_msg("function", map_type);
         let suggestion = format!(
@@ -225,7 +226,7 @@ fn lint_map_unit_fn(cx: &LateContext<'_, '_>, stmt: &hir::Stmt<'_>, expr: &hir::
         );
 
         span_lint_and_then(cx, lint, expr.span, &msg, |diag| {
-            diag.span_suggestion(stmt.span, "try this", suggestion, Applicability::MachineApplicable);
+            diag.span_suggestion(stmt_span, "try this", suggestion, Applicability::MachineApplicable);
         });
     } else if let Some((binding, closure_expr)) = unit_closure(cx, fn_arg) {
         let msg = suggestion_msg("closure", map_type);
@@ -240,7 +241,7 @@ fn lint_map_unit_fn(cx: &LateContext<'_, '_>, stmt: &hir::Stmt<'_>, expr: &hir::
                     snippet(cx, reduced_expr_span, "_")
                 );
                 diag.span_suggestion(
-                    stmt.span,
+                    stmt_span,
                     "try this",
                     suggestion,
                     Applicability::MachineApplicable, // snippet
@@ -252,15 +253,15 @@ fn lint_map_unit_fn(cx: &LateContext<'_, '_>, stmt: &hir::Stmt<'_>, expr: &hir::
                     snippet(cx, binding.pat.span, "_"),
                     snippet(cx, var_arg.span, "_"),
                 );
-                diag.span_suggestion(stmt.span, "try this", suggestion, Applicability::HasPlaceholders);
+                diag.span_suggestion(stmt_span, "try this", suggestion, Applicability::HasPlaceholders);
             }
         });
     }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MapUnit {
     fn check_stmt(&mut self, cx: &LateContext<'_, '_>, stmt: &hir::Stmt<'_>) {
-        if stmt.span.from_expansion() {
+        if cx.tcx.hir().span(stmt.hir_id).from_expansion() {
             return;
         }
 
diff --git a/src/tools/clippy/clippy_lints/src/matches.rs b/src/tools/clippy/clippy_lints/src/matches.rs
@@ -736,7 +736,7 @@ fn check_wild_err_arm(cx: &LateContext<'_, '_>, ex: &Expr<'_>, arms: &[Arm<'_>])
                     if_chain! {
                         if matching_wild;
                         if let ExprKind::Block(ref block, _) = arm.body.kind;
-                        if is_panic_block(block);
+                        if is_panic_block(cx, block);
                         then {
                             // `Err(_)` or `Err(_e)` arm with `panic!` found
                             span_lint_and_note(cx,
@@ -872,13 +872,14 @@ fn check_wild_enum_match(cx: &LateContext<'_, '_>, ex: &Expr<'_>, arms: &[Arm<'_
 }
 
 // If the block contains only a `panic!` macro (as expression or statement)
-fn is_panic_block(block: &Block<'_>) -> bool {
+fn is_panic_block(cx: &LateContext<'_, '_>, block: &Block<'_>) -> bool {
     match (&block.expr, block.stmts.len(), block.stmts.first()) {
         (&Some(ref exp), 0, _) => {
             is_expn_of(exp.span, "panic").is_some() && is_expn_of(exp.span, "unreachable").is_none()
         },
         (&None, 1, Some(stmt)) => {
-            is_expn_of(stmt.span, "panic").is_some() && is_expn_of(stmt.span, "unreachable").is_none()
+            let stmt_span = cx.tcx.hir().span(stmt.hir_id);
+            is_expn_of(stmt_span, "panic").is_some() && is_expn_of(stmt_span, "unreachable").is_none()
         },
         _ => false,
     }
diff --git a/src/tools/clippy/clippy_lints/src/misc.rs b/src/tools/clippy/clippy_lints/src/misc.rs
@@ -317,7 +317,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MiscLints {
                         "`ref` on an entire `let` pattern is discouraged, take a reference with `&` instead",
                         |diag| {
                             diag.span_suggestion(
-                                stmt.span,
+                                cx.tcx.hir().span(stmt.hir_id),
                                 "try",
                                 format!(
                                     "let {name}{tyopt} = {initref};",
@@ -338,14 +338,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MiscLints {
             if binop.node == BinOpKind::And || binop.node == BinOpKind::Or;
             if let Some(sugg) = Sugg::hir_opt(cx, a);
             then {
+                let stmt_span = cx.tcx.hir().span(stmt.hir_id);
                 span_lint_and_then(cx,
                     SHORT_CIRCUIT_STATEMENT,
-                    stmt.span,
+                    stmt_span,
                     "boolean short circuit operator in statement may be clearer using an explicit test",
                     |diag| {
                         let sugg = if binop.node == BinOpKind::Or { !sugg } else { sugg };
                         diag.span_suggestion(
-                            stmt.span,
+                            stmt_span,
                             "replace it with",
                             format!(
                                 "if {} {{ {}; }}",
diff --git a/src/tools/clippy/clippy_lints/src/no_effect.rs b/src/tools/clippy/clippy_lints/src/no_effect.rs
@@ -91,7 +91,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NoEffect {
     fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt<'_>) {
         if let StmtKind::Semi(ref expr) = stmt.kind {
             if has_no_effect(cx, expr) {
-                span_lint(cx, NO_EFFECT, stmt.span, "statement with no effect");
+                span_lint(cx, NO_EFFECT, cx.tcx.hir().span(stmt.hir_id), "statement with no effect");
             } else if let Some(reduced) = reduce_expression(cx, expr) {
                 let mut snippet = String::new();
                 for e in reduced {
@@ -108,7 +108,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NoEffect {
                 span_lint_and_sugg(
                     cx,
                     UNNECESSARY_OPERATION,
-                    stmt.span,
+                    cx.tcx.hir().span(stmt.hir_id),
                     "statement can be reduced",
                     "replace it with",
                     snippet,
diff --git a/src/tools/clippy/clippy_lints/src/swap.rs b/src/tools/clippy/clippy_lints/src/swap.rs
@@ -133,7 +133,7 @@ fn check_manual_swap(cx: &LateContext<'_, '_>, block: &Block<'_>) {
                     (true, String::new(), String::new())
                 };
 
-                let span = w[0].span.to(second.span);
+                let span = cx.tcx.hir().span(w[0].hir_id).to(second.span);
 
                 span_lint_and_then(
                     cx,
diff --git a/src/tools/clippy/clippy_lints/src/types.rs b/src/tools/clippy/clippy_lints/src/types.rs
@@ -603,7 +603,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetUnitValue {
     fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt<'_>) {
         if let StmtKind::Local(ref local) = stmt.kind {
             if is_unit(cx.tables.pat_ty(&local.pat)) {
-                if in_external_macro(cx.sess(), stmt.span) || local.pat.span.from_expansion() {
+                let stmt_span = cx.tcx.hir().span(stmt.hir_id);
+                if in_external_macro(cx.sess(), stmt_span) || local.pat.span.from_expansion() {
                     return;
                 }
                 if higher::is_from_for_desugar(local) {
@@ -612,13 +613,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetUnitValue {
                 span_lint_and_then(
                     cx,
                     LET_UNIT_VALUE,
-                    stmt.span,
+                    stmt_span,
                     "this let-binding has unit value",
                     |diag| {
                         if let Some(expr) = &local.init {
                             let snip = snippet_with_macro_callsite(cx, expr.span, "()");
                             diag.span_suggestion(
-                                stmt.span,
+                                stmt_span,
                                 "omit the `let` binding",
                                 format!("{};", snip),
                                 Applicability::MachineApplicable, // snippet
@@ -826,7 +827,7 @@ fn lint_unit_args(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args_to_recover: &[
                         if let Some(snip) = snippet_opt(cx, last_expr.span);
                         then {
                             Some((
-                                last_stmt.span,
+                                cx.tcx.hir().span(last_stmt.hir_id),
                                 snip,
                             ))
                         }

Original file line number	Diff line number	Diff line change
`@@ -1103,7 +1103,6 @@ impl UnOp {`
`1103`	`1103`	`pub struct Stmt<'hir> {`
`1104`	`1104`	`pub hir_id: HirId,`
`1105`	`1105`	`pub kind: StmtKind<'hir>,`
`1106`		`- pub span: Span,`
`1107`	`1106`	`}`
`1108`	`1107`
`1109`	`1108`	`/// The contents of a statement.`
Original file line number	Diff line number	Diff line change
`@@ -1040,7 +1040,8 @@ impl<'a> State<'a> {`
`1040`	`1040`	`}`
`1041`	`1041`
`1042`	`1042`	`pub fn print_stmt(&mut self, st: &hir::Stmt<'_>) {`
`1043`		`- self.maybe_print_comment(st.span.lo());`
	`1043`	`+ let span = self.span(st.hir_id);`
	`1044`	`+ self.maybe_print_comment(span.lo());`
`1044`	`1045`	`match st.kind {`
`1045`	`1046`	`hir::StmtKind::Local(ref loc) => {`
`1046`	`1047`	`self.print_local(loc.init.as_deref(), \|this\| this.print_local_decl(&loc));`
`@@ -1059,7 +1060,7 @@ impl<'a> State<'a> {`
`1059`	`1060`	`if stmt_ends_with_semi(&st.kind) {`
`1060`	`1061`	`self.s.word(";");`
`1061`	`1062`	`}`
`1062`		`- self.maybe_print_trailing_comment(st.span, None)`
	`1063`	`+ self.maybe_print_trailing_comment(span, None)`
`1063`	`1064`	`}`
`1064`	`1065`
`1065`	`1066`	`pub fn print_block(&mut self, blk: &hir::Block<'_>) {`
Original file line number	Diff line number	Diff line change
`@@ -444,7 +444,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {`
`444`	`444`	`}`
`445`	`445`
`446`	`446`	`fn visit_stmt(&mut self, stmt: &'hir Stmt<'hir>) {`
`447`		`- self.insert(stmt.span, stmt.hir_id, Node::Stmt(stmt));`
	`447`	`+ self.insert(DUMMY_SP, stmt.hir_id, Node::Stmt(stmt));`
`448`	`448`
`449`	`449`	`self.with_parent(stmt.hir_id, \|this\| {`
`450`	`450`	`intravisit::walk_stmt(this, stmt);`
Original file line number	Diff line number	Diff line change
`@@ -922,7 +922,8 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {`
`922`	`922`	`// no return, suggest removal of semicolon on last statement.`
`923`	`923`	`// Once that is added, close #54771.`
`924`	`924`	`if let Some(ref stmt) = blk.stmts.last() {`
`925`		`- let sp = self.tcx.sess.source_map().end_point(stmt.span);`
	`925`	`+ let span = self.tcx.hir().span(stmt.hir_id);`
	`926`	`+ let sp = self.tcx.sess.source_map().end_point(span);`
`926`	`927`	`err.span_label(sp, "consider removing this semicolon");`
`927`	`928`	`}`
`928`	`929`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4618,7 +4618,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`4618`	`4618`	`hir::StmtKind::Local(..) \| hir::StmtKind::Expr(..) \| hir::StmtKind::Semi(..) => {}`
`4619`	`4619`	`}`
`4620`	`4620`
`4621`		`- self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");`
	`4621`	`+ let span = self.tcx.hir().span(stmt.hir_id);`
	`4622`	`+ self.warn_if_unreachable(stmt.hir_id, span, "statement");`
`4622`	`4623`
`4623`	`4624`	// Hide the outer diverging and `has_errors` flags.
`4624`	`4625`	`let old_diverges = self.diverges.replace(Diverges::Maybe);`
`@@ -5406,7 +5407,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`5406`	`5407`	`{`
`5407`	`5408`	`return None;`
`5408`	`5409`	`}`
`5409`		`- let original_span = original_sp(last_stmt.span, blk.span);`
	`5410`	`+ let last_stmt_span = self.tcx.hir().span(last_stmt.hir_id);`
	`5411`	`+ let original_span = original_sp(last_stmt_span, blk.span);`
`5410`	`5412`	`Some(original_span.with_lo(original_span.hi() - BytePos(1)))`
`5411`	`5413`	`}`
`5412`	`5414`