1#![allow(
2 clippy::missing_const_for_fn,
3 clippy::std_instead_of_core,
4 clippy::std_instead_of_alloc,
5 clippy::alloc_instead_of_core,
6 reason = "irrelevant for proc macros"
7)]
8#![allow(
9 clippy::missing_docs_in_private_items,
10 missing_docs,
11 reason = "may be removed eventually"
12)]
13
14#[allow(
15 unused_macros,
16 reason = "may not be used for all feature flag combinations"
17)]
18macro_rules! bug {
19 () => { compile_error!("provide an error message to help fix a possible bug") };
20 ($descr:literal $($rest:tt)?) => {
21 unreachable!(concat!("internal error: ", $descr) $($rest)?)
22 }
23}
24
25#[macro_use]
26mod quote;
27
28mod date;
29mod datetime;
30mod error;
31#[cfg(any(feature = "formatting", feature = "parsing"))]
32mod format_description;
33mod helpers;
34mod offset;
35#[cfg(all(feature = "serde", any(feature = "formatting", feature = "parsing")))]
36mod serde_format_description;
37mod time;
38mod to_tokens;
39mod utc_datetime;
40
41#[cfg(any(feature = "formatting", feature = "parsing"))]
42use std::iter::Peekable;
43
44#[cfg(all(feature = "serde", any(feature = "formatting", feature = "parsing")))]
45use proc_macro::Delimiter;
46use proc_macro::TokenStream;
47#[cfg(any(feature = "formatting", feature = "parsing"))]
48use proc_macro::TokenTree;
49
50use self::error::Error;
51
52macro_rules! impl_macros {
53 ($($name:ident)*) => {$(
54 #[proc_macro]
55 pub fn $name(input: TokenStream) -> TokenStream {
56 use crate::to_tokens::ToTokenStream;
57
58 let mut iter = input.into_iter().peekable();
59 match $name::parse(&mut iter) {
60 Ok(value) => match iter.peek() {
61 Some(tree) => Error::UnexpectedToken { tree: tree.clone() }.to_compile_error(),
62 None => quote_! { const { #S(value.into_token_stream()) } },
63 },
64 Err(err) => err.to_compile_error(),
65 }
66 }
67 )*};
68}
69
70impl_macros![date datetime utc_datetime offset time];
71
72#[cfg(any(feature = "formatting", feature = "parsing"))]
73type PeekableTokenStreamIter = Peekable<proc_macro::token_stream::IntoIter>;
74
75#[cfg(any(feature = "formatting", feature = "parsing"))]
76enum FormatDescriptionVersion {
77 V1,
78 V2,
79}
80
81#[cfg(any(feature = "formatting", feature = "parsing"))]
82fn parse_format_description_version<const NO_EQUALS_IS_MOD_NAME: bool>(
83 iter: &mut PeekableTokenStreamIter,
84) -> Result<Option<FormatDescriptionVersion>, Error> {
85 let end_of_input_err = || {
86 if NO_EQUALS_IS_MOD_NAME {
87 Error::UnexpectedEndOfInput
88 } else {
89 Error::ExpectedString {
90 span_start: None,
91 span_end: None,
92 }
93 }
94 };
95 let version_ident = match iter.peek().ok_or_else(end_of_input_err)? {
96 version @ TokenTree::Ident(ident) if ident.to_string() == "version" => {
97 let version_ident = version.clone();
98 iter.next(); version_ident
100 }
101 _ => return Ok(None),
102 };
103
104 match iter.peek() {
105 Some(TokenTree::Punct(punct)) if punct.as_char() == '=' => iter.next(),
106 _ if NO_EQUALS_IS_MOD_NAME => {
107 *iter = std::iter::once(version_ident)
109 .chain(iter.clone())
110 .collect::<TokenStream>()
111 .into_iter()
112 .peekable();
113 return Ok(None);
114 }
115 Some(token) => {
116 return Err(Error::Custom {
117 message: "expected `=`".into(),
118 span_start: Some(token.span()),
119 span_end: Some(token.span()),
120 });
121 }
122 None => {
123 return Err(Error::Custom {
124 message: "expected `=`".into(),
125 span_start: None,
126 span_end: None,
127 });
128 }
129 };
130 let version_literal = match iter.next() {
131 Some(TokenTree::Literal(literal)) => literal,
132 Some(token) => {
133 return Err(Error::Custom {
134 message: "expected 1 or 2".into(),
135 span_start: Some(token.span()),
136 span_end: Some(token.span()),
137 });
138 }
139 None => {
140 return Err(Error::Custom {
141 message: "expected 1 or 2".into(),
142 span_start: None,
143 span_end: None,
144 });
145 }
146 };
147 let version = match version_literal.to_string().as_str() {
148 "1" => FormatDescriptionVersion::V1,
149 "2" => FormatDescriptionVersion::V2,
150 _ => {
151 return Err(Error::Custom {
152 message: "invalid format description version".into(),
153 span_start: Some(version_literal.span()),
154 span_end: Some(version_literal.span()),
155 });
156 }
157 };
158 helpers::consume_punct(',', iter)?;
159
160 Ok(Some(version))
161}
162
163#[cfg(all(feature = "serde", any(feature = "formatting", feature = "parsing")))]
164fn parse_visibility(iter: &mut PeekableTokenStreamIter) -> Result<TokenStream, Error> {
165 let mut visibility = match iter.peek().ok_or(Error::UnexpectedEndOfInput)? {
166 pub_ident @ TokenTree::Ident(ident) if ident.to_string() == "pub" => {
167 let visibility = quote_! { #(pub_ident.clone()) };
168 iter.next(); visibility
170 }
171 _ => return Ok(quote_! {}),
172 };
173
174 match iter.peek().ok_or(Error::UnexpectedEndOfInput)? {
175 group @ TokenTree::Group(path) if path.delimiter() == Delimiter::Parenthesis => {
176 visibility.extend(std::iter::once(group.clone()));
177 iter.next(); }
179 _ => {}
180 }
181
182 Ok(visibility)
183}
184
185#[cfg(any(feature = "formatting", feature = "parsing"))]
186#[proc_macro]
187pub fn format_description(input: TokenStream) -> TokenStream {
188 (|| {
189 let mut input = input.into_iter().peekable();
190 let version = parse_format_description_version::<false>(&mut input)?;
191 let (span, string) = helpers::get_string_literal(input)?;
192 let items = format_description::parse_with_version(version, &string, span)?;
193
194 Ok(quote_! {
195 const {
196 use ::time::format_description::{*, modifier::*};
197 &[#S(
198 items
199 .into_iter()
200 .map(|item| quote_! { #S(item), })
201 .collect::<TokenStream>()
202 )] as &[BorrowedFormatItem]
203 }
204 })
205 })()
206 .unwrap_or_else(|err: Error| err.to_compile_error())
207}
208
209#[cfg(all(feature = "serde", any(feature = "formatting", feature = "parsing")))]
210#[proc_macro]
211pub fn serde_format_description(input: TokenStream) -> TokenStream {
212 (|| {
213 let mut tokens = input.into_iter().peekable();
214
215 let version = parse_format_description_version::<true>(&mut tokens)?;
217
218 let visibility = parse_visibility(&mut tokens)?;
220
221 let mod_name = match tokens.next() {
223 Some(TokenTree::Ident(ident)) => Ok(ident),
224 Some(tree) => Err(Error::UnexpectedToken { tree }),
225 None => Err(Error::UnexpectedEndOfInput),
226 }?;
227
228 helpers::consume_punct(',', &mut tokens)?;
230
231 let formattable = match tokens.next() {
233 Some(tree @ TokenTree::Ident(_)) => Ok(tree),
234 Some(tree) => Err(Error::UnexpectedToken { tree }),
235 None => Err(Error::UnexpectedEndOfInput),
236 }?;
237
238 helpers::consume_punct(',', &mut tokens)?;
240
241 let (format, format_description_display) = match tokens.peek() {
245 Some(TokenTree::Literal(_)) => {
247 let (span, format_string) = helpers::get_string_literal(tokens)?;
248 let items = format_description::parse_with_version(version, &format_string, span)?;
249 let items: TokenStream = items
250 .into_iter()
251 .map(|item| quote_! { #S(item), })
252 .collect();
253 let items = quote_! {
254 const {
255 use ::time::format_description::{*, modifier::*};
256 &[#S(items)] as &[BorrowedFormatItem]
257 }
258 };
259
260 (items, String::from_utf8_lossy(&format_string).into_owned())
261 }
262 Some(_) => {
264 let tokens = tokens.collect::<TokenStream>();
265 let tokens_string = tokens.to_string();
266 (tokens, tokens_string)
267 }
268 None => return Err(Error::UnexpectedEndOfInput),
269 };
270
271 Ok(serde_format_description::build(
272 visibility,
273 mod_name,
274 formattable,
275 format,
276 format_description_display,
277 ))
278 })()
279 .unwrap_or_else(|err: Error| err.to_compile_error_standalone())
280}