eager2 1.1.4

Proc-macros for eager macro expansion
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

use std::sync::OnceLock;

use eager2_core::{
    consts::EAGER_CALL_SIGIL,
    parse::{eat_zero_group, Param},
    pm::{self, Span, TokenTree},
    Error, Note,
};
use litrs::Literal;

pub fn expect_call_literal(tt: Result<TokenTree, Span>) -> bool {
    static EAGER_CALL_LITERAL: OnceLock<Literal<String>> = OnceLock::new();
    let lit =
        EAGER_CALL_LITERAL.get_or_init(|| Literal::parse(EAGER_CALL_SIGIL).unwrap().into_owned());
    expect_literal(tt, lit.clone()).ok().is_none()
}

pub fn expect_literal<'a>(
    tt: Result<TokenTree, Span>,
    s: impl Into<Param<'a, Literal<String>>>,
) -> Result<(Literal<String>, Span), Error> {
    expect_literal_impl(tt, s.into())
}

fn expect_literal_impl(
    tt: Result<TokenTree, Span>,
    s: Param<Literal<String>>,
) -> Result<(Literal<String>, Span), Error> {
    let (tt, s) = match (tt.map(eat_zero_group), s) {
        (Err(span), Param::ExactValue(s)) => Err(Error {
            span,
            msg: "unexpected end of macro invocation".into(),
            note: Some(Note {
                span: None,
                msg: format!("while trying to match literal `{s}`").into(),
            }),
        }),
        (Err(span), Param::Named(s)) => Err(Error {
            span,
            msg: "unexpected end of macro invocation".into(),
            note: Some(Note {
                span: None,
                msg: format!("while trying to match literal `${s}:literal`").into(),
            }),
        }),
        (Ok(tt), s) => Ok((tt, s)),
    }?;
    let span = tt.span();

    match (Literal::try_from(tt.clone()), s) {
        (Err(_), Param::Named(s)) => Err(Error {
            span: tt.span(),
            msg: format!("expected literal: `${s}:literal`").into(),
            note: None,
        }),
        (Ok(l), Param::Named(_)) => Ok((l, span)),
        (Ok(l), Param::ExactValue(s)) if l == s => Ok((l, span)),
        (Err(_) | Ok(_), Param::ExactValue(s)) => Err(Error {
            span: tt.span(),
            msg: format!("expected literal: `{s}`").into(),
            note: None,
        }),
    }
}

pub fn get_string_literal(l: pm::Literal) -> Option<String> {
    if let Literal::String(s) = Literal::from(l) {
        Some(s.value().to_string())
    } else {
        None
    }
}

pub fn expect_string_literal(
    tt: Result<TokenTree, Span>,
    s: Param<&str>,
) -> Result<(String, Span), Error> {
    let (tt, s) = match (tt.map(eat_zero_group), s) {
        (Err(span), Param::ExactValue(s)) => Err(Error {
            span,
            msg: "unexpected end of macro invocation".into(),
            note: Some(Note {
                span: None,
                msg: format!("while trying to match string literal `{s}`").into(),
            }),
        }),
        (Err(span), Param::Named(s)) => Err(Error {
            span,
            msg: "unexpected end of macro invocation".into(),
            note: Some(Note {
                span: None,
                msg: format!("while trying to match string literal `${s}:literal`").into(),
            }),
        }),
        (Ok(tt), s) => Ok((tt, s)),
    }?;
    let span = tt.span();

    let (l, s) = match (Literal::try_from(tt), s) {
        (Err(_), Param::ExactValue(s)) => Err(Error {
            span,
            msg: format!("expected string literal: `{s}`").into(),
            note: None,
        }),
        (Err(_), Param::Named(s)) => Err(Error {
            span,
            msg: format!("expected string literal: `${s}:literal`").into(),
            note: None,
        }),
        (Ok(l), s) => Ok((l, s)),
    }?;

    match (l, s) {
        (Literal::String(l), Param::Named(_)) => Ok((l.into_value().into_owned(), span)),
        (Literal::String(l), Param::ExactValue(s)) if l.value() == s => {
            Ok((l.into_value().into_owned(), span))
        }
        (_, Param::ExactValue(s)) => Err(Error {
            span,
            msg: format!("expected string literal: `{s}`").into(),
            note: None,
        }),
        (_, Param::Named(s)) => Err(Error {
            span,
            msg: format!("expected string literal: `${s}:literal`").into(),
            note: None,
        }),
    }
}