Rust type that requires manual drop

Question

Is there a way to have the Rust compiler error if a struct is to be automatically dropped?

Example: I'm implementing a memory pool and want the allocations to be manually returned to the memory pool to prevent leakage. Is there something like RequireManualDrop from the below example?

impl MemoryPool {
   pub fn allocate(&mut self) -> Option<Allocation> { /* ... */ }
   pub fn free(&mut self, alloc: Allocation) { let (ptr, size) = alloc.inner.into_inner(); /* ... */ }
}

pub struct Allocation {
   inner: RequireManualDrop<(*mut u8, usize)>,
}

fn valid_usage(mem: &mut MemoryPool) {
   let chunk = mem.allocate();
   /* ... */
   mem.free(chunk);
}

/* compile error: Allocation.inner needs to be manully dropped */
fn will_have_compile_error(mem: &mut MemoryPool) {
   let chunk = mem.allocate();
   /* ... */
}

Answer 1

Rust doesn't have a direct solution for this. However, you can use a nit trick for that (this trick is taken from https://github.com/Kixunil/dont_panic).

If you call a declared but not defined function, the linker will report an error. We can use that to error on drop. By calling an undefined function in the destructor, the code will not compile unless the destructor is not called.

#[derive(Debug)]
pub struct Undroppable(pub i32);

impl Drop for Undroppable {
    fn drop(&mut self) {
        extern "C" {
            // This will show (somewhat) useful error message instead of complete gibberish
            #[link_name = "\n\nERROR: `Undroppable` implicitly dropped\n\n"]
            fn trigger() -> !;
        }
        unsafe { trigger() }
    }
}

pub fn manually_drop(v: Undroppable) {
    let v = std::mem::ManuallyDrop::new(v);
    println!("Manually dropping {v:?}...");
}

Playground.

However, beware that while in this case it worked even in debug builds, it may require optimizations in other cases to eliminate the call. And unwinding may complicate the process even more, because it can lead to unexpected implicit drops. For example, if I change manually_drop() to the following seemingly identical version:

pub fn manually_drop(v: Undroppable) {
    println!("Manually dropping {v:?}...");
    std::mem::forget(v);
}

It doesn't work, because println!() may unwind, and then std::mem::forget(v) won't be reached. If a function that takes Undroppable by value must unwind, you probably have no options but to wrap it with ManuallyDrop and manually ensure it is correctly dropped (though you can just drop it at the end of the function, and let the unwind case leak it, as leaking in panicking is mostly fine).