Crate proc_macro_tool

Some common simple tool for proc-macro impl

There are many methods available for chain calls

What can do:

• Quickly create processors in the style of #foo(...)
• Common methods, such as add, split_puncts, is_ident, as_ident, into_punct, is_joint, as_punct_char and set_spaned etc
• span, set_span traits
• ParseIter, can peek n, and peek jointed puncts

Examples

extern crate proc_macro;
use proc_macro::*;;
use proc_macro_tool::*;

fn index_tt<I>(mut tt: TokenTree, iter: &mut ParseIter<I>) -> Result<TokenTree, TokenStream>
where I: Iterator<Item = TokenTree>,
{
    while let Some((mut span, mut param)) = iter
        .next_if(|tt| tt.is_delimiter_bracket())
        .map(|tt| tt.into_group().unwrap())
        .map(|g| (g.span_close(), g.stream().into_iter()))
    {
        let i = param.next()
            .ok_or_else(|| err!("unexpected token, expected literal", span))?
            .span_as(&mut span)
            .into_literal()
            .map_err(|_| err!("unexpected token, expected literal", span))?
            .to_string()
            .parse()
            .map_err(|e| err!(@("parse number {e}"), span))?;
        let g = tt.into_group()
            .map_err(|t| err!(@("cannot index {t}, e.g [...]"), span))?;
        tt = g.stream().into_iter().nth(i)
            .ok_or_else(|| err!(@("index {i} out of range, of {}", g), span))?
    };
    Ok(tt)
}

Macros

err

return err(msg [, span])

rerr

return rerr(msg [, span])

Structs

ParseIter

Peek n iterator adapter

Enums

TokenKind

Enum to TokenTree variants

Traits

GetSpan

General implementations of TokenTree::span

GroupExt

ParseIterExt

Create ParseIter

PunctExt

PunctsExt

SetSpan

General implementations of TokenTree::set_span

StrExt

Suffixed

Create suffixed Literal

TokenStreamExt

TokenTreeExt

Unsuffixed

Create unsuffixed Literal

WalkExt

Remake each subtree methods

Functions

brace

Like Group::new(Delimiter::Brace, iter)

bracket

Like Group::new(Delimiter::Bracket, iter)

err

Make compile_error! {"..."}

none

Like Group::new(Delimiter::None, iter)

paren

Like Group::new(Delimiter::Parenthesis, iter)

pfunc

Call f on #name(...) #name[...] etc, exclude Delimiter::None

pfunc_lossless

Like pfunc, but it’s lossless when no changes are made

puncts

Make puncts, spacing is last punct spacing

puncts_spanned

Make puncts, spacing is last punct spacing

rerr

Like err(), but use Result

span_setter

Generate a function, set input TokenTree span

stream

Create TokenStream from IntoIterator<Item = TokenTree>

streams

Create TokenStream from IntoIterator<Item = TokenStream>

try_pfunc

Call f on #name(...) #name[...] etc, exclude Delimiter::None

try_pfunc_lossless

Like try_pfunc, but it’s lossless when no changes are made