serde_syn 0.1.0

Use serde to parse Rust source code.
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

use crate::SynError;
use serde::de::Error as DeError;
use proc_macro2::Span;
use std::fmt;
pub(crate) use std::error::Error as StdError;

/// A serde deserialization error which wraps `syn::Error` or a custom string.
/// The `Syn` variant is preferred when possible, since it tracks the location
/// in the input syntax where the error occurred.
pub enum Error {
    Syn(SynError),
    Custom(String),
}

impl Error {
    /// Returns the location in the input syntax where this error occurred if
    /// one is known.
    pub fn span(&self) -> Option<Span> {
        match self {
            Error::Syn(e) => Some(e.span()),
            Error::Custom(_) => None,
        }
    }

    /// Attaches a span to this error if needed.
    #[inline(always)]
    pub fn with_span(self, span: Span) -> Error {
        Error::Syn(self.to_syn(span))
    }

    /// Converts `self` to a `syn::Error` by attaching a span if needed.
    ///
    /// ```
    /// # use proc_macro2::Span;
    /// # use serde_syn::Error;
    /// # use serde::de::Error as _;
    /// let err = Error::custom("an error");
    /// assert!(err.span().is_none());
    /// let syn_err = err.to_syn(Span::call_site());
    /// println!("{:?}", syn_err.span());
    /// ```
    #[inline(always)]
    pub fn to_syn(self, span: Span) -> SynError {
        match self {
            Error::Syn(e) => e,
            Error::Custom(msg) => SynError::new(span, msg),
        }
    }
}

/// Attach the given span to res if a span is not already attached.
#[inline(always)]
pub(crate) fn span_result<T>(res: Result<T, Error>, span: Span)
    -> Result<T, Error>
{
    res.map_err(|e| e.with_span(span))
}

impl From<SynError> for Error {
    fn from(err: SynError) -> Error {
        Error::Syn(err)
    }
}

impl DeError for Error {
    fn custom<T: fmt::Display>(msg: T) -> Self {
        Error::Custom(msg.to_string())
    }
}

impl StdError for Error {
    fn description(&self) -> &str {
        match self {
            Error::Syn(e) => e.description(),
            Error::Custom(m) => m.as_str(),
        }
    }

    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        match self {
            Error::Syn(e) => Some(e),
            Error::Custom(_) => None,
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::Syn(e) => fmt::Display::fmt(e, f),
            Error::Custom(m) => fmt::Display::fmt(m, f),
        }
    }
}

impl fmt::Debug for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::Syn(e) => fmt::Debug::fmt(e, f),
            Error::Custom(m) => f.debug_tuple("Error")
                .field(&m)
                .finish(),
        }
    }
}