more cleanup on diags

Author: chenyukang

compiler/rustc_errors/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2021"
 # tidy-alphabetical-start
 annotate-snippets = "0.9"
 derive_setters = "0.1.6"
+fluent = "0.16.0"
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_data_structures = { path = "../rustc_data_structures" }
@@ -24,10 +25,8 @@ serde_json = "1.0.59"
 termcolor = "1.2.0"
 termize = "0.1.1"
 tracing = "0.1"
-unicode-width = "0.1.4"
-fluent = "0.16.0"
 unic-langid = {version = "0.9.1", features = ["unic-langid-macros"]}
-
+unicode-width = "0.1.4"
 # tidy-alphabetical-end
 
 [target.'cfg(windows)'.dependencies.windows]

compiler/rustc_errors/src/translation.rs

@@ -68,23 +68,19 @@ pub trait Translate {
                 if args.iter().next().is_none() || (!msg.contains("$") && !msg.contains("`{")) {
                     return Ok(Cow::Borrowed(msg));
                 } else {
-                    // FIXME(yukang) A hacky for raw fluent content
+                    // FIXME(yukang): A hack for raw fluent content for new diagnostics proc format
                     let fluent_text = format!("dummy = {}", msg);
                     if let Ok(resource) = FluentResource::try_new(fluent_text) {
-                        let langid_en = langid!("en-US");
-                        let mut bundle = RawFluentBundle::new(vec![langid_en]);
+                        let mut bundle = RawFluentBundle::new(vec![langid!("en-US")]);
                         bundle.add_resource(resource).unwrap();
                         let mut errors = vec![];
                         let pattern = bundle.get_message("dummy").unwrap().value().unwrap();
                         let res = bundle.format_pattern(&pattern, Some(args), &mut errors);
-                        //eprintln!("translated: {:?}", msg);
-                        //eprintln!("args: {:?}", args);
-                        //eprintln!("res: {:?}", res);
                         return Ok(Cow::Owned(
                             res.to_string().replace("\u{2068}", "").replace("\u{2069}", ""),
                         ));
                     } else {
-                        //eprintln!("translate error: {}, args: {:?}", msg, args);
+                        // If the message is not a valid Fluent resource, just return the original
                         return Ok(Cow::Borrowed(msg));
                     }
                 }

compiler/rustc_macros/Cargo.toml

@@ -10,7 +10,7 @@ proc-macro = true
 # tidy-alphabetical-start
 proc-macro2 = "1"
 quote = "1"
+regex = "1.3.3"
 syn = { version = "2.0.9", features = ["full"] }
 synstructure = "0.13.0"
-regex = "1.3.3"
 # tidy-alphabetical-end

compiler/rustc_macros/src/diagnostics/diagnostic.rs

@@ -30,6 +30,7 @@ impl<'a> DiagnosticDerive<'a> {
     pub(crate) fn into_tokens(self) -> TokenStream {
         let DiagnosticDerive { mut structure, mut builder } = self;
 
+        let slugs = RefCell::new(Vec::new());
         let implementation = builder.each_variant(&mut structure, |mut builder, variant| {
             let diag = &builder.parent.diag;
             let DiagnosticDeriveKind::Diagnostic { handler } = &builder.parent.kind else {
@@ -61,17 +62,18 @@ impl<'a> DiagnosticDerive<'a> {
                     return DiagnosticDeriveError::ErrorHandled.to_compile_error();
                 }
                 (Some(slug), None) => {
+                    slugs.borrow_mut().push(slug.clone());
                     quote! {
                         let mut #diag = #handler.struct_diagnostic(crate::fluent_generated::#slug);
                     }
                 }
-                (None, Some(text)) => {
+                (None, Some(raw_label)) => {
                     quote! {
-                        let mut #diag = #handler.struct_diagnostic(DiagnosticMessage::Str(#text.into()));
+                        let mut #diag = #handler.struct_diagnostic(DiagnosticMessage::Str(#raw_label.into()));
                     }
                 }
-                (Some(_slug), Some(_text)) => {
-                    unreachable!("BUG: slug and text specified");
+                (Some(_slug), Some(_raw_label)) => {
+                    unreachable!("BUG: slug and raw label specified");
                 }
             };
 
@@ -89,7 +91,7 @@ impl<'a> DiagnosticDerive<'a> {
             unreachable!();
         };
 
-        let imp = structure.gen_impl(quote! {
+        let mut imp = structure.gen_impl(quote! {
             gen impl<'__diagnostic_handler_sess, G>
                     rustc_errors::IntoDiagnostic<'__diagnostic_handler_sess, G>
                     for @Self
@@ -106,6 +108,10 @@ impl<'a> DiagnosticDerive<'a> {
                 }
             }
         });
+
+        for test in slugs.borrow().iter().map(|s| generate_test(s, &structure)) {
+            imp.extend(test);
+        }
         imp
     }
 }

compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs

@@ -4,14 +4,13 @@ use super::utils::{convert_to_litstr, SubdiagnosticVariant};
 use crate::diagnostics::error::{
     span_err, throw_invalid_attr, throw_span_err, DiagnosticDeriveError,
 };
-//use crate::diagnostics::utils::format_for_variables;
 use crate::diagnostics::utils::{
     build_field_mapping, is_doc_comment, report_error_if_not_applied_to_span, report_type_error,
     should_generate_set_arg, type_is_bool, type_is_unit, type_matches_path, FieldInfo,
     FieldInnerTy, FieldMap, HasFieldMap, SetOnce, SpannedOption, SubdiagnosticKind,
 };
 use proc_macro2::{Ident, Span, TokenStream, TokenTree};
-use quote::{format_ident, quote, quote_spanned, ToTokens};
+use quote::{format_ident, quote, quote_spanned};
 use std::collections::HashMap;
 use syn::MetaList;
 use syn::Token;
@@ -66,9 +65,6 @@ pub(crate) struct DiagnosticDeriveVariantBuilder<'parent> {
 
     /// Attributes on the variant.
     pub attrs: HashMap<String, LitStr>,
-
-    /// fields for bidnings in the variant.
-    pub fields: FieldMap,
 }
 
 impl<'a> HasFieldMap for DiagnosticDeriveVariantBuilder<'a> {
@@ -121,7 +117,6 @@ impl DiagnosticDeriveBuilder {
                 code: None,
                 label: None,
                 attrs: HashMap::new(),
-                fields: HashMap::new(),
             };
             f(builder, variant)
         });
@@ -140,9 +135,6 @@ impl<'a> DiagnosticDeriveVariantBuilder<'a> {
     pub fn preamble(&mut self, variant: &VariantInfo<'_>) -> TokenStream {
         let ast = variant.ast();
         let attrs = &ast.attrs;
-        for binding in variant.bindings().iter().filter(|bi| should_generate_set_arg(bi.ast())) {
-            self.generate_binding_for_attr(binding);
-        }
 
         let preamble = attrs.iter().map(|attr| {
             self.generate_structure_code_for_attr(attr).unwrap_or_else(|v| v.to_compile_error())
@@ -193,7 +185,7 @@ impl<'a> DiagnosticDeriveVariantBuilder<'a> {
             SubdiagnosticKind::MultipartSuggestion { .. } => unreachable!(),
         });
 
-        Ok(Some((subdiag.kind, slug, subdiag.no_span, subdiag.text.map(|t| t.value()))))
+        Ok(Some((subdiag.kind, slug, subdiag.no_span, subdiag.raw_label.map(|t| t.value()))))
     }
 
     /// Establishes state in the `DiagnosticDeriveBuilder` resulting from the struct
@@ -283,7 +275,7 @@ impl<'a> DiagnosticDeriveVariantBuilder<'a> {
                         return Ok(());
                     };
 
-                    if path.is_ident("text") || path.is_ident("label") {
+                    if path.is_ident("label") {
                         let value = nested.parse::<syn::LitStr>()?;
                         self.label.set_once(value, path.span().unwrap());
                     } else if path.is_ident("code") {
@@ -314,15 +306,15 @@ impl<'a> DiagnosticDeriveVariantBuilder<'a> {
             return Ok(tokens);
         }
 
-        let Some((subdiag, slug, _no_span, text)) = self.parse_subdiag_attribute(attr)? else {
+        let Some((subdiag, slug, _no_span, raw_label)) = self.parse_subdiag_attribute(attr)? else {
             // Some attributes aren't errors - like documentation comments - but also aren't
             // subdiagnostics.
             return Ok(quote! {});
         };
         let fn_ident = format_ident!("{}", subdiag);
         match subdiag {
             SubdiagnosticKind::Note | SubdiagnosticKind::Help | SubdiagnosticKind::Warn => {
-                Ok(self.add_subdiagnostic(&fn_ident, slug, text))
+                Ok(self.add_subdiagnostic(&fn_ident, slug, raw_label))
             }
             SubdiagnosticKind::Label | SubdiagnosticKind::Suggestion { .. } => {
                 throw_invalid_attr!(attr, |diag| diag
@@ -349,16 +341,6 @@ impl<'a> DiagnosticDeriveVariantBuilder<'a> {
         }
     }
 
-    fn generate_binding_for_attr(&mut self, binding_info: &BindingInfo<'_>) {
-        let field = binding_info.ast();
-        let mut field_binding = binding_info.binding.clone();
-        field_binding.set_span(field.ty.span());
-
-        let ident = field.ident.as_ref().unwrap();
-        let ident = format_ident!("{}", ident); // strip `r#` prefix, if present
-        self.fields.insert(ident.to_string(), field_binding.into_token_stream());
-    }
-
     fn generate_field_attrs_code(&mut self, binding_info: &BindingInfo<'_>) -> TokenStream {
         let field = binding_info.ast();
         let field_binding = &binding_info.binding;
@@ -474,7 +456,7 @@ impl<'a> DiagnosticDeriveVariantBuilder<'a> {
             _ => (),
         }
 
-        let Some((subdiag, slug, _no_span, text)) = self.parse_subdiag_attribute(attr)? else {
+        let Some((subdiag, slug, _no_span, raw_label)) = self.parse_subdiag_attribute(attr)? else {
             // Some attributes aren't errors - like documentation comments - but also aren't
             // subdiagnostics.
             return Ok(quote! {});
@@ -483,18 +465,18 @@ impl<'a> DiagnosticDeriveVariantBuilder<'a> {
         match subdiag {
             SubdiagnosticKind::Label => {
                 report_error_if_not_applied_to_span(attr, &info)?;
-                Ok(self.add_spanned_subdiagnostic(binding, &fn_ident, slug, text))
+                Ok(self.add_spanned_subdiagnostic(binding, &fn_ident, slug, raw_label))
             }
             SubdiagnosticKind::Note | SubdiagnosticKind::Help | SubdiagnosticKind::Warn => {
                 let inner = info.ty.inner_type();
                 if type_matches_path(inner, &["rustc_span", "Span"])
                     || type_matches_path(inner, &["rustc_span", "MultiSpan"])
                 {
-                    Ok(self.add_spanned_subdiagnostic(binding, &fn_ident, slug, text))
+                    Ok(self.add_spanned_subdiagnostic(binding, &fn_ident, slug, raw_label))
                 } else if type_is_unit(inner)
                     || (matches!(info.ty, FieldInnerTy::Plain(_)) && type_is_bool(inner))
                 {
-                    Ok(self.add_subdiagnostic(&fn_ident, slug, text))
+                    Ok(self.add_subdiagnostic(&fn_ident, slug, raw_label))
                 } else {
                     report_type_error(attr, "`Span`, `MultiSpan`, `bool` or `()`")?
                 }
@@ -525,10 +507,9 @@ impl<'a> DiagnosticDeriveVariantBuilder<'a> {
                     .unwrap_or_else(|| quote! { rustc_errors::Applicability::Unspecified });
                 let style = suggestion_kind.to_suggestion_style();
 
-                let suggestion_label = if let Some(text) = text {
-                    //let text = format_for_variables(&text, &self.fields);
+                let suggestion_label = if let Some(raw_label) = raw_label {
                     quote! {
-                        #text
+                        #raw_label
                     }
                 } else {
                     quote! {
@@ -558,24 +539,23 @@ impl<'a> DiagnosticDeriveVariantBuilder<'a> {
         field_binding: TokenStream,
         kind: &Ident,
         fluent_attr_identifier: Path,
-        text: Option<String>,
+        raw_label: Option<String>,
     ) -> TokenStream {
         let diag = &self.parent.diag;
         let fn_name = format_ident!("span_{}", kind);
-        if let Some(text) = text {
-            //let text = format_for_variables(&text, &self.fields);
+        if let Some(raw_label) = raw_label {
             return quote! {
                 #diag.#fn_name(
                     #field_binding,
-                    #text
+                    #raw_label
                 );
             };
         }
-        if let Some(text) = self.get_attr(kind.to_string().as_str()) {
+        if let Some(raw_label) = self.get_attr(kind.to_string().as_str()) {
             quote! {
                 #diag.#fn_name(
                     #field_binding,
-                    #text
+                    #raw_label
                 );
             }
         } else {
@@ -594,22 +574,17 @@ impl<'a> DiagnosticDeriveVariantBuilder<'a> {
         &self,
         kind: &Ident,
         fluent_attr_identifier: Path,
-        text: Option<String>,
+        raw_label: Option<String>,
     ) -> TokenStream {
         let diag = &self.parent.diag;
-        // eprintln!(
-        //     "add_subdiagnostic fluent_attr_identifier: {:?} text: {:?}",
-        //     fluent_attr_identifier, text
-        // );
-        if let Some(text) = text {
-            //let text = format_for_variables(&text, &self.fields);
+        if let Some(raw_label) = raw_label {
             return quote! {
-                #diag.#kind(#text);
+                #diag.#kind(#raw_label);
             };
         }
-        if let Some(text) = self.get_attr(kind.to_string().as_str()) {
+        if let Some(raw_label) = self.get_attr(kind.to_string().as_str()) {
             quote! {
-                #diag.#kind(#text);
+                #diag.#kind(#raw_label);
             }
         } else {
             quote! {
@@ -677,7 +652,6 @@ impl<'a> DiagnosticDeriveVariantBuilder<'a> {
 
     fn get_attr(&self, key: &str) -> Option<TokenStream> {
         self.attrs.get(key).map(|val| {
-            //let text = format_for_variables(&val.value(), &self.fields);
             let text = &val.value();
             quote! {
                 #text

compiler/rustc_macros/src/diagnostics/subdiagnostic.rs

@@ -190,30 +190,30 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
         let mut kind_slugs = vec![];
 
         for attr in self.variant.ast().attrs {
-            let Some(SubdiagnosticVariant { kind, slug, no_span, text }) =
+            let Some(SubdiagnosticVariant { kind, slug, no_span, raw_label }) =
                 SubdiagnosticVariant::from_attr(attr, self)?
             else {
                 // Some attributes aren't errors - like documentation comments - but also aren't
                 // subdiagnostics.
                 continue;
             };
 
-            match (&slug, &text) {
+            match (&slug, &raw_label) {
                 (None, None) => {
                     throw_span_err!(
                         attr.span().unwrap(),
-                        "diagnostic slug or text must be first argument of a `#[{name}(...)]` attribute"
+                        "diagnostic slug or raw_label must be first argument of a `#[{name}(...)]` attribute"
                     );
                 }
                 (Some(_), Some(_)) => {
                     throw_span_err!(
                         attr.span().unwrap(),
-                        "diagnostic slug and text cannot both be specified"
+                        "diagnostic slug and raw_label cannot both be specified"
                     );
                 }
                 _ => (),
             }
-            kind_slugs.push((kind, slug, no_span, text));
+            kind_slugs.push((kind, slug, no_span, raw_label));
         }
 
         Ok(kind_slugs)
@@ -520,14 +520,14 @@ impl<'parent, 'a> SubdiagnosticDeriveVariantBuilder<'parent, 'a> {
         let diag = &self.parent.diag;
         let f = &self.parent.f;
         let mut calls = TokenStream::new();
-        for (kind, slug, no_span, text) in kind_slugs {
+        for (kind, slug, no_span, raw_label) in kind_slugs {
             let message = format_ident!("__message");
             if let Some(slug) = slug {
                 calls.extend(
                     quote! { let #message = #f(#diag, crate::fluent_generated::#slug.into()); },
                 );
             } else {
-                calls.extend(quote! { let #message = #f(#diag, #text.into()); });
+                calls.extend(quote! { let #message = #f(#diag, #raw_label.into()); });
             }
 
             let name = format_ident!(