make one single lint parser

Author: Bryntet

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -269,6 +269,10 @@ impl<S: Stage> AttributeParser<S> for NakedParser {
             sym::should_panic,
             sym::bench,
             // diagnostics
+            sym::allow,
+            sym::warn,
+            sym::deny,
+            sym::forbid,
             sym::deprecated,
             sym::must_use,
             // abi, linking and FFI

compiler/rustc_attr_parsing/src/attributes/lint.rs

@@ -1,3 +1,6 @@
+use std::marker::PhantomData;
+
+use rustc_ast::AttrStyle;
 use rustc_hir::HashIgnoredAttrId;
 use rustc_hir::attrs::{LintAttrIdsInformation, LintAttributeKind};
 use rustc_hir::lints::{AttributeLintKind, RenamedLintSuggestion};
@@ -9,7 +12,9 @@ use super::prelude::*;
 use crate::session_diagnostics::UnknownToolInScopedLint;
 use crate::target_checking::Policy;
 
-const ALLOWED_TARGETS: &'static [Policy] = &[
+const ALLOWED_TARGETS: &'static [Policy] = {
+    use super::prelude::{Allow, Warn};
+    &[
         Allow(Target::ExternCrate),
         Allow(Target::Use),
         Allow(Target::Static),
@@ -45,49 +50,62 @@ const ALLOWED_TARGETS: &'static [Policy] = &[
         Allow(Target::Param),
         Allow(Target::PatField),
         Allow(Target::ExprField),
-        Allow(Target::MacroCall),
         Allow(Target::Crate),
         Allow(Target::Delegation { mac: false }),
         Allow(Target::Delegation { mac: true }),
-    ]
+        Warn(Target::MacroCall),
+    ]}
 ;
 
+
+pub(crate) trait Lint {
+    fn lint_level<S: Stage>(cx: &FinalizeContext<'_, '_, S>,) -> LintAttributeKind;
+    const ATTR_SYMBOL: Symbol;
+}
+
 #[derive(Default)]
