macros: compute slugs with raw fluent diags

Signed-off-by: David Wood <[email protected]>

Author: davidtwco

compiler/rustc_macros/src/diagnostics/diagnostic.rs

@@ -28,7 +28,7 @@ impl<'a> DiagnosticDerive<'a> {
             let preamble = builder.preamble(variant);
             let body = builder.body(variant);
 
-            let args = if matches!(builder.slug.value_ref(), Some(SlugOrRawFluent::RawFluent(_))) {
+            let args = if matches!(builder.slug.value_ref(), Some(SlugOrRawFluent::RawFluent(_, _))) {
                 let args = builder.args;
                 quote! {
                     use rustc_data_structures::fx::FxHashMap;
@@ -70,9 +70,9 @@ impl<'a> DiagnosticDerive<'a> {
                         );
                     }
                 }
-                Some(SlugOrRawFluent::RawFluent(raw)) => {
+                Some(SlugOrRawFluent::RawFluent(slug, raw)) => {
                     quote! {
-                        let raw = dcx.raw_translate("foo", #raw, args.iter());
+                        let raw = dcx.raw_translate(#slug, #raw, args.iter());
                         let mut diag = rustc_errors::DiagnosticBuilder::new(
                             dcx,
                             level,
@@ -176,7 +176,7 @@ impl<'a> LintDiagnosticDerive<'a> {
                         crate::fluent_generated::#slug.into()
                     }
                 }
-                Some(SlugOrRawFluent::RawFluent(raw)) => {
+                Some(SlugOrRawFluent::RawFluent(_, raw)) => {
                     quote! {
                         #raw
                     }

compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs

@@ -5,8 +5,8 @@ use crate::diagnostics::error::{
 };
 use crate::diagnostics::utils::{
     build_field_mapping, is_doc_comment, report_error_if_not_applied_to_span, report_type_error,
-    should_generate_arg, type_is_bool, type_is_unit, type_matches_path, FieldInfo, FieldInnerTy,
-    FieldMap, HasFieldMap, SetOnce, SpannedOption, SubdiagnosticKind,
+    should_generate_arg, slugify, type_is_bool, type_is_unit, type_matches_path, FieldInfo,
+    FieldInnerTy, FieldMap, HasFieldMap, SetOnce, SpannedOption, SubdiagnosticKind,
 };
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{format_ident, quote, quote_spanned};
@@ -29,10 +29,10 @@ pub(crate) enum SlugOrRawFluent {
     ///
     /// e.g. `#[diag(foo_bar)]`
     Slug(Path),
-    /// Literal string containing the Fluent message.
+    /// Literal string containing the Fluent message and its computed slug.
     ///
     /// e.g. `#[diag_raw(message = "raw fluent content")]`
-    RawFluent(LitStr),
+    RawFluent(String, LitStr),
 }
 
 /// Tracks persistent information required for a specific variant when building up individual calls
@@ -60,6 +60,7 @@ pub(crate) struct DiagnosticDeriveVariantBuilder {
     /// multiple specifications.
     pub code: SpannedOption<()>,
 
+    pub generated_slug: String,
     pub args: Vec<TokenStream>,
 }
 
@@ -96,8 +97,14 @@ impl DiagnosticDeriveKind {
             }
         }
 
+        let generated_slug = slugify(&structure.ast().ident.to_string());
         structure.bind_with(|_| synstructure::BindStyle::Move);
         let variants = structure.each_variant(|variant| {
+            let mut generated_slug = generated_slug.clone();
+            if matches!(ast.data, syn::Data::Enum(..)) {
+                generated_slug.push_str("_");
+                generated_slug.push_str(&slugify(&variant.ast().ident.to_string()));
+            }
             let span = match structure.ast().data {
                 syn::Data::Struct(..) => span,
                 // There isn't a good way to get the span of the variant, so the variant's
@@ -111,6 +118,7 @@ impl DiagnosticDeriveKind {
                 formatting_init: TokenStream::new(),
                 slug: None,
                 code: None,
+                generated_slug,
                 args: Vec::new(),
             };
             f(builder, variant)
@@ -157,9 +165,10 @@ impl DiagnosticDeriveVariantBuilder {
     /// Parse a `SubdiagnosticKind` from an `Attribute`.
     fn parse_subdiag_attribute(
         &self,
+        generated_slug: &str,
         attr: &Attribute,
     ) -> Result<Option<(SubdiagnosticKind, SlugOrRawFluent, bool)>, DiagnosticDeriveError> {
-        let Some(subdiag) = SubdiagnosticVariant::from_attr(attr, self)? else {
+        let Some(subdiag) = SubdiagnosticVariant::from_attr(generated_slug, attr, self)? else {
             // Some attributes aren't errors - like documentation comments - but also aren't
             // subdiagnostics.
             return Ok(None);
@@ -228,7 +237,10 @@ impl DiagnosticDeriveVariantBuilder {
 
                 if path.is_ident("message") {
                     self.slug.set_once(
-                        SlugOrRawFluent::RawFluent(nested.parse::<LitStr>()?),
+                        SlugOrRawFluent::RawFluent(
+                            self.generated_slug.clone(),
+                            nested.parse::<LitStr>()?,
+                        ),
                         path.span().unwrap(),
                     );
                     return Ok(());
@@ -252,7 +264,9 @@ impl DiagnosticDeriveVariantBuilder {
             return Ok(tokens);
         }
 
-        let Some((subdiag, slug, _no_span)) = self.parse_subdiag_attribute(attr)? else {
+        let Some((subdiag, slug, _no_span)) =
+            self.parse_subdiag_attribute(&self.generated_slug, attr)?
+        else {
             // Some attributes aren't errors - like documentation comments - but also aren't
             // subdiagnostics.
             return Ok(quote! {});
@@ -278,7 +292,7 @@ impl DiagnosticDeriveVariantBuilder {
         let ident = field.ident.as_ref().unwrap();
         let ident = format_ident!("{}", ident); // strip `r#` prefix, if present
 
-        if matches!(self.slug.value_ref(), Some(SlugOrRawFluent::RawFluent(_))) {
+        if matches!(self.slug.value_ref(), Some(SlugOrRawFluent::RawFluent(_, _))) {
             // Cloning should not be necessary once there are no `diag.arg` calls.
             self.args.push(quote! {
                 args.insert(stringify!(#ident).into(), #field_binding.clone().into_diagnostic_arg());
@@ -370,7 +384,14 @@ impl DiagnosticDeriveVariantBuilder {
             _ => (),
         }
 
-        let Some((subdiag, slug, _no_span)) = self.parse_subdiag_attribute(attr)? else {
+        let mut generated_slug = self.generated_slug.clone();
+        if let Some(field_name) = &info.binding.ast().ident {
+            generated_slug.push_str("_");
+            generated_slug.push_str(&slugify(&field_name.to_string()));
+        }
+        let Some((subdiag, slug, _no_span)) =
+            self.parse_subdiag_attribute(&generated_slug, attr)?
+        else {
             // Some attributes aren't errors - like documentation comments - but also aren't
             // subdiagnostics.
             return Ok(quote! {});
@@ -432,8 +453,8 @@ impl DiagnosticDeriveVariantBuilder {
                             #style
                         );
                     }),
-                    SlugOrRawFluent::RawFluent(raw) => Ok(quote! {
-                        let raw = dcx.raw_translate("foo", #raw, args.iter());
+                    SlugOrRawFluent::RawFluent(slug, raw) => Ok(quote! {
+                        let raw = dcx.raw_translate(#slug, #raw, args.iter());
                         diag.span_suggestions_with_style(
                             #span_field,
                             raw,
@@ -466,9 +487,9 @@ impl DiagnosticDeriveVariantBuilder {
                     );
                 }
             }
-            SlugOrRawFluent::RawFluent(raw) => {
+            SlugOrRawFluent::RawFluent(slug, raw) => {
                 quote! {
-                    let raw = dcx.raw_translate("foo", #raw, args.iter());
+                    let raw = dcx.raw_translate(#slug, #raw, args.iter());
                     diag.#fn_name(#field_binding, raw);
                 }
             }
@@ -484,9 +505,9 @@ impl DiagnosticDeriveVariantBuilder {
                     diag.#kind(crate::fluent_generated::#fluent_attr_identifier);
                 }
             }
-            SlugOrRawFluent::RawFluent(raw) => {
+            SlugOrRawFluent::RawFluent(slug, raw) => {
                 quote! {
-                    let raw = dcx.raw_translate("foo", #raw, args.iter());
+                    let raw = dcx.raw_translate(#slug, #raw, args.iter());
                     diag.#kind(raw);
                 }
             }

compiler/rustc_macros/src/diagnostics/mod.rs

@@ -2,6 +2,8 @@ mod diagnostic;
 mod diagnostic_builder;
 mod error;
 mod subdiagnostic;
+#[cfg(test)]
+mod tests;
 mod utils;
 
 use diagnostic::{DiagnosticDerive, LintDiagnosticDerive};

compiler/rustc_macros/src/diagnostics/subdiagnostic.rs

@@ -6,8 +6,8 @@ use crate::diagnostics::error::{
 use crate::diagnostics::utils::{
     build_field_mapping, build_suggestion_code, is_doc_comment, new_code_ident,
     report_error_if_not_applied_to_applicability, report_error_if_not_applied_to_span,
-    should_generate_arg, AllowMultipleAlternatives, FieldInfo, FieldInnerTy, FieldMap, HasFieldMap,
-    SetOnce, SpannedOption, SubdiagnosticKind,
+    should_generate_arg, slugify, AllowMultipleAlternatives, FieldInfo, FieldInnerTy, FieldMap,
+    HasFieldMap, SetOnce, SpannedOption, SubdiagnosticKind,
 };
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
@@ -61,8 +61,14 @@ impl SubdiagnosticDeriveBuilder {
                 }
             }
 
+            let generated_slug = slugify(&structure.ast().ident.to_string());
             structure.bind_with(|_| synstructure::BindStyle::Move);
             let variants_ = structure.each_variant(|variant| {
+                let mut generated_slug = generated_slug.clone();
+                if matches!(ast.data, syn::Data::Enum(..)) {
+                    generated_slug.push_str("_");
+                    generated_slug.push_str(&slugify(&variant.ast().ident.to_string()));
+                }
                 let mut builder = SubdiagnosticDeriveVariantBuilder {
                     parent: &self,
                     variant,
@@ -73,6 +79,7 @@ impl SubdiagnosticDeriveBuilder {
                     applicability: None,
                     has_suggestion_parts: false,
                     is_enum,
+                    generated_slug,
                 };
                 builder.into_tokens().unwrap_or_else(|v| v.to_compile_error())
             });
@@ -132,6 +139,8 @@ struct SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
 
     /// Set to true when this variant is an enum variant rather than just the body of a struct.
     is_enum: bool,
+
+    generated_slug: String,
 }
 
 impl<'parent, 'a> HasFieldMap for SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
@@ -186,7 +195,7 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
 
         for attr in self.variant.ast().attrs {
             let Some(SubdiagnosticVariant { kind, slug, no_span }) =
-                SubdiagnosticVariant::from_attr(attr, self)?
+                SubdiagnosticVariant::from_attr(&self.generated_slug, attr, self)?
             else {
                 // Some attributes aren't errors - like documentation comments - but also aren't
                 // subdiagnostics.
@@ -520,7 +529,7 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
                         quote! { let #message = #f(#diag, crate::fluent_generated::#slug.into()); },
                     );
                 }
-                SlugOrRawFluent::RawFluent(raw) => {
+                SlugOrRawFluent::RawFluent(_, raw) => {
                     calls.extend(quote! { let #message = #raw; });
                 }
             }

compiler/rustc_macros/src/diagnostics/tests.rs

@@ -0,0 +1,7 @@
+use crate::diagnostics::utils::slugify;
+
+#[test]
+fn slugs() {
+    assert_eq!(slugify("ExampleStructName"), "example_struct_name");
+    assert_eq!(slugify("foo-bar"), "foo_bar");
+}

compiler/rustc_macros/src/diagnostics/utils.rs

@@ -609,6 +609,7 @@ impl SubdiagnosticVariant {
     /// `#[error(parser::add_paren, no_span)]` or `#[suggestion(code = "...")]`. Returns the
     /// `SubdiagnosticKind` and the diagnostic slug, if specified.
     pub(super) fn from_attr(
+        generated_slug: &str,
         attr: &Attribute,
         fields: &impl HasFieldMap,
     ) -> Result<Option<SubdiagnosticVariant>, DiagnosticDeriveError> {
@@ -750,7 +751,7 @@ impl SubdiagnosticVariant {
                         .emit();
                         return Ok(());
                     };
-                    slug = Some(SlugOrRawFluent::RawFluent(value.parse::<LitStr>()?));
+                    slug = Some(SlugOrRawFluent::RawFluent(generated_slug.to_string(), value.parse::<LitStr>()?));
                 },
                 ("code", SubdiagnosticKind::Suggestion { code_field, .. }) => {
                     let code_init = build_suggestion_code(
@@ -885,3 +886,24 @@ pub(super) fn should_generate_arg(field: &Field) -> bool {
 pub(super) fn is_doc_comment(attr: &Attribute) -> bool {
     attr.path().segments.last().unwrap().ident == "doc"
 }
+
+pub(super) fn slugify(inpt: &str) -> String {
+    let mut slug = Vec::with_capacity(inpt.len());
+    for c in inpt.chars() {
+        match c {
+            'A'..='Z' => {
+                if !slug.is_empty() {
+                    slug.push('_');
+                }
+                slug.extend(char::to_lowercase(c));
+            }
+            '-' => {
+                slug.push('_');
+            }
+            _ => {
+                slug.push(c);
+            }
+        }
+    }
+    slug.into_iter().collect()
+}