Remove eagerly_format_to_string from DiagCtxt

JonathanBrouwer · JonathanBrouwer · commit 10eb844bac75 · 2026-03-06T18:52:11.000+01:00
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
@@ -949,17 +949,14 @@ pub(crate) struct AsmClobberNoReg {
 
 impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AsmClobberNoReg {
     fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
-        // eager translation as `span_labels` takes `AsRef<str>`
-        let lbl1 = dcx.eagerly_format_to_string(msg!("clobber_abi"), [].into_iter());
-        let lbl2 = dcx.eagerly_format_to_string(msg!("generic outputs"), [].into_iter());
         Diag::new(
             dcx,
             level,
             msg!("asm with `clobber_abi` must specify explicit registers for outputs"),
         )
         .with_span(self.spans.clone())
-        .with_span_labels(self.clobbers, &lbl1)
-        .with_span_labels(self.spans, &lbl2)
+        .with_span_labels(self.clobbers, "clobber_abi")
+        .with_span_labels(self.spans, "generic outputs")
     }
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs
@@ -2,7 +2,9 @@ use std::ffi::CString;
 use std::path::Path;
 
 use rustc_data_structures::small_c_str::SmallCStr;
-use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, msg};
+use rustc_errors::{
+    Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, format_diag_message, msg,
+};
 use rustc_macros::Diagnostic;
 use rustc_span::Span;
 
@@ -24,7 +26,7 @@ impl<G: EmissionGuarantee> Diagnostic<'_, G> for ParseTargetMachineConfig<'_> {
     fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
         let diag: Diag<'_, G> = self.0.into_diag(dcx, level);
         let (message, _) = diag.messages.first().expect("`LlvmError` with no message");
-        let message = dcx.eagerly_format_to_string(message.clone(), diag.args.iter());
+        let message = format_diag_message(message, &diag.args);
         Diag::new(
             dcx,
             level,
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
@@ -6,8 +6,8 @@ use rustc_abi::WrappingRange;
 use rustc_errors::codes::*;
 use rustc_errors::formatting::DiagMessageAddArg;
 use rustc_errors::{
-    Diag, DiagArgValue, DiagMessage, Diagnostic, EmissionGuarantee, Level, MultiSpan,
-    Subdiagnostic, msg,
+    Diag, DiagArgMap, DiagArgValue, DiagMessage, Diagnostic, EmissionGuarantee, Level, MultiSpan,
+    Subdiagnostic, format_diag_message, msg,
 };
 use rustc_hir::ConstContext;
 use rustc_macros::{Diagnostic, Subdiagnostic};
@@ -623,7 +623,7 @@ pub trait ReportErrorExt {
             let mut diag = dcx.struct_allow(DiagMessage::Str(String::new().into()));
             let message = self.diagnostic_message();
             self.add_args(&mut diag);
-            let s = dcx.eagerly_format_to_string(message, diag.args.iter());
+            let s = format_diag_message(&message, &diag.args).into_owned();
             diag.cancel();
             s
         })
@@ -1085,12 +1085,12 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
         }
 
         let message = if let Some(path) = self.path {
-            err.dcx.eagerly_format_to_string(
-                msg!("constructing invalid value at {$path}"),
-                [("path".into(), DiagArgValue::Str(path.into()))].iter().map(|(a, b)| (a, b)),
+            format_diag_message(
+                &msg!("constructing invalid value at {$path}"),
+                &DiagArgMap::from_iter([("path".into(), DiagArgValue::Str(path.into()))]),
             )
         } else {
-            err.dcx.eagerly_format_to_string(msg!("constructing invalid value"), [].into_iter())
+            Cow::Borrowed("constructing invalid value")
         };
 
         err.arg("front_matter", message);
@@ -1116,12 +1116,13 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
                 msg!("in the range {$lo}..={$hi}")
             };
 
-            let args = [
-                ("lo".into(), DiagArgValue::Str(lo.to_string().into())),
-                ("hi".into(), DiagArgValue::Str(hi.to_string().into())),
-            ];
-            let args = args.iter().map(|(a, b)| (a, b));
-            let message = err.dcx.eagerly_format_to_string(msg, args);
+            let message = format_diag_message(
+                &msg,
+                &DiagArgMap::from_iter([
+                    ("lo".into(), DiagArgValue::Str(lo.to_string().into())),
+                    ("hi".into(), DiagArgValue::Str(hi.to_string().into())),
+                ]),
+            );
             err.arg("in_range", message);
         }
 
@@ -1131,19 +1132,18 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
             }
             PointerAsInt { expected } | Uninit { expected } => {
                 let msg = match expected {
-                    ExpectedKind::Reference => msg!("expected a reference"),
-                    ExpectedKind::Box => msg!("expected a box"),
-                    ExpectedKind::RawPtr => msg!("expected a raw pointer"),
-                    ExpectedKind::InitScalar => msg!("expected initialized scalar value"),
-                    ExpectedKind::Bool => msg!("expected a boolean"),
-                    ExpectedKind::Char => msg!("expected a unicode scalar value"),
-                    ExpectedKind::Float => msg!("expected a floating point number"),
-                    ExpectedKind::Int => msg!("expected an integer"),
-                    ExpectedKind::FnPtr => msg!("expected a function pointer"),
-                    ExpectedKind::EnumTag => msg!("expected a valid enum tag"),
-                    ExpectedKind::Str => msg!("expected a string"),
+                    ExpectedKind::Reference => "expected a reference",
+                    ExpectedKind::Box => "expected a box",
+                    ExpectedKind::RawPtr => "expected a raw pointer",
+                    ExpectedKind::InitScalar => "expected initialized scalar value",
+                    ExpectedKind::Bool => "expected a boolean",
+                    ExpectedKind::Char => "expected a unicode scalar value",
+                    ExpectedKind::Float => "expected a floating point number",
+                    ExpectedKind::Int => "expected an integer",
+                    ExpectedKind::FnPtr => "expected a function pointer",
+                    ExpectedKind::EnumTag => "expected a valid enum tag",
+                    ExpectedKind::Str => "expected a string",
                 };
-                let msg = err.dcx.eagerly_format_to_string(msg, [].into_iter());
                 err.arg("expected", msg);
             }
             InvalidEnumTag { value }
