use decorators instead of macro, more compile-time checks

Author: rustopian

sysvar/src/clock.rs

@@ -143,7 +143,7 @@ mod tests {
     #[test]
     fn test_clock_size_matches_bincode() {
         // Prove that Clock's in-memory layout matches its bincode serialization,
-        // so we do not need to use define_sysvar_wire.
+        // so we do not need to use sysvar_packed_struct.
         let clock = Clock::default();
         let in_memory_size = core::mem::size_of::<Clock>();
 

sysvar/src/epoch_rewards.rs

@@ -156,34 +156,47 @@
 
 #[cfg(feature = "bincode")]
 use crate::SysvarSerialize;
-use crate::{get_sysvar_via_packed, sysvar_packed_struct, Sysvar};
+use crate::{get_sysvar_via_packed, Sysvar};
 pub use {
     solana_epoch_rewards::EpochRewards,
     solana_sdk_ids::sysvar::epoch_rewards::{check_id, id, ID},
 };
 
-sysvar_packed_struct! {
-    struct EpochRewardsPacked(81) {
-        distribution_starting_block_height: u64,
-        num_partitions: u64,
-        parent_blockhash: [u8; 32],
-        total_points: u128,
-        total_rewards: u64,
-        distributed_rewards: u64,
-        active: u8, // bool as u8
-    }
+#[repr(C, packed)]
+#[derive(Clone, Copy)]
+struct EpochRewardsPacked {
+    distribution_starting_block_height: u64,
+    num_partitions: u64,
+    parent_blockhash: [u8; 32],
+    total_points: u128,
+    total_rewards: u64,
+    distributed_rewards: u64,
+    active: u8, // bool as u8
 }
 
+const _: () = assert!(core::mem::size_of::<EpochRewardsPacked>() == 81);
+
 impl From<EpochRewardsPacked> for EpochRewards {
     fn from(p: EpochRewardsPacked) -> Self {
+        // Ensure field parity at compile time
+        let EpochRewardsPacked {
+            distribution_starting_block_height,
+            num_partitions,
+            parent_blockhash,
+            total_points,
+            total_rewards,
+            distributed_rewards,
+            active,
+        } = p;
+
         Self {
-            distribution_starting_block_height: p.distribution_starting_block_height,
-            num_partitions: p.num_partitions,
-            parent_blockhash: solana_hash::Hash::new_from_array(p.parent_blockhash),
-            total_points: p.total_points,
-            total_rewards: p.total_rewards,
-            distributed_rewards: p.distributed_rewards,
-            active: p.active != 0,
+            distribution_starting_block_height,
+            num_partitions,
+            parent_blockhash: solana_hash::Hash::new_from_array(parent_blockhash),
+            total_points,
+            total_rewards,
+            distributed_rewards,
+            active: active != 0,
         }
     }
 }

sysvar/src/epoch_schedule.rs

@@ -121,30 +121,41 @@
 //! ```
 #[cfg(feature = "bincode")]
 use crate::SysvarSerialize;
-use crate::{get_sysvar_via_packed, sysvar_packed_struct, Sysvar};
+use crate::{get_sysvar_via_packed, Sysvar};
 pub use {
     solana_epoch_schedule::EpochSchedule,
     solana_sdk_ids::sysvar::epoch_schedule::{check_id, id, ID},
 };
 
-sysvar_packed_struct! {
-    struct EpochSchedulePacked(33) {
-        slots_per_epoch: u64,
-        leader_schedule_slot_offset: u64,
-        warmup: u8, // bool as u8
-        first_normal_epoch: u64,
-        first_normal_slot: u64,
-    }
+#[repr(C, packed)]
+#[derive(Clone, Copy)]
+struct EpochSchedulePacked {
+    slots_per_epoch: u64,
+    leader_schedule_slot_offset: u64,
+    warmup: u8, // bool as u8
+    first_normal_epoch: u64,
+    first_normal_slot: u64,
 }
 
+const _: () = assert!(core::mem::size_of::<EpochSchedulePacked>() == 33);
+
 impl From<EpochSchedulePacked> for EpochSchedule {
     fn from(p: EpochSchedulePacked) -> Self {
+        // Ensure field parity at compile time
+        let EpochSchedulePacked {
+            slots_per_epoch,
+            leader_schedule_slot_offset,
+            warmup,
+            first_normal_epoch,
+            first_normal_slot,
+        } = p;
+
         Self {
-            slots_per_epoch: p.slots_per_epoch,
-            leader_schedule_slot_offset: p.leader_schedule_slot_offset,
-            warmup: p.warmup != 0,
-            first_normal_epoch: p.first_normal_epoch,
-            first_normal_slot: p.first_normal_slot,
+            slots_per_epoch,
+            leader_schedule_slot_offset,
+            warmup: warmup != 0,
+            first_normal_epoch,
+            first_normal_slot,
         }
     }
 }

sysvar/src/last_restart_slot.rs

@@ -57,8 +57,8 @@ mod tests {
 
     #[test]
     fn test_last_restart_slot_size_matches_bincode() {
-        // Prove that Clock's in-memory layout matches its bincode serialization,
-        // so we do not need to use define_sysvar_wire.
+        // Prove that LastRestartSlot's in-memory layout matches its bincode serialization,
+        // so we do not need to use sysvar_packed_struct.
         let slot = LastRestartSlot::default();
         let in_memory_size = core::mem::size_of::<LastRestartSlot>();
 

sysvar/src/lib.rs

@@ -202,40 +202,6 @@ macro_rules! impl_sysvar_get {
     };
 }
 
-/// Defines a `#[repr(C, packed)]` struct with compile-time size and alignment checking.
-///
-/// Used for sysvars whose canonical `#[repr(C)]` layout contains padding
-/// that doesn't match the runtime's compact serialization format.
-///
-/// # Example
-///
-/// ```ignore
-/// sysvar_packed_struct! {
-///     struct RentPacked(17) {
-///         lamports_per_byte_year: u64,
-///         exemption_threshold: [u8; 8],
-///         burn_percent: u8,
-///     }
-/// }
-/// ```
-#[macro_export]
-macro_rules! sysvar_packed_struct {
-    (
-        struct $name:ident($size:expr) {
-            $( $field:ident : $fty:ty ),* $(,)?
-        }
-    ) => {
-        #[repr(C, packed)]
-        #[derive(Clone, Copy)]
-        struct $name {
-            $( $field: $fty ),*
-        }
-
-        const _: () = assert!(core::mem::size_of::<$name>() == $size);
-        const _: () = assert!(core::mem::align_of::<$name>() == 1);
-    };
-}
-
 /// Generic helper to load a sysvar via a packed representation.
 ///
 /// 1. Allocates uninitialized memory for the packed struct

sysvar/src/rent.rs

@@ -123,26 +123,35 @@
 //! ```
 #[cfg(feature = "bincode")]
 use crate::SysvarSerialize;
-use crate::{get_sysvar_via_packed, sysvar_packed_struct, Sysvar};
+use crate::{get_sysvar_via_packed, Sysvar};
 pub use {
     solana_rent::Rent,
     solana_sdk_ids::sysvar::rent::{check_id, id, ID},
 };
 
-sysvar_packed_struct! {
-    struct RentPacked(17) {
-        lamports_per_byte_year: u64,
-        exemption_threshold: [u8; 8], // f64 as little-endian bytes
-        burn_percent: u8,
-    }
+#[repr(C, packed)]
+#[derive(Clone, Copy)]
+struct RentPacked {
+    lamports_per_byte_year: u64,
+    exemption_threshold: [u8; 8], // f64 as little-endian bytes
+    burn_percent: u8,
 }
 
+const _: () = assert!(core::mem::size_of::<RentPacked>() == 17);
+
 impl From<RentPacked> for Rent {
     fn from(p: RentPacked) -> Self {
+        // Ensure field parity at compile time
+        let RentPacked {
+            lamports_per_byte_year,
+            exemption_threshold,
+            burn_percent,
+        } = p;
+
         Self {
-            lamports_per_byte_year: p.lamports_per_byte_year,
-            exemption_threshold: f64::from_le_bytes(p.exemption_threshold),
-            burn_percent: p.burn_percent,
+            lamports_per_byte_year,
+            exemption_threshold: f64::from_le_bytes(exemption_threshold),
+            burn_percent,
         }
     }
 }