Skip to content

Commit fe196a9

Browse files
Markus WesterlindMarwes
Markus Westerlind
authored and
Marwes
committed
refactor: Factor out whitespace skipping into helpers
Should hopefully reduce the amount of code being generated
1 parent ae8d93d commit fe196a9

File tree

1 file changed

+67
-122
lines changed

1 file changed

+67
-122
lines changed

‎src/de.rs

+67-122
Original file line numberDiff line numberDiff line change
@@ -234,6 +234,24 @@ impl<'de, R: Read<'de>> Deserializer<R> {
234234
Error::syntax(reason, position.line, position.column)
235235
}
236236

237+
/// Returns the first non-whitespace byte without consuming it, or `Err` if
238+
/// EOF is encountered.
239+
fn parse_whitespace_in_value(&mut self) -> Result<u8> {
240+
match tri!(self.parse_whitespace()) {
241+
Some(b) => Ok(b),
242+
None => Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
243+
}
244+
}
245+
246+
/// Returns the first non-whitespace byte without consuming it, or `Err` if
247+
/// EOF is encountered.
248+
fn parse_whitespace_in_object(&mut self) -> Result<u8> {
249+
match tri!(self.parse_whitespace()) {
250+
Some(b) => Ok(b),
251+
None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
252+
}
253+
}
254+
237255
/// Returns the first non-whitespace byte without consuming it, or `None` if
238256
/// EOF is encountered.
239257
fn parse_whitespace(&mut self) -> Result<Option<u8>> {
@@ -304,12 +322,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
304322
where
305323
V: de::Visitor<'de>,
306324
{
307-
let peek = match tri!(self.parse_whitespace()) {
308-
Some(b) => b,
309-
None => {
310-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
311-
}
312-
};
325+
let peek = tri!(self.parse_whitespace_in_value());
313326

314327
let value = match peek {
315328
b'-' => {
@@ -961,13 +974,12 @@ impl<'de, R: Read<'de>> Deserializer<R> {
961974
}
962975

963976
fn parse_object_colon(&mut self) -> Result<()> {
964-
match tri!(self.parse_whitespace()) {
965-
Some(b':') => {
977+
match tri!(self.parse_whitespace_in_object()) {
978+
b':' => {
966979
self.eat_char();
967980
Ok(())
968981
}
969-
Some(_) => Err(self.peek_error(ErrorCode::ExpectedColon)),
970-
None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
982+
_ => Err(self.peek_error(ErrorCode::ExpectedColon)),
971983
}
972984
}
973985

@@ -990,14 +1002,13 @@ impl<'de, R: Read<'de>> Deserializer<R> {
9901002
}
9911003

9921004
fn end_map(&mut self) -> Result<()> {
993-
match tri!(self.parse_whitespace()) {
994-
Some(b'}') => {
1005+
match tri!(self.parse_whitespace_in_object()) {
1006+
b'}' => {
9951007
self.eat_char();
9961008
Ok(())
9971009
}
998-
Some(b',') => Err(self.peek_error(ErrorCode::TrailingComma)),
999-
Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
1000-
None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
1010+
b',' => Err(self.peek_error(ErrorCode::TrailingComma)),
1011+
_ => Err(self.peek_error(ErrorCode::TrailingCharacters)),
10011012
}
10021013
}
10031014

@@ -1006,12 +1017,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
10061017
let mut enclosing = None;
10071018

10081019
loop {
1009-
let peek = match tri!(self.parse_whitespace()) {
1010-
Some(b) => b,
1011-
None => {
1012-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1013-
}
1014-
};
1020+
let peek = tri!(self.parse_whitespace_in_value());
10151021

10161022
let frame = match peek {
10171023
b'n' => {
@@ -1099,16 +1105,14 @@ impl<'de, R: Read<'de>> Deserializer<R> {
10991105
}
11001106

11011107
if frame == b'{' {
1102-
match tri!(self.parse_whitespace()) {
1103-
Some(b'"') => self.eat_char(),
1104-
Some(_) => return Err(self.peek_error(ErrorCode::KeyMustBeAString)),
1105-
None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
1108+
match tri!(self.parse_whitespace_in_object()) {
1109+
b'"' => self.eat_char(),
1110+
_ => return Err(self.peek_error(ErrorCode::KeyMustBeAString)),
11061111
}
11071112
tri!(self.read.ignore_str());
1108-
match tri!(self.parse_whitespace()) {
1109-
Some(b':') => self.eat_char(),
1110-
Some(_) => return Err(self.peek_error(ErrorCode::ExpectedColon)),
1111-
None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
1113+
match tri!(self.parse_whitespace_in_object()) {
1114+
b':' => self.eat_char(),
1115+
_ => return Err(self.peek_error(ErrorCode::ExpectedColon)),
11121116
}
11131117
}
11141118

@@ -1292,12 +1296,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
12921296
where
12931297
V: de::Visitor<'de>,
12941298
{
1295-
let peek = match tri!(self.parse_whitespace()) {
1296-
Some(b) => b,
1297-
None => {
1298-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1299-
}
1300-
};
1299+
let peek = tri!(self.parse_whitespace_in_value());
13011300

13021301
let value = match peek {
13031302
b'n' => {
@@ -1368,12 +1367,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
13681367
where
13691368
V: de::Visitor<'de>,
13701369
{
1371-
let peek = match tri!(self.parse_whitespace()) {
1372-
Some(b) => b,
1373-
None => {
1374-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1375-
}
1376-
};
1370+
let peek = tri!(self.parse_whitespace_in_value());
13771371

13781372
let value = match peek {
13791373
b't' => {
@@ -1425,16 +1419,10 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
14251419
{
14261420
let mut buf = String::new();
14271421

1428-
match tri!(self.parse_whitespace()) {
1429-
Some(b'-') => {
1430-
self.eat_char();
1431-
buf.push('-');
1432-
}
1433-
Some(_) => {}
1434-
None => {
1435-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1436-
}
1437-
};
1422+
if tri!(self.parse_whitespace_in_value()) == b'-' {
1423+
self.eat_char();
1424+
buf.push('-');
1425+
}
14381426

14391427
tri!(self.scan_integer128(&mut buf));
14401428

@@ -1455,14 +1443,8 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
14551443
where
14561444
V: de::Visitor<'de>,
14571445
{
1458-
match tri!(self.parse_whitespace()) {
1459-
Some(b'-') => {
1460-
return Err(self.peek_error(ErrorCode::NumberOutOfRange));
1461-
}
1462-
Some(_) => {}
1463-
None => {
1464-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1465-
}
1446+
if tri!(self.parse_whitespace_in_value()) == b'-' {
1447+
return Err(self.peek_error(ErrorCode::NumberOutOfRange));
14661448
}
14671449

14681450
let mut buf = String::new();
@@ -1493,12 +1475,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
14931475
where
14941476
V: de::Visitor<'de>,
14951477
{
1496-
let peek = match tri!(self.parse_whitespace()) {
1497-
Some(b) => b,
1498-
None => {
1499-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1500-
}
1501-
};
1478+
let peek = tri!(self.parse_whitespace_in_value());
15021479

15031480
let value = match peek {
15041481
b'"' => {
@@ -1600,12 +1577,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
16001577
where
16011578
V: de::Visitor<'de>,
16021579
{
1603-
let peek = match tri!(self.parse_whitespace()) {
1604-
Some(b) => b,
1605-
None => {
1606-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1607-
}
1608-
};
1580+
let peek = tri!(self.parse_whitespace_in_value());
16091581

16101582
let value = match peek {
16111583
b'"' => {
@@ -1654,12 +1626,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
16541626
where
16551627
V: de::Visitor<'de>,
16561628
{
1657-
let peek = match tri!(self.parse_whitespace()) {
1658-
Some(b) => b,
1659-
None => {
1660-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1661-
}
1662-
};
1629+
let peek = tri!(self.parse_whitespace_in_value());
16631630

16641631
let value = match peek {
16651632
b'n' => {
@@ -1704,12 +1671,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
17041671
where
17051672
V: de::Visitor<'de>,
17061673
{
1707-
let peek = match tri!(self.parse_whitespace()) {
1708-
Some(b) => b,
1709-
None => {
1710-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1711-
}
1712-
};
1674+
let peek = tri!(self.parse_whitespace_in_value());
17131675

17141676
let value = match peek {
17151677
b'[' => {
@@ -1755,12 +1717,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
17551717
where
17561718
V: de::Visitor<'de>,
17571719
{
1758-
let peek = match tri!(self.parse_whitespace()) {
1759-
Some(b) => b,
1760-
None => {
1761-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1762-
}
1763-
};
1720+
let peek = tri!(self.parse_whitespace_in_value());
17641721

17651722
let value = match peek {
17661723
b'{' => {
@@ -1792,12 +1749,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
17921749
where
17931750
V: de::Visitor<'de>,
17941751
{
1795-
let peek = match tri!(self.parse_whitespace()) {
1796-
Some(b) => b,
1797-
None => {
1798-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1799-
}
1800-
};
1752+
let peek = tri!(self.parse_whitespace_in_value());
18011753

18021754
let value = match peek {
18031755
b'[' => {
@@ -1843,25 +1795,23 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
18431795
where
18441796
V: de::Visitor<'de>,
18451797
{
1846-
match tri!(self.parse_whitespace()) {
1847-
Some(b'{') => {
1798+
match tri!(self.parse_whitespace_in_value()) {
1799+
b'{' => {
18481800
check_recursion! {
18491801
self.eat_char();
18501802
let value = tri!(visitor.visit_enum(VariantAccess::new(self)));
18511803
}
18521804

1853-
match tri!(self.parse_whitespace()) {
1854-
Some(b'}') => {
1805+
match tri!(self.parse_whitespace_in_object()) {
1806+
b'}' => {
18551807
self.eat_char();
18561808
Ok(value)
18571809
}
1858-
Some(_) => Err(self.error(ErrorCode::ExpectedSomeValue)),
1859-
None => Err(self.error(ErrorCode::EofWhileParsingObject)),
1810+
_ => Err(self.error(ErrorCode::ExpectedSomeValue)),
18601811
}
18611812
}
1862-
Some(b'"') => visitor.visit_enum(UnitVariantAccess::new(self)),
1863-
Some(_) => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
1864-
None => Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
1813+
b'"' => visitor.visit_enum(UnitVariantAccess::new(self)),
1814+
_ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
18651815
}
18661816
}
18671817

@@ -1905,12 +1855,12 @@ impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
19051855
}
19061856
Some(b',') if !self.first => {
19071857
self.de.eat_char();
1908-
tri!(self.de.parse_whitespace())
1858+
tri!(self.de.parse_whitespace_in_value())
19091859
}
19101860
Some(b) => {
19111861
if self.first {
19121862
self.first = false;
1913-
Some(b)
1863+
b
19141864
} else {
19151865
return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd));
19161866
}
@@ -1921,9 +1871,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
19211871
};
19221872

19231873
match peek {
1924-
Some(b']') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1925-
Some(_) => Ok(Some(tri!(seed.deserialize(&mut *self.de)))),
1926-
None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
1874+
b']' => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1875+
_ => Ok(Some(tri!(seed.deserialize(&mut *self.de)))),
19271876
}
19281877
}
19291878
}
@@ -1946,32 +1895,28 @@ impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> {
19461895
where
19471896
K: de::DeserializeSeed<'de>,
19481897
{
1949-
let peek = match tri!(self.de.parse_whitespace()) {
1950-
Some(b'}') => {
1898+
let peek = match tri!(self.de.parse_whitespace_in_object()) {
1899+
b'}' => {
19511900
return Ok(None);
19521901
}
1953-
Some(b',') if !self.first => {
1902+
b',' if !self.first => {
19541903
self.de.eat_char();
1955-
tri!(self.de.parse_whitespace())
1904+
tri!(self.de.parse_whitespace_in_value())
19561905
}
1957-
Some(b) => {
1906+
b => {
19581907
if self.first {
19591908
self.first = false;
1960-
Some(b)
1909+
b
19611910
} else {
19621911
return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
19631912
}
19641913
}
1965-
None => {
1966-
return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject));
1967-
}
19681914
};
19691915

19701916
match peek {
1971-
Some(b'"') => seed.deserialize(MapKey { de: &mut *self.de }).map(Some),
1972-
Some(b'}') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1973-
Some(_) => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)),
1974-
None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
1917+
b'"' => seed.deserialize(MapKey { de: &mut *self.de }).map(Some),
1918+
b'}' => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1919+
_ => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)),
19751920
}
19761921
}
19771922

0 commit comments

Comments
 (0)