migrate: rustc_lint::context

compiler/rustc_error_messages/locales/en-US/lint.ftl

@@ -414,3 +414,16 @@ lint_reason_must_come_last = reason in lint attribute must come last
 
 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
+
+lint_unsupported_group = `{$lint_group}` lint group is not supported with ´--force-warn´
+
+lint_requested_level = requested on the command line with `{$level} {$lint_name}`
+
+lint_check_name_unknown = unknown lint: `{$lint_name}`
+    .help = did you mean: `{$suggestion}`
+
+lint_check_name_unknown_tool = unknown lint tool: `{$tool_name}`
+
+lint_check_name_warning = {$msg}
+
+lint_check_name_deprecated = lint name `{$lint_name}` is deprecated and does not have an effect anymore. Use: {$new_name}

compiler/rustc_lint/src/context.rs

@@ -1,3 +1,6 @@
+// #![deny(rustc::diagnostic_outside_of_impl)]
+// #![deny(rustc::untranslatable_diagnostic)]
+//
 //! Implementation of lint checking.
 //!
 //! The lint checking is mostly consolidated into one pass which runs
@@ -16,12 +19,16 @@
 
 use self::TargetLint::*;
 
+use crate::errors::{
+    CheckNameDeprecated, CheckNameUnknown, CheckNameUnknownTool, CheckNameWarning, RequestedLevel,
+    UnsupportedGroup,
+};
 use crate::levels::LintLevelsBuilder;
 use crate::passes::{EarlyLintPassObject, LateLintPassObject};
 use rustc_ast::util::unicode::TEXT_FLOW_CONTROL_CHARS;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync;
-use rustc_errors::{add_elided_lifetime_in_path_suggestion, struct_span_err};
+use rustc_errors::add_elided_lifetime_in_path_suggestion;
 use rustc_errors::{
     Applicability, DecorateLint, LintDiagnosticBuilder, MultiSpan, SuggestionStyle,
 };
