Rollup of 14 pull requests

compiler/rustc_ast/src/tokenstream.rs

@@ -622,7 +622,7 @@ pub enum Spacing {
 
 /// A `TokenStream` is an abstract sequence of tokens, organized into [`TokenTree`]s.
 #[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Encodable, Decodable)]
-pub struct TokenStream(pub(crate) Arc<Vec<TokenTree>>);
+pub struct TokenStream(Arc<Vec<TokenTree>>);
 
 impl TokenStream {
     pub fn new(tts: Vec<TokenTree>) -> TokenStream {
@@ -881,7 +881,7 @@ impl<'t> Iterator for TokenStreamIter<'t> {
 }
 
 #[derive(Clone, Debug)]
-pub struct TokenTreeCursor {
+struct TokenTreeCursor {
     stream: TokenStream,
     /// Points to the current token tree in the stream. In `TokenCursor::curr`,
     /// this can be any token tree. In `TokenCursor::stack`, this is always a
@@ -891,27 +891,27 @@ pub struct TokenTreeCursor {
 
 impl TokenTreeCursor {
     #[inline]
-    pub fn new(stream: TokenStream) -> Self {
+    fn new(stream: TokenStream) -> Self {
         TokenTreeCursor { stream, index: 0 }
     }
 
     #[inline]
-    pub fn curr(&self) -> Option<&TokenTree> {
+    fn curr(&self) -> Option<&TokenTree> {
         self.stream.get(self.index)
     }
 
-    pub fn look_ahead(&self, n: usize) -> Option<&TokenTree> {
+    fn look_ahead(&self, n: usize) -> Option<&TokenTree> {
         self.stream.get(self.index + n)
     }
 
     #[inline]
-    pub fn bump(&mut self) {
+    fn bump(&mut self) {
         self.index += 1;
     }
 
     // For skipping ahead in rare circumstances.
     #[inline]
-    pub fn bump_to_end(&mut self) {
+    fn bump_to_end(&mut self) {
         self.index = self.stream.len();
     }
 }
@@ -927,18 +927,68 @@ pub struct TokenCursor {
     // The delimiters for this token stream are found in `self.stack.last()`;
     // if that is `None` we are in the outermost token stream which never has
     // delimiters.
-    pub curr: TokenTreeCursor,
+    curr: TokenTreeCursor,
 
     // Token streams surrounding the current one. The index within each cursor
     // always points to a `TokenTree::Delimited`.
-    pub stack: Vec<TokenTreeCursor>,
+    stack: Vec<TokenTreeCursor>,
 }
 
 impl TokenCursor {
+    #[inline]
+    pub fn new(stream: TokenStream) -> Self {
+        TokenCursor { curr: TokenTreeCursor::new(stream), stack: vec![] }
+    }
+
     pub fn next(&mut self) -> (Token, Spacing) {
         self.inlined_next()
     }
 
+    /// An `n` of zero is the next token tree in the current token stream; won't look outside the
+    /// current token stream.
+    #[inline]
+    pub fn look_ahead(&self, n: usize) -> Option<&TokenTree> {
+        self.curr.look_ahead(n)
+    }
+
+    /// Returns the first token tree (if there is one) past the close delimiter of the enclosing
+    /// delimited sequence. Panics if we are not within a delimited sequence.
+    #[inline]
+    pub fn look_ahead_past_close_delim(&self) -> Option<&TokenTree> {
+        self.stack.last().unwrap().look_ahead(1)
+    }
+
+    /// Clones the `TokenTree::Delimited` that we are currently within. Panics if we are not within
+    /// a delimited sequence.
+    #[inline]
+    pub fn clone_enclosing_delim(&self) -> TokenTree {
+        self.stack.last().unwrap().curr().unwrap().clone()
+    }
+
+    /// For skipping to the end of the current sequence, in rare circumstances.
+    #[inline]
+    pub fn bump_to_end(&mut self) {
+        self.curr.bump_to_end()
+    }
+
+    /// Note: the outermost stream has depth of 0.
+    #[inline]
+    pub fn depth(&self) -> usize {
+        self.stack.len()
+    }
+
+    /// Returns details about the parent delimited sequence, if there is one.
+    #[inline]
+    pub fn parent_delim_and_span(&self) -> Option<(Delimiter, DelimSpan)> {
+        if let Some(last) = self.stack.last()
+            && let Some(TokenTree::Delimited(span, _, delim, _)) = last.curr()
+        {
+            Some((*delim, *span))
+        } else {
+            None
+        }
+    }
+
     /// This always-inlined version should only be used on hot code paths.
     #[inline(always)]
     pub fn inlined_next(&mut self) -> (Token, Spacing) {

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -541,7 +541,7 @@ impl CombineAttributeParser for TargetFeatureParser {
         parse_tf_attribute(cx, args)
     }
 
-    fn finalize_check(cx: &FinalizeContext<'_, '_>, attr_span: Span) {
+    fn finalize_check(cx: &FinalizeCheckContext<'_, '_>, attr_span: Span) {
         // `#[target_feature]` is incompatible with lang item functions,
         // except on WASM where calling target-feature functions is safe (see #84988).
         if !cx.sess().target.is_like_wasm && !cx.sess().opts.actually_rustdoc {

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -576,7 +576,7 @@ impl NoArgsAttributeParser for FfiPureParser {
     const STABILITY: AttributeStability = unstable!(ffi_pure);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::FfiPure;
 
-    fn finalize_check(cx: &FinalizeContext<'_, '_>, attr_span: Span) {
+    fn finalize_check(cx: &FinalizeCheckContext<'_, '_>, attr_span: Span) {
         // `#[ffi_const]` functions cannot be `#[ffi_pure]`.
         if cx.all_attrs.iter().any(|a| a.word_is(sym::ffi_const)) {
             cx.emit_err(BothFfiConstAndPure { attr_span });

compiler/rustc_attr_parsing/src/attributes/lint_helpers.rs

@@ -1,6 +1,9 @@
 use rustc_feature::AttributeStability;
+use rustc_hir::attrs::ReprAttr;
+use rustc_hir::find_attr;
 
 use super::prelude::*;
+use crate::session_diagnostics::RustcPubTransparent;
 
 pub(crate) struct RustcAsPtrParser;
 impl NoArgsAttributeParser for RustcAsPtrParser {
@@ -26,6 +29,17 @@ impl NoArgsAttributeParser for RustcPubTransparentParser {
     ]);
     const STABILITY: AttributeStability = unstable!(rustc_attrs);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcPubTransparent;
+
+    fn finalize_check(cx: &FinalizeCheckContext<'_, '_>, attr_span: Span) {
+        // `#[rustc_pub_transparent]` may only be applied to `#[repr(transparent)]` types.
+        let is_transparent = find_attr!(
+            cx.parsed_attrs,
+            Repr { reprs, .. } if reprs.iter().any(|(r, _)| r == &ReprAttr::ReprTransparent)
+        );
+        if !is_transparent {
+            cx.emit_err(RustcPubTransparent { span: cx.target_span, attr_span });
+        }
+    }
 }
 
 pub(crate) struct RustcPassByValueParser;

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -26,7 +26,7 @@ use rustc_span::edition::Edition;
 use rustc_span::{Span, Symbol};
 use thin_vec::ThinVec;
 
-use crate::context::{AcceptContext, FinalizeContext};
+use crate::context::{AcceptContext, FinalizeCheckContext, FinalizeCheckFn, FinalizeContext};
 use crate::parser::ArgParser;
 use crate::session_diagnostics::UnusedMultiple;
 use crate::target_checking::AllowedTargets;
@@ -117,6 +117,20 @@ pub(crate) trait AttributeParser: Default + 'static {
     /// every single syntax item that could have attributes applied to it.
     /// Your accept mappings should determine whether this returns something.
     fn finalize(self, cx: &FinalizeContext<'_, '_>) -> Option<AttributeKind>;
+
+    /// If this parser produced an attribute, optionally returns a cross-attribute check
+    /// to run once *all* attributes on the item have been finalized, together with the
+    /// span it should be reported at.
+    ///
+    /// Running after finalization means the check can inspect the fully parsed attributes
+    /// via [`FinalizeCheckContext::parsed_attrs`], which are not yet all available during
+    /// [`finalize`](Self::finalize). This is queried right before `finalize` consumes the
+    /// parser state.
+    ///
+    /// Defaults to no check.
+    fn deferred_finalize_check(&self) -> Option<(FinalizeCheckFn, Span)> {
+        None
+    }
 }
 
 /// Alternative to [`AttributeParser`] that automatically handles state management.
@@ -148,13 +162,14 @@ pub(crate) trait SingleAttributeParser: 'static {
     /// Converts a single syntactical attribute to a single semantic attribute, or [`AttributeKind`]
     fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind>;
 
-    /// Optional cross-attribute validation, run once during finalization after all
-    /// attributes on the item have been parsed. Unlike [`convert`](Self::convert), this
-    /// has access to the sibling attributes via [`FinalizeContext::all_attrs`], so it can
-    /// reject incompatible combinations. `attr_span` is the span of this attribute.
+    /// Optional cross-attribute validation, run once *after* all attributes on the item
+    /// have been finalized. Unlike [`convert`](Self::convert), this has access to the
+    /// sibling attributes via [`FinalizeCheckContext::all_attrs`] and the fully parsed
+    /// attributes via [`FinalizeCheckContext::parsed_attrs`], so it can reject incompatible
+    /// combinations. `attr_span` is the span of this attribute.
     ///
     /// Defaults to a no-op.
-    fn finalize_check(_cx: &FinalizeContext<'_, '_>, _attr_span: Span) {}
+    fn finalize_check(_cx: &FinalizeCheckContext<'_, '_>, _attr_span: Span) {}
 }
 
 /// Use in combination with [`SingleAttributeParser`].
@@ -185,11 +200,15 @@ impl<T: SingleAttributeParser> AttributeParser for Single<T> {
     const ALLOWED_TARGETS: AllowedTargets<'_> = T::ALLOWED_TARGETS;
     const SAFETY: AttributeSafety = T::SAFETY;
 
-    fn finalize(self, cx: &FinalizeContext<'_, '_>) -> Option<AttributeKind> {
-        let (kind, span) = self.1?;
-        T::finalize_check(cx, span);
+    fn finalize(self, _cx: &FinalizeContext<'_, '_>) -> Option<AttributeKind> {
+        let (kind, _span) = self.1?;
         Some(kind)
     }
+
+    fn deferred_finalize_check(&self) -> Option<(FinalizeCheckFn, Span)> {
+        let (_, span) = self.1.as_ref()?;
+        Some((<T as SingleAttributeParser>::finalize_check, *span))
+    }
 }
 
 pub(crate) enum OnDuplicate {
@@ -269,13 +288,14 @@ pub(crate) trait NoArgsAttributeParser: 'static {
     /// Create the [`AttributeKind`] given attribute's [`Span`].
     const CREATE: fn(Span) -> AttributeKind;
 
-    /// Optional cross-attribute validation, run once during finalization after all
-    /// attributes on the item have been parsed. Has access to the sibling attributes via
-    /// [`FinalizeContext::all_attrs`], so it can reject incompatible combinations.
+    /// Optional cross-attribute validation, run once *after* all attributes on the item
+    /// have been finalized. Has access to the sibling attributes via
+    /// [`FinalizeCheckContext::all_attrs`] and the fully parsed attributes via
+    /// [`FinalizeCheckContext::parsed_attrs`], so it can reject incompatible combinations.
     /// `attr_span` is the span of this attribute.
     ///
     /// Defaults to a no-op.
-    fn finalize_check(_cx: &FinalizeContext<'_, '_>, _attr_span: Span) {}
+    fn finalize_check(_cx: &FinalizeCheckContext<'_, '_>, _attr_span: Span) {}
 }
 
 pub(crate) struct WithoutArgs<T: NoArgsAttributeParser>(PhantomData<T>);
@@ -299,7 +319,7 @@ impl<T: NoArgsAttributeParser> SingleAttributeParser for WithoutArgs<T> {
         Some(T::CREATE(cx.attr_span))
     }
 
-    fn finalize_check(cx: &FinalizeContext<'_, '_>, attr_span: Span) {
+    fn finalize_check(cx: &FinalizeCheckContext<'_, '_>, attr_span: Span) {
         T::finalize_check(cx, attr_span)
     }
 }
@@ -336,13 +356,14 @@ pub(crate) trait CombineAttributeParser: 'static {
         args: &ArgParser,
     ) -> impl IntoIterator<Item = Self::Item>;
 
-    /// Optional cross-attribute validation, run once during finalization after all
-    /// attributes on the item have been parsed. Has access to the sibling attributes via
-    /// [`FinalizeContext::all_attrs`], so it can reject incompatible combinations.
+    /// Optional cross-attribute validation, run once *after* all attributes on the item
+    /// have been finalized. Has access to the sibling attributes via
+    /// [`FinalizeCheckContext::all_attrs`] and the fully parsed attributes via
+    /// [`FinalizeCheckContext::parsed_attrs`], so it can reject incompatible combinations.
     /// `attr_span` is the span of the first attribute that was encountered.
     ///
     /// Defaults to a no-op.
-    fn finalize_check(_cx: &FinalizeContext<'_, '_>, _attr_span: Span) {}
+    fn finalize_check(_cx: &FinalizeCheckContext<'_, '_>, _attr_span: Span) {}
 }
 
 /// Use in combination with [`CombineAttributeParser`].
@@ -375,12 +396,12 @@ impl<T: CombineAttributeParser> AttributeParser for Combine<T> {
     const ALLOWED_TARGETS: AllowedTargets<'_> = T::ALLOWED_TARGETS;
     const SAFETY: AttributeSafety = T::SAFETY;
 
-    fn finalize(self, cx: &FinalizeContext<'_, '_>) -> Option<AttributeKind> {
-        if let Some(first_span) = self.first_span {
-            T::finalize_check(cx, first_span);
-            Some(T::CONVERT(self.items, first_span))
-        } else {
-            None
-        }
+    fn finalize(self, _cx: &FinalizeContext<'_, '_>) -> Option<AttributeKind> {
+        let first_span = self.first_span?;
+        Some(T::CONVERT(self.items, first_span))
+    }
+
+    fn deferred_finalize_check(&self) -> Option<(FinalizeCheckFn, Span)> {
+        Some((<T as CombineAttributeParser>::finalize_check, self.first_span?))
     }
 }

compiler/rustc_attr_parsing/src/attributes/prelude.rs

@@ -15,7 +15,7 @@ pub(super) use crate::attributes::{
 };
 // contexts
 #[doc(hidden)]
-pub(super) use crate::context::{AcceptContext, FinalizeContext};
+pub(super) use crate::context::{AcceptContext, FinalizeCheckContext, FinalizeContext};
 #[doc(hidden)]
 pub(super) use crate::parser::*;
 // target checking