Rollup of 13 pull requests

compiler/rustc_ast/src/visit.rs

@@ -757,9 +757,11 @@ macro_rules! common_visitor_and_walkers {
             ) -> V::Result;
         }
 
-        // this is only used by the MutVisitor. We include this symmetry here to make writing other functions easier
+        // This is only used by the MutVisitor. We include this symmetry here to make writing other
+        // functions easier.
         $(${ignore($lt)}
-            #[expect(unused, rustc::pass_by_value)]
+            #[cfg_attr(not(bootstrap), expect(unused, rustc::disallowed_pass_by_ref))]
+            #[cfg_attr(bootstrap, expect(unused, rustc::pass_by_value))]
             #[inline]
         )?
         fn visit_span<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, span: &$($lt)? $($mut)? Span) -> V::Result {

compiler/rustc_ast_lowering/src/lib.rs

@@ -2521,16 +2521,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             ExprKind::Block(block, _) => {
                 if let [stmt] = block.stmts.as_slice()
                     && let StmtKind::Expr(expr) = &stmt.kind
-                    && matches!(
-                        expr.kind,
-                        ExprKind::Block(..)
-                            | ExprKind::Path(..)
-                            | ExprKind::Struct(..)
-                            | ExprKind::Call(..)
-                            | ExprKind::Tup(..)
-                            | ExprKind::Array(..)
-                            | ExprKind::ConstBlock(..)
-                    )
                 {
                     return self.lower_expr_to_const_arg_direct(expr);
                 }
@@ -2553,6 +2543,17 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 let span = expr.span;
                 let literal = self.lower_lit(literal, span);
 
+                if !matches!(literal.node, LitKind::Int(..)) {
+                    let err =
+                        self.dcx().struct_span_err(expr.span, "negated literal must be an integer");
+
+                    return ConstArg {
+                        hir_id: self.next_id(),
+                        kind: hir::ConstArgKind::Error(err.emit()),
+                        span,
+                    };
+                }
+
                 ConstArg {
                     hir_id: self.lower_node_id(expr.id),
                     kind: hir::ConstArgKind::Literal { lit: literal.node, negated: true },

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -9,7 +9,7 @@ use rustc_hir::{
 
 use super::prelude::*;
 use super::util::parse_version;
-use crate::session_diagnostics::{self};
+use crate::session_diagnostics;
 
 macro_rules! reject_outside_std {
     ($cx: ident) => {

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -1,6 +1,6 @@
 use std::num::IntErrorKind;
 
-use rustc_ast::{self as ast};
+use rustc_ast as ast;
 use rustc_errors::codes::*;
 use rustc_errors::{
     Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level,

compiler/rustc_builtin_macros/src/cmdline_attrs.rs

@@ -1,6 +1,6 @@
 //! Attributes injected into the crate root from command line using `-Z crate-attr`.
 
-use rustc_ast::{self as ast};
+use rustc_ast as ast;
 use rustc_errors::Diag;
 use rustc_parse::parser::attr::InnerAttrPolicy;
 use rustc_parse::{parse_in, source_str_to_stream};

compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs

@@ -26,15 +26,14 @@ pub(crate) fn expand_deriving_eq(
         additional_bounds: Vec::new(),
         supports_unions: true,
         methods: vec![MethodDef {
-            name: sym::assert_receiver_is_total_eq,
+            name: sym::assert_fields_are_eq,
             generics: Bounds::empty(),
             explicit_self: true,
             nonself_args: vec![],
             ret_ty: Unit,
             attributes: thin_vec![
-                cx.attr_word(sym::inline, span),
                 cx.attr_nested_word(sym::doc, sym::hidden, span),
-                cx.attr_nested_word(sym::coverage, sym::off, span)
+                cx.attr_nested_word(sym::coverage, sym::off, span),
             ],
             fieldless_variants_strategy: FieldlessVariantsStrategy::Unify,
             combine_substructure: combine_substructure(Box::new(|a, b, c| {

compiler/rustc_codegen_gcc/src/builder.rs

@@ -1655,6 +1655,10 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         unimplemented!();
     }
 
+    fn get_funclet_cleanuppad(&self, _funclet: &Funclet) -> RValue<'gcc> {
+        unimplemented!();
+    }
+
     // Atomic Operations
     fn atomic_cmpxchg(
         &mut self,

compiler/rustc_codegen_llvm/src/builder.rs

@@ -1296,6 +1296,10 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         ret
     }
 
+    fn get_funclet_cleanuppad(&self, funclet: &Funclet<'ll>) -> &'ll Value {
+        funclet.cleanuppad()
+    }
+
     // Atomic Operations
     fn atomic_cmpxchg(
         &mut self,

compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs

@@ -21,8 +21,8 @@ use crate::debuginfo::metadata::{
     size_and_align_of, type_di_node, unknown_file_metadata, visibility_di_flags,
 };
 use crate::debuginfo::utils::DIB;
+use crate::llvm;
 use crate::llvm::debuginfo::{DIFile, DIFlags, DIType};
-use crate::llvm::{self};
 
 // The names of the associated constants in each variant wrapper struct.
 // These have to match up with the names being used in `intrinsic.natvis`.

compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs

@@ -21,8 +21,8 @@ use crate::debuginfo::metadata::{
     file_metadata_from_def_id, type_di_node, unknown_file_metadata,
 };
 use crate::debuginfo::utils::{DIB, create_DIArray, get_namespace_for_item};
+use crate::llvm;
 use crate::llvm::debuginfo::{DIFlags, DIType};
-use crate::llvm::{self};
 
 mod cpp_like;
 mod native;

compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/native.rs

@@ -5,9 +5,8 @@ use rustc_abi::{Size, TagEncoding, VariantIdx, Variants};
 use rustc_codegen_ssa::debuginfo::type_names::compute_debuginfo_type_name;
 use rustc_codegen_ssa::debuginfo::{tag_base_type, wants_c_like_enum_debuginfo};
 use rustc_codegen_ssa::traits::{ConstCodegenMethods, MiscCodegenMethods};
-use rustc_middle::bug;
 use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
-use rustc_middle::ty::{self};
+use rustc_middle::{bug, ty};
 use smallvec::smallvec;
 
 use crate::common::{AsCCharPtr, CodegenCx};
@@ -18,8 +17,8 @@ use crate::debuginfo::metadata::{
     unknown_file_metadata, visibility_di_flags,
 };
 use crate::debuginfo::utils::{DIB, create_DIArray, get_namespace_for_item};
+use crate::llvm;
 use crate::llvm::debuginfo::{DIFile, DIFlags, DIType};
-use crate::llvm::{self};
 
 /// Build the debuginfo node for an enum type. The listing below shows how such a
 /// type looks like at the LLVM IR/DWARF level. It is a `DW_TAG_structure_type`

compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs

@@ -12,8 +12,8 @@ use rustc_middle::ty::{self, ExistentialTraitRef, Ty, TyCtxt};
 use super::{DefinitionLocation, SmallVec, UNKNOWN_LINE_NUMBER, unknown_file_metadata};
 use crate::common::CodegenCx;
 use crate::debuginfo::utils::{DIB, create_DIArray, debug_context};
+use crate::llvm;
 use crate::llvm::debuginfo::{DIFlags, DIScope, DIType};
-use crate::llvm::{self};
 
 mod private {
     use rustc_macros::HashStable;

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -13,8 +13,8 @@ use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
 use rustc_codegen_ssa::mir::place::{PlaceRef, PlaceValue};
 use rustc_codegen_ssa::traits::*;
 use rustc_data_structures::assert_matches;
+use rustc_hir as hir;
 use rustc_hir::def_id::LOCAL_CRATE;
-use rustc_hir::{self as hir};
 use rustc_middle::mir::BinOp;
 use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, HasTypingEnv, LayoutOf};
 use rustc_middle::ty::offload_meta::OffloadMetadata;