refactor: more general terminology and use existing attr parse machinery

Author: BarronKane

compiler/rustc_ast_lowering/src/lib.rs

@@ -654,8 +654,8 @@ pub fn lower_to_hir(tcx: TyCtxt<'_>, (): ()) -> mid_hir::Crate<'_> {
 
     for def_id in ast_index.indices() {
         match &ast_index[def_id] {
-            AstOwner::Item(Item { kind: ItemKind::Delegation { .. }, .. })
-            | AstOwner::AssocItem(Item { kind: AssocItemKind::Delegation { .. }, .. }, _) => {
+            AstOwner::Item(Item { kind: ItemKind::Delegation(..), .. })
+            | AstOwner::AssocItem(Item { kind: AssocItemKind::Delegation(..), .. }, _) => {
                 delayed_ids.insert(def_id);
             }
             _ => lowerer.lower_node(def_id),

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

@@ -38,7 +38,6 @@ use crate::attributes::dummy::*;
 use crate::attributes::inline::*;
 use crate::attributes::instruction_set::*;
 use crate::attributes::link_attrs::*;
-use crate::attributes::lint::*;
 use crate::attributes::lint_helpers::*;
 use crate::attributes::loop_match::*;
 use crate::attributes::macro_attrs::*;
@@ -151,7 +150,6 @@ attribute_parsers!(
         ConfusablesParser,
         ConstStabilityParser,
         DocParser,
-        LintParser,
         MacroUseParser,
         NakedParser,
         OnConstParser,
@@ -887,17 +885,6 @@ where
         )
     }
 
-    pub(crate) fn expected_nv_as_last_argument(
-        &mut self,
-        span: Span,
-        name_value_key: Symbol,
-    ) -> ErrorGuaranteed {
-        self.emit_parse_error(
-            span,
-            AttributeParseErrorReason::ExpectedNameValueAsLastArgument { span, name_value_key },
-        )
-    }
-
     pub(crate) fn warn_empty_attribute(&mut self, span: Span) {
         let attr_path = self.attr_path.clone().to_string();
         let valid_without_list = self.template.word;

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

@@ -182,16 +182,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

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

compiler/rustc_middle/src/ty/mod.rs

@@ -37,7 +37,7 @@ use rustc_data_structures::steal::Steal;
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_errors::{Diag, ErrorGuaranteed, LintBuffer};
 use rustc_hir as hir;
-use rustc_hir::attrs::{AttrConstResolution, StrippedCfgItem};
+use rustc_hir::attrs::{AttrResolution, StrippedCfgItem};
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, DocLinkResMap, LifetimeRes, Res};
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, LocalDefIdMap};
 use rustc_hir::{LangItem, attrs as attr, find_attr};
@@ -211,8 +211,9 @@ pub struct ResolverAstLowering<'tcx> {
     pub lifetimes_res_map: NodeMap<LifetimeRes>,
     /// Lifetime parameters that lowering will have to introduce.
     pub extra_lifetime_params_map: NodeMap<Vec<(Ident, ast::NodeId, LifetimeRes)>>,
-    /// Resolutions for const item paths used in opted-in late attributes, keyed by attribute ID.
-    pub attr_const_res_map: FxIndexMap<AttrId, Vec<AttrConstResolution<ast::NodeId>>>,
+    /// Resolutions for builtin attribute arguments that need late name resolution, keyed by
+    /// attribute ID.
+    pub attr_res_map: FxIndexMap<AttrId, Vec<AttrResolution<ast::NodeId>>>,
 
     pub next_node_id: ast::NodeId,
 

compiler/rustc_resolve/src/late.rs

@@ -8,14 +8,15 @@
 
 use std::borrow::Cow;
 use std::collections::hash_map::Entry;
-use std::debug_assert_matches;
 use std::mem::{replace, swap, take};
 use std::ops::{ControlFlow, Range};
+use std::{debug_assert_matches, slice};
 
 use rustc_ast::visit::{
     AssocCtxt, BoundKind, FnCtxt, FnKind, Visitor, try_visit, visit_opt, walk_list,
 };
 use rustc_ast::*;
+use rustc_attr_parsing::{AttrResolutionRequest, AttributeParser};
 use rustc_data_structures::either::Either;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_data_structures::unord::{UnordMap, UnordSet};
@@ -24,7 +25,7 @@ use rustc_errors::{
     Applicability, Diag, DiagArgValue, Diagnostic, ErrorGuaranteed, IntoDiagArg, MultiSpan,
     StashKey, Suggestions, elided_lifetime_in_path_suggestion, pluralize,
 };
-use rustc_hir::attrs::AttrConstResolved;
+use rustc_hir::attrs::AttrResolved;
 use rustc_hir::def::Namespace::{self, *};
 use rustc_hir::def::{self, CtorKind, DefKind, LifetimeRes, NonMacroAttrKind, PartialRes, PerNS};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LOCAL_CRATE, LocalDefId};
@@ -826,7 +827,7 @@ struct LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 /// Walks the whole crate in DFS order, visiting each item, resolving names as it goes.
 impl<'ast, 'ra, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
     fn visit_attribute(&mut self, attr: &'ast Attribute) {
-        self.resolve_attr_const_paths(attr);
+        self.resolve_attr_paths(attr);
     }
     fn visit_item(&mut self, item: &'ast Item) {
         let prev = replace(&mut self.diag_metadata.current_item, Some(item));
@@ -1471,65 +1472,37 @@ impl<'ast, 'ra, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'ra, 'tc
 }
 
 impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
-    fn resolve_attr_const_paths(&mut self, attr: &'ast Attribute) {
-        match attr.name() {
-            Some(sym::repr) => {
-                let Some(items) = attr.meta_item_list() else {
-                    return;
-                };
-                for item in &items {
-                    let Some(meta) = item.meta_item() else {
-                        continue;
-                    };
-                    let Some(name) = meta.name() else {
-                        continue;
-                    };
-                    if !matches!(name, sym::align | sym::packed) {
-                        continue;
-                    }
-                    let Some([arg]) = meta.meta_item_list() else {
-                        continue;
-                    };
-                    let Some(path_meta) = arg.meta_item() else {
-                        continue;
-                    };
-                    if !path_meta.is_word() {
-                        continue;
-                    }
-                    if !self.should_resolve_attr_const_path(path_meta.path.span) {
-                        continue;
-                    }
-                    self.resolve_attr_const_path(attr.id, &path_meta.path);
-                }
-            }
-            Some(sym::rustc_align | sym::rustc_align_static) => {
-                let Some(items) = attr.meta_item_list() else {
-                    return;
-                };
-                let [arg] = items.as_slice() else {
-                    return;
-                };
-                let Some(path_meta) = arg.meta_item() else {
-                    return;
-                };
-                if !path_meta.is_word() {
-                    return;
-                }
-                if !self.should_resolve_attr_const_path(path_meta.path.span) {
-                    return;
-                }
-                self.resolve_attr_const_path(attr.id, &path_meta.path);
-            }
-            _ => {}
+    fn resolve_attr_paths(&mut self, attr: &'ast Attribute) {
+        let Some(name) = attr.name() else {
+            return;
+        };
+        if !matches!(name, sym::repr | sym::rustc_align | sym::rustc_align_static) {
+            return;
         }
-    }
 
-    fn should_resolve_attr_const_path(&self, span: Span) -> bool {
-        self.r.tcx.features().const_attr_paths() || span.allows_unstable(sym::const_attr_paths)
+        let parse_only = match name {
+            sym::repr => &[sym::repr][..],
+            sym::rustc_align => &[sym::rustc_align][..],
+            sym::rustc_align_static => &[sym::rustc_align_static][..],
+            _ => unreachable!(),
+        };
+
+        let mut requests = AttributeParser::parse_limited_attr_resolution_requests(
+            self.r.tcx.sess,
+            slice::from_ref(attr),
+            parse_only,
+            attr.span,
+            DUMMY_NODE_ID,
+            Some(self.r.tcx.features()),
+        );
+        for request in requests.shift_remove(&attr.id).into_iter().flatten() {
+            self.resolve_attr_path(attr.id, request);
+        }
     }
 
-    fn resolve_attr_const_path(&mut self, attr_id: AttrId, path: &Path) {
-        let path_segments = path
+    fn resolve_attr_path(&mut self, attr_id: AttrId, request: AttrResolutionRequest) {
+        let path_segments = request
+            .path
             .segments
             .iter()
             .map(|segment| Segment::from_ident(segment.ident))
@@ -1538,19 +1511,21 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             &None,
             &path_segments,
             PathSource::Expr(None),
-            Finalize::new(DUMMY_NODE_ID, path.span),
+            Finalize::new(DUMMY_NODE_ID, request.path.span),
             RecordPartialRes::No,
             None,
         );
         let resolved = match partial_res.full_res() {
-            Some(Res::Err) | None => AttrConstResolved::Error,
-            Some(res) => AttrConstResolved::Resolved(res),
+            Some(Res::Err) | None => AttrResolved::Error,
+            Some(res) => AttrResolved::Resolved(res),
         };
-        self.r
-            .attr_const_resolutions
-            .entry(attr_id)
-            .or_default()
-            .push(rustc_hir::attrs::AttrConstResolution { path_span: path.span, resolved });
+        self.r.attr_resolutions.entry(attr_id).or_default().push(
+            rustc_hir::attrs::AttrResolution {
+                kind: request.kind,
+                path_span: request.path.span,
+                resolved,
+            },
+        );
     }
 }