use exhaustive checking for manual Serialize implementations

Author: ibraheemdev

src/function/memo.rs

@@ -379,15 +379,18 @@ mod persistence {
                 }
             }
 
-            let value = self
-                .value
-                .as_ref()
-                .expect("attempted to serialize empty memo");
+            let Memo {
+                value,
+                verified_at,
+                revisions,
+            } = self;
+
+            let value = value.as_ref().expect("attempted to serialize empty memo");
 
             let mut s = serializer.serialize_struct("Memo", 3)?;
             s.serialize_field("value", &SerializeValue::<C>(value))?;
-            s.serialize_field("verified_at", &self.verified_at)?;
-            s.serialize_field("revisions", &self.revisions)?;
+            s.serialize_field("verified_at", &verified_at)?;
+            s.serialize_field("revisions", &revisions)?;
             s.end()
         }
     }

src/input.rs

@@ -494,9 +494,16 @@ mod persistence {
                 }
             }
 
-            map.serialize_entry(&"durabilities", &self.durabilities)?;
-            map.serialize_entry(&"revisions", &self.revisions)?;
-            map.serialize_entry(&"fields", &SerializeFields::<C>(&self.fields))?;
+            let Value {
+                fields,
+                revisions,
+                durabilities,
+                memos: _,
+            } = self;
+
+            map.serialize_entry(&"durabilities", &durabilities)?;
+            map.serialize_entry(&"revisions", &revisions)?;
+            map.serialize_entry(&"fields", &SerializeFields::<C>(fields))?;
 
             map.end()
         }

src/interned.rs

@@ -155,6 +155,7 @@ where
 
 /// Shared value data can only be read through the lock.
 #[repr(Rust, packed)] // Allow `durability` to be stored in the padding of the outer `Value` struct.
+#[derive(Clone, Copy)]
 struct ValueShared {
     /// The interned ID for this value.
     ///
@@ -1346,16 +1347,28 @@ mod persistence {
                 }
             }
 
+            let Value {
+                fields,
+                shared,
+                shard: _,
+                link: _,
+                memos: _,
+            } = self;
+
             // SAFETY: The safety invariant of `Ingredient::serialize` ensures we have exclusive access
             // to the database.
-            let fields = unsafe { &*self.fields.get() };
+            let fields = unsafe { &*fields.get() };
 
             // SAFETY: The safety invariant of `Ingredient::serialize` ensures we have exclusive access
             // to the database.
-            let value_shared = unsafe { &*self.shared.get() };
+            let ValueShared {
+                durability,
+                last_interned_at,
+                id: _,
+            } = unsafe { *shared.get() };
 
-            map.serialize_entry(&"durability", &{ value_shared.durability })?;
-            map.serialize_entry(&"last_interned_at", &{ value_shared.last_interned_at })?;
+            map.serialize_entry(&"durability", &durability)?;
+            map.serialize_entry(&"last_interned_at", &last_interned_at)?;
             map.serialize_entry(&"fields", &SerializeFields::<C>(fields))?;
 
             map.end()

src/tracked_struct.rs

@@ -1215,10 +1215,18 @@ mod persistence {
                 }
             }
 
-            map.serialize_entry(&"durability", &self.durability)?;
-            map.serialize_entry(&"updated_at", &self.updated_at)?;
-            map.serialize_entry(&"revisions", &self.revisions)?;
-            map.serialize_entry(&"fields", &SerializeFields::<C>(&self.fields))?;
+            let Value {
+                durability,
+                updated_at,
+                fields,
+                revisions,
+                memos: _,
+            } = self;
+
+            map.serialize_entry(&"durability", &durability)?;
+            map.serialize_entry(&"updated_at", &updated_at)?;
+            map.serialize_entry(&"revisions", &revisions)?;
+            map.serialize_entry(&"fields", &SerializeFields::<C>(fields))?;
 
             map.end()
         }