rustc_attr_parsing/attributes/
proc_macro_attrs.rs

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

rustc_attr_parsing/attributes/
proc_macro_attrs.rs
