E0193 rust type_error ai_generated true

error[E0193]: cannot destructure a type that implements `Drop`; use `std::mem::ManuallyDrop`

ID: rust/e0193-cannot-destruct-type-with-drop

Also available as: JSON · Markdown · 中文
80%Fix Rate
87%Confidence
1Evidence
2024-06-05First Seen

Version Compatibility

VersionStatusIntroducedDeprecatedNotes
rustc 1.79.0 active — — —
rustc 1.80.0 active — — —
rustc 1.82.0 active — — —

Root Cause

Trying to pattern match or destructure a value of a type that implements the `Drop` trait, which would cause a double drop or undefined behavior if the destructor runs after partial moves.

generic

中文

尝试对实现了 `Drop` trait 的类型进行模式匹配或解构，这会导致部分移动后析构函数运行，可能造成双重释放或未定义行为。

Official Documentation

https://doc.rust-lang.org/error_codes/E0193.html

Workarounds

  1. 85% success Wrap the field in `std::mem::ManuallyDrop` to prevent automatic drop, allowing destructuring. 
    Wrap the field in `std::mem::ManuallyDrop` to prevent automatic drop, allowing destructuring.
  2. 80% success Refactor the type to not implement `Drop`, e.g., by moving cleanup logic to a separate method that users call explicitly. 
    Refactor the type to not implement `Drop`, e.g., by moving cleanup logic to a separate method that users call explicitly.
  3. 75% success Use `std::mem::take` or `std::mem::replace` to extract values without destructuring, then handle cleanup manually. 
    Use `std::mem::take` or `std::mem::replace` to extract values without destructuring, then handle cleanup manually.

中文步骤

  1. Wrap the field in `std::mem::ManuallyDrop` to prevent automatic drop, allowing destructuring.
  2. Refactor the type to not implement `Drop`, e.g., by moving cleanup logic to a separate method that users call explicitly.
  3. Use `std::mem::take` or `std::mem::replace` to extract values without destructuring, then handle cleanup manually.

Dead Ends

Common approaches that don't work:

  1. 75% fail

    The error is about the language restriction on destructuring `Drop` types; implementing `Drop` again doesn't remove the restriction.

  2. 60% fail

    Unsafe code can bypass the check but risks double drops or memory corruption; the compiler still prevents safe destructuring.