From 2795f0ed9d5dc63b8ab1c2b64368941c42a852c4 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 4 Apr 2017 18:18:47 -0700 Subject: [PATCH 1/3] Remove questionable type conversions --- serde/src/de/impls.rs | 52 ------------------------------------------- serde/src/utils.rs | 24 -------------------- 2 files changed, 76 deletions(-) diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs index 9b6f1f5d..1aa91db5 100644 --- a/serde/src/de/impls.rs +++ b/serde/src/de/impls.rs @@ -80,12 +80,6 @@ impl<'de> Visitor<'de> for UnitVisitor { { Ok(()) } - - fn visit_seq(self, _: V) -> Result<(), V::Error> - where V: SeqVisitor<'de> - { - Ok(()) - } } impl<'de> Deserialize<'de> for () { @@ -113,16 +107,6 @@ impl<'de> Visitor<'de> for BoolVisitor { { Ok(v) } - - fn visit_str(self, s: &str) -> Result - where E: Error - { - match s.trim_matches(::utils::Pattern_White_Space) { - "true" => Ok(true), - "false" => Ok(false), - _ => Err(Error::invalid_type(Unexpected::Str(s), &self)), - } - } } impl<'de> Deserialize<'de> for bool { @@ -175,15 +159,6 @@ macro_rules! impl_deserialize_num { impl_deserialize_num_method!($ty, u64, visit_u64, from_u64, Unsigned, u64); impl_deserialize_num_method!($ty, f32, visit_f32, from_f32, Float, f64); impl_deserialize_num_method!($ty, f64, visit_f64, from_f64, Float, f64); - - #[inline] - fn visit_str(self, s: &str) -> Result<$ty, E> - where E: Error, - { - str::FromStr::from_str(s.trim_matches(::utils::Pattern_White_Space)).or_else(|_| { - Err(Error::invalid_type(Unexpected::Str(s), &self)) - }) - } } deserializer.$method(PrimitiveVisitor) @@ -269,12 +244,6 @@ impl<'de> Visitor<'de> for StringVisitor { Ok(v) } - fn visit_unit(self) -> Result - where E: Error - { - Ok(String::new()) - } - fn visit_bytes(self, v: &[u8]) -> Result where E: Error { @@ -503,13 +472,6 @@ macro_rules! seq_impl { formatter.write_str("a sequence") } - #[inline] - fn visit_unit(self) -> Result - where E: Error, - { - Ok($ctor) - } - #[inline] fn visit_seq(self, mut $visitor: V) -> Result where V: SeqVisitor<'de>, @@ -613,13 +575,6 @@ impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 0]> formatter.write_str("an empty array") } - #[inline] - fn visit_unit(self) -> Result<[T; 0], E> - where E: Error - { - Ok([]) - } - #[inline] fn visit_seq(self, _: V) -> Result<[T; 0], V::Error> where V: SeqVisitor<'de> @@ -819,13 +774,6 @@ macro_rules! map_impl { formatter.write_str("a map") } - #[inline] - fn visit_unit(self) -> Result - where E: Error, - { - Ok($ctor) - } - #[inline] fn visit_map(self, mut $visitor: Visitor) -> Result where Visitor: MapVisitor<'de>, diff --git a/serde/src/utils.rs b/serde/src/utils.rs index 927d1256..4e81616a 100644 --- a/serde/src/utils.rs +++ b/serde/src/utils.rs @@ -48,27 +48,3 @@ impl EncodeUtf8 { ::core::str::from_utf8(&self.buf[self.pos..]).unwrap() } } - -#[allow(non_upper_case_globals)] -const Pattern_White_Space_table: &'static [(char, char)] = &[('\u{9}', '\u{d}'), - ('\u{20}', '\u{20}'), - ('\u{85}', '\u{85}'), - ('\u{200e}', '\u{200f}'), - ('\u{2028}', '\u{2029}')]; - -fn bsearch_range_table(c: char, r: &'static [(char, char)]) -> bool { - use core::cmp::Ordering::{Equal, Less, Greater}; - r.binary_search_by(|&(lo, hi)| if c < lo { - Greater - } else if hi < c { - Less - } else { - Equal - }) - .is_ok() -} - -#[allow(non_snake_case)] -pub fn Pattern_White_Space(c: char) -> bool { - bsearch_range_table(c, Pattern_White_Space_table) -} From 7a722d506091dc28c541225d441275a110a1dc29 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 4 Apr 2017 18:38:58 -0700 Subject: [PATCH 2/3] Remove questionable conversion tests --- test_suite/tests/test_de.rs | 51 ------------------------------------- 1 file changed, 51 deletions(-) diff --git a/test_suite/tests/test_de.rs b/test_suite/tests/test_de.rs index 8d21844c..ab7b112e 100644 --- a/test_suite/tests/test_de.rs +++ b/test_suite/tests/test_de.rs @@ -245,18 +245,6 @@ declare_tests! { } test_unit { () => &[Token::Unit], - () => &[ - Token::SeqStart(Some(0)), - Token::SeqEnd, - ], - () => &[ - Token::SeqStart(None), - Token::SeqEnd, - ], - () => &[ - Token::TupleStructStart("Anything", 0), - Token::TupleStructEnd, - ], } test_unit_struct { UnitStruct => &[Token::Unit], @@ -272,9 +260,6 @@ declare_tests! { Token::SeqEnd, ], } - test_unit_string { - String::new() => &[Token::Unit], - } test_tuple_struct { TupleStruct(1, 2, 3) => &[ Token::SeqStart(Some(3)), @@ -326,9 +311,6 @@ declare_tests! { ], } test_btreeset { - BTreeSet::::new() => &[ - Token::Unit, - ], BTreeSet::::new() => &[ Token::SeqStart(Some(0)), Token::SeqEnd, @@ -355,18 +337,12 @@ declare_tests! { Token::SeqEnd, Token::SeqEnd, ], - BTreeSet::::new() => &[ - Token::UnitStruct("Anything"), - ], BTreeSet::::new() => &[ Token::TupleStructStart("Anything", 0), Token::TupleStructEnd, ], } test_hashset { - HashSet::::new() => &[ - Token::Unit, - ], HashSet::::new() => &[ Token::SeqStart(Some(0)), Token::SeqEnd, @@ -383,9 +359,6 @@ declare_tests! { Token::I32(3), Token::SeqEnd, ], - HashSet::::new() => &[ - Token::UnitStruct("Anything"), - ], HashSet::::new() => &[ Token::TupleStructStart("Anything", 0), Token::TupleStructEnd, @@ -404,9 +377,6 @@ declare_tests! { ], } test_vec { - Vec::::new() => &[ - Token::Unit, - ], Vec::::new() => &[ Token::SeqStart(Some(0)), Token::SeqEnd, @@ -433,18 +403,12 @@ declare_tests! { Token::SeqEnd, Token::SeqEnd, ], - Vec::::new() => &[ - Token::UnitStruct("Anything"), - ], Vec::::new() => &[ Token::TupleStructStart("Anything", 0), Token::TupleStructEnd, ], } test_array { - [0; 0] => &[ - Token::Unit, - ], [0; 0] => &[ Token::SeqStart(Some(0)), Token::SeqEnd, @@ -497,9 +461,6 @@ declare_tests! { Token::SeqEnd, Token::SeqEnd, ], - [0; 0] => &[ - Token::UnitStruct("Anything"), - ], [0; 0] => &[ Token::TupleStructStart("Anything", 0), Token::TupleStructEnd, @@ -544,9 +505,6 @@ declare_tests! { ], } test_btreemap { - BTreeMap::::new() => &[ - Token::Unit, - ], BTreeMap::::new() => &[ Token::MapStart(Some(0)), Token::MapEnd, @@ -589,18 +547,12 @@ declare_tests! { Token::MapEnd, Token::MapEnd, ], - BTreeMap::::new() => &[ - Token::UnitStruct("Anything"), - ], BTreeMap::::new() => &[ Token::StructStart("Anything", 0), Token::StructEnd, ], } test_hashmap { - HashMap::::new() => &[ - Token::Unit, - ], HashMap::::new() => &[ Token::MapStart(Some(0)), Token::MapEnd, @@ -643,9 +595,6 @@ declare_tests! { Token::MapEnd, Token::MapEnd, ], - HashMap::::new() => &[ - Token::UnitStruct("Anything"), - ], HashMap::::new() => &[ Token::StructStart("Anything", 0), Token::StructEnd, From d03ecda3339aee04cc60fb29ab4d9251015ac984 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 4 Apr 2017 18:50:40 -0700 Subject: [PATCH 3/3] Test that conversions do not happen --- test_suite/tests/test_de.rs | 111 ++++++++++++++++++++++++++++++++++++ 1 file changed, 111 insertions(+) diff --git a/test_suite/tests/test_de.rs b/test_suite/tests/test_de.rs index ab7b112e..552e58cb 100644 --- a/test_suite/tests/test_de.rs +++ b/test_suite/tests/test_de.rs @@ -1068,4 +1068,115 @@ declare_error_tests! { ], Error::Message("nul byte found in provided data at position: 2".into()), } + test_unit_from_empty_seq<()> { + &[ + Token::SeqStart(Some(0)), + Token::SeqEnd, + ], + Error::Message("invalid type: sequence, expected unit".into()), + } + test_unit_from_empty_seq_without_len<()> { + &[ + Token::SeqStart(None), + Token::SeqEnd, + ], + Error::Message("invalid type: sequence, expected unit".into()), + } + test_unit_from_tuple_struct<()> { + &[ + Token::TupleStructStart("Anything", 0), + Token::TupleStructEnd, + ], + Error::Message("invalid type: sequence, expected unit".into()), + } + test_string_from_unit { + &[ + Token::Unit, + ], + Error::Message("invalid type: unit value, expected a string".into()), + } + test_btreeset_from_unit> { + &[ + Token::Unit, + ], + Error::Message("invalid type: unit value, expected a sequence".into()), + } + test_btreeset_from_unit_struct> { + &[ + Token::UnitStruct("Anything"), + ], + Error::Message("invalid type: unit value, expected a sequence".into()), + } + test_hashset_from_unit> { + &[ + Token::Unit, + ], + Error::Message("invalid type: unit value, expected a sequence".into()), + } + test_hashset_from_unit_struct> { + &[ + Token::UnitStruct("Anything"), + ], + Error::Message("invalid type: unit value, expected a sequence".into()), + } + test_vec_from_unit> { + &[ + Token::Unit, + ], + Error::Message("invalid type: unit value, expected a sequence".into()), + } + test_vec_from_unit_struct> { + &[ + Token::UnitStruct("Anything"), + ], + Error::Message("invalid type: unit value, expected a sequence".into()), + } + test_zero_array_from_unit<[isize; 0]> { + &[ + Token::Unit, + ], + Error::Message("invalid type: unit value, expected an empty array".into()), + } + test_zero_array_from_unit_struct<[isize; 0]> { + &[ + Token::UnitStruct("Anything"), + ], + Error::Message("invalid type: unit value, expected an empty array".into()), + } + test_btreemap_from_unit> { + &[ + Token::Unit, + ], + Error::Message("invalid type: unit value, expected a map".into()), + } + test_btreemap_from_unit_struct> { + &[ + Token::UnitStruct("Anything"), + ], + Error::Message("invalid type: unit value, expected a map".into()), + } + test_hashmap_from_unit> { + &[ + Token::Unit, + ], + Error::Message("invalid type: unit value, expected a map".into()), + } + test_hashmap_from_unit_struct> { + &[ + Token::UnitStruct("Anything"), + ], + Error::Message("invalid type: unit value, expected a map".into()), + } + test_bool_from_string { + &[ + Token::Str("false"), + ], + Error::Message("invalid type: string \"false\", expected a boolean".into()), + } + test_number_from_string { + &[ + Token::Str("1"), + ], + Error::Message("invalid type: string \"1\", expected isize".into()), + } }