Struct parsel::util::TokenStreamFormatter

pub struct TokenStreamFormatter<S, W> { /* private fields */ }

Helper type for correctly and reasonably “pretty”-printing any TokenStream in a grammar- and language-agnostic way. This mostly means dealing with parentheses, so that nested structures don’t end up on one single long line.

Of course, it is not possible to perform pretty-printing in a completely generic manner, but the primary purpose of this mechanism is not that – it’s merely trying to be a useful debugging tool, of which the results are less unnecessarily verbose, and therefore easier to read, than the output of #[derive(Debug)].

use parsel::util::TokenStreamFormatter;
use parsel::quote::quote;

let ts = quote!{
    [
        [
            7.43 * {
                zzz (
                    3333 + "52" - 'a / [
                        foo bar || &baz;
                    ]
                ) != 5;
                ww;
                6 <<= 78 >>= 951,
                $ foo $bar #![attribute]
            },
            x, y
        ]
    ]
};

let mut string = String::new();
let mut fmt = TokenStreamFormatter::new(&mut string);
fmt.write(ts)?;

assert_eq!(string, str::trim(r#"
[
    [
        7.43 * {
            zzz (
                3333 + "52" - 'a / [
                    foo bar || & baz ;
                ]
            )
            != 5 ;
            ww ;
            6 <<= 78 >>= 951 ,
            $ foo $ bar # ! [
                attribute
            ]
        }
        ,
        x ,
        y
    ]
]
"#));

Implementations

impl<S, W> TokenStreamFormatter<S, W> where
    S: AsRef<str>, 

pub fn with_indent(indent_string: S, writer: W) -> Result<Self>

Constructor for indenting with arbitrary whitespace.

This returns an error when non-whitespace characters are present in the indentation.

let ok = TokenStreamFormatter::with_indent("  \t", Cursor::new(&[] as &[u8]));
assert!(ok.is_ok());

let err = TokenStreamFormatter::with_indent("  not ws ", Cursor::new(&[] as &[u8]));
assert!(err.is_err());

impl<S, W> TokenStreamFormatter<S, W> where
    S: AsRef<str>,
    W: Write, 

pub fn write(&mut self, stream: TokenStream) -> Result

pub fn write_node<T>(&mut self, node: &T) -> Result where
    T: ?Sized + ToTokens, 

impl<W> TokenStreamFormatter<&'static str, W>

pub const fn new(writer: W) -> Self

Trait Implementations

impl<S: Clone, W: Clone> Clone for TokenStreamFormatter<S, W>

fn clone(&self) -> TokenStreamFormatter<S, W>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug, W: Debug> Debug for TokenStreamFormatter<S, W>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Hash, W: Hash> Hash for TokenStreamFormatter<S, W>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<S: PartialEq, W: PartialEq> PartialEq<TokenStreamFormatter<S, W>> for TokenStreamFormatter<S, W>

fn eq(&self, other: &TokenStreamFormatter<S, W>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &TokenStreamFormatter<S, W>) -> bool

This method tests for !=.

impl<S: Copy, W: Copy> Copy for TokenStreamFormatter<S, W>

impl<S: Eq, W: Eq> Eq for TokenStreamFormatter<S, W>

impl<S, W> StructuralEq for TokenStreamFormatter<S, W>

impl<S, W> StructuralPartialEq for TokenStreamFormatter<S, W>