Rollup of 8 pull requests

compiler/rustc_codegen_llvm/src/asm.rs

@@ -791,12 +791,10 @@ fn reg_to_llvm(reg: InlineAsmRegOrRegClass, layout: Option<&TyAndLayout<'_>>) ->
             } else if let Some(idx) = hexagon_vreg_pair_index(reg) {
                 // LLVM uses `wN` for Hexagon HVX vector pair registers.
                 format!("{{w{}}}", idx)
-            } else if reg == InlineAsmReg::Arm(ArmInlineAsmReg::r14)
-                && llvm_util::get_version() < (23, 0, 0)
-            {
+            } else if reg == InlineAsmReg::Arm(ArmInlineAsmReg::r14) {
                 // FIXME(llvm): LLVM <23 does not recognize `r14` as a register name
                 // in inline assembly.
-                // This workaround can be removed when support for LLVM 22 is dropped.
+                // We can make this branch fallthrough again for LLVM 23+ when https://github.com/llvm/llvm-project/pull/225746 gets released.
                 "{lr}".to_string()
             } else if let InlineAsmReg::Sparc(reg) = reg
                 && let Some(num) = reg.dreg_number()

compiler/rustc_errors/src/lib.rs

@@ -384,7 +384,6 @@ pub enum StashKey {
     /// FRU syntax
     MaybeFruTypo,
     CallAssocMethod,
-    AssociatedTypeSuggestion,
     UndeterminedMacroResolution,
     /// Used by `Parser::maybe_recover_trailing_expr`
     ExprInPat,

compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs

@@ -2,10 +2,7 @@ use rustc_ast::TraitObjectSyntax;
 use rustc_attr_ir::lang_items::LangItem;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
-use rustc_errors::{
-    Applicability, Diag, DiagCtxtHandle, Diagnostic, Level, StashKey, Suggestions,
-    struct_span_code_err,
-};
+use rustc_errors::{Applicability, Diag, DiagCtxtHandle, Diagnostic, Level, struct_span_code_err};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, HirId};
@@ -17,6 +14,7 @@ use rustc_middle::ty::{
 };
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::{ErrorGuaranteed, Span};
+use rustc_trait_selection::diagnostics::AssocTypeWithSameName;
 use rustc_trait_selection::error_reporting::traits::report_dyn_incompatibility;
 use rustc_trait_selection::error_reporting::traits::suggestions::NextTypeParamName;
 use rustc_trait_selection::traits;
@@ -655,15 +653,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 poly_trait_ref.trait_ref.trait_def_id(),
                 &mut diag,
             );
-            // In case there is an associated type with the same name
-            // Add the suggestion to this error
-            if let Some(mut sugg) =
-                self.dcx().steal_non_err(span, StashKey::AssociatedTypeSuggestion)
-                && let Suggestions::Enabled(ref mut s1) = diag.suggestions
-                && let Suggestions::Enabled(ref mut s2) = sugg.suggestions
+            // If there is an associated type with the same name, add the suggestion to this error.
+            if self
+                .tcx()
+                .resolutions(())
+                .paths_matching_assoc_types
+                .contains(&span.with_parent(None))
             {
-                s1.append(s2);
-                sugg.cancel();
+                diag.subdiagnostic(AssocTypeWithSameName { span: span.shrink_to_lo() });
             }
             Some(diag.emit_err())
         } else {

compiler/rustc_lint/src/diagnostics.rs

@@ -1040,9 +1040,10 @@ pub(crate) struct ForgetCopyDiag<'a> {
 
 #[derive(Diagnostic)]
 #[diag(
-    "calls to `std::mem::drop` with `std::mem::ManuallyDrop` instead of the inner value does nothing"
+    "calls to `{$krate}::mem::drop` with `{$krate}::mem::ManuallyDrop` instead of the inner value does nothing"
 )]
 pub(crate) struct UndroppedManuallyDropsDiag<'a> {
+    pub krate: &'static str,
     pub arg_ty: Ty<'a>,
     #[label("argument has type `{$arg_ty}`")]
     pub label: Span,
