diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index b790a60..2453d78 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,6 @@
 {
   "git": {
-    "sha1": "219f0ca73d15cc518e9d56952b4e296dc8c17636"
-  }
-}
+    "sha1": "3cff8b417bbde9cb80f9d3aa1be0704ec9c78006"
+  },
+  "path_in_vcs": ""
+}
\ No newline at end of file
diff --git a/Android.bp b/Android.bp
index 41b90b6..1cb9448 100644
--- a/Android.bp
+++ b/Android.bp
@@ -1,8 +1,6 @@
 // This file is generated by cargo2android.py --config cargo2android.json.
 // Do not modify this file as changes will be overridden on upgrade.
 
-
-
 package {
     default_applicable_licenses: ["external_rust_crates_litrs_license"],
 }
@@ -43,7 +41,7 @@
     name: "liblitrs",
     crate_name: "litrs",
     cargo_env_compat: true,
-    cargo_pkg_version: "0.2.3",
+    cargo_pkg_version: "0.3.0",
     srcs: ["src/lib.rs"],
     edition: "2018",
     features: [
@@ -54,8 +52,4 @@
         "libproc_macro2",
     ],
     compile_multilib: "first",
-    apex_available: [
-        "//apex_available:platform",
-        "//apex_available:anyapex",
-    ],
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9e6628a..3d4ee99 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,23 @@
 
 ## [Unreleased]
 
