Skip to content

Commit 0d1353e

Browse files
juntyrjuntyr
committed
Experimentation with revised ron-rs#209 
1 parent 07f8d96 commit 0d1353e

File tree

2 files changed

+108
-47
lines changed

2 files changed

+108
-47
lines changed

‎src/de/mod.rs

Lines changed: 108 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -55,6 +55,14 @@ impl<'de> Deserializer<'de> {
5555
pub fn remainder(&self) -> Cow<'_, str> {
5656
String::from_utf8_lossy(self.bytes.bytes())
5757
}
58+
59+
fn fix_error_position(&self, err: Error) -> Error {
60+
if err.position == (Position { line: 0, col: 0 }) {
61+
self.bytes.error(err.code)
62+
} else {
63+
err
64+
}
65+
}
5866
}
5967

6068
/// A convenience function for reading data from a reader
@@ -121,7 +129,7 @@ impl<'de> Deserializer<'de> {
121129
self.deserialize_struct("", &[], visitor)
122130
}
123131
} else {
124-
visitor.visit_unit()
132+
visitor.visit_unit().map_err(|e| self.fix_error_position(e))
125133
}
126134
}
127135
}
@@ -138,21 +146,31 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
138146
self.newtype_variant = false;
139147

140148
if self.bytes.consume_ident("true") {
141-
return visitor.visit_bool(true);
149+
return visitor
150+
.visit_bool(true)
151+
.map_err(|e| self.fix_error_position(e));
142152
} else if self.bytes.consume_ident("false") {
143-
return visitor.visit_bool(false);
153+
return visitor
154+
.visit_bool(false)
155+
.map_err(|e| self.fix_error_position(e));
144156
} else if self.bytes.check_ident("Some") {
145157
return self.deserialize_option(visitor);
146158
} else if self.bytes.consume_ident("None") {
147-
return visitor.visit_none();
159+
return visitor.visit_none().map_err(|e| self.fix_error_position(e));
148160
} else if self.bytes.consume("()") {
149-
return visitor.visit_unit();
161+
return visitor.visit_unit().map_err(|e| self.fix_error_position(e));
150162
} else if self.bytes.consume_ident("inf") {
151-
return visitor.visit_f64(std::f64::INFINITY);
163+
return visitor
164+
.visit_f64(std::f64::INFINITY)
165+
.map_err(|e| self.fix_error_position(e));
152166
} else if self.bytes.consume_ident("-inf") {
153-
return visitor.visit_f64(std::f64::NEG_INFINITY);
167+
return visitor
168+
.visit_f64(std::f64::NEG_INFINITY)
169+
.map_err(|e| self.fix_error_position(e));
154170
} else if self.bytes.consume_ident("NaN") {
155-
return visitor.visit_f64(std::f64::NAN);
171+
return visitor
172+
.visit_f64(std::f64::NAN)
173+
.map_err(|e| self.fix_error_position(e));
156174
}
157175

158176
// `identifier` does not change state if it fails
@@ -187,6 +205,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
187205
#[cfg(feature = "integer128")]
188206
AnyNum::U128(x) => visitor.visit_u128(x),
189207
}
208+
.map_err(|e| self.fix_error_position(e))
190209
}
191210
b'.' => self.deserialize_f64(visitor),
192211
b'"' | b'r' => self.deserialize_string(visitor),
@@ -199,100 +218,128 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
199218
where
200219
V: Visitor<'de>,
201220
{
202-
visitor.visit_bool(self.bytes.bool()?)
221+
visitor
222+
.visit_bool(self.bytes.bool()?)
223+
.map_err(|e| self.fix_error_position(e))
203224
}
204225

205226
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
206227
where
207228
V: Visitor<'de>,
208229
{
209-
visitor.visit_i8(self.bytes.signed_integer()?)
230+
visitor
231+
.visit_i8(self.bytes.signed_integer()?)
232+
.map_err(|e| self.fix_error_position(e))
210233
}
211234

212235
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
213236
where
214237
V: Visitor<'de>,
215238
{
216-
visitor.visit_i16(self.bytes.signed_integer()?)
239+
visitor
240+
.visit_i16(self.bytes.signed_integer()?)
241+
.map_err(|e| self.fix_error_position(e))
217242
}
218243

219244
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
220245
where
221246
V: Visitor<'de>,
222247
{
223-
visitor.visit_i32(self.bytes.signed_integer()?)
248+
visitor
249+
.visit_i32(self.bytes.signed_integer()?)
250+
.map_err(|e| self.fix_error_position(e))
224251
}
225252

226253
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
227254
where
228255
V: Visitor<'de>,
229256
{
230-
visitor.visit_i64(self.bytes.signed_integer()?)
257+
visitor
258+
.visit_i64(self.bytes.signed_integer()?)
259+
.map_err(|e| self.fix_error_position(e))
231260
}
232261

