rustc_attr_parsing/attributes/
crate_level.rs1use 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}