chore: deny let_underscore_drop

I'm curious for opinions on this.

I stubbed my toe recently on:

```
let _ = span.enter();
```

Which does not enter the span for the remainder of the function (it immediately drops the
span). There is already a by-default-deny lint for `let _ = lock()` but no such lint for other
guard-like things:

- [`tracing::Span::enter()`](https://docs.rs/tracing/latest/tracing/struct.Span.html#method.enter)
- [`xshell::Shell::push_dir`](https://docs.rs/xshell/latest/xshell/struct.Shell.html#method.push_dir)

Signed-off-by: Daniel King <[email protected]>

Author: danking

Cargo.toml

@@ -264,6 +264,7 @@ package = "getrandom"
 version = "0.3.1"
 
 [workspace.lints.rust]
+let_underscore_drop = "deny"
 macro_use_extern_crate = "deny"
 redundant_lifetimes = "deny"
 unsafe_op_in_unsafe_fn = "deny"

bench-vortex/src/clickbench/clickbench_data.rs

@@ -399,7 +399,7 @@ impl Flavor {
                 let pool = rayon::ThreadPoolBuilder::new()
                     .thread_name(|i| format!("clickbench download {i}"))
                     .build()?;
-                let _ = pool.install(|| (0_u32..100).into_par_iter().map(|idx| {
+                let _unused = pool.install(|| (0_u32..100).into_par_iter().map(|idx| {
                     let output_path = basepath.join(Format::Parquet.name()).join(format!("hits_{idx}.parquet"));
                     idempotent(&output_path, |output_path| {
                         info!("Downloading file {idx}");

vortex-cxx/src/lib.rs

@@ -26,6 +26,7 @@ pub(crate) static RUNTIME: LazyLock<CurrentThreadRuntime> =
     LazyLock::new(CurrentThreadRuntime::new);
 
 #[cxx::bridge(namespace = "vortex::ffi")]
+#[allow(let_underscore_drop)]
 mod ffi {
     extern "Rust" {
         type DType;

vortex-duckdb/build.rs

@@ -44,7 +44,7 @@ fn download_duckdb_lib_archive() -> Result<PathBuf, Box<dyn std::error::Error>>
     let archive_path = duckdb_dir.join(&archive_name);
 
     // Recreate the duckdb directory
-    let _ = fs::remove_dir_all(&duckdb_dir);
+    drop(fs::remove_dir_all(&duckdb_dir));
     fs::create_dir_all(&duckdb_dir)?;
 
     if !archive_path.exists() {
@@ -192,7 +192,7 @@ fn build_duckdb(duckdb_source_root: &Path) -> Result<PathBuf, Box<dyn std::error
     let target_dir = manifest_dir.parent().unwrap().join("target");
     let duckdb_library_dir = target_dir.join("duckdb-lib");
 
-    let _ = fs::remove_dir_all(&duckdb_library_dir);
+    drop(fs::remove_dir_all(&duckdb_library_dir));
     fs::create_dir_all(&duckdb_library_dir)?;
 
     // Copy .dylib and .so files (macOS and Linux).
@@ -223,7 +223,7 @@ fn main() {
     // Download, extract and symlink DuckDB source code.
     let zip_source_path = download_duckdb_source_archive().unwrap();
     let extracted_source_path = extract_duckdb_source(zip_source_path).unwrap();
-    let _ = fs::remove_dir_all(&duckdb_repo);
+    drop(fs::remove_dir_all(&duckdb_repo));
     std::os::unix::fs::symlink(&extracted_source_path, &duckdb_repo).unwrap();
 
     let library_path =

vortex-duckdb/src/duckdb/object_cache.rs

@@ -12,7 +12,7 @@ use crate::{cpp, lifetime_wrapper};
 unsafe extern "C-unwind" fn rust_box_deleter<T>(ptr: *mut c_void) {
     if !ptr.is_null() {
         unsafe {
-            let _ = Box::from_raw(ptr as *mut T);
+            drop(Box::from_raw(ptr as *mut T));
         }
     }
 }

vortex-gpu/src/jit/run.rs

@@ -57,7 +57,7 @@ pub fn create_run_jit_kernel(
             .record_event(Some(CU_EVENT_DEFAULT))
             .ok()
             .vortex_expect("Failed to record event");
-        let _ = unsafe { launch_builder.launch(launch_config) };
+        drop(unsafe { launch_builder.launch(launch_config) });
         ctx.synchronize()
             .map_err(|e| vortex_err!("Failed to synchronize: {e}"))?;
         let end = stream

vortex-io/src/file/read/mod.rs

@@ -124,7 +124,7 @@ impl Drop for ReadFuture {
     fn drop(&mut self) {
         // When the FileHandle is dropped, we can send a shutdown event to the I/O stream.
         // If the I/O stream has already been dropped, this will fail silently.
-        let _ = self.events.unbounded_send(ReadEvent::Dropped(self.id));
+        drop(self.events.unbounded_send(ReadEvent::Dropped(self.id)));
     }
 }
 

vortex-io/src/runtime/handle.rs

@@ -67,7 +67,7 @@ impl Handle {
         let abort_handle = self.runtime().spawn(
             async move {
                 // Task::detach allows the receiver to be dropped, so we ignore send errors.
-                let _ = send.send(f.await);
+                drop(send.send(f.await));
             }
             .boxed(),
         );
@@ -106,7 +106,7 @@ impl Handle {
             // Optimistically avoid the work if the result won't be used.
             if !send.is_closed() {
                 // Task::detach allows the receiver to be dropped, so we ignore send errors.
-                let _ = send.send(f());
+                drop(send.send(f()));
             }
         }));
         Task {
@@ -126,7 +126,7 @@ impl Handle {
             // Optimistically avoid the work if the result won't be used.
             if !send.is_closed() {
                 // Task::detach allows the receiver to be dropped, so we ignore send errors.
-                let _ = send.send(f());
+                drop(send.send(f()));
             }
         }));
         Task {

vortex-io/src/runtime/single.rs

@@ -56,9 +56,11 @@ impl Sender {
                 while let Ok(spawn) = scheduling_recv.as_async().recv().await {
                     if let Some(local) = weak_local2.upgrade() {
                         // Ignore send errors since it means the caller immediately detached.
-                        let _ = spawn
-                            .task_callback
-                            .send(SmolAbortHandle::new_handle(local.spawn(spawn.future)));
+                        drop(
+                            spawn
+                                .task_callback
+                                .send(SmolAbortHandle::new_handle(local.spawn(spawn.future))),
+                        );
                     }
                 }
             })
@@ -72,9 +74,9 @@ impl Sender {
                     if let Some(local) = weak_local2.upgrade() {
                         let work = spawn.sync;
                         // Ignore send errors since it means the caller immediately detached.
-                        let _ = spawn.task_callback.send(SmolAbortHandle::new_handle(
+                        drop(spawn.task_callback.send(SmolAbortHandle::new_handle(
                             local.spawn(async move { work() }),
-                        ));
+                        )));
                     }
                 }
             })
@@ -88,9 +90,9 @@ impl Sender {
                     if let Some(local) = weak_local2.upgrade() {
                         let work = spawn.sync;
                         // Ignore send errors since it means the caller immediately detached.
-                        let _ = spawn.task_callback.send(SmolAbortHandle::new_handle(
+                        drop(spawn.task_callback.send(SmolAbortHandle::new_handle(
                             local.spawn(async move { work() }),
-                        ));
+                        )));
                     }
                 }
             })

vortex-layout/src/layouts/dict/writer.rs

@@ -370,7 +370,7 @@ impl Stream for DictionaryTransformer {
                         // Receiver dropped, close this group
                         self.active_codes_tx = None;
                         if let Some(values_tx) = self.active_values_tx.take() {
-                            let _ = values_tx.send(Err(vortex_err!("values receiver dropped")));
+                            drop(values_tx.send(Err(vortex_err!("values receiver dropped"))));
                         }
                     }
                     Poll::Pending => {
@@ -423,14 +423,14 @@ impl Stream for DictionaryTransformer {
                 Poll::Ready(Some(Ok(DictionaryChunk::Values(values)))) => {
                     // Complete the current group
                     if let Some(values_tx) = self.active_values_tx.take() {
-                        let _ = values_tx.send(Ok(values));
+                        drop(values_tx.send(Ok(values)));
                     }
                     self.active_codes_tx = None; // Close codes stream
                 }
                 Poll::Ready(Some(Err(e))) => {
                     // Send error to active channels if any
                     if let Some(values_tx) = self.active_values_tx.take() {
-                        let _ = values_tx.send(Err(e));
+                        drop(values_tx.send(Err(e)));
                     }
                     self.active_codes_tx = None;
                     // And terminate the stream
@@ -439,7 +439,7 @@ impl Stream for DictionaryTransformer {
                 Poll::Ready(None) => {
                     // Handle any incomplete group
                     if let Some(values_tx) = self.active_values_tx.take() {
-                        let _ = values_tx.send(Err(vortex_err!("Incomplete dictionary group")));
+                        drop(values_tx.send(Err(vortex_err!("Incomplete dictionary group"))));
                     }
                     self.active_codes_tx = None;
                     return Poll::Ready(None);