@@ -39,7 +46,7 @@ use rustc_session::lint::{FutureIncompatibleInfo, Level, Lint, LintBuffer, LintI
 use rustc_session::Session;
 use rustc_span::lev_distance::find_best_match_for_name;
 use rustc_span::symbol::{sym, Ident, Symbol};
-use rustc_span::{BytePos, Span, DUMMY_SP};
+use rustc_span::{BytePos, Span};
 use rustc_target::abi;
 use tracing::debug;
 
@@ -326,68 +333,41 @@ impl LintStore {
     ) {
         let (tool_name, lint_name_only) = parse_lint_and_tool_name(lint_name);
         if lint_name_only == crate::WARNINGS.name_lower() && matches!(level, Level::ForceWarn(_)) {
-            struct_span_err!(
+            sess.emit_err(UnsupportedGroup { lint_group: crate::WARNINGS.name_lower() });
-                sess,
-                DUMMY_SP,
-                E0602,
-                "`{}` lint group is not supported with ´--force-warn´",
-                crate::WARNINGS.name_lower()
-            )
-            .emit();
             return;
         }
-        let db = match self.check_lint_name(lint_name_only, tool_name, registered_tools) {
+        let lint_name = lint_name.to_string();
-            CheckLintNameResult::Ok(_) => None,
+        match self.check_lint_name(lint_name_only, tool_name, registered_tools) {
-            CheckLintNameResult::Warning(ref msg, _) => Some(sess.struct_warn(msg)),
+            CheckLintNameResult::Warning(msg, _) => {
-            CheckLintNameResult::NoLint(suggestion) => {
+                sess.emit_warning(CheckNameWarning {
-                let mut err =
+                    msg,
-                    struct_span_err!(sess, DUMMY_SP, E0602, "unknown lint: `{}`", lint_name);
+                    sub: RequestedLevel { level, lint_name },
-
+                });
-                if let Some(suggestion) = suggestion {
-                    err.help(&format!("did you mean: `{}`", suggestion));
-                }
-
-                Some(err.forget_guarantee())
             }
-            CheckLintNameResult::Tool(result) => match result {
+            CheckLintNameResult::NoLint(suggestion) => {
-                Err((Some(_), new_name)) => Some(sess.struct_warn(&format!(
+                sess.emit_err(CheckNameUnknown {
-                    "lint name `{}` is deprecated \
+                    lint_name: lint_name.clone(),
-                     and does not have an effect anymore. \
+                    suggestion,
-                     Use: {}",
+                    sub: RequestedLevel { level, lint_name },
-                    lint_name, new_name
+                });
-                ))),
+            }
-                _ => None,
+            CheckLintNameResult::Tool(result) => {
-            },
+                if let Err((Some(_), new_name)) = result {
-            CheckLintNameResult::NoTool => Some(
+                    sess.emit_warning(CheckNameDeprecated {
-                struct_span_err!(
+                        lint_name: lint_name.clone(),
-                    sess,
+                        new_name,
-                    DUMMY_SP,
+                        sub: RequestedLevel { level, lint_name },
-                    E0602,
+                    });
-                    "unknown lint tool: `{}`",
+                }
-                    tool_name.unwrap()
+            }
-                )
+            CheckLintNameResult::NoTool => {
-                .forget_guarantee(),
+                sess.emit_err(CheckNameUnknownTool {
-            ),
+                    tool_name: tool_name.unwrap(),
+                    sub: RequestedLevel { level, lint_name },
+                });
+            }
+            _ => {}
         };
-
-        if let Some(mut db) = db {
-            let msg = format!(
-                "requested on the command line with `{} {}`",
-                match level {
-                    Level::Allow => "-A",
-                    Level::Warn => "-W",
-                    Level::ForceWarn(_) => "--force-warn",
-                    Level::Deny => "-D",
-                    Level::Forbid => "-F",
-                    Level::Expect(_) => {
-                        unreachable!("lints with the level of `expect` should not run this code");
-                    }
-                },
-                lint_name
-            );
-            db.note(&msg);
-            db.emit();
-        }
     }
 
     /// True if this symbol represents a lint group name.

compiler/rustc_lint/src/errors.rs

@@ -1,5 +1,6 @@
-use rustc_errors::{fluent, AddSubdiagnostic};
+use rustc_errors::{fluent, AddSubdiagnostic, ErrorGuaranteed};
 use rustc_macros::{SessionDiagnostic, SessionSubdiagnostic};
+use rustc_session::{lint::Level, parse::ParseSess, SessionDiagnostic};
 use rustc_span::{Span, Symbol};
 
 #[derive(SessionDiagnostic)]
@@ -80,3 +81,82 @@ pub struct BuiltinEllpisisInclusiveRangePatterns {
     pub suggestion: Span,
     pub replace: String,
 }
+
+pub struct RequestedLevel {
+    pub level: Level,
+    pub lint_name: String,
+}
+
+impl AddSubdiagnostic for RequestedLevel {
+    fn add_to_diagnostic(self, diag: &mut rustc_errors::Diagnostic) {
+        diag.note(fluent::lint::requested_level);
+        diag.set_arg(
+            "level",
+            match self.level {
+                Level::Allow => "-A",
+                Level::Warn => "-W",
+                Level::ForceWarn(_) => "--force-warn",
+                Level::Deny => "-D",
+                Level::Forbid => "-F",
+                Level::Expect(_) => {
+                    unreachable!("lints with the level of `expect` should not run this code");
+                }
+            },
+        );
+        diag.set_arg("lint_name", self.lint_name);
+    }
+}
+
+#[derive(SessionDiagnostic)]
+#[error(lint::unsupported_group, code = "E0602")]
+pub struct UnsupportedGroup {
+    pub lint_group: String,
+}
+
+pub struct CheckNameUnknown {
+    pub lint_name: String,
+    pub suggestion: Option<Symbol>,
+    pub sub: RequestedLevel,
+}
+
+impl SessionDiagnostic<'_> for CheckNameUnknown {
+    fn into_diagnostic(
+        self,
+        sess: &ParseSess,
+    ) -> rustc_errors::DiagnosticBuilder<'_, ErrorGuaranteed> {
+        let mut diag = sess.struct_err(fluent::lint::check_name_unknown);
+        diag.code(rustc_errors::error_code!(E0602));
+        if let Some(suggestion) = self.suggestion {
+            diag.help(fluent::lint::help);
+            diag.set_arg("suggestion", suggestion);
+        }
+        diag.set_arg("lint_name", self.lint_name);
+        diag.subdiagnostic(self.sub);
+        diag
+    }
+}
+
+#[derive(SessionDiagnostic)]
+#[error(lint::check_name_unknown_tool, code = "E0602")]
+pub struct CheckNameUnknownTool {
+    pub tool_name: Symbol,
+    #[subdiagnostic]
+    pub sub: RequestedLevel,
+}
+
+#[derive(SessionDiagnostic)]
+#[warning(lint::check_name_warning)]
+pub struct CheckNameWarning {
+    pub msg: String,
+    #[subdiagnostic]
+    pub sub: RequestedLevel,
+}
+
+#[derive(SessionDiagnostic)]
+#[warning(lint::check_name_deprecated)]
+pub struct CheckNameDeprecated {
+    pub lint_name: String,
+    pub new_name: String,
+    #[subdiagnostic]
+    pub sub: RequestedLevel,
+}