litrs/
impls.rs

1use std::convert::TryFrom;
2
3use crate::{Literal, err::{InvalidToken, TokenKind}};
4
5
6/// Helper macro to call a `callback` macro four times for all combinations of
7/// `proc_macro`/`proc_macro2` and `&`/owned.
8macro_rules! helper {
9    ($callback:ident, $($input:tt)*) => {
10        $callback!([proc_macro::] => $($input)*);
11        $callback!([&proc_macro::] => $($input)*);
12        #[cfg(feature = "proc-macro2")]
13        $callback!([proc_macro2::] => $($input)*);
14        #[cfg(feature = "proc-macro2")]
15        $callback!([&proc_macro2::] => $($input)*);
16    };
17}
18
19/// Like `helper!` but without reference types.
20macro_rules! helper_no_refs {
21    ($callback:ident, $($input:tt)*) => {
22        $callback!([proc_macro::] => $($input)*);
23        #[cfg(feature = "proc-macro2")]
24        $callback!([proc_macro2::] => $($input)*);
25    };
26}
27
28
29// ==============================================================================================
30// ===== `From<*Lit> for Literal`
31// ==============================================================================================
32
33macro_rules! impl_specific_lit_to_lit {
34    ($ty:ty, $variant:ident) => {
35        impl<B: crate::Buffer> From<$ty> for Literal<B> {
36            fn from(src: $ty) -> Self {
37                Literal::$variant(src)
38            }
39        }
40    };
41}
42
43impl_specific_lit_to_lit!(crate::BoolLit, Bool);
44impl_specific_lit_to_lit!(crate::IntegerLit<B>, Integer);
45impl_specific_lit_to_lit!(crate::FloatLit<B>, Float);
46impl_specific_lit_to_lit!(crate::CharLit<B>, Char);
47impl_specific_lit_to_lit!(crate::StringLit<B>, String);
48impl_specific_lit_to_lit!(crate::ByteLit<B>, Byte);
49impl_specific_lit_to_lit!(crate::ByteStringLit<B>, ByteString);
50
51
52
53// ==============================================================================================
54// ===== `From<pm::Literal> for Literal`
55// ==============================================================================================
56
57
58macro_rules! impl_tt_to_lit {
59    ([$($prefix:tt)*] => ) => {
60        impl From<$($prefix)* Literal> for Literal<String> {
61            fn from(src: $($prefix)* Literal) -> Self {
62                // We call `expect` in all these impls: this library aims to implement exactly
63                // the Rust grammar, so if we have a valid Rust literal, we should always be
64                // able to parse it.
65                Self::parse(src.to_string())
66                    .expect("bug: failed to parse output of `Literal::to_string`")
67            }
68        }
69    }
70}
71
72helper!(impl_tt_to_lit, );
73
74
75// ==============================================================================================
76// ===== `TryFrom<pm::TokenTree> for Literal`
77// ==============================================================================================
78
79macro_rules! impl_tt_to_lit {
80    ([$($prefix:tt)*] => ) => {
81        impl TryFrom<$($prefix)* TokenTree> for Literal<String> {
82            type Error = InvalidToken;
83            fn try_from(tt: $($prefix)* TokenTree) -> Result<Self, Self::Error> {
84                let span = tt.span();
85                let res = match tt {
86                    $($prefix)* TokenTree::Group(_) => Err(TokenKind::Group),
87                    $($prefix)* TokenTree::Punct(_) => Err(TokenKind::Punct),
88                    $($prefix)* TokenTree::Ident(ref ident) if ident.to_string() == "true"
89                        => return Ok(Literal::Bool(crate::BoolLit::True)),
90                    $($prefix)* TokenTree::Ident(ref ident) if ident.to_string() == "false"
91                        => return Ok(Literal::Bool(crate::BoolLit::False)),
92                    $($prefix)* TokenTree::Ident(_) => Err(TokenKind::Ident),
93                    $($prefix)* TokenTree::Literal(ref lit) => Ok(lit),
94                };
95
96                match res {
97                    Ok(lit) => Ok(From::from(lit)),
98                    Err(actual) => Err(InvalidToken {
99                        actual,
100                        expected: TokenKind::Literal,
101                        span: span.into(),
102                    }),
103                }
104            }
105        }
106    }
107}
108
109helper!(impl_tt_to_lit, );
110
111
112// ==============================================================================================
113// ===== `TryFrom<pm::Literal>`, `TryFrom<pm::TokenTree>` for non-bool `*Lit`
114// ==============================================================================================
115
116fn kind_of(lit: &Literal<String>) -> TokenKind {
117    match lit {
118        Literal::String(_) => TokenKind::StringLit,
119        Literal::Bool(_) => TokenKind::BoolLit,
120        Literal::Integer(_) => TokenKind::IntegerLit,
121        Literal::Float(_) => TokenKind::FloatLit,
122        Literal::Char(_) => TokenKind::CharLit,
123        Literal::Byte(_) => TokenKind::ByteLit,
124        Literal::ByteString(_) => TokenKind::ByteStringLit,
125    }
126}
127
128macro_rules! impl_for_specific_lit {
129    ([$($prefix:tt)*] => $ty:ty, $variant:ident, $kind:ident) => {
130        impl TryFrom<$($prefix)* Literal> for $ty {
131            type Error = InvalidToken;
132            fn try_from(src: $($prefix)* Literal) -> Result<Self, Self::Error> {
133                let span = src.span();
134                let lit: Literal<String> = src.into();
135                match lit {
136                    Literal::$variant(s) => Ok(s),
137                    other => Err(InvalidToken {
138                        expected: TokenKind::$kind,
139                        actual: kind_of(&other),
140                        span: span.into(),
141                    }),
142                }
143            }
144        }
145
146        impl TryFrom<$($prefix)* TokenTree> for $ty {
147            type Error = InvalidToken;
148            fn try_from(tt: $($prefix)* TokenTree) -> Result<Self, Self::Error> {
149                let span = tt.span();
150                let res = match tt {
151                    $($prefix)* TokenTree::Group(_) => Err(TokenKind::Group),
152                    $($prefix)* TokenTree::Punct(_) => Err(TokenKind::Punct),
153                    $($prefix)* TokenTree::Ident(_) => Err(TokenKind::Ident),
154                    $($prefix)* TokenTree::Literal(ref lit) => Ok(lit),
155                };
156
157                match res {
158                    Ok(lit) => <$ty>::try_from(lit),
159                    Err(actual) => Err(InvalidToken {
160                        actual,
161                        expected: TokenKind::$kind,
162                        span: span.into(),
163                    }),
164                }
165            }
166        }
167    };
168}
169
170helper!(impl_for_specific_lit, crate::IntegerLit<String>, Integer, IntegerLit);
171helper!(impl_for_specific_lit, crate::FloatLit<String>, Float, FloatLit);
172helper!(impl_for_specific_lit, crate::CharLit<String>, Char, CharLit);
173helper!(impl_for_specific_lit, crate::StringLit<String>, String, StringLit);
174helper!(impl_for_specific_lit, crate::ByteLit<String>, Byte, ByteLit);
175helper!(impl_for_specific_lit, crate::ByteStringLit<String>, ByteString, ByteStringLit);
176
177
178// ==============================================================================================
179// ===== `From<*Lit> for pm::Literal`
180// ==============================================================================================
181
182macro_rules! impl_specific_lit_to_pm_lit {
183    ([$($prefix:tt)*] => $ty:ident, $variant:ident, $kind:ident) => {
184        impl<B: crate::Buffer> From<crate::$ty<B>> for $($prefix)* Literal {
185            fn from(l: crate::$ty<B>) -> Self {
186                // This should never fail: an input that is parsed successfuly
187                // as one of our literal types should always parse as a
188                // proc_macro literal as well!
189                l.raw_input().parse().unwrap_or_else(|e| {
190                    panic!(
191                        "failed to parse `{}` as `{}`: {}",
192                        l.raw_input(),
193                        std::any::type_name::<Self>(),
194                        e,
195                    )
196                })
197            }
198        }
199    };
200}
201
202helper_no_refs!(impl_specific_lit_to_pm_lit, IntegerLit, Integer, IntegerLit);
203helper_no_refs!(impl_specific_lit_to_pm_lit, FloatLit, Float, FloatLit);
204helper_no_refs!(impl_specific_lit_to_pm_lit, CharLit, Char, CharLit);
205helper_no_refs!(impl_specific_lit_to_pm_lit, StringLit, String, StringLit);
206helper_no_refs!(impl_specific_lit_to_pm_lit, ByteLit, Byte, ByteLit);
207helper_no_refs!(impl_specific_lit_to_pm_lit, ByteStringLit, ByteString, ByteStringLit);
208
209
210// ==============================================================================================
211// ===== `TryFrom<pm::TokenTree> for BoolLit`
212// ==============================================================================================
213
214macro_rules! impl_from_tt_for_bool {
215    ([$($prefix:tt)*] => ) => {
216        impl TryFrom<$($prefix)* TokenTree> for crate::BoolLit {
217            type Error = InvalidToken;
218            fn try_from(tt: $($prefix)* TokenTree) -> Result<Self, Self::Error> {
219                let span = tt.span();
220                let actual = match tt {
221                    $($prefix)* TokenTree::Ident(ref ident) if ident.to_string() == "true"
222                        => return Ok(crate::BoolLit::True),
223                    $($prefix)* TokenTree::Ident(ref ident) if ident.to_string() == "false"
224                        => return Ok(crate::BoolLit::False),
225
226                    $($prefix)* TokenTree::Group(_) => TokenKind::Group,
227                    $($prefix)* TokenTree::Punct(_) => TokenKind::Punct,
228                    $($prefix)* TokenTree::Ident(_) => TokenKind::Ident,
229                    $($prefix)* TokenTree::Literal(ref lit) => kind_of(&Literal::from(lit)),
230                };
231
232                Err(InvalidToken {
233                    actual,
234                    expected: TokenKind::BoolLit,
235                    span: span.into(),
236                })
237            }
238        }
239    };
240}
241
242helper!(impl_from_tt_for_bool, );
243
244// ==============================================================================================
245// ===== `From<BoolLit> for pm::Ident`
246// ==============================================================================================
247
248macro_rules! impl_bool_lit_to_pm_lit {
249    ([$($prefix:tt)*] => ) => {
250        impl From<crate::BoolLit> for $($prefix)* Ident {
251            fn from(l: crate::BoolLit) -> Self {
252                Self::new(l.as_str(), $($prefix)* Span::call_site())
253            }
254        }
255    };
256}
257
258helper_no_refs!(impl_bool_lit_to_pm_lit, );
259
260
261mod tests {
262    //! # Tests
263    //!
264    //! ```no_run
265    //! extern crate proc_macro;
266    //!
267    //! use std::convert::TryFrom;
268    //! use litrs::Literal;
269    //!
270    //! fn give<T>() -> T {
271    //!     panic!()
272    //! }
273    //!
274    //! let _ = litrs::Literal::<String>::from(give::<litrs::BoolLit>());
275    //! let _ = litrs::Literal::<String>::from(give::<litrs::IntegerLit<String>>());
276    //! let _ = litrs::Literal::<String>::from(give::<litrs::FloatLit<String>>());
277    //! let _ = litrs::Literal::<String>::from(give::<litrs::CharLit<String>>());
278    //! let _ = litrs::Literal::<String>::from(give::<litrs::StringLit<String>>());
279    //! let _ = litrs::Literal::<String>::from(give::<litrs::ByteLit<String>>());
280    //! let _ = litrs::Literal::<String>::from(give::<litrs::ByteStringLit<String>>());
281    //!
282    //! let _ = litrs::Literal::<&'static str>::from(give::<litrs::BoolLit>());
283    //! let _ = litrs::Literal::<&'static str>::from(give::<litrs::IntegerLit<&'static str>>());
284    //! let _ = litrs::Literal::<&'static str>::from(give::<litrs::FloatLit<&'static str>>());
285    //! let _ = litrs::Literal::<&'static str>::from(give::<litrs::CharLit<&'static str>>());
286    //! let _ = litrs::Literal::<&'static str>::from(give::<litrs::StringLit<&'static str>>());
287    //! let _ = litrs::Literal::<&'static str>::from(give::<litrs::ByteLit<&'static str>>());
288    //! let _ = litrs::Literal::<&'static str>::from(give::<litrs::ByteStringLit<&'static str>>());
289    //!
290    //!
291    //! let _ = litrs::Literal::from(give::<proc_macro::Literal>());
292    //! let _ = litrs::Literal::from(give::<&proc_macro::Literal>());
293    //!
294    //! let _ = litrs::Literal::try_from(give::<proc_macro::TokenTree>());
295    //! let _ = litrs::Literal::try_from(give::<&proc_macro::TokenTree>());
296    //!
297    //!
298    //! let _ = litrs::IntegerLit::try_from(give::<proc_macro::Literal>());
299    //! let _ = litrs::IntegerLit::try_from(give::<&proc_macro::Literal>());
300    //!
301    //! let _ = litrs::FloatLit::try_from(give::<proc_macro::Literal>());
302    //! let _ = litrs::FloatLit::try_from(give::<&proc_macro::Literal>());
303    //!
304    //! let _ = litrs::CharLit::try_from(give::<proc_macro::Literal>());
305    //! let _ = litrs::CharLit::try_from(give::<&proc_macro::Literal>());
306    //!
307    //! let _ = litrs::StringLit::try_from(give::<proc_macro::Literal>());
308    //! let _ = litrs::StringLit::try_from(give::<&proc_macro::Literal>());
309    //!
310    //! let _ = litrs::ByteLit::try_from(give::<proc_macro::Literal>());
311    //! let _ = litrs::ByteLit::try_from(give::<&proc_macro::Literal>());
312    //!
313    //! let _ = litrs::ByteStringLit::try_from(give::<proc_macro::Literal>());
314    //! let _ = litrs::ByteStringLit::try_from(give::<&proc_macro::Literal>());
315    //!
316    //!
317    //! let _ = litrs::BoolLit::try_from(give::<proc_macro::TokenTree>());
318    //! let _ = litrs::BoolLit::try_from(give::<&proc_macro::TokenTree>());
319    //!
320    //! let _ = litrs::IntegerLit::try_from(give::<proc_macro::TokenTree>());
321    //! let _ = litrs::IntegerLit::try_from(give::<&proc_macro::TokenTree>());
322    //!
323    //! let _ = litrs::FloatLit::try_from(give::<proc_macro::TokenTree>());
324    //! let _ = litrs::FloatLit::try_from(give::<&proc_macro::TokenTree>());
325    //!
326    //! let _ = litrs::CharLit::try_from(give::<proc_macro::TokenTree>());
327    //! let _ = litrs::CharLit::try_from(give::<&proc_macro::TokenTree>());
328    //!
329    //! let _ = litrs::StringLit::try_from(give::<proc_macro::TokenTree>());
330    //! let _ = litrs::StringLit::try_from(give::<&proc_macro::TokenTree>());
331    //!
332    //! let _ = litrs::ByteLit::try_from(give::<proc_macro::TokenTree>());
333    //! let _ = litrs::ByteLit::try_from(give::<&proc_macro::TokenTree>());
334    //!
335    //! let _ = litrs::ByteStringLit::try_from(give::<proc_macro::TokenTree>());
336    //! let _ = litrs::ByteStringLit::try_from(give::<&proc_macro::TokenTree>());
337    //! ```
338}
339
340#[cfg(feature = "proc-macro2")]
341mod tests_proc_macro2 {
342    //! # Tests
343    //!
344    //! ```no_run
345    //! extern crate proc_macro;
346    //!
347    //! use std::convert::TryFrom;
348    //! use litrs::Literal;
349    //!
350    //! fn give<T>() -> T {
351    //!     panic!()
352    //! }
353    //!
354    //! let _ = litrs::Literal::from(give::<proc_macro2::Literal>());
355    //! let _ = litrs::Literal::from(give::<&proc_macro2::Literal>());
356    //!
357    //! let _ = litrs::Literal::try_from(give::<proc_macro2::TokenTree>());
358    //! let _ = litrs::Literal::try_from(give::<&proc_macro2::TokenTree>());
359    //!
360    //!
361    //! let _ = litrs::IntegerLit::try_from(give::<proc_macro2::Literal>());
362    //! let _ = litrs::IntegerLit::try_from(give::<&proc_macro2::Literal>());
363    //!
364    //! let _ = litrs::FloatLit::try_from(give::<proc_macro2::Literal>());
365    //! let _ = litrs::FloatLit::try_from(give::<&proc_macro2::Literal>());
366    //!
367    //! let _ = litrs::CharLit::try_from(give::<proc_macro2::Literal>());
368    //! let _ = litrs::CharLit::try_from(give::<&proc_macro2::Literal>());
369    //!
370    //! let _ = litrs::StringLit::try_from(give::<proc_macro2::Literal>());
371    //! let _ = litrs::StringLit::try_from(give::<&proc_macro2::Literal>());
372    //!
373    //! let _ = litrs::ByteLit::try_from(give::<proc_macro2::Literal>());
374    //! let _ = litrs::ByteLit::try_from(give::<&proc_macro2::Literal>());
375    //!
376    //! let _ = litrs::ByteStringLit::try_from(give::<proc_macro2::Literal>());
377    //! let _ = litrs::ByteStringLit::try_from(give::<&proc_macro2::Literal>());
378    //!
379    //!
380    //! let _ = litrs::BoolLit::try_from(give::<proc_macro2::TokenTree>());
381    //! let _ = litrs::BoolLit::try_from(give::<&proc_macro2::TokenTree>());
382    //!
383    //! let _ = litrs::IntegerLit::try_from(give::<proc_macro2::TokenTree>());
384    //! let _ = litrs::IntegerLit::try_from(give::<&proc_macro2::TokenTree>());
385    //!
386    //! let _ = litrs::FloatLit::try_from(give::<proc_macro2::TokenTree>());
387    //! let _ = litrs::FloatLit::try_from(give::<&proc_macro2::TokenTree>());
388    //!
389    //! let _ = litrs::CharLit::try_from(give::<proc_macro2::TokenTree>());
390    //! let _ = litrs::CharLit::try_from(give::<&proc_macro2::TokenTree>());
391    //!
392    //! let _ = litrs::StringLit::try_from(give::<proc_macro2::TokenTree>());
393    //! let _ = litrs::StringLit::try_from(give::<&proc_macro2::TokenTree>());
394    //!
395    //! let _ = litrs::ByteLit::try_from(give::<proc_macro2::TokenTree>());
396    //! let _ = litrs::ByteLit::try_from(give::<&proc_macro2::TokenTree>());
397    //!
398    //! let _ = litrs::ByteStringLit::try_from(give::<proc_macro2::TokenTree>());
399    //! let _ = litrs::ByteStringLit::try_from(give::<&proc_macro2::TokenTree>());
400    //! ```
401}
litrs/impls.rs

litrs/
impls.rs
