spectec_ast_decode 1.0.0

Trait for decoding SpecTec AST S-expressions
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

use std::{num::ParseIntError, str::ParseBoolError};

use thiserror::Error;

#[derive(Error, Debug)]
pub enum ErrorKind {
    #[error("Unrecognised atom symbol: {0}")]
    UnrecognisedAtomSymbol(String),
    #[error("Unrecognised node symbol: {0}")]
    UnrecognisedNodeSymbol(String),
    #[error("Required another S-expression but stream is empty")]
    RequiredMissingSExpr(),
    #[error("Could not decode from S-Expression: {0}")]
    CannotDecodeSExpr(String),
    #[error("Extra unparsed S-expression remaining: {0}")]
    UnparsedSExpr(String),
    #[error("Error parsing a bool: {0}")]
    ParseBoolError(#[from] std::str::ParseBoolError),
    #[error("Error parsing an int: {0}")]
    ParseIntError(#[from] std::num::ParseIntError),
    #[error("{0}")]
    Wrapped(#[from] Box<Error>),
}

#[derive(Error, Debug)]
pub struct Error {
    #[source]
    pub kind: ErrorKind,
    pub variant: Option<String>,
    pub field: Option<String>,
    pub decoding: &'static str,
}

impl Error {
    #[must_use]
    pub(crate) fn new<T: crate::Decode>(kind: ErrorKind) -> Self {
        Self {
            kind,
            variant: None,
            field: None,
            decoding: std::any::type_name::<T>(),
        }
    }

    #[must_use]
    pub fn with_variant<S: Into<String>>(mut self, variant: S) -> Self {
        self.variant = Some(variant.into());
        self
    }

    #[must_use]
    pub fn with_field<S: Into<String>>(mut self, field: S) -> Self {
        self.field = Some(field.into());
        self
    }

    #[must_use]
    pub fn unrecognised_atom_symbol<T: crate::Decode, S: Into<String>>(symbol: S) -> Self {
        Self::new::<T>(ErrorKind::UnrecognisedAtomSymbol(symbol.into()))
    }

    #[must_use]
    pub fn unrecognised_node_symbol<T: crate::Decode, S: Into<String>>(symbol: S) -> Self {
        Self::new::<T>(ErrorKind::UnrecognisedNodeSymbol(symbol.into()))
    }

    #[must_use]
    pub fn required_missing_sexpr<T: crate::Decode>() -> Self {
        Self::new::<T>(ErrorKind::RequiredMissingSExpr())
    }

    #[must_use]
    pub fn cannot_decode_sexpr<T: crate::Decode>(sexpr: &sexpr_parse::SExprItem) -> Self {
        Self::new::<T>(ErrorKind::CannotDecodeSExpr(format!("{sexpr:?}")))
    }

    #[must_use]
    pub fn unparsed_sexpr<T: crate::Decode>(sexpr: &sexpr_parse::SExprItem) -> Self {
        Self::new::<T>(ErrorKind::UnparsedSExpr(format!("{sexpr:?}")))
    }

    #[must_use]
    pub fn parse_bool_err<T: crate::Decode>(from: ParseBoolError) -> Self {
        Self::new::<T>(ErrorKind::from(from))
    }

    #[must_use]
    pub fn parse_int_err<T: crate::Decode>(from: ParseIntError) -> Self {
        Self::new::<T>(ErrorKind::from(from))
    }

    #[must_use]
    pub fn wrapped<T: crate::Decode>(from: Error) -> Self {
        Self::new::<T>(ErrorKind::from(Box::new(from)))
    }
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Error decoding {}", self.decoding)?;
        if let Some(variant) = &self.variant {
            write!(f, "::{variant}")?;
        }
        if let Some(field) = &self.field {
            write!(f, ".{field}")?;
        }
        write!(f, ": {}", self.kind)
    }
}

pub type Result<T> = core::result::Result<T, Error>;