refactor: more general terminology and use existing attr parse machinery

Author: BarronKane

compiler/rustc_ast_lowering/src/lib.rs

@@ -48,7 +48,7 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::steal::Steal;
 use rustc_data_structures::tagged_ptr::TaggedRef;
 use rustc_errors::{DiagArgFromDisplay, DiagCtxtHandle};
-use rustc_hir::attrs::AttrConstResolution;
+use rustc_hir::attrs::AttrResolution;
 use rustc_hir::def::{DefKind, LifetimeRes, Namespace, PartialRes, PerNS, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE, LocalDefId};
 use rustc_hir::definitions::{DefPathData, DisambiguatorState};
@@ -156,7 +156,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 attr_const_res_map = resolver.all_attr_const_resolutions();
+        let attr_res_map = resolver.all_attr_resolutions();
         Self {
             tcx,
             resolver,
@@ -211,7 +211,7 @@ impl<'a, 'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'a, 'hir, R> {
                 tcx.sess,
                 tcx.features(),
                 registered_tools,
-                attr_const_res_map,
+                attr_res_map,
                 Late,
             ),
             delayed_lints: Vec::new(),
@@ -242,7 +242,7 @@ impl SpanLowerer {
 struct ResolverDelayedAstLowering<'a, 'tcx> {
     node_id_to_def_id: NodeMap<LocalDefId>,
     partial_res_map: NodeMap<PartialRes>,
-    attr_const_res_map: FxIndexMap<rustc_span::AttrId, Vec<AttrConstResolution<ast::NodeId>>>,
+    attr_res_map: FxIndexMap<rustc_span::AttrId, Vec<AttrResolution<ast::NodeId>>>,
     next_node_id: NodeId,
     base: &'a ResolverAstLowering<'tcx>,
 }
@@ -257,11 +257,11 @@ impl<'a, 'tcx> ResolverAstLoweringExt<'tcx> for ResolverDelayedAstLowering<'a, '
         self.partial_res_map.get(&id).copied().or_else(|| self.base.get_partial_res(id))
     }
 
-    fn all_attr_const_resolutions(
+    fn all_attr_resolutions(
         &self,
-    ) -> FxIndexMap<rustc_span::AttrId, Vec<AttrConstResolution<ast::NodeId>>> {
-        let mut map = self.base.all_attr_const_resolutions();
-        for (attr_id, resolutions) in &self.attr_const_res_map {
+    ) -> FxIndexMap<rustc_span::AttrId, Vec<AttrResolution<ast::NodeId>>> {
+        let mut map = self.base.all_attr_resolutions();
+        for (attr_id, resolutions) in &self.attr_res_map {
             map.entry(*attr_id).or_default().extend(resolutions.iter().copied());
         }
         map
@@ -359,10 +359,10 @@ impl<'tcx> ResolverAstLowering<'tcx> {
         self.partial_res_map.get(&id).copied()
     }
 
-    fn all_attr_const_resolutions(
+    fn all_attr_resolutions(
         &self,
-    ) -> FxIndexMap<rustc_span::AttrId, Vec<AttrConstResolution<ast::NodeId>>> {
-        self.attr_const_res_map.clone()
+    ) -> FxIndexMap<rustc_span::AttrId, Vec<AttrResolution<ast::NodeId>>> {
+        self.attr_res_map.clone()
     }
 
     /// Obtains per-namespace resolutions for `use` statement with the given `NodeId`.
@@ -683,7 +683,7 @@ pub fn lower_delayed_owner(tcx: TyCtxt<'_>, def_id: LocalDefId) {
     let mut resolver = ResolverDelayedAstLowering {
         next_node_id: resolver.next_node_id,
         partial_res_map: Default::default(),
-        attr_const_res_map: Default::default(),
+        attr_res_map: Default::default(),
         node_id_to_def_id: Default::default(),
         base: resolver,
     };

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;
 
@@ -103,7 +103,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
@@ -198,7 +201,7 @@ enum AlignmentParseError {
 }
 
 fn parse_repr_align<S: Stage>(
-    cx: &AcceptContext<'_, '_, S>,
+    cx: &mut AcceptContext<'_, '_, S>,
     list: &MetaItemListParser,
     param_span: Span,
     align_kind: AlignKind,
@@ -281,7 +284,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> {
@@ -299,10 +302,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,
@@ -313,7 +321,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) {
@@ -323,22 +333,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

@@ -8,7 +8,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;
@@ -488,11 +488,25 @@ impl<'f, 'sess: 'f, S: Stage> SharedContext<'f, 'sess, S> {
 }
 
 impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
-    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.attr_id.and_then(|attr_id| self.shared.cx.attr_resolution(attr_id, kind, path_span))
+    }
+
+    pub(crate) fn record_attr_resolution_request(
+        &mut self,
+        kind: AttrResolutionKind,
+        path: rustc_ast::Path,
+    ) {
+        if let Some(attr_id) = self.attr_id {
+            self.shared.cx.record_attr_resolution_request(
+                attr_id,
+                crate::interface::AttrResolutionRequest { kind, path },
+            );
+        }
     }
 
     fn emit_parse_error(