@@ -1052,21 +1053,23 @@ pub(crate) struct UndroppedManuallyDropsDiag<'a> {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    "use `std::mem::ManuallyDrop::into_inner` to get the inner value",
+    "use `{$krate}::mem::ManuallyDrop::into_inner` to get the inner value",
     applicability = "machine-applicable"
 )]
 pub(crate) struct UndroppedManuallyDropsSuggestion {
-    #[suggestion_part(code = "std::mem::ManuallyDrop::into_inner(")]
+    pub krate: &'static str,
+    #[suggestion_part(code = "{krate}::mem::ManuallyDrop::into_inner(")]
     pub start_span: Span,
     #[suggestion_part(code = ")")]
     pub end_span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(
-    "calls to `drop_in_place` with a pointer to a `std::mem::ManuallyDrop` instead of the inner value does nothing"
+    "calls to `drop_in_place` with a pointer to a `{$krate}::mem::ManuallyDrop` instead of the inner value does nothing"
 )]
 pub(crate) struct UndroppedManuallyDropsInPlaceDiag<'a> {
+    pub krate: &'static str,
     pub arg_ty: Ty<'a>,
     #[label("argument has type `{$arg_ty}`")]
     pub label: Span,
@@ -1076,11 +1079,12 @@ pub(crate) struct UndroppedManuallyDropsInPlaceDiag<'a> {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    "use `std::mem::ManuallyDrop::drop` to drop the inner value",
+    "use `{$krate}::mem::ManuallyDrop::drop` to drop the inner value",
     applicability = "maybe-incorrect"
 )]
 pub(crate) struct UndroppedManuallyDropsInPlaceSuggestion {
-    #[suggestion_part(code = "std::mem::ManuallyDrop::drop(&mut *")]
+    pub krate: &'static str,
+    #[suggestion_part(code = "{krate}::mem::ManuallyDrop::drop(&mut *")]
     pub start_span: Span,
     #[suggestion_part(code = ")")]
     pub end_span: Span,
@@ -2074,44 +2078,53 @@ impl<'a> Diagnostic<'a> for DropGlue<'_> {
 #[note(
     "exposed provenance semantics can be used to create a pointer based on some previously exposed provenance"
 )]
-#[help(
-    "if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`"
-)]
 #[help(
     "for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>"
 )]
 #[help(
     "for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>"
 )]
 pub(crate) struct IntegerToPtrTransmutes<'tcx> {
+    #[subdiagnostic]
+    pub without_prov: Option<IntegerToPtrWithoutProvHelp>,
     #[subdiagnostic]
     pub suggestion: Option<IntegerToPtrTransmutesSuggestion<'tcx>>,
 }
 
+#[derive(Subdiagnostic)]
+#[help(
+    "if you truly mean to create a pointer without provenance, use `{$krate}::ptr::without_provenance_mut`"
+)]
+pub(crate) struct IntegerToPtrWithoutProvHelp {
+    pub krate: &'static str,
+}
+
 #[derive(Subdiagnostic)]
 pub(crate) enum IntegerToPtrTransmutesSuggestion<'tcx> {
     #[multipart_suggestion(
-        "use `std::ptr::with_exposed_provenance{$suffix}` instead to use a previously exposed provenance",
+        "use `{$krate}::ptr::with_exposed_provenance{$suffix}` instead to use a previously exposed provenance",
         applicability = "machine-applicable",
         style = "verbose"
     )]
     ToPtr {
+        krate: &'static str,
         dst: Ty<'tcx>,
         suffix: &'static str,
-        #[suggestion_part(code = "std::ptr::with_exposed_provenance{suffix}::<{dst}>(")]
+        #[suggestion_part(code = "{krate}::ptr::with_exposed_provenance{suffix}::<{dst}>(")]
         start_call: Span,
     },
     #[multipart_suggestion(
-        "use `std::ptr::with_exposed_provenance{$suffix}` instead to use a previously exposed provenance",
+        "use `{$krate}::ptr::with_exposed_provenance{$suffix}` instead to use a previously exposed provenance",
         applicability = "machine-applicable",
         style = "verbose"
     )]
     ToRef {
+        krate: &'static str,
         dst: Ty<'tcx>,
         suffix: &'static str,
         ref_mutbl: &'static str,
         #[suggestion_part(
-            code = "&{ref_mutbl}*std::ptr::with_exposed_provenance{suffix}::<{dst}>("
+            code = "&{ref_mutbl}*{krate}::ptr::with_exposed_provenance{suffix}::<{dst}>("
         )]
         start_call: Span,
     },
