Make diagnostics more translatable

Author: jhpratt

compiler/rustc_parse/messages.ftl

@@ -377,12 +377,12 @@ parse_inclusive_range_no_end = inclusive range with no end
 parse_incorrect_parens_trait_bounds = incorrect parentheses around trait bounds
 parse_incorrect_parens_trait_bounds_sugg = fix the parentheses
 
-parse_incorrect_restriction = incorrect {$noun} restriction
-    .help = some possible {$noun} restrictions are:
-            `{$keyword}(crate)`: {$adjective} only in the current crate
-            `{$keyword}(super)`: {$adjective} only in the current module's parent
-            `{$keyword}(in path::to::module)`: {$adjective} only in the specified path
-    .suggestion = make this {$adjective} only to module `{$inner_str}` with `in`
+parse_incorrect_restriction = incorrect {parse_restriction_noun} restriction
+    .help = some possible {parse_restriction_noun} restrictions are:
+            `{$keyword}(crate)`: {parse_restriction_adjective} only in the current crate
+            `{$keyword}(super)`: {parse_restriction_adjective} only in the current module's parent
+            `{$keyword}(in path::to::module)`: {parse_restriction_adjective} only in the specified path
+    .suggestion = make this {parse_restriction_adjective} only to module `{$path}` with `in`
 
 parse_incorrect_semicolon =
     expected item, found `;`
@@ -790,6 +790,18 @@ parse_reserved_string = invalid string literal
     .note = unprefixed guarded string literals are reserved for future use since Rust 2024
     .suggestion_whitespace = consider inserting whitespace here
 
+# internal use only
+parse_restriction_adjective = { $keyword ->
+    [impl] implementable
+    *[DEFAULT_IS_BUG] BUG
+}
+
+# internal use only
+parse_restriction_noun = { $keyword ->
+    [impl] impl
+    *[DEFAULT_IS_BUG] BUG
+}
+
 parse_return_types_use_thin_arrow = return types are denoted using `->`
     .suggestion = use `->` instead
 

compiler/rustc_parse/src/errors.rs

@@ -1046,12 +1046,10 @@ pub(crate) struct IncorrectVisibilityRestriction {
 #[help]
 pub(crate) struct IncorrectRestriction<'kw> {
     #[primary_span]
-    #[suggestion(code = "in {inner_str}", applicability = "machine-applicable", style = "verbose")]
+    #[suggestion(code = "in {path}", applicability = "machine-applicable", style = "verbose")]
     pub span: Span,
-    pub inner_str: String,
+    pub path: String,
     pub keyword: &'kw str,
-    pub adjective: &'static str,
-    pub noun: &'static str,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_parse/src/parser/item.rs

@@ -931,13 +931,8 @@ impl<'a> Parser<'a> {
 
     /// Parses `[ impl(in path) ]? unsafe? auto? trait Foo { ... }` or `trait Foo = Bar;`.
     fn parse_item_trait(&mut self, attrs: &mut AttrVec, lo: Span) -> PResult<'a, ItemKind> {
-        let impl_restriction = self.parse_restriction(
-            exp!(Impl),
-            Some(sym::impl_restriction),
-            "implementable",
-            "impl",
-            FollowedByType::No,
-        )?;
+        let impl_restriction =
+            self.parse_restriction(exp!(Impl), Some(sym::impl_restriction), FollowedByType::No)?;
         let safety = self.parse_safety(Case::Sensitive);
         // Parse optional `auto` prefix.
         let is_auto = if self.eat_keyword(exp!(Auto)) {

compiler/rustc_parse/src/parser/mod.rs

@@ -1522,8 +1522,6 @@ impl<'a> Parser<'a> {
         &mut self,
         kw: ExpKeywordPair,
         feature_gate: Option<Symbol>,
-        action: &'static str,
-        description: &'static str,
         fbt: FollowedByType,
     ) -> PResult<'a, Restriction> {
         if !self.eat_keyword(kw) {
@@ -1567,7 +1565,7 @@ impl<'a> Parser<'a> {
             } else if let FollowedByType::No = fbt {
                 // Provide this diagnostic if a type cannot follow;
                 // in particular, if this is not a tuple struct.
-                self.recover_incorrect_restriction(kw.kw.as_str(), action, description)?;
+                self.recover_incorrect_restriction(kw.kw.as_str())?;
                 // Emit diagnostic, but continue unrestricted.
             }
         }
@@ -1576,24 +1574,13 @@ impl<'a> Parser<'a> {
     }
 
     /// Recovery for e.g. `kw(something) fn ...` or `struct X { kw(something) y: Z }`
-    fn recover_incorrect_restriction<'kw>(
-        &mut self,
-        kw: &'kw str,
-        action: &'static str,
-        description: &'static str,
-    ) -> PResult<'a, ()> {
+    fn recover_incorrect_restriction<'kw>(&mut self, kw: &'kw str) -> PResult<'a, ()> {
         self.bump(); // `(`
         let path = self.parse_path(PathStyle::Mod)?;
         self.expect(exp!(CloseParen))?; // `)`
 
         let path_str = pprust::path_to_string(&path);
-        self.dcx().emit_err(IncorrectRestriction {
-            span: path.span,
-            inner_str: path_str,
-            keyword: kw,
-            adjective: action,
-            noun: description,
-        });
+        self.dcx().emit_err(IncorrectRestriction { span: path.span, path: path_str, keyword: kw });
 
         Ok(())
     }