Add quote integration as optional printing feature

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "litrs"
-version = "0.4.0"
+version = "0.4.1"
 authors = ["Lukas Kalbertodt <[email protected]>"]
 edition = "2018"
 rust-version = "1.54"
@@ -25,9 +25,11 @@ exclude = [".github"]
 
 
 [features]
-default = ["proc-macro2"]
+default = ["proc-macro2", "printing"]
 check_suffix = ["unicode-xid"]
+printing = ["dep:quote"]
 
 [dependencies]
-proc-macro2 = { version = "1", optional = true }
+proc-macro2 = { version = "1",     optional = true }
 unicode-xid = { version = "0.2.4", optional = true }
+quote       = { version = "1",     optional = true, no-default-features = true }

src/lib.rs

@@ -154,6 +154,9 @@ mod test_util;
 #[cfg(test)]
 mod tests;
 
+#[cfg(feature = "printing")]
+mod printing;
+
 mod bool;
 mod byte;
 mod bytestr;

src/printing/mod.rs

@@ -0,0 +1,44 @@
+use quote::{ToTokens, TokenStreamExt};
+
+use crate::Buffer;
+
+macro_rules! to_tokens_simple {
+    ($id:ident) => {
+        impl<B: Buffer + Clone> ToTokens for crate::$id<B> {
+            fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+                tokens.append(<Self as Into<proc_macro2::Literal>>::into(self.clone()))
+            }
+
+            fn into_token_stream(self) -> proc_macro2::TokenStream
+            where
+                Self: Sized,
+            {
+                proc_macro2::TokenStream::from(proc_macro2::TokenTree::from(<Self as Into<
+                    proc_macro2::Literal,
+                >>::into(self)))
+            }
+        }
+    };
+}
+to_tokens_simple!(ByteLit);
+to_tokens_simple!(ByteStringLit);
+to_tokens_simple!(CharLit);
+to_tokens_simple!(FloatLit);
+to_tokens_simple!(IntegerLit);
+to_tokens_simple!(StringLit);
+
+impl ToTokens for crate::BoolLit {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        use crate::BoolLit::*;
+        tokens.append(proc_macro2::Ident::new(
+            match self {
+                True => "true",
+                False => "false",
+            },
+            proc_macro2::Span::call_site(),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests;

src/printing/tests.rs

@@ -0,0 +1,82 @@
+use proc_macro2::{Literal, TokenTree};
+use quote::ToTokens;
+
+use crate::{ByteLit, ByteStringLit, CharLit, FloatLit, IntegerLit, StringLit};
+
+#[test]
+fn it_preserves_bool_true() {
+    let other = crate::BoolLit::True
+        .to_token_stream()
+        .into_iter()
+        .next()
+        .and_then(|v| {
+            if let TokenTree::Ident(v) = v {
+                Some(v)
+            } else {
+                None
+            }
+        })
+        .unwrap();
+    assert_eq!(other, "true")
+}
+#[test]
+fn it_preserves_bool_false() {
+    let other = crate::BoolLit::False
+        .to_token_stream()
+        .into_iter()
+        .next()
+        .and_then(|v| {
+            if let TokenTree::Ident(v) = v {
+                Some(v)
+            } else {
+                None
+            }
+        })
+        .unwrap();
+    assert_eq!(other, "false")
+}
+
+// NOTE: sometimes the round-trip to quote simplifies literals (for example float literals)
+// this is something that has to be taken into consideration when writing tests
+macro_rules! preservation {
+    ($name:ident : $ty:ident : $($content:tt)+) => {
+        #[test]
+        fn $name() {
+            use std::convert::TryFrom;
+
+            let lit = Literal::$($content)+;
+
+            let lhs = $ty::try_from(lit).unwrap();
+
+            let rhs = $ty::try_from(
+                lhs.to_token_stream()
+                    .into_iter()
+                    .next()
+                    .and_then(|v| {
+                        if let TokenTree::Literal(v) = v {
+                            Some(v)
+                        } else {
+                            None
+                        }
+                    })
+                    .unwrap(),
+            )
+            .unwrap();
+
+            assert_eq!(lhs, rhs);
+        }
+    }
+}
+
+preservation!(it_preserves_u8_suffixed   : IntegerLit :   u8_suffixed(10));
+preservation!(it_preserves_u8_unsuffixed : IntegerLit : u8_unsuffixed(10));
+
+preservation!(it_preserves_f64_suffixed   : FloatLit :   f64_suffixed(1.1));
+preservation!(it_preserves_f64_unsuffixed : FloatLit : f64_unsuffixed(1.1));
+
+preservation!(it_preserves_strings     : StringLit : string("hello world"));
+preservation!(it_preserves_raw_strings : StringLit : string(r#"hello world"#));
+
+preservation!(it_preserves_char : CharLit : character('1'));
+
+preservation!(it_preserves_bytestring : ByteStringLit : byte_string(b"hello world"));