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
use crate::macros::Storage;
use crate::shared::Description;
use crate::Spanned;
use runestick::{Source, SpannedError};
use thiserror::Error;
error! {
#[derive(Debug, Clone)]
pub struct ResolveError {
kind: ResolveErrorKind,
}
}
impl ResolveError {
pub(crate) fn expected<A, E>(actual: A, expected: E) -> Self
where
A: Description + Spanned,
E: Description,
{
Self::new(
actual.span(),
ResolveErrorKind::Expected {
actual: actual.description(),
expected: expected.description(),
},
)
}
}
impl From<ResolveError> for SpannedError {
fn from(error: ResolveError) -> Self {
SpannedError::new(error.span, error.kind)
}
}
#[allow(missing_docs)]
#[derive(Debug, Clone, Copy, Error)]
pub enum ResolveErrorKind {
#[error("{message}")]
Custom { message: &'static str },
#[error("expected {expected}, but got `{actual}`")]
Expected {
actual: &'static str,
expected: &'static str,
},
#[error("tried to read bad slice from source")]
BadSlice,
#[error("tried to get bad synthetic identifier `{id}` for {kind}")]
BadSyntheticId { kind: &'static str, id: usize },
#[error("bad escape sequence")]
BadEscapeSequence,
#[error("bad unicode escape")]
BadUnicodeEscape,
#[error(
"this form of character escape may only be used with characters in the range [\\x00-\\x7f]"
)]
BadHexEscapeChar,
#[error(
"this form of byte escape may only be used with characters in the range [\\x00-\\xff]"
)]
BadHexEscapeByte,
#[error("bad byte escape")]
BadByteEscape,
#[error("bad character literal")]
BadCharLiteral,
#[error("bad byte literal")]
BadByteLiteral,
#[error("unicode escapes are not supported as a byte or byte string")]
BadUnicodeEscapeInByteString,
#[error("number literal not valid")]
BadNumberLiteral,
}
pub trait Resolve<'a>: ResolveOwned {
type Output: 'a;
fn resolve(&self, storage: &Storage, source: &'a Source) -> Result<Self::Output, ResolveError>;
}
pub trait ResolveOwned {
type Owned;
fn resolve_owned(
&self,
storage: &Storage,
source: &Source,
) -> Result<Self::Owned, ResolveError>;
}