Rollup merge of #153228 - JonathanBrouwer:remove_translate_error, r=lqd

Remove `TranslationError`

This function is now infallible, since the diagnostic message and presence of variables is already parsed in the `msg!` or `derive(Diagnostic)` macro.

In practice, the result of this function was just unwrapped everywhere anyways...

r? @Kivooeo if you feel like reviewing diagnostics PRs again, I have a few more coming :)
(Tho other people are also free to steal these PRs)

Author: JonathanBrouwer

compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs

@@ -6,7 +6,6 @@
 //! [annotate_snippets]: https://docs.rs/crate/annotate-snippets/
 
 use std::borrow::Cow;
-use std::error::Report;
 use std::fmt::Debug;
 use std::io;
 use std::io::Write;
@@ -361,10 +360,7 @@ impl AnnotateSnippetEmitter {
                     if substitutions.is_empty() {
                         continue;
                     }
-                    let mut msg = format_diag_message(&suggestion.msg, args)
-                        .map_err(Report::new)
-                        .unwrap()
-                        .to_string();
+                    let mut msg = format_diag_message(&suggestion.msg, args).to_string();
 
                     let lo = substitutions
                         .iter()
@@ -547,7 +543,7 @@ impl AnnotateSnippetEmitter {
     ) -> String {
         msgs.iter()
             .filter_map(|(m, style)| {
-                let text = format_diag_message(m, args).map_err(Report::new).unwrap();
+                let text = format_diag_message(m, args);
                 let style = style.anstyle(level);
                 if text.is_empty() { None } else { Some(format!("{style}{text}{style:#}")) }
             })
@@ -694,9 +690,7 @@ fn collect_annotations(
 
         let kind = if is_primary { AnnotationKind::Primary } else { AnnotationKind::Context };
 
-        let label = label.as_ref().map(|m| {
-            normalize_whitespace(&format_diag_message(m, args).map_err(Report::new).unwrap())
-        });
+        let label = label.as_ref().map(|m| normalize_whitespace(&format_diag_message(m, args)));
 
         let ann = Annotation { kind, span, label };
         if sm.is_valid_span(ann.span).is_ok() {

compiler/rustc_errors/src/emitter.rs

@@ -8,7 +8,6 @@
 //! The output types are defined in `rustc_session::config::ErrorOutputType`.
 
 use std::borrow::Cow;
-use std::error::Report;
 use std::io::prelude::*;
 use std::io::{self, IsTerminal};
 use std::iter;
@@ -106,7 +105,7 @@ pub trait Emitter {
         fluent_args: &FluentArgs<'_>,
     ) {
         if let Some((sugg, rest)) = suggestions.split_first() {
-            let msg = format_diag_message(&sugg.msg, fluent_args).map_err(Report::new).unwrap();
+            let msg = format_diag_message(&sugg.msg, fluent_args);
             if rest.is_empty()
                // ^ if there is only one suggestion
                // don't display multi-suggestions as labels

compiler/rustc_errors/src/error.rs

@@ -9,7 +9,6 @@
 
 // FIXME: spec the JSON output properly.
 
-use std::error::Report;
 use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
@@ -301,8 +300,7 @@ impl Diagnostic {
     fn from_errors_diagnostic(diag: crate::DiagInner, je: &JsonEmitter) -> Diagnostic {
         let args = to_fluent_args(diag.args.iter());
         let sugg_to_diag = |sugg: &CodeSuggestion| {
-            let translated_message =
-                format_diag_message(&sugg.msg, &args).map_err(Report::new).unwrap();
+            let translated_message = format_diag_message(&sugg.msg, &args);
             Diagnostic {
                 message: translated_message.to_string(),
                 code: None,
@@ -417,10 +415,7 @@ impl DiagnosticSpan {
         Self::from_span_etc(
             span.span,
             span.is_primary,
-            span.label
-                .as_ref()
-                .map(|m| format_diag_message(m, args).unwrap())
-                .map(|m| m.to_string()),
+            span.label.as_ref().map(|m| format_diag_message(m, args)).map(|m| m.to_string()),
             suggestion,
             je,
         )

compiler/rustc_errors/src/json.rs

@@ -21,7 +21,6 @@ extern crate self as rustc_errors;
 use std::backtrace::{Backtrace, BacktraceStatus};
 use std::borrow::Cow;
 use std::cell::Cell;
-use std::error::Report;
 use std::ffi::OsStr;
 use std::hash::Hash;
 use std::io::Write;
@@ -78,7 +77,6 @@ mod decorate_diag;
 mod diagnostic;
 mod diagnostic_impls;
 pub mod emitter;
-pub mod error;
 pub mod json;
 mod lock;
 pub mod markdown;
@@ -1437,7 +1435,7 @@ impl DiagCtxtInner {
         args: impl Iterator<Item = DiagArg<'a>>,
     ) -> String {
         let args = crate::translation::to_fluent_args(args);
-        format_diag_message(&message, &args).map_err(Report::new).unwrap().to_string()
+        format_diag_message(&message, &args).to_string()
     }
 
     fn eagerly_translate_for_subdiag(

compiler/rustc_errors/src/lib.rs

@@ -1,11 +1,9 @@
 use std::borrow::Cow;
-use std::error::Report;
 
 pub use rustc_error_messages::FluentArgs;
 use rustc_error_messages::{langid, register_functions};
 use tracing::{debug, trace};
 
-use crate::error::TranslateError;
 use crate::fluent_bundle::FluentResource;
 use crate::{DiagArg, DiagMessage, Style, fluent_bundle};
 
@@ -33,22 +31,14 @@ pub fn format_diag_messages(
     messages: &[(DiagMessage, Style)],
     args: &FluentArgs<'_>,
 ) -> Cow<'static, str> {
-    Cow::Owned(
-        messages
-            .iter()
-            .map(|(m, _)| format_diag_message(m, args).map_err(Report::new).unwrap())
-            .collect::<String>(),
-    )
+    Cow::Owned(messages.iter().map(|(m, _)| format_diag_message(m, args)).collect::<String>())
 }
 
 /// Convert a `DiagMessage` to a string
-pub fn format_diag_message<'a>(
-    message: &'a DiagMessage,
-    args: &'a FluentArgs<'_>,
-) -> Result<Cow<'a, str>, TranslateError<'a>> {
+pub fn format_diag_message<'a>(message: &'a DiagMessage, args: &'a FluentArgs<'_>) -> Cow<'a, str> {
     trace!(?message, ?args);
     match message {
-        DiagMessage::Str(msg) => Ok(Cow::Borrowed(msg)),
+        DiagMessage::Str(msg) => Cow::Borrowed(msg),
         // This translates an inline fluent diagnostic message
         // It does this by creating a new `FluentBundle` with only one message,
         // and then translating using this bundle.
@@ -67,9 +57,9 @@ pub fn format_diag_message<'a>(
             let translated = bundle.format_pattern(value, Some(args), &mut errs).to_string();
             debug!(?translated, ?errs);
             if errs.is_empty() {
-                Ok(Cow::Owned(translated))
+                Cow::Owned(translated)
             } else {
-                Err(TranslateError::fluent(&Cow::Borrowed(GENERATED_MSG_ID), args, errs))
+                panic!("Fluent errors while formatting message: {errs:?}");
             }
         }
     }

compiler/rustc_errors/src/translation.rs

@@ -151,8 +151,7 @@ impl Emitter for BufferEmitter {
         let mut buffer = self.buffer.borrow_mut();
 
         let fluent_args = to_fluent_args(diag.args.iter());
-        let translated_main_message = format_diag_message(&diag.messages[0].0, &fluent_args)
-            .unwrap_or_else(|e| panic!("{e}"));
+        let translated_main_message = format_diag_message(&diag.messages[0].0, &fluent_args);
 
         buffer.messages.push(format!("error from rustc: {translated_main_message}"));
         if diag.is_error() {