Fix clippy warnings that are enabled in newer toolchains

Author: syntactically

src/hyperlight_component_util/src/subtype.rs

@@ -36,7 +36,7 @@ pub enum Error<'r> {
     /// A value type was present, but incompatible with its expected type
     MismatchedValue(Value<'r>, Value<'r>),
     /// A defined type was present, but incompatible with its expected type
-    MismatchedDefined(Defined<'r>, Defined<'r>),
+    MismatchedDefined(Box<Defined<'r>>, Box<Defined<'r>>),
     /// A resource was present, but was not the same resource as was expected
     MismatchedResources(ResourceId, ResourceId),
     /// A type variable could not be resolved to be the same as the
@@ -239,7 +239,10 @@ impl<'p, 'a> Ctx<'p, 'a> {
                 self.subtype_qualified_instance(it1, it2)
             }
             (Defined::Component(ct1), Defined::Component(ct2)) => self.subtype_component(ct1, ct2),
-            _ => Err(Error::MismatchedDefined(dt1.clone(), dt2.clone())),
+            _ => Err(Error::MismatchedDefined(
+                Box::new(dt1.clone()),
+                Box::new(dt2.clone()),
+            )),
         }
     }
     pub fn subtype_handleable_is_resource<'r>(&self, ht: &'r Handleable) -> Result<(), Error<'a>> {

src/hyperlight_host/src/hypervisor/mod.rs

@@ -378,8 +378,8 @@ pub trait InterruptHandle: Debug + Send + Sync {
     ///
     /// - If this is called while the vcpu is running, then it will interrupt the vcpu and return `true`.
     /// - If this is called while the vcpu is not running, (for example during a host call), the
-    ///     vcpu will not immediately be interrupted, but will prevent the vcpu from running **the next time**
-    ///     it's scheduled, and returns `false`.
+    ///   vcpu will not immediately be interrupted, but will prevent the vcpu from running **the next time**
+    ///   it's scheduled, and returns `false`.
     ///
     /// # Note
     /// This function will block for the duration of the time it takes for the vcpu thread to be interrupted.
@@ -389,8 +389,8 @@ pub trait InterruptHandle: Debug + Send + Sync {
     ///
     /// - If this is called while the vcpu is running, then it will interrupt the vcpu and return `true`.
     /// - If this is called while the vcpu is not running, (for example during a host call), the
-    ///     vcpu will not immediately be interrupted, but will prevent the vcpu from running **the next time**
-    ///     it's scheduled, and returns `false`.
+    ///   vcpu will not immediately be interrupted, but will prevent the vcpu from running **the next time**
+    ///   it's scheduled, and returns `false`.
     ///
     /// # Note
     /// This function will block for the duration of the time it takes for the vcpu thread to be interrupted.
@@ -412,7 +412,7 @@ pub(super) struct LinuxInterruptHandle {
     /// 1. The VCPU is running (generation N),
     /// 2. It gets cancelled,
     /// 3. Then quickly restarted (generation N+1),
-    ///     before the original thread has observed that it was cancelled.
+    ///    before the original thread has observed that it was cancelled.
     ///
     /// Without this generation counter, the interrupt logic might assume the VCPU is still
     /// in the *original* run (generation N), see that it's `running`, and re-send the signal.
@@ -428,9 +428,9 @@ pub(super) struct LinuxInterruptHandle {
     /// `kill()` is called, and cleared when the vcpu is no longer running.
     /// This is used to
     /// 1. make sure stale signals do not interrupt the
-    ///     the wrong vcpu (a vcpu may only be interrupted iff `cancel_requested` is true),
+    ///    the wrong vcpu (a vcpu may only be interrupted iff `cancel_requested` is true),
     /// 2. ensure that if a vm is killed while a host call is running,
-    ///     the vm will not re-enter the guest after the host call returns.
+    ///    the vm will not re-enter the guest after the host call returns.
     cancel_requested: AtomicBool,
     /// True when the debugger has requested the VM to be interrupted. Set immediately when
     /// `kill_from_debugger()` is called, and cleared when the vcpu is no longer running.

src/hyperlight_host/src/lib.rs

@@ -50,7 +50,7 @@ pub mod hypervisor;
 /// present and code length will be zero;
 ///
 /// - The pointer passed to the Entrypoint in the Guest application is the size of page table + size of code,
-///     at this address structs below are laid out in this order
+///   at this address structs below are laid out in this order
 pub mod mem;
 /// Metric definitions and helpers
 pub mod metrics;

src/hyperlight_host/src/mem/layout.rs

@@ -64,7 +64,7 @@ use crate::{Result, new_error};
 // +-------------------------------------------+ 0x0_000
 
 /// - `InitData` - some extra data that can be loaded onto the sandbox during
-///     initialization.
+///   initialization.
 ///
 /// - `HostDefinitions` - the length of this is the `HostFunctionDefinitionSize`
 ///   field from `SandboxConfiguration`

src/hyperlight_host/src/mem/shared_mem.rs

@@ -785,7 +785,7 @@ impl HostSharedMemory {
     /// patterns
     pub fn read<T: AllValid>(&self, offset: usize) -> Result<T> {
         bounds_check!(offset, std::mem::size_of::<T>(), self.mem_size());
-        let ret = unsafe {
+        unsafe {
             let mut ret: core::mem::MaybeUninit<T> = core::mem::MaybeUninit::uninit();
             {
                 let slice: &mut [u8] = core::slice::from_raw_parts_mut(
@@ -795,8 +795,7 @@ impl HostSharedMemory {
                 self.copy_to_slice(slice, offset)?;
             }
             Ok(ret.assume_init())
-        };
-        ret
+        }
     }
 
     /// Write a value of type T, whose representation is the same