233262
#[cfg(feature = "integer128")]
234263
fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
235264
where
236265
V: Visitor<'de>,
237266
{
238-
visitor.visit_i128(self.bytes.signed_integer()?)
267+
visitor
268+
.visit_i128(self.bytes.signed_integer()?)
269+
.map_err(|e| self.fix_error_position(e))
239270
}
240271

241272
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
242273
where
243274
V: Visitor<'de>,
244275
{
245-
visitor.visit_u8(self.bytes.unsigned_integer()?)
276+
visitor
277+
.visit_u8(self.bytes.unsigned_integer()?)
278+
.map_err(|e| self.fix_error_position(e))
246279
}
247280

248281
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
249282
where
250283
V: Visitor<'de>,
251284
{
252-
visitor.visit_u16(self.bytes.unsigned_integer()?)
285+
visitor
286+
.visit_u16(self.bytes.unsigned_integer()?)
287+
.map_err(|e| self.fix_error_position(e))
253288
}
254289

255290
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
256291
where
257292
V: Visitor<'de>,
258293
{
259-
visitor.visit_u32(self.bytes.unsigned_integer()?)
294+
visitor
295+
.visit_u32(self.bytes.unsigned_integer()?)
296+
.map_err(|e| self.fix_error_position(e))
260297
}
261298

262299
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
263300
where
264301
V: Visitor<'de>,
265302
{
266-
visitor.visit_u64(self.bytes.unsigned_integer()?)
303+
visitor
304+
.visit_u64(self.bytes.unsigned_integer()?)
305+
.map_err(|e| self.fix_error_position(e))
267306
}
268307

269308
#[cfg(feature = "integer128")]
270309
fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
271310
where
272311
V: Visitor<'de>,
273312
{
274-
visitor.visit_u128(self.bytes.unsigned_integer()?)
313+
visitor
314+
.visit_u128(self.bytes.unsigned_integer()?)
315+
.map_err(|e| self.fix_error_position(e))
275316
}
276317

277318
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
278319
where
279320
V: Visitor<'de>,
280321
{
281-
visitor.visit_f32(self.bytes.float()?)
322+
visitor
323+
.visit_f32(self.bytes.float()?)
324+
.map_err(|e| self.fix_error_position(e))
282325
}
283326

284327
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
285328
where
286329
V: Visitor<'de>,
287330
{
288-
visitor.visit_f64(self.bytes.float()?)
331+
visitor
332+
.visit_f64(self.bytes.float()?)
333+
.map_err(|e| self.fix_error_position(e))
289334
}
290335

291336
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
292337
where
293338
V: Visitor<'de>,
294339
{
295-
visitor.visit_char(self.bytes.char()?)
340+
visitor
341+
.visit_char(self.bytes.char()?)
342+
.map_err(|e| self.fix_error_position(e))
296343
}
297344

298345
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
@@ -303,6 +350,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
303350
ParsedStr::Allocated(s) => visitor.visit_string(s),
304351
ParsedStr::Slice(s) => visitor.visit_borrowed_str(s),
305352
}
353+
.map_err(|e| self.fix_error_position(e))
306354
}
307355

308356
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
@@ -333,7 +381,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
333381
};
334382