+## [0.3.0] - 2022-12-19
+### Breaking
+- Bump MSRV (minimal supported Rust version) to 1.54
+
+### Added
+- Add `raw_input` and `into_raw_input` to non-bool `*Lit` types
+- Add `impl From<*Lit> for pm::Literal` (for non-bool literals)
+- Add `impl From<BoolLit> for pm::Ident`
+
+### Fixed
+- Fix link to reference and clarify bool literals ([#7](https://github.com/LukasKalbertodt/litrs/pull/7))
+
+### Internals
+- Move lots of parsing code into non-generic functions (this hopefully reduces compile times)
+- To implement `[into_]raw_input` for integer and float literals, their
+  internals were changed a bit so that they store the full input string now.
+
 ## [0.2.3] - 2021-06-09
 ### Changed
 - Minor internal code change to bring MSRV from 1.52 to 1.42
@@ -51,7 +68,8 @@
 - Everything
 
 
-[Unreleased]: https://github.com/LukasKalbertodt/litrs/compare/v0.2.3...HEAD
+[Unreleased]: https://github.com/LukasKalbertodt/litrs/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/LukasKalbertodt/litrs/compare/v0.2.3...v0.3.0
 [0.2.3]: https://github.com/LukasKalbertodt/litrs/compare/v0.2.2...v0.2.3
 [0.2.2]: https://github.com/LukasKalbertodt/litrs/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/LukasKalbertodt/litrs/compare/v0.2.0...v0.2.1
diff --git a/Cargo.toml b/Cargo.toml
index e0e1115..62e2503 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,26 +3,41 @@
 # When uploading crates to the registry Cargo will automatically
 # "normalize" Cargo.toml files for maximal compatibility
 # with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
+# to registry (e.g., crates.io) dependencies.
 #
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
 
 [package]
 edition = "2018"
+rust-version = "1.54"
 name = "litrs"
-version = "0.2.3"
+version = "0.3.0"
 authors = ["Lukas Kalbertodt <lukas.kalbertodt@gmail.com>"]
 exclude = [".github"]
-description = "Parse and inspect Rust literals (i.e. tokens in the Rust programming language\nrepresenting fixed values). Particularly useful for proc macros, but can also\nbe used outside of a proc-macro context.\n"
+description = """
+Parse and inspect Rust literals (i.e. tokens in the Rust programming language
+representing fixed values). Particularly useful for proc macros, but can also
+be used outside of a proc-macro context.
+"""
 documentation = "https://docs.rs/litrs/"
 readme = "README.md"
-keywords = ["literal", "parsing", "proc-macro", "type", "procedural"]
-categories = ["development-tools::procedural-macro-helpers", "parser-implementations", "development-tools::build-utils"]
+keywords = [
+    "literal",
+    "parsing",
+    "proc-macro",
+    "type",
+    "procedural",
+]
+categories = [
+    "development-tools::procedural-macro-helpers",
+    "parser-implementations",
+    "development-tools::build-utils",
+]
 license = "MIT/Apache-2.0"
 repository = "https://github.com/LukasKalbertodt/litrs/"
+
 [dependencies.proc-macro2]
 version = "1"
 optional = true
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 9adec4c..bbfd540 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,8 +1,9 @@
 [package]
 name = "litrs"
-version = "0.2.3"
+version = "0.3.0"
 authors = ["Lukas Kalbertodt <lukas.kalbertodt@gmail.com>"]
 edition = "2018"
+rust-version = "1.54"
 
 description = """
 Parse and inspect Rust literals (i.e. tokens in the Rust programming language
diff --git a/METADATA b/METADATA
index 74905a4..e70e7d5 100644
--- a/METADATA
+++ b/METADATA
@@ -1,3 +1,7 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/litrs
+# For more info, check https://cs.android.com/android/platform/superproject/+/master:tools/external_updater/README.md
+
 name: "litrs"
 description: "Parse and inspect Rust literals (i.e. tokens in the Rust programming language representing fixed values). Particularly useful for proc macros, but can also be used outside of a proc-macro context."
 third_party {
@@ -7,14 +11,13 @@
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/litrs/litrs-0.2.3.crate"
+    value: "https://static.crates.io/crates/litrs/litrs-0.3.0.crate"
   }
-  version: "0.2.3"
-  # Dual-licensed, using the least restrictive per go/thirdpartylicenses#same.
+  version: "0.3.0"
   license_type: NOTICE
   last_upgrade_date {
-    year: 2022
-    month: 10
-    day: 27
+    year: 2023
+    month: 2
+    day: 3
   }
 }
diff --git a/README.md b/README.md
index 04c7b47..2307a5f 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,11 @@
 # `litrs`: parsing and inspecting Rust literals
 
-[<img alt="CI status of master" src="https://img.shields.io/github/workflow/status/LukasKalbertodt/litrs/CI/master?label=CI&logo=github&logoColor=white&style=for-the-badge" height="23">](https://github.com/LukasKalbertodt/litrs/actions?query=workflow%3ACI+branch%3Amaster)
+[<img alt="CI status of main" src="https://img.shields.io/github/actions/workflow/status/LukasKalbertodt/litrs/ci.yml?branch=main&label=CI&logo=github&logoColor=white&style=for-the-badge" height="23">](https://github.com/LukasKalbertodt/litrs/actions/workflows/ci.yml)
 [<img alt="Crates.io Version" src="https://img.shields.io/crates/v/litrs?logo=rust&style=for-the-badge" height="23">](https://crates.io/crates/litrs)
 [<img alt="docs.rs" src="https://img.shields.io/crates/v/litrs?color=blue&label=docs&style=for-the-badge" height="23">](https://docs.rs/litrs)
 
 `litrs` offers functionality to parse Rust literals, i.e. tokens in the Rust programming language that represent fixed values.
+For example: `27`, `"crab"`, `bool`.
 This is particularly useful for proc macros, but can also be used outside of a proc-macro context.
 
 **Why this library?**
@@ -12,11 +13,10 @@
 There are mainly two libraries for this purpose:
 [`syn`](https://github.com/dtolnay/syn) and [`literalext`](https://github.com/mystor/literalext).
 The latter is deprecated.
-And `syn` is oftentimes overkill for the task at hand, especially when developing function like proc-macros (e.g. `foo!(..)`).
+And `syn` is oftentimes overkill for the task at hand, especially when developing function-like proc-macros (e.g. `foo!(..)`).
 This crate is a lightweight alternative.
 Also, when it comes to literals, `litrs` offers a bit more flexibility and a few more features compared to `syn`.
 
-While this library is fairly young, it is extensively tested and I think the number of parsing bugs should already be very low.
 I'm interested in community feedback!
 If you consider using this, please speak your mind [in this issue](https://github.com/LukasKalbertodt/litrs/issues/1).
 
diff --git a/src/bool/mod.rs b/src/bool/mod.rs
index 406174c..d7b54a1 100644
--- a/src/bool/mod.rs
+++ b/src/bool/mod.rs
@@ -5,7 +5,11 @@
 
 /// A bool literal: `true` or `false`. Also see [the reference][ref].
 ///
-/// [ref]: https://doc.rust-lang.org/reference/tokens.html#boolean-literals
+/// Notice that, strictly speaking, from Rust point of view "boolean literals" are not
+/// actual literals but [keywords].
+///
+/// [ref]: https://doc.rust-lang.org/reference/expressions/literal-expr.html#boolean-literal-expressions
+/// [keywords]: https://doc.rust-lang.org/reference/keywords.html#strict-keywords
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BoolLit {
     False,
diff --git a/src/byte/mod.rs b/src/byte/mod.rs
index 5f60e42..7c64901 100644
--- a/src/byte/mod.rs
+++ b/src/byte/mod.rs
@@ -29,7 +29,8 @@
             return Err(perr(None, InvalidByteLiteralStart));
         }
 
-        Self::parse_impl(input)
+        let value = parse_impl(&input)?;
+        Ok(Self { raw: input, value })
     }
 
     /// Returns the byte value that this literal represents.
@@ -37,37 +38,16 @@
         self.value
     }
 
-    /// Precondition: must start with `b'`.
-    pub(crate) fn parse_impl(input: B) -> Result<Self, ParseError> {
-        if input.len() == 2 {
-            return Err(perr(None, UnterminatedByteLiteral));
-        }
-        if *input.as_bytes().last().unwrap() != b'\'' {
-            return Err(perr(None, UnterminatedByteLiteral));
-        }
-
-        let inner = &input[2..input.len() - 1];
-        let first = inner.as_bytes().get(0).ok_or(perr(None, EmptyByteLiteral))?;
-        let (c, len) = match first {
-            b'\'' => return Err(perr(2, UnescapedSingleQuote)),
-            b'\n' | b'\t' | b'\r'
-                => return Err(perr(2, UnescapedSpecialWhitespace)),
-
-            b'\\' => unescape::<u8>(inner, 2)?,
-            other if other.is_ascii() => (*other, 1),
-            _ => return Err(perr(2, NonAsciiInByteLiteral)),
-        };
-        let rest = &inner[len..];
-
-        if !rest.is_empty() {
-            return Err(perr(len + 2..input.len() - 1, OverlongByteLiteral));
-        }
-
-        Ok(Self {
-            raw: input,
-            value: c,
-        })
+    /// Returns the raw input that was passed to `parse`.
+    pub fn raw_input(&self) -> &str {
+        &self.raw
     }
+
+    /// Returns the raw input that was passed to `parse`, potentially owned.
+    pub fn into_raw_input(self) -> B {
+        self.raw
+    }
+
 }
 
 impl ByteLit<&str> {
@@ -87,5 +67,35 @@
     }
 }
 
+/// Precondition: must start with `b'`.
+#[inline(never)]
+pub(crate) fn parse_impl(input: &str) -> Result<u8, ParseError> {
+    if input.len() == 2 {
+        return Err(perr(None, UnterminatedByteLiteral));
+    }
+    if *input.as_bytes().last().unwrap() != b'\'' {
+        return Err(perr(None, UnterminatedByteLiteral));
+    }
+
+    let inner = &input[2..input.len() - 1];
+    let first = inner.as_bytes().get(0).ok_or(perr(None, EmptyByteLiteral))?;
+    let (c, len) = match first {
+        b'\'' => return Err(perr(2, UnescapedSingleQuote)),
+        b'\n' | b'\t' | b'\r'
+            => return Err(perr(2, UnescapedSpecialWhitespace)),
+
+        b'\\' => unescape::<u8>(inner, 2)?,
+        other if other.is_ascii() => (*other, 1),
+        _ => return Err(perr(2, NonAsciiInByteLiteral)),
+    };
+    let rest = &inner[len..];
+
+    if !rest.is_empty() {
+        return Err(perr(len + 2..input.len() - 1, OverlongByteLiteral));
+    }
+
+    Ok(c)
+}
+
 #[cfg(test)]
 mod tests;
diff --git a/src/byte/tests.rs b/src/byte/tests.rs
index 5f663ce..08586b0 100644
--- a/src/byte/tests.rs
+++ b/src/byte/tests.rs
@@ -1,4 +1,4 @@
-use crate::{ByteLit, Literal, test_util::assert_parse_ok_eq};
+use crate::{ByteLit, Literal, test_util::{assert_parse_ok_eq, assert_roundtrip}};
 
 // ===== Utility functions =======================================================================
 
@@ -13,6 +13,7 @@
         assert_parse_ok_eq(input, ByteLit::parse(input), expected.clone(), "ByteLit::parse");
         assert_parse_ok_eq(input, Literal::parse(input), Literal::Byte(expected), "Literal::parse");
         assert_eq!(ByteLit::parse(input).unwrap().value(), $lit);
+        assert_roundtrip(expected.to_owned(), input);
     };
 }
 
diff --git a/src/bytestr/mod.rs b/src/bytestr/mod.rs
index 6cfb61d..a2908b9 100644
--- a/src/bytestr/mod.rs
+++ b/src/bytestr/mod.rs
@@ -62,6 +62,16 @@
         self.num_hashes.is_some()
     }
 
+    /// Returns the raw input that was passed to `parse`.
+    pub fn raw_input(&self) -> &str {
+        &self.raw
+    }
+
+    /// Returns the raw input that was passed to `parse`, potentially owned.
+    pub fn into_raw_input(self) -> B {
+        self.raw
+    }
+
     /// The range within `self.raw` that excludes the quotes and potential `r#`.
     fn inner_range(&self) -> Range<usize> {
         match self.num_hashes {
diff --git a/src/bytestr/tests.rs b/src/bytestr/tests.rs
index 8e3c033..b0480fd 100644
--- a/src/bytestr/tests.rs
+++ b/src/bytestr/tests.rs
@@ -1,4 +1,4 @@
-use crate::{Literal, ByteStringLit, test_util::assert_parse_ok_eq};
+use crate::{Literal, ByteStringLit, test_util::{assert_parse_ok_eq, assert_roundtrip}};
 
 // ===== Utility functions =======================================================================
 
@@ -14,9 +14,10 @@
         assert_parse_ok_eq(
             input, ByteStringLit::parse(input), expected.clone(), "ByteStringLit::parse");
         assert_parse_ok_eq(
-            input, Literal::parse(input), Literal::ByteString(expected), "Literal::parse");
+            input, Literal::parse(input), Literal::ByteString(expected.clone()), "Literal::parse");
         assert_eq!(ByteStringLit::parse(input).unwrap().value(), $lit);
         assert_eq!(ByteStringLit::parse(input).unwrap().into_value().as_ref(), $lit);
+        assert_roundtrip(expected.into_owned(), input);
     };
 }
 
diff --git a/src/char/mod.rs b/src/char/mod.rs
index 1480bdf..96d5037 100644
--- a/src/char/mod.rs
+++ b/src/char/mod.rs
@@ -24,7 +24,10 @@
     /// is invalid or represents a different kind of literal.
     pub fn parse(input: B) -> Result<Self, ParseError> {
         match first_byte_or_empty(&input)? {
-            b'\'' => Self::parse_impl(input),
+            b'\'' => {
+                let value = parse_impl(&input)?;
+                Ok(Self { raw: input, value })
+            },
             _ => Err(perr(0, DoesNotStartWithQuote)),
         }
     }
@@ -34,36 +37,16 @@
         self.value
     }
 
-    /// Precondition: first character in input must be `'`.
-    pub(crate) fn parse_impl(input: B) -> Result<Self, ParseError> {
-        if input.len() == 1 {
-            return Err(perr(None, UnterminatedCharLiteral));
-        }
-        if *input.as_bytes().last().unwrap() != b'\'' {
-            return Err(perr(None, UnterminatedCharLiteral));
-        }
-
-        let inner = &input[1..input.len() - 1];
-        let first = inner.chars().nth(0).ok_or(perr(None, EmptyCharLiteral))?;
-        let (c, len) = match first {
-            '\'' => return Err(perr(1, UnescapedSingleQuote)),
-            '\n' | '\t' | '\r'
-                => return Err(perr(1, UnescapedSpecialWhitespace)),
-
-            '\\' => unescape::<char>(inner, 1)?,
-            other => (other, other.len_utf8()),
-        };
-        let rest = &inner[len..];
-
-        if !rest.is_empty() {
-            return Err(perr(len + 1..input.len() - 1, OverlongCharLiteral));
-        }
-
-        Ok(Self {
-            raw: input,
-            value: c,
-        })
+    /// Returns the raw input that was passed to `parse`.
+    pub fn raw_input(&self) -> &str {
+        &self.raw
     }
+
+    /// Returns the raw input that was passed to `parse`, potentially owned.
+    pub fn into_raw_input(self) -> B {
+        self.raw
+    }
+
 }
 
 impl CharLit<&str> {
@@ -83,6 +66,34 @@
     }
 }
 
+/// Precondition: first character in input must be `'`.
+#[inline(never)]
+pub(crate) fn parse_impl(input: &str) -> Result<char, ParseError> {
+    if input.len() == 1 {
+        return Err(perr(None, UnterminatedCharLiteral));
+    }
+    if *input.as_bytes().last().unwrap() != b'\'' {
+        return Err(perr(None, UnterminatedCharLiteral));
+    }
+
+    let inner = &input[1..input.len() - 1];
+    let first = inner.chars().nth(0).ok_or(perr(None, EmptyCharLiteral))?;
+    let (c, len) = match first {
+        '\'' => return Err(perr(1, UnescapedSingleQuote)),
+        '\n' | '\t' | '\r'
+            => return Err(perr(1, UnescapedSpecialWhitespace)),
+
+        '\\' => unescape::<char>(inner, 1)?,
+        other => (other, other.len_utf8()),
+    };
+    let rest = &inner[len..];
+
+    if !rest.is_empty() {
+        return Err(perr(len + 1..input.len() - 1, OverlongCharLiteral));
+    }
+
+    Ok(c)
+}
 
 #[cfg(test)]
 mod tests;
diff --git a/src/char/tests.rs b/src/char/tests.rs
index 01ca2c5..bfae5e4 100644
--- a/src/char/tests.rs
+++ b/src/char/tests.rs
@@ -1,4 +1,4 @@
-use crate::{Literal, test_util::assert_parse_ok_eq};
+use crate::{Literal, test_util::{assert_parse_ok_eq, assert_roundtrip}};
 use super::CharLit;
 
 // ===== Utility functions =======================================================================
@@ -14,6 +14,7 @@
         assert_parse_ok_eq(input, CharLit::parse(input), expected.clone(), "CharLit::parse");
         assert_parse_ok_eq(input, Literal::parse(input), Literal::Char(expected), "Literal::parse");
         assert_eq!(CharLit::parse(input).unwrap().value(), $lit);
+        assert_roundtrip(expected.to_owned(), input);
     };
 }
 
diff --git a/src/err.rs b/src/err.rs
index dd5b472..1011550 100644
--- a/src/err.rs
+++ b/src/err.rs
@@ -180,16 +180,19 @@
 }
 
 impl SpanLike for Option<Range<usize>> {
+    #[inline(always)]
     fn into_span(self) -> Option<Range<usize>> {
         self
     }
 }
 impl SpanLike for Range<usize> {
+    #[inline(always)]
     fn into_span(self) -> Option<Range<usize>> {
         Some(self)
     }
 }
 impl SpanLike for usize {
+    #[inline(always)]
     fn into_span(self) -> Option<Range<usize>> {
         Some(self..self + 1)
     }
diff --git a/src/escape.rs b/src/escape.rs
index 3e93113..19b63a1 100644
--- a/src/escape.rs
+++ b/src/escape.rs
@@ -108,11 +108,12 @@
 
 /// Checks whether the character is skipped after a string continue start
 /// (unescaped backlash followed by `\n`).
-pub(crate) fn is_string_continue_skipable_whitespace(b: u8) -> bool {
+fn is_string_continue_skipable_whitespace(b: u8) -> bool {
     b == b' ' || b == b'\t' || b == b'\n' || b == b'\r'
 }
 
 /// Unescapes a whole string or byte string.
+#[inline(never)]
 pub(crate) fn unescape_string<E: Escapee>(
     input: &str,
     offset: usize,
@@ -180,6 +181,7 @@
 /// Reads and checks a raw (byte) string literal, converting `\r\n` sequences to
 /// just `\n` sequences. Returns an optional new string (if the input contained
 /// any `\r\n`) and the number of hashes used by the literal.
+#[inline(never)]
 pub(crate) fn scan_raw_string<E: Escapee>(
     input: &str,
     offset: usize,
diff --git a/src/float/mod.rs b/src/float/mod.rs
index e30a336..b196845 100644
--- a/src/float/mod.rs
+++ b/src/float/mod.rs
@@ -21,27 +21,27 @@
 /// [ref]: https://doc.rust-lang.org/reference/tokens.html#floating-point-literals
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct FloatLit<B: Buffer> {
-    /// Basically the whole literal, but without the type suffix. Other `usize`
-    /// fields in this struct partition this string. `end_integer_part` is
-    /// always <= `end_fractional_part`.
+    /// The whole raw input. The `usize` fields in this struct partition this
+    /// string. Always true: `end_integer_part <= end_fractional_part`.
     ///
     /// ```text
-    ///    12_3.4_56e789
-    ///        ╷    ╷
+    ///    12_3.4_56e789f32
+    ///        ╷    ╷   ╷
+    ///        |    |   └ end_number_part = 13
     ///        |    └ end_fractional_part = 9
     ///        └ end_integer_part = 4
     ///
     ///    246.
     ///       ╷╷
-    ///       |└ end_fractional_part = 4
+    ///       |└ end_fractional_part = end_number_part = 4
     ///       └ end_integer_part = 3
     ///
     ///    1234e89
-    ///        ╷
-    ///        |
+    ///        ╷  ╷
+    ///        |  └ end_number_part = 7
     ///        └ end_integer_part = end_fractional_part = 4
     /// ```
-    number_part: B,
+    raw: B,
 
     /// The first index not part of the integer part anymore. Since the integer
     /// part is at the start, this is also the length of that part.
@@ -50,6 +50,9 @@
     /// The first index after the fractional part.
     end_fractional_part: usize,
 
+    /// The first index after the whole number part (everything except type suffix).
+    end_number_part: usize,
+
     /// Optional type suffix.
     type_suffix: Option<FloatType>,
 }
@@ -66,7 +69,24 @@
     /// input is invalid or represents a different kind of literal.
     pub fn parse(s: B) -> Result<Self, ParseError> {
         match first_byte_or_empty(&s)? {
-            b'0'..=b'9' => Self::parse_impl(s),
+            b'0'..=b'9' => {
+                // TODO: simplify once RFC 2528 is stabilized
+                let FloatLit {
+                    end_integer_part,
+                    end_fractional_part,
+                    end_number_part,
+                    type_suffix,
+                    ..
+                } = parse_impl(&s)?;
+
+                Ok(Self {
+                    raw: s,
+                    end_integer_part,
+                    end_fractional_part,
+                    end_number_part,
+                    type_suffix,
+                })
+            },
             _ => Err(perr(0, DoesNotStartWithDigit)),
         }
     }
@@ -76,12 +96,12 @@
     /// floating point value, you need to parse this string, e.g. with
     /// `f32::from_str` or an external crate.
     pub fn number_part(&self) -> &str {
-        &self.number_part
+        &(*self.raw)[..self.end_number_part]
     }
 
     /// Returns the non-empty integer part of this literal.
     pub fn integer_part(&self) -> &str {
-        &(*self.number_part)[..self.end_integer_part]
+        &(*self.raw)[..self.end_integer_part]
     }
 
     /// Returns the optional fractional part of this literal. Does not include
@@ -91,14 +111,14 @@
         if self.end_integer_part == self.end_fractional_part {
             None
         } else {
-            Some(&(*self.number_part)[self.end_integer_part + 1..self.end_fractional_part])
+            Some(&(*self.raw)[self.end_integer_part + 1..self.end_fractional_part])
         }
     }
 
     /// Optional exponent part. Might be empty if there was no exponent part in
     /// the input. Includes the `e` or `E` at the beginning.
     pub fn exponent_part(&self) -> &str {
-        &(*self.number_part)[self.end_fractional_part..]
+        &(*self.raw)[self.end_fractional_part..self.end_number_part]
     }
 
     /// The optional type suffix.
@@ -106,70 +126,14 @@
         self.type_suffix
     }
 
-    /// Precondition: first byte of string has to be in `b'0'..=b'9'`.
-    pub(crate) fn parse_impl(input: B) -> Result<Self, ParseError> {
-        // Integer part.
-        let end_integer_part = end_dec_digits(&input);
-        let rest = &input[end_integer_part..];
+    /// Returns the raw input that was passed to `parse`.
+    pub fn raw_input(&self) -> &str {
+        &self.raw
+    }
 
-
-        // Fractional part.
-        let end_fractional_part = if rest.as_bytes().get(0) == Some(&b'.') {
-            // The fractional part must not start with `_`.
-            if rest.as_bytes().get(1) == Some(&b'_') {
-                return Err(perr(end_integer_part + 1, UnexpectedChar));
-            }
-
-            end_dec_digits(&rest[1..]) + 1 + end_integer_part
-        } else {
-            end_integer_part
-        };
-        let rest = &input[end_fractional_part..];
-
-        // If we have a period that is not followed by decimal digits, the
-        // literal must end now.
-        if end_integer_part + 1 == end_fractional_part && !rest.is_empty() {
-            return Err(perr(end_integer_part + 1, UnexpectedChar));
-        }
-
-
-        // Optional exponent.
-        let end_number_part = if rest.starts_with('e') || rest.starts_with('E') {
-            // Strip single - or + sign at the beginning.
-            let exp_number_start = match rest.as_bytes().get(1) {
-                Some(b'-') | Some(b'+') => 2,
-                _ => 1,
-            };
-
-            // Find end of exponent and make sure there is at least one digit.
-            let end_exponent = end_dec_digits(&rest[exp_number_start..]) + exp_number_start;
-            if !rest[exp_number_start..end_exponent].bytes().any(|b| matches!(b, b'0'..=b'9')) {
-                return Err(perr(
-                    end_fractional_part..end_fractional_part + end_exponent,
-                    NoExponentDigits,
-                ));
-            }
-
-            end_exponent + end_fractional_part
-        } else {
-            end_fractional_part
-        };
-
-
-        // Type suffix
-        let type_suffix = match &input[end_number_part..] {
-            "" => None,
-            "f32" => Some(FloatType::F32),
-            "f64" => Some(FloatType::F64),
-            _ => return Err(perr(end_number_part..input.len(), InvalidFloatTypeSuffix)),
-        };
-
-        Ok(Self {
-            number_part: input.cut(0..end_number_part),
-            end_integer_part,
-            end_fractional_part,
-            type_suffix,
-        })
+    /// Returns the raw input that was passed to `parse`, potentially owned.
+    pub fn into_raw_input(self) -> B {
+        self.raw
     }
 }
 
@@ -178,9 +142,10 @@
     /// `Self`.
     pub fn to_owned(&self) -> FloatLit<String> {
         FloatLit {
-            number_part: self.number_part.to_owned(),
+            raw: self.raw.to_owned(),
             end_integer_part: self.end_integer_part,
             end_fractional_part: self.end_fractional_part,
+            end_number_part: self.end_number_part,
             type_suffix: self.type_suffix,
         }
     }
@@ -188,15 +153,77 @@
 
 impl<B: Buffer> fmt::Display for FloatLit<B> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let suffix = match self.type_suffix {
-            None => "",
-            Some(FloatType::F32) => "f32",
-            Some(FloatType::F64) => "f64",
-        };
-        write!(f, "{}{}", self.number_part(), suffix)
+        write!(f, "{}", &*self.raw)
     }
 }
 
+/// Precondition: first byte of string has to be in `b'0'..=b'9'`.
+#[inline(never)]
+pub(crate) fn parse_impl(input: &str) -> Result<FloatLit<&str>, ParseError> {
+    // Integer part.
+    let end_integer_part = end_dec_digits(input.as_bytes());
+    let rest = &input[end_integer_part..];
+
+
+    // Fractional part.
+    let end_fractional_part = if rest.as_bytes().get(0) == Some(&b'.') {
+        // The fractional part must not start with `_`.
+        if rest.as_bytes().get(1) == Some(&b'_') {
+            return Err(perr(end_integer_part + 1, UnexpectedChar));
+        }
+
+        end_dec_digits(rest[1..].as_bytes()) + 1 + end_integer_part
+    } else {
+        end_integer_part
+    };
+    let rest = &input[end_fractional_part..];
+
+    // If we have a period that is not followed by decimal digits, the
+    // literal must end now.
+    if end_integer_part + 1 == end_fractional_part && !rest.is_empty() {
+        return Err(perr(end_integer_part + 1, UnexpectedChar));
+    }
+
+
+    // Optional exponent.
+    let end_number_part = if rest.starts_with('e') || rest.starts_with('E') {
+        // Strip single - or + sign at the beginning.
+        let exp_number_start = match rest.as_bytes().get(1) {
+            Some(b'-') | Some(b'+') => 2,
+            _ => 1,
+        };
+
+        // Find end of exponent and make sure there is at least one digit.
+        let end_exponent = end_dec_digits(rest[exp_number_start..].as_bytes()) + exp_number_start;
+        if !rest[exp_number_start..end_exponent].bytes().any(|b| matches!(b, b'0'..=b'9')) {
+            return Err(perr(
+                end_fractional_part..end_fractional_part + end_exponent,
+                NoExponentDigits,
+            ));
+        }
+
+        end_exponent + end_fractional_part
+    } else {
+        end_fractional_part
+    };
+
+
+    // Type suffix
+    let type_suffix = match &input[end_number_part..] {
+        "" => None,
+        "f32" => Some(FloatType::F32),
+        "f64" => Some(FloatType::F64),
+        _ => return Err(perr(end_number_part..input.len(), InvalidFloatTypeSuffix)),
+    };
+
+    Ok(FloatLit {
+        raw: input,
+        end_integer_part,
+        end_fractional_part,
+        end_number_part,
+        type_suffix,
+    })
+}
 
 #[cfg(test)]
 mod tests;
diff --git a/src/float/tests.rs b/src/float/tests.rs
index 44f734f..f15af05 100644
--- a/src/float/tests.rs
+++ b/src/float/tests.rs
@@ -1,6 +1,6 @@
 use crate::{
     Literal, ParseError,
-    test_util::assert_parse_ok_eq,
+    test_util::{assert_parse_ok_eq, assert_roundtrip},
 };
 use super::{FloatLit, FloatType};
 
@@ -16,9 +16,10 @@
     ($intpart:literal $fracpart:literal $exppart:literal $suffix:tt) => {
         let input = concat!($intpart, $fracpart, $exppart, check!(@stringify_suffix $suffix));
         let expected_float = FloatLit {
-            number_part: concat!($intpart, $fracpart, $exppart),
+            raw: input,
             end_integer_part: $intpart.len(),
             end_fractional_part: $intpart.len() + $fracpart.len(),
+            end_number_part: $intpart.len() + $fracpart.len() + $exppart.len(),
             type_suffix: check!(@ty $suffix),
         };
 
@@ -26,7 +27,7 @@
             input, FloatLit::parse(input), expected_float.clone(), "FloatLit::parse");
         assert_parse_ok_eq(
             input, Literal::parse(input), Literal::Float(expected_float), "Literal::parse");
-
+        assert_roundtrip(expected_float.to_owned(), input);
     };
     (@ty f32) => { Some(FloatType::F32) };
     (@ty f64) => { Some(FloatType::F64) };
diff --git a/src/impls.rs b/src/impls.rs
index 251f350..61a314d 100644
--- a/src/impls.rs
+++ b/src/impls.rs
@@ -16,6 +16,15 @@
     };
 }
 
+/// Like `helper!` but without reference types.
+macro_rules! helper_no_refs {
+    ($callback:ident, $($input:tt)*) => {
+        $callback!([proc_macro::] => $($input)*);
+        #[cfg(feature = "proc-macro2")]
+        $callback!([proc_macro2::] => $($input)*);
+    };
+}
+
 
 // ==============================================================================================
 // ===== `From<*Lit> for Literal`
@@ -101,7 +110,7 @@
 
 
 // ==============================================================================================
-// ===== `TryFrom<pm::Literal> for *Lit` and `TryFrom<pm::TokenTree> for *Lit`
+// ===== `TryFrom<pm::Literal>`, `TryFrom<pm::TokenTree>` for non-bool `*Lit`
 // ==============================================================================================
 
 fn kind_of(lit: &Literal<String>) -> TokenKind {
@@ -165,6 +174,43 @@
 helper!(impl_for_specific_lit, crate::ByteLit<String>, Byte, ByteLit);
 helper!(impl_for_specific_lit, crate::ByteStringLit<String>, ByteString, ByteStringLit);
 
+
+// ==============================================================================================
+// ===== `From<*Lit> for pm::Literal`
+// ==============================================================================================
+
+macro_rules! impl_specific_lit_to_pm_lit {
+    ([$($prefix:tt)*] => $ty:ident, $variant:ident, $kind:ident) => {
+        impl<B: crate::Buffer> From<crate::$ty<B>> for $($prefix)* Literal {
+            fn from(l: crate::$ty<B>) -> Self {
+                // This should never fail: an input that is parsed successfuly
+                // as one of our literal types should always parse as a
+                // proc_macro literal as well!
+                l.raw_input().parse().unwrap_or_else(|e| {
+                    panic!(
+                        "failed to parse `{}` as `{}`: {}",
+                        l.raw_input(),
+                        std::any::type_name::<Self>(),
+                        e,
+                    )
+                })
+            }
+        }
+    };
+}
+
+helper_no_refs!(impl_specific_lit_to_pm_lit, IntegerLit, Integer, IntegerLit);
+helper_no_refs!(impl_specific_lit_to_pm_lit, FloatLit, Float, FloatLit);
+helper_no_refs!(impl_specific_lit_to_pm_lit, CharLit, Char, CharLit);
+helper_no_refs!(impl_specific_lit_to_pm_lit, StringLit, String, StringLit);
+helper_no_refs!(impl_specific_lit_to_pm_lit, ByteLit, Byte, ByteLit);
+helper_no_refs!(impl_specific_lit_to_pm_lit, ByteStringLit, ByteString, ByteStringLit);
+
+
+// ==============================================================================================
+// ===== `TryFrom<pm::TokenTree> for BoolLit`
+// ==============================================================================================
+
 macro_rules! impl_from_tt_for_bool {
     ([$($prefix:tt)*] => ) => {
         impl TryFrom<$($prefix)* TokenTree> for crate::BoolLit {
@@ -195,6 +241,22 @@
 
 helper!(impl_from_tt_for_bool, );
 
+// ==============================================================================================
+// ===== `From<BoolLit> for pm::Ident`
+// ==============================================================================================
+
+macro_rules! impl_bool_lit_to_pm_lit {
+    ([$($prefix:tt)*] => ) => {
+        impl From<crate::BoolLit> for $($prefix)* Ident {
+            fn from(l: crate::BoolLit) -> Self {
+                Self::new(l.as_str(), $($prefix)* Span::call_site())
+            }
+        }
+    };
+}
+
+helper_no_refs!(impl_bool_lit_to_pm_lit, );
+
 
 mod tests {
     //! # Tests
diff --git a/src/integer/mod.rs b/src/integer/mod.rs
index 52519a6..79f7e55 100644
--- a/src/integer/mod.rs
+++ b/src/integer/mod.rs
@@ -25,8 +25,12 @@
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[non_exhaustive]
 pub struct IntegerLit<B: Buffer> {
+    raw: B,
+    // First index of the main number part (after the base prefix).
+    start_main_part: usize,
+    // First index not part of the main number part.
+    end_main_part: usize,
     base: IntegerBase,
-    main_part: B,
     type_suffix: Option<IntegerType>,
 }
 
@@ -74,7 +78,24 @@
     /// invalid or represents a different kind of literal.
     pub fn parse(input: B) -> Result<Self, ParseError> {
         match first_byte_or_empty(&input)? {
-            digit @ b'0'..=b'9' => Self::parse_impl(input, digit),
+            digit @ b'0'..=b'9' => {
+                // TODO: simplify once RFC 2528 is stabilized
+                let IntegerLit {
+                    start_main_part,
+                    end_main_part,
+                    base,
+                    type_suffix,
+                    ..
+                } =  parse_impl(&input, digit)?;
+
+                Ok(Self {
+                    raw: input,
+                    start_main_part,
+                    end_main_part,
+                    base,
+                    type_suffix,
+                })
+            },
             _ => Err(perr(0, DoesNotStartWithDigit)),
         }
     }
@@ -93,7 +114,7 @@
         };
 
         let mut acc = N::from_small_number(0);
-        for digit in self.main_part.bytes() {
+        for digit in self.raw_main_part().bytes() {
             if digit == b'_' {
                 continue;
             }
@@ -118,7 +139,7 @@
     /// The main part containing the digits and potentially `_`. Do not try to
     /// parse this directly as that would ignore the base!
     pub fn raw_main_part(&self) -> &str {
-        &self.main_part
+        &(*self.raw)[self.start_main_part..self.end_main_part]
     }
 
     /// The type suffix, if specified.
@@ -126,73 +147,14 @@
         self.type_suffix
     }
 
-    /// Precondition: first byte of string has to be in `b'0'..=b'9'`.
-    pub(crate) fn parse_impl(input: B, first: u8) -> Result<Self, ParseError> {
-        // Figure out base and strip prefix base, if it exists.
-        let (end_prefix, base) = match (first, input.as_bytes().get(1)) {
-            (b'0', Some(b'b')) => (2, IntegerBase::Binary),
-            (b'0', Some(b'o')) => (2, IntegerBase::Octal),
-            (b'0', Some(b'x')) => (2, IntegerBase::Hexadecimal),
+    /// Returns the raw input that was passed to `parse`.
+    pub fn raw_input(&self) -> &str {
+        &self.raw
+    }
 
-            // Everything else is treated as decimal. Several cases are caught
-            // by this:
-            // - "123"
-            // - "0"
-            // - "0u8"
-            // - "0r" -> this will error later
-            _ => (0, IntegerBase::Decimal),
-        };
-        let without_prefix = &input[end_prefix..];
-
-        // Find end of main part.
-        let end_main = without_prefix.bytes()
-                .position(|b| !matches!(b, b'0'..=b'9' | b'a'..=b'f' | b'A'..=b'F' | b'_'))
-                .unwrap_or(without_prefix.len());
-        let (main_part, type_suffix) = without_prefix.split_at(end_main);
-
-        // Check for invalid digits and make sure there is at least one valid digit.
-        let invalid_digit_pos = match base {
-            IntegerBase::Binary => main_part.bytes()
-                .position(|b| !matches!(b, b'0' | b'1' | b'_')),
-            IntegerBase::Octal => main_part.bytes()
-                .position(|b| !matches!(b, b'0'..=b'7' | b'_')),
-            IntegerBase::Decimal => main_part.bytes()
-                .position(|b| !matches!(b, b'0'..=b'9' | b'_')),
-            IntegerBase::Hexadecimal => None,
-        };
-
-        if let Some(pos) = invalid_digit_pos {
-            return Err(perr(end_prefix + pos, InvalidDigit));
-        }
-
-        if main_part.bytes().filter(|&b| b != b'_').count() == 0 {
-            return Err(perr(end_prefix..end_prefix + end_main, NoDigits));
-        }
-
-
-        // Parse type suffix
-        let type_suffix = match type_suffix {
-            "" => None,
-            "u8" => Some(IntegerType::U8),
-            "u16" => Some(IntegerType::U16),
-            "u32" => Some(IntegerType::U32),
-            "u64" => Some(IntegerType::U64),
-            "u128" => Some(IntegerType::U128),
-            "usize" => Some(IntegerType::Usize),
-            "i8" => Some(IntegerType::I8),
-            "i16" => Some(IntegerType::I16),
-            "i32" => Some(IntegerType::I32),
-            "i64" => Some(IntegerType::I64),
-            "i128" => Some(IntegerType::I128),
-            "isize" => Some(IntegerType::Isize),
-            _ => return Err(perr(end_main + end_prefix..input.len(), InvalidIntegerTypeSuffix)),
-        };
-
-        Ok(Self {
-            base,
-            main_part: input.cut(end_prefix..end_main + end_prefix),
-            type_suffix,
-        })
+    /// Returns the raw input that was passed to `parse`, potentially owned.
+    pub fn into_raw_input(self) -> B {
+        self.raw
     }
 }
 
@@ -201,8 +163,10 @@
     /// `Self`.
     pub fn to_owned(&self) -> IntegerLit<String> {
         IntegerLit {
+            raw: self.raw.to_owned(),
+            start_main_part: self.start_main_part,
+            end_main_part: self.end_main_part,
             base: self.base,
-            main_part: self.main_part.to_owned(),
             type_suffix: self.type_suffix,
         }
     }
@@ -210,22 +174,7 @@
 
 impl<B: Buffer> fmt::Display for IntegerLit<B> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let suffix = match self.type_suffix {
-            None => "",
-            Some(IntegerType::U8) => "u8",
-            Some(IntegerType::U16) => "u16",
-            Some(IntegerType::U32) => "u32",
-            Some(IntegerType::U64) => "u64",
-            Some(IntegerType::U128) => "u128",
-            Some(IntegerType::Usize) => "usize",
-            Some(IntegerType::I8) => "i8",
-            Some(IntegerType::I16) => "i16",
-            Some(IntegerType::I32) => "i32",
-            Some(IntegerType::I64) => "i64",
-            Some(IntegerType::I128) => "i128",
-            Some(IntegerType::Isize) => "isize",
-        };
-        write!(f, "{}{}{}", self.base.prefix(), &*self.main_part, suffix)
+        write!(f, "{}", &*self.raw)
     }
 }
 
@@ -280,6 +229,78 @@
     pub trait Sealed {}
 }
 
+/// Precondition: first byte of string has to be in `b'0'..=b'9'`.
+#[inline(never)]
+pub(crate) fn parse_impl(input: &str, first: u8) -> Result<IntegerLit<&str>, ParseError> {
+    // Figure out base and strip prefix base, if it exists.
+    let (end_prefix, base) = match (first, input.as_bytes().get(1)) {
+        (b'0', Some(b'b')) => (2, IntegerBase::Binary),
+        (b'0', Some(b'o')) => (2, IntegerBase::Octal),
+        (b'0', Some(b'x')) => (2, IntegerBase::Hexadecimal),
+
+        // Everything else is treated as decimal. Several cases are caught
+        // by this:
+        // - "123"
+        // - "0"
+        // - "0u8"
+        // - "0r" -> this will error later
+        _ => (0, IntegerBase::Decimal),
+    };
+    let without_prefix = &input[end_prefix..];
+
+    // Find end of main part.
+    let end_main = without_prefix.bytes()
+            .position(|b| !matches!(b, b'0'..=b'9' | b'a'..=b'f' | b'A'..=b'F' | b'_'))
+            .unwrap_or(without_prefix.len());
+    let (main_part, type_suffix) = without_prefix.split_at(end_main);
+
+    // Check for invalid digits and make sure there is at least one valid digit.
+    let invalid_digit_pos = match base {
+        IntegerBase::Binary => main_part.bytes()
+            .position(|b| !matches!(b, b'0' | b'1' | b'_')),
+        IntegerBase::Octal => main_part.bytes()
+            .position(|b| !matches!(b, b'0'..=b'7' | b'_')),
+        IntegerBase::Decimal => main_part.bytes()
+            .position(|b| !matches!(b, b'0'..=b'9' | b'_')),
+        IntegerBase::Hexadecimal => None,
+    };
+
+    if let Some(pos) = invalid_digit_pos {
+        return Err(perr(end_prefix + pos, InvalidDigit));
+    }
+
+    if main_part.bytes().filter(|&b| b != b'_').count() == 0 {
+        return Err(perr(end_prefix..end_prefix + end_main, NoDigits));
+    }
+
+
+    // Parse type suffix
+    let type_suffix = match type_suffix {
+        "" => None,
+        "u8" => Some(IntegerType::U8),
+        "u16" => Some(IntegerType::U16),
+        "u32" => Some(IntegerType::U32),
+        "u64" => Some(IntegerType::U64),
+        "u128" => Some(IntegerType::U128),
+        "usize" => Some(IntegerType::Usize),
+        "i8" => Some(IntegerType::I8),
+        "i16" => Some(IntegerType::I16),
+        "i32" => Some(IntegerType::I32),
+        "i64" => Some(IntegerType::I64),
+        "i128" => Some(IntegerType::I128),
+        "isize" => Some(IntegerType::Isize),
+        _ => return Err(perr(end_main + end_prefix..input.len(), InvalidIntegerTypeSuffix)),
+    };
+
+    Ok(IntegerLit {
+        raw: input,
+        start_main_part: end_prefix,
+        end_main_part: end_main + end_prefix,
+        base,
+        type_suffix,
+    })
+}
+
 
 #[cfg(test)]
 mod tests;
diff --git a/src/integer/tests.rs b/src/integer/tests.rs
index dc8c861..1656345 100644
--- a/src/integer/tests.rs
+++ b/src/integer/tests.rs
@@ -1,7 +1,7 @@
 use std::fmt::{Debug, Display};
 use crate::{
     FromIntegerLiteral, Literal, IntegerLit, IntegerType as Ty, IntegerBase, IntegerBase::*,
-    test_util::assert_parse_ok_eq,
+    test_util::{assert_parse_ok_eq, assert_roundtrip},
 };
 
 
@@ -15,11 +15,18 @@
     main_part: &str,
     type_suffix: Option<Ty>,
 ) {
-    let expected_integer = IntegerLit { base, main_part, type_suffix };
+    let expected_integer = IntegerLit {
+        raw: input,
+        start_main_part: base.prefix().len(),
+        end_main_part: base.prefix().len() + main_part.len(),
+        base,
+        type_suffix
+    };
     assert_parse_ok_eq(
         input, IntegerLit::parse(input), expected_integer.clone(), "IntegerLit::parse");
     assert_parse_ok_eq(
         input, Literal::parse(input), Literal::Integer(expected_integer), "Literal::parse");
+    assert_roundtrip(expected_integer.to_owned(), input);
 
     let actual_value = IntegerLit::parse(input)
         .unwrap()
diff --git a/src/parse.rs b/src/parse.rs
index 07026ed..a0266da 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -16,7 +16,7 @@
 impl<B: Buffer> Literal<B> {
     /// Parses the given input as a Rust literal.
     pub fn parse(input: B) -> Result<Self, ParseError> {
-        let first = first_byte_or_empty(&input)?;
+        let (first, rest) = input.as_bytes().split_first().ok_or(perr(None, Empty))?;
         let second = input.as_bytes().get(1).copied();
 
         match first {
@@ -24,32 +24,32 @@
             b't' if &*input == "true" => Ok(Self::Bool(BoolLit::True)),
 
             // A number literal (integer or float).
-            digit @ b'0'..=b'9' => {
+            b'0'..=b'9' => {
                 // To figure out whether this is a float or integer, we do some
                 // quick inspection here. Yes, this is technically duplicate
                 // work with what is happening in the integer/float parse
                 // methods, but it makes the code way easier for now and won't
                 // be a huge performance loss.
-                let end = 1 + end_dec_digits(&input[1..]);
+                let end = 1 + end_dec_digits(rest);
                 match input.as_bytes().get(end) {
                     // Potential chars in integer literals: b, o, x for base; u
                     // and i for type suffix.
                     None | Some(b'b') | Some(b'o') | Some(b'x') | Some(b'u') | Some(b'i')
-                        => IntegerLit::parse_impl(input, digit).map(Literal::Integer),
+                        => IntegerLit::parse(input).map(Literal::Integer),
 
                     // Potential chars for float literals: `.` as fractional
                     // period, e and E as exponent start and f as type suffix.
                     Some(b'.') | Some(b'e') | Some(b'E') | Some(b'f')
-                        => FloatLit::parse_impl(input).map(Literal::Float),
+                        => FloatLit::parse(input).map(Literal::Float),
 
                     _ => Err(perr(end, UnexpectedChar)),
                 }
             },
 
-            b'\'' => CharLit::parse_impl(input).map(Literal::Char),
+            b'\'' => CharLit::parse(input).map(Literal::Char),
             b'"' | b'r' => StringLit::parse_impl(input).map(Literal::String),
 
-            b'b' if second == Some(b'\'') => ByteLit::parse_impl(input).map(Literal::Byte),
+            b'b' if second == Some(b'\'') => ByteLit::parse(input).map(Literal::Byte),
             b'b' if second == Some(b'r') || second == Some(b'"')
                 => ByteStringLit::parse_impl(input).map(Literal::ByteString),
 
@@ -65,8 +65,8 @@
 
 /// Returns the index of the first non-underscore, non-decimal digit in `input`,
 /// or the `input.len()` if all characters are decimal digits.
-pub(crate) fn end_dec_digits(input: &str) -> usize {
-    input.bytes()
+pub(crate) fn end_dec_digits(input: &[u8]) -> usize {
+    input.iter()
         .position(|b| !matches!(b, b'_' | b'0'..=b'9'))
         .unwrap_or(input.len())
 }
diff --git a/src/string/mod.rs b/src/string/mod.rs
index a21f7a7..ab1cc3f 100644
--- a/src/string/mod.rs
+++ b/src/string/mod.rs
@@ -59,6 +59,16 @@
         self.num_hashes.is_some()
     }
 
+    /// Returns the raw input that was passed to `parse`.
+    pub fn raw_input(&self) -> &str {
+        &self.raw
+    }
+
+    /// Returns the raw input that was passed to `parse`, potentially owned.
+    pub fn into_raw_input(self) -> B {
+        self.raw
+    }
+
     /// The range within `self.raw` that excludes the quotes and potential `r#`.
     fn inner_range(&self) -> Range<usize> {
         match self.num_hashes {
diff --git a/src/string/tests.rs b/src/string/tests.rs
index 8d8882e..51519ab 100644
--- a/src/string/tests.rs
+++ b/src/string/tests.rs
@@ -1,4 +1,4 @@
-use crate::{Literal, StringLit, test_util::assert_parse_ok_eq};
+use crate::{Literal, StringLit, test_util::{assert_parse_ok_eq, assert_roundtrip}};
 
 // ===== Utility functions =======================================================================
 
@@ -13,9 +13,10 @@
 
         assert_parse_ok_eq(input, StringLit::parse(input), expected.clone(), "StringLit::parse");
         assert_parse_ok_eq(
-            input, Literal::parse(input), Literal::String(expected), "Literal::parse");
+            input, Literal::parse(input), Literal::String(expected.clone()), "Literal::parse");
         assert_eq!(StringLit::parse(input).unwrap().value(), $lit);
         assert_eq!(StringLit::parse(input).unwrap().into_value(), $lit);
+        assert_roundtrip(expected.into_owned(), input);
     };
 }
 
diff --git a/src/test_util.rs b/src/test_util.rs
index dc7a1f6..fd284e9 100644
--- a/src/test_util.rs
+++ b/src/test_util.rs
@@ -39,6 +39,53 @@
     }
 }
 
+// This is not ideal, but to perform this check we need `proc-macro2`. So we
+// just don't do anything if that feature is not enabled.
+#[cfg(not(feature = "proc-macro2"))]
+pub(crate) fn assert_roundtrip<T>(_: T, _: &str) {}
+
+#[cfg(feature = "proc-macro2")]
+#[track_caller]
+pub(crate) fn assert_roundtrip<T>(ours: T, input: &str)
+where
+    T: std::convert::TryFrom<proc_macro2::Literal> + fmt::Debug + PartialEq + Clone,
+    proc_macro2::Literal: From<T>,
+    <T as std::convert::TryFrom<proc_macro2::Literal>>::Error: std::fmt::Display,
+{
+    let pm_lit = input.parse::<proc_macro2::Literal>()
+        .expect("failed to parse input as proc_macro2::Literal");
+    let t_name = std::any::type_name::<T>();
+
+    // Unfortunately, `proc_macro2::Literal` does not implement `PartialEq`, so
+    // this is the next best thing.
+    if proc_macro2::Literal::from(ours.clone()).to_string() != pm_lit.to_string() {
+        panic!(
+            "Converting {} to proc_macro2::Literal has unexpected result:\
+                \nconverted: {:?}\nexpected:  {:?}",
+            t_name,
+            proc_macro2::Literal::from(ours),
+            pm_lit,
+        );
+    }
+
+    match T::try_from(pm_lit) {
+        Err(e) => {
+            panic!("Trying to convert proc_macro2::Literal to {} results in error: {}", t_name, e);
+        }
+        Ok(res) => {
+            if res != ours {
+                panic!(
+                    "Converting proc_macro2::Literal to {} has unexpected result:\
+                        \nactual:    {:?}\nexpected:  {:?}",
+                    t_name,
+                    res,
+                    ours,
+                );
+            }
+        }
+    }
+}
+
 macro_rules! assert_err {
     ($ty:ident, $input:literal, $kind:ident, $( $span:tt )+ ) => {
         assert_err_single!($ty::parse($input), $kind, $($span)+);