Move remaining early buffered lints for rustc_ast_passes to dyn lint diagnostics

Author: fmease

compiler/rustc_ast_passes/messages.ftl

@@ -107,6 +107,9 @@ ast_passes_coroutine_and_c_variadic = functions cannot be both `{$coroutine_kind
     .const = `{$coroutine_kind}` because of this
     .variadic = C-variadic because of this
 
+ast_passes_deprecated_where_clause_location = where clause not allowed here
+    .note = see issue #89122 <https://github.com/rust-lang/rust/issues/89122> for more information
+
 ast_passes_equality_in_where = equality constraints are not yet supported in `where` clauses
     .label = not supported
     .suggestion = if `{$ident}` is an associated type you're trying to set, use the associated type binding syntax
@@ -237,6 +240,8 @@ ast_passes_missing_unsafe_on_extern_lint = extern blocks should be unsafe
 ast_passes_module_nonascii = trying to load file for module `{$name}` with non-ascii identifier name
     .help = consider using the `#[path]` attribute to specify filesystem path
 
+ast_passes_move_leading_ty_alias_where_clause = move it to the end of the type declaration
+
 ast_passes_negative_bound_not_supported =
     negative bounds are not supported
 
@@ -259,6 +264,7 @@ ast_passes_out_of_order_params = {$param_ord} parameters must be declared prior
 
 ast_passes_pattern_in_bodiless = patterns aren't allowed in functions without bodies
     .label = pattern not allowed in function without body
+    .remove_mut_sugg = remove `mut` from the parameter
 
 ast_passes_pattern_in_fn_pointer = patterns aren't allowed in function pointer types
 
@@ -270,6 +276,8 @@ ast_passes_precise_capturing_duplicated = duplicate `use<...>` precise capturing
 
 ast_passes_precise_capturing_not_allowed_here = `use<...>` precise capturing syntax not allowed in {$loc}
 
+ast_passes_remove_leading_ty_alias_where_clause = remove this `where`
+
 ast_passes_static_without_body =
     free static item without body
     .suggestion = provide a definition for the static
@@ -322,6 +330,10 @@ ast_passes_unsafe_negative_impl = negative impls cannot be unsafe
 ast_passes_unsafe_static =
     static items cannot be declared with `unsafe` safety qualifier outside of `extern` block
 
+ast_passes_unused_visibilities = visibility qualifiers have no effect on `const _` declarations
+    .note = `const _` does not declare a name, so there is nothing for the qualifier to apply to
+    .suggestion = remove the qualifier
+
 ast_passes_visibility_not_permitted =
     visibility qualifiers are not permitted here
     .enum_variant = enum variants and their fields always share the visibility of the enum they are in
@@ -336,5 +348,3 @@ ast_passes_where_clause_after_type_alias = where clauses are not allowed after t
 
 ast_passes_where_clause_before_type_alias = where clauses are not allowed before the type for type aliases
     .note = see issue #89122 <https://github.com/rust-lang/rust/issues/89122> for more information
-    .remove_suggestion = remove this `where`
-    .move_suggestion = move it to the end of the type declaration

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -30,7 +30,6 @@ use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::{DiagCtxtHandle, LintBuffer};
 use rustc_feature::Features;
 use rustc_session::Session;
-use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{
     DEPRECATED_WHERE_CLAUSE_LOCATION, MISSING_ABI, MISSING_UNSAFE_ON_EXTERN,
     PATTERNS_IN_FNS_WITHOUT_BODY, UNUSED_VISIBILITIES,
@@ -166,13 +165,13 @@ impl<'a> AstValidator<'a> {
                 state.print_where_predicate(p);
             }
 
-            errors::WhereClauseBeforeTypeAliasSugg::Move {
+            errors::ModifyLeadingTyAliasWhereClause::Move {
                 left: span,
                 snippet: state.s.eof(),
                 right: ty_alias.after_where_clause.span.shrink_to_hi(),
             }
         } else {
-            errors::WhereClauseBeforeTypeAliasSugg::Remove { span }
+            errors::ModifyLeadingTyAliasWhereClause::Remove { span }
         };
 
         Err(errors::WhereClauseBeforeTypeAlias { span, sugg })
@@ -230,14 +229,12 @@ impl<'a> AstValidator<'a> {
         });
     }
 
