Make lint messages translatable

Author: Xiretza

compiler/rustc_lint/messages.ftl

@@ -1,3 +1,8 @@
+lint_abs_path_with_module =
+    absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition
+
+lint_ambiguous_glob_reexport = ambiguous glob re-exports
+
 lint_ambiguous_wide_pointer_comparisons = ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
     .addr_metadata_suggestion = use explicit `std::ptr::eq` method to compare metadata and addresses
     .addr_suggestion = use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
@@ -26,10 +31,19 @@ lint_atomic_ordering_load = atomic loads cannot have `Release` or `AcqRel` order
 lint_atomic_ordering_store = atomic stores cannot have `Acquire` or `AcqRel` ordering
     .help = consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
+lint_avoid_att_syntax =
+    avoid using `.att_syntax`, prefer using `options(att_syntax)` instead
+
+lint_avoid_intel_syntax =
+    avoid using `.intel_syntax`, Intel syntax is the default
+
 lint_bad_attribute_argument = bad attribute argument
 
 lint_bad_opt_access = {$msg}
 
+lint_break_with_label_and_loop =
+    this labeled break expression is easy to confuse with an unlabeled break with a labeled value expression
+
 lint_builtin_allow_internal_unsafe =
     `allow_internal_unsafe` allows defining macros using unsafe without triggering the `unsafe_code` lint at their call site
 
@@ -184,6 +198,8 @@ lint_cstring_ptr = getting the inner pointer of a temporary `CString`
     .note = pointers do not have a lifetime; when calling `as_ptr` the `CString` will be deallocated at the end of the statement because nothing is referencing it as far as the type system is concerned
     .help = for more information, see https://doc.rust-lang.org/reference/destructors.html
 
+lint_custom_inner_attribute_unstable = custom inner attributes are unstable
+
 lint_default_hash_types = prefer `{$preferred}` over `{$used}`, it has better performance
     .note = a `use rustc_data_structures::fx::{$preferred}` may be necessary
 
@@ -214,6 +230,11 @@ lint_dropping_references = calls to `std::mem::drop` with a reference instead of
     .label = argument has type `{$arg_ty}`
     .note = use `let _ = ...` to ignore the expression or result
 
+lint_duplicate_macro_attribute =
+    duplicated attribute
+
+lint_elided_lifetime_not_allowed = `'_` cannot be used here
+
 lint_enum_intrinsics_mem_discriminant =
     the return value of `mem::discriminant` is unspecified when called with a non-enum type
     .note = the argument to `discriminant` should be a reference to an enum, but it was passed a reference to a `{$ty_param}`, which is not an enum.
@@ -226,6 +247,8 @@ lint_expectation = this lint expectation is unfulfilled
     .note = the `unfulfilled_lint_expectations` lint can't be expected and will always produce this message
     .rationale = {$rationale}
 
+lint_extern_crate_not_idiomatic = `extern crate` is not idiomatic in the new edition
+
 lint_extern_without_abi = extern declarations without an explicit ABI are deprecated
 
 lint_for_loops_over_fallibles =
@@ -242,6 +265,10 @@ lint_forgetting_references = calls to `std::mem::forget` with a reference instea
     .label = argument has type `{$arg_ty}`
     .note = use `let _ = ...` to ignore the expression or result
 
