clean up tracked struct IDs to handle overflow

Author: ibraheemdev

src/id.rs

@@ -39,7 +39,7 @@ impl Id {
     #[doc(hidden)]
     #[track_caller]
     #[inline]
-    pub const unsafe fn from_data(v: u32) -> Self {
+    pub const unsafe fn from_index(v: u32) -> Self {
         debug_assert!(v < Self::MAX_U32);
 
         Id {
@@ -66,13 +66,24 @@ impl Id {
         }
     }
 
+    /// Returns a new `Id` with same index, but the generation incremented by one.
+    ///
+    /// Returns `None` if the generation would overflow, i.e. the current generation
+    /// is `u32::MAX`.
+    #[inline]
+    pub fn next_generation(self) -> Option<Id> {
+        self.generation()
+            .checked_add(1)
+            .map(|generation| self.with_generation(generation))
+    }
+
     /// Mark the `Id` with a generation.
     ///
     /// This `Id` will refer to the same page and slot in the database,
     /// but will differ from other identifiers of the slot based on the
     /// provided generation.
     #[inline]
-    pub fn with_generation(self, generation: u32) -> Id {
+    pub const fn with_generation(self, generation: u32) -> Id {
         let mut value = self.value.get();
 
         value &= 0xFFFFFFFF;
@@ -84,9 +95,9 @@ impl Id {
         }
     }
 
-    /// Return the data portion of this `Id`.
+    /// Return the index portion of this `Id`.
     #[inline]
-    pub const fn data(self) -> u32 {
+    pub const fn index(self) -> u32 {
         // Truncate the high-order bits.
         (self.value.get() as u32) - 1
     }
@@ -108,9 +119,9 @@ impl Id {
 impl Debug for Id {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if self.generation() == 0 {
-            write!(f, "Id({:x})", self.data())
+            write!(f, "Id({:x})", self.index())
         } else {
-            write!(f, "Id({:x}g{:x})", self.data(), self.generation())
+            write!(f, "Id({:x}g{:x})", self.index(), self.generation())
         }
     }
 }

src/key.rs

@@ -22,19 +22,19 @@ impl DatabaseKeyIndex {
     #[inline]
     pub(crate) fn new(ingredient_index: IngredientIndex, key_index: Id) -> Self {
         Self {
-            key_index: key_index.data(),
+            key_index: key_index.index(),
             key_generation: key_index.generation(),
             ingredient_index,
         }
     }
 
-    pub fn ingredient_index(self) -> IngredientIndex {
+    pub const fn ingredient_index(self) -> IngredientIndex {
         self.ingredient_index
     }
 
-    pub fn key_index(self) -> Id {
+    pub const fn key_index(self) -> Id {
         // SAFETY: `self.key_index` was returned by `Id::data`.
-        unsafe { Id::from_data(self.key_index) }.with_generation(self.key_generation)
+        unsafe { Id::from_index(self.key_index) }.with_generation(self.key_generation)
     }
 
     pub(crate) fn maybe_changed_after(

src/table.rs

@@ -400,13 +400,13 @@ fn make_id(page: PageIndex, slot: SlotIndex) -> Id {
     let page = page.0 as u32;
     let slot = slot.0 as u32;
     // SAFETY: `slot` is guaranteed to be small enough that the resulting Id won't be bigger than `Id::MAX_U32`
-    unsafe { Id::from_data((page << PAGE_LEN_BITS) | slot) }
+    unsafe { Id::from_index((page << PAGE_LEN_BITS) | slot) }
 }
 
 #[inline]
 fn split_id(id: Id) -> (PageIndex, SlotIndex) {
-    let data = id.data() as usize;
-    let slot = data & PAGE_LEN_MASK;
-    let page = data >> PAGE_LEN_BITS;
+    let index = id.index() as usize;
+    let slot = index & PAGE_LEN_MASK;
+    let page = index >> PAGE_LEN_BITS;
     (PageIndex::new(page), SlotIndex::new(slot))
 }