Fixing span manipulation and indentation of the suggestion introduced by rust-lang#126187

According to:
rust-lang#128084 (comment)
https://github.com/rust-lang/rust/pull/126187/files#r1634897691

I try to add a span field to `Block` which doesn't include brace '{' and '}', because I need to add a suggestion at the end of function's body, and this can help me find the right place. But this will make `Block` larger.

I don't want to break the original span field in `Block`, I'm worried that it will cause a lot of code failures and I think it may be more intuitive for span to include braces.

Author: surechen

compiler/rustc_ast/src/ast.rs

@@ -544,6 +544,9 @@ pub struct Block {
     /// Distinguishes between `unsafe { ... }` and `{ ... }`.
     pub rules: BlockCheckMode,
     pub span: Span,
+    // Only for function or method written by developers that do have a block,
+    // but not including the blocks automatically inserted by the compiler.
+    pub no_brace_span: Option<Span>,
     pub tokens: Option<LazyAttrTokenStream>,
     /// The following *isn't* a parse error, but will cause multiple errors in following stages.
     /// ```compile_fail
@@ -3501,7 +3504,7 @@ mod size_asserts {
     static_assert_size!(AssocItem, 88);
     static_assert_size!(AssocItemKind, 16);
     static_assert_size!(Attribute, 32);
-    static_assert_size!(Block, 32);
+    static_assert_size!(Block, 48);
     static_assert_size!(Expr, 72);
     static_assert_size!(ExprKind, 40);
     static_assert_size!(Fn, 160);

compiler/rustc_ast/src/mut_visit.rs

@@ -1076,7 +1076,8 @@ fn walk_mt<T: MutVisitor>(vis: &mut T, MutTy { ty, mutbl: _ }: &mut MutTy) {
 }
 
 pub fn walk_block<T: MutVisitor>(vis: &mut T, block: &mut P<Block>) {
-    let Block { id, stmts, rules: _, span, tokens, could_be_bare_literal: _ } = block.deref_mut();
+    let Block { id, stmts, rules: _, span, tokens, could_be_bare_literal: _, no_brace_span: _ } =
+        block.deref_mut();
     vis.visit_id(id);
     stmts.flat_map_in_place(|stmt| vis.flat_map_stmt(stmt));
     visit_lazy_tts(vis, tokens);

compiler/rustc_ast/src/visit.rs

@@ -943,7 +943,15 @@ pub fn walk_field_def<'a, V: Visitor<'a>>(visitor: &mut V, field: &'a FieldDef)
 }
 
 pub fn walk_block<'a, V: Visitor<'a>>(visitor: &mut V, block: &'a Block) -> V::Result {
-    let Block { stmts, id: _, rules: _, span: _, tokens: _, could_be_bare_literal: _ } = block;
+    let Block {
+        stmts,
+        id: _,
+        rules: _,
+        span: _,
+        tokens: _,
+        could_be_bare_literal: _,
+        no_brace_span: _,
+    } = block;
     walk_list!(visitor, visit_stmt, stmts);
     V::Result::output()
 }

compiler/rustc_ast_lowering/src/block.rs

@@ -1,5 +1,6 @@
 use rustc_ast::{Block, BlockCheckMode, Local, LocalKind, Stmt, StmtKind};
 use rustc_hir as hir;
+use rustc_span::Span;
 use smallvec::SmallVec;
 
 use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext};
@@ -21,7 +22,17 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let (stmts, expr) = self.lower_stmts(&b.stmts);
         let rules = self.lower_block_check_mode(&b.rules);
         let hir_id = self.lower_node_id(b.id);
-        hir::Block { hir_id, stmts, expr, rules, span: self.lower_span(b.span), targeted_by_break }
+        let lower = |span: Span| -> Option<Span> { Some(self.lower_span(span)) };
+        let no_brace_span = b.no_brace_span.and_then(lower);
+        hir::Block {
+            hir_id,
+            stmts,
+            expr,
+            rules,
+            span: self.lower_span(b.span),
+            no_brace_span,
+            targeted_by_break,
+        }
     }
 
     fn lower_stmts(

compiler/rustc_ast_lowering/src/delegation.rs

@@ -353,6 +353,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             hir_id: self.next_id(),
             rules: hir::BlockCheckMode::DefaultBlock,
             span,
+            no_brace_span: None,
             targeted_by_break: false,
         });
 

compiler/rustc_ast_lowering/src/expr.rs

@@ -592,6 +592,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 hir_id: self.next_id(),
                 rules: hir::BlockCheckMode::DefaultBlock,
                 span,
+                no_brace_span: None,
                 targeted_by_break: false,
             });
             self.arena.alloc(hir::Expr {
@@ -2116,6 +2117,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     hir_id,
                     rules: hir::BlockCheckMode::UnsafeBlock(hir::UnsafeSource::CompilerGenerated),
                     span: self.lower_span(span),
+                    no_brace_span: None,
                     targeted_by_break: false,
                 }),
                 None,

compiler/rustc_ast_lowering/src/format.rs

@@ -612,6 +612,7 @@ fn expand_format_args<'hir>(
             hir_id,
             rules: hir::BlockCheckMode::UnsafeBlock(hir::UnsafeSource::CompilerGenerated),
             span: macsp,
+            no_brace_span: None,
             targeted_by_break: false,
         }));
         let args = ctx.arena.alloc_from_iter([lit_pieces, args, format_options, unsafe_arg]);

compiler/rustc_ast_lowering/src/lib.rs

@@ -2571,6 +2571,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             hir_id: self.next_id(),
             rules: hir::BlockCheckMode::DefaultBlock,
             span: self.lower_span(span),
+            no_brace_span: None,
             targeted_by_break: false,
         };
         self.arena.alloc(blk)

compiler/rustc_builtin_macros/src/deriving/mod.rs

@@ -112,6 +112,7 @@ fn call_unreachable(cx: &ExtCtxt<'_>, span: Span) -> P<ast::Expr> {
         id: ast::DUMMY_NODE_ID,
         rules: ast::BlockCheckMode::Unsafe(ast::CompilerGenerated),
         span,
+        no_brace_span: None,
         tokens: None,
         could_be_bare_literal: false,
     }))

compiler/rustc_expand/src/build.rs

@@ -247,6 +247,7 @@ impl<'a> ExtCtxt<'a> {
             id: ast::DUMMY_NODE_ID,
             rules: BlockCheckMode::Default,
             span,
+            no_brace_span: None,
             tokens: None,
             could_be_bare_literal: false,
         })