1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
//! Helper functions, types and macros that didn't fit anywhere else.
use std::fmt::{self, Debug, Display, Formatter};
use crate::{Error, Span, Spanned};
/// Similar to `syn::parse_quote!`, but instead of panicking, it returns an
/// `Err` if the inferred type fails to parse from the specified token stream.
///
/// ```rust
/// use core::iter::FromIterator;
/// use parsel::{try_parse_quote, Result};
/// use parsel::ast::{Lit, Many};
///
/// fn try_parse_literals(bit: bool, number: u64) -> Result<Many<Lit>> {
/// let ast: Many<Lit> = try_parse_quote!(#bit "some text" #number);
/// Ok(ast)
/// }
///
/// let actual: Many<Lit> = try_parse_literals(true, 76192)?;
/// let expected: Many<Lit> = Many::from_iter([
/// Lit::from(true),
/// Lit::from("some text"),
/// Lit::from(76192_u128),
/// ]);
///
/// assert_eq!(actual, expected);
/// #
/// # Result::<()>::Ok(())
/// ```
#[macro_export]
macro_rules! try_parse_quote {
($($tt:tt)*) => {
match ::parsel::parse2(::parsel::quote::quote!($($tt)*)) {
::parsel::Result::Ok(ast) => ast,
::parsel::Result::Err(error) => {
return ::core::result::Result::Err(
::core::convert::From::from(error)
)
}
}
}
}
/// Similar to `syn::parse_quote_spanned!`, but instead of panicking, it returns
/// an `Err` if the inferred type fails to parse from the specified token stream.
///
/// ```rust
/// use parsel::{parse_str, try_parse_quote_spanned, Result};
/// use parsel::ast::{word, Word, Punctuated};
/// use parsel::ast::token::Comma;
///
/// fn try_parse_words(interp: &str, spanner: &str) -> Result<Punctuated<Word, Comma>> {
/// let interp: Word = parse_str(interp)?;
/// let spanner: Word = parse_str(spanner)?;
///
/// // Interpolated tokens must preserve their own span, whereas
/// // tokens originating from the macro will have the specified span.
/// let ast = try_parse_quote_spanned!{ spanner.span() =>
/// lorem, #interp, ipsum
/// };
///
/// Ok(ast)
/// }
///
/// let interp = "quodsit";
/// let spanner = "this_is_a_long_identifier";
///
/// let actual = try_parse_words(interp, spanner)?;
/// let expected_strings = ["lorem", interp, "ipsum"];
/// let expected: Punctuated<Word, Comma> = expected_strings
/// .iter()
/// .copied()
/// .map(word)
/// .collect();
///
/// let actual_ends: Vec<_> = actual
/// .iter()
/// .map(|w| w.span().end().column)
/// .collect();
/// let expected_ends = vec![spanner.len(), interp.len(), spanner.len()];
///
/// assert_eq!(actual, expected);
/// assert_eq!(actual_ends, expected_ends);
/// #
/// # Result::<()>::Ok(())
/// ```
#[macro_export]
macro_rules! try_parse_quote_spanned {
($span:expr => $($tt:tt)*) => {
match ::parsel::parse2(::parsel::quote::quote_spanned!($span => $($tt)*)) {
::parsel::Result::Ok(ast) => ast,
::parsel::Result::Err(error) => {
return ::core::result::Result::Err(
::core::convert::From::from(error)
)
}
}
}
}
/// Extension trait for formatting the span of AST nodes in a human-readable manner.
pub trait FormatSpan: Spanned {
fn format_span(&self) -> SpanDisplay;
}
impl<T> FormatSpan for T
where
T: ?Sized + Spanned
{
fn format_span(&self) -> SpanDisplay {
SpanDisplay::new(self.span())
}
}
/// Helper type that formats a `Span` in a human-readable way.
#[derive(Clone, Copy, Debug)]
pub struct SpanDisplay {
span: Span,
}
impl SpanDisplay {
pub const fn new(span: Span) -> Self {
SpanDisplay { span }
}
}
impl From<Span> for SpanDisplay {
fn from(span: Span) -> Self {
SpanDisplay::new(span)
}
}
impl Display for SpanDisplay {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
write!(
formatter,
"{start_line}:{start_col}..{end_line}:{end_col}",
start_line = self.span.start().line,
start_col = self.span.start().column + 1, // 0-indexed
end_line = self.span.end().line,
end_col = self.span.end().column, // + 1 - 1: 0-indexed but inclusive
)
}
}
/// Not public API -- runtime helper for `parsel_derive::Parse`.
///
/// Preserves span and message of original error (because they
/// are more specific), but also adds our own, wider context.
#[doc(hidden)]
pub fn chain_error(
cause: &Error,
ty: &str,
member: &str,
) -> Error {
let message = format!(
"error parsing {ty}::{member}, caused by:\n{cause}",
ty = ty,
member = member,
cause = cause,
);
Error::new(cause.span(), message)
}