Convert early lints to diag structs

Author: Xiretza

compiler/rustc_lint/messages.ftl

@@ -235,6 +235,8 @@ lint_dropping_references = calls to `std::mem::drop` with a reference instead of
 lint_duplicate_macro_attribute =
     duplicated attribute
 
+lint_duplicate_matcher_binding = duplicate matcher binding
+
 lint_elided_lifetime_not_allowed = `'_` cannot be used here
 
 lint_enum_intrinsics_mem_discriminant =
@@ -312,6 +314,11 @@ lint_identifier_uncommon_codepoints = identifier contains {$codepoints_len ->
 
 lint_ignored_unless_crate_specified = {$level}({$name}) is ignored unless specified at crate level
 
+lint_ill_formed_attribute_input = {$num_suggestions ->
+        [1] attribute must be of the form {$suggestions}
+        *[other] valid forms for the attribute are {$suggestions}
+    }
+
 lint_improper_ctypes = `extern` {$desc} uses type `{$ty}`, which is not FFI-safe
     .label = not FFI-safe
     .note = the type is defined here
@@ -415,6 +422,16 @@ lint_lintpass_by_hand = implementing `LintPass` by hand
 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_is_private = macro `{$ident}` is private
+
+lint_macro_rule_never_used = ${NUMBER($n, type: "ordinal") ->
+        [1] first
+        [one] {$n}st
+        [two] {$n}nd
+        [few] {$n}rd
+        *[other] {$n}th
+    } rule of macro `{$name}` is never used
+
 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
 
@@ -427,6 +444,10 @@ 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_metavariable_still_repeating = variable '{$name}' is still repeating at this depth
+
+lint_metavariable_wrong_operator = meta-variable repeats with different Kleene operator
+
 lint_missing_fragment_specifier = missing fragment specifier
 
 lint_mixed_script_confusables =
@@ -583,6 +604,9 @@ 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_private_extern_crate_reexport =
+    extern crate `{$ident}` is private, and cannot be re-exported (error E0365), consider declaring with `pub`
+
 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
@@ -681,6 +705,8 @@ lint_unknown_lint =
         *[false] did you mean: `{$replace}`
     }
 
+lint_unknown_macro_variable = unknown macro variable `{$name}`
+
 lint_unknown_tool_in_scoped_lint = unknown tool name `{$tool_name}` found in scoped lint: `{$tool_name}::{$lint_name}`
     .help = add `#![register_tool({$tool_name})]` to the crate root
 
@@ -711,6 +737,8 @@ lint_unused_coroutine =
     }{$post} that must be used
     .note = coroutines are lazy and do nothing unless resumed
 
+lint_unused_crate_dependency = external crate `{$extern_crate}` unused in `{$local_crate}`: remove the dependency or add `use {$extern_crate} as _;`
+
 lint_unused_def = unused {$pre}`{$def}`{$post} that must be used
     .suggestion = use `let _ = ...` to ignore the resulting value
 
@@ -723,6 +751,8 @@ lint_unused_import_braces = braces around {$node} is unnecessary
 
 lint_unused_label = unused label
 
+lint_unused_macro_definition = unused macro definition: `{$name}`
+
 lint_unused_macro_use = unused `#[macro_use]` import
 
 lint_unused_op = unused {$op} that must be used

compiler/rustc_lint/src/context/diagnostics.rs

@@ -3,23 +3,27 @@
 
 use rustc_ast::util::unicode::TEXT_FLOW_CONTROL_CHARS;
 use rustc_errors::{
-    add_elided_lifetime_in_path_suggestion, pluralize, Diag, DiagMessage, MultiSpan,
+    add_elided_lifetime_in_path_suggestion, pluralize, Diag, DiagArgValue, DiagMessage, MultiSpan,
 };
 use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_middle::middle::stability;
 use rustc_session::lint::{BuiltinLintDiag, Lint};
 use rustc_session::Session;
 use rustc_span::BytePos;
 
-use std::fmt::Write;
-
+use crate::lints::{
+    AvoidAttSyntax, AvoidIntelSyntax, CfgAttrNoAttributes, CrateNameInCfgAttr, CrateTypeInCfgAttr,
+    DuplicateMacroAttribute, DuplicateMatcherBinding, IllFormedAttributeInput, IncompleteInclude,
+    InnerAttributeUnstable, InvalidCrateTypeValue, MacroIsPrivate, MacroRuleNeverUsed,
+    MacroUseDeprecated, MetaVariableStillRepeating, MetaVariableWrongOperator,
+    MissingFragmentSpecifier, PrivateExternCrateReexport, UnknownDiagnosticAttribute,
+    UnknownMacroVariable, UnnameableTestItems, UnstableFeature, UnusedCrateDependency, UnusedLabel,
+    UnusedMacroDefinition, UnusedMacroUse, WasmCAbi,
+};
 use crate::{fluent_generated as fluent, LintContext};
 
 mod check_cfg;
 
