`.
---
### Author:  [@Jules-Bertholet](https://internals.rust-lang.org/u/Jules-Bertholet)
#### Post date: [July 24, 2023, 5:31pm UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/9 "2023-07-24T17:31:10Z")
I am not 100% certain what is going on in your example, but what I intend is:
```rust
struct Foo(String, String);
impl Drop for Foo {
fn drop(&mut self) {}
}
let foo = Foo("a".to_owned(), "b".to_owned());
let manual = ManuallyDrop::new(foo);
let a = manual.0; // Partial move
```
---
### Author:  [@withoutboats](https://internals.rust-lang.org/u/withoutboats)
#### Post date: [July 24, 2023, 6:09pm UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/10 "2023-07-24T18:09:14Z")
(NOT A CONTRIBUTION)
On the other hand, DerefMove has been discussed since at least 2015 and has made almost no progress toward shipping because of the difficulty of providing this API. Adding one more already-lang-item type, with a particularly strong motivation, to a behavioral special case that already exists, may be a prudent trade off.
---
### Author:  [@afetisov](https://internals.rust-lang.org/u/afetisov)
#### Post date: [July 24, 2023, 7:00pm UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/11 "2023-07-24T19:00:48Z")
The real question is why do we need ManuallyDrop just to move a single field out of a struct. Now, there is likely no other way to do it if you intend to drop the struct later. But many uses of ManuallyDrop are for the Drop impls themselves, where the struct will be destroyed anyway. Ideally the compiler should just know not to call recursive drop on already moved-from fields.
I know there were many discussions about this issue, but having read some of them, I am left with no understanding what is the current status of this change, and what are the blocking issues. It seemed like it just dropped off the radar at some point, with ManuallyDrop being a good-enough solution.
Similarly, there were proposals about allowing to destruct structs into their fields without calling Drop on the struct itself.
Does anyone know what happened to those proposals?
---
### Author:  [@Nemo157](https://internals.rust-lang.org/u/Nemo157)
#### Post date: [July 24, 2023, 9:32pm UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/12 "2023-07-24T21:32:55Z")
It's not about the recursive drop, if a type is `impl Drop` then it must be a complete value when `Drop::drop` is called on it, if you move a field out then the compiler cannot insert the normal drop call for the value itself. `ManuallyDrop` can be used as a marker "yes, I know this type would normally call `Drop`, but in this case I want to skip that and destructure it manually".
One issue I see is that `ManuallyDrop` seems to suppress the recursive-field-drop too, presumably in [the last example](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/9) this would leak the `"b".to_owned()` since it was never moved from.
---
### Author:  [@afetisov](https://internals.rust-lang.org/u/afetisov)
#### Post date: [July 25, 2023, 6:40am UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/13 "2023-07-25T06:40:04Z")
That's not what I'm talking about.
1. [This](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=3f9d65997aea6f64226b145935ef943c) code doesn't compile, even though the compiler could allow to destruct Foo into components and omit drop glue for `x`.
```rust
fn main() {
struct Foo(Vec);
impl Drop for Foo {
fn drop(&mut self) {}
}
let x = Foo(vec![]);
let Foo(y) = x;
}
```
1. In Drop impls, there is no issue of passing in an incomplete object. The object was already passed in, but I can't move a field out of it, because the method takes a `&mut self`, and because the compiler expects to drop all fields recursively.
---
### Author:  [@Nemo157](https://internals.rust-lang.org/u/Nemo157)
#### Post date: [July 25, 2023, 8:04am UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/14 "2023-07-25T08:04:44Z")
> [@afetisov](#):
>
> In Drop impls, there is no issue of passing in an incomplete object.
```rust
struct Foo(String, String);
impl Drop for Foo {
fn drop(&mut self) {
std::mem::take(&mut self.0);
}
}
let mut foo = Foo("a".into_owned(), "b".into_owned());
drop(foo.0);
// Double-free when `drop(&mut foo)` runs
```
---
### Author:  [@afetisov](https://internals.rust-lang.org/u/afetisov)
#### Post date: [July 25, 2023, 9:54am UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/15 "2023-07-25T09:54:18Z")
You're not even trying to understand what I wrote.
---
### Author:  [@Nemo157](https://internals.rust-lang.org/u/Nemo157)
#### Post date: [July 25, 2023, 9:57am UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/16 "2023-07-25T09:57:13Z")
I tried, but I don’t understand why you think it’s ok to call `Drop` on a partially moved value, you are definitely able to move a field out as demonstrated since you are given `&mut self`.
---
### Author:  [@Jules-Bertholet](https://internals.rust-lang.org/u/Jules-Bertholet)
#### Post date: [July 25, 2023, 10:01am UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/17 "2023-07-25T10:01:44Z")
> [@afetisov](#):
>
> [This](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=3f9d65997aea6f64226b145935ef943c) code doesn't compile, even though the compiler could allow to destruct Foo into components and omit drop glue for `x`
Whether `x` has drop glue called would then depend on whether `Foo.0: Copy`, which seems like a massive footgun.
---
### Author:  [@afetisov](https://internals.rust-lang.org/u/afetisov)
#### Post date: [July 25, 2023, 10:10am UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/18 "2023-07-25T10:10:27Z")
I'm not suggesting dropping a partially moved value. I'm suggesting allowing to omit drop if a value was partially moved. For correctness reasons, this should require some explicit syntax, like a fully destructuring binding or some special keyword, but otherwise the concept is sound.
For values inside of Drop impl, the Self is _already_ being dropped, so the objection also doesn't apply.
---
### Author:  [@Nemo157](https://internals.rust-lang.org/u/Nemo157)
#### Post date: [July 25, 2023, 10:22am UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/19 "2023-07-25T10:22:41Z")
> [@afetisov](#):
>
> I'm suggesting allowing to omit drop if a value was partially moved. For correctness reasons, this should require some explicit syntax, like a fully destructuring binding or some special keyword, but otherwise the concept is sound.
That’s what my understanding of _this_ proposal is, using `ManuallyDrop` as the explicit syntax to omit the `Drop` call and then allow for partial moving.
---
### Author:  [@Jules-Bertholet](https://internals.rust-lang.org/u/Jules-Bertholet)
#### Post date: [July 30, 2023, 10:08pm UTC](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216/20 "2023-07-30T22:08:02Z")
RFC posted: [Move out of deref for `ManuallyDrop` by Jules-Bertholet · Pull Request #3466 · rust-lang/rfcs · GitHub](https://github.com/rust-lang/rfcs/pull/3466)
[Next page](https://internals.rust-lang.org/t/move-out-of-deref-for-manuallydrop/19216.md?page=2)