diff --git a/compiler/rustc_const_eval/src/interpret/eval_context.rs b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@@ -1,7 +1,7 @@
 use either::{Left, Right};
 use rustc_abi::{Align, HasDataLayout, Size, TargetDataLayout};
 use rustc_data_structures::debug_assert_matches;
-use rustc_errors::{DiagCtxtHandle, msg};
+use rustc_errors::{DiagCtxtHandle, format_diag_message, msg};
 use rustc_hir::def_id::DefId;
 use rustc_hir::limit::Limit;
 use rustc_middle::mir::interpret::{ErrorHandled, InvalidMetaKind, ReportedErrorInfo};
@@ -235,9 +235,9 @@ pub fn format_interp_error<'tcx>(dcx: DiagCtxtHandle<'_>, e: InterpErrorInfo<'tc
     let mut diag = dcx.struct_allow("");
     let msg = e.diagnostic_message();
     e.add_args(&mut diag);
-    let s = dcx.eagerly_format_to_string(msg, diag.args.iter());
+    let msg = format_diag_message(&msg, &diag.args).into_owned();
     diag.cancel();
-    s
+    msg
 }
 
 impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
@@ -483,16 +483,6 @@ impl DiagCtxt {
         self.inner.borrow_mut().emitter = emitter;
     }
 
-    /// Format `message` eagerly with `args` to `String`.
-    pub fn eagerly_format_to_string<'a>(
-        &self,
-        message: DiagMessage,
-        args: impl Iterator<Item = DiagArg<'a>>,
-    ) -> String {
-        let inner = self.inner.borrow();
-        inner.eagerly_format_to_string(message, args)
-    }
-
     // This is here to not allow mutation of flags;
     // as of this writing it's used in Session::consider_optimizing and
     // in tests in rustc_interface.
@@ -1408,16 +1398,6 @@ impl DiagCtxtInner {
         self.has_errors().or_else(|| self.delayed_bugs.get(0).map(|(_, guar)| guar).copied())
     }
 
-    /// Format `message` eagerly with `args` to `String`.
-    fn eagerly_format_to_string<'a>(
-        &self,
-        message: DiagMessage,
-        args: impl Iterator<Item = DiagArg<'a>>,
-    ) -> String {
-        let args = args.map(|(name, val)| (name.clone(), val.clone())).collect();
-        format_diag_message(&message, &args).to_string()
-    }
-
     fn flush_delayed(&mut self) {
         // Stashed diagnostics must be emitted before delayed bugs are flushed.
         // Otherwise, we might ICE prematurely when errors would have
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
@@ -1,4 +1,5 @@
 use rustc_errors::codes::*;
+use rustc_errors::formatting::DiagMessageAddArg;
 use rustc_errors::{
     Applicability, Diag, DiagCtxtHandle, DiagMessage, Diagnostic, ElidedLifetimeInPathSubdiag,
     EmissionGuarantee, IntoDiagArg, Level, MultiSpan, Subdiagnostic, msg,
@@ -1364,12 +1365,10 @@ impl Subdiagnostic for FoundItemConfigureOut {
         let mut multispan: MultiSpan = self.span.into();
         match self.item_was {
             ItemWas::BehindFeature { feature, span } => {
-                let key = "feature".into();
                 let value = feature.into_diag_arg(&mut None);
-                let msg = diag.dcx.eagerly_format_to_string(
-                    msg!("the item is gated behind the `{$feature}` feature"),
-                    [(&key, &value)].into_iter(),
-                );
+                let msg = msg!("the item is gated behind the `{$feature}` feature")
+                    .arg("feature", value)
+                    .format();
                 multispan.push_span_label(span, msg);
             }
             ItemWas::CfgOut { span } => {

Original file line number	Diff line number	Diff line change
`@@ -949,17 +949,14 @@ pub(crate) struct AsmClobberNoReg {`
`949`	`949`
`950`	`950`	`impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AsmClobberNoReg {`
`951`	`951`	`fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {`
`952`		- // eager translation as `span_labels` takes `AsRef<str>`
`953`		`- let lbl1 = dcx.eagerly_format_to_string(msg!("clobber_abi"), [].into_iter());`
`954`		`- let lbl2 = dcx.eagerly_format_to_string(msg!("generic outputs"), [].into_iter());`
`955`	`952`	`Diag::new(`
`956`	`953`	`dcx,`
`957`	`954`	`level,`
`958`	`955`	msg!("asm with `clobber_abi` must specify explicit registers for outputs"),
`959`	`956`	`)`
`960`	`957`	`.with_span(self.spans.clone())`
`961`		`- .with_span_labels(self.clobbers, &lbl1)`
`962`		`- .with_span_labels(self.spans, &lbl2)`
	`958`	`+ .with_span_labels(self.clobbers, "clobber_abi")`
	`959`	`+ .with_span_labels(self.spans, "generic outputs")`
`963`	`960`	`}`
`964`	`961`	`}`
`965`	`962`