llint attr stuff

Author: Bryntet

compiler/rustc_attr_parsing/src/attributes/lint.rs

@@ -1,8 +1,7 @@
 use std::marker::PhantomData;
 
-use rustc_ast::AttrStyle;
 use rustc_hir::HashIgnoredAttrId;
-use rustc_hir::attrs::{LintAttrIdsInformation, LintAttributeKind};
+use rustc_hir::attrs::{LintAttrIdsInformation, LintAttrInfo, LintAttributeKind};
 use rustc_hir::lints::{AttributeLintKind, RenamedLintSuggestion};
 use rustc_middle::bug;
 use rustc_session::lint::CheckLintNameResult;
@@ -54,59 +53,38 @@ const ALLOWED_TARGETS: &'static [Policy] = {
         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 KIND: LintAttributeKind;
     const ATTR_SYMBOL: Symbol;
 }
 
 #[derive(Default)]
 pub(crate) struct LintParser<T: Lint> {
-    lint_ids: ThinVec<LintAttrIdsInformation>,
-    reason: Option<Symbol>,
-    errored: bool,
-    attr_span: Option<Span>,
-    attr_style: Option<AttrStyle>,
+    lint_attrs: ThinVec<LintAttrInfo>,
+    lint_index: usize,
     phantom: PhantomData<T>,
 }
 
-impl<S: Stage, T: Lint + 'static + Default> AttributeParser<S> for LintParser<T>  {
+impl<S: Stage, T: Lint + 'static + Default> AttributeParser<S> for LintParser<T> {
     const ATTRIBUTES: AcceptMapping<Self, S> = &[(
         &[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,
-                T::ATTR_SYMBOL,
-            );
+            if let Some(lint_attr) = validate_lint_attr(cx, args, T::ATTR_SYMBOL, &mut this.lint_index) {
+                this.lint_attrs.push(lint_attr);
+            }
         },
     )];
 
-    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: T::lint_level(cx),
-                attr_span,
-                attr_style,
-            })
+    fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
+        if !self.lint_attrs.is_empty() {
+            Some(AttributeKind::LintAttribute { sub_attrs: self.lint_attrs, kind: T::KIND })
         } else {
             None
         }
@@ -120,105 +98,95 @@ pub(crate) struct Expect;
 pub(crate) type ExpectParser = LintParser<Expect>;
 
 impl Lint for Expect {
-    fn lint_level<S:Stage>(cx: &FinalizeContext<'_, '_, S>) -> LintAttributeKind {
-        LintAttributeKind::Expect(HashIgnoredAttrId { attr_id:cx.attr_id })
-    }
+    const KIND: LintAttributeKind = LintAttributeKind::Expect;
     const ATTR_SYMBOL: Symbol = sym::expect;
-} 
+}
 
 #[derive(Default)]
 pub(crate) struct Allow;
 pub(crate) type AllowParser = LintParser<Allow>;
 
 impl Lint for Allow {
-    fn lint_level<S:Stage>(_cx: &FinalizeContext<'_, '_, S>) -> LintAttributeKind {
-        LintAttributeKind::Allow
-    }
+    const KIND: LintAttributeKind = LintAttributeKind::Allow;
     const ATTR_SYMBOL: Symbol = sym::allow;
-} 
+}
 #[derive(Default)]
 pub(crate) struct Warn;
 pub(crate) type WarnParser = LintParser<Warn>;
 
 impl Lint for Warn {
-    fn lint_level<S:Stage>(_cx: &FinalizeContext<'_, '_, S>) -> LintAttributeKind {
-        LintAttributeKind::Warn
-    }
+    const KIND: LintAttributeKind = LintAttributeKind::Warn;
+
     const ATTR_SYMBOL: Symbol = sym::warn;
-} 
+}
 
 #[derive(Default)]
 pub(crate) struct Deny;
 pub(crate) type DenyParser = LintParser<Deny>;
 
 impl Lint for Deny {
-    fn lint_level<S:Stage>(_cx: &FinalizeContext<'_, '_, S>) -> LintAttributeKind {
-        LintAttributeKind::Deny
-    }
+    const KIND: LintAttributeKind = LintAttributeKind::Deny;
+
     const ATTR_SYMBOL: Symbol = sym::deny;
-} 
+}
 
 #[derive(Default)]
 pub(crate) struct Forbid;
 pub(crate) type ForbidParser = LintParser<Forbid>;
 
 impl Lint for Forbid {
-    fn lint_level<S:Stage>(_cx: &FinalizeContext<'_, '_, S>) -> LintAttributeKind {
-        LintAttributeKind::Forbid
-    }
-    const ATTR_SYMBOL: Symbol = sym::forbid;
-} 
-
-
+    const KIND: LintAttributeKind = LintAttributeKind::Forbid;
 
