diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index d72913764e9d1..83b27520457b6 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -108,11 +108,9 @@ use crate::session_diagnostics::{
 };
 
 pub fn default_translator() -> Translator {
-    Translator::with_fallback_bundle(DEFAULT_LOCALE_RESOURCES.to_vec(), false)
+    Translator::new()
 }
 
-pub static DEFAULT_LOCALE_RESOURCES: &[&str] = &[];
-
 /// Exit status code used for successful compilation and help output.
 pub const EXIT_SUCCESS: i32 = 0;
 
@@ -219,7 +217,6 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
         output_dir: odir,
         ice_file,
         file_loader: None,
-        locale_resources: DEFAULT_LOCALE_RESOURCES.to_vec(),
         lint_caps: Default::default(),
         psess_created: None,
         hash_untracked_state: None,
@@ -1528,7 +1525,7 @@ fn report_ice(
     extra_info: fn(&DiagCtxt),
     using_internal_features: &AtomicBool,
 ) {
-    let translator = default_translator();
+    let translator = Translator::new();
     let emitter =
         Box::new(rustc_errors::annotate_snippet_emitter_writer::AnnotateSnippetEmitter::new(
             stderr_destination(rustc_errors::ColorConfig::Auto),
diff --git a/compiler/rustc_error_messages/src/lib.rs b/compiler/rustc_error_messages/src/lib.rs
index 641defd1eabfe..916a370659aa7 100644
--- a/compiler/rustc_error_messages/src/lib.rs
+++ b/compiler/rustc_error_messages/src/lib.rs
@@ -230,9 +230,6 @@ pub fn fallback_fluent_bundle(
     })))
 }
 
-/// Identifier for the Fluent message/attribute corresponding to a diagnostic message.
-type FluentId = Cow<'static, str>;
-
 /// Abstraction over a message in a subdiagnostic (i.e. label, note, help, etc) to support both
 /// translatable and non-translatable diagnostic messages.
 ///
