1use std::cmp::Ordering;
2use 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")]
12pub const NAME: &str = "$__serde_spanned_private_Spanned";
13#[doc(hidden)]
14#[cfg(feature = "serde")]
15pub const START_FIELD: &str = "$__serde_spanned_private_start";
16#[doc(hidden)]
17#[cfg(feature = "serde")]
18pub const END_FIELD: &str = "$__serde_spanned_private_end";
19#[doc(hidden)]
20#[cfg(feature = "serde")]
21pub const VALUE_FIELD: &str = "$__serde_spanned_private_value";
22#[doc(hidden)]
23#[cfg(feature = "serde")]
24pub 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)]
30pub struct Spanned<T> {
31 /// Byte range
32 span: std::ops::Range<usize>,
33 /// The spanned value.
34 value: T,
35}
36
37impl<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
59impl std::borrow::Borrow<str> for Spanned<String> {
60 fn borrow(&self) -> &str {
61 self.get_ref()
62 }
63}
64
65impl<T> AsRef<T> for Spanned<T> {
66 fn as_ref(&self) -> &T {
67 self.get_ref()
68 }
69}
70
71impl<T> AsMut<T> for Spanned<T> {
72 fn as_mut(&mut self) -> &mut T {
73 self.get_mut()
74 }
75}
76
77impl<T: PartialEq> PartialEq for Spanned<T> {
78 fn eq(&self, other: &Self) -> bool {
79 self.value.eq(&other.value)
80 }
81}
82
83impl<T: Eq> Eq for Spanned<T> {}
84
85impl<T: Hash> Hash for Spanned<T> {
86 fn hash<H: Hasher>(&self, state: &mut H) {
87 self.value.hash(state);
88 }
89}
90
91impl<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
97impl<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")]
104impl<'de, T> serde::de::Deserialize<'de> for Spanned<T>
105where
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")]
158impl<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