time_macros/
lib.rs

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(); // consume `version`
99            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            // Push the `version` ident to the front of the iterator.
108            *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(); // consume `pub`
169            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(); // consume parentheses and path
178        }
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        // First, the optional format description version.
216        let version = parse_format_description_version::<true>(&mut tokens)?;
217
218        // Then, the visibility of the module.
219        let visibility = parse_visibility(&mut tokens)?;
220
221        // Next, an identifier (the desired module name)
222        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        // Followed by a comma
229        helpers::consume_punct(',', &mut tokens)?;
230
231        // Then, the type to create serde serializers for (e.g., `OffsetDateTime`).
232        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        // Another comma
239        helpers::consume_punct(',', &mut tokens)?;
240
241        // We now have two options. The user can either provide a format description as a string or
242        // they can provide a path to a format description. If the latter, all remaining tokens are
243        // assumed to be part of the path.
244        let (format, format_description_display) = match tokens.peek() {
245            // string literal
246            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            // path
263            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}