[unused_braces] Lint multiline blocks as long as not in arms

Currently the lint faces a severe limitation: since it only catches single-line block, running rustfmt beforehand will remove all occurences of it, because it breaks them into multiline blocks.

We do not check match `Arm` for two reasons:
- In case it does not use commas to separate arms, removing the block would result in a compilation error
Example:
```
    match expr {
        pat => {()}
        _ => println!("foo")
    }
    ```
    - Do not lint multiline match arms used for formatting reasons
    ```
    match expr {
       pat => {
           somewhat_long_expression
       }
     // ...
    }
```

Delete `unused-braces-lint` test

The modified lint correctly provide a span in its suggestion.

```shell
    error: unnecessary braces around block return value
      --> /rust/src/test/rustdoc-ui/unused-braces-lint.rs:9:5
       |
    LL | /     {
    LL | |         {
       | |________^
    LL |               use std;
    LL |           }
       |  __________^
    LL | |     }
       | |_____^
       |
    note: the lint level is defined here
      --> /rust/src/test/rustdoc-ui/unused-braces-lint.rs:6:9
       |
    LL | #![deny(unused_braces)]
       |         ^^^^^^^^^^^^^
    help: remove these braces
       |
    LL ~     {
    LL |             use std;
    LL ~         }
       |
```

It is unclear to which extend #70814 is still an issue, as the inital MCVE does not trigger the lint on stable either,[rust playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=b6ff31a449c0b73a08daac8ee43b1fa6)

Fix code with expanded `unused_braces` lint

Also allow `unused_braces` on tests

Mute `unused_braces` on `match_ast!`

compiler/rustc_codegen_cranelift/src/base.rs

@@ -50,10 +50,10 @@ pub(crate) fn codegen_fn<'tcx>(
     let mir = tcx.instance_mir(instance.def);
     let _mir_guard = crate::PrintOnPanic(|| {
         let mut buf = Vec::new();
-        with_no_trimmed_paths!({
+        with_no_trimmed_paths!(
             rustc_middle::mir::pretty::write_mir_fn(tcx, mir, &mut |_, _| Ok(()), &mut buf)
-                .unwrap();
-        });
+                .unwrap()
+        );
         String::from_utf8_lossy(&buf).into_owned()
     });
 
@@ -295,9 +295,9 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
 
         if fx.clif_comments.enabled() {
             let mut terminator_head = "\n".to_string();
-            with_no_trimmed_paths!({
-                bb_data.terminator().kind.fmt_head(&mut terminator_head).unwrap();
-            });
+            with_no_trimmed_paths!(
+                bb_data.terminator().kind.fmt_head(&mut terminator_head).unwrap()
+            );
             let inst = fx.bcx.func.layout.last_inst(block).unwrap();
             fx.add_comment(inst, terminator_head);
         }

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -649,45 +649,36 @@ fn codegen_regular_intrinsic_call<'tcx>(
 
             let layout = fx.layout_of(substs.type_at(0));
             if layout.abi.is_uninhabited() {
-                with_no_trimmed_paths!({
-                    crate::base::codegen_panic_nounwind(
-                        fx,
-                        &format!("attempted to instantiate uninhabited type `{}`", layout.ty),
-                        source_info,
-                    )
-                });
+                with_no_trimmed_paths!(crate::base::codegen_panic_nounwind(
+                    fx,
+                    &format!("attempted to instantiate uninhabited type `{}`", layout.ty),
+                    source_info,
+                ));
                 return;
             }
 
             if intrinsic == sym::assert_zero_valid
                 && !fx.tcx.permits_zero_init(fx.param_env().and(layout))
             {
-                with_no_trimmed_paths!({
-                    crate::base::codegen_panic_nounwind(
-                        fx,
-                        &format!(
-                            "attempted to zero-initialize type `{}`, which is invalid",
-                            layout.ty
-                        ),
-                        source_info,
-                    );
-                });
+                with_no_trimmed_paths!(crate::base::codegen_panic_nounwind(
+                    fx,
+                    &format!("attempted to zero-initialize type `{}`, which is invalid", layout.ty),
+                    source_info,
+                ));
                 return;
             }
 
             if intrinsic == sym::assert_mem_uninitialized_valid
                 && !fx.tcx.permits_uninit_init(fx.param_env().and(layout))
             {
-                with_no_trimmed_paths!({
-                    crate::base::codegen_panic_nounwind(
-                        fx,
-                        &format!(
-                            "attempted to leave type `{}` uninitialized, which is invalid",
-                            layout.ty
-                        ),
-                        source_info,
-                    )
-                });
+                with_no_trimmed_paths!(crate::base::codegen_panic_nounwind(
+                    fx,
+                    &format!(
+                        "attempted to leave type `{}` uninitialized, which is invalid",
+                        layout.ty
+                    ),
+                    source_info,
+                ));
                 return;
             }
         }

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -465,27 +465,25 @@ pub fn type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll D
         _ => bug!("debuginfo: unexpected type in type_di_node(): {:?}", t),
     };
 