+    const ATTR_SYMBOL: Symbol = sym::forbid;
+}
 
 #[inline(always)]
 fn validate_lint_attr<S: Stage>(
     cx: &mut AcceptContext<'_, '_, S>,
     args: &ArgParser,
-    lint_ids: &mut ThinVec<LintAttrIdsInformation>,
-    errored: &mut bool,
-    reason: &mut Option<Symbol>,
     attr_name: Symbol,
-) {
-    
+    lint_index: &mut usize
+) -> Option<LintAttrInfo> {
     let Some(list) = args.list() else {
         cx.expected_list(cx.inner_span, args);
-        return;
+        return None;
     };
     let mut list = list.mixed().peekable();
 
-    let mut lint_index = 0;
     let mut skip_reason_check = false;
+    let mut errored = false;
+    let mut reason = None;
+    let mut lint_ids = ThinVec::new();
+
     while let Some(item) = list.next() {
         let Some(meta_item) = item.meta_item() else {
             cx.expected_identifier(item.span());
-            *errored = true;
+            errored = true;
             continue;
         };
 
         if let Some(args) = meta_item.word_is(sym::reason) {
             if reason.is_some() {
                 // TODO check if this check is already present
                 cx.duplicate_key(meta_item.span(), sym::reason);
-                *errored = true;
+                errored = true;
             }
             let ArgParser::NameValue(nv) = args else {
                 cx.expected_name_value(meta_item.span(), Some(sym::reason));
-                *errored = true;
+                errored = true;
                 continue;
             };
             if list.peek().is_some() {
                 cx.expected_nv_as_last_argument(nv.args_span(), attr_name, sym::reason);
-                *errored = true;
+                errored = true;
                 continue;
             }
             let Some(s) = nv.value_as_str() else {
                 cx.expected_string_literal(nv.value_span, Some(nv.value_as_lit()));
-                *errored = true;
+                errored = true;
                 continue;
             };
-            *reason = Some(s);
+            reason = Some(s);
         } else {
             let mut segments = meta_item.path().segments();
 
@@ -241,19 +209,33 @@ fn validate_lint_attr<S: Stage>(
                 &tool_name.map(|tool| format!("{tool}::{}", &name)).unwrap_or(name.clone()),
             );
 
-            if let Some(ids) =
-                check_lint(cx, original_name, &name, tool_name, tool_span, meta_item.span(),lint_index )
-            {
+            if let Some(ids) = check_lint(
+                cx,
+                original_name,
+                &name,
+                tool_name,
+                tool_span,
+                meta_item.span(),
+                *lint_index,
+            ) {
                 lint_ids.extend(ids);
             } else {
                 skip_reason_check = true
             }
-            lint_index += 1;
+            *lint_index += 1;
         }
     }
     if !skip_reason_check && lint_ids.is_empty() {
         cx.warn_empty_attribute(cx.attr_span);
     }
+
+    (!errored).then_some(LintAttrInfo {
+        reason,
+        lint_groups: lint_ids,
+        attr_span: cx.attr_span,
+        attr_style: cx.attr_style,
+        attr_id: HashIgnoredAttrId { attr_id: cx.attr_id },
+    })
 }
 
 fn check_lint<S: Stage>(
@@ -263,7 +245,7 @@ fn check_lint<S: Stage>(
     tool_name: Option<Symbol>,
     tool_span: Option<Span>,
     span: Span,
-    lint_index: usize
+    lint_index: usize,
 ) -> Option<Vec<LintAttrIdsInformation>> {
     let Some(lint_store) = &cx.sess.lint_store else {
         bug!("lint_store required while parsing attributes");
@@ -304,7 +286,7 @@ fn check_lint<S: Stage>(
                     original_name,
                     span,
                     tool_name,
-                    lint_index
+                    lint_index,
                 });
             }
         }
@@ -351,7 +333,13 @@ fn check_lint<S: Stage>(
 
             for id in ids {
                 let name = Symbol::intern(&id.to_string());
-                lint_ids.push(LintAttrIdsInformation { name, original_name, span, tool_name, lint_index});
+                lint_ids.push(LintAttrIdsInformation {
+                    name,
+                    original_name,
+                    span,
+                    tool_name,
+                    lint_index,
+                });
             }
         }
 

compiler/rustc_attr_parsing/src/context.rs

@@ -422,6 +422,8 @@ pub struct AcceptContext<'f, 'sess, S: Stage> {
 
     /// The name of the attribute we're currently accepting.
     pub(crate) attr_path: AttrPath,
+
+    pub(crate) attr_id: AttrId,
 }
 
 impl<'f, 'sess: 'f, S: Stage> SharedContext<'f, 'sess, S> {
@@ -738,8 +740,6 @@ pub(crate) struct FinalizeContext<'p, 'sess, S: Stage> {
     /// Usually, you should use normal attribute parsing logic instead,
     /// especially when making a *denylist* of other attributes.
     pub(crate) all_attrs: &'p [RefPathParser<'p>],
-
-    pub(crate) attr_id: AttrId,
 }
 
 impl<'p, 'sess: 'p, S: Stage> Deref for FinalizeContext<'p, 'sess, S> {

