Avoid direct transmutation

server/src/engine/data/tag.rs

@@ -47,7 +47,18 @@ pub enum TagClass {
 
 strid! {
     #[repr(u8)]
-    #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, PartialOrd, Ord, sky_macros::EnumMethods)]
+    #[derive(
+        Debug,
+        PartialEq,
+        Eq,
+        Clone,
+        Copy,
+        Hash,
+        PartialOrd,
+        Ord,
+        sky_macros::EnumMethods,
+        sky_macros::TaggedEnum,
+    )]
     pub enum TagSelector {
         Bool = 0,
         UInt8 = 1,
@@ -70,49 +81,57 @@ impl TagSelector {
     pub const fn into_full(self) -> FullTag {
         FullTag::new(self.tag_class(), self, self.tag_unique())
     }
-    pub const unsafe fn from_raw(v: u8) -> Self {
-        core::mem::transmute(v)
-    }
     pub const fn tag_unique(&self) -> TagUnique {
         [
-            TagUnique::Illegal,
-            TagUnique::UnsignedInt,
-            TagUnique::UnsignedInt,
-            TagUnique::UnsignedInt,
-            TagUnique::UnsignedInt,
-            TagUnique::SignedInt,
-            TagUnique::SignedInt,
-            TagUnique::SignedInt,
-            TagUnique::SignedInt,
-            TagUnique::Illegal,
-            TagUnique::Illegal,
-            TagUnique::Bin,
-            TagUnique::Str,
-            TagUnique::Illegal,
+            TagUnique::Illegal,     // bool
+            TagUnique::UnsignedInt, // uint8
+            TagUnique::UnsignedInt, // uint16
+            TagUnique::UnsignedInt, // uint32
+            TagUnique::UnsignedInt, // uint64
+            TagUnique::SignedInt,   // sint8
+            TagUnique::SignedInt,   // sint16
+            TagUnique::SignedInt,   // sint32
+            TagUnique::SignedInt,   // sint64
+            TagUnique::Illegal,     // f32
+            TagUnique::Illegal,     // f64
+            TagUnique::Bin,         // bin
+            TagUnique::Str,         // str
+            TagUnique::Illegal,     // list
         ][self.value_word()]
     }
     pub const fn tag_class(&self) -> TagClass {
         [
-            TagClass::Bool,
-            TagClass::UnsignedInt,
-            TagClass::UnsignedInt,
-            TagClass::UnsignedInt,
-            TagClass::UnsignedInt,
-            TagClass::SignedInt,
-            TagClass::SignedInt,
-            TagClass::SignedInt,
-            TagClass::SignedInt,
-            TagClass::Float,
-            TagClass::Float,
-            TagClass::Bin,
-            TagClass::Str,
-            TagClass::List,
+            TagClass::Bool,        // bool
+            TagClass::UnsignedInt, // uint8
+            TagClass::UnsignedInt, // uint16
+            TagClass::UnsignedInt, // uint32
+            TagClass::UnsignedInt, // uint64
+            TagClass::SignedInt,   // sint8
+            TagClass::SignedInt,   // sint16
+            TagClass::SignedInt,   // sint32
+            TagClass::SignedInt,   // sint64
+            TagClass::Float,       // f32
+            TagClass::Float,       // f64
+            TagClass::Bin,         // bin
+            TagClass::Str,         // str
+            TagClass::List,        // recursive list
         ][self.value_word()]
     }
 }
 
 #[repr(u8)]
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, PartialOrd, Ord, sky_macros::EnumMethods)]
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    Clone,
+    Copy,
+    Hash,
+    PartialOrd,
+    Ord,
+    sky_macros::EnumMethods,
+    sky_macros::TaggedEnum,
+)]
 pub enum TagUnique {
     UnsignedInt = 0,
     SignedInt = 1,
@@ -125,12 +144,6 @@ impl TagUnique {
     pub const fn is_unique(&self) -> bool {
         self.value_u8() != Self::Illegal.value_u8()
     }
-    pub const fn try_from_raw(raw: u8) -> Option<Self> {
-        if raw > 3 {
-            return None;
-        }
-        Some(unsafe { core::mem::transmute(raw) })
-    }
 }
 
 pub trait DataTag {

server/src/engine/net/protocol/handshake.rs

@@ -26,7 +26,7 @@
 
 use crate::{
     engine::mem::scanner::{BufferedScanner, ScannerDecodeResult},
-    util::compiler,
+    util::compiler::{self, TaggedEnum},
 };
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, sky_macros::EnumMethods)]
@@ -86,7 +86,7 @@ pub enum QueryMode {
     Bql1 = 0,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy, sky_macros::EnumMethods)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy, sky_macros::EnumMethods, sky_macros::TaggedEnum)]
 #[repr(u8)]
 /// the authentication mode
 pub enum AuthMode {
@@ -94,9 +94,6 @@ pub enum AuthMode {
 }
 
 impl AuthMode {
-    unsafe fn from_raw(v: u8) -> Self {
-        core::mem::transmute(v)
-    }
     /// returns the minimum number of metadata bytes need to parse the payload for this auth mode
     const fn min_payload_bytes(&self) -> usize {
         match self {

server/src/engine/storage/common/sdss/impls/sdss_r1/mod.rs

@@ -44,13 +44,10 @@ use {
             storage::common::interface::fs::{FileRead, FileWrite},
             RuntimeResult,
         },
-        util::os,
+        util::{compiler::TaggedEnum, os},
         IoResult,
     },
-    std::{
-        mem::{transmute, ManuallyDrop},
-        ops::Range,
-    },
+    std::{mem::ManuallyDrop, ops::Range},
 };
 
 pub const TEST_TIME: u128 = (u64::MAX / sizeof!(u64) as u64) as _;
@@ -59,22 +56,13 @@ pub const TEST_TIME: u128 = (u64::MAX / sizeof!(u64) as u64) as _;
     header utils
 */
 
-pub trait HeaderV1Enumeration {
-    /// the maximum value of this enumeration
-    const MAX: u8;
-    /// Create a new enumeration, given that the maximum is validated
-    unsafe fn new(x: u8) -> Self;
-    /// Return the 1B repr of the enumeration
-    fn repr_u8(&self) -> u8;
-}
-
 /// A trait that enables customizing the SDSS header for a specific version tuple
 pub trait HeaderV1Spec {
     // types
     /// The file class type
-    type FileClass: HeaderV1Enumeration + Copy + PartialEq;
+    type FileClass: TaggedEnum<Dscr = u8> + Copy + PartialEq;
     /// The file specifier type
-    type FileSpecifier: HeaderV1Enumeration + Copy + PartialEq;
+    type FileSpecifier: TaggedEnum<Dscr = u8> + Copy + PartialEq;
     // constants
     /// The server version to use during encode
     ///
@@ -232,8 +220,8 @@ impl<H: HeaderV1Spec> HeaderV1<H> {
         ret[Self::SEG2_REC1_HOST_PTR_WIDTH] = HostPointerWidth::new().value_u8();
         ret[Self::SEG2_REC1_HOST_ENDIAN] = HostEndian::new().value_u8();
         // 2.1.3
-        ret[Self::SEG2_REC1_FILE_CLASS] = file_class.repr_u8();
-        ret[Self::SEG2_REC1_FILE_SPECIFIER] = file_specifier.repr_u8();
+        ret[Self::SEG2_REC1_FILE_CLASS] = file_class.dscr();
+        ret[Self::SEG2_REC1_FILE_SPECIFIER] = file_specifier.dscr();
         ret[Self::SEG2_REC1_FILE_SPECIFIER_VERSION]
             .copy_from_slice(&file_specifier_version.little_endian());
         // 2.2
@@ -321,8 +309,8 @@ impl<H: HeaderV1Spec> HeaderV1<H> {
             raw_host_ptr_width <= HostPointerWidth::MAX,
             raw_host_endian <= HostEndian::MAX,
             // 2.1.3
-            raw_file_class <= H::FileClass::MAX,
-            raw_file_specifier <= H::FileSpecifier::MAX,
+            raw_file_class <= H::FileClass::MAX_DSCR,
+            raw_file_specifier <= H::FileSpecifier::MAX_DSCR,
         );
         if okay {
             Ok(unsafe {
@@ -334,13 +322,13 @@ impl<H: HeaderV1Spec> HeaderV1<H> {
                     raw_server_version,
                     raw_driver_version,
                     // 2.1.2
-                    transmute(raw_host_os),
-                    transmute(raw_host_arch),
-                    transmute(raw_host_ptr_width),
-                    transmute(raw_host_endian),
+                    HostOS::from_raw(raw_host_os),
+                    HostArch::from_raw(raw_host_arch),
+                    HostPointerWidth::from_raw(raw_host_ptr_width),
+                    HostEndian::from_raw(raw_host_endian),
                     // 2.1.3
-                    H::FileClass::new(raw_file_class),
-                    H::FileSpecifier::new(raw_file_specifier),
+                    H::FileClass::from_raw(raw_file_class),
+                    H::FileSpecifier::from_raw(raw_file_specifier),
                     raw_file_specifier_version,
                     // 2.2
                     raw_runtime_epoch_time,

server/src/engine/storage/common/static_meta.rs

@@ -33,7 +33,17 @@
 pub const SDSS_MAGIC_8B: u64 = 0x4F48534159414E21;
 
 #[repr(u8)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, sky_macros::EnumMethods)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    sky_macros::EnumMethods,
+    sky_macros::TaggedEnum,
+)]
 /// Host architecture enumeration for common platforms
 pub enum HostArch {
     X86 = 0,
@@ -65,7 +75,17 @@ impl HostArch {
 }
 
 #[repr(u8)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, sky_macros::EnumMethods)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    sky_macros::EnumMethods,
+    sky_macros::TaggedEnum,
+)]
 /// Host OS enumeration for common operating systems
 pub enum HostOS {
     // T1
@@ -124,7 +144,17 @@ impl HostOS {
 }
 
 #[repr(u8)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, sky_macros::EnumMethods)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    sky_macros::EnumMethods,
+    sky_macros::TaggedEnum,
+)]
 /// Host endian enumeration
 pub enum HostEndian {
     Big = 0,
@@ -141,7 +171,17 @@ impl HostEndian {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, sky_macros::EnumMethods)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    sky_macros::EnumMethods,
+    sky_macros::TaggedEnum,
+)]
 #[repr(u8)]
 /// Host pointer width enumeration
 pub enum HostPointerWidth {

server/src/engine/storage/common_encoding/r1/map.rs

@@ -40,7 +40,7 @@ use {
             idx::{IndexSTSeqCns, STIndexSeq},
             mem::{BufferedScanner, StatelessLen},
         },
-        util::{copy_slice_to_array as memcpy, EndianQW},
+        util::{compiler::TaggedEnum, copy_slice_to_array as memcpy, EndianQW},
     },
     std::{collections::HashMap, marker::PhantomData},
 };

server/src/engine/storage/common_encoding/r1/obj.rs

@@ -41,7 +41,7 @@ use {
             idx::IndexSTSeqCns,
             mem::{BufferedScanner, VInline},
         },
-        util::EndianQW,
+        util::{compiler::TaggedEnum, EndianQW},
     },
 };
 