335383
match res {
336-
Ok(byte_buf) => visitor.visit_byte_buf(byte_buf),
384+
Ok(byte_buf) => visitor
385+
.visit_byte_buf(byte_buf)
386+
.map_err(|e| self.fix_error_position(e)),
337387
Err(err) => self.bytes.err(ErrorCode::Base64Error(err)),
338388
}
339389
}
@@ -343,16 +393,20 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
343393
V: Visitor<'de>,
344394
{
345395
if self.bytes.consume("None") {
346-
visitor.visit_none()
396+
visitor.visit_none().map_err(|e| self.fix_error_position(e))
347397
} else if self.bytes.exts.contains(Extensions::IMPLICIT_SOME) {
348-
visitor.visit_some(&mut *self)
398+
visitor
399+
.visit_some(&mut *self)
400+
.map_err(|e| self.fix_error_position(e))
349401
} else if self.bytes.consume("Some") && {
350402
self.bytes.skip_ws()?;
351403
self.bytes.consume("(")
352404
} {
353405
self.bytes.skip_ws()?;
354406

355-
let v = visitor.visit_some(&mut *self)?;
407+
let v = visitor
408+
.visit_some(&mut *self)
409+
.map_err(|e| self.fix_error_position(e))?;
356410

357411
self.bytes.skip_ws()?;
358412

@@ -374,7 +428,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
374428
if self.newtype_variant || self.bytes.consume("()") {
375429
self.newtype_variant = false;
376430

377-
visitor.visit_unit()
431+
visitor.visit_unit().map_err(|e| self.fix_error_position(e))
378432
} else {
379433
self.bytes.err(ErrorCode::ExpectedUnit)
380434
}
@@ -387,7 +441,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
387441
if self.newtype_variant || self.bytes.consume_struct_name(name)? {
388442
self.newtype_variant = false;
389443

390-
visitor.visit_unit()
444+
visitor.visit_unit().map_err(|e| self.fix_error_position(e))
391445
} else {
392446
self.deserialize_unit(visitor)
393447
}
@@ -400,7 +454,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
400454
if self.bytes.exts.contains(Extensions::UNWRAP_NEWTYPES) || self.newtype_variant {
401455
self.newtype_variant = false;
402456

403-
return visitor.visit_newtype_struct(&mut *self);
457+
return visitor
458+
.visit_newtype_struct(&mut *self)
459+
.map_err(|e| self.fix_error_position(e));
404460
}
405461

406462
self.bytes.consume_struct_name(name)?;
@@ -409,7 +465,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
409465

410466
if self.bytes.consume("(") {
411467
self.bytes.skip_ws()?;
412-
let value = visitor.visit_newtype_struct(&mut *self)?;
468+
let value = visitor
469+
.visit_newtype_struct(&mut *self)
470+
.map_err(|e| self.fix_error_position(e))?;
413471
self.bytes.comma()?;
414472

415473
if self.bytes.consume(")") {
@@ -431,7 +489,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
431489
self.newtype_variant = false;
432490

433491
if self.bytes.consume("[") {
434-
let value = visitor.visit_seq(CommaSeparated::new(b']', &mut self))?;
492+
let value = visitor
493+
.visit_seq(CommaSeparated::new(b']', &mut self))
494+
.map_err(|e| self.fix_error_position(e))?;
435495
self.bytes.comma()?;
436496

437497
if self.bytes.consume("]") {
@@ -452,7 +512,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
452512
let old_newtype_variant = self.newtype_variant;
453513
self.newtype_variant = false;
454514

455-
let value = visitor.visit_seq(CommaSeparated::new(b')', &mut self))?;
515+
let value = visitor
516+
.visit_seq(CommaSeparated::new(b')', &mut self))
517+
.map_err(|e| self.fix_error_position(e))?;
456518
self.bytes.comma()?;
457519

458520
if old_newtype_variant || self.bytes.consume(")") {
@@ -488,7 +550,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
488550
self.newtype_variant = false;
489551

490552
if self.bytes.consume("{") {
491-
let value = visitor.visit_map(CommaSeparated::new(b'}', &mut self))?;
553+
let value = visitor
554+
.visit_map(CommaSeparated::new(b'}', &mut self))
555+
.map_err(|e| self.fix_error_position(e))?;
492556
self.bytes.comma()?;
493557

494558
if self.bytes.consume("}") {
@@ -520,7 +584,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
520584
let old_newtype_variant = self.newtype_variant;
521585
self.newtype_variant = false;
522586

523-
let value = visitor.visit_map(CommaSeparated::new(b')', &mut self))?;
587+
let value = visitor
588+
.visit_map(CommaSeparated::new(b')', &mut self))
589+
.map_err(|e| self.fix_error_position(e))?;
524590
self.bytes.comma()?;
525591

526592
if old_newtype_variant || self.bytes.consume(")") {
@@ -546,16 +612,20 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
546612
{
547613
self.newtype_variant = false;
548614

549-
visitor.visit_enum(Enum::new(self))
615+
visitor
616+
.visit_enum(Enum::new(self))
617+
.map_err(|e| self.fix_error_position(e))
550618
}
551619

552620
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
553621
where
554622
V: Visitor<'de>,
555623
{
556-
visitor.visit_str(
557-
str::from_utf8(self.bytes.identifier()?).map_err(|e| self.bytes.error(e.into()))?,
558-
)
624+
visitor
625+
.visit_str(
626+
str::from_utf8(self.bytes.identifier()?).map_err(|e| self.bytes.error(e.into()))?,
627+
)
628+
.map_err(|e| self.fix_error_position(e))
559629
}
560630

561631
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>

‎src/error.rs

Lines changed: 0 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -165,15 +165,6 @@ impl From<FromUtf8Error> for ErrorCode {
165165
}
166166
}
167167

168-
impl From<Utf8Error> for Error {
169-
fn from(e: Utf8Error) -> Self {
170-
Error {
171-
code: ErrorCode::Utf8Error(e),
172-
position: Position { line: 0, col: 0 },
173-
}
174-
}
175-
}
176-
177168
impl From<io::Error> for Error {
178169
fn from(e: io::Error) -> Self {
179170
Error {

0 commit comments

Comments
 (0)