pformat_macro 0.0.1

Simple format_args!-like macro whose result can be stored for later use
Documentation 
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

use crate::PFormatArgs;
use proc_macro2::Span;
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::spanned::Spanned;
use syn::{Expr, Lit, LitStr, Token};

#[repr(transparent)]
struct FormatStr {
    format: LitStr,
}

impl FormatStr {
    fn split_into_pieces<T: FromIterator<String>>(&self) -> T {
        self.format
            .value()
            .split(&"{}")
            .map(|x| x.to_string())
            .collect()
    }
}

impl From<LitStr> for FormatStr {
    fn from(format: LitStr) -> Self {
        FormatStr { format }
    }
}

impl Parse for FormatStr {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let format: Expr = input.parse()?;
        if let Expr::Lit(format) = format {
            if let Lit::Str(format) = format.lit {
                return Ok(format.into());
            }

            Err(syn::Error::new(
                format.span(),
                "format must be a constant string literal",
            ))
        } else {
            Err(syn::Error::new(
                format.span(),
                "format must be a constant string literal",
            ))
        }
    }
}

type Args = Punctuated<Expr, Token![,]>;

#[repr(transparent)]
struct FormatArgs {
    args: Option<Args>,
}

impl FormatArgs {
    fn len(&self) -> usize {
        match &self.args {
            Some(args) => args.len(),
            None => 0,
        }
    }

    fn span(&self) -> Option<Span> {
        self.args.as_ref().map(|args| args.span())
    }

    fn span_or_default(&self) -> Span {
        self.span().unwrap_or_else(Span::call_site)
    }
}

impl IntoIterator for FormatArgs {
    type Item = Expr;
    type IntoIter = <Args as IntoIterator>::IntoIter;

    fn into_iter(self) -> Self::IntoIter {
        match self.args {
            Some(args) => args.into_iter(),
            None => Args::default().into_iter(),
        }
    }
}

impl From<Option<Args>> for FormatArgs {
    fn from(args: Option<Args>) -> Self {
        FormatArgs { args }
    }
}

impl Parse for FormatArgs {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let args: Args = input.parse_terminated(Expr::parse)?;
        Ok(Some(args).into())
    }
}

struct PFormatArgsAST {
    str: FormatStr,
    args: FormatArgs,
}

impl Parse for PFormatArgsAST {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let str: FormatStr = input.parse()?;
        let args = if input.peek(Token![,]) {
            //Format arguments are present.
            input.parse::<Token![,]>()?;
            let args: FormatArgs = input.parse()?;
            args
        } else {
            //No format arguments.
            None.into()
        };

        Ok(PFormatArgsAST { str, args })
    }
}

impl TryFrom<PFormatArgsAST> for PFormatArgs {
    type Error = syn::Error;

    fn try_from(value: PFormatArgsAST) -> Result<Self, Self::Error> {
        let pieces: Vec<String> = value.str.split_into_pieces();

        if pieces.len() - 1 < value.args.len() {
            Err(syn::Error::new(
                value.args.span_or_default(),
                "too many format arguments passed (more than parameters)",
            ))
        } else if pieces.len() - 1 > value.args.len() {
            Err(syn::Error::new(
                value.args.span_or_default(),
                "too few format arguments passed (fewer than parameters)",
            ))
        } else {
            Ok(PFormatArgs {
                pieces,
                args: value.args.into_iter().collect(),
            })
        }
    }
}

impl Parse for PFormatArgs {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let ast: PFormatArgsAST = input.parse()?;
        ast.try_into()
    }
}