-#[cfg(test)]
-mod tests;
-
 fn buffered_decorate(sess: &Session, diagnostic: BuiltinLintDiag, diag: &mut Diag<'_, ()>) {
     match diagnostic {
         BuiltinLintDiag::UnicodeTextFlow(span, content) => {
@@ -374,11 +378,11 @@ fn buffered_decorate(sess: &Session, diagnostic: BuiltinLintDiag, diag: &mut Dia
         | BuiltinLintDiag::MetaVariableWrongOperator
         | BuiltinLintDiag::DuplicateMatcherBinding
         | BuiltinLintDiag::UnknownMacroVariable(_)
-        | BuiltinLintDiag::UnusedExternCrate2 { .. }
+        | BuiltinLintDiag::UnusedCrateDependency { .. }
         | BuiltinLintDiag::WasmCAbi
         | BuiltinLintDiag::IllFormedAttributeInput { .. }
         | BuiltinLintDiag::InnerAttributeUnstable { .. }
-        | BuiltinLintDiag::UnknownDiagnosticAttribute => {}
+        | BuiltinLintDiag::UnknownDiagnosticAttribute => unreachable!(),
     }
 }
 
@@ -474,68 +478,34 @@ fn buffered_message(diagnostic: &BuiltinLintDiag) -> DiagMessage {
             import_vis
         )
         .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 => fluent::lint_unused_label,
-        BuiltinLintDiag::MacroIsPrivate(ident) => format!("macro `{ident}` is private").into(),
-        BuiltinLintDiag::UnusedMacroDefinition(name) => {
-            format!("unused macro definition: `{}`", name).into()
-        }
-        BuiltinLintDiag::MacroRuleNeverUsed(n, name) => {
-            format!("{} rule of macro `{}` is never used", ordinalize(n + 1), name).into()
-        }
-        BuiltinLintDiag::UnstableFeature(msg) => msg.clone().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()
-        }
-        BuiltinLintDiag::MetaVariableWrongOperator => {
-            "meta-variable repeats with different Kleene operator".into()
-        }
-        BuiltinLintDiag::DuplicateMatcherBinding => "duplicate matcher binding".into(),
-        BuiltinLintDiag::UnknownMacroVariable(name) => {
-            format!("unknown macro variable `{name}`").into()
-        }
-        BuiltinLintDiag::UnusedExternCrate2 { extern_crate, local_crate } => format!(
-            "external crate `{}` unused in `{}`: remove the dependency or add `use {} as _;`",
-            extern_crate, local_crate, extern_crate
-        )
-        .into(),
-        BuiltinLintDiag::WasmCAbi => fluent::lint_wasm_c_abi,
-        BuiltinLintDiag::IllFormedAttributeInput { suggestions } => suggestions
-            .iter()
-            .enumerate()
-            .fold("attribute must be of the form ".to_string(), |mut acc, (i, sugg)| {
-                if i != 0 {
-                    write!(acc, " or ").unwrap();
-                }
-                write!(acc, "`{sugg}`").unwrap();
-                acc
-            })
-            .into(),
-        BuiltinLintDiag::InnerAttributeUnstable { is_macro } => {
-            if *is_macro {
-                fluent::lint_inner_macro_attribute_unstable
-            } else {
-                fluent::lint_custom_inner_attribute_unstable
-            }
-        }
-        BuiltinLintDiag::UnknownDiagnosticAttribute => fluent::lint_unknown_diagnostic_attribute,
+
+        BuiltinLintDiag::InvalidCrateTypeValue
+        | BuiltinLintDiag::MacroUseDeprecated
+        | BuiltinLintDiag::UnusedMacroUse
+        | BuiltinLintDiag::PrivateExternCrateReexport(_)
+        | BuiltinLintDiag::UnusedLabel
+        | BuiltinLintDiag::MacroIsPrivate(_)
+        | BuiltinLintDiag::UnusedMacroDefinition(_)
+        | BuiltinLintDiag::MacroRuleNeverUsed(_, _)
+        | BuiltinLintDiag::UnstableFeature(_)
+        | BuiltinLintDiag::AvoidUsingIntelSyntax
+        | BuiltinLintDiag::AvoidUsingAttSyntax
+        | BuiltinLintDiag::IncompleteInclude
+        | BuiltinLintDiag::UnnameableTestItems
+        | BuiltinLintDiag::DuplicateMacroAttribute
+        | BuiltinLintDiag::CfgAttrNoAttributes
+        | BuiltinLintDiag::CrateTypeInCfgAttr
+        | BuiltinLintDiag::CrateNameInCfgAttr
+        | BuiltinLintDiag::MissingFragmentSpecifier
+        | BuiltinLintDiag::MetaVariableStillRepeating(_)
+        | BuiltinLintDiag::MetaVariableWrongOperator
+        | BuiltinLintDiag::DuplicateMatcherBinding
+        | BuiltinLintDiag::UnknownMacroVariable(_)
+        | BuiltinLintDiag::UnusedCrateDependency { .. }
+        | BuiltinLintDiag::WasmCAbi
+        | BuiltinLintDiag::IllFormedAttributeInput { .. }
+        | BuiltinLintDiag::InnerAttributeUnstable { .. }
+        | BuiltinLintDiag::UnknownDiagnosticAttribute => unreachable!(),
     }
 }
 
