rustc_attr_parsing/attributes/
proc_macro_attrs.rs

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

rustc_attr_parsing/attributes/
proc_macro_attrs.rs
