rustc_attr_parsing/attributes/
crate_level.rs

1use super::prelude::*;
2
3pub(crate) struct CrateNameParser;
4
5impl<S: Stage> SingleAttributeParser<S> for CrateNameParser {
6    const PATH: &[Symbol] = &[sym::crate_name];
7    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
8    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
9    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
10    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
11
12    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
13        let ArgParser::NameValue(n) = args else {
14            cx.expected_name_value(cx.attr_span, None);
15            return None;
16        };
17
18        let Some(name) = n.value_as_str() else {
19            cx.expected_string_literal(n.value_span, Some(n.value_as_lit()));
20            return None;
21        };
22
23        Some(AttributeKind::CrateName { name, name_span: n.value_span, attr_span: cx.attr_span })
24    }
25}
26
27pub(crate) struct RecursionLimitParser;
28
29impl<S: Stage> SingleAttributeParser<S> for RecursionLimitParser {
30    const PATH: &[Symbol] = &[sym::recursion_limit];
31    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
32    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
33    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N", "https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute");
34    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
35
36    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
37        let ArgParser::NameValue(nv) = args else {
38            cx.expected_name_value(cx.attr_span, None);
39            return None;
40        };
41
42        Some(AttributeKind::RecursionLimit {
43            limit: cx.parse_limit_int(nv)?,
44            attr_span: cx.attr_span,
45            limit_span: nv.value_span,
46        })
47    }
48}
49
50pub(crate) struct MoveSizeLimitParser;
51
52impl<S: Stage> SingleAttributeParser<S> for MoveSizeLimitParser {
53    const PATH: &[Symbol] = &[sym::move_size_limit];
54    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
55    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
56    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
57    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
58
59    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
60        let ArgParser::NameValue(nv) = args else {
61            cx.expected_name_value(cx.attr_span, None);
62            return None;
63        };
64
65        Some(AttributeKind::MoveSizeLimit {
66            limit: cx.parse_limit_int(nv)?,
67            attr_span: cx.attr_span,
68            limit_span: nv.value_span,
69        })
70    }
71}
72
73pub(crate) struct TypeLengthLimitParser;
74
75impl<S: Stage> SingleAttributeParser<S> for TypeLengthLimitParser {
76    const PATH: &[Symbol] = &[sym::type_length_limit];
77    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
78    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
79    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
80    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
81
82    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
83        let ArgParser::NameValue(nv) = args else {
84            cx.expected_name_value(cx.attr_span, None);
85            return None;
86        };
87
88        Some(AttributeKind::TypeLengthLimit {
89            limit: cx.parse_limit_int(nv)?,
90            attr_span: cx.attr_span,
91            limit_span: nv.value_span,
92        })
93    }
94}
95
96pub(crate) struct PatternComplexityLimitParser;
97
98impl<S: Stage> SingleAttributeParser<S> for PatternComplexityLimitParser {
99    const PATH: &[Symbol] = &[sym::pattern_complexity_limit];
100    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
101    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
102    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
103    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
104
105    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
106        let ArgParser::NameValue(nv) = args else {
107            cx.expected_name_value(cx.attr_span, None);
108            return None;
109        };
110
111        Some(AttributeKind::PatternComplexityLimit {
112            limit: cx.parse_limit_int(nv)?,
113            attr_span: cx.attr_span,
114            limit_span: nv.value_span,
115        })
116    }
117}
118
119pub(crate) struct NoCoreParser;
120
121impl<S: Stage> NoArgsAttributeParser<S> for NoCoreParser {
122    const PATH: &[Symbol] = &[sym::no_core];
123    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
124    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
125    const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoCore;
126}
127
128pub(crate) struct NoStdParser;
129
130impl<S: Stage> NoArgsAttributeParser<S> for NoStdParser {
131    const PATH: &[Symbol] = &[sym::no_std];
132    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
133    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
134    const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoStd;
135}
136
137pub(crate) struct RustcCoherenceIsCoreParser;
138
139impl<S: Stage> NoArgsAttributeParser<S> for RustcCoherenceIsCoreParser {
140    const PATH: &[Symbol] = &[sym::rustc_coherence_is_core];
141    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
142    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
143    const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcCoherenceIsCore;
144}
rustc_attr_parsing/attributes/crate_level.rs

rustc_attr_parsing/attributes/
crate_level.rs