@@ -244,18 +241,9 @@ type FluentId = Cow<'static, str>;
 pub enum SubdiagMessage {
     /// Non-translatable diagnostic message.
     Str(Cow<'static, str>),
-    /// Identifier of a Fluent message. Instances of this variant are generated by the
-    /// `Subdiagnostic` derive.
-    FluentIdentifier(FluentId),
     /// An inline Fluent message. Instances of this variant are generated by the
     /// `Subdiagnostic` derive.
     Inline(Cow<'static, str>),
-    /// Attribute of a Fluent message. Needs to be combined with a Fluent identifier to produce an
-    /// actual translated message. Instances of this variant are generated by the `fluent_messages`
-    /// macro.
-    ///
-    /// <https://projectfluent.org/fluent/guide/attributes.html>
-    FluentAttr(FluentId),
 }
 
 impl From<String> for SubdiagMessage {
@@ -288,12 +276,6 @@ pub enum DiagMessage {
     /// are translated when they are added to the parent diagnostic. This is one of the ways
     /// this variant of `DiagMessage` is produced.
     Str(Cow<'static, str>),
-    /// Identifier for a Fluent message (with optional attribute) corresponding to the diagnostic
-    /// message. Yet to be translated.
-    ///
-    /// <https://projectfluent.org/fluent/guide/hello.html>
-    /// <https://projectfluent.org/fluent/guide/attributes.html>
-    FluentIdentifier(FluentId, Option<FluentId>),
     /// An inline Fluent message, containing the to be translated diagnostic message.
     Inline(Cow<'static, str>),
 }
@@ -305,27 +287,16 @@ impl DiagMessage {
     /// - If the `SubdiagMessage` is non-translatable then return the message as a `DiagMessage`.
     /// - If `self` is non-translatable then return `self`'s message.
     pub fn with_subdiagnostic_message(&self, sub: SubdiagMessage) -> Self {
-        let attr = match sub {
-            SubdiagMessage::Str(s) => return DiagMessage::Str(s),
-            SubdiagMessage::FluentIdentifier(id) => {
-                return DiagMessage::FluentIdentifier(id, None);
-            }
-            SubdiagMessage::Inline(s) => return DiagMessage::Inline(s),
-            SubdiagMessage::FluentAttr(attr) => attr,
-        };
-
-        match self {
-            DiagMessage::FluentIdentifier(id, _) => {
-                DiagMessage::FluentIdentifier(id.clone(), Some(attr))
-            }
-            _ => panic!("Tried to add a subdiagnostic to a message without a fluent identifier"),
+        match sub {
+            SubdiagMessage::Str(s) => DiagMessage::Str(s),
+            SubdiagMessage::Inline(s) => DiagMessage::Inline(s),
         }
     }
 
     pub fn as_str(&self) -> Option<&str> {
         match self {
             DiagMessage::Str(s) => Some(s),
-            DiagMessage::FluentIdentifier(_, _) | DiagMessage::Inline(_) => None,
+            DiagMessage::Inline(_) => None,
         }
     }
 }
@@ -355,10 +326,6 @@ impl From<DiagMessage> for SubdiagMessage {
     fn from(val: DiagMessage) -> Self {
         match val {
             DiagMessage::Str(s) => SubdiagMessage::Str(s),
-            DiagMessage::FluentIdentifier(id, None) => SubdiagMessage::FluentIdentifier(id),
-            // There isn't really a sensible behaviour for this because it loses information but
-            // this is the most sensible of the behaviours.
-            DiagMessage::FluentIdentifier(_, Some(attr)) => SubdiagMessage::FluentAttr(attr),
             DiagMessage::Inline(s) => SubdiagMessage::Inline(s),
         }
     }
diff --git a/compiler/rustc_errors/src/json/tests.rs b/compiler/rustc_errors/src/json/tests.rs
index 6f99930c433be..ffcf9947a7a86 100644
--- a/compiler/rustc_errors/src/json/tests.rs
+++ b/compiler/rustc_errors/src/json/tests.rs
@@ -45,7 +45,7 @@ fn test_positions(code: &str, span: (u32, u32), expected_output: SpanTestData) {
     rustc_span::create_default_session_globals_then(|| {
         let sm = Arc::new(SourceMap::new(FilePathMapping::empty()));
         sm.new_source_file(filename(&sm, "test.rs"), code.to_owned());
-        let translator = Translator::with_fallback_bundle(vec![], false);
+        let translator = Translator::new();
 
         let output = Arc::new(Mutex::new(Vec::new()));
         let je = JsonEmitter::new(
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 534fe32a897f0..2e0afb8fc4c2d 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -83,8 +83,6 @@ pub mod error;
 pub mod json;
 mod lock;
 pub mod markdown;
-#[cfg(test)]
-mod tests;
 pub mod timings;
 pub mod translation;
 
diff --git a/compiler/rustc_errors/src/tests.rs b/compiler/rustc_errors/src/tests.rs
deleted file mode 100644
index 34ebac0fde11b..0000000000000
--- a/compiler/rustc_errors/src/tests.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-use std::sync::{Arc, LazyLock};
-
-use rustc_data_structures::sync::IntoDynSyncSend;
-use rustc_error_messages::fluent_bundle::resolver::errors::{ReferenceKind, ResolverError};
-use rustc_error_messages::{DiagMessage, langid};
-
-use crate::FluentBundle;
-use crate::error::{TranslateError, TranslateErrorKind};
-use crate::fluent_bundle::*;
-use crate::translation::Translator;
-
-fn make_translator(ftl: &'static str) -> Translator {
-    let resource = FluentResource::try_new(ftl.into()).expect("Failed to parse an FTL string.");
-
-    let langid_en = langid!("en-US");
-
-    let mut bundle: FluentBundle =
-        IntoDynSyncSend(crate::fluent_bundle::bundle::FluentBundle::new_concurrent(vec![
-            langid_en,
-        ]));
-
-    bundle.add_resource(resource).expect("Failed to add FTL resources to the bundle.");
-
-    Translator {
-        fluent_bundle: None,
-        fallback_fluent_bundle: Arc::new(LazyLock::new(Box::new(|| bundle))),
-    }
-}
-
-#[test]
-fn wellformed_fluent() {
-    let translator = make_translator("mir_build_borrow_of_moved_value = borrow of moved value
-    .label = value moved into `{$name}` here
-    .occurs_because_label = move occurs because `{$name}` has type `{$ty}` which does not implement the `Copy` trait
-    .value_borrowed_label = value borrowed here after move
-    .suggestion = borrow this binding in the pattern to avoid moving the value");
-
-    let mut args = FluentArgs::new();
-    args.set("name", "Foo");
-    args.set("ty", "std::string::String");
-    {
-        let message = DiagMessage::FluentIdentifier(
-            "mir_build_borrow_of_moved_value".into(),
-            Some("suggestion".into()),
-        );
-
-        assert_eq!(
-            translator.translate_message(&message, &args).unwrap(),
-            "borrow this binding in the pattern to avoid moving the value"
-        );
-    }
-
-    {
-        let message = DiagMessage::FluentIdentifier(
-            "mir_build_borrow_of_moved_value".into(),
-            Some("value_borrowed_label".into()),
-        );
-
-        assert_eq!(
-            translator.translate_message(&message, &args).unwrap(),
-            "value borrowed here after move"
-        );
-    }
-
-    {
-        let message = DiagMessage::FluentIdentifier(
-            "mir_build_borrow_of_moved_value".into(),
-            Some("occurs_because_label".into()),
-        );
-
-        assert_eq!(
-            translator.translate_message(&message, &args).unwrap(),
-            "move occurs because `\u{2068}Foo\u{2069}` has type `\u{2068}std::string::String\u{2069}` which does not implement the `Copy` trait"
-        );
-
-        {
-            let message = DiagMessage::FluentIdentifier(
-                "mir_build_borrow_of_moved_value".into(),
-                Some("label".into()),
-            );
-
-            assert_eq!(
-                translator.translate_message(&message, &args).unwrap(),
-                "value moved into `\u{2068}Foo\u{2069}` here"
-            );
-        }
-    }
-}
-
-#[test]
-fn misformed_fluent() {
-    let translator = make_translator("mir_build_borrow_of_moved_value = borrow of moved value
-    .label = value moved into `{name}` here
-    .occurs_because_label = move occurs because `{$oops}` has type `{$ty}` which does not implement the `Copy` trait
-    .suggestion = borrow this binding in the pattern to avoid moving the value");
-
-    let mut args = FluentArgs::new();
-    args.set("name", "Foo");
-    args.set("ty", "std::string::String");
-    {
-        let message = DiagMessage::FluentIdentifier(
-            "mir_build_borrow_of_moved_value".into(),
-            Some("value_borrowed_label".into()),
-        );
-
-        let err = translator.translate_message(&message, &args).unwrap_err();
-        assert!(
-            matches!(
-                &err,
-                TranslateError::Two {
-                    primary: box TranslateError::One {
-                        kind: TranslateErrorKind::PrimaryBundleMissing,
-                        ..
-                    },
-                    fallback: box TranslateError::One {
-                        kind: TranslateErrorKind::AttributeMissing { attr: "value_borrowed_label" },
-                        ..
-                    }
-                }
-            ),
-            "{err:#?}"
-        );
-        assert_eq!(
-            format!("{err}"),
-            "failed while formatting fluent string `mir_build_borrow_of_moved_value`: \nthe attribute `value_borrowed_label` was missing\nhelp: add `.value_borrowed_label = <message>`\n"
-        );
-    }
-
-    {
-        let message = DiagMessage::FluentIdentifier(
-            "mir_build_borrow_of_moved_value".into(),
-            Some("label".into()),
-        );
-
-        let err = translator.translate_message(&message, &args).unwrap_err();
-        if let TranslateError::Two {
-            primary: box TranslateError::One { kind: TranslateErrorKind::PrimaryBundleMissing, .. },
-            fallback: box TranslateError::One { kind: TranslateErrorKind::Fluent { errs }, .. },
-        } = &err
-            && let [
-                FluentError::ResolverError(ResolverError::Reference(
-                    ReferenceKind::Message { id, .. } | ReferenceKind::Variable { id, .. },
-                )),
-            ] = &**errs
-            && id == "name"
-        {
-        } else {
-            panic!("{err:#?}")
-        };
-        assert_eq!(
-            format!("{err}"),
-            "failed while formatting fluent string `mir_build_borrow_of_moved_value`: \nargument `name` exists but was not referenced correctly\nhelp: try using `{$name}` instead\n"
-        );
-    }
-
-    {
-        let message = DiagMessage::FluentIdentifier(
-            "mir_build_borrow_of_moved_value".into(),
-            Some("occurs_because_label".into()),
-        );
-
-        let err = translator.translate_message(&message, &args).unwrap_err();
-        if let TranslateError::Two {
-            primary: box TranslateError::One { kind: TranslateErrorKind::PrimaryBundleMissing, .. },
-            fallback: box TranslateError::One { kind: TranslateErrorKind::Fluent { errs }, .. },
-        } = &err
-            && let [
-                FluentError::ResolverError(ResolverError::Reference(
-                    ReferenceKind::Message { id, .. } | ReferenceKind::Variable { id, .. },
-                )),
-            ] = &**errs
-            && id == "oops"
-        {
-        } else {
-            panic!("{err:#?}")
-        };
-        assert_eq!(
-            format!("{err}"),
-            "failed while formatting fluent string `mir_build_borrow_of_moved_value`: \nthe fluent string has an argument `oops` that was not found.\nhelp: the arguments `name` and `ty` are available\n"
-        );
-    }
-}
diff --git a/compiler/rustc_errors/src/translation.rs b/compiler/rustc_errors/src/translation.rs
index ed3f9a405342e..b5de3f87e9f35 100644
--- a/compiler/rustc_errors/src/translation.rs
+++ b/compiler/rustc_errors/src/translation.rs
@@ -1,5 +1,4 @@
 use std::borrow::Cow;
-use std::env;
 use std::error::Report;
 use std::sync::Arc;
 
@@ -7,7 +6,7 @@ pub use rustc_error_messages::{FluentArgs, LazyFallbackBundle};
 use rustc_error_messages::{langid, register_functions};
 use tracing::{debug, trace};
 
-use crate::error::{TranslateError, TranslateErrorKind};
+use crate::error::TranslateError;
 use crate::fluent_bundle::FluentResource;
 use crate::{DiagArg, DiagMessage, FluentBundle, Style, fluent_bundle};
 
@@ -35,24 +34,11 @@ pub struct Translator {
     /// Localized diagnostics for the locale requested by the user. If no language was requested by
     /// the user then this will be `None` and `fallback_fluent_bundle` should be used.
     pub fluent_bundle: Option<Arc<FluentBundle>>,
-    /// Return `FluentBundle` with localized diagnostics for the default locale of the compiler.
-    /// Used when the user has not requested a specific language or when a localized diagnostic is
-    /// unavailable for the requested locale.
-    pub fallback_fluent_bundle: LazyFallbackBundle,
 }
 
 impl Translator {
-    pub fn with_fallback_bundle(
-        resources: Vec<&'static str>,
-        with_directionality_markers: bool,
-    ) -> Translator {
-        Translator {
-            fluent_bundle: None,
-            fallback_fluent_bundle: crate::fallback_fluent_bundle(
-                resources,
-                with_directionality_markers,
-            ),
-        }
+    pub fn new() -> Translator {
+        Translator { fluent_bundle: None }
     }
 
     /// Convert `DiagMessage`s to a string, performing translation if necessary.
@@ -76,11 +62,8 @@ impl Translator {
         args: &'a FluentArgs<'_>,
     ) -> Result<Cow<'a, str>, TranslateError<'a>> {
         trace!(?message, ?args);
-        let (identifier, attr) = match message {
-            DiagMessage::Str(msg) => {
-                return Ok(Cow::Borrowed(msg));
-            }
-            DiagMessage::FluentIdentifier(identifier, attr) => (identifier, attr),
+        match message {
+            DiagMessage::Str(msg) => Ok(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.
@@ -98,71 +81,11 @@ impl Translator {
                 let mut errs = vec![];
                 let translated = bundle.format_pattern(value, Some(args), &mut errs).to_string();
                 debug!(?translated, ?errs);
-                return if errs.is_empty() {
+                if errs.is_empty() {
                     Ok(Cow::Owned(translated))
                 } else {
                     Err(TranslateError::fluent(&Cow::Borrowed(GENERATED_MSG_ID), args, errs))
-                };
-            }
-        };
-        let translate_with_bundle =
-            |bundle: &'a FluentBundle| -> Result<Cow<'_, str>, TranslateError<'_>> {
-                let message = bundle
-                    .get_message(identifier)
-                    .ok_or(TranslateError::message(identifier, args))?;
-                let value = match attr {
-                    Some(attr) => message
-                        .get_attribute(attr)
-                        .ok_or(TranslateError::attribute(identifier, args, attr))?
-                        .value(),
-                    None => message.value().ok_or(TranslateError::value(identifier, args))?,
-                };
-                debug!(?message, ?value);
-
-                let mut errs = vec![];
-                let translated = bundle.format_pattern(value, Some(args), &mut errs);
-                debug!(?translated, ?errs);
-                if errs.is_empty() {
-                    Ok(translated)
-                } else {
-                    Err(TranslateError::fluent(identifier, args, errs))
                 }
-            };
-
-        try {
-            match self.fluent_bundle.as_ref().map(|b| translate_with_bundle(b)) {
-                // The primary bundle was present and translation succeeded
-                Some(Ok(t)) => t,
-
-                // If `translate_with_bundle` returns `Err` with the primary bundle, this is likely
-                // just that the primary bundle doesn't contain the message being translated, so
-                // proceed to the fallback bundle.
-                Some(Err(
-                    primary @ TranslateError::One {
-                        kind: TranslateErrorKind::MessageMissing, ..
-                    },
-                )) => translate_with_bundle(&self.fallback_fluent_bundle)
-                    .map_err(|fallback| primary.and(fallback))?,
-
-                // Always yeet out for errors on debug (unless
-                // `RUSTC_TRANSLATION_NO_DEBUG_ASSERT` is set in the environment - this allows
-                // local runs of the test suites, of builds with debug assertions, to test the
-                // behaviour in a normal build).
-                Some(Err(primary))
-                    if cfg!(debug_assertions)
-                        && env::var("RUSTC_TRANSLATION_NO_DEBUG_ASSERT").is_err() =>
-                {
-                    do yeet primary
-                }
-
-                // ..otherwise, for end users, an error about this wouldn't be useful or actionable, so
-                // just hide it and try with the fallback bundle.
-                Some(Err(primary)) => translate_with_bundle(&self.fallback_fluent_bundle)
-                    .map_err(|fallback| primary.and(fallback))?,
-
-                // The primary bundle is missing, proceed to the fallback bundle
-                None => translate_with_bundle(&self.fallback_fluent_bundle)
-                    .map_err(|fallback| TranslateError::primary(identifier, args).and(fallback))?,
             }
         }
     }
diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs
index 722e9a420540f..72080c5f53696 100644
--- a/compiler/rustc_interface/src/interface.rs
+++ b/compiler/rustc_interface/src/interface.rs
@@ -332,9 +332,6 @@ pub struct Config {
     /// bjorn3 for "hooking rust-analyzer's VFS into rustc at some point for
     /// running rustc without having to save". (See #102759.)
     pub file_loader: Option<Box<dyn FileLoader + Send + Sync>>,
-    /// The list of fluent resources, used for lints declared with
-    /// [`Diagnostic`](rustc_errors::Diagnostic) and [`LintDiagnostic`](rustc_errors::LintDiagnostic).
-    pub locale_resources: Vec<&'static str>,
 
     pub lint_caps: FxHashMap<lint::LintId, lint::Level>,
 
@@ -458,7 +455,6 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
                     temps_dir,
                 },
                 bundle,
-                config.locale_resources,
                 config.lint_caps,
                 target,
                 util::rustc_version_str().unwrap_or("unknown"),
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index 4241af244941e..5ebf898f45a34 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -72,7 +72,6 @@ where
             sessopts,
             io,
             None,
-            vec![],
             Default::default(),
             target,
             "",
diff --git a/compiler/rustc_macros/src/diagnostics/diagnostic.rs b/compiler/rustc_macros/src/diagnostics/diagnostic.rs
index e8356655dd9f6..dc8231e5f0b06 100644
--- a/compiler/rustc_macros/src/diagnostics/diagnostic.rs
+++ b/compiler/rustc_macros/src/diagnostics/diagnostic.rs
@@ -1,7 +1,5 @@
 #![deny(unused_must_use)]
 
-use std::cell::RefCell;
-
 use proc_macro2::TokenStream;
 use quote::quote;
 use synstructure::Structure;
@@ -22,7 +20,6 @@ impl<'a> DiagnosticDerive<'a> {
     pub(crate) fn into_tokens(self) -> TokenStream {
         let DiagnosticDerive { mut structure } = self;
         let kind = DiagnosticDeriveKind::Diagnostic;
-        let messages = RefCell::new(Vec::new());
         let implementation = kind.each_variant(&mut structure, |mut builder, variant| {
             let preamble = builder.preamble(variant);
             let body = builder.body(variant);
@@ -30,7 +27,6 @@ impl<'a> DiagnosticDerive<'a> {
             let Some(message) = builder.primary_message() else {
                 return DiagnosticDeriveError::ErrorHandled.to_compile_error();
             };
-            messages.borrow_mut().push(message.clone());
             let message = message.diag_message(Some(variant));
 
             let init = quote! {
@@ -52,9 +48,7 @@ impl<'a> DiagnosticDerive<'a> {
         });
 
         // A lifetime of `'a` causes conflicts, but `_sess` is fine.
-        // FIXME(edition_2024): Fix the `keyword_idents_2024` lint to not trigger here?
-        #[allow(keyword_idents_2024)]
-        let mut imp = structure.gen_impl(quote! {
+        structure.gen_impl(quote! {
             gen impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for @Self
                 where G: rustc_errors::EmissionGuarantee
             {
@@ -67,11 +61,7 @@ impl<'a> DiagnosticDerive<'a> {
                     #implementation
                 }
             }
-        });
-        for test in messages.borrow().iter().map(|s| s.generate_test(&structure)) {
-            imp.extend(test);
-        }
-        imp
+        })
     }
 }
 
@@ -88,7 +78,6 @@ impl<'a> LintDiagnosticDerive<'a> {
     pub(crate) fn into_tokens(self) -> TokenStream {
         let LintDiagnosticDerive { mut structure } = self;
         let kind = DiagnosticDeriveKind::LintDiagnostic;
-        let messages = RefCell::new(Vec::new());
         let implementation = kind.each_variant(&mut structure, |mut builder, variant| {
             let preamble = builder.preamble(variant);
             let body = builder.body(variant);
@@ -96,7 +85,6 @@ impl<'a> LintDiagnosticDerive<'a> {
             let Some(message) = builder.primary_message() else {
                 return DiagnosticDeriveError::ErrorHandled.to_compile_error();
             };
-            messages.borrow_mut().push(message.clone());
             let message = message.diag_message(Some(variant));
             let primary_message = quote! {
                 diag.primary_message(#message);
@@ -112,9 +100,7 @@ impl<'a> LintDiagnosticDerive<'a> {
             }
         });
 
-        // FIXME(edition_2024): Fix the `keyword_idents_2024` lint to not trigger here?
-        #[allow(keyword_idents_2024)]
-        let mut imp = structure.gen_impl(quote! {
+        structure.gen_impl(quote! {
             gen impl<'__a> rustc_errors::LintDiagnostic<'__a, ()> for @Self {
                 #[track_caller]
                 fn decorate_lint<'__b>(
@@ -124,11 +110,6 @@ impl<'a> LintDiagnosticDerive<'a> {
                     #implementation;
                 }
             }
-        });
-        for test in messages.borrow().iter().map(|s| s.generate_test(&structure)) {
-            imp.extend(test);
-        }
-
-        imp
+        })
     }
 }
diff --git a/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs b/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs
index 6107b181eea29..b386408a19186 100644
--- a/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs
+++ b/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs
@@ -4,7 +4,7 @@ use proc_macro2::{Ident, Span, TokenStream};
 use quote::{format_ident, quote, quote_spanned};
 use syn::parse::ParseStream;
 use syn::spanned::Spanned;
-use syn::{Attribute, LitStr, Meta, Path, Token, Type, parse_quote};
+use syn::{Attribute, LitStr, Meta, Path, Token, Type};
 use synstructure::{BindingInfo, Structure, VariantInfo};
 
 use super::utils::SubdiagnosticVariant;
@@ -109,24 +109,14 @@ impl DiagnosticDeriveVariantBuilder {
     pub(crate) fn primary_message(&self) -> Option<&Message> {
         match self.message.as_ref() {
             None => {
-                span_err(self.span, "diagnostic slug not specified")
+                span_err(self.span, "diagnostic message not specified")
                     .help(
-                        "specify the slug as the first argument to the `#[diag(...)]` \
-                            attribute, such as `#[diag(hir_analysis_example_error)]`",
+                        "specify the message as the first argument to the `#[diag(...)]` \
+                            attribute, such as `#[diag(\"Example error\")]`",
                     )
                     .emit();
                 None
             }
-            Some(Message::Slug(slug))
-                if let Some(Mismatch { slug_name, crate_name, slug_prefix }) =
-                    Mismatch::check(slug) =>
-            {
-                span_err(slug.span().unwrap(), "diagnostic slug and crate name do not match")
-                    .note(format!("slug is `{slug_name}` but the crate name is `{crate_name}`"))
-                    .help(format!("expected a slug starting with `{slug_prefix}_...`"))
-                    .emit();
-                None
-            }
             Some(msg) => Some(msg),
         }
     }
@@ -177,25 +167,15 @@ impl DiagnosticDeriveVariantBuilder {
                 .help("consider creating a `Subdiagnostic` instead"));
         }
 
-        // For subdiagnostics without a message specified, insert a placeholder slug
-        let slug = subdiag.slug.unwrap_or_else(|| {
-            Message::Slug(match subdiag.kind {
-                SubdiagnosticKind::Label => parse_quote! { _subdiag::label },
-                SubdiagnosticKind::Note => parse_quote! { _subdiag::note },
-                SubdiagnosticKind::NoteOnce => parse_quote! { _subdiag::note_once },
-                SubdiagnosticKind::Help => parse_quote! { _subdiag::help },
-                SubdiagnosticKind::HelpOnce => parse_quote! { _subdiag::help_once },
-                SubdiagnosticKind::Warn => parse_quote! { _subdiag::warn },
-                SubdiagnosticKind::Suggestion { .. } => parse_quote! { _subdiag::suggestion },
-                SubdiagnosticKind::MultipartSuggestion { .. } => unreachable!(),
-            })
-        });
+        let Some(message) = subdiag.message else {
+            throw_invalid_attr!(attr, |diag| diag.help("subdiagnostic message is missing"))
+        };
 
-        Ok(Some((subdiag.kind, slug, false)))
+        Ok(Some((subdiag.kind, message, false)))
     }
 
     /// Establishes state in the `DiagnosticDeriveBuilder` resulting from the struct
-    /// attributes like `#[diag(..)]`, such as the slug and error code. Generates
+    /// attributes like `#[diag(..)]`, such as the message and error code. Generates
     /// diagnostic builder calls for setting error code and creating note/help messages.
     fn generate_structure_code_for_attr(
         &mut self,
@@ -213,9 +193,6 @@ impl DiagnosticDeriveVariantBuilder {
         if name == "diag" {
             let mut tokens = TokenStream::new();
             attr.parse_args_with(|input: ParseStream<'_>| {
-                let mut input = &*input;
-                let slug_recovery_point = input.fork();
-
                 if input.peek(LitStr) {
                     // Parse an inline message
                     let message = input.parse::<LitStr>()?;
@@ -226,15 +203,8 @@ impl DiagnosticDeriveVariantBuilder {
                         )
                         .emit();
                     }
-                    self.message = Some(Message::Inline(message.span(), message.value()));
-                } else {
-                    // Parse a slug
-                    let slug = input.parse::<Path>()?;
-                    if input.is_empty() || input.peek(Token![,]) {
-                        self.message = Some(Message::Slug(slug));
-                    } else {
-                        input = &slug_recovery_point;
-                    }
+                    self.message =
+                        Some(Message { message_span: message.span(), value: message.value() });
                 }
 
                 // Parse arguments
@@ -248,7 +218,7 @@ impl DiagnosticDeriveVariantBuilder {
                     if input.peek(Token![,]) {
                         span_err(
                             arg_name.span().unwrap(),
-                            "diagnostic slug must be the first argument",
+                            "diagnostic message must be the first argument",
                         )
                         .emit();
                         continue;
@@ -265,7 +235,7 @@ impl DiagnosticDeriveVariantBuilder {
                         }
                         _ => {
                             span_err(arg_name.span().unwrap(), "unknown argument")
-                                .note("only the `code` parameter is valid after the slug")
+                                .note("only the `code` parameter is valid after the message")
                                 .emit();
                         }
                     }
@@ -276,7 +246,7 @@ impl DiagnosticDeriveVariantBuilder {
             return Ok(tokens);
         }
 
-        let Some((subdiag, slug, _no_span)) = self.parse_subdiag_attribute(attr)? else {
+        let Some((subdiag, message, _no_span)) = self.parse_subdiag_attribute(attr)? else {
             // Some attributes aren't errors - like documentation comments - but also aren't
             // subdiagnostics.
             return Ok(quote! {});
@@ -287,7 +257,7 @@ impl DiagnosticDeriveVariantBuilder {
             | SubdiagnosticKind::NoteOnce
             | SubdiagnosticKind::Help
             | SubdiagnosticKind::HelpOnce
-            | SubdiagnosticKind::Warn => Ok(self.add_subdiagnostic(&fn_ident, slug, variant)),
+            | SubdiagnosticKind::Warn => Ok(self.add_subdiagnostic(&fn_ident, message, variant)),
             SubdiagnosticKind::Label | SubdiagnosticKind::Suggestion { .. } => {
                 throw_invalid_attr!(attr, |diag| diag
                     .help("`#[label]` and `#[suggestion]` can only be applied to fields"));
@@ -406,7 +376,7 @@ impl DiagnosticDeriveVariantBuilder {
             _ => (),
         }
 
-        let Some((subdiag, slug, _no_span)) = self.parse_subdiag_attribute(attr)? else {
+        let Some((subdiag, message, _no_span)) = self.parse_subdiag_attribute(attr)? else {
             // Some attributes aren't errors - like documentation comments - but also aren't
             // subdiagnostics.
             return Ok(quote! {});
@@ -415,7 +385,7 @@ impl DiagnosticDeriveVariantBuilder {
         match subdiag {
             SubdiagnosticKind::Label => {
                 report_error_if_not_applied_to_span(attr, &info)?;
-                Ok(self.add_spanned_subdiagnostic(binding, &fn_ident, slug, variant))
+                Ok(self.add_spanned_subdiagnostic(binding, &fn_ident, message, variant))
             }
             SubdiagnosticKind::Note
             | SubdiagnosticKind::NoteOnce
@@ -426,11 +396,11 @@ impl DiagnosticDeriveVariantBuilder {
                 if type_matches_path(inner, &["rustc_span", "Span"])
                     || type_matches_path(inner, &["rustc_span", "MultiSpan"])
                 {
-                    Ok(self.add_spanned_subdiagnostic(binding, &fn_ident, slug, variant))
+                    Ok(self.add_spanned_subdiagnostic(binding, &fn_ident, message, variant))
                 } else if type_is_unit(inner)
                     || (matches!(info.ty, FieldInnerTy::Plain(_)) && type_is_bool(inner))
                 {
-                    Ok(self.add_subdiagnostic(&fn_ident, slug, variant))
+                    Ok(self.add_subdiagnostic(&fn_ident, message, variant))
                 } else {
                     report_type_error(attr, "`Span`, `MultiSpan`, `bool` or `()`")?
                 }
@@ -456,7 +426,7 @@ impl DiagnosticDeriveVariantBuilder {
                     applicability.set_once(quote! { #static_applicability }, span);
                 }
 
-                let message = slug.diag_message(Some(variant));
+                let message = message.diag_message(Some(variant));
                 let applicability = applicability
                     .value()
                     .unwrap_or_else(|| quote! { rustc_errors::Applicability::Unspecified });
@@ -477,7 +447,7 @@ impl DiagnosticDeriveVariantBuilder {
         }
     }
 
-    /// Adds a spanned subdiagnostic by generating a `diag.span_$kind` call with the current slug
+    /// Adds a spanned subdiagnostic by generating a `diag.span_$kind` call with the current message
     /// and `fluent_attr_identifier`.
     fn add_spanned_subdiagnostic(
         &self,
@@ -496,7 +466,7 @@ impl DiagnosticDeriveVariantBuilder {
         }
     }
 
-    /// Adds a subdiagnostic by generating a `diag.span_$kind` call with the current slug
+    /// Adds a subdiagnostic by generating a `diag.span_$kind` call with the current message
     /// and `fluent_attr_identifier`.
     fn add_subdiagnostic(
         &self,
@@ -567,27 +537,3 @@ impl DiagnosticDeriveVariantBuilder {
         }
     }
 }
-
-struct Mismatch {
-    slug_name: String,
-    crate_name: String,
-    slug_prefix: String,
-}
-
-impl Mismatch {
-    /// Checks whether the slug starts with the crate name it's in.
-    fn check(slug: &syn::Path) -> Option<Mismatch> {
-        // If this is missing we're probably in a test, so bail.
-        let crate_name = std::env::var("CARGO_CRATE_NAME").ok()?;
-
-        // If we're not in a "rustc_" crate, bail.
-        let Some(("rustc", slug_prefix)) = crate_name.split_once('_') else { return None };
-
-        let slug_name = slug.segments.first()?.ident.to_string();
-        if slug_name.starts_with(slug_prefix) {
-            return None;
-        }
-
-        Some(Mismatch { slug_name, slug_prefix: slug_prefix.to_string(), crate_name })
-    }
-}
diff --git a/compiler/rustc_macros/src/diagnostics/message.rs b/compiler/rustc_macros/src/diagnostics/message.rs
index 2db8df2f69ae3..18d4d60dde3ee 100644
--- a/compiler/rustc_macros/src/diagnostics/message.rs
+++ b/compiler/rustc_macros/src/diagnostics/message.rs
@@ -2,16 +2,15 @@ use fluent_bundle::FluentResource;
 use fluent_syntax::ast::{Expression, InlineExpression, Pattern, PatternElement};
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
-use syn::Path;
 use syn::ext::IdentExt;
-use synstructure::{Structure, VariantInfo};
+use synstructure::VariantInfo;
 
 use crate::diagnostics::error::span_err;
 
 #[derive(Clone)]
-pub(crate) enum Message {
-    Slug(Path),
-    Inline(Span, String),
+pub(crate) struct Message {
+    pub message_span: Span,
+    pub value: String,
 }
 
 impl Message {
@@ -19,69 +18,9 @@ impl Message {
     /// The passed `variant` is used to check whether all variables in the message are used.
     /// For subdiagnostics, we cannot check this.
     pub(crate) fn diag_message(&self, variant: Option<&VariantInfo<'_>>) -> TokenStream {
-        match self {
-            Message::Slug(slug) => {
-                quote! { crate::fluent_generated::#slug }
-            }
-            Message::Inline(message_span, message) => {
-                verify_fluent_message(*message_span, &message, variant);
-                quote! { rustc_errors::DiagMessage::Inline(std::borrow::Cow::Borrowed(#message)) }
-            }
-        }
-    }
-
-    /// Generates a `#[test]` that verifies that all referenced variables
-    /// exist on this structure.
-    pub(crate) fn generate_test(&self, structure: &Structure<'_>) -> TokenStream {
-        match self {
-            Message::Slug(slug) => {
-                // FIXME: We can't identify variables in a subdiagnostic
-                for field in structure.variants().iter().flat_map(|v| v.ast().fields.iter()) {
-                    for attr_name in field.attrs.iter().filter_map(|at| at.path().get_ident()) {
-                        if attr_name == "subdiagnostic" {
-                            return quote!();
-                        }
-                    }
-                }
-                use std::sync::atomic::{AtomicUsize, Ordering};
-                // We need to make sure that the same diagnostic slug can be used multiple times without
-                // causing an error, so just have a global counter here.
-                static COUNTER: AtomicUsize = AtomicUsize::new(0);
-                let slug = slug.get_ident().unwrap();
-                let ident = quote::format_ident!(
-                    "verify_{slug}_{}",
-                    COUNTER.fetch_add(1, Ordering::Relaxed)
-                );
-                let ref_slug = quote::format_ident!("{slug}_refs");
-                let struct_name = &structure.ast().ident;
-                let variables: Vec<_> = structure
-                    .variants()
-                    .iter()
-                    .flat_map(|v| {
-                        v.ast()
-                            .fields
-                            .iter()
-                            .filter_map(|f| f.ident.as_ref().map(|i| i.to_string()))
-                    })
-                    .collect();
-                // tidy errors on `#[test]` outside of test files, so we use `#[test ]` to work around this
-                quote! {
-                    #[cfg(test)]
-                    #[test ]
-                    fn #ident() {
-                        let variables = [#(#variables),*];
-                        for vref in crate::fluent_generated::#ref_slug {
-                            assert!(variables.contains(vref), "{}: variable `{vref}` not found ({})", stringify!(#struct_name), stringify!(#slug));
-                        }
-                    }
-                }
-            }
-            Message::Inline(..) => {
-                // We don't generate a test for inline diagnostics, we can verify these at compile-time!
-                // This verification is done in the `diag_message` function above
-                quote! {}
-            }
-        }
+        let message = &self.value;
+        verify_fluent_message(self.message_span, &message, variant);
+        quote! { rustc_errors::DiagMessage::Inline(std::borrow::Cow::Borrowed(#message)) }
     }
 }
 
diff --git a/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs b/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs
index ac1fa984664c2..7eb170ec236a3 100644
--- a/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs
+++ b/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs
@@ -186,10 +186,10 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
     fn identify_kind(
         &mut self,
     ) -> Result<Vec<(SubdiagnosticKind, Message)>, DiagnosticDeriveError> {
-        let mut kind_slugs = vec![];
+        let mut kind_messages = vec![];
 
         for attr in self.variant.ast().attrs {
-            let Some(SubdiagnosticVariant { kind, slug }) =
+            let Some(SubdiagnosticVariant { kind, message }) =
                 SubdiagnosticVariant::from_attr(attr, &self.fields)?
             else {
                 // Some attributes aren't errors - like documentation comments - but also aren't
@@ -197,22 +197,22 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
                 continue;
             };
 
-            let Some(slug) = slug else {
+            let Some(message) = message else {
                 let name = attr.path().segments.last().unwrap().ident.to_string();
                 let name = name.as_str();
 
                 throw_span_err!(
                     attr.span().unwrap(),
                     format!(
-                        "diagnostic slug must be first argument of a `#[{name}(...)]` attribute"
+                        "diagnostic message must be first argument of a `#[{name}(...)]` attribute"
                     )
                 );
             };
 
-            kind_slugs.push((kind, slug));
+            kind_messages.push((kind, message));
         }
 
-        Ok(kind_slugs)
+        Ok(kind_messages)
     }
 
     /// Generates the code for a field with no attributes.
@@ -498,9 +498,9 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
     }
 
     pub(crate) fn into_tokens(&mut self) -> Result<TokenStream, DiagnosticDeriveError> {
-        let kind_slugs = self.identify_kind()?;
+        let kind_messages = self.identify_kind()?;
 
-        let kind_stats: KindsStatistics = kind_slugs.iter().map(|(kind, _slug)| kind).collect();
+        let kind_stats: KindsStatistics = kind_messages.iter().map(|(kind, _msg)| kind).collect();
 
         let init = if kind_stats.has_multipart_suggestion {
             quote! { let mut suggestions = Vec::new(); }
@@ -516,7 +516,7 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
             .map(|binding| self.generate_field_attr_code(binding, kind_stats))
             .collect();
 
-        if kind_slugs.is_empty() && !self.has_subdiagnostic {
+        if kind_messages.is_empty() && !self.has_subdiagnostic {
             if self.is_enum {
                 // It's okay for a variant to not be a subdiagnostic at all..
                 return Ok(quote! {});
@@ -533,9 +533,9 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
 
         let diag = &self.parent.diag;
         let mut calls = TokenStream::new();
-        for (kind, slug) in kind_slugs {
+        for (kind, messages) in kind_messages {
             let message = format_ident!("__message");
-            let message_stream = slug.diag_message(None);
+            let message_stream = messages.diag_message(None);
             calls.extend(quote! { let #message = #diag.eagerly_translate(#message_stream); });
 
             let name = format_ident!("{}{}", if span_field.is_some() { "span_" } else { "" }, kind);
diff --git a/compiler/rustc_macros/src/diagnostics/utils.rs b/compiler/rustc_macros/src/diagnostics/utils.rs
index a5265a847a9c7..c308f6126325f 100644
--- a/compiler/rustc_macros/src/diagnostics/utils.rs
+++ b/compiler/rustc_macros/src/diagnostics/utils.rs
@@ -267,7 +267,7 @@ pub(super) type FieldMap = HashMap<String, TokenStream>;
 ///
 /// ```ignore (not-usage-example)
 /// /// Suggest `==` when users wrote `===`.
-/// #[suggestion(slug = "parser-not-javascript-eq", code = "{lhs} == {rhs}")]
+/// #[suggestion("example message", code = "{lhs} == {rhs}")]
 /// struct NotJavaScriptEq {
 ///     #[primary_span]
 ///     span: Span,
@@ -588,13 +588,13 @@ pub(super) enum SubdiagnosticKind {
 
 pub(super) struct SubdiagnosticVariant {
     pub(super) kind: SubdiagnosticKind,
-    pub(super) slug: Option<Message>,
+    pub(super) message: Option<Message>,
 }
 
 impl SubdiagnosticVariant {
     /// Constructs a `SubdiagnosticVariant` from a field or type attribute such as `#[note]`,
-    /// `#[error(parser::add_paren)]` or `#[suggestion(code = "...")]`. Returns the
-    /// `SubdiagnosticKind` and the diagnostic slug, if specified.
+    /// `#[error("add parenthesis")]` or `#[suggestion(code = "...")]`. Returns the
+    /// `SubdiagnosticKind` and the diagnostic message, if specified.
     pub(super) fn from_attr(
         attr: &Attribute,
         fields: &FieldMap,
@@ -660,11 +660,11 @@ impl SubdiagnosticVariant {
         let list = match &attr.meta {
             Meta::List(list) => {
                 // An attribute with properties, such as `#[suggestion(code = "...")]` or
-                // `#[error(some::slug)]`
+                // `#[error("message")]`
                 list
             }
             Meta::Path(_) => {
-                // An attribute without a slug or other properties, such as `#[note]` - return
+                // An attribute without a message or other properties, such as `#[note]` - return
                 // without further processing.
                 //
                 // Only allow this if there are no mandatory properties, such as `code = "..."` in
@@ -677,7 +677,7 @@ impl SubdiagnosticVariant {
                     | SubdiagnosticKind::HelpOnce
                     | SubdiagnosticKind::Warn
                     | SubdiagnosticKind::MultipartSuggestion { .. } => {
-                        return Ok(Some(SubdiagnosticVariant { kind, slug: None }));
+                        return Ok(Some(SubdiagnosticVariant { kind, message: None }));
                     }
                     SubdiagnosticKind::Suggestion { .. } => {
                         throw_span_err!(span, "suggestion without `code = \"...\"`")
@@ -692,45 +692,34 @@ impl SubdiagnosticVariant {
         let mut code = None;
         let mut suggestion_kind = None;
 
-        let mut slug = None;
+        let mut message = None;
 
         list.parse_args_with(|input: ParseStream<'_>| {
             let mut is_first = true;
             while !input.is_empty() {
                 // Try to parse an inline diagnostic message
                 if input.peek(LitStr) {
-                    let message = input.parse::<LitStr>()?;
-                    if !message.suffix().is_empty() {
+                    let inline_message = input.parse::<LitStr>()?;
+                    if !inline_message.suffix().is_empty() {
                         span_err(
-                            message.span().unwrap(),
+                            inline_message.span().unwrap(),
                             "Inline message is not allowed to have a suffix",
                         ).emit();
                     }
                     if !input.is_empty() { input.parse::<Token![,]>()?; }
                     if is_first {
-                        slug = Some(Message::Inline(message.span(), message.value()));
+                        message = Some(Message { message_span: inline_message.span(), value: inline_message.value() });
                         is_first = false;
                     } else {
-                        span_err(message.span().unwrap(), "a diagnostic message must be the first argument to the attribute").emit();
-                    }
-                    continue
-                }
-
-                // Try to parse a slug instead
-                let arg_name: Path = input.parse::<Path>()?;
-                let arg_name_span = arg_name.span().unwrap();
-                if input.is_empty() || input.parse::<Token![,]>().is_ok() {
-                    if is_first {
-                        slug = Some(Message::Slug(arg_name));
-                        is_first = false;
-                    } else {
-                        span_err(arg_name_span, "a diagnostic slug must be the first argument to the attribute").emit();
+                        span_err(inline_message.span().unwrap(), "a diagnostic message must be the first argument to the attribute").emit();
                     }
                     continue
                 }
                 is_first = false;
 
                 // Try to parse an argument
+                let arg_name: Path = input.parse::<Path>()?;
+                let arg_name_span = arg_name.span().unwrap();
                 match (arg_name.require_ident()?.to_string().as_str(), &mut kind) {
                     ("code", SubdiagnosticKind::Suggestion { code_field, .. }) => {
                         let code_init = build_suggestion_code(
@@ -836,7 +825,7 @@ impl SubdiagnosticVariant {
             | SubdiagnosticKind::Warn => {}
         }
 
-        Ok(Some(SubdiagnosticVariant { kind, slug }))
+        Ok(Some(SubdiagnosticVariant { kind, message }))
     }
 }
 
diff --git a/compiler/rustc_parse/src/parser/tests.rs b/compiler/rustc_parse/src/parser/tests.rs
index 1b17f422345f8..ac9c3e63e8534 100644
--- a/compiler/rustc_parse/src/parser/tests.rs
+++ b/compiler/rustc_parse/src/parser/tests.rs
@@ -42,7 +42,7 @@ fn string_to_parser(psess: &ParseSess, source_str: String) -> Parser<'_> {
 fn create_test_handler(theme: OutputTheme) -> (DiagCtxt, Arc<SourceMap>, Arc<Mutex<Vec<u8>>>) {
     let output = Arc::new(Mutex::new(Vec::new()));
     let source_map = Arc::new(SourceMap::new(FilePathMapping::empty()));
-    let translator = Translator::with_fallback_bundle(vec![], false);
+    let translator = Translator::new();
     let shared: Box<dyn Write + Send> = Box::new(Shared { data: output.clone() });
     let auto_stream = AutoStream::never(shared);
     let dcx = DiagCtxt::new(Box::new(
@@ -89,7 +89,7 @@ where
 
 /// Maps a string to tts, using a made-up filename.
 pub(crate) fn string_to_stream(source_str: String) -> TokenStream {
-    let psess = ParseSess::new(vec![]);
+    let psess = ParseSess::new();
     unwrap_or_emit_fatal(source_str_to_stream(
         &psess,
         filename(psess.source_map(), "bogofile"),
@@ -2239,12 +2239,12 @@ fn sp(a: u32, b: u32) -> Span {
 
 /// Parses a string, return an expression.
 fn string_to_expr(source_str: String) -> Box<ast::Expr> {
-    with_error_checking_parse(source_str, &ParseSess::new(vec![]), |p| p.parse_expr())
+    with_error_checking_parse(source_str, &ParseSess::new(), |p| p.parse_expr())
 }
 
 /// Parses a string, returns an item.
 fn string_to_item(source_str: String) -> Option<Box<ast::Item>> {
-    with_error_checking_parse(source_str, &ParseSess::new(vec![]), |p| {
+    with_error_checking_parse(source_str, &ParseSess::new(), |p| {
         p.parse_item(ForceCollect::No, AllowConstBlockItems::Yes)
     })
 }
@@ -2480,7 +2480,7 @@ let mut fflags: c_int = wb();
 #[test]
 fn crlf_doc_comments() {
     create_default_session_globals_then(|| {
-        let psess = ParseSess::new(vec![]);
+        let psess = ParseSess::new();
 
         let name_1 = FileName::Custom("crlf_source_1".to_string());
         let source = "/// doc comment\r\nfn foo() {}".to_string();
@@ -2515,7 +2515,7 @@ fn ttdelim_span() {
     }
 
     create_default_session_globals_then(|| {
-        let psess = ParseSess::new(vec![]);
+        let psess = ParseSess::new();
         let expr = parse_expr_from_source_str(
             filename(psess.source_map(), "foo"),
             "foo!( fn main() { body } )".to_string(),
@@ -2551,7 +2551,7 @@ fn look_ahead() {
         let sym_S = Symbol::intern("S");
         let raw_no = IdentIsRaw::No;
 
-        let psess = ParseSess::new(vec![]);
+        let psess = ParseSess::new();
         let mut p = string_to_parser(&psess, "fn f(x: u32) { x } struct S;".to_string());
 
         // Current position is the `fn`.
@@ -2626,7 +2626,7 @@ fn look_ahead_non_outermost_stream() {
         let sym_S = Symbol::intern("S");
         let raw_no = IdentIsRaw::No;
 
-        let psess = ParseSess::new(vec![]);
+        let psess = ParseSess::new();
         let mut p = string_to_parser(&psess, "mod m { fn f(x: u32) { x } struct S; }".to_string());
 
         // Move forward to the `fn`, which is not within the outermost token
@@ -2658,7 +2658,7 @@ fn look_ahead_non_outermost_stream() {
 #[test]
 fn debug_lookahead() {
     create_default_session_globals_then(|| {
-        let psess = ParseSess::new(vec![]);
+        let psess = ParseSess::new();
         let mut p = string_to_parser(&psess, "fn f(x: u32) { x } struct S;".to_string());
 
         // Current position is the `fn`.
@@ -2879,7 +2879,7 @@ fn debug_lookahead() {
 #[test]
 fn out_of_line_mod() {
     create_default_session_globals_then(|| {
-        let psess = ParseSess::new(vec![]);
+        let psess = ParseSess::new();
         let item = parse_item_from_source_str(
             filename(psess.source_map(), "foo"),
             "mod foo { struct S; mod this_does_not_exist; }".to_owned(),
diff --git a/compiler/rustc_session/src/parse.rs b/compiler/rustc_session/src/parse.rs
index 7bebbc579c438..62c23424f371f 100644
--- a/compiler/rustc_session/src/parse.rs
+++ b/compiler/rustc_session/src/parse.rs
@@ -280,8 +280,8 @@ pub struct ParseSess {
 
 impl ParseSess {
     /// Used for testing.
-    pub fn new(locale_resources: Vec<&'static str>) -> Self {
-        let translator = Translator::with_fallback_bundle(locale_resources, false);
+    pub fn new() -> Self {
+        let translator = Translator::new();
         let sm = Arc::new(SourceMap::new(FilePathMapping::empty()));
         let emitter = Box::new(
             AnnotateSnippetEmitter::new(stderr_destination(ColorConfig::Auto), translator)
@@ -314,7 +314,7 @@ impl ParseSess {
     }
 
     pub fn emitter_with_note(note: String) -> Self {
-        let translator = Translator::with_fallback_bundle(vec![], false);
+        let translator = Translator::new();
         let sm = Arc::new(SourceMap::new(FilePathMapping::empty()));
         let emitter = Box::new(AnnotateSnippetEmitter::new(
             stderr_destination(ColorConfig::Auto),
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 92c47e3bfb36e..ed37e9e960cd8 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -19,7 +19,7 @@ use rustc_errors::timings::TimingSectionHandler;
 use rustc_errors::translation::Translator;
 use rustc_errors::{
     Diag, DiagCtxt, DiagCtxtHandle, DiagMessage, Diagnostic, ErrorGuaranteed, FatalAbort,
-    TerminalUrl, fallback_fluent_bundle,
+    TerminalUrl,
 };
 use rustc_hir::limit::Limit;
 use rustc_macros::HashStable_Generic;
@@ -967,7 +967,6 @@ pub fn build_session(
     sopts: config::Options,
     io: CompilerIO,
     fluent_bundle: Option<Arc<rustc_errors::FluentBundle>>,
-    fluent_resources: Vec<&'static str>,
     driver_lint_caps: FxHashMap<lint::LintId, lint::Level>,
     target: Target,
     cfg_version: &'static str,
@@ -985,13 +984,7 @@ pub fn build_session(
     let cap_lints_allow = sopts.lint_cap.is_some_and(|cap| cap == lint::Allow);
     let can_emit_warnings = !(warnings_allow || cap_lints_allow);
 
-    let translator = Translator {
-        fluent_bundle,
-        fallback_fluent_bundle: fallback_fluent_bundle(
-            fluent_resources,
-            sopts.unstable_opts.translate_directionality_markers,
-        ),
-    };
+    let translator = Translator { fluent_bundle };
     let source_map = rustc_span::source_map::get_source_map().unwrap();
     let emitter = default_emitter(&sopts, Arc::clone(&source_map), translator);
 
@@ -1430,7 +1423,7 @@ impl EarlyDiagCtxt {
 fn mk_emitter(output: ErrorOutputType) -> Box<DynEmitter> {
     // FIXME(#100717): early errors aren't translated at the moment, so this is fine, but it will
     // need to reference every crate that might emit an early error for translation to work.
-    let translator = Translator::with_fallback_bundle(vec![], false);
+    let translator = Translator::new();
     let emitter: Box<DynEmitter> = match output {
         config::ErrorOutputType::HumanReadable { kind, color_config } => match kind {
             HumanReadableErrorType { short, unicode } => Box::new(
diff --git a/src/librustdoc/clean/render_macro_matchers.rs b/src/librustdoc/clean/render_macro_matchers.rs
index b5a8d64ff4f56..a69e3808bd7f7 100644
--- a/src/librustdoc/clean/render_macro_matchers.rs
+++ b/src/librustdoc/clean/render_macro_matchers.rs
@@ -63,7 +63,7 @@ fn snippet_equal_to_token(tcx: TyCtxt<'_>, matcher: &TokenTree) -> Option<String
     let snippet = source_map.span_to_snippet(span).ok()?;
 
     // Create a Parser.
-    let psess = ParseSess::new(rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec());
+    let psess = ParseSess::new();
     let file_name = FileName::macro_expansion_source_code(&snippet);
     let mut parser = match rustc_parse::new_parser_from_source_str(
         &psess,
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index a45175dc08f0d..7629425ffb559 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -289,7 +289,6 @@ pub(crate) fn create_config(
         output_file: None,
         output_dir: None,
         file_loader: None,
-        locale_resources: rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec(),
         lint_caps,
         psess_created: None,
         hash_untracked_state: None,
diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 0605d16699fa3..5d3715c70e087 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -188,7 +188,6 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, input: Input, options: RustdocOptions
         output_file: None,
         output_dir: None,
         file_loader: None,
-        locale_resources: rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec(),
         lint_caps,
         psess_created: None,
         hash_untracked_state: None,
diff --git a/tests/ui-fulldeps/mod_dir_path_canonicalized.rs b/tests/ui-fulldeps/mod_dir_path_canonicalized.rs
index 894fec248f1f9..806d395a90ad0 100644
--- a/tests/ui-fulldeps/mod_dir_path_canonicalized.rs
+++ b/tests/ui-fulldeps/mod_dir_path_canonicalized.rs
@@ -29,7 +29,7 @@ pub fn main() {
 }
 
 fn parse() {
-    let psess = ParseSess::new(vec![]);
+    let psess = ParseSess::new();
 
     let path = Path::new(file!());
     let path = path.canonicalize().unwrap();
diff --git a/tests/ui-fulldeps/pprust-expr-roundtrip.rs b/tests/ui-fulldeps/pprust-expr-roundtrip.rs
index 7fe71004522aa..8d7425186680a 100644
--- a/tests/ui-fulldeps/pprust-expr-roundtrip.rs
+++ b/tests/ui-fulldeps/pprust-expr-roundtrip.rs
@@ -219,7 +219,7 @@ fn main() {
 }
 
 fn run() {
-    let psess = ParseSess::new(vec![]);
+    let psess = ParseSess::new();
 
     iter_exprs(2, &mut |mut e| {
         // If the pretty printer is correct, then `parse(print(e))` should be identical to `e`,
diff --git a/tests/ui-fulldeps/pprust-parenthesis-insertion.rs b/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
index 90cf9b89a293b..85ee87155a7ae 100644
--- a/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
+++ b/tests/ui-fulldeps/pprust-parenthesis-insertion.rs
@@ -196,7 +196,7 @@ fn main() -> ExitCode {
     };
 
     rustc_span::create_default_session_globals_then(|| {
-        let psess = &ParseSess::new(vec![]);
+        let psess = &ParseSess::new();
 
         for &source_code in EXPRS {
             let Some(expr) = parse_expr(psess, source_code) else {
diff --git a/tests/ui-fulldeps/run-compiler-twice.rs b/tests/ui-fulldeps/run-compiler-twice.rs
index 8b5e99cbee8dc..bd92cc6218f19 100644
--- a/tests/ui-fulldeps/run-compiler-twice.rs
+++ b/tests/ui-fulldeps/run-compiler-twice.rs
@@ -64,7 +64,6 @@ fn compile(code: String, output: PathBuf, sysroot: Sysroot, linker: Option<&Path
         output_dir: None,
         ice_file: None,
         file_loader: None,
-        locale_resources: Vec::new(),
         lint_caps: Default::default(),
         psess_created: None,
         hash_untracked_state: None,
diff --git a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.rs b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.rs
index 1d2bfc66aaff0..ca803d450b92f 100644
--- a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.rs
+++ b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.rs
@@ -45,9 +45,9 @@ struct Hello {}
 //~^ ERROR unsupported type attribute for diagnostic derive enum
 enum DiagnosticOnEnum {
     Foo,
-    //~^ ERROR diagnostic slug not specified
+    //~^ ERROR diagnostic message not specified
     Bar,
-    //~^ ERROR diagnostic slug not specified
+    //~^ ERROR diagnostic message not specified
 }
 
 #[derive(Diagnostic)]
@@ -59,28 +59,28 @@ struct WrongStructAttrStyle {}
 #[derive(Diagnostic)]
 #[nonsense("this is an example message", code = E0123)]
 //~^ ERROR `#[nonsense(...)]` is not a valid attribute
-//~^^ ERROR diagnostic slug not specified
+//~^^ ERROR diagnostic message not specified
 //~^^^ ERROR cannot find attribute `nonsense` in this scope
 struct InvalidStructAttr {}
 
 #[derive(Diagnostic)]
 #[diag(code = E0123)]
-//~^ ERROR diagnostic slug not specified
+//~^ ERROR diagnostic message not specified
 struct InvalidLitNestedAttr {}
 
 #[derive(Diagnostic)]
 #[diag(nonsense("foo"), code = E0123, slug = "foo")]
-//~^ ERROR derive(Diagnostic): diagnostic slug not specified
+//~^ ERROR derive(Diagnostic): diagnostic message not specified
 struct InvalidNestedStructAttr1 {}
 
 #[derive(Diagnostic)]
 #[diag(nonsense = "...", code = E0123, slug = "foo")]
-//~^ ERROR diagnostic slug not specified
+//~^ ERROR diagnostic message not specified
 struct InvalidNestedStructAttr2 {}
 
 #[derive(Diagnostic)]
 #[diag(nonsense = 4, code = E0123, slug = "foo")]
-//~^ ERROR diagnostic slug not specified
+//~^ ERROR diagnostic message not specified
 struct InvalidNestedStructAttr3 {}
 
 #[derive(Diagnostic)]
@@ -109,15 +109,15 @@ struct CodeSpecifiedTwice {}
 
 #[derive(Diagnostic)]
 #[diag("this is an example message", no_crate::example, code = E0123)]
-//~^ ERROR diagnostic slug must be the first argument
+//~^ ERROR diagnostic message must be the first argument
 struct SlugSpecifiedTwice {}
 
 #[derive(Diagnostic)]
-struct KindNotProvided {} //~ ERROR diagnostic slug not specified
+struct KindNotProvided {} //~ ERROR diagnostic message not specified
 
 #[derive(Diagnostic)]
 #[diag(code = E0123)]
-//~^ ERROR diagnostic slug not specified
+//~^ ERROR diagnostic message not specified
 struct SlugNotProvided {}
 
 #[derive(Diagnostic)]
@@ -467,7 +467,15 @@ struct BoolField {
 #[diag("this is an example message", code = E0123)]
 struct LabelWithTrailingPath {
     #[label("with a label", foo)]
-    //~^ ERROR a diagnostic slug must be the first argument to the attribute
+    //~^ ERROR derive(Diagnostic): no nested attribute expected here
+    span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag("this is an example message", code = E0123)]
+struct LabelWithTrailingMessage {
+    #[label("with a label", "and another one?")]
+    //~^ ERROR derive(Diagnostic): a diagnostic message must be the first argument to the attribute
     span: Span,
 }
 
@@ -516,28 +524,28 @@ struct ErrorWithWarn {
 #[derive(Diagnostic)]
 #[error("this is an example message", code = E0123)]
 //~^ ERROR `#[error(...)]` is not a valid attribute
-//~| ERROR diagnostic slug not specified
+//~| ERROR diagnostic message not specified
 //~| ERROR cannot find attribute `error` in this scope
 struct ErrorAttribute {}
 
 #[derive(Diagnostic)]
 #[warn_("this is an example message", code = E0123)]
 //~^ ERROR `#[warn_(...)]` is not a valid attribute
-//~| ERROR diagnostic slug not specified
+//~| ERROR diagnostic message not specified
 //~| ERROR cannot find attribute `warn_` in this scope
 struct WarnAttribute {}
 
 #[derive(Diagnostic)]
 #[lint("this is an example message", code = E0123)]
 //~^ ERROR `#[lint(...)]` is not a valid attribute
-//~| ERROR diagnostic slug not specified
+//~| ERROR diagnostic message not specified
 //~| ERROR cannot find attribute `lint` in this scope
 struct LintAttributeOnSessionDiag {}
 
 #[derive(LintDiagnostic)]
 #[lint("this is an example message", code = E0123)]
 //~^ ERROR `#[lint(...)]` is not a valid attribute
-//~| ERROR diagnostic slug not specified
+//~| ERROR diagnostic message not specified
 //~| ERROR cannot find attribute `lint` in this scope
 struct LintAttributeOnLintDiag {}
 
diff --git a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.stderr b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.stderr
index 71ed77804a6c0..b32235c02b07f 100644
--- a/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.stderr
+++ b/tests/ui-fulldeps/session-diagnostic/diagnostic-derive-inline.stderr
@@ -4,21 +4,21 @@ error: derive(Diagnostic): unsupported type attribute for diagnostic derive enum
 LL | #[diag("this is an example message", code = E0123)]
    | ^
 
-error: derive(Diagnostic): diagnostic slug not specified
+error: derive(Diagnostic): diagnostic message not specified
   --> $DIR/diagnostic-derive-inline.rs:47:5
    |
 LL |     Foo,
    |     ^^^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
-error: derive(Diagnostic): diagnostic slug not specified
+error: derive(Diagnostic): diagnostic message not specified
   --> $DIR/diagnostic-derive-inline.rs:49:5
    |
 LL |     Bar,
    |     ^^^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
 error: expected parentheses: #[diag(...)]
   --> $DIR/diagnostic-derive-inline.rs:55:8
@@ -32,45 +32,45 @@ error: derive(Diagnostic): `#[nonsense(...)]` is not a valid attribute
 LL | #[nonsense("this is an example message", code = E0123)]
    | ^
 
-error: derive(Diagnostic): diagnostic slug not specified
+error: derive(Diagnostic): diagnostic message not specified
   --> $DIR/diagnostic-derive-inline.rs:60:1
    |
 LL | #[nonsense("this is an example message", code = E0123)]
    | ^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
-error: derive(Diagnostic): diagnostic slug not specified
+error: derive(Diagnostic): diagnostic message not specified
   --> $DIR/diagnostic-derive-inline.rs:67:1
    |
 LL | #[diag(code = E0123)]
    | ^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
-error: derive(Diagnostic): diagnostic slug not specified
+error: derive(Diagnostic): diagnostic message not specified
   --> $DIR/diagnostic-derive-inline.rs:72:1
    |
 LL | #[diag(nonsense("foo"), code = E0123, slug = "foo")]
    | ^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
-error: derive(Diagnostic): diagnostic slug not specified
+error: derive(Diagnostic): diagnostic message not specified
   --> $DIR/diagnostic-derive-inline.rs:77:1
    |
 LL | #[diag(nonsense = "...", code = E0123, slug = "foo")]
    | ^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
-error: derive(Diagnostic): diagnostic slug not specified
+error: derive(Diagnostic): diagnostic message not specified
   --> $DIR/diagnostic-derive-inline.rs:82:1
    |
 LL | #[diag(nonsense = 4, code = E0123, slug = "foo")]
    | ^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
 error: derive(Diagnostic): unknown argument
   --> $DIR/diagnostic-derive-inline.rs:87:52
@@ -78,7 +78,7 @@ error: derive(Diagnostic): unknown argument
 LL | #[diag("this is an example message", code = E0123, slug = "foo")]
    |                                                    ^^^^
    |
-   = note: only the `code` parameter is valid after the slug
+   = note: only the `code` parameter is valid after the message
 
 error: derive(Diagnostic): `#[suggestion = ...]` is not a valid attribute
   --> $DIR/diagnostic-derive-inline.rs:94:5
@@ -110,27 +110,27 @@ note: previously specified here
 LL | #[diag("this is an example message", code = E0123, code = E0456)]
    |                                      ^^^^
 
-error: derive(Diagnostic): diagnostic slug must be the first argument
+error: derive(Diagnostic): diagnostic message must be the first argument
   --> $DIR/diagnostic-derive-inline.rs:111:38
    |
 LL | #[diag("this is an example message", no_crate::example, code = E0123)]
    |                                      ^^^^^^^^
 
-error: derive(Diagnostic): diagnostic slug not specified
+error: derive(Diagnostic): diagnostic message not specified
   --> $DIR/diagnostic-derive-inline.rs:116:1
    |
 LL | struct KindNotProvided {}
    | ^^^^^^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
-error: derive(Diagnostic): diagnostic slug not specified
+error: derive(Diagnostic): diagnostic message not specified
   --> $DIR/diagnostic-derive-inline.rs:119:1
    |
 LL | #[diag(code = E0123)]
    | ^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
 error: derive(Diagnostic): the `#[primary_span]` attribute can only be applied to fields of type `Span` or `MultiSpan`
   --> $DIR/diagnostic-derive-inline.rs:130:5
@@ -276,26 +276,32 @@ error: derive(Diagnostic): the `#[help(...)]` attribute can only be applied to f
 LL |     #[help("with a help")]
    |     ^
 
-error: derive(Diagnostic): a diagnostic slug must be the first argument to the attribute
+error: derive(Diagnostic): no nested attribute expected here
   --> $DIR/diagnostic-derive-inline.rs:469:29
    |
 LL |     #[label("with a label", foo)]
    |                             ^^^
 
-error: derive(Diagnostic): no nested attribute expected here
+error: derive(Diagnostic): a diagnostic message must be the first argument to the attribute
   --> $DIR/diagnostic-derive-inline.rs:477:29
    |
+LL |     #[label("with a label", "and another one?")]
+   |                             ^^^^^^^^^^^^^^^^^^
+
+error: derive(Diagnostic): no nested attribute expected here
+  --> $DIR/diagnostic-derive-inline.rs:485:29
+   |
 LL |     #[label("with a label", foo = "...")]
    |                             ^^^
 
 error: derive(Diagnostic): no nested attribute expected here
-  --> $DIR/diagnostic-derive-inline.rs:485:29
+  --> $DIR/diagnostic-derive-inline.rs:493:29
    |
 LL |     #[label("with a label", foo("..."))]
    |                             ^^^
 
 error: derive(Diagnostic): `#[primary_span]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:497:5
+  --> $DIR/diagnostic-derive-inline.rs:505:5
    |
 LL |     #[primary_span]
    |     ^
@@ -303,75 +309,75 @@ LL |     #[primary_span]
    = help: the `primary_span` field attribute is not valid for lint diagnostics
 
 error: derive(Diagnostic): `#[error(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:517:1
+  --> $DIR/diagnostic-derive-inline.rs:525:1
    |
 LL | #[error("this is an example message", code = E0123)]
    | ^
 
-error: derive(Diagnostic): diagnostic slug not specified
-  --> $DIR/diagnostic-derive-inline.rs:517:1
+error: derive(Diagnostic): diagnostic message not specified
+  --> $DIR/diagnostic-derive-inline.rs:525:1
    |
 LL | #[error("this is an example message", code = E0123)]
    | ^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
 error: derive(Diagnostic): `#[warn_(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:524:1
+  --> $DIR/diagnostic-derive-inline.rs:532:1
    |
 LL | #[warn_("this is an example message", code = E0123)]
    | ^
 
-error: derive(Diagnostic): diagnostic slug not specified
-  --> $DIR/diagnostic-derive-inline.rs:524:1
+error: derive(Diagnostic): diagnostic message not specified
+  --> $DIR/diagnostic-derive-inline.rs:532:1
    |
 LL | #[warn_("this is an example message", code = E0123)]
    | ^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
 error: derive(Diagnostic): `#[lint(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:531:1
+  --> $DIR/diagnostic-derive-inline.rs:539:1
    |
 LL | #[lint("this is an example message", code = E0123)]
    | ^
 
-error: derive(Diagnostic): diagnostic slug not specified
-  --> $DIR/diagnostic-derive-inline.rs:531:1
+error: derive(Diagnostic): diagnostic message not specified
+  --> $DIR/diagnostic-derive-inline.rs:539:1
    |
 LL | #[lint("this is an example message", code = E0123)]
    | ^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
 error: derive(Diagnostic): `#[lint(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:538:1
+  --> $DIR/diagnostic-derive-inline.rs:546:1
    |
 LL | #[lint("this is an example message", code = E0123)]
    | ^
 
-error: derive(Diagnostic): diagnostic slug not specified
-  --> $DIR/diagnostic-derive-inline.rs:538:1
+error: derive(Diagnostic): diagnostic message not specified
+  --> $DIR/diagnostic-derive-inline.rs:546:1
    |
 LL | #[lint("this is an example message", code = E0123)]
    | ^
    |
-   = help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
+   = help: specify the message as the first argument to the `#[diag(...)]` attribute, such as `#[diag("Example error")]`
 
 error: derive(Diagnostic): attribute specified multiple times
-  --> $DIR/diagnostic-derive-inline.rs:547:53
+  --> $DIR/diagnostic-derive-inline.rs:555:53
    |
 LL |     #[suggestion("with a suggestion", code = "...", code = ",,,")]
    |                                                     ^^^^
    |
 note: previously specified here
-  --> $DIR/diagnostic-derive-inline.rs:547:39
+  --> $DIR/diagnostic-derive-inline.rs:555:39
    |
 LL |     #[suggestion("with a suggestion", code = "...", code = ",,,")]
    |                                       ^^^^
 
 error: derive(Diagnostic): wrong types for suggestion
-  --> $DIR/diagnostic-derive-inline.rs:556:24
+  --> $DIR/diagnostic-derive-inline.rs:564:24
    |
 LL |     suggestion: (Span, usize),
    |                        ^^^^^
@@ -379,7 +385,7 @@ LL |     suggestion: (Span, usize),
    = help: `#[suggestion(...)]` on a tuple field must be applied to fields of type `(Span, Applicability)`
 
 error: derive(Diagnostic): wrong types for suggestion
-  --> $DIR/diagnostic-derive-inline.rs:564:17
+  --> $DIR/diagnostic-derive-inline.rs:572:17
    |
 LL |     suggestion: (Span,),
    |                 ^^^^^^^
@@ -387,13 +393,13 @@ LL |     suggestion: (Span,),
    = help: `#[suggestion(...)]` on a tuple field must be applied to fields of type `(Span, Applicability)`
 
 error: derive(Diagnostic): suggestion without `code = "..."`
-  --> $DIR/diagnostic-derive-inline.rs:571:5
+  --> $DIR/diagnostic-derive-inline.rs:579:5
    |
 LL |     #[suggestion("with a suggestion")]
    |     ^
 
 error: derive(Diagnostic): `#[multipart_suggestion(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:578:1
+  --> $DIR/diagnostic-derive-inline.rs:586:1
    |
 LL | #[multipart_suggestion("with a suggestion")]
    | ^
@@ -401,7 +407,7 @@ LL | #[multipart_suggestion("with a suggestion")]
    = help: consider creating a `Subdiagnostic` instead
 
 error: derive(Diagnostic): `#[multipart_suggestion(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:581:1
+  --> $DIR/diagnostic-derive-inline.rs:589:1
    |
 LL | #[multipart_suggestion()]
    | ^
@@ -409,7 +415,7 @@ LL | #[multipart_suggestion()]
    = help: consider creating a `Subdiagnostic` instead
 
 error: derive(Diagnostic): `#[multipart_suggestion(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:585:5
+  --> $DIR/diagnostic-derive-inline.rs:593:5
    |
 LL |     #[multipart_suggestion("with a suggestion")]
    |     ^
@@ -417,7 +423,7 @@ LL |     #[multipart_suggestion("with a suggestion")]
    = help: consider creating a `Subdiagnostic` instead
 
 error: derive(Diagnostic): `#[suggestion(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:593:1
+  --> $DIR/diagnostic-derive-inline.rs:601:1
    |
 LL | #[suggestion("with a suggestion", code = "...")]
    | ^
@@ -425,81 +431,81 @@ LL | #[suggestion("with a suggestion", code = "...")]
    = help: `#[label]` and `#[suggestion]` can only be applied to fields
 
 error: derive(Diagnostic): `#[label]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:602:1
+  --> $DIR/diagnostic-derive-inline.rs:610:1
    |
 LL | #[label]
    | ^
    |
-   = help: `#[label]` and `#[suggestion]` can only be applied to fields
+   = help: subdiagnostic message is missing
 
 error: derive(Diagnostic): `#[subdiagnostic(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:636:5
+  --> $DIR/diagnostic-derive-inline.rs:644:5
    |
 LL |     #[subdiagnostic(bad)]
    |     ^
 
 error: derive(Diagnostic): `#[subdiagnostic = ...]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:644:5
+  --> $DIR/diagnostic-derive-inline.rs:652:5
    |
 LL |     #[subdiagnostic = "bad"]
    |     ^
 
 error: derive(Diagnostic): `#[subdiagnostic(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:652:5
+  --> $DIR/diagnostic-derive-inline.rs:660:5
    |
 LL |     #[subdiagnostic(bad, bad)]
    |     ^
 
 error: derive(Diagnostic): `#[subdiagnostic(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:660:5
+  --> $DIR/diagnostic-derive-inline.rs:668:5
    |
 LL |     #[subdiagnostic("bad")]
    |     ^
 
 error: derive(Diagnostic): `#[subdiagnostic(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:668:5
+  --> $DIR/diagnostic-derive-inline.rs:676:5
    |
 LL |     #[subdiagnostic(eager)]
    |     ^
 
 error: derive(Diagnostic): `#[subdiagnostic(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:676:5
+  --> $DIR/diagnostic-derive-inline.rs:684:5
    |
 LL |     #[subdiagnostic(eager)]
    |     ^
 
 error: derive(Diagnostic): `#[subdiagnostic(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:697:5
+  --> $DIR/diagnostic-derive-inline.rs:705:5
    |
 LL |     #[subdiagnostic(eager)]
    |     ^
 
 error: derive(Diagnostic): expected at least one string literal for `code(...)`
-  --> $DIR/diagnostic-derive-inline.rs:728:44
+  --> $DIR/diagnostic-derive-inline.rs:736:44
    |
 LL |     #[suggestion("with a suggestion", code())]
    |                                            ^
 
 error: derive(Diagnostic): `code(...)` must contain only string literals
-  --> $DIR/diagnostic-derive-inline.rs:736:44
+  --> $DIR/diagnostic-derive-inline.rs:744:44
    |
 LL |     #[suggestion("with a suggestion", code(foo))]
    |                                            ^^^
 
 error: unexpected token, expected `)`
-  --> $DIR/diagnostic-derive-inline.rs:736:44
+  --> $DIR/diagnostic-derive-inline.rs:744:44
    |
 LL |     #[suggestion("with a suggestion", code(foo))]
    |                                            ^^^
 
 error: expected string literal
-  --> $DIR/diagnostic-derive-inline.rs:745:46
+  --> $DIR/diagnostic-derive-inline.rs:753:46
    |
 LL |     #[suggestion("with a suggestion", code = 3)]
    |                                              ^
 
 error: derive(Diagnostic): `#[suggestion(...)]` is not a valid attribute
-  --> $DIR/diagnostic-derive-inline.rs:760:5
+  --> $DIR/diagnostic-derive-inline.rs:768:5
    |
 LL |     #[suggestion("with a suggestion", code = "")]
    |     ^
@@ -509,7 +515,7 @@ LL |     #[suggestion("with a suggestion", code = "")]
    = help: to show a variable set of suggestions, use a `Vec` of `Subdiagnostic`s annotated with `#[suggestion(...)]`
 
 error: derive(Diagnostic): Variable `nosub` not found in diagnostic 
-  --> $DIR/diagnostic-derive-inline.rs:772:8
+  --> $DIR/diagnostic-derive-inline.rs:780:8
    |
 LL | #[diag("does not exist: {$nosub}")]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -529,7 +535,7 @@ LL |     #[nonsense]
    |       ^^^^^^^^
 
 error: cannot find attribute `error` in this scope
-  --> $DIR/diagnostic-derive-inline.rs:517:3
+  --> $DIR/diagnostic-derive-inline.rs:525:3
    |
 LL | #[error("this is an example message", code = E0123)]
    |   ^^^^^
@@ -541,7 +547,7 @@ LL | struct ErrorAttribute {}
    |
 
 error: cannot find attribute `warn_` in this scope
-  --> $DIR/diagnostic-derive-inline.rs:524:3
+  --> $DIR/diagnostic-derive-inline.rs:532:3
    |
 LL | #[warn_("this is an example message", code = E0123)]
    |   ^^^^^
@@ -553,7 +559,7 @@ LL + #[warn("this is an example message", code = E0123)]
    |
 
 error: cannot find attribute `lint` in this scope
-  --> $DIR/diagnostic-derive-inline.rs:531:3
+  --> $DIR/diagnostic-derive-inline.rs:539:3
    |
 LL | #[lint("this is an example message", code = E0123)]
    |   ^^^^
@@ -565,7 +571,7 @@ LL + #[link("this is an example message", code = E0123)]
    |
 
 error: cannot find attribute `lint` in this scope
-  --> $DIR/diagnostic-derive-inline.rs:538:3
+  --> $DIR/diagnostic-derive-inline.rs:546:3
    |
 LL | #[lint("this is an example message", code = E0123)]
    |   ^^^^
@@ -577,7 +583,7 @@ LL + #[link("this is an example message", code = E0123)]
    |
 
 error: cannot find attribute `multipart_suggestion` in this scope
-  --> $DIR/diagnostic-derive-inline.rs:578:3
+  --> $DIR/diagnostic-derive-inline.rs:586:3
    |
 LL | #[multipart_suggestion("with a suggestion")]
    |   ^^^^^^^^^^^^^^^^^^^^
@@ -589,7 +595,7 @@ LL | struct MultipartSuggestion {
    |
 
 error: cannot find attribute `multipart_suggestion` in this scope
-  --> $DIR/diagnostic-derive-inline.rs:581:3
+  --> $DIR/diagnostic-derive-inline.rs:589:3
    |
 LL | #[multipart_suggestion()]
    |   ^^^^^^^^^^^^^^^^^^^^
@@ -601,7 +607,7 @@ LL | struct MultipartSuggestion {
    |
 
 error: cannot find attribute `multipart_suggestion` in this scope
-  --> $DIR/diagnostic-derive-inline.rs:585:7
+  --> $DIR/diagnostic-derive-inline.rs:593:7
    |
 LL |     #[multipart_suggestion("with a suggestion")]
    |       ^^^^^^^^^^^^^^^^^^^^
@@ -630,6 +636,6 @@ note: required by a bound in `Diag::<'a, G>::arg`
    = note: in this macro invocation
    = note: this error originates in the macro `with_fn` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 80 previous errors
+error: aborting due to 81 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui-fulldeps/session-diagnostic/subdiagnostic-derive-inline.rs b/tests/ui-fulldeps/session-diagnostic/subdiagnostic-derive-inline.rs
index 079c2a74c4a13..99b2cba89da4b 100644
--- a/tests/ui-fulldeps/session-diagnostic/subdiagnostic-derive-inline.rs
+++ b/tests/ui-fulldeps/session-diagnostic/subdiagnostic-derive-inline.rs
@@ -54,7 +54,7 @@ struct C {
 
 #[derive(Subdiagnostic)]
 #[label]
-//~^ ERROR diagnostic slug must be first argument
+//~^ ERROR diagnostic message must be first argument
 struct D {
     #[primary_span]
     span: Span,
@@ -83,7 +83,7 @@ struct F {
 #[derive(Subdiagnostic)]
 #[label(bug = "...")]
 //~^ ERROR no nested attribute expected here
-//~| ERROR diagnostic slug must be first argument
+//~| ERROR diagnostic message must be first argument
 struct G {
     #[primary_span]
     span: Span,
@@ -93,7 +93,7 @@ struct G {
 #[derive(Subdiagnostic)]
 #[label(slug = 4)]
 //~^ ERROR no nested attribute expected here
-//~| ERROR diagnostic slug must be first argument
+//~| ERROR diagnostic message must be first argument
 struct J {
     #[primary_span]
     span: Span,
@@ -103,7 +103,7 @@ struct J {
 #[derive(Subdiagnostic)]
 #[label(slug("..."))]
 //~^ ERROR no nested attribute expected here
-//~| ERROR diagnostic slug must be first argument
+//~| ERROR diagnostic message must be first argument
 struct K {
     #[primary_span]
     span: Span,
@@ -112,7 +112,7 @@ struct K {
 
 #[derive(Subdiagnostic)]
 #[label()]
-//~^ ERROR diagnostic slug must be first argument of a `#[label(...)]` attribute
+//~^ ERROR diagnostic message must be first argument of a `#[label(...)]` attribute
 struct M {
     #[primary_span]
     span: Span,
@@ -201,7 +201,7 @@ enum T {
 #[derive(Subdiagnostic)]
 enum U {
     #[label(code = "...")]
-    //~^ ERROR diagnostic slug must be first argument of a `#[label(...)]` attribute
+    //~^ ERROR diagnostic message must be first argument of a `#[label(...)]` attribute
     //~| ERROR no nested attribute expected here
     A {
         #[primary_span]
@@ -303,7 +303,7 @@ struct AD {
 
 #[derive(Subdiagnostic)]
 #[label("example message", no_crate::example)]
-//~^ ERROR a diagnostic slug must be the first argument to the attribute
+//~^ ERROR expected this path to be an identifier
 struct AE {
     #[primary_span]
     span: Span,
@@ -771,7 +771,7 @@ struct SuggestionStyleInvalid2 {
 
 #[derive(Subdiagnostic)]
 #[suggestion("example message", code = "", style)]
-//~^ ERROR a diagnostic slug must be the first argument to the attribute
+//~^ ERROR expected `=`
 struct SuggestionStyleInvalid3 {
     #[primary_span]
     sub: Span,
diff --git a/tests/ui-fulldeps/session-diagnostic/subdiagnostic-derive-inline.stderr b/tests/ui-fulldeps/session-diagnostic/subdiagnostic-derive-inline.stderr
index 8ff5ed00d0ba9..90e0c285ee746 100644
--- a/tests/ui-fulldeps/session-diagnostic/subdiagnostic-derive-inline.stderr
+++ b/tests/ui-fulldeps/session-diagnostic/subdiagnostic-derive-inline.stderr
@@ -4,7 +4,7 @@ error: derive(Diagnostic): label without `#[primary_span]` field
 LL | #[label("example message")]
    | ^
 
-error: derive(Diagnostic): diagnostic slug must be first argument of a `#[label(...)]` attribute
+error: derive(Diagnostic): diagnostic message must be first argument of a `#[label(...)]` attribute
   --> $DIR/subdiagnostic-derive-inline.rs:56:1
    |
 LL | #[label]
@@ -28,7 +28,7 @@ error: derive(Diagnostic): no nested attribute expected here
 LL | #[label(bug = "...")]
    |         ^^^
 
-error: derive(Diagnostic): diagnostic slug must be first argument of a `#[label(...)]` attribute
+error: derive(Diagnostic): diagnostic message must be first argument of a `#[label(...)]` attribute
   --> $DIR/subdiagnostic-derive-inline.rs:84:1
    |
 LL | #[label(bug = "...")]
@@ -40,7 +40,7 @@ error: derive(Diagnostic): no nested attribute expected here
 LL | #[label(slug = 4)]
    |         ^^^^
 
-error: derive(Diagnostic): diagnostic slug must be first argument of a `#[label(...)]` attribute
+error: derive(Diagnostic): diagnostic message must be first argument of a `#[label(...)]` attribute
   --> $DIR/subdiagnostic-derive-inline.rs:94:1
    |
 LL | #[label(slug = 4)]
@@ -52,13 +52,13 @@ error: derive(Diagnostic): no nested attribute expected here
 LL | #[label(slug("..."))]
    |         ^^^^
 
-error: derive(Diagnostic): diagnostic slug must be first argument of a `#[label(...)]` attribute
+error: derive(Diagnostic): diagnostic message must be first argument of a `#[label(...)]` attribute
   --> $DIR/subdiagnostic-derive-inline.rs:104:1
    |
 LL | #[label(slug("..."))]
    | ^
 
-error: derive(Diagnostic): diagnostic slug must be first argument of a `#[label(...)]` attribute
+error: derive(Diagnostic): diagnostic message must be first argument of a `#[label(...)]` attribute
   --> $DIR/subdiagnostic-derive-inline.rs:114:1
    |
 LL | #[label()]
@@ -112,7 +112,7 @@ error: derive(Diagnostic): no nested attribute expected here
 LL |     #[label(code = "...")]
    |             ^^^^
 
-error: derive(Diagnostic): diagnostic slug must be first argument of a `#[label(...)]` attribute
+error: derive(Diagnostic): diagnostic message must be first argument of a `#[label(...)]` attribute
   --> $DIR/subdiagnostic-derive-inline.rs:203:5
    |
 LL |     #[label(code = "...")]
@@ -168,11 +168,11 @@ LL | |     b: u64,
 LL | | }
    | |_^
 
-error: derive(Diagnostic): a diagnostic slug must be the first argument to the attribute
+error: expected this path to be an identifier
   --> $DIR/subdiagnostic-derive-inline.rs:305:28
    |
 LL | #[label("example message", no_crate::example)]
-   |                            ^^^^^^^^
+   |                            ^^^^^^^^^^^^^^^^^
 
 error: derive(Diagnostic): attribute specified multiple times
   --> $DIR/subdiagnostic-derive-inline.rs:318:5
@@ -464,11 +464,11 @@ error: expected string literal
 LL | #[suggestion("example message", code = "", style = 42)]
    |                                                    ^^
 
-error: derive(Diagnostic): a diagnostic slug must be the first argument to the attribute
-  --> $DIR/subdiagnostic-derive-inline.rs:773:44
+error: expected `=`
+  --> $DIR/subdiagnostic-derive-inline.rs:773:49
    |
 LL | #[suggestion("example message", code = "", style)]
-   |                                            ^^^^^
+   |                                                 ^
 
 error: expected `=`
   --> $DIR/subdiagnostic-derive-inline.rs:781:49