-    {
-        if already_stored_in_typemap {
-            // Make sure that we really do have a `TypeMap` entry for the unique type ID.
-            let di_node_for_uid =
-                match debug_context(cx).type_map.di_node_for_unique_id(unique_type_id) {
-                    Some(di_node) => di_node,
-                    None => {
-                        bug!(
-                            "expected type debuginfo node for unique \
+    if already_stored_in_typemap {
+        // Make sure that we really do have a `TypeMap` entry for the unique type ID.
+        let di_node_for_uid = match debug_context(cx).type_map.di_node_for_unique_id(unique_type_id)
+        {
+            Some(di_node) => di_node,
+            None => {
+                bug!(
+                    "expected type debuginfo node for unique \
                                type ID '{:?}' to already be in \
                                the `debuginfo::TypeMap` but it \
                                was not.",
-                            unique_type_id,
-                        );
-                    }
-                };
+                    unique_type_id,
+                );
+            }
+        };
 
-            debug_assert_eq!(di_node_for_uid as *const _, di_node as *const _);
-        } else {
-            debug_context(cx).type_map.insert(unique_type_id, di_node);
-        }
+        debug_assert_eq!(di_node_for_uid as *const _, di_node as *const _);
+    } else {
+        debug_context(cx).type_map.insert(unique_type_id, di_node);
     }
 
     di_node

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -678,21 +678,17 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 MemUninitializedValid => !bx.tcx().permits_uninit_init(bx.param_env().and(layout)),
             };
             Some(if do_panic {
-                let msg_str = with_no_visible_paths!({
-                    with_no_trimmed_paths!({
-                        if layout.abi.is_uninhabited() {
-                            // Use this error even for the other intrinsics as it is more precise.
-                            format!("attempted to instantiate uninhabited type `{}`", ty)
-                        } else if intrinsic == ZeroValid {
-                            format!("attempted to zero-initialize type `{}`, which is invalid", ty)
-                        } else {
-                            format!(
-                                "attempted to leave type `{}` uninitialized, which is invalid",
-                                ty
-                            )
-                        }
-                    })
-                });
+                let msg_str = with_no_visible_paths!(with_no_trimmed_paths!(if layout
+                    .abi
+                    .is_uninhabited()
+                {
+                    // Use this error even for the other intrinsics as it is more precise.
+                    format!("attempted to instantiate uninhabited type `{}`", ty)
+                } else if intrinsic == ZeroValid {
+                    format!("attempted to zero-initialize type `{}`, which is invalid", ty)
+                } else {
+                    format!("attempted to leave type `{}` uninitialized, which is invalid", ty)
+                }));
                 let msg = bx.const_str(&msg_str);
 
                 // Obtain the panic entry point.

compiler/rustc_expand/src/placeholders.rs

@@ -144,17 +144,17 @@ pub fn placeholder(
             span,
             is_placeholder: true,
         }]),
