From 87424370364fa391214d4a55feaf9d3606add9e0 Mon Sep 17 00:00:00 2001 From: Jason Volk Date: Fri, 1 Nov 2024 22:43:26 +0000 Subject: [PATCH] wrap unimplemented ser/de branches with internal macro Signed-off-by: Jason Volk --- src/database/de.rs | 34 ++++++++++++++++--------------- src/database/mod.rs | 2 +- src/database/ser.rs | 48 ++++++++++++++++++++++---------------------- src/database/util.rs | 23 +++++++++++++++++++++ 4 files changed, 66 insertions(+), 41 deletions(-) diff --git a/src/database/de.rs b/src/database/de.rs index 0e074fdb..d7dc1102 100644 --- a/src/database/de.rs +++ b/src/database/de.rs @@ -5,6 +5,8 @@ use serde::{ Deserialize, }; +use crate::util::unhandled; + /// Deserialize into T from buffer. pub(crate) fn from_slice<'a, T>(buf: &'a [u8]) -> Result where @@ -192,7 +194,7 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { match name { "Ignore" => self.record_ignore(), "IgnoreAll" => self.record_ignore_all(), - _ => unimplemented!("Unrecognized deserialization Directive {name:?}"), + _ => unhandled!("Unrecognized deserialization Directive {name:?}"), }; visitor.visit_unit() @@ -214,27 +216,27 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { where V: Visitor<'de>, { - unimplemented!("deserialize Enum not implemented") + unhandled!("deserialize Enum not implemented") } fn deserialize_option>(self, _visitor: V) -> Result { - unimplemented!("deserialize Option not implemented") + unhandled!("deserialize Option not implemented") } fn deserialize_bool>(self, _visitor: V) -> Result { - unimplemented!("deserialize bool not implemented") + unhandled!("deserialize bool not implemented") } fn deserialize_i8>(self, _visitor: V) -> Result { - unimplemented!("deserialize i8 not implemented") + unhandled!("deserialize i8 not implemented") } fn deserialize_i16>(self, _visitor: V) -> Result { - unimplemented!("deserialize i16 not implemented") + unhandled!("deserialize i16 not implemented") } fn deserialize_i32>(self, _visitor: V) -> Result { - unimplemented!("deserialize i32 not implemented") + unhandled!("deserialize i32 not implemented") } fn deserialize_i64>(self, visitor: V) -> Result { @@ -244,15 +246,15 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { } fn deserialize_u8>(self, _visitor: V) -> Result { - unimplemented!("deserialize u8 not implemented; try dereferencing the Handle for [u8] access instead") + unhandled!("deserialize u8 not implemented; try dereferencing the Handle for [u8] access instead") } fn deserialize_u16>(self, _visitor: V) -> Result { - unimplemented!("deserialize u16 not implemented") + unhandled!("deserialize u16 not implemented") } fn deserialize_u32>(self, _visitor: V) -> Result { - unimplemented!("deserialize u32 not implemented") + unhandled!("deserialize u32 not implemented") } fn deserialize_u64>(self, visitor: V) -> Result { @@ -262,15 +264,15 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { } fn deserialize_f32>(self, _visitor: V) -> Result { - unimplemented!("deserialize f32 not implemented") + unhandled!("deserialize f32 not implemented") } fn deserialize_f64>(self, _visitor: V) -> Result { - unimplemented!("deserialize f64 not implemented") + unhandled!("deserialize f64 not implemented") } fn deserialize_char>(self, _visitor: V) -> Result { - unimplemented!("deserialize char not implemented") + unhandled!("deserialize char not implemented") } fn deserialize_str>(self, visitor: V) -> Result { @@ -291,11 +293,11 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { } fn deserialize_byte_buf>(self, _visitor: V) -> Result { - unimplemented!("deserialize Byte Buf not implemented") + unhandled!("deserialize Byte Buf not implemented") } fn deserialize_unit>(self, _visitor: V) -> Result { - unimplemented!("deserialize Unit not implemented") + unhandled!("deserialize Unit not implemented") } // this only used for $serde_json::private::RawValue at this time; see MapAccess @@ -305,7 +307,7 @@ impl<'a, 'de: 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { } fn deserialize_ignored_any>(self, _visitor: V) -> Result { - unimplemented!("deserialize Ignored Any not implemented") + unhandled!("deserialize Ignored Any not implemented") } fn deserialize_any>(self, visitor: V) -> Result { diff --git a/src/database/mod.rs b/src/database/mod.rs index dcd66a1e..f09c4a71 100644 --- a/src/database/mod.rs +++ b/src/database/mod.rs @@ -11,7 +11,7 @@ mod opts; mod ser; mod stream; mod tests; -mod util; +pub(crate) mod util; mod watchers; pub(crate) use self::{ diff --git a/src/database/ser.rs b/src/database/ser.rs index 0cc5c886..961d2700 100644 --- a/src/database/ser.rs +++ b/src/database/ser.rs @@ -4,6 +4,8 @@ use arrayvec::ArrayVec; use conduit::{debug::type_name, err, result::DebugInspect, utils::exchange, Error, Result}; use serde::{ser, Serialize}; +use crate::util::unhandled; + #[inline] pub fn serialize_to_array(val: T) -> Result> where @@ -146,17 +148,15 @@ impl ser::Serializer for &mut Serializer<'_, W> { fn serialize_tuple_variant( self, _name: &'static str, _idx: u32, _var: &'static str, _len: usize, ) -> Result { - unimplemented!("serialize Tuple Variant not implemented") + unhandled!("serialize Tuple Variant not implemented") } fn serialize_map(self, _len: Option) -> Result { - unimplemented!( - "serialize Map not implemented; did you mean to use database::Json() around your serde_json::Value?" - ) + unhandled!("serialize Map not implemented; did you mean to use database::Json() around your serde_json::Value?") } fn serialize_struct(self, _name: &'static str, _len: usize) -> Result { - unimplemented!( + unhandled!( "serialize Struct not implemented at this time; did you mean to use database::Json() around your struct?" ) } @@ -164,7 +164,7 @@ impl ser::Serializer for &mut Serializer<'_, W> { fn serialize_struct_variant( self, _name: &'static str, _idx: u32, _var: &'static str, _len: usize, ) -> Result { - unimplemented!("serialize Struct Variant not implemented") + unhandled!("serialize Struct Variant not implemented") } #[allow(clippy::needless_borrows_for_generic_args)] // buggy @@ -179,14 +179,14 @@ impl ser::Serializer for &mut Serializer<'_, W> { match name { "Json" => serde_json::to_writer(&mut self.out, value).map_err(Into::into), - _ => unimplemented!("Unrecognized serialization Newtype {name:?}"), + _ => unhandled!("Unrecognized serialization Newtype {name:?}"), } } fn serialize_newtype_variant( self, _name: &'static str, _idx: u32, _var: &'static str, _value: &T, ) -> Result { - unimplemented!("serialize Newtype Variant not implemented") + unhandled!("serialize Newtype Variant not implemented") } fn serialize_unit_struct(self, name: &'static str) -> Result { @@ -197,14 +197,14 @@ impl ser::Serializer for &mut Serializer<'_, W> { "Separator" => { self.separator()?; }, - _ => unimplemented!("Unrecognized serialization directive: {name:?}"), + _ => unhandled!("Unrecognized serialization directive: {name:?}"), }; Ok(()) } fn serialize_unit_variant(self, _name: &'static str, _idx: u32, _var: &'static str) -> Result { - unimplemented!("serialize Unit Variant not implemented") + unhandled!("serialize Unit Variant not implemented") } fn serialize_some(self, val: &T) -> Result { val.serialize(self) } @@ -234,29 +234,29 @@ impl ser::Serializer for &mut Serializer<'_, W> { self.write(v) } - fn serialize_f64(self, _v: f64) -> Result { unimplemented!("serialize f64 not implemented") } + fn serialize_f64(self, _v: f64) -> Result { unhandled!("serialize f64 not implemented") } - fn serialize_f32(self, _v: f32) -> Result { unimplemented!("serialize f32 not implemented") } + fn serialize_f32(self, _v: f32) -> Result { unhandled!("serialize f32 not implemented") } fn serialize_i64(self, v: i64) -> Result { self.write(&v.to_be_bytes()) } fn serialize_i32(self, v: i32) -> Result { self.write(&v.to_be_bytes()) } - fn serialize_i16(self, _v: i16) -> Result { unimplemented!("serialize i16 not implemented") } + fn serialize_i16(self, _v: i16) -> Result { unhandled!("serialize i16 not implemented") } - fn serialize_i8(self, _v: i8) -> Result { unimplemented!("serialize i8 not implemented") } + fn serialize_i8(self, _v: i8) -> Result { unhandled!("serialize i8 not implemented") } fn serialize_u64(self, v: u64) -> Result { self.write(&v.to_be_bytes()) } fn serialize_u32(self, v: u32) -> Result { self.write(&v.to_be_bytes()) } - fn serialize_u16(self, _v: u16) -> Result { unimplemented!("serialize u16 not implemented") } + fn serialize_u16(self, _v: u16) -> Result { unhandled!("serialize u16 not implemented") } fn serialize_u8(self, v: u8) -> Result { self.write(&[v]) } - fn serialize_bool(self, _v: bool) -> Result { unimplemented!("serialize bool not implemented") } + fn serialize_bool(self, _v: bool) -> Result { unhandled!("serialize bool not implemented") } - fn serialize_unit(self) -> Result { unimplemented!("serialize unit not implemented") } + fn serialize_unit(self) -> Result { unhandled!("serialize unit not implemented") } } impl ser::SerializeSeq for &mut Serializer<'_, W> { @@ -309,14 +309,14 @@ impl ser::SerializeMap for &mut Serializer<'_, W> { type Ok = (); fn serialize_key(&mut self, _key: &T) -> Result { - unimplemented!("serialize Map Key not implemented") + unhandled!("serialize Map Key not implemented") } fn serialize_value(&mut self, _val: &T) -> Result { - unimplemented!("serialize Map Val not implemented") + unhandled!("serialize Map Val not implemented") } - fn end(self) -> Result { unimplemented!("serialize Map End not implemented") } + fn end(self) -> Result { unhandled!("serialize Map End not implemented") } } impl ser::SerializeStruct for &mut Serializer<'_, W> { @@ -324,10 +324,10 @@ impl ser::SerializeStruct for &mut Serializer<'_, W> { type Ok = (); fn serialize_field(&mut self, _key: &'static str, _val: &T) -> Result { - unimplemented!("serialize Struct Field not implemented") + unhandled!("serialize Struct Field not implemented") } - fn end(self) -> Result { unimplemented!("serialize Struct End not implemented") } + fn end(self) -> Result { unhandled!("serialize Struct End not implemented") } } impl ser::SerializeStructVariant for &mut Serializer<'_, W> { @@ -335,8 +335,8 @@ impl ser::SerializeStructVariant for &mut Serializer<'_, W> { type Ok = (); fn serialize_field(&mut self, _key: &'static str, _val: &T) -> Result { - unimplemented!("serialize Struct Variant Field not implemented") + unhandled!("serialize Struct Variant Field not implemented") } - fn end(self) -> Result { unimplemented!("serialize Struct Variant End not implemented") } + fn end(self) -> Result { unhandled!("serialize Struct Variant End not implemented") } } diff --git a/src/database/util.rs b/src/database/util.rs index d36e183f..ae076381 100644 --- a/src/database/util.rs +++ b/src/database/util.rs @@ -1,6 +1,29 @@ use conduit::{err, Result}; use rocksdb::{Direction, IteratorMode}; +//#[cfg(debug_assertions)] +macro_rules! unhandled { + ($msg:literal) => { + unimplemented!($msg) + }; +} + +// activate when stable; we're not ready for this yet +#[cfg(disable)] // #[cfg(not(debug_assertions))] +macro_rules! unhandled { + ($msg:literal) => { + // SAFETY: Eliminates branches for serializing and deserializing types never + // encountered in the codebase. This can promote optimization and reduce + // codegen. The developer must verify for every invoking callsite that the + // unhandled type is in no way involved and could not possibly be encountered. + unsafe { + std::hint::unreachable_unchecked(); + } + }; +} + +pub(crate) use unhandled; + #[inline] pub(crate) fn _into_direction(mode: &IteratorMode<'_>) -> Direction { use Direction::{Forward, Reverse};