Add new Literal::str_value, Literal::cstr_value and Literal::byte_str_value methods

Author: GuillaumeGomez

Cargo.toml

@@ -30,6 +30,7 @@ features = ["span-locations"]
 
 [dependencies]
 unicode-ident = "1.0"
+rustc-literal-escaper = "0.0.5"
 
 [dev-dependencies]
 flate2 = "1.0"

src/lib.rs

@@ -88,6 +88,7 @@
 #![cfg_attr(any(proc_macro_span, super_unstable), feature(proc_macro_span))]
 #![cfg_attr(super_unstable, feature(proc_macro_def_site))]
 #![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(procmacro2_semver_exempt, feature(proc_macro_value))]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![allow(
     clippy::cast_lossless,
@@ -1271,6 +1272,98 @@ impl Literal {
     pub unsafe fn from_str_unchecked(repr: &str) -> Self {
         Literal::_new(unsafe { imp::Literal::from_str_unchecked(repr) })
     }
+
+    /// Returns the unescaped string value if the current literal is a string or a string literal.
+    #[cfg(procmacro2_semver_exempt)]
+    pub fn str_value(&self) -> Result<String, proc_macro::ConversionErrorKind> {
+        match self.inner {
+            imp::Literal::Compiler(ref compiler_lit) => compiler_lit.str_value(),
+            imp::Literal::Fallback(ref fallback) => {
+                if !fallback.repr.starts_with('"') {
+                    return Err(proc_macro::ConversionErrorKind::InvalidLiteralKind);
+                }
+                let mut error = None;
+                let mut buf = String::with_capacity(fallback.repr.len());
+                rustc_literal_escaper::unescape_str(&fallback.repr, |_, res| match res {
+                    Ok(c) => buf.push(c),
+                    Err(err) => {
+                        if err.is_fatal() {
+                            error = Some(ConversionErrorKind::FailedToUnescape(err));
+                        }
+                    }
+                });
+                if let Some(error) = error {
+                    Err(error)
+                } else {
+                    Ok(buf)
+                }
+            }
+        }
+    }
+
+    /// Returns the unescaped string value if the current literal is a c-string or a c-string
+    /// literal.
+    #[cfg(procmacro2_semver_exempt)]
+    pub fn cstr_value(&self) -> Result<Vec<u8>, proc_macro::ConversionErrorKind> {
+        match self.inner {
+            imp::Literal::Compiler(ref compiler_lit) => compiler_lit.cstr_value(),
+            imp::Literal::Fallback(ref fallback) => {
+                if !fallback.repr.starts_with('c') {
+                    return Err(proc_macro::ConversionErrorKind::InvalidLiteralKind);
+                }
+                let mut error = None;
+                let mut buf = Vec::with_capacity(symbol.len());
+
+                rustc_literal_escaper::unescape_c_str(symbol, |_span, res| match res {
+                    Ok(MixedUnit::Char(c)) => {
+                        buf.extend_from_slice(c.get().encode_utf8(&mut [0; 4]).as_bytes())
+                    }
+                    Ok(MixedUnit::HighByte(b)) => buf.push(b.get()),
+                    Err(err) => {
+                        if err.is_fatal() {
+                            error = Some(ConversionErrorKind::FailedToUnescape(err));
+                        }
+                    }
+                });
+                if let Some(error) = error {
+                    Err(error)
+                } else {
+                    buf.push(0);
+                    Ok(buf)
+                }
+            }
+        }
+    }
+
+    /// Returns the unescaped string value if the current literal is a byte string or a byte string
+    /// literal.
+    #[cfg(procmacro2_semver_exempt)]
+    pub fn byte_str_value(&self) -> Result<Vec<u8>, proc_macro::ConversionErrorKind> {
+        match self.inner {
+            imp::Literal::Compiler(ref compiler_lit) => compiler_lit.byte_str_value(),
+            imp::Literal::Fallback(ref fallback) => {
+                if !fallback.repr.starts_with('c') {
+                    return Err(proc_macro::ConversionErrorKind::InvalidLiteralKind);
+                }
+                let mut error = None;
+                let mut buf = Vec::with_capacity(symbol.len());
+
+                rustc_literal_escaper::unescape_byte_str(symbol, |_span, res| match res {
+                    Ok(c) => buf.push(c),
+                    Err(err) => {
+                        if err.is_fatal() {
+                            error = Some(ConversionErrorKind::FailedToUnescape(err));
+                        }
+                    }
+                });
+                if let Some(error) = error {
+                    Err(error)
+                } else {
+                    Ok(buf)
+                }
+            }
+        }
+    }
 }
 
 impl FromStr for Literal {