@@ -2348,25 +2361,30 @@ pub(crate) enum AmbiguousWidePointerComparisons<'a> {
     #[diag(
         "ambiguous wide pointer comparison, the comparison includes metadata which may not be expected"
     )]
-    #[help("use explicit `std::ptr::eq` method to compare metadata and addresses")]
-    #[help("use `std::ptr::addr_eq` or untyped pointers to only compare their addresses")]
-    Spanless,
+    #[help("use explicit `{$krate}::ptr::eq` method to compare metadata and addresses")]
+    #[help("use `{$krate}::ptr::addr_eq` or untyped pointers to only compare their addresses")]
+    Spanless { krate: &'static str },
+    #[diag(
+        "ambiguous wide pointer comparison, the comparison includes metadata which may not be expected"
+    )]
+    Warn,
 }
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    "use explicit `std::ptr::eq` method to compare metadata and addresses",
+    "use explicit `{$krate}::ptr::eq` method to compare metadata and addresses",
     style = "verbose",
     // FIXME(#53934): make machine-applicable again
     applicability = "maybe-incorrect"
 )]
 pub(crate) struct AmbiguousWidePointerComparisonsAddrMetadataSuggestion<'a> {
+    pub krate: &'static str,
     pub ne: &'a str,
     pub deref_left: &'a str,
     pub deref_right: &'a str,
     pub l_modifiers: &'a str,
     pub r_modifiers: &'a str,
-    #[suggestion_part(code = "{ne}std::ptr::eq({deref_left}")]
+    #[suggestion_part(code = "{ne}{krate}::ptr::eq({deref_left}")]
     pub left: Span,
     #[suggestion_part(code = "{l_modifiers}, {deref_right}")]
     pub middle: Span,
@@ -2376,18 +2394,19 @@ pub(crate) struct AmbiguousWidePointerComparisonsAddrMetadataSuggestion<'a> {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    "use `std::ptr::addr_eq` or untyped pointers to only compare their addresses",
+    "use `{$krate}::ptr::addr_eq` or untyped pointers to only compare their addresses",
     style = "verbose",
     // FIXME(#53934): make machine-applicable again
     applicability = "maybe-incorrect"
 )]
 pub(crate) struct AmbiguousWidePointerComparisonsAddrSuggestion<'a> {
+    pub(crate) krate: &'static str,
     pub(crate) ne: &'a str,
     pub(crate) deref_left: &'a str,
     pub(crate) deref_right: &'a str,
     pub(crate) l_modifiers: &'a str,
     pub(crate) r_modifiers: &'a str,
-    #[suggestion_part(code = "{ne}std::ptr::addr_eq({deref_left}")]
+    #[suggestion_part(code = "{ne}{krate}::ptr::addr_eq({deref_left}")]
     pub(crate) left: Span,
     #[suggestion_part(code = "{l_modifiers}, {deref_right}")]
     pub(crate) middle: Span,
@@ -2470,32 +2489,34 @@ pub(crate) enum UnpredictableFunctionPointerComparisons<'a, 'tcx> {
 #[derive(Subdiagnostic)]
 pub(crate) enum UnpredictableFunctionPointerComparisonsSuggestion<'a, 'tcx> {
     #[multipart_suggestion(
-        "refactor your code, or use `std::ptr::fn_addr_eq` to suppress the lint",
+        "refactor your code, or use `{$krate}::ptr::fn_addr_eq` to suppress the lint",
         style = "verbose",
         applicability = "maybe-incorrect"
     )]
     FnAddrEq {
+        krate: &'static str,
         ne: &'a str,
         deref_left: &'a str,
         deref_right: &'a str,
-        #[suggestion_part(code = "{ne}std::ptr::fn_addr_eq({deref_left}")]
+        #[suggestion_part(code = "{ne}{krate}::ptr::fn_addr_eq({deref_left}")]
         left: Span,
         #[suggestion_part(code = ", {deref_right}")]
         middle: Span,
         #[suggestion_part(code = ")")]
         right: Span,
     },
     #[multipart_suggestion(