compiler/rustc_attr_parsing/src/interface.rs

@@ -216,6 +216,7 @@ impl<'sess> AttributeParser<'sess, Early> {
         if let Some(safety) = attr_safety {
             parser.check_attribute_safety(&attr_path, inner_span, safety, &mut emit_lint)
         }
+        let attr_id = sess.psess.attr_id_generator.mk_attr_id();
         let mut cx: AcceptContext<'_, 'sess, Early> = AcceptContext {
             shared: SharedContext {
                 cx: &mut parser,
@@ -229,6 +230,7 @@ impl<'sess> AttributeParser<'sess, Early> {
             parsed_description,
             template,
             attr_path,
+            attr_id,
         };
         parse_fn(&mut cx, args)
     }
@@ -388,9 +390,9 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                             parsed_description: ParsedDescription::Attribute,
                             template: &accept.template,
                             attr_path: attr_path.clone(),
+                            attr_id: attr.id,
                         };
 
-
                         (accept.accept_fn)(&mut cx, &args);
                         finalizers.push(&accept.finalizer);
 
@@ -428,11 +430,9 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 
         early_parsed_state.finalize_early_parsed_attributes(&mut attributes);
         for f in &finalizers {
-            let attr_id = self.sess.psess.attr_id_generator.mk_attr_id();
             if let Some(attr) = f(&mut FinalizeContext {
                 shared: SharedContext { cx: self, target_span, target, emit_lint: &mut emit_lint },
                 all_attrs: &attr_paths,
-                attr_id,
             }) {
                 attributes.push(Attribute::Parsed(attr));
             }

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -794,13 +794,22 @@ pub struct RustcCleanQueries {
     pub span: Span,
 }
 
+#[derive(Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
+pub struct LintAttrInfo {
+    pub lint_groups: ThinVec<LintAttrIdsInformation>,
+    pub attr_span: Span,
+    pub reason: Option<Symbol>,
+    pub attr_style: AttrStyle,
+    pub attr_id: HashIgnoredAttrId,
+}
+
 #[derive(Debug, Clone, PrintAttribute, Encodable, Decodable, HashStable_Generic)]
 pub struct LintAttrIdsInformation {
     pub name: Symbol,
     pub span: Span,
     pub original_name: Symbol,
     pub tool_name: Option<Symbol>,
-    pub lint_index: usize
+    pub lint_index: usize,
 }
 
 #[derive(Clone, Copy, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
@@ -809,7 +818,7 @@ pub enum LintAttributeKind {
     Warn,
     Deny,
     Forbid,
-    Expect(HashIgnoredAttrId),
+    Expect,
 }
 
 /// Represents parsed *built-in* inert attributes.
@@ -989,13 +998,7 @@ pub enum AttributeKind {
     Linkage(Linkage, Span),
 
     /// Represents `#[allow]`, `#[expect]`, `#[warn]`, `#[deny]`, `#[forbid]`
-    LintAttribute {
-        reason: Option<Symbol>,
-        kind: LintAttributeKind,
-        lint_groups: ThinVec<LintAttrIdsInformation>,
-        attr_span: Span,
-        attr_style: AttrStyle
-    },
+    LintAttribute { kind: LintAttributeKind, sub_attrs: ThinVec<LintAttrInfo> },
     /// Represents `#[loop_match]`.
     LoopMatch(Span),