Patch the compiler

Some of the changes may be unnecessary / can be done in the macro def, rather
than usage. However: I do not care anymore.

Author: WaffleLapkin

compiler/rustc_codegen_ssa/src/back/metadata.rs

@@ -174,7 +174,7 @@ pub(super) fn get_metadata_xcoff<'a>(path: &Path, data: &'a [u8]) -> Result<&'a
         return Ok(&info_data[offset..(offset + len)]);
     } else {
         return Err(format!("Unable to find symbol {AIX_METADATA_SYMBOL_NAME}"));
-    };
+    }
 }
 
 pub(crate) fn create_object_file(sess: &Session) -> Option<write::Object<'static>> {

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -275,9 +275,7 @@ pub fn eval_to_const_value_raw_provider<'tcx>(
     // Catch such calls and evaluate them instead of trying to load a constant's MIR.
     if let ty::InstanceDef::Intrinsic(def_id) = key.value.instance.def {
         let ty = key.value.instance.ty(tcx, key.param_env);
-        let ty::FnDef(_, args) = ty.kind() else {
-            bug!("intrinsic with type {:?}", ty);
-        };
+        let ty::FnDef(_, args) = ty.kind() else { bug!("intrinsic with type {:?}", ty) };
         return eval_nullary_intrinsic(tcx, key.param_env, def_id, args).map_err(|error| {
             let span = tcx.def_span(def_id);
 

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -476,7 +476,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
                             Some(CtfeValidationMode::Const { .. }) => {
                                 // We can't recursively validate `extern static`, so we better reject them.
                                 if self.ecx.tcx.is_foreign_item(did) {
-                                    throw_validation_failure!(self.path, ConstRefToExtern);
+                                    throw_validation_failure!(self.path, ConstRefToExtern)
                                 }
                             }
                             None => {}
@@ -518,14 +518,14 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
                     if ptr_expected_mutbl == Mutability::Mut
                         && alloc_actual_mutbl == Mutability::Not
                     {
-                        throw_validation_failure!(self.path, MutableRefToImmutable);
+                        throw_validation_failure!(self.path, MutableRefToImmutable)
                     }
                     // In a const, everything must be completely immutable.
                     if matches!(self.ctfe_mode, Some(CtfeValidationMode::Const { .. })) {
                         if ptr_expected_mutbl == Mutability::Mut
                             || alloc_actual_mutbl == Mutability::Mut
                         {
-                            throw_validation_failure!(self.path, ConstRefToMutable);
+                            throw_validation_failure!(self.path, ConstRefToMutable)
                         }
                     }
                 }
@@ -621,7 +621,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
                 } else {
                     // Otherwise (for standalone Miri), we have to still check it to be non-null.
                     if self.ecx.scalar_may_be_null(value)? {
-                        throw_validation_failure!(self.path, NullFnPtr);
+                        throw_validation_failure!(self.path, NullFnPtr)
                     }
                 }
                 Ok(true)
@@ -786,7 +786,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
         if self.ctfe_mode.is_some_and(|c| !c.allow_immutable_unsafe_cell()) {
             if !op.layout.is_zst() && !op.layout.ty.is_freeze(*self.ecx.tcx, self.ecx.param_env) {
                 if !self.in_mutable_memory(op) {
-                    throw_validation_failure!(self.path, UnsafeCellInImmutable);
+                    throw_validation_failure!(self.path, UnsafeCellInImmutable)
                 }
             }
         }
@@ -819,7 +819,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
                 && def.is_unsafe_cell()
             {
                 if !self.in_mutable_memory(op) {
-                    throw_validation_failure!(self.path, UnsafeCellInImmutable);
+                    throw_validation_failure!(self.path, UnsafeCellInImmutable)
                 }
             }
         }
