refactor: more general terminology and use existing attr parse machinery

Author: BarronKane

compiler/rustc_ast_lowering/src/lib.rs

@@ -155,7 +155,7 @@ struct LoweringContext<'a, 'hir, R> {
 
 impl<'a, 'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'a, 'hir, R> {
     fn new(tcx: TyCtxt<'hir>, resolver: &'a mut R) -> Self {
-        let registered_tools = tcx.registered_tools(()).iter().map(|x| x.name).collect();
+        let registered_tools = tcx.registered_tools(());
         let attr_res_map = resolver.all_attr_resolutions();
         Self {
             tcx,

compiler/rustc_attr_parsing/src/attributes/repr.rs

@@ -1,6 +1,6 @@
 use rustc_abi::{Align, Size};
 use rustc_ast::{IntTy, LitIntType, LitKind, UintTy};
-use rustc_hir::attrs::{AttrConstResolved, AttrIntValue, IntType, ReprAttr};
+use rustc_hir::attrs::{AttrIntValue, AttrResolutionKind, AttrResolved, IntType, ReprAttr};
 use rustc_hir::def::{DefKind, Res};
 use rustc_session::parse::feature_err;
 
@@ -105,7 +105,10 @@ fn int_type_of_word(s: Symbol) -> Option<IntType> {
     }
 }
 
-fn parse_repr<S: Stage>(cx: &AcceptContext<'_, '_, S>, param: &MetaItemParser) -> Option<ReprAttr> {
+fn parse_repr<S: Stage>(
+    cx: &mut AcceptContext<'_, '_, S>,
+    param: &MetaItemParser,
+) -> Option<ReprAttr> {
     use ReprAttr::*;
 
     // FIXME(jdonszelmann): invert the parsing here to match on the word first and then the
@@ -200,7 +203,7 @@ enum AlignmentParseError {
 }
 
 fn parse_repr_align<S: Stage>(
-    cx: &AcceptContext<'_, '_, S>,
+    cx: &mut AcceptContext<'_, '_, S>,
     list: &MetaItemListParser,
     param_span: Span,
     align_kind: AlignKind,
@@ -283,7 +286,7 @@ fn parse_alignment<S: Stage>(
 }
 
 fn parse_alignment_or_const_path<S: Stage>(
-    cx: &AcceptContext<'_, '_, S>,
+    cx: &mut AcceptContext<'_, '_, S>,
     arg: &MetaItemOrLitParser,
     attr_name: &'static str,
 ) -> Result<AttrIntValue, AlignmentParseError> {
@@ -301,10 +304,15 @@ fn parse_alignment_or_const_path<S: Stage>(
         return Err(AlignmentParseError::Message("not an unsuffixed integer".to_string()));
     }
 
-    if let Some(features) = cx.features_option()
-        && !features.const_attr_paths()
-        && !meta.span().allows_unstable(sym::const_attr_paths)
-    {
+    let path_span = meta.path().span();
+    let feature_enabled = cx.features_option().is_some_and(|features| features.const_attr_paths())
+        || path_span.allows_unstable(sym::const_attr_paths);
+
+    if !feature_enabled {
+        if matches!(cx.stage.should_emit(), ShouldEmit::Nothing) {
+            return Ok(AttrIntValue::Lit(1));
+        }
+
         feature_err(
             cx.sess(),
             sym::const_attr_paths,
@@ -315,7 +323,9 @@ fn parse_alignment_or_const_path<S: Stage>(
         return Err(AlignmentParseError::AlreadyErrored);
     }
 
-    let Some(resolution) = cx.attr_const_resolution(meta.path().span()) else {
+    cx.record_attr_resolution_request(AttrResolutionKind::Const, meta.path().0.clone());
+
+    let Some(resolution) = cx.attr_resolution(AttrResolutionKind::Const, path_span) else {
         // `parse_limited(sym::repr)` runs before lowering for callers that only care whether
         // `repr(packed(...))` exists at all.
         if matches!(cx.stage.should_emit(), ShouldEmit::Nothing) {
@@ -325,22 +335,18 @@ fn parse_alignment_or_const_path<S: Stage>(
     };
 
     match resolution {
-        AttrConstResolved::Resolved(Res::Def(DefKind::Const { .. }, def_id)) => {
-            Ok(AttrIntValue::Const { def_id, span: meta.path().span() })
+        AttrResolved::Resolved(Res::Def(DefKind::Const { .. }, def_id)) => {
+            Ok(AttrIntValue::Const { def_id, span: path_span })
         }
-        AttrConstResolved::Resolved(Res::Def(DefKind::ConstParam, _)) => {
-            cx.emit_err(AttrConstGenericNotSupported { span: meta.path().span(), attr_name });
+        AttrResolved::Resolved(Res::Def(DefKind::ConstParam, _)) => {
+            cx.emit_err(AttrConstGenericNotSupported { span: path_span, attr_name });
             Err(AlignmentParseError::AlreadyErrored)
         }
-        AttrConstResolved::Resolved(res) => {
-            cx.emit_err(AttrConstPathNotConst {
-                span: meta.path().span(),
-                attr_name,
-                thing: res.descr(),
-            });
+        AttrResolved::Resolved(res) => {
+            cx.emit_err(AttrConstPathNotConst { span: path_span, attr_name, thing: res.descr() });
             Err(AlignmentParseError::AlreadyErrored)
         }
-        AttrConstResolved::Error => Err(AlignmentParseError::AlreadyErrored),
+        AttrResolved::Error => Err(AlignmentParseError::AlreadyErrored),
     }
 }
 

compiler/rustc_attr_parsing/src/context.rs

@@ -9,7 +9,7 @@ use private::Sealed;
 use rustc_ast::{AttrStyle, MetaItemLit, NodeId};
 use rustc_errors::{Diag, Diagnostic, Level};
 use rustc_feature::{AttrSuggestionStyle, AttributeTemplate};
-use rustc_hir::attrs::AttributeKind;
+use rustc_hir::attrs::{AttrResolutionKind, AttributeKind};
 use rustc_hir::lints::AttributeLintKind;
 use rustc_hir::{AttrPath, HirId};
 use rustc_parse::parser::Recovery;
@@ -416,7 +416,6 @@ pub struct Late;
 /// Gives [`AttributeParser`]s enough information to create errors, for example.
 pub struct AcceptContext<'f, 'sess, S: Stage> {
     pub(crate) shared: SharedContext<'f, 'sess, S>,
-    pub(crate) attr_id: Option<AttrId>,
 
     /// The outer span of the attribute currently being parsed
     ///
@@ -502,13 +501,25 @@ impl<'f, 'sess: 'f, S: Stage> SharedContext<'f, 'sess, S> {
 impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
     pub(crate) fn adcx(&mut self) -> AttributeDiagnosticContext<'_, 'f, 'sess, S> {
         AttributeDiagnosticContext { ctx: self, custom_suggestions: Vec::new() }
+    }
 
-    pub(crate) fn attr_const_resolution(
+    pub(crate) fn attr_resolution(
         &self,
+        kind: AttrResolutionKind,
         path_span: Span,
-    ) -> Option<rustc_hir::attrs::AttrConstResolved<NodeId>> {
-        self.attr_id.and_then(|attr_id| self.shared.cx.attr_const_resolution(attr_id, path_span))
+    ) -> Option<rustc_hir::attrs::AttrResolved<NodeId>> {
+        self.shared.cx.attr_resolution(self.attr_id, kind, path_span)
     }
+
+    pub(crate) fn record_attr_resolution_request(
+        &mut self,
+        kind: AttrResolutionKind,
+        path: rustc_ast::Path,
+    ) {
+        self.shared.cx.record_attr_resolution_request(
+            self.attr_id,
+            crate::interface::AttrResolutionRequest { kind, path },
+        );
     }
 }
 

compiler/rustc_attr_parsing/src/interface.rs

@@ -3,15 +3,15 @@ use std::convert::identity;
 use rustc_ast as ast;
 use rustc_ast::token::DocFragmentKind;
 use rustc_ast::{AttrItemKind, AttrStyle, NodeId, Path, Safety};
-use rustc_data_structures::fx::FxIndexMap;
+use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_errors::DiagCtxtHandle;
 use rustc_feature::{AttributeTemplate, Features};
 use rustc_hir::attrs::{AttrResolution, AttrResolutionKind, AttrResolved, AttributeKind};
 use rustc_hir::lints::AttributeLintKind;
 use rustc_hir::{AttrArgs, AttrItem, AttrPath, Attribute, HashIgnoredAttrId, Target};
 use rustc_session::Session;
 use rustc_session::lint::{BuiltinLintDiag, LintId};
-use rustc_span::{AttrId, DUMMY_SP, Span, Symbol, sym};
+use rustc_span::{AttrId, DUMMY_SP, Ident, Span, Symbol, sym};
 
 use crate::context::{AcceptContext, FinalizeContext, FinalizeFn, SharedContext, Stage};
 use crate::early_parsed::{EARLY_PARSED_ATTRIBUTES, EarlyParsedState};
@@ -34,7 +34,7 @@ struct LimitedParseResult {
 /// Context created once, for example as part of the ast lowering
 /// context, through which all attributes can be lowered.
 pub struct AttributeParser<'sess, S: Stage = Late> {
-    pub(crate) tools: Vec<Symbol>,
+    pub(crate) tools: Option<&'sess FxIndexSet<Ident>>,
     pub(crate) features: Option<&'sess Features>,
     pub(crate) sess: &'sess Session,
     pub(crate) stage: S,
@@ -101,6 +101,7 @@ impl<'sess> AttributeParser<'sess, Early> {
             target_node_id,
             features,
             should_emit,
+            None,
         )
         .attributes;
         assert!(parsed.len() <= 1);
@@ -127,6 +128,7 @@ impl<'sess> AttributeParser<'sess, Early> {
             target_node_id,
             features,
             should_emit,
+            None,
         )
         .attr_resolution_requests
     }
@@ -166,6 +168,7 @@ impl<'sess> AttributeParser<'sess, Early> {
         target_node_id: NodeId,
         features: Option<&'sess Features>,
         emit_errors: ShouldEmit,
+        tools: Option<&'sess FxIndexSet<Ident>>,
     ) -> Vec<Attribute> {
         Self::parse_limited_inner(
             sess,
@@ -176,10 +179,39 @@ impl<'sess> AttributeParser<'sess, Early> {
             target_node_id,
             features,
             emit_errors,
+            tools,
         )
         .attributes
     }
 
+    /// This method provides the same functionality as [`parse_limited_all`](Self::parse_limited_all)
+    /// except filtered, making sure that only allow-listed symbols are parsed.
+    pub fn parse_limited_all_filtered(
+        sess: &'sess Session,
+        attrs: &[ast::Attribute],
+        filter: &[Symbol],
+        target: Target,
+        target_span: Span,
+        target_node_id: NodeId,
+        features: Option<&'sess Features>,
+        emit_errors: ShouldEmit,
+        tools: &'sess FxIndexSet<Ident>,
+    ) -> Vec<Attribute> {
+        let filtered =
+            attrs.iter().filter(|attr| attr.has_any_name(filter)).cloned().collect::<Vec<_>>();
+        Self::parse_limited_all(
+            sess,
+            &filtered,
+            None,
+            target,
+            target_span,
+            target_node_id,
+            features,
+            emit_errors,
+            Some(tools),
+        )
+    }
+
     fn parse_limited_inner(
         sess: &'sess Session,
         attrs: &[ast::Attribute],
@@ -189,10 +221,11 @@ impl<'sess> AttributeParser<'sess, Early> {
         target_node_id: NodeId,
         features: Option<&'sess Features>,
         emit_errors: ShouldEmit,
+        tools: Option<&'sess FxIndexSet<Ident>>,
     ) -> LimitedParseResult {
         let mut p = Self {
             features,
-            tools: Vec::new(),
+            tools,
             parse_only,
             sess,
             stage: Early { emit_errors },
@@ -285,7 +318,7 @@ impl<'sess> AttributeParser<'sess, Early> {
     ) -> T {
         let mut parser = Self {
             features,
-            tools: Vec::new(),
+            tools: None,
             parse_only: None,
             sess,
             stage: Early { emit_errors },
@@ -310,7 +343,7 @@ impl<'sess> AttributeParser<'sess, Early> {
                 target,
                 emit_lint: &mut emit_lint,
             },
-            attr_id: None,
+            attr_id: sess.psess.attr_id_generator.mk_attr_id(),
             attr_span,
             inner_span,
             attr_style,
@@ -326,13 +359,13 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
     pub fn new(
         sess: &'sess Session,
         features: &'sess Features,
-        tools: Vec<Symbol>,
+        tools: &'sess FxIndexSet<Ident>,
         attr_res_map: FxIndexMap<AttrId, Vec<AttrResolution<NodeId>>>,
         stage: S,
     ) -> Self {
         Self {
             features: Some(features),
-            tools,
+            tools: Some(tools),
             parse_only: None,
             sess,
             stage,
@@ -521,7 +554,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                                 target,
                                 emit_lint: &mut emit_lint,
                             },
-                            attr_id: Some(attr.id),
+                            attr_id: attr.id,
                             attr_span,
                             inner_span: lower_span(n.item.span()),
                             attr_style: attr.style,
@@ -554,11 +587,9 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 
                         let attr = Attribute::Unparsed(Box::new(attr));
 
-                        if self.tools.contains(&parts[0])
-                            // FIXME: this can be removed once #152369 has been merged.
-                            // https://github.com/rust-lang/rust/pull/152369
-                            || [sym::allow, sym::deny, sym::expect, sym::forbid, sym::warn]
-                                .contains(&parts[0])
+                        if self
+                            .tools
+                            .is_some_and(|tools| tools.iter().any(|tool| tool.name == parts[0]))
                         {
                             attributes.push(attr);
                         } else {

compiler/rustc_attr_parsing/src/lib.rs

@@ -112,5 +112,5 @@ pub use attributes::cfg::{
 pub use attributes::cfg_select::*;
 pub use attributes::util::{is_builtin_attr, parse_version};
 pub use context::{Early, Late, OmitDoc, ShouldEmit};
-pub use interface::AttributeParser;
+pub use interface::{AttrResolutionRequest, AttributeParser};
 pub use session_diagnostics::ParsedDescription;

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -184,16 +184,35 @@ pub enum AttrIntValue {
     Const { def_id: DefId, span: Span },
 }
 
+/// The resolution strategy a parsed builtin attribute argument expects.
+#[derive(
+    Copy,
+    Clone,
+    Debug,
+    PartialEq,
+    Eq,
+    HashStable_Generic,
+    Encodable,
+    Decodable,
+    PrintAttribute
+)]
+pub enum AttrResolutionKind {
+    Const,
+}
+
+/// A resolved attribute argument path, or an error placeholder if resolution failed.
 #[derive(Debug, Copy, Clone, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
-pub enum AttrConstResolved<Id = ast::NodeId> {
+pub enum AttrResolved<Id = ast::NodeId> {
     Resolved(Res<Id>),
     Error,
 }
 
+/// A resolved attribute argument path produced by late resolution for a builtin attribute.
 #[derive(Debug, Copy, Clone, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
-pub struct AttrConstResolution<Id = ast::NodeId> {
+pub struct AttrResolution<Id = ast::NodeId> {
+    pub kind: AttrResolutionKind,
     pub path_span: Span,
-    pub resolved: AttrConstResolved<Id>,
+    pub resolved: AttrResolved<Id>,
 }
 
 pub enum TransparencyError {

compiler/rustc_hir/src/attrs/pretty_printing.rs

@@ -17,7 +17,8 @@ use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
 use rustc_target::spec::SanitizerSet;
 use thin_vec::ThinVec;
 
-use crate::attrs::AttrIntValue;
+use crate::HashIgnoredAttrId;
+use crate::attrs::{AttrIntValue, LintInstance};
 use crate::limit::Limit;
 
 /// This trait is used to print attributes in `rustc_hir_pretty`.
@@ -205,8 +206,8 @@ macro_rules! print_tup {
 }
 
 print_tup!(A B C D E F G H);
-print_skip!(Span, (), ErrorGuaranteed, AttrId);
-print_disp!(u8, u16, u32, u128, usize, bool, NonZero<u32>, Limit);
+print_skip!(Span, (), ErrorGuaranteed, AttrId, HashIgnoredAttrId);
+print_disp!(u8, u16, u32, u128, usize, bool, NonZero<u32>, Limit, LintInstance);
 print_debug!(
     Symbol,
     Ident,