@@ -57,10 +57,21 @@ pub mod cell {
                 cell::Datacell,
                 tag::{DataTag, TagClass, TagSelector},
             },
-            util::EndianQW,
+            util::{compiler::TaggedEnum, EndianQW},
         },
     };
-    #[derive(Debug, PartialEq, Eq, Clone, Copy, PartialOrd, Ord, Hash, sky_macros::EnumMethods)]
+    #[derive(
+        Debug,
+        PartialEq,
+        Eq,
+        Clone,
+        Copy,
+        PartialOrd,
+        Ord,
+        Hash,
+        sky_macros::EnumMethods,
+        sky_macros::TaggedEnum,
+    )]
     #[repr(u8)]
     #[allow(dead_code)]
     pub enum StorageCellTypeID {
@@ -82,23 +93,13 @@ pub mod cell {
         Dict = 0x0F,
     }
     impl StorageCellTypeID {
-        pub const unsafe fn from_raw(v: u8) -> Self {
-            core::mem::transmute(v)
-        }
-        pub const fn try_from_raw(v: u8) -> Option<Self> {
-            if Self::is_valid(v) {
-                Some(unsafe { Self::from_raw(v) })
-            } else {
-                None
-            }
-        }
         #[inline(always)]
         pub const fn is_valid(d: u8) -> bool {
             d <= Self::MAX
         }
-        const unsafe fn into_selector(self) -> TagSelector {
+        unsafe fn into_selector(self) -> TagSelector {
             debug_assert!(self.value_u8() != Self::Null.value_u8());
-            core::mem::transmute(self.value_u8() - 1)
+            TagSelector::from_raw(self.value_u8() - 1)
         }
         #[inline(always)]
         pub fn expect_atleast(d: u8) -> usize {

server/src/engine/storage/common_encoding/r1/tests.rs

@@ -26,7 +26,8 @@
 
 use {
     super::obj,
-    crate::engine::{
+    crate::{
+        engine::{
             core::{
                 model::{Field, Layer, ModelData},
                 space::Space,
@@ -41,6 +42,8 @@ use {
             mem::BufferedScanner,
             storage::common_encoding::r1::obj::cell::StorageCellTypeID,
         },
+        util::compiler::TaggedEnum,
+    },
 };
 
 #[test]

server/src/engine/storage/v1/raw/batch_jrnl/restore.rs

@@ -29,7 +29,8 @@ use {
         MARKER_ACTUAL_BATCH_EVENT, MARKER_BATCH_CLOSED, MARKER_BATCH_REOPEN, MARKER_END_OF_BATCH,
         MARKER_RECOVERY_EVENT,
     },
-    crate::engine::{
+    crate::{
+        engine::{
             core::{
                 index::{DcFieldIndex, PrimaryIndexKey, Row},
                 model::{delta::DeltaVersion, ModelData},
@@ -46,6 +47,8 @@ use {
                 v1::raw::rw::{SDSSFileIO, TrackedReader},
             },
         },
+        util::compiler::TaggedEnum,
+    },
     std::{
         collections::{hash_map::Entry as HMEntry, HashMap},
         mem::ManuallyDrop,

server/src/engine/storage/v1/raw/spec.rs

@@ -39,35 +39,37 @@ impl sdss::sdss_r1::HeaderV1Spec for HeaderImplV1 {
     const CURRENT_SERVER_VERSION: ServerVersion = versions::v1::V1_SERVER_VERSION;
     const CURRENT_DRIVER_VERSION: DriverVersion = versions::v1::V1_DRIVER_VERSION;
 }
-impl sdss::sdss_r1::HeaderV1Enumeration for FileScope {
-    const MAX: u8 = FileScope::MAX;
-    unsafe fn new(x: u8) -> Self {
-        core::mem::transmute(x)
-    }
-    fn repr_u8(&self) -> u8 {
-        FileScope::value_u8(self)
-    }
-}
-impl sdss::sdss_r1::HeaderV1Enumeration for FileSpecifier {
-    const MAX: u8 = FileSpecifier::MAX;
-    unsafe fn new(x: u8) -> Self {
-        core::mem::transmute(x)
-    }
-    fn repr_u8(&self) -> u8 {
-        self.value_u8()
-    }
-}
 
 /// The file scope
 #[repr(u8)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, sky_macros::EnumMethods)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    sky_macros::EnumMethods,
+    sky_macros::TaggedEnum,
+)]
 pub enum FileScope {
     Journal = 0,
     DataBatch = 1,
     FlatmapData = 2,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, sky_macros::EnumMethods)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    sky_macros::EnumMethods,
+    sky_macros::TaggedEnum,
+)]
 #[repr(u8)]
 pub enum FileSpecifier {
     GNSTxnLog = 0,

server/src/engine/storage/v2/impls/mdl_journal.rs

@@ -616,7 +616,8 @@ impl BatchAdapterSpec for ModelDataAdapter {
 mod restore_impls {
     use {
         super::BatchMetadata,
-        crate::engine::{
+        crate::{
+            engine::{
                 core::index::PrimaryIndexKey,
                 data::{cell::Datacell, tag::TagUnique},
                 error::StorageError,
@@ -630,6 +631,8 @@ mod restore_impls {
                 },
                 RuntimeResult,
             },
+            util::compiler::TaggedEnum,
+        },
         std::mem::ManuallyDrop,
     };
     /// Primary key decode impl
@@ -662,7 +665,7 @@ mod restore_impls {
                     PrimaryIndexKey::new_from_dual(pk_type, len, md.as_mut_ptr() as usize)
                 }
             }
-            _ => unsafe {
+            TagUnique::Illegal => unsafe {
                 // UNSAFE(@ohsayan): TagUnique::try_from_raw rejects an construction with Invalid as the dscr
                 impossible!()
             },

server/src/engine/storage/v2/raw/journal/raw/mod.rs

@@ -28,7 +28,8 @@
 mod tests;
 
 use {
-    crate::engine::{
+    crate::{
+        engine::{
             error::StorageError,
             mem::unsafe_apis::memcpy,
             storage::common::{
@@ -40,6 +41,8 @@ use {
             },
             RuntimeResult,
         },
+        util::compiler::TaggedEnum,
+    },
     core::fmt,
     std::ops::Range,
 };
@@ -434,7 +437,7 @@ impl DriverEvent {
             if invalid_ev_dscr | invalid_ck | invalid_pl_size {
                 return None;
             }
-            driver_event = core::mem::transmute(driver_event_ as u8);
+            driver_event = DriverEventKind::from_raw(driver_event_ as u8);
             Some(Self::with_checksum(
                 txn_id,
                 driver_event,
@@ -447,7 +450,7 @@ impl DriverEvent {
     }
 }
 
-#[derive(Debug, PartialEq, Clone, Copy, sky_macros::EnumMethods)]
+#[derive(Debug, PartialEq, Clone, Copy, sky_macros::EnumMethods, sky_macros::TaggedEnum)]
 #[repr(u8)]
 pub(super) enum DriverEventKind {
     Reopened = 0,

server/src/engine/storage/v2/raw/spec.rs

@@ -24,12 +24,9 @@
  *
 */
 
-use {
-    crate::engine::storage::common::{
+use crate::engine::storage::common::{
     sdss::{self, sdss_r1::HeaderV1},
     versions::{self, DriverVersion, FileSpecifierVersion, ServerVersion},
-    },
-    std::mem::transmute,
 };
 
 #[allow(unused)]
@@ -37,39 +34,39 @@ pub type Header = HeaderV1<HeaderImplV2>;
 
 /// The file scope
 #[repr(u8)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, sky_macros::EnumMethods)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    sky_macros::EnumMethods,
+    sky_macros::TaggedEnum,
+)]
 pub enum FileClass {
     EventLog = 0,
     Batch = 1,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, sky_macros::EnumMethods)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    sky_macros::EnumMethods,
+    sky_macros::TaggedEnum,
+)]
 #[repr(u8)]
 pub enum FileSpecifier {
     GlobalNS = 0,
     ModelData = 1,
 }
 
-impl sdss::sdss_r1::HeaderV1Enumeration for FileClass {
-    const MAX: u8 = FileClass::MAX;
-    unsafe fn new(x: u8) -> Self {
-        transmute(x)
-    }
-    fn repr_u8(&self) -> u8 {
-        self.value_u8()
-    }
-}
-
-impl sdss::sdss_r1::HeaderV1Enumeration for FileSpecifier {
-    const MAX: u8 = FileSpecifier::MAX;
-    unsafe fn new(x: u8) -> Self {
-        transmute(x)
-    }
-    fn repr_u8(&self) -> u8 {
-        self.value_u8()
-    }
-}
-
 #[derive(Debug)]
 pub struct HeaderImplV2;
 impl sdss::sdss_r1::HeaderV1Spec for HeaderImplV2 {