Address clippy lints

Signed-off-by: Nick Spinale <[email protected]>

crates/examples/root-task/spawn-task/src/main.rs

@@ -6,6 +6,7 @@
 
 #![no_std]
 #![no_main]
+#![allow(clippy::useless_conversion)]
 
 extern crate alloc;
 

crates/examples/root-task/spawn-thread/src/main.rs

@@ -134,7 +134,7 @@ fn create_user_context(f: SecondaryThreadFn) -> sel4::UserContext {
     let mut ctx = sel4::UserContext::default();
 
     *ctx.sp_mut() = SECONDARY_THREAD_STACK.top().try_into().unwrap();
-    *ctx.pc_mut() = secondary_thread_entrypoint as sel4::Word;
+    *ctx.pc_mut() = (secondary_thread_entrypoint as usize).try_into().unwrap();
     *ctx.c_param_mut(0) = f.into_arg();
 
     let tls_reservation = TlsReservation::new(&get_tls_image());

crates/private/support/sel4-simple-task/runtime/src/lib.rs

@@ -8,6 +8,7 @@
 #![feature(never_type)]
 #![feature(thread_local)]
 #![allow(internal_features)]
+#![allow(clippy::useless_conversion)]
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
@@ -95,7 +96,7 @@ pub unsafe extern "C" fn cont_fn(cont_arg: *mut sel4_runtime_common::ContArg) ->
         let reply_authority = {
             sel4::sel4_cfg_if! {
                 if #[sel4_cfg(KERNEL_MCS)] {
-                    sel4::cap::Reply::from_bits(thread_config.reply_authority().unwrap())
+                    sel4::cap::Reply::from_bits(thread_config.reply_authority().unwrap().try_into().unwrap())
                 } else {
                     assert!(thread_config.reply_authority().is_none());
                     sel4::ImplicitReplyAuthority

crates/sel4-async/time/src/sub_key.rs

@@ -7,6 +7,7 @@
 pub trait SubKey: Sized + Ord {
     fn min() -> Self;
 
+    #[allow(dead_code)]
     fn max() -> Self;
 
     fn succ(&self) -> Option<Self>;

crates/sel4-backtrace/addr2line-context-helper/src/lib.rs

@@ -11,7 +11,6 @@ extern crate alloc;
 use alloc::borrow::Cow;
 use alloc::rc::Rc;
 
-use addr2line::gimli;
 use addr2line::object::{Object, ObjectSection};
 use addr2line::Context as AbstractContext;
 

crates/sel4-capdl-initializer/with-embedded-spec/embedded-spec/validate/src/lib.rs

@@ -35,10 +35,7 @@ pub fn run(tell_cargo: bool) {
     let input = &embedding.spec;
     let adapted_input: SpecCommon = input
         .traverse_names_with_context(|named_obj| {
-            embedding
-                .object_names_level
-                .apply(named_obj)
-                .map(Clone::clone)
+            embedding.object_names_level.apply(named_obj).cloned()
         })
         .traverse_data(|key| embedding.fill_map.get(key).to_vec())
         .traverse_embedded_frames(|fill| {

crates/sel4-capdl-initializer/with-embedded-spec/src/main.rs

@@ -8,6 +8,7 @@
 #![no_main]
 
 use core::ops::Range;
+use core::ptr;
 
 use sel4_capdl_initializer_core::{Initializer, InitializerBuffers, PerObjectBuffer};
 use sel4_capdl_initializer_types::SpecWithSources;
@@ -39,7 +40,7 @@ fn main(bootinfo: &sel4::BootInfoPtr) -> ! {
         embedded_frame_source: &trivial_source,
     };
     Initializer::initialize(bootinfo, user_image_bounds(), &spec_with_sources, unsafe {
-        &mut BUFFERS
+        ptr::addr_of_mut!(BUFFERS).as_mut().unwrap()
     })
 }
 

crates/sel4-dlmalloc/src/lib.rs

@@ -197,6 +197,12 @@ impl<const N: usize> StaticHeap<N> {
     }
 }
 
+impl<const N: usize> Default for StaticHeap<N> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<const N: usize> GetStaticHeapBounds for &StaticHeap<N> {
     fn bounds(self) -> StaticHeapBounds {
         StaticHeapBounds::new(self.0.get().cast(), N)

crates/sel4-kernel-loader/src/arch/arm/arch/aarch32/drivers/spin_table.rs

@@ -5,21 +5,22 @@
 //
 
 use core::arch::{asm, global_asm};
+use core::ptr;
 
 #[used]
 #[no_mangle]
 static mut spin_table_secondary_stack_bottom: usize = 0;
 
 pub(crate) fn start_secondary_core(spin_table: &[usize], core_id: usize, sp: usize) {
     unsafe {
-        core::ptr::addr_of_mut!(spin_table_secondary_stack_bottom).write(sp);
+        ptr::addr_of_mut!(spin_table_secondary_stack_bottom).write(sp);
 
         let start = spin_table_secondary_entry as *const SpinTableSecondaryEntryFn as usize;
         let start_ptr = spin_table[core_id] as *mut usize;
 
         start_ptr.write_volatile(start);
 
-        clean_dcache_entry(&spin_table_secondary_stack_bottom as *const _ as usize);
+        clean_dcache_entry(ptr::addr_of!(spin_table_secondary_stack_bottom) as usize);
 
         // Barrier ensure both strl and dc cvac happen before sev
         asm!("dsb sy");

crates/sel4-kernel-loader/src/arch/arm/arch/aarch64/drivers/spin_table.rs

@@ -5,6 +5,7 @@
 //
 
 use core::arch::{asm, global_asm};
+use core::ptr;
 use core::sync::atomic::{AtomicUsize, Ordering};
 
 #[used]
@@ -23,7 +24,7 @@ pub(crate) fn start_secondary_core(spin_table: &[usize], core_id: usize, sp: usi
         AtomicUsize::from_ptr(start_ptr).store(start, Ordering::Release);
 
         dc_cvac(start_ptr as usize);
-        dc_cvac(&spin_table_secondary_stack_bottom as *const _ as usize);
+        dc_cvac(ptr::addr_of!(spin_table_secondary_stack_bottom) as usize);
 
         // Barrier ensure both strl and dc cvac happen before sev
         asm!("dsb sy");

crates/sel4-microkit/src/defer.rs

@@ -120,3 +120,9 @@ impl DeferredActionSlot {
         self.defer(DeferredAction::new_irq_ack(channel))
     }
 }
+
+impl Default for DeferredActionSlot {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/sel4-newlib/src/heap.rs

@@ -4,14 +4,14 @@
 // SPDX-License-Identifier: BSD-2-Clause
 //
 
-use super::*;
-
 use core::cell::UnsafeCell;
 use core::ffi::{c_int, c_void};
 use core::sync::atomic::{AtomicIsize, Ordering};
 
 use sel4_panicking_env::abort;
 
+use crate::errno;
+
 // NOTE(rustc_wishlist) use SyncUnsafeCell once #![feature(sync_unsafe_cell)] stabilizes
 #[repr(align(4096))] // no real reason for this
 struct BackingMemory<const N: usize>(UnsafeCell<[u8; N]>);
@@ -69,6 +69,12 @@ impl<const N: usize> StaticHeap<N> {
     }
 }
 
+impl<const N: usize> Default for StaticHeap<N> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[macro_export]
 macro_rules! declare_sbrk_with_static_heap {
     ($n:expr) => {

crates/sel4-runtime-common/src/start.rs

@@ -35,6 +35,12 @@ impl<const N: usize> Stack<N> {
     }
 }
 
+impl<const N: usize> Default for Stack<N> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[repr(transparent)]
 pub struct StackTop(#[allow(dead_code)] *mut u8);
 

crates/sel4-runtime-common/src/unwinding.rs

@@ -31,8 +31,7 @@ unsafe impl EhFrameFinder for EhFrameFinderImpl {
 
         let eh_frame_hdr = phdrs.iter().find_map(|phdr| {
             if phdr.p_type == PT_GNU_EH_FRAME {
-                let eh_frame_hdr = phdr.p_vaddr.try_into().unwrap();
-                return Some(eh_frame_hdr);
+                return Some(phdr.p_vaddr);
             }
             None
         })?;

crates/sel4-shared-ring-buffer/bookkeeping/src/slot_set_semaphore.rs

@@ -259,8 +259,6 @@ impl SlotSemaphore for Rc<DummySlotSemaphore> {
 
 #[cfg(feature = "async-unsync")]
 mod async_unsync_impl {
-    use alloc::rc::Rc;
-
     use async_unsync::semaphore::{Semaphore, TryAcquireError};
 
     use super::*;

crates/sel4-sync/src/mutex.rs

@@ -126,6 +126,12 @@ impl DeferredNotificationMutexSyncOps {
     }
 }
 
+impl Default for DeferredNotificationMutexSyncOps {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl MutexSyncOpsWithNotification for DeferredNotificationMutexSyncOps {
     fn notification(&self) -> sel4::cap::Notification {
         *self.inner.get().unwrap()
@@ -188,6 +194,12 @@ impl PanickingMutexSyncOps {
     }
 }
 
+impl Default for PanickingMutexSyncOps {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl MutexSyncOps for PanickingMutexSyncOps {
     fn signal(&self) {
         panic!("unexpected contention: signal")

crates/sel4/bitfield-ops/src/lib.rs

@@ -200,26 +200,28 @@ fn checked_cast<T: TryInto<U>, U>(val: T) -> U {
     val.try_into().map_err(|_| unreachable!()).unwrap()
 }
 
-pub fn set_bits_from_slice<T: UnsignedPrimInt, U: UnsignedPrimInt>(
+pub fn set_bits_from_slice<T, U>(
     dst: &mut [T],
     dst_range: Range<usize>,
     src: &[U],
     src_start: usize,
 ) where
-    T: TryFrom<usize>,
+    T: UnsignedPrimInt + TryFrom<usize>,
+    U: UnsignedPrimInt,
     usize: TryFrom<U>,
 {
     set_bits_from_slice_via::<_, _, usize>(dst, dst_range, src, src_start)
 }
 
-fn set_bits_from_slice_via<T: UnsignedPrimInt, U: UnsignedPrimInt, V: UnsignedPrimInt>(
+fn set_bits_from_slice_via<T, U, V>(
     dst: &mut [T],
     dst_range: Range<usize>,
     src: &[U],
     src_start: usize,
 ) where
-    T: TryFrom<V>,
-    V: TryFrom<U>,
+    T: UnsignedPrimInt + TryFrom<V>,
+    U: UnsignedPrimInt,
+    V: UnsignedPrimInt + TryFrom<U>,
 {
     let num_bits = dst_range.len();
 
@@ -302,13 +304,9 @@ impl<T: AsRef<[U]>, U: UnsignedPrimInt> Bitfield<T, U> {
         get_bits(self.bits(), range)
     }
 
-    pub fn get_bits_into_slice<V: UnsignedPrimInt>(
-        &self,
-        range: Range<usize>,
-        dst: &mut [V],
-        dst_start: usize,
-    ) where
-        V: TryFrom<usize>,
+    pub fn get_bits_into_slice<V>(&self, range: Range<usize>, dst: &mut [V], dst_start: usize)
+    where
+        V: UnsignedPrimInt + TryFrom<usize>,
         usize: TryFrom<U>,
     {
         let dst_range = dst_start..(dst_start + range.len());
@@ -355,8 +353,8 @@ impl<T: AsMut<[U]>, U: UnsignedPrimInt> Bitfield<T, U> {
 // // //
 
 #[cfg(test)]
+#[allow(unused_imports)]
 mod test {
-    #![allow(unused_imports)]
 
     extern crate std;
 

crates/sel4/bitfield-parser/src/lib.rs

@@ -4,6 +4,8 @@
 // SPDX-License-Identifier: BSD-2-Clause
 //
 
+#![allow(clippy::empty_docs)] // for #[derive(Parser)]
+
 use pest::{iterators::Pair, Parser};
 use pest_derive::Parser;
 use regex::Regex;

crates/sel4/src/arch/riscv/vspace.rs

@@ -4,6 +4,8 @@
 // SPDX-License-Identifier: MIT
 //
 
+#![allow(clippy::eq_op)]
+
 use sel4_config::sel4_cfg_wrap_match;
 
 #[allow(unused_imports)]