Fix new clippy lints

src/cell/builder.rs

@@ -697,10 +697,19 @@ impl CellBuilder {
         ) -> Result<(), Error> {
             let bits = value.remaining_bits();
             if builder.bit_len + bits <= MAX_BIT_LEN {
-                let mut slice_data = MaybeUninit::<[u8; 128]>::uninit();
-                let slice_data = unsafe { &mut *(slice_data.as_mut_ptr() as *mut [u8; 128]) };
-                let slice_data = ok!(value.get_raw(0, slice_data, bits));
+                // SAFETY: An uninitialized `[MaybeUninit<_>; LEN]` is valid.
+                let mut slice_data =
+                    unsafe { MaybeUninit::<[MaybeUninit<u8>; 128]>::uninit().assume_init() };
+
+                // SAFETY: casting `slice_data` to a `*const [u8]` is safe since `MaybeUninit`
+                // is guaranteed to have the same layout as `u8`.
+                // The pointer obtained is valid since it refers to memory owned by `slice_data`
+                // which is a reference and thus guaranteed to be valid for reads.
+                let slice_data = unsafe {
+                    &mut *(&mut slice_data as *mut [MaybeUninit<u8>; 128] as *mut [u8; 128])
+                };
 
+                let slice_data = ok!(value.get_raw(0, slice_data, bits));
                 builder.store_raw(slice_data, bits)
             } else {
                 Err(Error::CellOverflow)

src/cell/slice.rs

@@ -306,24 +306,12 @@ impl CellSliceRange {
 }
 
 /// A read-only view for a subrange of a cell.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct CellSlice<'a> {
     cell: &'a DynCell,
     range: CellSliceRange,
 }
 
-impl<'a> Clone for CellSlice<'a> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self {
-            cell: self.cell,
-            range: self.range,
-        }
-    }
-}
-
-impl<'a> Copy for CellSlice<'a> {}
-
 impl<'a> AsRef<CellSlice<'a>> for CellSlice<'a> {
     #[inline]
     fn as_ref(&self) -> &CellSlice<'a> {

src/dict/raw.rs

@@ -565,7 +565,7 @@ impl<'a> RawIter<'a> {
                     builder: Box::default(),
                     reversed,
                     signed,
-                }
+                };
             };
 
             segments.push(IterSegment {
@@ -957,13 +957,13 @@ impl<'a> RawValues<'a> {
         let mut segments = Vec::new();
         if let Some(root) = root {
             let Ok(data) = root.as_slice() else {
-                    return Self {
-                        segments: Vec::new(),
-                        status: IterStatus::Pruned,
-                        reversed,
-                        signed,
-                    };
+                return Self {
+                    segments: Vec::new(),
+                    status: IterStatus::Pruned,
+                    reversed,
+                    signed,
                 };
+            };
 
             segments.push(ValuesSegment {
                 data,

src/dict/typed.rs

@@ -495,7 +495,8 @@ where
         bound: DictBound,
         signed: bool,
     ) -> Result<Option<(K, CellSlice<'_>)>, Error> {
-        let Some((key, value)) = ok!(dict_find_bound(self.root.as_ref(), K::BITS, bound, signed)) else {
+        let Some((key, value)) = ok!(dict_find_bound(self.root.as_ref(), K::BITS, bound, signed))
+        else {
             return Ok(None);
         };
         match K::from_raw_data(key.raw_data()) {

src/models/config/mod.rs

@@ -240,7 +240,9 @@ impl BlockchainConfig {
 
     /// Tries to get a parameter from the blockchain config.
     pub fn get<'a, T: KnownConfigParam<'a>>(&'a self) -> Result<Option<T::Value>, Error> {
-        let Some(mut slice) = ok!(self.get_raw(T::ID)) else { return Ok(None); };
+        let Some(mut slice) = ok!(self.get_raw(T::ID)) else {
+            return Ok(None);
+        };
         match <T::Wrapper as Load<'a>>::load_from(&mut slice) {
             Ok(wrapped) => Ok(Some(wrapped.into_inner())),
             Err(e) => Err(e),

src/models/config/params.rs

@@ -720,7 +720,7 @@ impl Store for ValidatorSet {
         finalizer: &mut dyn Finalizer,
     ) -> Result<(), Error> {
         let Ok(total) = u16::try_from(self.list.len()) else {
-            return Err(Error::InvalidData)
+            return Err(Error::InvalidData);
         };
 
         // TODO: optimize