+lint_hidden_glob_reexport = private item shadows public glob re-export
+
+lint_hidden_lifetime_parameters = hidden lifetime parameters in types are deprecated
+
 lint_hidden_unicode_codepoints = unicode codepoint changing visible direction of text present in {$label}
     .label = this {$label} contains {$count ->
         [one] an invisible
@@ -342,6 +369,13 @@ lint_improper_ctypes_union_layout_help = consider adding a `#[repr(C)]` or `#[re
 lint_improper_ctypes_union_layout_reason = this union has unspecified layout
 lint_improper_ctypes_union_non_exhaustive = this union is non-exhaustive
 
+lint_incomplete_include =
+    include macro expected single expression in source
+
+lint_inner_macro_attribute_unstable = inner macro attributes are unstable
+
+lint_invalid_crate_type_value = invalid `crate_type` value
+
 # FIXME: we should ordinalize $valid_up_to when we add support for doing so
 lint_invalid_from_utf8_checked = calls to `{$method}` with a invalid literal always return an error
     .label = the literal was valid UTF-8 up to the {$valid_up_to} bytes
@@ -370,9 +404,18 @@ lint_invalid_reference_casting_note_book = for more information, visit <https://
 
 lint_invalid_reference_casting_note_ty_has_interior_mutability = even for types with interior mutability, the only legal way to obtain a mutable pointer from a shared reference is through `UnsafeCell::get`
 
+lint_legacy_derive_helpers =
+    derive helper attribute is used before it is introduced
+
 lint_lintpass_by_hand = implementing `LintPass` by hand
     .help = try using `declare_lint_pass!` or `impl_lint_pass!` instead
 
+lint_macro_expanded_macro_exports_accessed_by_absolute_paths =
+    macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths
+
+lint_macro_use_deprecated =
+    deprecated `#[macro_use]` attribute used to import macros should be replaced at use sites with a `use` item to import the macro instead
+
 lint_malformed_attribute = malformed lint attribute input
 
 lint_map_unit_fn = `Iterator::map` call that discard the iterator's values
@@ -382,6 +425,8 @@ lint_map_unit_fn = `Iterator::map` call that discard the iterator's values
     .map_label = after this call to map, the resulting iterator is `impl Iterator<Item = ()>`, which means the only information carried by the iterator is the number of items
     .suggestion = you might have meant to use `Iterator::for_each`
 
+lint_missing_fragment_specifier = missing fragment specifier
+
 lint_mixed_script_confusables =
     the usage of Script Group `{$set}` in this crate consists solely of mixed script confusables
     .includes_note = the usage includes {$includes}
@@ -498,6 +543,9 @@ lint_opaque_hidden_inferred_bound = opaque type `{$ty}` does not satisfy its ass
 
 lint_opaque_hidden_inferred_bound_sugg = add this bound
 
+lint_or_patterns_back_compat =
+    the meaning of the `pat` fragment specifier is changing in Rust 2021, which may affect this macro
+
 lint_overflowing_bin_hex = literal out of range for `{$ty}`
     .negative_note = the literal `{$lit}` (decimal `{$dec}`) does not fit into the type `{$ty}`
     .negative_becomes_note = and the value `-{$lit}` will become `{$actually}{$ty}`
@@ -533,6 +581,8 @@ lint_pattern_in_bodiless = patterns aren't allowed in functions without bodies
 lint_pattern_in_foreign = patterns aren't allowed in foreign function declarations
     .label = pattern not allowed in foreign function
 
+lint_proc_macro_back_compat_rental = using an old version of `rental`
+
 lint_ptr_null_checks_fn_ptr = function pointers are not nullable, so checking them for null will always return false
     .help = wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
     .label = expression has type `{$orig_ty}`
@@ -564,6 +614,8 @@ lint_redundant_semicolons =
         *[false] this semicolon
     }
 
+lint_reference_without_lifetime_not_allowed = `&` without an explicit lifetime name cannot be used here
+
 lint_removed_lint = lint `{$name}` has been removed: {$reason}
 
 lint_renamed_lint = lint `{$name}` has been renamed to `{$replace}`
@@ -585,6 +637,9 @@ lint_suspicious_double_ref_clone =
 lint_suspicious_double_ref_deref =
     using `.deref()` on a double reference, which returns `{$ty}` instead of dereferencing the inner type
 
+lint_trailing_semi_macro =
+    trailing semicolon in macro used in expression position
+
 lint_ty_qualified = usage of qualified `ty::{$ty}`
     .suggestion = try importing it and using it unqualified
 
