1 | use std::cmp::Ordering; |
2 | use std::hash::{Hash, Hasher}; |
3 | |
4 | // Currently serde itself doesn't have a spanned type, so we map our `Spanned` |
5 | // to a special value in the serde data model. Namely one with these special |
6 | // fields/struct names. |
7 | // |
8 | // In general, supported deserializers should catch this and not literally emit |
9 | // these strings but rather emit `Spanned` as they're intended. |
10 | #[doc (hidden)] |
11 | #[cfg (feature = "serde" )] |
12 | pub const NAME: &str = "$__serde_spanned_private_Spanned" ; |
13 | #[doc (hidden)] |
14 | #[cfg (feature = "serde" )] |
15 | pub const START_FIELD: &str = "$__serde_spanned_private_start" ; |
16 | #[doc (hidden)] |
17 | #[cfg (feature = "serde" )] |
18 | pub const END_FIELD: &str = "$__serde_spanned_private_end" ; |
19 | #[doc (hidden)] |
20 | #[cfg (feature = "serde" )] |
21 | pub const VALUE_FIELD: &str = "$__serde_spanned_private_value" ; |
22 | #[doc (hidden)] |
23 | #[cfg (feature = "serde" )] |
24 | pub fn is_spanned(name: &'static str, fields: &'static [&'static str]) -> bool { |
25 | name == NAME && fields == [START_FIELD, END_FIELD, VALUE_FIELD] |
26 | } |
27 | |
28 | /// A spanned value, indicating the range at which it is defined in the source. |
29 | #[derive (Clone, Debug)] |
30 | pub struct Spanned<T> { |
31 | /// Byte range |
32 | span: std::ops::Range<usize>, |
33 | /// The spanned value. |
34 | value: T, |
35 | } |
36 | |
37 | impl<T> Spanned<T> { |
38 | /// Byte range |
39 | pub fn span(&self) -> std::ops::Range<usize> { |
40 | self.span.clone() |
41 | } |
42 | |
43 | /// Consumes the spanned value and returns the contained value. |
44 | pub fn into_inner(self) -> T { |
45 | self.value |
46 | } |
47 | |
48 | /// Returns a reference to the contained value. |
49 | pub fn get_ref(&self) -> &T { |
50 | &self.value |
51 | } |
52 | |
53 | /// Returns a mutable reference to the contained value. |
54 | pub fn get_mut(&mut self) -> &mut T { |
55 | &mut self.value |
56 | } |
57 | } |
58 | |
59 | impl std::borrow::Borrow<str> for Spanned<String> { |
60 | fn borrow(&self) -> &str { |
61 | self.get_ref() |
62 | } |
63 | } |
64 | |
65 | impl<T> AsRef<T> for Spanned<T> { |
66 | fn as_ref(&self) -> &T { |
67 | self.get_ref() |
68 | } |
69 | } |
70 | |
71 | impl<T> AsMut<T> for Spanned<T> { |
72 | fn as_mut(&mut self) -> &mut T { |
73 | self.get_mut() |
74 | } |
75 | } |
76 | |
77 | impl<T: PartialEq> PartialEq for Spanned<T> { |
78 | fn eq(&self, other: &Self) -> bool { |
79 | self.value.eq(&other.value) |
80 | } |
81 | } |
82 | |
83 | impl<T: Eq> Eq for Spanned<T> {} |
84 | |
85 | impl<T: Hash> Hash for Spanned<T> { |
86 | fn hash<H: Hasher>(&self, state: &mut H) { |
87 | self.value.hash(state); |
88 | } |
89 | } |
90 | |
91 | impl<T: PartialOrd> PartialOrd for Spanned<T> { |
92 | fn partial_cmp(&self, other: &Self) -> Option<Ordering> { |
93 | self.value.partial_cmp(&other.value) |
94 | } |
95 | } |
96 | |
97 | impl<T: Ord> Ord for Spanned<T> { |
98 | fn cmp(&self, other: &Self) -> Ordering { |
99 | self.value.cmp(&other.value) |
100 | } |
101 | } |
102 | |
103 | #[cfg (feature = "serde" )] |
104 | impl<'de, T> serde::de::Deserialize<'de> for Spanned<T> |
105 | where |
106 | T: serde::de::Deserialize<'de>, |
107 | { |
108 | fn deserialize<D>(deserializer: D) -> Result<Spanned<T>, D::Error> |
109 | where |
110 | D: serde::de::Deserializer<'de>, |
111 | { |
112 | struct SpannedVisitor<T>(::std::marker::PhantomData<T>); |
113 | |
114 | impl<'de, T> serde::de::Visitor<'de> for SpannedVisitor<T> |
115 | where |
116 | T: serde::de::Deserialize<'de>, |
117 | { |
118 | type Value = Spanned<T>; |
119 | |
120 | fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
121 | formatter.write_str("a spanned value" ) |
122 | } |
123 | |
124 | fn visit_map<V>(self, mut visitor: V) -> Result<Spanned<T>, V::Error> |
125 | where |
126 | V: serde::de::MapAccess<'de>, |
127 | { |
128 | if visitor.next_key()? != Some(START_FIELD) { |
129 | return Err(serde::de::Error::custom("spanned start key not found" )); |
130 | } |
131 | let start: usize = visitor.next_value()?; |
132 | |
133 | if visitor.next_key()? != Some(END_FIELD) { |
134 | return Err(serde::de::Error::custom("spanned end key not found" )); |
135 | } |
136 | let end: usize = visitor.next_value()?; |
137 | |
138 | if visitor.next_key()? != Some(VALUE_FIELD) { |
139 | return Err(serde::de::Error::custom("spanned value key not found" )); |
140 | } |
141 | let value: T = visitor.next_value()?; |
142 | |
143 | Ok(Spanned { |
144 | span: start..end, |
145 | value, |
146 | }) |
147 | } |
148 | } |
149 | |
150 | let visitor = SpannedVisitor(::std::marker::PhantomData); |
151 | |
152 | static FIELDS: [&str; 3] = [START_FIELD, END_FIELD, VALUE_FIELD]; |
153 | deserializer.deserialize_struct(NAME, &FIELDS, visitor) |
154 | } |
155 | } |
156 | |
157 | #[cfg (feature = "serde" )] |
158 | impl<T: serde::ser::Serialize> serde::ser::Serialize for Spanned<T> { |
159 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> |
160 | where |
161 | S: serde::ser::Serializer, |
162 | { |
163 | self.value.serialize(serializer) |
164 | } |
165 | } |
166 | |