Return None after stream deserializer has failed

dtolnay · dtolnay · commit e99e9d3713b4 · 2020-04-04T16:00:50.000-07:00
diff --git a/src/de.rs b/src/de.rs
@@ -151,6 +151,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
         StreamDeserializer {
             de: self,
             offset: offset,
+            failed: false,
             output: PhantomData,
             lifetime: PhantomData,
         }
@@ -2046,6 +2047,7 @@ where
 pub struct StreamDeserializer<'de, R, T> {
     de: Deserializer<R>,
     offset: usize,
+    failed: bool,
     output: PhantomData<T>,
     lifetime: PhantomData<&'de ()>,
 }
@@ -2068,6 +2070,7 @@ where
         StreamDeserializer {
             de: Deserializer::new(read),
             offset: offset,
+            failed: false,
             output: PhantomData,
             lifetime: PhantomData,
         }
@@ -2132,6 +2135,10 @@ where
     type Item = Result<T>;
 
     fn next(&mut self) -> Option<Result<T>> {
+        if R::should_early_return_if_failed && self.failed {
+            return None;
+        }
+
         // skip whitespaces, if any
         // this helps with trailing whitespaces, since whitespaces between
         // values are handled for us.
@@ -2160,10 +2167,16 @@ where
                             self.peek_end_of_value().map(|_| value)
                         }
                     }
-                    Err(e) => Err(e),
+                    Err(e) => {
+                        self.de.read.set_failed(&mut self.failed);
+                        Err(e)
+                    }
                 })
             }
-            Err(e) => Some(Err(e)),
+            Err(e) => {
+                self.de.read.set_failed(&mut self.failed);
+                Some(Err(e))
+            }
         }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -337,6 +337,7 @@
     clippy::missing_errors_doc,
     clippy::must_use_candidate,
 )]
+#![allow(non_upper_case_globals)]
 #![deny(missing_docs)]
 #![cfg_attr(not(feature = "std"), no_std)]
 
diff --git a/src/read.rs b/src/read.rs
@@ -97,6 +97,18 @@ pub trait Read<'de>: private::Sealed {
     fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>;
+
+    /// Whether StreamDeserializer::next needs to check the failed flag. True
+    /// for IoRead, false for StrRead and SliceRead which can track failure by
+    /// truncating their input slice to avoid the extra check on every next
+    /// call.
+    #[doc(hidden)]
+    const should_early_return_if_failed: bool;
+
+    /// Mark a persistent failure of StreamDeserializer, either by setting the
+    /// flag or by truncating the input data.
+    #[doc(hidden)]
+    fn set_failed(&mut self, failed: &mut bool);
 }
 
 pub struct Position {
@@ -379,6 +391,13 @@ where
             raw_value: Some(raw),
         })
     }
+
+    const should_early_return_if_failed: bool = true;
+
+    #[inline]
+    fn set_failed(&mut self, failed: &mut bool) {
+        *failed = true;
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -590,6 +609,13 @@ impl<'a> Read<'a> for SliceRead<'a> {
             raw_value: Some(raw),
         })
     }
+
+    const should_early_return_if_failed: bool = false;
+
+    #[inline]
+    fn set_failed(&mut self, _failed: &mut bool) {
+        self.slice = &self.slice[..self.index];
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -681,6 +707,13 @@ impl<'a> Read<'a> for StrRead<'a> {
             raw_value: Some(raw),
         })
     }
+
+    const should_early_return_if_failed: bool = false;
+
+    #[inline]
+    fn set_failed(&mut self, failed: &mut bool) {
+        self.delegate.set_failed(failed);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////

Original file line number	Diff line number	Diff line change
`@@ -151,6 +151,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {`
`151`	`151`	`StreamDeserializer {`
`152`	`152`	`de: self,`
`153`	`153`	`offset: offset,`
	`154`	`+ failed: false,`
`154`	`155`	`output: PhantomData,`
`155`	`156`	`lifetime: PhantomData,`
`156`	`157`	`}`
`@@ -2046,6 +2047,7 @@ where`
`2046`	`2047`	`pub struct StreamDeserializer<'de, R, T> {`
`2047`	`2048`	`de: Deserializer<R>,`
`2048`	`2049`	`offset: usize,`
	`2050`	`+ failed: bool,`
`2049`	`2051`	`output: PhantomData<T>,`
`2050`	`2052`	`lifetime: PhantomData<&'de ()>,`
`2051`	`2053`	`}`
`@@ -2068,6 +2070,7 @@ where`
`2068`	`2070`	`StreamDeserializer {`
`2069`	`2071`	`de: Deserializer::new(read),`
`2070`	`2072`	`offset: offset,`
	`2073`	`+ failed: false,`
`2071`	`2074`	`output: PhantomData,`
`2072`	`2075`	`lifetime: PhantomData,`
`2073`	`2076`	`}`
`@@ -2132,6 +2135,10 @@ where`
`2132`	`2135`	`type Item = Result<T>;`
`2133`	`2136`
`2134`	`2137`	`fn next(&mut self) -> Option<Result<T>> {`
	`2138`	`+ if R::should_early_return_if_failed && self.failed {`
	`2139`	`+ return None;`
	`2140`	`+ }`
	`2141`	`+`
`2135`	`2142`	`// skip whitespaces, if any`
`2136`	`2143`	`// this helps with trailing whitespaces, since whitespaces between`
`2137`	`2144`	`// values are handled for us.`
`@@ -2160,10 +2167,16 @@ where`
`2160`	`2167`	`self.peek_end_of_value().map(\|_\| value)`
`2161`	`2168`	`}`
`2162`	`2169`	`}`
`2163`		`- Err(e) => Err(e),`
	`2170`	`+ Err(e) => {`
	`2171`	`+ self.de.read.set_failed(&mut self.failed);`
	`2172`	`+ Err(e)`
	`2173`	`+ }`
`2164`	`2174`	`})`
`2165`	`2175`	`}`
`2166`		`- Err(e) => Some(Err(e)),`
	`2176`	`+ Err(e) => {`
	`2177`	`+ self.de.read.set_failed(&mut self.failed);`
	`2178`	`+ Some(Err(e))`
	`2179`	`+ }`
`2167`	`2180`	`}`
`2168`	`2181`	`}`
`2169`	`2182`	`}`