vermouth 0.5.4

a new kind of parser for procedural macros
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

//! [`Span`]-handling utilities.

use std::ops::{Deref, DerefMut};

use proc_macro::{Ident, Span, TokenTree};

/// Enables conversion between different span formats.
///
/// # Implementors
///
/// This trait is notably implemented for:
/// * [`Span`] itself
/// * [`Spanned<T>`]
/// * [`TokenTree`]
pub trait ToSpan {
    /// Converts a type into a [span](Span).
    fn span(&self) -> Span;
}

impl ToSpan for Span {
    #[inline]
    fn span(&self) -> Span {
        *self
    }
}

impl ToSpan for TokenTree {
    #[inline]
    fn span(&self) -> Span {
        self.span()
    }
}

impl<T> ToSpan for Spanned<T> {
    #[inline]
    fn span(&self) -> Span {
        self.span
    }
}

/// A simple wrapper which provides span information for any value.
///
/// Often it is preferrable to include span information on types directly,
/// but this type can be useful when the contained values aren't *explicitly*
/// linked to syntax.
///
/// # Examples
///
/// ```
/// # vermouth::ඞ_declare_test!();
/// # #[cfg(feature = "parse")]
/// # {
/// use proc_macro::{Ident, Span};
/// use vermouth::{Spanned, Expected, ToSpan};
///
/// fn is_continue_kw(kw: Spanned<&str>) -> bool {
///     kw == "continue"
/// }
///
/// let ident = Ident::new("continue", Span::call_site());
/// let spanned: Spanned<String> = ident.into();
/// assert!(is_continue_kw(spanned.as_deref()));
/// # };
/// ```
pub struct Spanned<T> {
    inner: T,
    span: Span,
}

impl<R, T: PartialEq<R>> PartialEq<R> for Spanned<T> {
    fn eq(&self, other: &R) -> bool {
        self.inner == *other
    }
}

impl From<Ident> for Spanned<String> {
    fn from(value: Ident) -> Self {
        Spanned::new(value.span(), value.to_string())
    }
}

impl<T: Clone> Clone for Spanned<T> {
    fn clone(&self) -> Self {
        Self {
            inner: self.inner.clone(),
            span: self.span,
        }
    }
}

impl<T: Copy> Copy for Spanned<T> {}

impl<T> Spanned<T> {
    /// Creates a new [`Spanned`] object.
    pub fn new(span: impl ToSpan, inner: T) -> Self {
        Self {
            inner,
            span: span.span(),
        }
    }

    /// Unwraps the contained value of a [`Spanned`] object.
    pub fn into_inner(self) -> T {
        self.inner
    }
    /// [Dereferences] the value stored in this `Spanned` value.
    ///
    /// [Dereferences]: Deref
    pub fn as_deref(&self) -> Spanned<&T::Target>
    where
        T: Deref,
    {
        Spanned::new(self.span, self.deref())
    }

    /// [Mutably dereferences] the value stored in this `Spanned` value.
    ///
    /// [Mutably dereferences]: DerefMut
    pub fn as_deref_mut(&mut self) -> Spanned<&mut T::Target>
    where
        T: DerefMut,
    {
        Spanned::new(self.span, self.deref_mut())
    }
}

impl<T> From<(Span, T)> for Spanned<T> {
    fn from((span, inner): (Span, T)) -> Self {
        Self::new(span, inner)
    }
}

impl<T> Deref for Spanned<T> {
    type Target = T;

    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl<T> DerefMut for Spanned<T> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}