Fix clippy warnings for hyperlight-guest

Signed-off-by: Mark Rossett <[email protected]>

Author: marosset

Justfile

@@ -176,33 +176,6 @@ clippy-apply-fix-unix:
 clippy-apply-fix-windows:
     cargo clippy --target x86_64-pc-windows-msvc --fix --all 
 
-# Generate and test all possible feature combinations for a package
-clippy-feature-combinations package target=default-target:
-    #!/usr/bin/env bash
-    set -euo pipefail
-    
-    # Get all features for the package
-    features=$(cargo metadata --format-version 1 --no-deps | jq -r '.packages[] | select(.name == "{{package}}") | .features | keys[]' | grep -v default || true)
-    
-    echo "Testing {{package}} with no features..."
-    cargo clippy -p {{package}} --all-targets --no-default-features --profile={{ if target == "debug" { "dev" } else { target } }} -- -D warnings
-    
-    echo "Testing {{package}} with default features..."
-    cargo clippy -p {{package}} --all-targets --profile={{ if target == "debug" { "dev" } else { target } }} -- -D warnings
-    
-    # Test each feature individually
-    for feature in $features; do
-        echo "Testing {{package}} with feature: $feature"
-        cargo clippy -p {{package}} --all-targets --no-default-features --features "$feature" --profile={{ if target == "debug" { "dev" } else { target } }} -- -D warnings || echo "Feature $feature failed for {{package}}"
-    done
-    
-    # Test all features together
-    if [ -n "$features" ]; then
-        all_features=$(echo $features | tr '\n' ',' | sed 's/,$//')
-        echo "Testing {{package}} with all features: $all_features"
-        cargo clippy -p {{package}} --all-targets --no-default-features --features "$all_features" --profile={{ if target == "debug" { "dev" } else { target } }} -- -D warnings || echo "All features failed for {{package}}"
-    fi
-
 # Run clippy with feature combinations for all packages
 clippy-exhaustive target=default-target: (witguest-wit)
     ./hack/clippy-package-features.sh hyperlight-host {{ target }}

src/hyperlight_guest/src/guest_handle/handle.rs

@@ -25,7 +25,7 @@ use hyperlight_common::mem::HyperlightPEB;
 ///
 /// Guests are expected to initialize this and store it. For example, you
 /// could store it in a global variable.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Default)]
 pub struct GuestHandle {
     peb: Option<*mut HyperlightPEB>,
 }

src/hyperlight_guest/src/guest_handle/host_comm.rs

@@ -41,13 +41,13 @@ impl GuestHandle {
         let user_memory_region_size = unsafe { (*peb_ptr).init_data.size };
 
         if num > user_memory_region_size {
-            return Err(HyperlightGuestError::new(
+            Err(HyperlightGuestError::new(
                 ErrorCode::GuestError,
                 format!(
                     "Requested {} bytes from user memory, but only {} bytes are available",
                     num, user_memory_region_size
                 ),
-            ));
+            ))
         } else {
             let user_memory_region_slice =
                 unsafe { core::slice::from_raw_parts(user_memory_region_ptr, num as usize) };
@@ -142,7 +142,7 @@ impl GuestHandle {
     /// Write an error to the shared output data buffer.
     pub fn write_error(&self, error_code: ErrorCode, message: Option<&str>) {
         let guest_error: GuestError = GuestError::new(
-            error_code.clone(),
+            error_code,
             message.map_or("".to_string(), |m| m.to_string()),
         );
         let guest_error_buffer: Vec<u8> = (&guest_error)

src/hyperlight_guest_bin/src/exceptions/idtr.rs

@@ -49,6 +49,7 @@ pub(crate) unsafe fn load_idt() {
 
         // Use &raw mut to get a mutable raw pointer, then dereference it
         // this is to avoid the clippy warning "shared reference to mutable static"
+        #[allow(clippy::deref_addrof)]
         let idtr = &mut *(&raw mut IDTR);
         idtr.init(expected_base, idt_size as u16);
         idtr.load();

src/hyperlight_guest_bin/src/guest_function/call.rs

@@ -42,6 +42,7 @@ pub(crate) fn call_guest_function(function_call: FunctionCall) -> Result<Vec<u8>
     // Find the function definition for the function call.
     // Use &raw const to get an immutable reference to the static HashMap
     // this is to avoid the clippy warning "shared reference to mutable static"
+    #[allow(clippy::deref_addrof)]
     if let Some(registered_function_definition) =
         unsafe { (*(&raw const REGISTERED_GUEST_FUNCTIONS)).get(&function_call.function_name) }
     {
@@ -90,7 +91,7 @@ fn internal_dispatch_function() -> Result<()> {
         .expect("Function call deserialization failed");
 
     let result_vec = call_guest_function(function_call).inspect_err(|e| {
-        handle.write_error(e.kind.clone(), Some(e.message.as_str()));
+        handle.write_error(e.kind, Some(e.message.as_str()));
     })?;
 
     handle.push_shared_output_data(result_vec)

src/hyperlight_guest_bin/src/host_comm.rs

@@ -101,7 +101,7 @@ pub fn print_output_with_host_print(function_call: &FunctionCall) -> Result<Vec<
 pub unsafe extern "C" fn _putchar(c: c_char) {
     let handle = unsafe { GUEST_HANDLE };
     let char = c as u8;
-    let mut message_buffer = unsafe { &mut MESSAGE_BUFFER };
+    let message_buffer = unsafe { &mut MESSAGE_BUFFER };
 
     // Extend buffer capacity if it's empty (like `with_capacity` in lazy_static).
     // TODO: replace above Vec::new() with Vec::with_capacity once it's stable in const contexts.
@@ -113,12 +113,12 @@ pub unsafe extern "C" fn _putchar(c: c_char) {
 
     if message_buffer.len() == BUFFER_SIZE || char == b'\0' {
         let str = if char == b'\0' {
-            CStr::from_bytes_until_nul(&message_buffer)
+            CStr::from_bytes_until_nul(message_buffer)
                 .expect("No null byte in buffer")
                 .to_string_lossy()
                 .into_owned()
         } else {
-            String::from_utf8(mem::take(&mut message_buffer))
+            String::from_utf8(mem::take(message_buffer))
                 .expect("Failed to convert buffer to string")
         };
 

src/hyperlight_guest_bin/src/lib.rs

@@ -103,7 +103,7 @@ pub extern "C" fn entrypoint(peb_address: u64, seed: u64, ops: u64, max_log_leve
             #[allow(static_mut_refs)]
             let peb_ptr = GUEST_HANDLE.peb().unwrap();
 
-            let srand_seed = ((peb_address << 8 ^ seed >> 4) >> 32) as u32;
+            let srand_seed = (((peb_address << 8) ^ (seed >> 4)) >> 32) as u32;
 
             // Set the seed for the random number generator for C code using rand;
             srand(srand_seed);