@@ -578,49 +548,83 @@ pub(super) fn emit_buffered_lint<C: LintContext + ?Sized>(
         | BuiltinLintDiag::HiddenGlobReexports { .. }
         | BuiltinLintDiag::UnusedQualifications { .. }
         | BuiltinLintDiag::AssociatedConstElidedLifetime { .. }
-        | BuiltinLintDiag::RedundantImportVisibility { .. }
-        | BuiltinLintDiag::InvalidCrateTypeValue
-        | BuiltinLintDiag::MacroUseDeprecated
-        | BuiltinLintDiag::UnusedMacroUse
-        | BuiltinLintDiag::PrivateExternCrateReexport(_)
-        | BuiltinLintDiag::UnusedLabel
-        | BuiltinLintDiag::MacroIsPrivate(_)
-        | BuiltinLintDiag::UnusedMacroDefinition(_)
-        | BuiltinLintDiag::MacroRuleNeverUsed(_, _)
-        | BuiltinLintDiag::UnstableFeature(_)
-        | BuiltinLintDiag::AvoidUsingIntelSyntax
-        | BuiltinLintDiag::AvoidUsingAttSyntax
-        | BuiltinLintDiag::IncompleteInclude
-        | BuiltinLintDiag::UnnameableTestItems
-        | BuiltinLintDiag::DuplicateMacroAttribute
-        | BuiltinLintDiag::CfgAttrNoAttributes
-        | BuiltinLintDiag::CrateTypeInCfgAttr
-        | BuiltinLintDiag::CrateNameInCfgAttr
-        | BuiltinLintDiag::MissingFragmentSpecifier
-        | BuiltinLintDiag::MetaVariableStillRepeating(_)
-        | BuiltinLintDiag::MetaVariableWrongOperator
-        | BuiltinLintDiag::DuplicateMatcherBinding
-        | BuiltinLintDiag::UnknownMacroVariable(_)
-        | BuiltinLintDiag::UnusedExternCrate2 { .. }
-        | BuiltinLintDiag::WasmCAbi
-        | BuiltinLintDiag::IllFormedAttributeInput { .. }
-        | BuiltinLintDiag::InnerAttributeUnstable { .. }
-        | BuiltinLintDiag::UnknownDiagnosticAttribute => {
+        | BuiltinLintDiag::RedundantImportVisibility { .. } => {
             ctx.span_lint(lint, span, buffered_message(&diagnostic), |db| {
                 // Now, set up surrounding context.
                 buffered_decorate(ctx.sess(), diagnostic, db);
             })
         }
+        BuiltinLintDiag::InvalidCrateTypeValue => {
+            ctx.emit_span_lint(lint, span, InvalidCrateTypeValue)
+        }
+        BuiltinLintDiag::MacroUseDeprecated => ctx.emit_span_lint(lint, span, MacroUseDeprecated),
+        BuiltinLintDiag::UnusedMacroUse => ctx.emit_span_lint(lint, span, UnusedMacroUse),
+        BuiltinLintDiag::PrivateExternCrateReexport(ident) => {
+            ctx.emit_span_lint(lint, span, PrivateExternCrateReexport { ident })
+        }
+        BuiltinLintDiag::UnusedLabel => ctx.emit_span_lint(lint, span, UnusedLabel),
+        BuiltinLintDiag::MacroIsPrivate(ident) => {
+            ctx.emit_span_lint(lint, span, MacroIsPrivate { ident })
+        }
+        BuiltinLintDiag::UnusedMacroDefinition(name) => {
+            ctx.emit_span_lint(lint, span, UnusedMacroDefinition { name })
+        }
+        BuiltinLintDiag::MacroRuleNeverUsed(n, name) => {
+            ctx.emit_span_lint(lint, span, MacroRuleNeverUsed { n: n + 1, name })
+        }
+        BuiltinLintDiag::UnstableFeature(msg) => {
+            ctx.emit_span_lint(lint, span, UnstableFeature { msg })
+        }
+        BuiltinLintDiag::AvoidUsingIntelSyntax => ctx.emit_span_lint(lint, span, AvoidIntelSyntax),
+        BuiltinLintDiag::AvoidUsingAttSyntax => ctx.emit_span_lint(lint, span, AvoidAttSyntax),
+        BuiltinLintDiag::IncompleteInclude => ctx.emit_span_lint(lint, span, IncompleteInclude),
+        BuiltinLintDiag::UnnameableTestItems => ctx.emit_span_lint(lint, span, UnnameableTestItems),
+        BuiltinLintDiag::DuplicateMacroAttribute => {
+            ctx.emit_span_lint(lint, span, DuplicateMacroAttribute)
+        }
+        BuiltinLintDiag::CfgAttrNoAttributes => ctx.emit_span_lint(lint, span, CfgAttrNoAttributes),
+        BuiltinLintDiag::CrateTypeInCfgAttr => ctx.emit_span_lint(lint, span, CrateTypeInCfgAttr),
+        BuiltinLintDiag::CrateNameInCfgAttr => ctx.emit_span_lint(lint, span, CrateNameInCfgAttr),
+        BuiltinLintDiag::MissingFragmentSpecifier => {
+            ctx.emit_span_lint(lint, span, MissingFragmentSpecifier)
+        }
+        BuiltinLintDiag::MetaVariableStillRepeating(name) => {
+            ctx.emit_span_lint(lint, span, MetaVariableStillRepeating { name })
+        }
+        BuiltinLintDiag::MetaVariableWrongOperator => {
+            ctx.emit_span_lint(lint, span, MetaVariableWrongOperator)
+        }
+        BuiltinLintDiag::DuplicateMatcherBinding => {
+            ctx.emit_span_lint(lint, span, DuplicateMatcherBinding)
+        }
+        BuiltinLintDiag::UnknownMacroVariable(name) => {
+            ctx.emit_span_lint(lint, span, UnknownMacroVariable { name })
+        }
+        BuiltinLintDiag::UnusedCrateDependency { extern_crate, local_crate } => {
+            ctx.emit_span_lint(lint, span, UnusedCrateDependency { extern_crate, local_crate })
+        }
+        BuiltinLintDiag::WasmCAbi => ctx.emit_span_lint(lint, span, WasmCAbi),
+        BuiltinLintDiag::IllFormedAttributeInput { suggestions } => ctx.emit_span_lint(
+            lint,
+            span,
+            IllFormedAttributeInput {
+                num_suggestions: suggestions.len(),
+                suggestions: DiagArgValue::StrListSepByAnd(
+                    suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
+                ),
+            },
+        ),
+        BuiltinLintDiag::InnerAttributeUnstable { is_macro } => ctx.emit_span_lint(
+            lint,
+            span,
+            if is_macro {
+                InnerAttributeUnstable::InnerMacroAttribute
+            } else {
+                InnerAttributeUnstable::CustomInnerAttribute
+            },
+        ),
+        BuiltinLintDiag::UnknownDiagnosticAttribute => {
+            ctx.emit_span_lint(lint, span, UnknownDiagnosticAttribute)
+        }
     }
 }
-
-/// Convert the given number into the corresponding ordinal
-pub(crate) fn ordinalize(v: usize) -> String {
-    let suffix = match ((11..=13).contains(&(v % 100)), v % 10) {
-        (false, 1) => "st",
-        (false, 2) => "nd",
-        (false, 3) => "rd",
-        _ => "th",
-    };
-    format!("{v}{suffix}")
-}