Continue migration to new Attribute API for doc attribute

Author: GuillaumeGomez

compiler/rustc_attr_parsing/src/attributes/doc.rs

@@ -1,10 +1,14 @@
-use rustc_attr_data_structures::lints::AttributeLintKind;
-use rustc_attr_data_structures::{AttributeKind, DocAttribute, DocInline};
+// FIXME: to be removed
+#![allow(unused_imports)]
+
 use rustc_errors::MultiSpan;
 use rustc_feature::template;
+use rustc_hir::attrs::{AttributeKind, DocAttribute, DocInline};
+use rustc_hir::lints::AttributeLintKind;
 use rustc_span::{Span, Symbol, edition, sym};
 
 use super::{AcceptMapping, AttributeParser};
+use super::prelude::{Allow, AllowedTargets, MethodKind, Target};
 use crate::context::{AcceptContext, FinalizeContext, Stage};
 use crate::fluent_generated as fluent;
 use crate::parser::{ArgParser, MetaItemOrLitParser, MetaItemParser, PathParser};
@@ -28,8 +32,8 @@ impl DocParser {
 
         match path.word_sym() {
             Some(sym::no_crate_inject) => {
-                if !args.no_args() {
-                    cx.expected_no_args(args.span().unwrap());
+                if let Err(span) = args.no_args() {
+                    cx.expected_no_args(span);
                     return;
                 }
 
@@ -42,16 +46,19 @@ impl DocParser {
             }
             Some(sym::attr) => {
                 let Some(list) = args.list() else {
-                    cx.expected_list(args.span().unwrap_or(path.span()));
+                    cx.expected_list(cx.attr_span);
                     return;
                 };
 
-                self.attribute.test_attrs.push(todo!());
+                // FIXME: convert list into a Vec of `AttributeKind`.
+                for _ in list {
+                    // self.attribute.test_attrs.push(AttributeKind::parse());
+                }
             }
             _ => {
                 cx.expected_specific_argument(
                     mip.span(),
-                    [sym::no_crate_inject.as_str(), sym::attr.as_str()].to_vec(),
+                    &[sym::no_crate_inject, sym::attr],
                 );
             }
         }
@@ -162,8 +169,8 @@ impl DocParser {
         args: &ArgParser<'_>,
         inline: DocInline,
     ) {
-        if !args.no_args() {
-            cx.expected_no_args(args.span().unwrap());
+        if let Err(span) = args.no_args() {
+            cx.expected_no_args(span);
             return;
         }
 
@@ -192,8 +199,8 @@ impl DocParser {
 
         macro_rules! no_args {
             ($ident: ident) => {{
-                if !args.no_args() {
-                    cx.expected_no_args(args.span().unwrap());
+                if let Err(span) = args.no_args() {
+                    cx.expected_no_args(span);
                     return;
                 }
 
@@ -239,7 +246,6 @@ impl DocParser {
             Some(sym::no_inline) => self.parse_inline(cx, path, args, DocInline::NoInline),
             Some(sym::masked) => no_args!(masked),
             Some(sym::cfg) => no_args!(cfg),
-            Some(sym::cfg_hide) => no_args!(cfg_hide),
             Some(sym::notable_trait) => no_args!(notable_trait),
             Some(sym::keyword) => self.parse_keyword(cx, path, args),
             Some(sym::fake_variadic) => no_args!(fake_variadic),
@@ -323,19 +329,18 @@ impl DocParser {
             _ => {
                 cx.expected_specific_argument(
                     mip.span(),
-                    [
-                        sym::alias.as_str(),
-                        sym::hidden.as_str(),
-                        sym::html_favicon_url.as_str(),
-                        sym::html_logo_url.as_str(),
-                        sym::html_no_source.as_str(),
-                        sym::html_playground_url.as_str(),
-                        sym::html_root_url.as_str(),
-                        sym::inline.as_str(),
-                        sym::no_inline.as_str(),
-                        sym::test.as_str(),
-                    ]
-                    .to_vec(),
+                    &[
+                        sym::alias,
+                        sym::hidden,
+                        sym::html_favicon_url,
+                        sym::html_logo_url,
+                        sym::html_no_source,
+                        sym::html_playground_url,
+                        sym::html_root_url,
+                        sym::inline,
+                        sym::no_inline,
+                        sym::test,
+                    ],
                 );
             }
         }
@@ -356,15 +361,17 @@ impl DocParser {
                         MetaItemOrLitParser::MetaItemParser(mip) => {
                             self.parse_single_doc_attr_item(cx, mip);
                         }
-                        MetaItemOrLitParser::Lit(lit) => todo!("error should've used equals"),
+                        MetaItemOrLitParser::Lit(lit) => {
+                            cx.expected_name_value(i.span(), None);
+                        }
                         MetaItemOrLitParser::Err(..) => {
                             // already had an error here, move on.
                         }
                     }
                 }
             }
             ArgParser::NameValue(v) => {
-                panic!("this should be rare if at all possible");
+                self.attribute.value.push((v, args.span()));
             }
         }
     }
@@ -373,11 +380,41 @@ impl DocParser {
 impl<S: Stage> AttributeParser<S> for DocParser {
     const ATTRIBUTES: AcceptMapping<Self, S> = &[(
         &[sym::doc],
-        template!(List: "hidden|inline|...", NameValueStr: "string"),
+        template!(List: &["hidden", "inline", "test"], NameValueStr: "string"),
         |this, cx, args| {
             this.accept_single_doc_attr(cx, args);
         },
     )];
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::ExternCrate),
+        Allow(Target::Use),
+        Allow(Target::Static),
+        Allow(Target::Const),
+        Allow(Target::Fn),
+        Allow(Target::Mod),
+        Allow(Target::ForeignMod),
+        Allow(Target::TyAlias),
+        Allow(Target::Enum),
+        Allow(Target::Variant),
+        Allow(Target::Struct),
+        Allow(Target::Field),
+        Allow(Target::Union),
+        Allow(Target::Trait),
+        Allow(Target::TraitAlias),
+        Allow(Target::Impl { of_trait: true }),
+        Allow(Target::Field { of_trait: true }),
+        Allow(Target::AssocConst),
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+        Allow(Target::AssocTy),
+        Allow(Target::ForeignFn),
+        Allow(Target::ForeignStatic),
+        Allow(Target::ForeignTy),
+        Allow(Target::MacroDef),
+        Allow(Target::Crate),
+    ]);
+
 
     fn finalize(self, cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         todo!()

compiler/rustc_attr_parsing/src/attributes/util.rs

@@ -5,7 +5,7 @@ use rustc_ast::attr::AttributeExt;
 use rustc_feature::is_builtin_attr_name;
 use rustc_hir::RustcVersion;
 use rustc_hir::limit::Limit;
-use rustc_span::{Symbol, sym};
+use rustc_span::Symbol;
 
 use crate::context::{AcceptContext, Stage};
 use crate::parser::{ArgParser, NameValueParser};
@@ -32,7 +32,6 @@ pub fn is_builtin_attr(attr: &impl AttributeExt) -> bool {
         || attr.ident().is_some_and(|ident| is_builtin_attr_name(ident.name))
 }
 
-
 /// Parse a single integer.
 ///
 /// Used by attributes that take a single integer as argument, such as
@@ -92,7 +91,3 @@ impl<S: Stage> AcceptContext<'_, '_, S> {
         None
     }
 }
-
-pub fn find_crate_name(attrs: &[impl AttributeExt]) -> Option<Symbol> {
-    first_attr_value_str_by_name(attrs, sym::crate_name)
-}

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -630,23 +630,6 @@ pub(crate) struct DocKeywordConflict {
     pub spans: MultiSpan,
 }
 
- #[derive(Subdiagnostic)]
- pub(crate) enum UnusedNote {
-     #[note(attr_parsing_unused_empty_lints_note)]
-     EmptyList { name: Symbol },
-     #[note(attr_parsing_unused_no_lints_note)]
-     NoLints { name: Symbol },
- }
-
- #[derive(LintDiagnostic)]
- #[diag(attr_parsing_unused)]
- pub(crate) struct Unused {
-     #[suggestion(code = "", applicability = "machine-applicable")]
-     pub attr_span: Span,
-     #[subdiagnostic]
-     pub note: UnusedNote,
- }
-
 #[derive(Diagnostic)]
 #[diag(attr_parsing_link_ordinal_out_of_range)]
 #[note]

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -392,6 +392,9 @@ pub enum DocInline {
 
 #[derive(Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
 pub struct DocAttribute {
+    /// `/// doc` or `#[doc = "doc"]`.
+    pub value: ThinVec<(Symbol, Span)>,
+
     pub aliases: FxIndexMap<Symbol, Span>,
     pub hidden: Option<Span>,
     pub inline: Option<(DocInline, Span)>,
@@ -417,13 +420,14 @@ pub struct DocAttribute {
     pub rust_logo: Option<Span>,
 
     // #[doc(test(...))]
-    pub test_attrs: ThinVec<()>,
+    pub test_attrs: ThinVec<AttributeKind>,
     pub no_crate_inject: Option<Span>,
 }
 
 impl Default for DocAttribute {
     fn default() -> Self {
         Self {
+            value: ThinVec::new(),
             aliases: FxIndexMap::default(),
             hidden: None,
             inline: None,