Can I offer an idea?
I think drop can be safe and flexible with little help of intrinsic type.
Rust can have a magic container:
// holds a value of type T, and performs "default" drop
// on destruction, i. e. invokes drop on all fields
// this object is instantiated by compiler only, not directly
struct DefaultDrop<T>(T);
impl<T> DefaultDrop<T> {
// get a reference to contained object
fn get_mut(&mut self) -> &mut T { ... }
// however contained object can be recovered
fn recover(self) -> T { ... }
}
// and then drop signature provided to user could look like this:
trait BetterDrop {
fn drop(self_holder: DefaultDrop<Self>);
}
// so by default to close resource or something get_mut can be used
impl BetterDrop for MyObjbect {
fn drop(self_holder: DefaultDrop<MyObject>) {
self_holder.get_mut().close_something();
// and the default destructor will be called at the end of this function
// when self_holder is be destroyed
}
}
// however this API allows data recovery
impl BetterDrop for AnotherObject {
fn drop(self_holder: DefaultDrop<AnotherObject) {
let AnotherObject { field1, field2 } = self_holder.recover();
// self_holder no longer exists, so no destructor will be called
// except for destructors of individual fields
// (unless those fields be moved elsewhere)
}
}