1use serde_core::de::IntoDeserializer;
2
3use crate::de::DeString;
4use crate::de::Error;
5
6pub(crate) struct KeyDeserializer<'i> {
7 span: Option<core::ops::Range<usize>>,
8 key: DeString<'i>,
9}
10
11impl<'i> KeyDeserializer<'i> {
12 pub(crate) fn new(key: DeString<'i>, span: Option<core::ops::Range<usize>>) -> Self {
13 KeyDeserializer { span, key }
14 }
15}
16
17impl<'de> IntoDeserializer<'de, Error> for KeyDeserializer<'de> {
18 type Deserializer = Self;
19
20 fn into_deserializer(self) -> Self::Deserializer {
21 self
22 }
23}
24
25impl<'de> serde_core::de::Deserializer<'de> for KeyDeserializer<'de> {
26 type Error = Error;
27
28 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
29 where
30 V: serde_core::de::Visitor<'de>,
31 {
32 self.key.into_deserializer().deserialize_any(visitor)
33 }
34
35 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
36 where
37 V: serde_core::de::Visitor<'de>,
38 {
39 let key: bool = self.key.parse().map_err(serde_core::de::Error::custom)?;
40 key.into_deserializer().deserialize_bool(visitor)
41 }
42
43 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
44 where
45 V: serde_core::de::Visitor<'de>,
46 {
47 let key: i8 = self.key.parse().map_err(serde_core::de::Error::custom)?;
48 key.into_deserializer().deserialize_i8(visitor)
49 }
50
51 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
52 where
53 V: serde_core::de::Visitor<'de>,
54 {
55 let key: i16 = self.key.parse().map_err(serde_core::de::Error::custom)?;
56 key.into_deserializer().deserialize_i16(visitor)
57 }
58
59 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
60 where
61 V: serde_core::de::Visitor<'de>,
62 {
63 let key: i32 = self.key.parse().map_err(serde_core::de::Error::custom)?;
64 key.into_deserializer().deserialize_i32(visitor)
65 }
66
67 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
68 where
69 V: serde_core::de::Visitor<'de>,
70 {
71 let key: i64 = self.key.parse().map_err(serde_core::de::Error::custom)?;
72 key.into_deserializer().deserialize_i64(visitor)
73 }
74
75 fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
76 where
77 V: serde_core::de::Visitor<'de>,
78 {
79 let key: i128 = self.key.parse().map_err(serde_core::de::Error::custom)?;
80 key.into_deserializer().deserialize_i128(visitor)
81 }
82
83 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
84 where
85 V: serde_core::de::Visitor<'de>,
86 {
87 let key: u8 = self.key.parse().map_err(serde_core::de::Error::custom)?;
88 key.into_deserializer().deserialize_u8(visitor)
89 }
90
91 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
92 where
93 V: serde_core::de::Visitor<'de>,
94 {
95 let key: u16 = self.key.parse().map_err(serde_core::de::Error::custom)?;
96 key.into_deserializer().deserialize_u16(visitor)
97 }
98
99 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
100 where
101 V: serde_core::de::Visitor<'de>,
102 {
103 let key: u32 = self.key.parse().map_err(serde_core::de::Error::custom)?;
104 key.into_deserializer().deserialize_u32(visitor)
105 }
106
107 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
108 where
109 V: serde_core::de::Visitor<'de>,
110 {
111 let key: u64 = self.key.parse().map_err(serde_core::de::Error::custom)?;
112 key.into_deserializer().deserialize_u64(visitor)
113 }
114
115 fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
116 where
117 V: serde_core::de::Visitor<'de>,
118 {
119 let key: u128 = self.key.parse().map_err(serde_core::de::Error::custom)?;
120 key.into_deserializer().deserialize_u128(visitor)
121 }
122
123 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
124 where
125 V: serde_core::de::Visitor<'de>,
126 {
127 let key: char = self.key.parse().map_err(serde_core::de::Error::custom)?;
128 key.into_deserializer().deserialize_char(visitor)
129 }
130
131 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
132 where
133 V: serde_core::de::Visitor<'de>,
134 {
135 match self.key {
136 DeString::Borrowed(s) => visitor.visit_borrowed_str(s),
137 DeString::Owned(s) => visitor.visit_string(s),
138 }
139 }
140
141 fn deserialize_enum<V>(
142 self,
143 name: &str,
144 variants: &'static [&'static str],
145 visitor: V,
146 ) -> Result<V::Value, Self::Error>
147 where
148 V: serde_core::de::Visitor<'de>,
149 {
150 let _ = name;
151 let _ = variants;
152 visitor.visit_enum(self)
153 }
154
155 fn deserialize_struct<V>(
156 self,
157 name: &'static str,
158 _fields: &'static [&'static str],
159 visitor: V,
160 ) -> Result<V::Value, Error>
161 where
162 V: serde_core::de::Visitor<'de>,
163 {
164 if serde_spanned::de::is_spanned(name) {
165 if let Some(span) = self.span.clone() {
166 return visitor.visit_map(super::SpannedDeserializer::new(self.key, span));
167 } else {
168 return Err(Error::custom("value is missing a span", None));
169 }
170 }
171 self.deserialize_any(visitor)
172 }
173
174 fn deserialize_newtype_struct<V>(
175 self,
176 _name: &'static str,
177 visitor: V,
178 ) -> Result<V::Value, Error>
179 where
180 V: serde_core::de::Visitor<'de>,
181 {
182 visitor.visit_newtype_struct(self)
183 }
184
185 serde_core::forward_to_deserialize_any! {
186 f32 f64 seq string
187 bytes byte_buf map option unit
188 ignored_any unit_struct tuple_struct tuple identifier
189 }
190}
191
192impl<'de> serde_core::de::EnumAccess<'de> for KeyDeserializer<'de> {
193 type Error = Error;
194 type Variant = UnitOnly<Self::Error>;
195
196 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
197 where
198 T: serde_core::de::DeserializeSeed<'de>,
199 {
200 seed.deserialize(self).map(unit_only)
201 }
202}
203
204pub(crate) struct UnitOnly<E> {
205 marker: core::marker::PhantomData<E>,
206}
207
208fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) {
209 (
210 t,
211 UnitOnly {
212 marker: core::marker::PhantomData,
213 },
214 )
215}
216
217impl<'de, E> serde_core::de::VariantAccess<'de> for UnitOnly<E>
218where
219 E: serde_core::de::Error,
220{
221 type Error = E;
222
223 fn unit_variant(self) -> Result<(), Self::Error> {
224 Ok(())
225 }
226
227 fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
228 where
229 T: serde_core::de::DeserializeSeed<'de>,
230 {
231 Err(serde_core::de::Error::invalid_type(
232 serde_core::de::Unexpected::UnitVariant,
233 &"newtype variant",
234 ))
235 }
236
237 fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
238 where
239 V: serde_core::de::Visitor<'de>,
240 {
241 Err(serde_core::de::Error::invalid_type(
242 serde_core::de::Unexpected::UnitVariant,
243 &"tuple variant",
244 ))
245 }
246
247 fn struct_variant<V>(
248 self,
249 _fields: &'static [&'static str],
250 _visitor: V,
251 ) -> Result<V::Value, Self::Error>
252 where
253 V: serde_core::de::Visitor<'de>,
254 {
255 Err(serde_core::de::Error::invalid_type(
256 serde_core::de::Unexpected::UnitVariant,
257 &"struct variant",
258 ))
259 }
260}