lints (#424)

Summary:
Pull Request resolved: #424

fix some lints

Reviewed By: amirafzali

Differential Revision: D77742948

fbshipit-source-id: c4e5da7f6d98ab38f026e565c5fcb4e3d833e7db

Author: shayne-fletcher

hyperactor/src/actor.rs

@@ -793,6 +793,7 @@ mod tests {
             .unwrap();
 
         // TODO: Fix this receiver hanging issue in T200423722.
+        #[allow(clippy::disallowed_methods)]
         let res: Result<Result<bool, MailboxError>, tokio::time::error::Elapsed> =
             timeout(Duration::from_secs(5), local_receiver.recv()).await;
         assert!(res.is_err());

hyperactor/src/simnet.rs

@@ -680,6 +680,7 @@ impl ProxyHandle {
             tokio::spawn(async move {
                 'outer: loop {
                     // timeout the wait to enable stop signal checking at least every 100ms.
+                    #[allow(clippy::disallowed_methods)]
                     if let Ok(Ok(msg)) = timeout(Duration::from_millis(100), rx.recv()).await {
                         let proxy_message: ProxyMessage = msg.deserialized().unwrap();
                         let event: Box<dyn Event> = match proxy_message.dest_addr {

hyperactor_mesh/src/alloc/process.rs

@@ -249,6 +249,7 @@ impl Child {
         tokio::spawn(async move {
             let exit_timeout =
                 hyperactor::config::global::get(hyperactor::config::PROCESS_EXIT_TIMEOUT);
+            #[allow(clippy::disallowed_methods)]
             if tokio::time::timeout(exit_timeout, exit_flag).await.is_err() {
                 let _ = stop_reason.set(ProcStopReason::Watchdog);
                 group.fail();

hyperactor_mesh/src/comm.rs

@@ -27,7 +27,6 @@ use hyperactor::WorldId;
 use hyperactor::data::Serialized;
 use hyperactor::mailbox::DeliveryError;
 use hyperactor::mailbox::MailboxSender;
-use hyperactor::mailbox::MessageEnvelope;
 use hyperactor::mailbox::Undeliverable;
 use hyperactor::mailbox::UndeliverableMailboxSender;
 use hyperactor::mailbox::UndeliverableMessageError;

hyperactor_mesh/test/process_allocator_cleanup/process_allocator_cleanup.rs

@@ -51,6 +51,7 @@ async fn test_process_allocator_child_cleanup() {
 
     // Read events until we have enough running children
     loop {
+        #[allow(clippy::disallowed_methods)]
         match timeout(Duration::from_secs(30), reader.next_line()).await {
             Ok(Ok(Some(line))) => {
                 if let Ok(proc_state) = serde_json::from_str::<ProcState>(&line) {
@@ -117,6 +118,7 @@ async fn test_process_allocator_child_cleanup() {
         .expect("Failed to kill parent process");
 
     // Wait for the parent to be killed
+    #[allow(clippy::disallowed_methods)]
     let wait_result = timeout(Duration::from_secs(5), child.wait()).await;
     match wait_result {
         Ok(Ok(status)) => eprintln!("Parent process exited with status: {:?}", status),

monarch_rdma/src/test_utils.rs

@@ -127,21 +127,21 @@ pub mod test_utils {
                 let parsed_idx = idx
                     .parse::<usize>()
                     .expect("Device index is not a valid integer");
-                let device_str1 = (backend.to_string(), parsed_idx.to_string());
+                let _device_str1 = (backend.to_string(), parsed_idx.to_string());
             } else {
                 assert!(devices.0 == "cpu");
-                let device_str1 = (devices.0.to_string(), 0);
+                let _device_str1 = (devices.0.to_string(), 0);
             }
 
             if let Some((backend, idx)) = devices.1.split_once(':') {
                 assert!(backend == "cuda");
                 let parsed_idx = idx
                     .parse::<usize>()
                     .expect("Device index is not a valid integer");
-                let device_str1 = (backend.to_string(), parsed_idx.to_string());
+                let _device_str1 = (backend.to_string(), parsed_idx.to_string());
             } else {
                 assert!(devices.1 == "cpu");
-                let device_str2 = (devices.1.to_string(), 0);
+                let _device_str2 = (devices.1.to_string(), 0);
             }
 
             let alloc_1 = LocalAllocator
@@ -187,10 +187,9 @@ pub mod test_utils {
                 unsafe {
                     cu_check!(cuda_sys::cuInit(0));
 
-                    let mut dptr: cuda_sys::CUdeviceptr = unsafe { std::mem::zeroed() };
-                    let mut handle: cuda_sys::CUmemGenericAllocationHandle =
-                        unsafe { std::mem::zeroed() };
-                    let mut padded_size: usize = 0;
+                    let mut dptr: cuda_sys::CUdeviceptr = std::mem::zeroed();
+                    let mut handle: cuda_sys::CUmemGenericAllocationHandle = std::mem::zeroed();
+                    let /*mut*/ padded_size: usize;
 
                     let mut device: cuda_sys::CUdevice = std::mem::zeroed();
                     cu_check!(cuda_sys::cuDeviceGet(&mut device, device_str.1));
@@ -272,8 +271,8 @@ pub mod test_utils {
                 }
             }
 
-            let buffer1 = vec![0u8; buffer_size].into_boxed_slice();
-            let buffer2 = vec![0u8; buffer_size].into_boxed_slice();
+            let _buffer1 = vec![0u8; buffer_size].into_boxed_slice();
+            let _buffer2 = vec![0u8; buffer_size].into_boxed_slice();
             // Fill buffer1 with test data
             if device_str1.0 == "cuda" {
                 let mut temp_buffer = vec![0u8; buffer_size].into_boxed_slice();