-        AstFragmentKind::GenericParams => AstFragment::GenericParams(smallvec![{
-            ast::GenericParam {
+        AstFragmentKind::GenericParams => {
+            AstFragment::GenericParams(smallvec![ast::GenericParam {
                 attrs: Default::default(),
                 bounds: Default::default(),
                 id,
                 ident,
                 is_placeholder: true,
                 kind: ast::GenericParamKind::Lifetime,
                 colon_span: None,
-            }
-        }]),
+            }])
+        }
         AstFragmentKind::Params => AstFragment::Params(smallvec![ast::Param {
             attrs: Default::default(),
             id,

compiler/rustc_lint/src/context.rs

@@ -1199,12 +1199,10 @@ impl<'tcx> LateContext<'tcx> {
                 }
 
                 // This shouldn't ever be needed, but just in case:
-                with_no_trimmed_paths!({
-                    Ok(vec![match trait_ref {
-                        Some(trait_ref) => Symbol::intern(&format!("{:?}", trait_ref)),
-                        None => Symbol::intern(&format!("<{}>", self_ty)),
-                    }])
-                })
+                with_no_trimmed_paths!(Ok(vec![match trait_ref {
+                    Some(trait_ref) => Symbol::intern(&format!("{:?}", trait_ref)),
+                    None => Symbol::intern(&format!("<{}>", self_ty)),
+                }]))
             }
 
             fn path_append_impl(

compiler/rustc_lint/src/unused.rs

@@ -1116,15 +1116,6 @@ impl UnusedDelimLint for UnusedBraces {
                 // - the block is not `unsafe`
                 // - the block contains exactly one expression (do not lint `{ expr; }`)
                 // - `followed_by_block` is true and the internal expr may contain a `{`
-                // - the block is not multiline (do not lint multiline match arms)
-                //      ```
-                //      match expr {
-                //          Pattern => {
-                //              somewhat_long_expression
-                //          }
-                //          // ...
-                //      }
-                //      ```
                 // - the block has no attribute and was not created inside a macro
                 // - if the block is an `anon_const`, the inner expr must be a literal
                 //   not created by a macro, i.e. do not lint on:
@@ -1133,14 +1124,31 @@ impl UnusedDelimLint for UnusedBraces {
                 //      let _: A<{ 2 + 3 }>;
                 //      let _: A<{produces_literal!()}>;
                 //      ```
+                //
+                // We do not check expression in `Arm` bodies:
+                // - if not using commas to separate arms, removing the block would result in a compilation error
+                // ```
+                // match expr {
+                //     pat => {()}
+                //     _ => println!("foo")
+                // }
+                // ```
+                // - multiline blocks can used for formatting
+                // ```
+                // match expr {
+                //    pat => {
+                //        somewhat_long_expression
+                //    }
+                //  // ...
+                // }
+                // ```
                 // FIXME(const_generics): handle paths when #67075 is fixed.
                 if let [stmt] = inner.stmts.as_slice() {
                     if let ast::StmtKind::Expr(ref expr) = stmt.kind {
                         if !Self::is_expr_delims_necessary(expr, followed_by_block, false)
                             && (ctx != UnusedDelimsCtx::AnonConst
                                 || (matches!(expr.kind, ast::ExprKind::Lit(_))
                                     && !expr.span.from_expansion()))
-                            && !cx.sess().source_map().is_multiline(value.span)
                             && value.attrs.is_empty()
                             && !value.span.from_expansion()
                             && !inner.span.from_expansion()

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -22,27 +22,27 @@ use std::sync::Arc;
 impl fmt::Debug for ty::TraitDef {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         ty::tls::with(|tcx| {
-            with_no_trimmed_paths!({
+            with_no_trimmed_paths!(
                 f.write_str(
                     &FmtPrinter::new(tcx, Namespace::TypeNS)
                         .print_def_path(self.def_id, &[])?
                         .into_buffer(),
                 )
-            })
+            )
         })
     }
 }
 
 impl<'tcx> fmt::Debug for ty::AdtDef<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         ty::tls::with(|tcx| {
-            with_no_trimmed_paths!({
+            with_no_trimmed_paths!(
                 f.write_str(
                     &FmtPrinter::new(tcx, Namespace::TypeNS)
                         .print_def_path(self.did(), &[])?
                         .into_buffer(),
                 )
-            })
+            )
         })
     }
 }
@@ -77,6 +77,7 @@ impl fmt::Debug for ty::BoundRegionKind {
                     write!(f, "BrNamed({:?}, {})", did, name)
                 }
             }
+
             ty::BrEnv => write!(f, "BrEnv"),
         }
     }

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -488,9 +488,9 @@ fn check_for_bindings_named_same_as_variants(
             })
         {
             let variant_count = edef.variants().len();
-            let ty_path = with_no_trimmed_paths!({
+            let ty_path = with_no_trimmed_paths!(
                 cx.tcx.def_path_str(edef.did())
-            });
+            );
             cx.tcx.emit_spanned_lint(
                 BINDINGS_WITH_VARIANT_NAME,
                 p.hir_id,

compiler/rustc_save_analysis/src/lib.rs

@@ -964,35 +964,33 @@ pub fn process_crate<H: SaveHandler>(
     config: Option<Config>,
     mut handler: H,
 ) {
-    with_no_trimmed_paths!({
-        tcx.dep_graph.with_ignore(|| {
-            info!("Dumping crate {}", cratename);
-
-            // Privacy checking must be done outside of type inference; use a
-            // fallback in case effective visibilities couldn't have been correctly computed.
-            let effective_visibilities = match tcx.sess.compile_status() {
-                Ok(..) => tcx.effective_visibilities(()),
-                Err(..) => tcx.arena.alloc(EffectiveVisibilities::default()),
-            };
+    with_no_trimmed_paths!(tcx.dep_graph.with_ignore(|| {
+        info!("Dumping crate {}", cratename);
+
+        // Privacy checking must be done outside of type inference; use a
+        // fallback in case effective visibilities couldn't have been correctly computed.
+        let effective_visibilities = match tcx.sess.compile_status() {
+            Ok(..) => tcx.effective_visibilities(()),
+            Err(..) => tcx.arena.alloc(EffectiveVisibilities::default()),
+        };
 
-            let save_ctxt = SaveContext {
-                tcx,
-                maybe_typeck_results: None,
-                effective_visibilities: &effective_visibilities,
-                span_utils: SpanUtils::new(&tcx.sess),
-                config: find_config(config),
-                impl_counter: Cell::new(0),
-            };
+        let save_ctxt = SaveContext {
+            tcx,
+            maybe_typeck_results: None,
+            effective_visibilities: &effective_visibilities,
+            span_utils: SpanUtils::new(&tcx.sess),
+            config: find_config(config),
+            impl_counter: Cell::new(0),
+        };
 
-            let mut visitor = DumpVisitor::new(save_ctxt);
+        let mut visitor = DumpVisitor::new(save_ctxt);
 
-            visitor.dump_crate_info(cratename);
-            visitor.dump_compilation_options(input, cratename);
-            visitor.process_crate();
+        visitor.dump_crate_info(cratename);
+        visitor.dump_compilation_options(input, cratename);
+        visitor.process_crate();
 
-            handler.save(&visitor.save_ctxt, &visitor.analysis())
-        })
-    })
+        handler.save(&visitor.save_ctxt, &visitor.analysis())
+    }))
 }
 
 fn find_config(supplied: Option<Config>) -> Config {

compiler/rustc_span/src/hygiene.rs

@@ -1332,11 +1332,9 @@ pub fn decode_syntax_context<D: Decoder, F: FnOnce(&mut D, u32) -> SyntaxContext
 
     let outer_ctxts = &context.remapped_ctxts;
 
-    // Ensure that the lock() temporary is dropped early
-    {
-        if let Some(ctxt) = outer_ctxts.lock().get(raw_id as usize).copied().flatten() {
-            return ctxt;
-        }
+    // the lock() temporary is dropped early
+    if let Some(ctxt) = outer_ctxts.lock().get(raw_id as usize).copied().flatten() {
+        return ctxt;
     }
 
     // Allocate and store SyntaxContext id *before* calling the decoder function,