@@ -934,7 +934,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
         match op.layout.abi {
             Abi::Uninhabited => {
                 let ty = op.layout.ty;
-                throw_validation_failure!(self.path, UninhabitedVal { ty });
+                throw_validation_failure!(self.path, UninhabitedVal { ty })
             }
             Abi::Scalar(scalar_layout) => {
                 if !scalar_layout.is_uninit_valid() {

compiler/rustc_driver_impl/src/lib.rs

@@ -642,21 +642,19 @@ fn process_rlink(sess: &Session, compiler: &interface::Compiler) {
         });
         let (codegen_results, outputs) = match CodegenResults::deserialize_rlink(sess, rlink_data) {
             Ok((codegen, outputs)) => (codegen, outputs),
-            Err(err) => {
-                match err {
-                    CodegenErrors::WrongFileType => dcx.emit_fatal(RLinkWrongFileType),
-                    CodegenErrors::EmptyVersionNumber => dcx.emit_fatal(RLinkEmptyVersionNumber),
-                    CodegenErrors::EncodingVersionMismatch { version_array, rlink_version } => sess
-                        .dcx()
-                        .emit_fatal(RLinkEncodingVersionMismatch { version_array, rlink_version }),
-                    CodegenErrors::RustcVersionMismatch { rustc_version } => {
-                        dcx.emit_fatal(RLinkRustcVersionMismatch {
-                            rustc_version,
-                            current_version: sess.cfg_version,
-                        })
-                    }
-                };
-            }
+            Err(err) => match err {
+                CodegenErrors::WrongFileType => dcx.emit_fatal(RLinkWrongFileType),
+                CodegenErrors::EmptyVersionNumber => dcx.emit_fatal(RLinkEmptyVersionNumber),
+                CodegenErrors::EncodingVersionMismatch { version_array, rlink_version } => sess
+                    .dcx()
+                    .emit_fatal(RLinkEncodingVersionMismatch { version_array, rlink_version }),
+                CodegenErrors::RustcVersionMismatch { rustc_version } => {
+                    dcx.emit_fatal(RLinkRustcVersionMismatch {
+                        rustc_version,
+                        current_version: sess.cfg_version,
+                    })
+                }
+            },
         };
         if compiler.codegen_backend.link(sess, codegen_results, &outputs).is_err() {
             FatalError.raise();

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -125,9 +125,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
                             .filter(|arg| arg.is_ty_or_const())
                             .position(|arg| arg.hir_id() == hir_id)
                     })
-                    .unwrap_or_else(|| {
-                        bug!("no arg matching AnonConst in segment");
-                    });
+                    .unwrap_or_else(|| bug!("no arg matching AnonConst in segment"));
 
                 (generics, arg_index)
             } else {
@@ -164,9 +162,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
                         .filter(|arg| arg.is_ty_or_const())
                         .position(|arg| arg.hir_id() == hir_id)
                 })
-                .unwrap_or_else(|| {
-                    bug!("no arg matching AnonConst in segment");
-                });
+                .unwrap_or_else(|| bug!("no arg matching AnonConst in segment"));
 
             (tcx.generics_of(type_dependent_def), idx)
         }

compiler/rustc_hir_typeck/src/lib.rs

@@ -344,9 +344,8 @@ pub struct EnclosingBreakables<'tcx> {
 
 impl<'tcx> EnclosingBreakables<'tcx> {
     fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
-        self.opt_find_breakable(target_id).unwrap_or_else(|| {
-            bug!("could not find enclosing breakable with id {}", target_id);
-        })
+        self.opt_find_breakable(target_id)
+            .unwrap_or_else(|| bug!("could not find enclosing breakable with id {}", target_id))
     }
 
     fn opt_find_breakable(&mut self, target_id: hir::HirId) -> Option<&mut BreakableCtxt<'tcx>> {

compiler/rustc_lint/src/types.rs

@@ -1118,7 +1118,7 @@ pub(crate) fn repr_nullable_ptr<'tcx>(
                 WrappingRange { start, end } => {
                     unreachable!("Unhandled start and end range: ({}, {})", start, end)
                 }
-            };
+            }
         }
     }
     None

compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs

@@ -152,7 +152,7 @@ impl DiagnosticDeriveVariantBuilder {
 
         if let SubdiagnosticKind::MultipartSuggestion { .. } = subdiag.kind {
             throw_invalid_attr!(attr, |diag| diag
-                .help("consider creating a `Subdiagnostic` instead"));
+                .help("consider creating a `Subdiagnostic` instead"))
         }
 
         let slug = subdiag.slug.unwrap_or_else(|| match subdiag.kind {
@@ -238,7 +238,7 @@ impl DiagnosticDeriveVariantBuilder {
             }
             SubdiagnosticKind::Label | SubdiagnosticKind::Suggestion { .. } => {
                 throw_invalid_attr!(attr, |diag| diag
-                    .help("`#[label]` and `#[suggestion]` can only be applied to fields"));
+                    .help("`#[label]` and `#[suggestion]` can only be applied to fields"))
             }
             SubdiagnosticKind::MultipartSuggestion { .. } => unreachable!(),
         }
@@ -373,7 +373,7 @@ impl DiagnosticDeriveVariantBuilder {
                         .note("`#[suggestion(...)]` applied to `Vec` field is ambiguous")
                         .help("to show a suggestion consisting of multiple parts, use a `Subdiagnostic` annotated with `#[multipart_suggestion(...)]`")
                         .help("to show a variable set of suggestions, use a `Vec` of `Subdiagnostic`s annotated with `#[suggestion(...)]`")
-                    });
+                    })
                 }
 
                 let (span_field, mut applicability) = self.span_and_applicability_of_ty(info)?;
@@ -458,15 +458,13 @@ impl DiagnosticDeriveVariantBuilder {
                     } else if type_matches_path(elem, &["rustc_errors", "Applicability"]) {
                         applicability_idx.set_once(syn::Index::from(idx), elem.span().unwrap());
                     } else {
-                        type_err(&elem.span())?;
+                        type_err(&elem.span())?
                     }
                 }
 