-    fn check_decl_no_pat(decl: &FnDecl, mut report_err: impl FnMut(Span, Option<Ident>, bool)) {
+    fn check_decl_no_pat(decl: &FnDecl, mut report_err: impl FnMut(Span, Option<Ident>)) {
         for Param { pat, .. } in &decl.inputs {
             match pat.kind {
                 PatKind::Missing | PatKind::Ident(BindingMode::NONE, _, None) | PatKind::Wild => {}
-                PatKind::Ident(BindingMode::MUT, ident, None) => {
-                    report_err(pat.span, Some(ident), true)
-                }
-                _ => report_err(pat.span, None, false),
+                PatKind::Ident(BindingMode::MUT, ident, None) => report_err(pat.span, Some(ident)),
+                _ => report_err(pat.span, None),
             }
         }
     }
@@ -929,7 +926,7 @@ impl<'a> AstValidator<'a> {
             TyKind::FnPtr(bfty) => {
                 self.check_fn_ptr_safety(bfty.decl_span, bfty.safety);
                 self.check_fn_decl(&bfty.decl, SelfSemantic::No);
-                Self::check_decl_no_pat(&bfty.decl, |span, _, _| {
+                Self::check_decl_no_pat(&bfty.decl, |span, _| {
                     self.dcx().emit_err(errors::PatternFnPointer { span });
                 });
                 if let Extern::Implicit(extern_span) = bfty.ext {
@@ -1355,7 +1352,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                         UNUSED_VISIBILITIES,
                         item.id,
                         item.vis.span,
-                        BuiltinLintDiag::UnusedVisibility(item.vis.span),
+                        errors::UnusedVisibility { span: item.vis.span },
                     )
                 }
 
@@ -1641,25 +1638,20 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
 
         // Functions without bodies cannot have patterns.
         if let FnKind::Fn(ctxt, _, Fn { body: None, sig, .. }) = fk {
-            Self::check_decl_no_pat(&sig.decl, |span, ident, mut_ident| {
-                if mut_ident && matches!(ctxt, FnCtxt::Assoc(_)) {
-                    if let Some(ident) = ident {
-                        self.lint_buffer.buffer_lint(
-                            PATTERNS_IN_FNS_WITHOUT_BODY,
-                            id,
-                            span,
-                            BuiltinLintDiag::PatternsInFnsWithoutBody {
-                                span,
-                                ident,
-                                is_foreign: matches!(ctxt, FnCtxt::Foreign),
-                            },
-                        )
-                    }
-                } else {
-                    match ctxt {
-                        FnCtxt::Foreign => self.dcx().emit_err(errors::PatternInForeign { span }),
-                        _ => self.dcx().emit_err(errors::PatternInBodiless { span }),
-                    };
+            Self::check_decl_no_pat(&sig.decl, |span, mut_ident| match ctxt {
+                FnCtxt::Assoc(_) if let Some(mut_ident) = mut_ident => {
+                    self.lint_buffer.buffer_lint(
+                        PATTERNS_IN_FNS_WITHOUT_BODY,
+                        id,
+                        span,
+                        errors::PatternInBodilessLint { removal: span.until(mut_ident.span) },
+                    );
+                }
+                FnCtxt::Foreign => {
+                    self.dcx().emit_err(errors::PatternInForeign { span });
+                }
+                _ => {
+                    self.dcx().emit_err(errors::PatternInBodiless { span });
                 }
             });
         }
@@ -1723,17 +1715,11 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
         if let AssocItemKind::Type(ty_alias) = &item.kind
             && let Err(err) = self.check_type_alias_where_clause_location(ty_alias)
         {
-            let sugg = match err.sugg {
-                errors::WhereClauseBeforeTypeAliasSugg::Remove { .. } => None,
-                errors::WhereClauseBeforeTypeAliasSugg::Move { snippet, right, .. } => {
-                    Some((right, snippet))
-                }
-            };
             self.lint_buffer.buffer_lint(
                 DEPRECATED_WHERE_CLAUSE_LOCATION,
                 item.id,
                 err.span,
-                BuiltinLintDiag::DeprecatedWhereclauseLocation(err.span, sugg),
+                errors::DeprecatedWhereClauseLocation { sugg: err.sugg },
             );
         }
 

compiler/rustc_ast_passes/src/errors.rs

@@ -575,18 +575,30 @@ pub(crate) struct WhereClauseBeforeTypeAlias {
     #[primary_span]
     pub span: Span,
     #[subdiagnostic]
-    pub sugg: WhereClauseBeforeTypeAliasSugg,
+    pub sugg: ModifyLeadingTyAliasWhereClause,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(ast_passes_deprecated_where_clause_location)]
+#[note]
+pub(crate) struct DeprecatedWhereClauseLocation {
+    #[subdiagnostic]
+    pub sugg: ModifyLeadingTyAliasWhereClause,
 }
 
 #[derive(Subdiagnostic)]
-pub(crate) enum WhereClauseBeforeTypeAliasSugg {
-    #[suggestion(ast_passes_remove_suggestion, applicability = "machine-applicable", code = "")]
+pub(crate) enum ModifyLeadingTyAliasWhereClause {
+    #[suggestion(
+        ast_passes_remove_leading_ty_alias_where_clause,
+        applicability = "machine-applicable",
+        code = ""
+    )]
     Remove {
         #[primary_span]
         span: Span,
     },
     #[multipart_suggestion(
-        ast_passes_move_suggestion,
+        ast_passes_move_leading_ty_alias_where_clause,
         applicability = "machine-applicable",
         style = "verbose"
     )]
@@ -743,7 +755,6 @@ pub(crate) struct CVariadicNotSupported<'a> {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_pattern_in_foreign, code = E0130)]
-// FIXME: deduplicate with rustc_lint (`BuiltinLintDiag::PatternsInFnsWithoutBody`)
 pub(crate) struct PatternInForeign {
     #[primary_span]
     #[label]
@@ -752,13 +763,19 @@ pub(crate) struct PatternInForeign {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_pattern_in_bodiless, code = E0642)]
-// FIXME: deduplicate with rustc_lint (`BuiltinLintDiag::PatternsInFnsWithoutBody`)
 pub(crate) struct PatternInBodiless {
     #[primary_span]
     #[label]
     pub span: Span,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(ast_passes_pattern_in_bodiless)]
+pub(crate) struct PatternInBodilessLint {
+    #[suggestion(ast_passes_remove_mut_sugg, code = "", applicability = "machine-applicable")]
+    pub removal: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(ast_passes_equality_in_where)]
 #[note]
@@ -990,3 +1007,11 @@ pub(crate) struct AbiX86Interrupt {
     pub spans: Vec<Span>,
     pub param_count: usize,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(ast_passes_unused_visibilities)]
+#[note]
+pub(crate) struct UnusedVisibility {
+    #[suggestion(style = "short", code = "", applicability = "machine-applicable")]
+    pub span: Span,
+}

compiler/rustc_lint/messages.ftl

@@ -222,11 +222,6 @@ lint_deprecated_lint_name =
     .suggestion = change it to
     .help = change it to {$replace}
 
-lint_deprecated_where_clause_location = where clause not allowed here
-    .note = see issue #89122 <https://github.com/rust-lang/rust/issues/89122> for more information
-    .suggestion_move_to_end = move it to the end of the type declaration
-    .suggestion_remove_where = remove this `where`
-
 lint_diag_out_of_impl =
     diagnostics should only be created in `Diagnostic`/`Subdiagnostic`/`LintDiagnostic` impls
 
@@ -746,12 +741,6 @@ lint_path_statement_drop = path statement drops value
 
 lint_path_statement_no_effect = path statement with no effect
 
-lint_pattern_in_bodiless = patterns aren't allowed in functions without bodies
-    .label = pattern not allowed in function without body
-
-lint_pattern_in_foreign = patterns aren't allowed in foreign function declarations
-    .label = pattern not allowed in foreign function
-
 lint_query_instability = using `{$query}` can result in unstable query results
     .note = if you believe this case to be fine, allow this lint and add a comment explaining your rationale
 
@@ -783,8 +772,6 @@ lint_redundant_semicolons_suggestion = remove {$multiple_semicolons ->
         *[false] this semicolon
     }
 
-lint_remove_mut_from_pattern = remove `mut` from the parameter
-
 lint_removed_lint = lint `{$name}` has been removed: {$reason}
 
 lint_renamed_lint = lint `{$name}` has been renamed to `{$replace}`
@@ -1004,10 +991,6 @@ lint_unused_op = unused {$op} that must be used
 
 lint_unused_result = unused result of type `{$ty}`
 
-lint_unused_visibilities = visibility qualifiers have no effect on `const _` declarations
-    .note = `const _` does not declare a name, so there is nothing for the qualifier to apply to
-    .suggestion = remove the qualifier
-
 lint_use_let_underscore_ignore_suggestion = use `let _ = ...` to ignore the expression or result
 
 lint_useless_ptr_null_checks_fn_ptr = function pointers are not nullable, so checking them for null will always return false

compiler/rustc_lint/src/early/diagnostics.rs

@@ -104,26 +104,6 @@ pub fn decorate_builtin_lint(
             stability::Deprecated { sub, kind: "macro".to_owned(), path, note, since_kind }
                 .decorate_lint(diag);
         }
-        BuiltinLintDiag::PatternsInFnsWithoutBody { span: remove_span, ident, is_foreign } => {
-            let sub = lints::PatternsInFnsWithoutBodySub { ident, span: remove_span };
-            if is_foreign {
-                lints::PatternsInFnsWithoutBody::Foreign { sub }
-            } else {
-                lints::PatternsInFnsWithoutBody::Bodiless { sub }
-            }
-            .decorate_lint(diag);
-        }
-        BuiltinLintDiag::DeprecatedWhereclauseLocation(left_sp, sugg) => {
-            let suggestion = match sugg {
-                Some((right_sp, sugg)) => lints::DeprecatedWhereClauseLocationSugg::MoveToEnd {
-                    left: left_sp,
-                    right: right_sp,
-                    sugg,
-                },
-                None => lints::DeprecatedWhereClauseLocationSugg::RemoveWhere { span: left_sp },
-            };
-            lints::DeprecatedWhereClauseLocation { suggestion }.decorate_lint(diag);
-        }
         BuiltinLintDiag::SingleUseLifetime {
             param_span,
             use_span: Some((use_span, elide)),
@@ -240,9 +220,6 @@ pub fn decorate_builtin_lint(
         BuiltinLintDiag::UnusedCrateDependency { extern_crate, local_crate } => {
             lints::UnusedCrateDependency { extern_crate, local_crate }.decorate_lint(diag)
         }
-        BuiltinLintDiag::UnusedVisibility(span) => {
-            lints::UnusedVisibility { span }.decorate_lint(diag)
-        }
         BuiltinLintDiag::AttributeLint(kind) => decorate_attribute_lint(sess, tcx, &kind, diag),
     }
 }