-        "refactor your code, or use `std::ptr::fn_addr_eq` to suppress the lint",
+        "refactor your code, or use `{$krate}::ptr::fn_addr_eq` to suppress the lint",
         style = "verbose",
         applicability = "maybe-incorrect"
     )]
     FnAddrEqWithCast {
+        krate: &'static str,
         ne: &'a str,
         deref_left: &'a str,
         deref_right: &'a str,
         fn_sig: rustc_middle::ty::PolyFnSig<'tcx>,
-        #[suggestion_part(code = "{ne}std::ptr::fn_addr_eq({deref_left}")]
+        #[suggestion_part(code = "{ne}{krate}::ptr::fn_addr_eq({deref_left}")]
         left: Span,
         #[suggestion_part(code = ", {deref_right}")]
         middle: Span,

compiler/rustc_lint/src/drop_forget_useless.rs

@@ -9,6 +9,7 @@ use crate::diagnostics::{
     UndroppedManuallyDropsInPlaceSuggestion, UndroppedManuallyDropsSuggestion,
     UseLetUnderscoreIgnoreSuggestion,
 };
+use crate::utils::std_or_core;
 use crate::{LateContext, LateLintPass, LintContext};
 
 declare_lint! {
@@ -252,15 +253,18 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetUseless {
                 }
                 sym::mem_drop
                     if let ty::Adt(adt, _) = arg_ty.kind()
-                        && adt.is_manually_drop() =>
+                        && adt.is_manually_drop()
+                        && let Some(krate) = std_or_core(cx) =>
                 {
                     cx.emit_span_lint(
                         UNDROPPED_MANUALLY_DROPS,
                         expr.span,
                         UndroppedManuallyDropsDiag {
+                            krate,
                             arg_ty,
                             label: arg.span,
                             suggestion: UndroppedManuallyDropsSuggestion {
+                                krate,
                                 start_span: arg.span.shrink_to_lo(),
                                 end_span: arg.span.shrink_to_hi(),
                             },
@@ -270,15 +274,18 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetUseless {
                 sym::ptr_drop_in_place | sym::ptr_drop_in_place_self
                     if let &ty::RawPtr(inner_ty, _mutbl) = arg_ty.kind()
                         && let ty::Adt(adt, _) = inner_ty.kind()
-                        && adt.is_manually_drop() =>
+                        && adt.is_manually_drop()
+                        && let Some(krate) = std_or_core(cx) =>
                 {
                     cx.emit_span_lint(
                         UNDROPPED_MANUALLY_DROPS,
                         expr.span,
                         UndroppedManuallyDropsInPlaceDiag {
+                            krate,
                             arg_ty,
                             label: arg.span,
                             suggestion: UndroppedManuallyDropsInPlaceSuggestion {
+                                krate,
                                 start_span: expr.span.shrink_to_lo().until(arg.span.shrink_to_lo()),
                                 end_span: arg.span.shrink_to_hi().until(expr.span.shrink_to_hi()),
                             },

compiler/rustc_lint/src/lib.rs

@@ -148,6 +148,7 @@ pub use rustc_lint_defs::{
     Applicability, FutureIncompatibleInfo, Lint, LintId, LintPass, LintVec, declare_lint,
     declare_lint_pass, declare_tool_lint, impl_lint_pass,
 };
+pub use utils::std_or_core;
 
 pub fn provide(providers: &mut Providers) {
     levels::provide(providers);

compiler/rustc_lint/src/non_fmt_panic.rs

@@ -143,7 +143,14 @@ impl<'a, 'b, 'tcx> Diagnostic<'a> for PanicMessageNotLiteral<'b, 'tcx> {
                     .get_diagnostic_item(sym::Debug)
                     .is_some_and(|t| infcx.type_implements_trait(t, [ty], param_env).may_apply());
 
-            let suggest_panic_any = !is_str && panic == Some(sym::std_panic_macro);
+            let suggest_panic_any = !is_str
+                && panic == Some(sym::std_panic_macro)
+                && cx
+                    .tcx
+                    .all_diagnostic_items(())
+                    .name_to_id
+                    .keys()
+                    .any(|name| name.as_str() == "panic_any");
 
             let fmt_applicability = if suggest_panic_any {
                 // If we can use panic_any, use that as the MachineApplicable suggestion.