Rename DiagnosticMessage as DiagMessage.

Author: nnethercote

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -16,8 +16,8 @@ use rustc_data_structures::sync::Lrc;
 use rustc_errors::emitter::Emitter;
 use rustc_errors::translation::Translate;
 use rustc_errors::{
- Diag, DiagArgMap, DiagCtxt, DiagnosticMessage, ErrCode, FatalError, FluentBundle, Level,
- MultiSpan, Style,
+ Diag, DiagArgMap, DiagCtxt, DiagMessage, ErrCode, FatalError, FluentBundle, Level, MultiSpan,
+ Style,
 };
 use rustc_fs_util::link_or_copy;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
@@ -1015,7 +1015,7 @@ pub struct CguMessage;
 // - `emitted_at`: not used for codegen diagnostics.
 struct Diagnostic {
  level: Level,
- messages: Vec<(DiagnosticMessage, Style)>,
+ messages: Vec<(DiagMessage, Style)>,
  code: Option<ErrCode>,
  children: Vec<Subdiagnostic>,
  args: DiagArgMap,
@@ -1026,7 +1026,7 @@ struct Diagnostic {
 // - `span`: it doesn't impl `Send`.
 pub struct Subdiagnostic {
  level: Level,
- messages: Vec<(DiagnosticMessage, Style)>,
+ messages: Vec<(DiagMessage, Style)>,
 }
 
 #[derive(PartialEq, Clone, Copy, Debug)]

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -1,8 +1,6 @@
 use std::mem;
 
-use rustc_errors::{
- DiagArgName, DiagArgValue, DiagnosticMessage, IntoDiagnostic, IntoDiagnosticArg,
-};
+use rustc_errors::{DiagArgName, DiagArgValue, DiagMessage, IntoDiagnostic, IntoDiagnosticArg};
 use rustc_hir::CRATE_HIR_ID;
 use rustc_middle::mir::AssertKind;
 use rustc_middle::query::TyCtxtAt;
@@ -25,7 +23,7 @@ pub enum ConstEvalErrKind {
 }
 
 impl MachineStopType for ConstEvalErrKind {
- fn diagnostic_message(&self) -> DiagnosticMessage {
+ fn diagnostic_message(&self) -> DiagMessage {
  use crate::fluent_generated::*;
  use ConstEvalErrKind::*;
  match self {

compiler/rustc_const_eval/src/errors.rs

@@ -1,8 +1,7 @@
 use std::borrow::Cow;
 
 use rustc_errors::{
- codes::*, Diag, DiagArgValue, DiagCtxt, DiagnosticMessage, EmissionGuarantee, IntoDiagnostic,
- Level,
+ codes::*, Diag, DiagArgValue, DiagCtxt, DiagMessage, EmissionGuarantee, IntoDiagnostic, Level,
 };
 use rustc_hir::ConstContext;
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
@@ -424,7 +423,7 @@ pub struct UndefinedBehavior {
 
 pub trait ReportErrorExt {
  /// Returns the diagnostic message for this error.
- fn diagnostic_message(&self) -> DiagnosticMessage;
+ fn diagnostic_message(&self) -> DiagMessage;
  fn add_args<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>);
 
  fn debug(self) -> String
@@ -433,7 +432,7 @@ pub trait ReportErrorExt {
  {
  ty::tls::with(move |tcx| {
  let dcx = tcx.dcx();
- let mut diag = dcx.struct_allow(DiagnosticMessage::Str(String::new().into()));
+ 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_translate_to_string(message, diag.args.iter());
@@ -457,7 +456,7 @@ fn bad_pointer_message(msg: CheckInAllocMsg, dcx: &DiagCtxt) -> String {
 }
 
 impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
- fn diagnostic_message(&self) -> DiagnosticMessage {
+ fn diagnostic_message(&self) -> DiagMessage {
  use crate::fluent_generated::*;
  use UndefinedBehaviorInfo::*;
  match self {
@@ -595,7 +594,7 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
 }
 
 impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
- fn diagnostic_message(&self) -> DiagnosticMessage {
+ fn diagnostic_message(&self) -> DiagMessage {
  use crate::fluent_generated::*;
  use rustc_middle::mir::interpret::ValidationErrorKind::*;
  match self.kind {
@@ -783,7 +782,7 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
 }
 
 impl ReportErrorExt for UnsupportedOpInfo {
- fn diagnostic_message(&self) -> DiagnosticMessage {
+ fn diagnostic_message(&self) -> DiagMessage {
  use crate::fluent_generated::*;
  match self {
  UnsupportedOpInfo::Unsupported(s) => s.clone().into(),
@@ -819,7 +818,7 @@ impl ReportErrorExt for UnsupportedOpInfo {
 }
 
 impl<'tcx> ReportErrorExt for InterpError<'tcx> {
- fn diagnostic_message(&self) -> DiagnosticMessage {
+ fn diagnostic_message(&self) -> DiagMessage {
  match self {
  InterpError::UndefinedBehavior(ub) => ub.diagnostic_message(),
  InterpError::Unsupported(e) => e.diagnostic_message(),
@@ -842,7 +841,7 @@ impl<'tcx> ReportErrorExt for InterpError<'tcx> {
 }
 
 impl<'tcx> ReportErrorExt for InvalidProgramInfo<'tcx> {
- fn diagnostic_message(&self) -> DiagnosticMessage {
+ fn diagnostic_message(&self) -> DiagMessage {
  use crate::fluent_generated::*;
  match self {
  InvalidProgramInfo::TooGeneric => const_eval_too_generic,
@@ -877,7 +876,7 @@ impl<'tcx> ReportErrorExt for InvalidProgramInfo<'tcx> {
 }
 
 impl ReportErrorExt for ResourceExhaustionInfo {
- fn diagnostic_message(&self) -> DiagnosticMessage {
+ fn diagnostic_message(&self) -> DiagMessage {
  use crate::fluent_generated::*;
  match self {
  ResourceExhaustionInfo::StackFrameLimitReached => const_eval_stack_frame_limit_reached,

compiler/rustc_error_messages/src/lib.rs

@@ -253,8 +253,8 @@ type FluentId = Cow<'static, str>;
 /// translatable and non-translatable diagnostic messages.
 ///
 /// Translatable messages for subdiagnostics are typically attributes attached to a larger Fluent
-/// message so messages of this type must be combined with a `DiagnosticMessage` (using
-/// `DiagnosticMessage::with_subdiagnostic_message`) before rendering. However, subdiagnostics from
+/// message so messages of this type must be combined with a `DiagMessage` (using
+/// `DiagMessage::with_subdiagnostic_message`) before rendering. However, subdiagnostics from
 /// the `Subdiagnostic` derive refer to Fluent identifiers directly.
 #[rustc_diagnostic_item = "SubdiagnosticMessage"]
 pub enum SubdiagnosticMessage {
@@ -265,7 +265,7 @@ pub enum SubdiagnosticMessage {
  /// Some diagnostics have repeated subdiagnostics where the same interpolated variables would
  /// be instantiated multiple times with different values. These subdiagnostics' messages
  /// are translated when they are added to the parent diagnostic, producing this variant of
- /// `DiagnosticMessage`.
+ /// `DiagMessage`.
  Translated(Cow<'static, str>),
  /// Identifier of a Fluent message. Instances of this variant are generated by the
  /// `Subdiagnostic` derive.
@@ -299,16 +299,16 @@ impl From<Cow<'static, str>> for SubdiagnosticMessage {
 ///
 /// Intended to be removed once diagnostics are entirely translatable.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Encodable, Decodable)]
-#[rustc_diagnostic_item = "DiagnosticMessage"]
-pub enum DiagnosticMessage {
+#[rustc_diagnostic_item = "DiagMessage"]
+pub enum DiagMessage {
  /// Non-translatable diagnostic message.
  Str(Cow<'static, str>),
  /// Translatable message which has been already translated.
  ///
  /// Some diagnostics have repeated subdiagnostics where the same interpolated variables would
  /// be instantiated multiple times with different values. These subdiagnostics' messages
  /// are translated when they are added to the parent diagnostic, producing this variant of
- /// `DiagnosticMessage`.
+ /// `DiagMessage`.
  Translated(Cow<'static, str>),
  /// Identifier for a Fluent message (with optional attribute) corresponding to the diagnostic
  /// message. Yet to be translated.
@@ -318,85 +318,81 @@ pub enum DiagnosticMessage {
  FluentIdentifier(FluentId, Option<FluentId>),
 }
 
-impl DiagnosticMessage {
+impl DiagMessage {
  /// Given a `SubdiagnosticMessage` which may contain a Fluent attribute, create a new
- /// `DiagnosticMessage` that combines that attribute with the Fluent identifier of `self`.
+ /// `DiagMessage` that combines that attribute with the Fluent identifier of `self`.
  ///
  /// - If the `SubdiagnosticMessage` is non-translatable then return the message as a
- /// `DiagnosticMessage`.
+ ///  `DiagMessage`.
  /// - If `self` is non-translatable then return `self`'s message.
  pub fn with_subdiagnostic_message(&self, sub: SubdiagnosticMessage) -> Self {
  let attr = match sub {
- SubdiagnosticMessage::Str(s) => return DiagnosticMessage::Str(s),
- SubdiagnosticMessage::Translated(s) => return DiagnosticMessage::Translated(s),
+ SubdiagnosticMessage::Str(s) => return DiagMessage::Str(s),
+ SubdiagnosticMessage::Translated(s) => return DiagMessage::Translated(s),
  SubdiagnosticMessage::FluentIdentifier(id) => {
- return DiagnosticMessage::FluentIdentifier(id, None);
+ return DiagMessage::FluentIdentifier(id, None);
  }
  SubdiagnosticMessage::FluentAttr(attr) => attr,
  };
 
  match self {
- DiagnosticMessage::Str(s) => DiagnosticMessage::Str(s.clone()),
- DiagnosticMessage::Translated(s) => DiagnosticMessage::Translated(s.clone()),
- DiagnosticMessage::FluentIdentifier(id, _) => {
- DiagnosticMessage::FluentIdentifier(id.clone(), Some(attr))
+ DiagMessage::Str(s) => DiagMessage::Str(s.clone()),
+ DiagMessage::Translated(s) => DiagMessage::Translated(s.clone()),
+ DiagMessage::FluentIdentifier(id, _) => {
+ DiagMessage::FluentIdentifier(id.clone(), Some(attr))
  }
  }
  }
 
  pub fn as_str(&self) -> Option<&str> {
  match self {
- DiagnosticMessage::Translated(s) | DiagnosticMessage::Str(s) => Some(s),
- DiagnosticMessage::FluentIdentifier(_, _) => None,
+ DiagMessage::Translated(s) | DiagMessage::Str(s) => Some(s),
+ DiagMessage::FluentIdentifier(_, _) => None,
  }
  }
 }
 
-impl From<String> for DiagnosticMessage {
+impl From<String> for DiagMessage {
  fn from(s: String) -> Self {
- DiagnosticMessage::Str(Cow::Owned(s))
+ DiagMessage::Str(Cow::Owned(s))
  }
 }
-impl From<&'static str> for DiagnosticMessage {
+impl From<&'static str> for DiagMessage {
  fn from(s: &'static str) -> Self {
- DiagnosticMessage::Str(Cow::Borrowed(s))
+ DiagMessage::Str(Cow::Borrowed(s))
  }
 }
-impl From<Cow<'static, str>> for DiagnosticMessage {
+impl From<Cow<'static, str>> for DiagMessage {
  fn from(s: Cow<'static, str>) -> Self {
- DiagnosticMessage::Str(s)
+ DiagMessage::Str(s)
  }
 }
 
 /// A workaround for must_produce_diag ICEs when formatting types in disabled lints.
 ///
-/// Delays formatting until `.into(): DiagnosticMessage` is used.
+/// Delays formatting until `.into(): DiagMessage` is used.
 pub struct DelayDm<F>(pub F);
 
-impl<F: FnOnce() -> String> From<DelayDm<F>> for DiagnosticMessage {
+impl<F: FnOnce() -> String> From<DelayDm<F>> for DiagMessage {
  fn from(DelayDm(f): DelayDm<F>) -> Self {
- DiagnosticMessage::from(f())
+ DiagMessage::from(f())
  }
 }
 
 /// Translating *into* a subdiagnostic message from a diagnostic message is a little strange - but
 /// the subdiagnostic functions (e.g. `span_label`) take a `SubdiagnosticMessage` and the
-/// subdiagnostic derive refers to typed identifiers that are `DiagnosticMessage`s, so need to be
-/// able to convert between these, as much as they'll be converted back into `DiagnosticMessage`
+/// subdiagnostic derive refers to typed identifiers that are `DiagMessage`s, so need to be
+/// able to convert between these, as much as they'll be converted back into `DiagMessage`
 /// using `with_subdiagnostic_message` eventually. Don't use this other than for the derive.
-impl Into<SubdiagnosticMessage> for DiagnosticMessage {
+impl Into<SubdiagnosticMessage> for DiagMessage {
  fn into(self) -> SubdiagnosticMessage {
  match self {
- DiagnosticMessage::Str(s) => SubdiagnosticMessage::Str(s),
- DiagnosticMessage::Translated(s) => SubdiagnosticMessage::Translated(s),
- DiagnosticMessage::FluentIdentifier(id, None) => {
- SubdiagnosticMessage::FluentIdentifier(id)
- }
+ DiagMessage::Str(s) => SubdiagnosticMessage::Str(s),
+ DiagMessage::Translated(s) => SubdiagnosticMessage::Translated(s),
+ DiagMessage::FluentIdentifier(id, None) => SubdiagnosticMessage::FluentIdentifier(id),
  // There isn't really a sensible behaviour for this because it loses information but
  // this is the most sensible of the behaviours.
- DiagnosticMessage::FluentIdentifier(_, Some(attr)) => {
- SubdiagnosticMessage::FluentAttr(attr)
- }
+ DiagMessage::FluentIdentifier(_, Some(attr)) => SubdiagnosticMessage::FluentAttr(attr),
  }
  }
 }
@@ -412,7 +408,7 @@ pub struct SpanLabel {
  pub is_primary: bool,
 
  /// What label should we attach to this span (if any)?
- pub label: Option<DiagnosticMessage>,
+ pub label: Option<DiagMessage>,
 }
 
 /// A collection of `Span`s.
@@ -426,7 +422,7 @@ pub struct SpanLabel {
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Encodable, Decodable)]
 pub struct MultiSpan {
  primary_spans: Vec<Span>,
- span_labels: Vec<(Span, DiagnosticMessage)>,
+ span_labels: Vec<(Span, DiagMessage)>,
 }
 
 impl MultiSpan {
@@ -444,7 +440,7 @@ impl MultiSpan {
  MultiSpan { primary_spans: vec, span_labels: vec![] }
  }
 
- pub fn push_span_label(&mut self, span: Span, label: impl Into<DiagnosticMessage>) {
+ pub fn push_span_label(&mut self, span: Span, label: impl Into<DiagMessage>) {
  self.span_labels.push((span, label.into()));
  }
 
@@ -487,7 +483,7 @@ impl MultiSpan {
  replacements_occurred
  }
 
- pub fn pop_span_label(&mut self) -> Option<(Span, DiagnosticMessage)> {
+ pub fn pop_span_label(&mut self) -> Option<(Span, DiagMessage)> {
  self.span_labels.pop()
  }
 

compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs

@@ -9,8 +9,8 @@ use crate::emitter::FileWithAnnotatedLines;
 use crate::snippet::Line;
 use crate::translation::{to_fluent_args, Translate};
 use crate::{
- CodeSuggestion, DiagInner, DiagnosticMessage, Emitter, ErrCode, FluentBundle,
- LazyFallbackBundle, Level, MultiSpan, Style, Subdiag,
+ CodeSuggestion, DiagInner, DiagMessage, Emitter, ErrCode, FluentBundle, LazyFallbackBundle,
+ Level, MultiSpan, Style, Subdiag,
 };
 use annotate_snippets::{Annotation, AnnotationType, Renderer, Slice, Snippet, SourceAnnotation};
 use rustc_data_structures::sync::Lrc;
@@ -125,7 +125,7 @@ impl AnnotateSnippetEmitter {
  fn emit_messages_default(
  &mut self,
  level: &Level,
- messages: &[(DiagnosticMessage, Style)],
+ messages: &[(DiagMessage, Style)],
  args: &FluentArgs<'_>,
  code: &Option<ErrCode>,
  msp: &MultiSpan,