refactor: use const _: () = { ... }; for static assert

Author: ryota2357

src/lib.rs

@@ -36,14 +36,12 @@ mod features;
 #[repr(transparent)]
 pub struct LeanString(Repr);
 
-fn _static_assert() {
-    const {
-        assert!(size_of::<LeanString>() == 2 * size_of::<usize>());
-        assert!(size_of::<Option<LeanString>>() == 2 * size_of::<usize>());
-        assert!(align_of::<LeanString>() == align_of::<usize>());
-        assert!(align_of::<Option<LeanString>>() == align_of::<usize>());
-    }
-}
+const _: () = {
+    assert!(size_of::<LeanString>() == size_of::<[usize; 2]>());
+    assert!(size_of::<Option<LeanString>>() == size_of::<[usize; 2]>());
+    assert!(align_of::<LeanString>() == align_of::<usize>());
+    assert!(align_of::<Option<LeanString>>() == align_of::<usize>());
+};
 
 impl LeanString {
     /// Creates a new empty [`LeanString`].

src/repr.rs

@@ -32,14 +32,12 @@ pub(crate) struct Repr(*const (), [u8; 7], LastByte);
 #[cfg(target_pointer_width = "32")]
 pub(crate) struct Repr(*const (), [u8; 3], LastByte);
 
-fn _static_assert() {
-    const {
-        assert!(size_of::<Repr>() == MAX_INLINE_SIZE);
-        assert!(size_of::<Option<Repr>>() == MAX_INLINE_SIZE);
-        assert!(align_of::<Repr>() == align_of::<usize>());
-        assert!(align_of::<Option<Repr>>() == align_of::<usize>());
-    }
-}
+const _: () = {
+    assert!(size_of::<Repr>() == MAX_INLINE_SIZE);
+    assert!(size_of::<Option<Repr>>() == MAX_INLINE_SIZE);
+    assert!(align_of::<Repr>() == align_of::<usize>());
+    assert!(align_of::<Option<Repr>>() == align_of::<usize>());
+};
 
 impl Repr {
     #[inline]

src/repr/heap_buffer.rs

@@ -34,12 +34,10 @@ struct Header {
     capacity: Capacity,
 }
 
-fn _static_assert() {
-    const {
-        assert!(size_of::<HeapBuffer>() == MAX_INLINE_SIZE);
-        assert!(align_of::<HeapBuffer>() == align_of::<usize>());
-    }
-}
+const _: () = {
+    assert!(size_of::<HeapBuffer>() == MAX_INLINE_SIZE);
+    assert!(align_of::<HeapBuffer>() == align_of::<usize>());
+};
 
 impl HeapBuffer {
     pub(super) fn new(text: &str) -> Result<Self, ReserveError> {

src/repr/inline_buffer.rs

@@ -8,6 +8,11 @@ pub(super) struct InlineBuffer([u8; MAX_INLINE_SIZE]);
 #[repr(C, align(4))]
 pub(super) struct InlineBuffer([u8; MAX_INLINE_SIZE]);
 
+const _: () = {
+    assert!(size_of::<InlineBuffer>() == MAX_INLINE_SIZE);
+    assert!(align_of::<InlineBuffer>() == align_of::<usize>());
+};
+
 impl InlineBuffer {
     /// # Safety
     /// `text` must have a length less than or equal to `MAX_INLINE_SIZE`.

src/repr/last_byte.rs

@@ -230,12 +230,10 @@ pub enum LastByte {
     StaticMarker = 0xD1,
 }
 
-fn _static_assert() {
-    const {
-        assert!(size_of::<LastByte>() == 1);
-        assert!(size_of::<Option<LastByte>>() == 1);
-    }
-}
+const _: () = {
+    assert!(size_of::<LastByte>() == 1);
+    assert!(size_of::<Option<LastByte>>() == 1);
+};
 
 #[allow(dead_code)]
 impl LastByte {

src/repr/static_buffer.rs

@@ -6,6 +6,11 @@ pub(super) struct StaticBuffer {
     len: usize, // stored as little-endian
 }
 
+const _: () = {
+    assert!(size_of::<StaticBuffer>() == MAX_INLINE_SIZE);
+    assert!(align_of::<StaticBuffer>() == align_of::<usize>());
+};
+
 const USIZE_SIZE: usize = size_of::<usize>();
 
 impl StaticBuffer {