Auto merge of #155824 - JonathanBrouwer:rollup-phz8QVJ, r=<try>

Rollup of 7 pull requests


try-job: dist-various-1
try-job: test-various
try-job: x86_64-gnu-aux
try-job: x86_64-gnu-llvm-21-3
try-job: x86_64-msvc-1
try-job: aarch64-apple
try-job: x86_64-mingw-1
try-job: i686-msvc-2

Author: bors

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -156,14 +156,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     .collect();
                 generic_args.push((kw::SelfUpper, this.clone()));
 
-                let args = FormatArgs {
-                    this,
-                    // Unused
-                    this_sugared: String::new(),
-                    // Unused
-                    item_context: "",
-                    generic_args,
-                };
+                let args = FormatArgs { this, generic_args, .. };
                 let CustomDiagnostic { message, label, notes, parent_label: _ } =
                     directive.eval(None, &args);
 

compiler/rustc_builtin_macros/src/format.rs

@@ -173,6 +173,16 @@ fn make_format_args(
         style: fmt_style,
         uncooked_symbol: uncooked_fmt_str,
     } = {
+        // Extract snippet so that we can check cases `{}`, `{:?}` and `{:#?}` and emit help for
+        // them later.
+        let snippet = if let ExprKind::Block(b, None) = &efmt.kind
+            && b.stmts.len() <= 1
+        {
+            Some(ecx.sess.source_map().span_to_snippet(unexpanded_fmt_span))
+        } else {
+            None
+        };
+
         let ExpandResult::Ready(mac) = expr_to_spanned_string(ecx, efmt.clone(), msg) else {
             return ExpandResult::Retry(());
         };
@@ -222,12 +232,26 @@ fn make_format_args(
                                     });
                                 }
                                 sugg_fmt = sugg_fmt.trim_end().to_string();
-                                err.span_suggestion(
+                                err.span_suggestion_verbose(
                                     unexpanded_fmt_span.shrink_to_lo(),
                                     "you might be missing a string literal to format with",
                                     format!("\"{sugg_fmt}\", "),
                                     Applicability::MaybeIncorrect,
                                 );
+
+                                if let Some(Ok(snippet)) = snippet.as_ref() {
+                                    match snippet.as_str() {
+                                        "{}" | "{:?}" | "{:#?}" => {
+                                            err.span_suggestion_verbose(
+                                                unexpanded_fmt_span,
+                                                format!("you might want to enclose `{snippet}` with `\"\"`"),
+                                                format!("\"{snippet}\""),
+                                                Applicability::MaybeIncorrect,
+                                            );
+                                        }
+                                        _ => {}
+                                    };
+                                }
                             }
                         }
                         err.emit()

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -1529,6 +1529,12 @@ fn codegen_regular_intrinsic_call<'tcx>(
             fx.bcx.set_cold_block(fx.bcx.current_block().unwrap());
         }
 
+        sym::return_address => {
+            let val = fx.bcx.ins().get_return_address(fx.pointer_type);
+            let val = CValue::by_val(val, ret.layout());
+            ret.write_cvalue(fx, val);
+        }
+
         // Unimplemented intrinsics must have a fallback body. The fallback body is obtained
         // by converting the `InstanceKind::Intrinsic` to an `InstanceKind::Item`.
         _ => {

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -838,6 +838,22 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 }
             }
 
+            sym::return_address => {
+                match self.sess().target.arch {
+                    // Expand this list as needed
+                    | Arch::Wasm32
+                    | Arch::Wasm64 => {
+                        let ty = self.type_ptr();
+                        self.const_null(ty)
+                    }
+                    _ => {
+                        let ty = self.type_ix(32);
+                        let val = self.const_int(ty, 0);
+                        self.call_intrinsic("llvm.returnaddress", &[], &[val])
+                    }
+                }
+            }
+
             _ => {
                 debug!("unknown intrinsic '{}' -- falling back to default body", name);
                 // Call the fallback body instead of generating the intrinsic code

compiler/rustc_codegen_ssa/src/mir/intrinsic.rs

@@ -121,7 +121,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 | sym::contract_checks
                 | sym::atomic_fence
                 | sym::atomic_singlethreadfence
-                | sym::caller_location => {}
+                | sym::caller_location
+                | sym::return_address => {}
                 _ => {
                     span_bug!(
                         span,

compiler/rustc_expand/src/lib.rs

@@ -1,6 +1,7 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![feature(associated_type_defaults)]
+#![feature(default_field_values)]
 #![feature(macro_metavar_expr)]
 #![feature(proc_macro_diagnostic)]
 #![feature(proc_macro_internals)]

compiler/rustc_expand/src/mbe/diagnostics.rs

@@ -77,19 +77,8 @@ pub(super) fn failed_to_match_macro(
     let CustomDiagnostic {
         message: custom_message, label: custom_label, notes: custom_notes, ..
     } = {
-        let macro_name = name.to_string();
         on_unmatch_args
-            .map(|directive| {
-                directive.eval(
-                    None,
-                    &FormatArgs {
-                        this: macro_name.clone(),
-                        this_sugared: macro_name,
-                        item_context: "macro invocation",
-                        generic_args: Vec::new(),
-                    },
-                )
-            })
+            .map(|directive| directive.eval(None, &FormatArgs { this: name.to_string(), .. }))
             .unwrap_or_default()
     };
 

compiler/rustc_hir/src/attrs/diagnostic.rs

@@ -218,10 +218,11 @@ impl FormatString {
 /// ```
 #[derive(Debug)]
 pub struct FormatArgs {
+    /// The name of the item the attribute is on.
     pub this: String,
-    pub this_sugared: String,
-    pub item_context: &'static str,
-    pub generic_args: Vec<(Symbol, String)>,
+    pub this_sugared: String = String::new(),
+    pub item_context: &'static str = "",
+    pub generic_args: Vec<(Symbol, String)> = Vec::new(),
 }
 
 #[derive(Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]

compiler/rustc_hir/src/lib.rs

@@ -7,6 +7,7 @@
 #![feature(closure_track_caller)]
 #![feature(const_default)]
 #![feature(const_trait_impl)]
+#![feature(default_field_values)]
 #![feature(derive_const)]
 #![feature(exhaustive_patterns)]
 #![feature(never_type)]

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -180,6 +180,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::ptr_guaranteed_cmp
         | sym::ptr_mask
         | sym::ptr_metadata
+        | sym::return_address
         | sym::rotate_left
         | sym::rotate_right
         | sym::round_ties_even_f16
@@ -803,6 +804,8 @@ pub(crate) fn check_intrinsic_type(
         | sym::atomic_xor => (2, 1, vec![Ty::new_mut_ptr(tcx, param(0)), param(1)], param(0)),
         sym::atomic_fence | sym::atomic_singlethreadfence => (0, 1, Vec::new(), tcx.types.unit),
 
+        sym::return_address => (0, 0, vec![], Ty::new_imm_ptr(tcx, tcx.types.unit)),
+
         other => {
             tcx.dcx().emit_err(UnrecognizedIntrinsicFunction { span, name: other });
             return;