Pass state to container advance methods (#18)

mitsuhiko · web-flow · commit 66ae3b642987 · 2022-02-10T20:54:46.000+01:00
The serializer state and deserializer state is now passed to `next_key`,
`next_value` and `next` on the sinks and emitters.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,8 @@ All notable changes to deser are documented here.
 - Made `Atom` non exhaustive and added `unexpected_atom` to `Deserialize`.
 - Removed `MapSink` and `SeqSink`.  The functionality of these is now
   directly on the `Sink`.
+- The serializer state and deserializer state is now passed to `next_key`/
+  `next_value` and `next` on the sinks and emitters.
 
 ## 0.5.0
 
diff --git a/deser-derive/src/de.rs b/deser-derive/src/de.rs
@@ -193,11 +193,15 @@ fn derive_struct(input: &syn::DeriveInput, fields: &syn::FieldsNamed) -> syn::Re
                     ::deser::__derive::Ok(())
                 }
 
-                fn next_key(&mut self) -> ::deser::__derive::Result<::deser::de::SinkHandle> {
+                fn next_key(&mut self, __state: &::deser::de::DeserializerState)
+                    -> ::deser::__derive::Result<::deser::de::SinkHandle>
+                {
                     ::deser::__derive::Ok(::deser::de::Deserialize::deserialize_into(&mut self.key))
                 }
 
-                fn next_value(&mut self) -> ::deser::__derive::Result<::deser::de::SinkHandle> {
+                fn next_value(&mut self, __state: &::deser::de::DeserializerState)
+                    -> ::deser::__derive::Result<::deser::de::SinkHandle>
+                {
                     match self.key.take().as_deref() {
                         #(
                             #matcher => ::deser::__derive::Ok(::deser::Deserialize::deserialize_into(&mut self.#sink_fieldname)),
diff --git a/deser-derive/src/ser.rs b/deser-derive/src/ser.rs
@@ -100,7 +100,9 @@ fn derive_struct(input: &syn::DeriveInput, fields: &syn::FieldsNamed) -> syn::Re
             }
 
             impl #wrapper_impl_generics ::deser::ser::StructEmitter for __StructEmitter #wrapper_ty_generics #bounded_where_clause {
-                fn next(&mut self) -> ::deser::__derive::Option<(deser::__derive::StrCow, ::deser::ser::SerializeHandle)> {
+                fn next(&mut self, __state: &::deser::ser::SerializerState)
+                    -> ::deser::__derive::Option<(deser::__derive::StrCow, ::deser::ser::SerializeHandle)>
+                {
                     loop {
                         let __index = self.index;
                         self.index = __index + 1;
diff --git a/deser-path/src/de.rs b/deser-path/src/de.rs
@@ -70,8 +70,8 @@ impl<'a> Sink for PathSink<'a> {
         self.sink.seq(state)
     }
 
-    fn next_key(&mut self) -> Result<SinkHandle, Error> {
-        self.sink.next_key().map(|sink| {
+    fn next_key(&mut self, state: &DeserializerState) -> Result<SinkHandle, Error> {
+        self.sink.next_key(state).map(|sink| {
             SinkHandle::boxed(PathSink {
                 sink,
                 container: match self.container {
@@ -83,7 +83,7 @@ impl<'a> Sink for PathSink<'a> {
         })
     }
 
-    fn next_value(&mut self) -> Result<SinkHandle, Error> {
+    fn next_value(&mut self, state: &DeserializerState) -> Result<SinkHandle, Error> {
         let set_segment = match self.container {
             Container::None => None,
             Container::Map(ref captured_key) => captured_key.borrow_mut().take(),
@@ -93,7 +93,7 @@ impl<'a> Sink for PathSink<'a> {
                 Some(PathSegment::Index(old_index))
             }
         };
-        self.sink.next_value().map(|sink| {
+        self.sink.next_value(state).map(|sink| {
             SinkHandle::boxed(PathSink {
                 sink,
                 container: Container::None,
diff --git a/deser-path/src/ser.rs b/deser-path/src/ser.rs
@@ -49,8 +49,8 @@ struct PathStructEmitter<'a> {
 }
 
 impl<'a> StructEmitter for PathStructEmitter<'a> {
-    fn next(&mut self) -> Option<(Cow<'_, str>, SerializeHandle)> {
-        let (key, value) = self.emitter.next()?;
+    fn next(&mut self, state: &SerializerState) -> Option<(Cow<'_, str>, SerializeHandle)> {
+        let (key, value) = self.emitter.next(state)?;
         let new_segment = PathSegment::Key(key.to_string());
         let value_serializable = SegmentPushingSerializable {
             serializable: value,
@@ -66,22 +66,22 @@ struct PathMapEmitter<'a> {
 }
 
 impl<'a> MapEmitter for PathMapEmitter<'a> {
-    fn next_key(&mut self) -> Option<SerializeHandle> {
+    fn next_key(&mut self, state: &SerializerState) -> Option<SerializeHandle> {
         let key_serializable = SegmentCollectingSerializable {
-            serializable: self.emitter.next_key()?,
+            serializable: self.emitter.next_key(state)?,
             segment: self.path_segment.clone(),
         };
         Some(SerializeHandle::boxed(key_serializable))
     }
 
-    fn next_value(&mut self) -> SerializeHandle {
+    fn next_value(&mut self, state: &SerializerState) -> SerializeHandle {
         let new_segment = self
             .path_segment
             .borrow_mut()
             .take()
             .unwrap_or(PathSegment::Unknown);
         let value_serializable = SegmentPushingSerializable {
-            serializable: self.emitter.next_value(),
+            serializable: self.emitter.next_value(state),
             segment: RefCell::new(Some(new_segment)),
         };
         SerializeHandle::boxed(value_serializable)
@@ -94,10 +94,10 @@ struct PathSeqEmitter<'a> {
 }
 
 impl<'a> SeqEmitter for PathSeqEmitter<'a> {
-    fn next(&mut self) -> Option<SerializeHandle> {
+    fn next(&mut self, state: &SerializerState) -> Option<SerializeHandle> {
         let index = self.index;
         self.index += 1;
-        let value = self.emitter.next()?;
+        let value = self.emitter.next(state)?;
         let new_segment = PathSegment::Index(index);
         let item_serializable = SegmentPushingSerializable {
             serializable: value,
diff --git a/deser/src/de/ignore.rs b/deser/src/de/ignore.rs
@@ -17,11 +17,11 @@ impl Sink for Ignore {
         Ok(())
     }
 
-    fn next_key(&mut self) -> Result<SinkHandle, Error> {
+    fn next_key(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {
         Ok(SinkHandle::null())
     }
 
-    fn next_value(&mut self) -> Result<SinkHandle, Error> {
+    fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {
         Ok(SinkHandle::null())
     }
 }
diff --git a/deser/src/de/impls.rs b/deser/src/de/impls.rs
@@ -263,7 +263,7 @@ impl<T: Deserialize> Deserialize for Vec<T> {
                 Ok(())
             }
 
-            fn next_value(&mut self) -> Result<SinkHandle, Error> {
+            fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {
                 self.flush();
                 Ok(Deserialize::deserialize_into(&mut self.element))
             }
@@ -325,12 +325,12 @@ where
                 Ok(())
             }
 
-            fn next_key(&mut self) -> Result<SinkHandle, Error> {
+            fn next_key(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {
                 self.flush();
                 Ok(Deserialize::deserialize_into(&mut self.key))
             }
 
-            fn next_value(&mut self) -> Result<SinkHandle, Error> {
+            fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {
                 Ok(Deserialize::deserialize_into(&mut self.value))
             }
 
@@ -388,12 +388,12 @@ where
                 &DESCRIPTOR
             }
 
-            fn next_key(&mut self) -> Result<SinkHandle, Error> {
+            fn next_key(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {
                 self.flush();
                 Ok(Deserialize::deserialize_into(&mut self.key))
             }
 
-            fn next_value(&mut self) -> Result<SinkHandle, Error> {
+            fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {
                 Ok(Deserialize::deserialize_into(&mut self.value))
             }
 
@@ -445,12 +445,12 @@ impl<'a> Sink for NullIgnoringSink<'a> {
         self.sink.seq(state)
     }
 
-    fn next_key(&mut self) -> Result<SinkHandle, Error> {
-        self.sink.next_key()
+    fn next_key(&mut self, state: &DeserializerState) -> Result<SinkHandle, Error> {
+        self.sink.next_key(state)
     }
 
-    fn next_value(&mut self) -> Result<SinkHandle, Error> {
-        self.sink.next_value()
+    fn next_value(&mut self, state: &DeserializerState) -> Result<SinkHandle, Error> {
+        self.sink.next_value(state)
     }
 
     fn descriptor(&self) -> &dyn Descriptor {
@@ -483,7 +483,7 @@ macro_rules! deserialize_for_tuple {
                         Ok(())
                     }
 
-                    fn next_value(&mut self) -> Result<SinkHandle, Error> {
+                    fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {
                         let __index = self.index;
                         self.index += 1;
                         let mut __counter = 0;
@@ -603,7 +603,7 @@ impl<T: Deserialize, const N: usize> Deserialize for [T; N] {
                 Ok(())
             }
 
-            fn next_value(&mut self) -> Result<SinkHandle, Error> {
+            fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {
                 unsafe {
                     self.flush();
                 }
diff --git a/deser/src/de/mod.rs b/deser/src/de/mod.rs
@@ -114,14 +114,14 @@
 //!         Ok(())
 //!     }
 //!
-//!     fn next_key(&mut self) -> Result<SinkHandle, Error> {
+//!     fn next_key(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {
 //!         // directly attach to the key field which can hold any
 //!         // string value.  This means that any string is accepted
 //!         // as key.
 //!         Ok(Deserialize::deserialize_into(&mut self.key))
 //!     }
 //!     
-//!     fn next_value(&mut self) -> Result<SinkHandle, Error> {
+//!     fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {
 //!         // whenever we are looking for a value slot, look at the last key
 //!         // to decide which value slot to connect.
 //!         match self.key.take().as_deref() {
@@ -337,12 +337,14 @@ pub trait Sink {
     }
 
     /// Returns a sink for the next key in a map.
-    fn next_key(&mut self) -> Result<SinkHandle, Error> {
+    fn next_key(&mut self, state: &DeserializerState) -> Result<SinkHandle, Error> {
+        let _ = state;
         Ok(SinkHandle::null())
     }
 
     /// Returns a sink for the next value in a map or sequence.
-    fn next_value(&mut self) -> Result<SinkHandle, Error> {
+    fn next_value(&mut self, state: &DeserializerState) -> Result<SinkHandle, Error> {
+        let _ = state;
         Ok(SinkHandle::null())
     }
 
@@ -370,7 +372,7 @@ pub trait Sink {
 /// Gives access to the deserializer state.
 pub struct DeserializerState<'a> {
     extensions: Extensions,
-    stack: ManuallyDrop<Vec<(SinkHandleWrapper, Layer)>>,
+    descriptor_stack: Vec<&'a dyn Descriptor>,
     _marker: PhantomData<&'a Driver<'a>>,
 }
 
@@ -387,14 +389,14 @@ impl<'a> DeserializerState<'a> {
 
     /// Returns the current recursion depth.
     pub fn depth(&self) -> usize {
-        self.stack.len()
+        self.descriptor_stack.len()
     }
 
     /// Returns the topmost descriptor.
     ///
     /// This descriptor always points to a container as the descriptor.
     pub fn top_descriptor(&self) -> Option<&dyn Descriptor> {
-        self.stack.last().map(|x| x.0.sink.descriptor())
+        self.descriptor_stack.last().copied()
     }
 }
 
@@ -405,8 +407,9 @@ impl<'a> DeserializerState<'a> {
 /// internally impossible with safe code, this is a safe abstractiont that
 /// hides the unsafety internally.
 pub struct Driver<'a> {
-    state: ManuallyDrop<DeserializerState<'a>>,
+    state: DeserializerState<'a>,
     current_sink: Option<SinkHandleWrapper>,
+    sink_stack: ManuallyDrop<Vec<(SinkHandleWrapper, Layer)>>,
 }
 
 struct SinkHandleWrapper {
@@ -437,11 +440,12 @@ impl<'a> Driver<'a> {
     /// Creates a new deserializer driver from a sink.
     pub fn from_sink(sink: SinkHandle) -> Driver<'a> {
         Driver {
-            state: ManuallyDrop::new(DeserializerState {
+            state: DeserializerState {
                 extensions: Extensions::default(),
-                stack: ManuallyDrop::new(Vec::new()),
+                descriptor_stack: Vec::new(),
                 _marker: PhantomData,
-            }),
+            },
+            sink_stack: ManuallyDrop::new(Default::default()),
             current_sink: Some(unsafe { SinkHandleWrapper::from(sink) }),
         }
     }
@@ -467,19 +471,20 @@ impl<'a> Driver<'a> {
     fn _emit(&mut self, event: Event) -> Result<(), Error> {
         macro_rules! target_sink {
             () => {{
-                match self.state.stack.last_mut() {
+                match self.sink_stack.last_mut() {
                     Some((map_sink, Layer::Map(ref mut is_key))) => {
                         let next_sink = if *is_key {
-                            map_sink.sink.next_key()?
+                            map_sink.sink.next_key(&self.state)?
                         } else {
-                            map_sink.sink.next_value()?
+                            map_sink.sink.next_value(&self.state)?
                         };
                         *is_key = !*is_key;
                         self.current_sink = Some(unsafe { SinkHandleWrapper::from(next_sink) });
                     }
                     Some((seq_sink, Layer::Seq)) => {
-                        self.current_sink =
-                            Some(unsafe { SinkHandleWrapper::from(seq_sink.sink.next_value()?) });
+                        self.current_sink = Some(unsafe {
+                            SinkHandleWrapper::from(seq_sink.sink.next_value(&self.state)?)
+                        });
                     }
                     _ => {}
                 }
@@ -501,29 +506,37 @@ impl<'a> Driver<'a> {
             Event::MapStart => {
                 let current_sink = target_sink!();
                 current_sink.map(&self.state)?;
+                let descriptor = current_sink.descriptor();
                 self.state
-                    .stack
+                    .descriptor_stack
+                    .push(unsafe { extend_lifetime!(descriptor, &dyn Descriptor) });
+                self.sink_stack
                     .push((self.current_sink.take().unwrap(), Layer::Map(true)));
                 return Ok(());
             }
-            Event::MapEnd => match self.state.stack.pop() {
+            Event::MapEnd => match self.sink_stack.pop() {
                 Some((mut map_sink, Layer::Map(_))) => {
                     map_sink.sink.finish(&self.state)?;
+                    self.state.descriptor_stack.pop();
                     self.current_sink = Some(map_sink);
                 }
                 _ => panic!("not inside a MapSink"),
             },
             Event::SeqStart => {
                 let current_sink = target_sink!();
                 current_sink.seq(&self.state)?;
+                let descriptor = current_sink.descriptor();
                 self.state
-                    .stack
+                    .descriptor_stack
+                    .push(unsafe { extend_lifetime!(descriptor, &dyn Descriptor) });
+                self.sink_stack
                     .push((self.current_sink.take().unwrap(), Layer::Seq));
                 return Ok(());
             }
-            Event::SeqEnd => match self.state.stack.pop() {
+            Event::SeqEnd => match self.sink_stack.pop() {
                 Some((mut seq_sink, Layer::Seq)) => {
                     seq_sink.sink.finish(&self.state)?;
+                    self.state.descriptor_stack.pop();
                     self.current_sink = Some(seq_sink);
                 }
                 _ => panic!("not inside a SeqSink"),
@@ -538,13 +551,11 @@ impl<'a> Driver<'a> {
 
 impl<'a> Drop for Driver<'a> {
     fn drop(&mut self) {
-        // it's important that we drop the values in inverse order.
-        while let Some(_last) = self.state.stack.pop() {
-            // drop in inverse order
-        }
         unsafe {
-            ManuallyDrop::drop(&mut self.state.stack);
-            ManuallyDrop::drop(&mut self.state);
+            while let Some(_item) = self.sink_stack.pop() {
+                // drop in inverse order
+            }
+            ManuallyDrop::drop(&mut self.sink_stack);
         }
     }
 }
diff --git a/deser/src/ser/impls.rs b/deser/src/ser/impls.rs
diff --git a/deser/src/ser/mod.rs b/deser/src/ser/mod.rs
diff --git a/deser/tests/test_custom_map.rs b/deser/tests/test_custom_map.rs
diff --git a/examples/manual-struct/src/main.rs b/examples/manual-struct/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -17,11 +17,11 @@ impl Sink for Ignore {`
`17`	`17`	`Ok(())`
`18`	`18`	`}`
`19`	`19`
`20`		`- fn next_key(&mut self) -> Result<SinkHandle, Error> {`
	`20`	`+ fn next_key(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {`
`21`	`21`	`Ok(SinkHandle::null())`
`22`	`22`	`}`
`23`	`23`
`24`		`- fn next_value(&mut self) -> Result<SinkHandle, Error> {`
	`24`	`+ fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {`
`25`	`25`	`Ok(SinkHandle::null())`
`26`	`26`	`}`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -263,7 +263,7 @@ impl<T: Deserialize> Deserialize for Vec<T> {`
`263`	`263`	`Ok(())`
`264`	`264`	`}`
`265`	`265`
`266`		`- fn next_value(&mut self) -> Result<SinkHandle, Error> {`
	`266`	`+ fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {`
`267`	`267`	`self.flush();`
`268`	`268`	`Ok(Deserialize::deserialize_into(&mut self.element))`
`269`	`269`	`}`
`@@ -325,12 +325,12 @@ where`
`325`	`325`	`Ok(())`
`326`	`326`	`}`
`327`	`327`
`328`		`- fn next_key(&mut self) -> Result<SinkHandle, Error> {`
	`328`	`+ fn next_key(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {`
`329`	`329`	`self.flush();`
`330`	`330`	`Ok(Deserialize::deserialize_into(&mut self.key))`
`331`	`331`	`}`
`332`	`332`
`333`		`- fn next_value(&mut self) -> Result<SinkHandle, Error> {`
	`333`	`+ fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {`
`334`	`334`	`Ok(Deserialize::deserialize_into(&mut self.value))`
`335`	`335`	`}`
`336`	`336`
`@@ -388,12 +388,12 @@ where`
`388`	`388`	`&DESCRIPTOR`
`389`	`389`	`}`
`390`	`390`
`391`		`- fn next_key(&mut self) -> Result<SinkHandle, Error> {`
	`391`	`+ fn next_key(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {`
`392`	`392`	`self.flush();`
`393`	`393`	`Ok(Deserialize::deserialize_into(&mut self.key))`
`394`	`394`	`}`
`395`	`395`
`396`		`- fn next_value(&mut self) -> Result<SinkHandle, Error> {`
	`396`	`+ fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {`
`397`	`397`	`Ok(Deserialize::deserialize_into(&mut self.value))`
`398`	`398`	`}`
`399`	`399`
`@@ -445,12 +445,12 @@ impl<'a> Sink for NullIgnoringSink<'a> {`
`445`	`445`	`self.sink.seq(state)`
`446`	`446`	`}`
`447`	`447`
`448`		`- fn next_key(&mut self) -> Result<SinkHandle, Error> {`
`449`		`- self.sink.next_key()`
	`448`	`+ fn next_key(&mut self, state: &DeserializerState) -> Result<SinkHandle, Error> {`
	`449`	`+ self.sink.next_key(state)`
`450`	`450`	`}`
`451`	`451`
`452`		`- fn next_value(&mut self) -> Result<SinkHandle, Error> {`
`453`		`- self.sink.next_value()`
	`452`	`+ fn next_value(&mut self, state: &DeserializerState) -> Result<SinkHandle, Error> {`
	`453`	`+ self.sink.next_value(state)`
`454`	`454`	`}`
`455`	`455`
`456`	`456`	`fn descriptor(&self) -> &dyn Descriptor {`
`@@ -483,7 +483,7 @@ macro_rules! deserialize_for_tuple {`
`483`	`483`	`Ok(())`
`484`	`484`	`}`
`485`	`485`
`486`		`- fn next_value(&mut self) -> Result<SinkHandle, Error> {`
	`486`	`+ fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {`
`487`	`487`	`let __index = self.index;`
`488`	`488`	`self.index += 1;`
`489`	`489`	`let mut __counter = 0;`
`@@ -603,7 +603,7 @@ impl<T: Deserialize, const N: usize> Deserialize for [T; N] {`
`603`	`603`	`Ok(())`
`604`	`604`	`}`
`605`	`605`
`606`		`- fn next_value(&mut self) -> Result<SinkHandle, Error> {`
	`606`	`+ fn next_value(&mut self, _state: &DeserializerState) -> Result<SinkHandle, Error> {`
`607`	`607`	`unsafe {`
`608`	`608`	`self.flush();`
`609`	`609`	`}`