Cleanup error handlers some more

compiler/rustc_builtin_macros/src/errors.rs

@@ -1,5 +1,5 @@
 use rustc_errors::{
- AddToDiagnostic, DiagnosticBuilder, EmissionGuarantee, Handler, IntoDiagnostic, MultiSpan,
+ AddToDiagnostic, DiagnosticBuilder, ErrorGuaranteed, Handler, IntoDiagnostic, MultiSpan,
  SingleLabelManySpans,
 };
 use rustc_macros::{Diagnostic, Subdiagnostic};
@@ -446,9 +446,9 @@ pub(crate) struct EnvNotDefinedWithUserMessage {
 }
 
 // Hand-written implementation to support custom user messages.
-impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for EnvNotDefinedWithUserMessage {
+impl<'a> IntoDiagnostic<'a> for EnvNotDefinedWithUserMessage {
  #[track_caller]
- fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, G> {
+ fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
  #[expect(
  rustc::untranslatable_diagnostic,
  reason = "cannot translate user-provided messages"
@@ -801,8 +801,8 @@ pub(crate) struct AsmClobberNoReg {
  pub(crate) clobbers: Vec<Span>,
 }
 
-impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for AsmClobberNoReg {
- fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, G> {
+impl<'a> IntoDiagnostic<'a> for AsmClobberNoReg {
+ fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
  let mut diag =
  handler.struct_diagnostic(crate::fluent_generated::builtin_macros_asm_clobber_no_reg);
  diag.set_span(self.spans.clone());

compiler/rustc_codegen_cranelift/src/concurrency_limiter.rs

@@ -64,7 +64,7 @@ impl ConcurrencyLimiter {
  // Make sure to drop the mutex guard first to prevent poisoning the mutex.
  drop(state);
  if let Some(err) = err {
- handler.fatal(err).raise();
+ handler.fatal(err);
  } else {
  // The error was already emitted, but compilation continued. Raise a silent
  // fatal error.

compiler/rustc_codegen_gcc/src/errors.rs

@@ -111,8 +111,8 @@ pub(crate) struct TargetFeatureDisableOrEnable<'a> {
 pub(crate) struct MissingFeatures;
 
 impl IntoDiagnostic<'_, ErrorGuaranteed> for TargetFeatureDisableOrEnable<'_> {
- fn into_diagnostic(self, sess: &'_ Handler) -> DiagnosticBuilder<'_, ErrorGuaranteed> {
- let mut diag = sess.struct_err(fluent::codegen_gcc_target_feature_disable_or_enable);
+ fn into_diagnostic(self, handler: &'_ Handler) -> DiagnosticBuilder<'_, ErrorGuaranteed> {
+ let mut diag = handler.struct_err(fluent::codegen_gcc_target_feature_disable_or_enable);
  if let Some(span) = self.span {
  diag.set_span(span);
  };

compiler/rustc_codegen_llvm/src/errors.rs

@@ -5,7 +5,7 @@ use std::path::Path;
 use crate::fluent_generated as fluent;
 use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_errors::{
- DiagnosticBuilder, EmissionGuarantee, ErrorGuaranteed, Handler, IntoDiagnostic,
+ DiagnosticBuilder, EmissionGuarantee, ErrorGuaranteed, FatalError, Handler, IntoDiagnostic,
 };
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::Span;
@@ -101,13 +101,13 @@ pub(crate) struct DynamicLinkingWithLTO;
 
 pub(crate) struct ParseTargetMachineConfig<'a>(pub LlvmError<'a>);
 
-impl<EM: EmissionGuarantee> IntoDiagnostic<'_, EM> for ParseTargetMachineConfig<'_> {
- fn into_diagnostic(self, sess: &'_ Handler) -> DiagnosticBuilder<'_, EM> {
- let diag: DiagnosticBuilder<'_, EM> = self.0.into_diagnostic(sess);
+impl IntoDiagnostic<'_, FatalError> for ParseTargetMachineConfig<'_> {
+ fn into_diagnostic(self, handler: &'_ Handler) -> DiagnosticBuilder<'_, FatalError> {
+ let diag: DiagnosticBuilder<'_, FatalError> = self.0.into_diagnostic(handler);
  let (message, _) = diag.styled_message().first().expect("`LlvmError` with no message");
- let message = sess.eagerly_translate_to_string(message.clone(), diag.args());
+ let message = handler.eagerly_translate_to_string(message.clone(), diag.args());
 
- let mut diag = sess.struct_diagnostic(fluent::codegen_llvm_parse_target_machine_config);
+ let mut diag = handler.struct_diagnostic(fluent::codegen_llvm_parse_target_machine_config);
  diag.set_arg("error", message);
  diag
  }
@@ -124,8 +124,8 @@ pub(crate) struct TargetFeatureDisableOrEnable<'a> {
 pub(crate) struct MissingFeatures;
 
 impl IntoDiagnostic<'_, ErrorGuaranteed> for TargetFeatureDisableOrEnable<'_> {
- fn into_diagnostic(self, sess: &'_ Handler) -> DiagnosticBuilder<'_, ErrorGuaranteed> {
- let mut diag = sess.struct_err(fluent::codegen_llvm_target_feature_disable_or_enable);
+ fn into_diagnostic(self, handler: &'_ Handler) -> DiagnosticBuilder<'_, ErrorGuaranteed> {
+ let mut diag = handler.struct_err(fluent::codegen_llvm_target_feature_disable_or_enable);
  if let Some(span) = self.span {
  diag.set_span(span);
  };
@@ -183,8 +183,8 @@ pub enum LlvmError<'a> {
 
 pub(crate) struct WithLlvmError<'a>(pub LlvmError<'a>, pub String);
 
-impl<EM: EmissionGuarantee> IntoDiagnostic<'_, EM> for WithLlvmError<'_> {
- fn into_diagnostic(self, sess: &'_ Handler) -> DiagnosticBuilder<'_, EM> {
+impl<G: EmissionGuarantee> IntoDiagnostic<'_, G> for WithLlvmError<'_> {
+ fn into_diagnostic(self, handler: &'_ Handler) -> DiagnosticBuilder<'_, G> {
  use LlvmError::*;
  let msg_with_llvm_err = match &self.0 {
  WriteOutput { .. } => fluent::codegen_llvm_write_output_with_llvm_err,
@@ -201,7 +201,7 @@ impl<EM: EmissionGuarantee> IntoDiagnostic<'_, EM> for WithLlvmError<'_> {
  PrepareThinLtoModule => fluent::codegen_llvm_prepare_thin_lto_module_with_llvm_err,
  ParseBitcode => fluent::codegen_llvm_parse_bitcode_with_llvm_err,
  };
- let mut diag = self.0.into_diagnostic(sess);
+ let mut diag = self.0.into_diagnostic(handler);
  diag.set_primary_message(msg_with_llvm_err);
  diag.set_arg("llvm_err", self.1);
  diag

compiler/rustc_errors/src/diagnostic.rs

@@ -239,7 +239,7 @@ impl Diagnostic {
  }
 
  #[track_caller]
- pub fn new_with_code<M: Into<DiagnosticMessage>>(
+ pub(crate) fn new_with_code<M: Into<DiagnosticMessage>>(
  level: Level,
  code: Option<DiagnosticId>,
  message: M,
@@ -281,7 +281,7 @@ impl Diagnostic {
  }
  }
 
- pub fn update_unstable_expectation_id(
+ pub(crate) fn update_unstable_expectation_id(
  &mut self,
  unstable_to_stable: &FxHashMap<LintExpectationId, LintExpectationId>,
  ) {
@@ -307,14 +307,14 @@ impl Diagnostic {
  }
 
  /// Indicates whether this diagnostic should show up in cargo's future breakage report.
- pub fn has_future_breakage(&self) -> bool {
+ pub(crate) fn has_future_breakage(&self) -> bool {
  match self.code {
  Some(DiagnosticId::Lint { has_future_breakage, .. }) => has_future_breakage,
  _ => false,
  }
  }
 
- pub fn is_force_warn(&self) -> bool {
+ pub(crate) fn is_force_warn(&self) -> bool {
  match self.code {
  Some(DiagnosticId::Lint { is_force_warn, .. }) => is_force_warn,
  _ => false,
@@ -391,29 +391,6 @@ impl Diagnostic {
  self.note_expected_found_extra(expected_label, expected, found_label, found, &"", &"")
  }
 
- pub fn note_unsuccessful_coercion(
- &mut self,
- expected: DiagnosticStyledString,
- found: DiagnosticStyledString,
- ) -> &mut Self {
- let mut msg: Vec<_> =
- vec![(Cow::from("required when trying to coerce from type `"), Style::NoStyle)];
- msg.extend(expected.0.iter().map(|x| match *x {
- StringPart::Normal(ref s) => (Cow::from(s.clone()), Style::NoStyle),
- StringPart::Highlighted(ref s) => (Cow::from(s.clone()), Style::Highlight),
- }));
- msg.push((Cow::from("` to type '"), Style::NoStyle));
- msg.extend(found.0.iter().map(|x| match *x {
- StringPart::Normal(ref s) => (Cow::from(s.clone()), Style::NoStyle),
- StringPart::Highlighted(ref s) => (Cow::from(s.clone()), Style::Highlight),
- }));
- msg.push((Cow::from("`"), Style::NoStyle));
-
- // For now, just attach these as notes
- self.highlighted_note(msg);
- self
- }
-
  pub fn note_expected_found_extra(
  &mut self,
  expected_label: &dyn fmt::Display,
@@ -475,7 +452,7 @@ impl Diagnostic {
  self
  }
 
- pub fn highlighted_note<M: Into<SubdiagnosticMessage>>(
+ fn highlighted_note<M: Into<SubdiagnosticMessage>>(
  &mut self,
  msg: Vec<(M, Style)>,
  ) -> &mut Self {
@@ -572,14 +549,6 @@ impl Diagnostic {
  self
  }
 
- /// Clear any existing suggestions.
- pub fn clear_suggestions(&mut self) -> &mut Self {
- if let Ok(suggestions) = &mut self.suggestions {
- suggestions.clear();
- }
- self
- }
-
  /// Helper for pushing to `self.suggestions`, if available (not disable).
  fn push_suggestion(&mut self, suggestion: CodeSuggestion) {
  if let Ok(suggestions) = &mut self.suggestions {
@@ -992,7 +961,7 @@ impl Diagnostic {
  /// Helper function that takes a `SubdiagnosticMessage` and returns a `DiagnosticMessage` by
  /// combining it with the primary message of the diagnostic (if translatable, otherwise it just
  /// passes the user's string along).
- pub(crate) fn subdiagnostic_message_to_diagnostic_message(
+ fn subdiagnostic_message_to_diagnostic_message(
  &self,
  attr: impl Into<SubdiagnosticMessage>,
  ) -> DiagnosticMessage {