@@ -601,9 +656,14 @@ lint_undropped_manually_drops = calls to `std::mem::drop` with `std::mem::Manual
 lint_ungated_async_fn_track_caller = `#[track_caller]` on async functions is a no-op
      .label = this function will not propagate the caller location
 
+lint_unicode_text_flow =
+    unicode codepoint changing visible direction of text present in comment
+
 lint_unit_bindings = binding has unit type `()`
     .label = this pattern is inferred to be the unit type `()`
 
+lint_unknown_diagnostic_attribute = unknown diagnostic attribute
+
 lint_unknown_gated_lint =
     unknown lint: `{$name}`
     .note = the `{$name}` lint is unstable
@@ -624,6 +684,8 @@ lint_unknown_tool_in_scoped_lint = unknown tool name `{$tool_name}` found in sco
 
 lint_unnameable_test_items = cannot test inner items
 
+lint_unnecessary_qualification = unnecessary qualification
+
 lint_unsupported_group = `{$lint_group}` lint group is not supported with ´--force-warn´
 
 lint_untranslatable_diag = diagnostics should be created using translatable messages
@@ -653,8 +715,14 @@ lint_unused_def = unused {$pre}`{$def}`{$post} that must be used
 lint_unused_delim = unnecessary {$delim} around {$item}
     .suggestion = remove these {$delim}
 
+lint_unused_doc_comment = unused doc comment
+
 lint_unused_import_braces = braces around {$node} is unnecessary
 
+lint_unused_label = unused label
+
+lint_unused_macro_use = unused `#[macro_use]` import
+
 lint_unused_op = unused {$op} that must be used
     .label = the {$op} produces a value
     .suggestion = use `let _ = ...` to ignore the resulting value

compiler/rustc_lint/src/context/diagnostics.rs

@@ -11,6 +11,8 @@ use rustc_span::BytePos;
 
 use std::fmt::Write;
 
+use crate::fluent_generated as fluent;
+
 mod check_cfg;
 
 #[cfg(test)]