-pub(crate) struct AllowParser {
+pub(crate) struct LintParser<T: Lint> {
     lint_ids: ThinVec<LintAttrIdsInformation>,
     reason: Option<Symbol>,
     errored: bool,
     attr_span: Option<Span>,
+    attr_style: Option<AttrStyle>,
+    phantom: PhantomData<T>,
 }
 
-// Needs to be manually impl:ed as `AttributeParser`, because otherwise deduplication occurs
-impl<S: Stage> AttributeParser<S> for AllowParser {
+impl<S: Stage, T: Lint + 'static + Default> AttributeParser<S> for LintParser<T>  {
     const ATTRIBUTES: AcceptMapping<Self, S> = &[(
-        &[sym::allow],
+        &[T::ATTR_SYMBOL],
         template!(
             List: &["lint1", "lint1, lint2, ...", r#"lint1, lint2, lint3, reason = "...""#],
             "https://doc.rust-lang.org/reference/attributes/diagnostics.html#lint-check-attributes"
         ),
         |this, cx, args| {
+            *this = Self::default();
             this.attr_span = Some(cx.attr_span);
+            this.attr_style = Some(cx.attr_style);
             validate_lint_attr(
                 cx,
                 args,
                 &mut this.lint_ids,
                 &mut this.errored,
                 &mut this.reason,
-                sym::allow,
+                T::ATTR_SYMBOL,
             );
         },
     )];
 
-    fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
-        if !self.errored && !self.attr_span.is_none() {
+    fn finalize(self, cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
+        let (Some(attr_span), Some(attr_style)) = (self.attr_span, self.attr_style) else {
+            return None;
+        };
+        if !self.errored {
             Some(AttributeKind::LintAttribute {
                 lint_groups: self.lint_ids,
                 reason: self.reason,
-                kind: LintAttributeKind::Allow,
-                attr_span: self.attr_span.unwrap(),
+                kind: T::lint_level(cx),
+                attr_span,
+                attr_style,
             })
         } else {
             None
@@ -96,178 +114,63 @@ impl<S: Stage> AttributeParser<S> for AllowParser {
 
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALLOWED_TARGETS);
 }
-#[derive(Default)]
-pub(crate) struct DenyParser {
-    lint_ids: ThinVec<LintAttrIdsInformation>,
-    reason: Option<Symbol>,
-    errored: bool,
-    attr_span: Option<Span>,
 
-}
-impl<S: Stage> AttributeParser<S> for DenyParser {
-    const ATTRIBUTES: AcceptMapping<Self, S> = &[(
-        &[sym::deny],
-        template!(
-            List: &["lint1", "lint1, lint2, ...", r#"lint1, lint2, lint3, reason = "...""#],
-            "https://doc.rust-lang.org/reference/attributes/diagnostics.html#lint-check-attributes"
-        ),
-        |this, cx, args| {
-            this.attr_span = Some(cx.attr_span);
-            validate_lint_attr(
-                cx,
-                args,
-                &mut this.lint_ids,
-                &mut this.errored,
-                &mut this.reason,
-                sym::deny,
-            );
-        },
-    )];
+#[derive(Default)]
+pub(crate) struct Expect;
+pub(crate) type ExpectParser = LintParser<Expect>;
 
-    fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
-        if !self.errored && !self.attr_span.is_none() {
-            Some(AttributeKind::LintAttribute {
-                lint_groups: self.lint_ids,
-                reason: self.reason,
-                kind: LintAttributeKind::Deny,attr_span: self.attr_span.unwrap(),
-            })
-        } else {
-            None
-        }
+impl Lint for Expect {
+    fn lint_level<S:Stage>(cx: &FinalizeContext<'_, '_, S>) -> LintAttributeKind {
+        LintAttributeKind::Expect(HashIgnoredAttrId { attr_id:cx.attr_id })
     }
-
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALLOWED_TARGETS);
-}
+    const ATTR_SYMBOL: Symbol = sym::expect;
+} 
 
 #[derive(Default)]
-pub(crate) struct ForbidParser {
-    lint_ids: ThinVec<LintAttrIdsInformation>,
-    reason: Option<Symbol>,
-    errored: bool,
-    attr_span: Option<Span>,
+pub(crate) struct Allow;
+pub(crate) type AllowParser = LintParser<Allow>;
 
-}
-impl<S: Stage> AttributeParser<S> for ForbidParser {
-    const ATTRIBUTES: AcceptMapping<Self, S> = &[(
-        &[sym::forbid],
-        template!(
-            List: &["lint1", "lint1, lint2, ...", r#"lint1, lint2, lint3, reason = "...""#],
-            "https://doc.rust-lang.org/reference/attributes/diagnostics.html#lint-check-attributes"
-        ),
-        |this, cx, args| {
-            this.attr_span = Some(cx.attr_span);
-            validate_lint_attr(
-                cx,
-                args,
-                &mut this.lint_ids,
-                &mut this.errored,
-                &mut this.reason,
-                sym::forbid,
-            );
-        },
-    )];
-
-    fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
-        if !self.errored {
-            Some(AttributeKind::LintAttribute {
-                lint_groups: self.lint_ids,
-                reason: self.reason,
-                kind: LintAttributeKind::Forbid,attr_span: self.attr_span.unwrap(),
-            })
-        } else {
-            None
-        }
+impl Lint for Allow {
+    fn lint_level<S:Stage>(_cx: &FinalizeContext<'_, '_, S>) -> LintAttributeKind {
+        LintAttributeKind::Allow
     }
+    const ATTR_SYMBOL: Symbol = sym::allow;
+} 
+#[derive(Default)]
+pub(crate) struct Warn;
+pub(crate) type WarnParser = LintParser<Warn>;
 
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALLOWED_TARGETS);
-}
+impl Lint for Warn {
+    fn lint_level<S:Stage>(_cx: &FinalizeContext<'_, '_, S>) -> LintAttributeKind {
+        LintAttributeKind::Warn
+    }
+    const ATTR_SYMBOL: Symbol = sym::warn;
+} 
 
 #[derive(Default)]
-pub(crate) struct WarnParser {
-    lint_ids: ThinVec<LintAttrIdsInformation>,
-    reason: Option<Symbol>,
-    errored: bool,
-    attr_span: Option<Span>,
-
-}
-impl<S: Stage> AttributeParser<S> for WarnParser {
-    const ATTRIBUTES: AcceptMapping<Self, S> = &[(
-        &[sym::warn],
-        template!(
-            List: &["lint1", "lint1, lint2, ...", r#"lint1, lint2, lint3, reason = "...""#],
-            "https://doc.rust-lang.org/reference/attributes/diagnostics.html#lint-check-attributes"
-        ),
-        |this, cx, args| {
-            this.attr_span = Some(cx.attr_span);
-            validate_lint_attr(
-                cx,
-                args,
-                &mut this.lint_ids,
-                &mut this.errored,
-                &mut this.reason,
-                sym::warn,
-            );
-        },
-    )];
+pub(crate) struct Deny;
+pub(crate) type DenyParser = LintParser<Deny>;
 
-    fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
-        if !self.errored && !self.attr_span.is_none() {
-            Some(AttributeKind::LintAttribute {
-                lint_groups: self.lint_ids,
-                reason: self.reason,
-                kind: LintAttributeKind::Warn,attr_span: self.attr_span.unwrap(),
-            })
-        } else {
-            None
-        }
+impl Lint for Deny {
+    fn lint_level<S:Stage>(_cx: &FinalizeContext<'_, '_, S>) -> LintAttributeKind {
+        LintAttributeKind::Deny
     }
-
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALLOWED_TARGETS);
-}
+    const ATTR_SYMBOL: Symbol = sym::deny;
+} 
 
 #[derive(Default)]
-pub(crate) struct ExpectParser {
-    lint_ids: ThinVec<LintAttrIdsInformation>,
-    reason: Option<Symbol>,
-    errored: bool,
-    attr_span: Option<Span>,
+pub(crate) struct Forbid;
+pub(crate) type ForbidParser = LintParser<Forbid>;
 
-}
-impl<S: Stage> AttributeParser<S> for ExpectParser {
-    const ATTRIBUTES: AcceptMapping<Self, S> = &[(
-        &[sym::expect],
-        template!(
-            List: &["lint1", "lint1, lint2, ...", r#"lint1, lint2, lint3, reason = "...""#],
-            "https://doc.rust-lang.org/reference/attributes/diagnostics.html#lint-check-attributes"
-        ),
-        |this, cx, args| {
-            this.attr_span = Some(cx.attr_span);
-            validate_lint_attr(
-                cx,
-                args,
-                &mut this.lint_ids,
-                &mut this.errored,
-                &mut this.reason,
-                sym::expect,
-            );
-        },
-    )];
-
-    fn finalize(self, cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
-        if !self.errored && !self.attr_span.is_none() {
-            Some(AttributeKind::LintAttribute {
-                lint_groups: self.lint_ids,
-                reason: self.reason,
-                kind: LintAttributeKind::Expect(HashIgnoredAttrId { attr_id:cx.attr_id}),
-                attr_span: self.attr_span.unwrap(),
-            })
-        } else {
-            None
-        }
+impl Lint for Forbid {
+    fn lint_level<S:Stage>(_cx: &FinalizeContext<'_, '_, S>) -> LintAttributeKind {
+        LintAttributeKind::Forbid
     }
+    const ATTR_SYMBOL: Symbol = sym::forbid;
+} 
+
+
 
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALLOWED_TARGETS);
-}
 
 #[inline(always)]
 fn validate_lint_attr<S: Stage>(
@@ -278,18 +181,18 @@ fn validate_lint_attr<S: Stage>(
     reason: &mut Option<Symbol>,
     attr_name: Symbol,
 ) {
-    let Some(list) = args.list().map(MetaItemListParser::mixed) else {
+    
+    let Some(list) = args.list() else {
         cx.expected_list(cx.inner_span, args);
         return;
     };
-    let mut list = list.peekable();
+    let mut list = list.mixed().peekable();
 
-    let mut skip_empty_check = false;
     let mut lint_index = 0;
-
+    let mut skip_reason_check = false;
     while let Some(item) = list.next() {
         let Some(meta_item) = item.meta_item() else {
-            cx.expected_string_literal(item.span(), item.lit());
+            cx.expected_identifier(item.span());
             *errored = true;
             continue;
         };
@@ -343,14 +246,12 @@ fn validate_lint_attr<S: Stage>(
             {
                 lint_ids.extend(ids);
             } else {
-                // Since external tool lints aren't directly checked by rustc, we don't store these ids
-                // inside the parsed attr, but this still means that something *does* exist in it, so we shouldn't warn
-                skip_empty_check = true;
+                skip_reason_check = true
             }
             lint_index += 1;
         }
     }
-    if !skip_empty_check && !*errored && lint_ids.is_empty() {
+    if !skip_reason_check && lint_ids.is_empty() {
         cx.warn_empty_attribute(cx.attr_span);
     }
 }

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -994,6 +994,7 @@ pub enum AttributeKind {
         kind: LintAttributeKind,
         lint_groups: ThinVec<LintAttrIdsInformation>,
         attr_span: Span,
+        attr_style: AttrStyle
     },
     /// Represents `#[loop_match]`.
     LoopMatch(Span),

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -55,7 +55,7 @@ impl AttributeKind {
             LinkOrdinal { .. } => No,
             LinkSection { .. } => Yes, // Needed for rustdoc
             Linkage(..) => No,
-            LintAttribute { .. } => Yes,
+            LintAttribute { .. } => No,
             LoopMatch(..) => No,
             MacroEscape(..) => No,
             MacroExport { .. } => Yes,