-                let Some((span_idx, _)) = span_idx else {
-                    type_err(&tup.span())?;
-                };
+                let Some((span_idx, _)) = span_idx else { type_err(&tup.span())? };
                 let Some((applicability_idx, applicability_span)) = applicability_idx else {
-                    type_err(&tup.span())?;
+                    type_err(&tup.span())?
                 };
                 let binding = &info.binding.binding;
                 let span = quote!(#binding.#span_idx);

compiler/rustc_macros/src/diagnostics/subdiagnostic.rs

@@ -205,7 +205,7 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
                     format!(
                         "diagnostic slug must be first argument of a `#[{name}(...)]` attribute"
                     )
-                );
+                )
             };
 
             kind_slugs.push((kind, slug, no_span));
@@ -327,7 +327,7 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
                             } else {
                                 diag
                             }
-                        });
+                        })
                     }
 
                     self.span_field.set_once(binding, span);
@@ -489,7 +489,7 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
                 throw_span_err!(
                     self.variant.ast().ident.span().unwrap(),
                     "subdiagnostic kind not specified"
-                );
+                )
             }
         };
 

compiler/rustc_macros/src/diagnostics/utils.rs

@@ -77,7 +77,7 @@ pub(crate) fn report_type_error(
             },
             ty_name
         )
-    );
+    )
 }
 
 /// Reports an error if the field's type does not match `path`.
@@ -88,7 +88,7 @@ fn report_error_if_not_applied_to_ty(
     ty_name: &str,
 ) -> Result<(), DiagnosticDeriveError> {
     if !type_matches_path(info.ty.inner_type(), path) {
-        report_type_error(attr, ty_name)?;
+        report_type_error(attr, ty_name)?
     }
 
     Ok(())
@@ -115,7 +115,7 @@ pub(crate) fn report_error_if_not_applied_to_span(
     if !type_matches_path(info.ty.inner_type(), &["rustc_span", "Span"])
         && !type_matches_path(info.ty.inner_type(), &["rustc_errors", "MultiSpan"])
     {
-        report_type_error(attr, "`Span` or `MultiSpan`")?;
+        report_type_error(attr, "`Span` or `MultiSpan`")?
     }
 
     Ok(())
@@ -662,7 +662,7 @@ impl SubdiagnosticVariant {
                         applicability: None,
                     }
                 } else {
-                    throw_invalid_attr!(attr);
+                    throw_invalid_attr!(attr)
                 }
             }
         };

compiler/rustc_metadata/src/dependency_format.rs

@@ -374,9 +374,8 @@ fn verify_ok(tcx: TyCtxt<'_>, list: &[Linkage]) {
             }
             panic_runtime = Some((
                 cnum,
-                tcx.required_panic_strategy(cnum).unwrap_or_else(|| {
-                    bug!("cannot determine panic strategy of a panic runtime");
-                }),
+                tcx.required_panic_strategy(cnum)
+                    .unwrap_or_else(|| bug!("cannot determine panic strategy of a panic runtime")),
             ));
         }
     }

compiler/rustc_middle/src/ty/mod.rs

@@ -1598,9 +1598,8 @@ impl<'tcx> TyCtxt<'tcx> {
     ///
     /// [`opt_item_name`]: Self::opt_item_name
     pub fn item_name(self, id: DefId) -> Symbol {
-        self.opt_item_name(id).unwrap_or_else(|| {
-            bug!("item_name: no name for {:?}", self.def_path(id));
-        })
+        self.opt_item_name(id)
+            .unwrap_or_else(|| bug!("item_name: no name for {:?}", self.def_path(id)))
     }
 
     /// Look up the name and span of a definition.

compiler/rustc_middle/src/ty/typeck_results.rs

@@ -518,7 +518,7 @@ fn invalid_hir_id_for_typeck_results(hir_owner: OwnerId, hir_id: hir::HirId) {
             tcx.hir().node_to_string(hir_id),
             hir_owner
         )
-    });
+    })
 }
 
 pub struct LocalTableInContext<'a, V> {

compiler/rustc_mir_transform/src/dataflow_const_prop.rs

@@ -857,4 +857,4 @@ impl<'tcx> Visitor<'tcx> for OperandCollector<'tcx, '_, '_, '_> {
             }
         }
     }
-}
+}

compiler/rustc_mir_transform/src/jump_threading.rs

@@ -546,7 +546,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
                 };
                 if writes_discriminant {
                     let discr = self.ecx.discriminant_for_variant(enum_ty, *variant_index).ok()?;
-                    self.process_immediate(bb, discr_target, discr, state)?;
+                    self.process_immediate(bb, discr_target, discr, state)?
                 }
             }
             // If we expect `lhs ?= true`, we have an opportunity if we assume `lhs == true`.
@@ -557,7 +557,7 @@ impl<'tcx, 'a> TOFinder<'tcx, 'a> {
                 conditions.iter_matches(ScalarInt::TRUE).for_each(register_opportunity);
             }
             StatementKind::Assign(box (lhs_place, rhs)) => {
-                self.process_assign(bb, lhs_place, rhs, state)?;
+                self.process_assign(bb, lhs_place, rhs, state)?
             }
             _ => {}
         }