@@ -384,23 +386,17 @@ pub(super) fn builtin(sess: &Session, diagnostic: BuiltinLintDiag, diag: &mut Di
 
 pub(super) fn builtin_message(diagnostic: &BuiltinLintDiag) -> DiagMessage {
     match diagnostic {
-        BuiltinLintDiag::AbsPathWithModule(_) => {
-            "absolute paths must start with `self`, `super`, `crate`, or an \
-                external crate name in the 2018 edition"
-                .into()
-        }
+        BuiltinLintDiag::AbsPathWithModule(_) => fluent::lint_abs_path_with_module,
         BuiltinLintDiag::ProcMacroDeriveResolutionFallback { ns, ident, .. } => {
             format!("cannot find {} `{}` in this scope", ns.descr(), ident).into()
         }
         BuiltinLintDiag::MacroExpandedMacroExportsAccessedByAbsolutePaths(_) => {
-            "macro-expanded `macro_export` macros from the current crate cannot \
-                be referred to by absolute paths"
-                .into()
+            fluent::lint_macro_expanded_macro_exports_accessed_by_absolute_paths
         }
         BuiltinLintDiag::ElidedLifetimesInPaths(_, _, _, _) => {
-            "hidden lifetime parameters in types are deprecated".into()
+            fluent::lint_hidden_lifetime_parameters
         }
-        BuiltinLintDiag::UnknownCrateTypes(_, _, _) => "invalid `crate_type` value".into(),
+        BuiltinLintDiag::UnknownCrateTypes(_, _, _) => fluent::lint_invalid_crate_type_value,
         BuiltinLintDiag::UnusedImports { span_snippets, .. } => format!(
             "unused import{}{}",
             pluralize!(span_snippets.len()),
@@ -415,42 +411,28 @@ pub(super) fn builtin_message(diagnostic: &BuiltinLintDiag) -> DiagMessage {
             format!("the item `{source}` is imported redundantly").into()
         }
         BuiltinLintDiag::DeprecatedMacro { message, .. } => message.clone().into(),
-        BuiltinLintDiag::MissingAbi(_, _) => crate::fluent_generated::lint_extern_without_abi,
-        BuiltinLintDiag::UnusedDocComment(_) => "unused doc comment".into(),
+        BuiltinLintDiag::MissingAbi(_, _) => fluent::lint_extern_without_abi,
+        BuiltinLintDiag::UnusedDocComment(_) => fluent::lint_unused_doc_comment,
         BuiltinLintDiag::UnusedBuiltinAttribute { attr_name, .. } => {
             format!("unused attribute `{attr_name}`").into()
         }
         BuiltinLintDiag::PatternsInFnsWithoutBody { is_foreign, .. } => {
             if *is_foreign {
-                crate::fluent_generated::lint_pattern_in_foreign
+                fluent::lint_pattern_in_foreign
             } else {
-                crate::fluent_generated::lint_pattern_in_bodiless
+                fluent::lint_pattern_in_bodiless
             }
         }
-        BuiltinLintDiag::LegacyDeriveHelpers(_) => {
-            "derive helper attribute is used before it is introduced".into()
-        }
-        BuiltinLintDiag::ProcMacroBackCompat(_) => "using an old version of `rental`".into(),
-        BuiltinLintDiag::OrPatternsBackCompat(_, _) => {
-            "the meaning of the `pat` fragment specifier is changing in Rust 2021, \
-            which may affect this macro"
-                .into()
-        }
+        BuiltinLintDiag::LegacyDeriveHelpers(_) => fluent::lint_legacy_derive_helpers,
+        BuiltinLintDiag::ProcMacroBackCompat(_) => fluent::lint_proc_macro_back_compat_rental,
+        BuiltinLintDiag::OrPatternsBackCompat(_, _) => fluent::lint_or_patterns_back_compat,
         BuiltinLintDiag::ReservedPrefix(_, prefix) => {
             format!("prefix `{prefix}` is unknown").into()
         }
-        BuiltinLintDiag::TrailingMacro(_, _) => {
-            "trailing semicolon in macro used in expression position".into()
-        }
-        BuiltinLintDiag::BreakWithLabelAndLoop(_) => {
-            "this labeled break expression is easy to confuse with an unlabeled break with a \
-            labeled value expression"
-                .into()
-        }
-        BuiltinLintDiag::NamedAsmLabel(_) => crate::fluent_generated::lint_builtin_asm_labels,
-        BuiltinLintDiag::UnicodeTextFlow(_, _) => {
-            "unicode codepoint changing visible direction of text present in comment".into()
-        }
+        BuiltinLintDiag::TrailingMacro(_, _) => fluent::lint_trailing_semi_macro,
+        BuiltinLintDiag::BreakWithLabelAndLoop(_) => fluent::lint_break_with_label_and_loop,
+        BuiltinLintDiag::NamedAsmLabel(_) => fluent::lint_builtin_asm_labels,
+        BuiltinLintDiag::UnicodeTextFlow(_, _) => fluent::lint_unicode_text_flow,
         BuiltinLintDiag::UnexpectedCfgName((name, _), _) => {
             format!("unexpected `cfg` condition name: `{}`", name).into()
         }
@@ -461,7 +443,7 @@ pub(super) fn builtin_message(diagnostic: &BuiltinLintDiag) -> DiagMessage {
         }
         .into(),
         BuiltinLintDiag::DeprecatedWhereclauseLocation(_) => {
-            crate::fluent_generated::lint_deprecated_where_clause_location
+            fluent::lint_deprecated_where_clause_location
         }
         BuiltinLintDiag::SingleUseLifetime { use_span, ident, .. } => {
             if use_span.is_some() {
@@ -477,41 +459,34 @@ pub(super) fn builtin_message(diagnostic: &BuiltinLintDiag) -> DiagMessage {
             format!("{ty} slice in a packed struct that derives a built-in trait").into()
         }
         BuiltinLintDiag::UnusedExternCrate { .. } => "unused extern crate".into(),
-        BuiltinLintDiag::ExternCrateNotIdiomatic { .. } => {
-            "`extern crate` is not idiomatic in the new edition".into()
-        }
+        BuiltinLintDiag::ExternCrateNotIdiomatic { .. } => fluent::lint_extern_crate_not_idiomatic,
         BuiltinLintDiag::AmbiguousGlobImports { diag } => diag.msg.clone().into(),
-        BuiltinLintDiag::AmbiguousGlobReexports { .. } => "ambiguous glob re-exports".into(),
-        BuiltinLintDiag::HiddenGlobReexports { .. } => {
-            "private item shadows public glob re-export".into()
-        }
-        BuiltinLintDiag::UnusedQualifications { .. } => "unnecessary qualification".into(),
-        BuiltinLintDiag::AssociatedConstElidedLifetime { elided, .. } => if *elided {
-            "`&` without an explicit lifetime name cannot be used here"
-        } else {
-            "`'_` cannot be used here"
+        BuiltinLintDiag::AmbiguousGlobReexports { .. } => fluent::lint_ambiguous_glob_reexport,
+        BuiltinLintDiag::HiddenGlobReexports { .. } => fluent::lint_hidden_glob_reexport,
+        BuiltinLintDiag::UnusedQualifications { .. } => fluent::lint_unnecessary_qualification,
+        BuiltinLintDiag::AssociatedConstElidedLifetime { elided, .. } => {
+            if *elided {
+                fluent::lint_reference_without_lifetime_not_allowed
+            } else {
+                fluent::lint_elided_lifetime_not_allowed
+            }
         }
-        .into(),
         BuiltinLintDiag::RedundantImportVisibility { import_vis, .. } => format!(
             "glob import doesn't reexport anything with visibility `{}` \
             because no imported item is public enough",
             import_vis
         )
         .into(),
-        BuiltinLintDiag::InvalidCrateTypeValue => "invalid `crate_type` value".into(),
-        BuiltinLintDiag::MacroUseDeprecated => "deprecated `#[macro_use]` attribute used to \
-                                import macros should be replaced at use sites \
-                                with a `use` item to import the macro \
-                                instead"
-            .into(),
-        BuiltinLintDiag::UnusedMacroUse => "unused `#[macro_use]` import".into(),
+        BuiltinLintDiag::InvalidCrateTypeValue => fluent::lint_invalid_crate_type_value,
+        BuiltinLintDiag::MacroUseDeprecated => fluent::lint_macro_use_deprecated,
+        BuiltinLintDiag::UnusedMacroUse => fluent::lint_unused_macro_use,
         BuiltinLintDiag::PrivateExternCrateReexport(ident) => format!(
             "extern crate `{ident}` is private, and cannot be \
                                    re-exported (error E0365), consider declaring with \
                                    `pub`"
         )
         .into(),
-        BuiltinLintDiag::UnusedLabel => "unused label".into(),
+        BuiltinLintDiag::UnusedLabel => fluent::lint_unused_label,
         BuiltinLintDiag::MacroIsPrivate(ident) => format!("macro `{ident}` is private").into(),
         BuiltinLintDiag::UnusedMacroDefinition(name) => {
             format!("unused macro definition: `{}`", name).into()
@@ -520,27 +495,15 @@ pub(super) fn builtin_message(diagnostic: &BuiltinLintDiag) -> DiagMessage {
             format!("{} rule of macro `{}` is never used", ordinalize(n + 1), name).into()
         }
         BuiltinLintDiag::UnstableFeature(msg) => msg.clone().into(),
-        BuiltinLintDiag::AvoidUsingIntelSyntax => {
-            "avoid using `.intel_syntax`, Intel syntax is the default".into()
-        }
-        BuiltinLintDiag::AvoidUsingAttSyntax => {
-            "avoid using `.att_syntax`, prefer using `options(att_syntax)` instead".into()
-        }
-        BuiltinLintDiag::IncompleteInclude => {
-            "include macro expected single expression in source".into()
-        }
-        BuiltinLintDiag::UnnameableTestItems => crate::fluent_generated::lint_unnameable_test_items,
-        BuiltinLintDiag::DuplicateMacroAttribute => "duplicated attribute".into(),
-        BuiltinLintDiag::CfgAttrNoAttributes => {
-            crate::fluent_generated::lint_cfg_attr_no_attributes
-        }
-        BuiltinLintDiag::CrateTypeInCfgAttr => {
-            crate::fluent_generated::lint_crate_type_in_cfg_attr_deprecated
-        }
-        BuiltinLintDiag::CrateNameInCfgAttr => {
-            crate::fluent_generated::lint_crate_name_in_cfg_attr_deprecated
-        }
-        BuiltinLintDiag::MissingFragmentSpecifier => "missing fragment specifier".into(),
+        BuiltinLintDiag::AvoidUsingIntelSyntax => fluent::lint_avoid_intel_syntax,
+        BuiltinLintDiag::AvoidUsingAttSyntax => fluent::lint_avoid_att_syntax,
+        BuiltinLintDiag::IncompleteInclude => fluent::lint_incomplete_include,
+        BuiltinLintDiag::UnnameableTestItems => fluent::lint_unnameable_test_items,
+        BuiltinLintDiag::DuplicateMacroAttribute => fluent::lint_duplicate_macro_attribute,
+        BuiltinLintDiag::CfgAttrNoAttributes => fluent::lint_cfg_attr_no_attributes,
+        BuiltinLintDiag::CrateTypeInCfgAttr => fluent::lint_crate_type_in_cfg_attr_deprecated,
+        BuiltinLintDiag::CrateNameInCfgAttr => fluent::lint_crate_name_in_cfg_attr_deprecated,
+        BuiltinLintDiag::MissingFragmentSpecifier => fluent::lint_missing_fragment_specifier,
         BuiltinLintDiag::MetaVariableStillRepeating(name) => {
             format!("variable '{name}' is still repeating at this depth").into()
         }
@@ -556,7 +519,7 @@ pub(super) fn builtin_message(diagnostic: &BuiltinLintDiag) -> DiagMessage {
             extern_crate, local_crate, extern_crate
         )
         .into(),
-        BuiltinLintDiag::WasmCAbi => crate::fluent_generated::lint_wasm_c_abi,
+        BuiltinLintDiag::WasmCAbi => fluent::lint_wasm_c_abi,
         BuiltinLintDiag::IllFormedAttributeInput { suggestions } => suggestions
             .iter()
             .enumerate()
@@ -568,13 +531,14 @@ pub(super) fn builtin_message(diagnostic: &BuiltinLintDiag) -> DiagMessage {
                 acc
             })
             .into(),
-        BuiltinLintDiag::InnerAttributeUnstable { is_macro } => if *is_macro {
-            "inner macro attributes are unstable"
-        } else {
-            "custom inner attributes are unstable"
+        BuiltinLintDiag::InnerAttributeUnstable { is_macro } => {
+            if *is_macro {
+                fluent::lint_inner_macro_attribute_unstable
+            } else {
+                fluent::lint_custom_inner_attribute_unstable
+            }
         }
-        .into(),
-        BuiltinLintDiag::UnknownDiagnosticAttribute => "unknown diagnostic attribute".into(),
+        BuiltinLintDiag::UnknownDiagnosticAttribute => fluent::lint_unknown_diagnostic_attribute,
     }
 }