rustc_attr_parsing/attributes/
proc_macro_attrs.rs

1use rustc_feature::{AttributeTemplate, template};
2use rustc_hir::attrs::AttributeKind;
3use rustc_span::{Span, Symbol, sym};
4use thin_vec::ThinVec;
5
6use crate::attributes::{
7    AttributeOrder, NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
8};
9use crate::context::{AcceptContext, Stage};
10use crate::parser::ArgParser;
11
12pub(crate) struct ProcMacroParser;
13impl<S: Stage> NoArgsAttributeParser<S> for ProcMacroParser {
14    const PATH: &[Symbol] = &[sym::proc_macro];
15    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
16    const CREATE: fn(Span) -> AttributeKind = AttributeKind::ProcMacro;
17}
18
19pub(crate) struct ProcMacroAttributeParser;
20impl<S: Stage> NoArgsAttributeParser<S> for ProcMacroAttributeParser {
21    const PATH: &[Symbol] = &[sym::proc_macro_attribute];
22    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
23    const CREATE: fn(Span) -> AttributeKind = AttributeKind::ProcMacroAttribute;
24}
25
26pub(crate) struct ProcMacroDeriveParser;
27impl<S: Stage> SingleAttributeParser<S> for ProcMacroDeriveParser {
28    const PATH: &[Symbol] = &[sym::proc_macro_derive];
29    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
30    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
31    const TEMPLATE: AttributeTemplate = template!(
32        List: &["TraitName", "TraitName, attributes(name1, name2, ...)"],
33        "https://doc.rust-lang.org/reference/procedural-macros.html#derive-macros"
34    );
35
36    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
37        let (trait_name, helper_attrs) = parse_derive_like(cx, args, true)?;
38        Some(AttributeKind::ProcMacroDerive {
39            trait_name: trait_name.expect("Trait name is mandatory, so it is present"),
40            helper_attrs,
41            span: cx.attr_span,
42        })
43    }
44}
45
46pub(crate) struct RustcBuiltinMacroParser;
47impl<S: Stage> SingleAttributeParser<S> for RustcBuiltinMacroParser {
48    const PATH: &[Symbol] = &[sym::rustc_builtin_macro];
49    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
50    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
51    const TEMPLATE: AttributeTemplate =
52        template!(List: &["TraitName", "TraitName, attributes(name1, name2, ...)"]);
53
54    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
55        let (builtin_name, helper_attrs) = parse_derive_like(cx, args, false)?;
56        Some(AttributeKind::RustcBuiltinMacro { builtin_name, helper_attrs, span: cx.attr_span })
57    }
58}
59
60fn parse_derive_like<S: Stage>(
61    cx: &mut AcceptContext<'_, '_, S>,
62    args: &ArgParser<'_>,
63    trait_name_mandatory: bool,
64) -> Option<(Option<Symbol>, ThinVec<Symbol>)> {
65    let Some(list) = args.list() else {
66        // For #[rustc_builtin_macro], it is permitted to leave out the trait name
67        if args.no_args().is_ok() && !trait_name_mandatory {
68            return Some((None, ThinVec::new()));
69        }
70        cx.expected_list(cx.attr_span);
71        return None;
72    };
73    let mut items = list.mixed();
74
75    // Parse the name of the trait that is derived.
76    let Some(trait_attr) = items.next() else {
77        cx.expected_at_least_one_argument(list.span);
78        return None;
79    };
80    let Some(trait_attr) = trait_attr.meta_item() else {
81        cx.unexpected_literal(trait_attr.span());
82        return None;
83    };
84    let Some(trait_ident) = trait_attr.path().word() else {
85        cx.expected_identifier(trait_attr.path().span());
86        return None;
87    };
88    if !trait_ident.name.can_be_raw() {
89        cx.expected_identifier(trait_ident.span);
90        return None;
91    }
92    if let Err(e) = trait_attr.args().no_args() {
93        cx.expected_no_args(e);
94        return None;
95    };
96
97    // Parse optional attributes
98    let mut attributes = ThinVec::new();
99    if let Some(attrs) = items.next() {
100        let Some(attr_list) = attrs.meta_item() else {
101            cx.expected_list(attrs.span());
102            return None;
103        };
104        if !attr_list.path().word_is(sym::attributes) {
105            cx.expected_specific_argument(attrs.span(), vec!["attributes"]);
106            return None;
107        }
108        let Some(attr_list) = attr_list.args().list() else {
109            cx.expected_list(attrs.span());
110            return None;
111        };
112
113        // Parse item in `attributes(...)` argument
114        for attr in attr_list.mixed() {
115            let Some(attr) = attr.meta_item() else {
116                cx.expected_identifier(attr.span());
117                return None;
118            };
119            if let Err(e) = attr.args().no_args() {
120                cx.expected_no_args(e);
121                return None;
122            };
123            let Some(ident) = attr.path().word() else {
124                cx.expected_identifier(attr.path().span());
125                return None;
126            };
127            if !ident.name.can_be_raw() {
128                cx.expected_identifier(ident.span);
129                return None;
130            }
131            attributes.push(ident.name);
132        }
133    }
134
135    // If anything else is specified, we should reject it
136    if let Some(next) = items.next() {
137        cx.expected_no_args(next.span());
138    }
139
140    Some((Some(trait_ident.name), attributes))
141}
rustc_attr_parsing/attributes/proc_macro_attrs.rs

rustc_attr_parsing/attributes/
proc_macro_attrs.rs
