begin on no-fluent-errors

Author: chenyukang

Cargo.lock

@@ -1369,6 +1369,16 @@ dependencies = [
  "miniz_oxide",
 ]
 
+[[package]]
+name = "fluent"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61f69378194459db76abd2ce3952b790db103ceb003008d3d50d97c41ff847a7"
+dependencies = [
+ "fluent-bundle",
+ "unic-langid",
+]
+
 [[package]]
 name = "fluent-bundle"
 version = "0.15.2"
@@ -3858,6 +3868,7 @@ version = "0.0.0"
 dependencies = [
  "annotate-snippets",
  "derive_setters",
+ "fluent",
  "rustc_ast",
  "rustc_ast_pretty",
  "rustc_data_structures",
@@ -3875,6 +3886,7 @@ dependencies = [
  "termcolor",
  "termize",
  "tracing",
+ "unic-langid",
  "unicode-width",
  "windows",
 ]
@@ -4190,6 +4202,7 @@ version = "0.0.0"
 dependencies = [
  "proc-macro2",
  "quote",
+ "regex",
  "syn 2.0.29",
  "synstructure",
 ]

compiler/rustc_errors/Cargo.toml

@@ -25,6 +25,9 @@ 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"]}
+
 # tidy-alphabetical-end
 
 [target.'cfg(windows)'.dependencies.windows]

compiler/rustc_errors/src/translation.rs

@@ -1,11 +1,14 @@
 use crate::error::{TranslateError, TranslateErrorKind};
+use crate::fluent_bundle::FluentResource;
 use crate::snippet::Style;
 use crate::{DiagnosticArg, DiagnosticMessage, FluentBundle};
+use fluent::FluentBundle as RawFluentBundle;
 use rustc_data_structures::sync::Lrc;
 use rustc_error_messages::FluentArgs;
 use std::borrow::Cow;
 use std::env;
 use std::error::Report;
+use unic_langid::langid;
 
 /// Convert diagnostic arguments (a rustc internal type that exists to implement
 /// `Encodable`/`Decodable`) into `FluentArgs` which is necessary to perform translation.
@@ -62,7 +65,29 @@ pub trait Translate {
         trace!(?message, ?args);
         let (identifier, attr) = match message {
             DiagnosticMessage::Str(msg) | DiagnosticMessage::Eager(msg) => {
-                return Ok(Cow::Borrowed(msg));
+                if args.iter().next().is_none() || (!msg.contains("$") && !msg.contains("`{")) {
+                    return Ok(Cow::Borrowed(msg));
+                } else {
+                    // FIXME(yukang) A hacky for raw fluent content
+                    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]);
+                        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);
+                        return Ok(Cow::Borrowed(msg));
+                    }
+                }
             }
             DiagnosticMessage::FluentIdentifier(identifier, attr) => (identifier, attr),
         };

compiler/rustc_macros/Cargo.toml

@@ -12,4 +12,5 @@ proc-macro2 = "1"
 quote = "1"
 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,26 +30,27 @@ 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 preamble = builder.preamble(variant);
-            let body = builder.body(variant);
-
             let diag = &builder.parent.diag;
             let DiagnosticDeriveKind::Diagnostic { handler } = &builder.parent.kind else {
+                eprintln!("BUG: DiagnosticDeriveKind::Diagnostic expected");
                 unreachable!()
             };
-            let init = match builder.slug.value_ref() {
-                None => {
-                    span_err(builder.span, "diagnostic slug not specified")
+
+            let preamble = builder.preamble(variant);
+            let body = builder.body(variant);
+
+            let init = match (builder.slug.value_ref(), builder.label.value_ref()) {
+                (None, None) => {
+                        span_err(builder.span, "diagnostic slug or label is not specified")
                         .help(
                             "specify the slug as the first argument to the `#[diag(...)]` \
-                            attribute, such as `#[diag(hir_analysis_example_error)]`",
+                            attribute, such as `#[diag(hir_analysis_example_error)]`, or use format #[diag(label = \"the message ..\")]",
                         )
                         .emit();
                     return DiagnosticDeriveError::ErrorHandled.to_compile_error();
                 }
-                Some(slug)
+                (Some(slug), None)
                     if let Some(Mismatch { slug_name, crate_name, slug_prefix }) =
                         Mismatch::check(slug) =>
                 {
@@ -59,12 +60,19 @@ impl<'a> DiagnosticDerive<'a> {
                         .emit();
                     return DiagnosticDeriveError::ErrorHandled.to_compile_error();
                 }
-                Some(slug) => {
-                    slugs.borrow_mut().push(slug.clone());
+                (Some(slug), None) => {
                     quote! {
                         let mut #diag = #handler.struct_diagnostic(crate::fluent_generated::#slug);
                     }
                 }
+                (None, Some(text)) => {
+                    quote! {
+                        let mut #diag = #handler.struct_diagnostic(DiagnosticMessage::Str(#text.into()));
+                    }
+                }
+                (Some(_slug), Some(_text)) => {
+                    unreachable!("BUG: slug and text specified");
+                }
             };
 
             let formatting_init = &builder.formatting_init;
@@ -77,9 +85,11 @@ impl<'a> DiagnosticDerive<'a> {
             }
         });
 
-        let DiagnosticDeriveKind::Diagnostic { handler } = &builder.kind else { unreachable!() };
+        let DiagnosticDeriveKind::Diagnostic { handler } = &builder.kind else {
+            unreachable!();
+        };
 
-        let mut imp = structure.gen_impl(quote! {
+        let imp = structure.gen_impl(quote! {
             gen impl<'__diagnostic_handler_sess, G>
                     rustc_errors::IntoDiagnostic<'__diagnostic_handler_sess, G>
                     for @Self
@@ -96,9 +106,6 @@ impl<'a> DiagnosticDerive<'a> {
                 }
             }
         });
-        for test in slugs.borrow().iter().map(|s| generate_test(s, &structure)) {
-            imp.extend(test);
-        }
         imp
     }
 }