Rust RFC 1860 深度解读:ManuallyDrop 与显式控制析构顺序
Rust RFC 1860 深度解读:ManuallyDrop 与显式控制析构顺序
导读
RFC 1860 是 Rust 语言设计中一个小而关键的提案:它在 core::mem(并随之引入 std::mem)中新增 ManuallyDrop<T> 包装类型,让开发者可以显式、精确地控制结构体字段的析构时机与顺序。这篇技术指南将以 RFC 原文为主体,结合仓库中与之关联的 RFC 1857(稳定析构顺序)、RFC 2514(union 初始化与析构)、RFC 1892(MaybeUninit) 等后续文档,完整讲解 ManuallyDrop 的 API 设计、编译器层面的特殊处理、典型应用场景,以及它在现代 Rust 生态中的实际地位。读完本文,你将理解"析构顺序"问题的来龙去脉,并掌握用 ManuallyDrop 写出依赖显式析构顺序的健壮代码的完整方法。
背景:析构顺序的"未指定"困境
RFC 1860 的核心动机源于一个 Rust 语言层面的现实:Rust 当时并不规定结构体字段析构函数的运行顺序,而且这个顺序还会随上下文而改变。这一"未指定但真实存在"的行为早在 RFC issue #744 中就被暴露出来——已有相当数量的真实代码隐式依赖了当前(未文档化的)析构顺序,一旦顺序变化,这些代码就会在无声无息中出问题。
单纯把"当前的析构顺序"稳定并文档化,从技术上可以解决上述问题,但 RFC 作者认为这里还有一个更重要的维度需要考虑——隐式性(implicitness)。看下面这段代码:
struct FruitBox {
peach: Peach,
banana: Banana,
}
这个结构体是否依赖 Peach 的析构函数在 Banana 之前运行才能保证正确性?还是恰恰相反,必须是 Banana 先析构?在绝大多数情况下,结构体字段之间并不存在这种析构依赖,因此开发者很容易在重构时忽略它。例如,为了按名称排序字段,把上面的结构体改成下面这样:
struct FruitBox {
banana: Banana,
peach: Peach,
}
一旦字段之间存在析构依赖,这种看似人畜无害的重排就会悄悄引入 bug。因此,对于字段间存在依赖的结构体,很有必要提供一种显式标注析构依赖的能力——这正是 ManuallyDrop 诞生的理由。
值得补充的是,围绕同一问题,仓库中还并存着另一条解决路线:RFC 1857(stabilize-drop-order) 提议直接稳定化析构顺序。该 RFC 确认了 rustc 当时的实现:结构体字段按声明顺序(FIFO)析构,但这一"反直觉"的顺序一旦稳定就难以更改,因为 rust-openssl 等真实库已经依赖它。RFC 1860 与 RFC 1857 分别从"显式化"与"稳定化"两个角度互补地解决了析构顺序问题,前者的 ManuallyDrop 方案可以让开发者摆脱对全局顺序的依赖。
设计详解:ManuallyDrop 的完整 API
RFC 提议在 core::mem(并随之引入 std::mem)中新增以下结构体,mem 模块被认为是这个类型最合适的位置——因为它已经容纳了用途非常相近的两个函数:drop 和 forget。
/// Inhibits compiler from automatically calling `T`'s destructor.
#[lang = "manually_drop"]
#[unstable(feature = "manually_drop", reason = "recently added", issue = "0")]
#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ManuallyDrop<T> {
value: T,
}
impl<T> ManuallyDrop<T> {
/// Wraps a value to be manually dropped.
#[unstable(feature = "manually_drop", reason = "recently added", issue = "0")]
pub fn new(value: T) -> ManuallyDrop<T> {
ManuallyDrop { value }
}
/// Extracts the value from the ManuallyDrop container.
#[unstable(feature = "manually_drop", reason = "recently added", issue = "0")]
pub fn into_inner(slot: ManuallyDrop<T>) -> T {
slot.value
}
/// Manually drops the contained value.
///
/// # Unsafety
///
/// This function runs the destructor of the contained value and thus makes any further action
/// with the value within invalid. The fact that this function does not consume the wrapper
/// does not statically prevent further reuse.
#[unstable(feature = "manually_drop", reason = "recently added", issue = "0")]
pub unsafe fn drop(slot: &mut ManuallyDrop<T>) {
ptr::drop_in_place(&mut slot.value)
}
}
impl<T> Deref for ManuallyDrop<T> {
type Target = T;
// ...
}
impl<T> DerefMut for ManuallyDrop<T> {
// ...
}
逐一拆解这份设计的核心要素:
#[lang = "manually_drop"]:将ManuallyDrop注册为语言项(lang item),编译器会对其施加特殊处理——不为该类型生成任何 drop glue(即变量离开作用域时自动递归析构其字段的代码)。这是整个设计的地基:因为ManuallyDrop没有 drop glue,编译器永远不会自动调用其内部T的析构函数,析构时机的控制权被完整地交还给开发者。new(value: T):把值包装进ManuallyDrop容器。此后该值不再受自动析构管理。into_inner(slot: ManuallyDrop<T>) -> T:将值从容器中取出,恢复其正常生命周期。取出后返回的T重新受常规析构规则管理。unsafe fn drop(slot: &mut ManuallyDrop<T>):手动运行容器内值的析构函数。其底层实现是ptr::drop_in_place(&mut slot.value),即"在原地址上就地析构"。它的危险性在于:该函数不消费(consume)包装器本身,因此无法在静态层面阻止调用者析构之后再次使用容器内的值——ManuallyDrop::drop之后继续读写内部值属于未定义行为(UB)。Deref/DerefMut:让ManuallyDrop<T>可以像普通&T/&mut T一样解引用访问内部值,极大改善了可读性。
在 RFC 写作时,这些 API 均以 #[unstable(feature = "manually_drop", ...)] 标记,处于特性门控状态。后续演进(详见下文"仓库内的后续佐证")证实该类型最终被实现并稳定进入标准库。
编译器特殊处理:没有 drop glue 的类型
RFC 明确要求,作为 lang item,ManuallyDrop 必须被编译器特殊对待,不为该类型发出任何 drop glue。这一点在整个语言机制中意义深远,仓库中的后续 RFC 也多次印证了它的存在与用途:
- RFC 2514(union 初始化与析构) 明确规定,union 的字段类型不得要求 drop glue,否则构成硬错误。但注释同时指出:"
ManuallyDrop<T>never has drop glue, even ifTdoes"——即ManuallyDrop<T>无论内部T是否实现Drop,都永远没有 drop glue。这正是 union 场景下绕开限制的标准解法:编译器拒绝某个 union 定义时,把字段包进ManuallyDrop即可获得可编译的定义,代价是需要手动负责析构时机。 - RFC 1892(MaybeUninit 取代 uninitialized) 中的
MaybeUninit<T>正是以 union 加ManuallyDrop实现的:
pub union MaybeUninit<T> {
uninit: (),
value: ManuallyDrop<T>,
}
MaybeUninit 的 set 方法内部即执行 self.value = ManuallyDrop::new(val),且其文档明确承诺"dropping a MaybeUninit will never call T's drop code"——这一安全保证正是建立在 ManuallyDrop 无 drop glue 的特性之上。
- RFC 2645(透明 union) 则记录了另一个实现细节:
ManuallyDrop<T>历史上曾被实现为#[repr(transparent)]包装类型,以确保它与T拥有相同的内存布局——这是它能在数组(如小型向量优化 small vector optimizations)中作为"占位但可控析构"的类型使用的前提。
实战:用 ManuallyDrop 显式指定字段析构顺序
RFC 将前面 motivation 中的 FruitBox 示例扩展开来,完整演示了 ManuallyDrop 的推荐用法:
struct FruitBox {
// Immediately clear there's something non-trivial going on with these fields.
peach: ManuallyDrop<Peach>,
melon: Melon, // Field that's independent of the other two.
banana: ManuallyDrop<Banana>,
}
impl Drop for FruitBox {
fn drop(&mut self) {
unsafe {
// Explicit ordering in which field destructors are run specified in the intuitive
// location – the destructor of the structure containing the fields.
// Moreover, one can now reorder fields within the struct however much they want.
ManuallyDrop::drop(&mut self.peach);
ManuallyDrop::drop(&mut self.banana);
}
// After destructor for `FruitBox` runs (this function), the destructor for Melon gets
// invoked in the usual manner, as it is not wrapped in `ManuallyDrop`.
}
}
这段代码展示了该模式的全部要点:
- 意图一目了然:
peach和banana字段一出现就带着ManuallyDrop包装,读者立刻能看出"这两个字段的析构有特殊安排",无需翻阅注释或猜测。 - 顺序写在正确的位置:显式的析构顺序被写在包含字段的结构体自身的
Drop实现中——这正是直觉上最应该找到它的地方。 - 字段可以自由重排:由于
peach、banana的析构不再依赖编译器生成的字段析构顺序,开发者可以按名称排序或按其他偏好重排字段,而不必担心破坏析构依赖。 - 普通字段照常析构:
melon未加包装,在FruitBox自己的Drop运行结束后,编译器照常为其生成析构调用。
RFC 明确提议,"对于必须按特定顺序析构字段的结构体,这种模式应当成为惯用写法(idiomatic)"。它把"析构依赖"从语言层面的隐式全局顺序,转化为局部、显式、可审查的代码。
教学定位:何时该用 ManuallyDrop
RFC 在"How We Teach This"一节中给出了这个 API 的定位:预计这些函数和包装器极少被需要。它不是一个日常高频工具,而是为"字段间存在析构依赖"这类特殊需求提供的精确解法。
教学层面的建议是:除了常规的 API 文档之外,还应在 Rust Reference / Nomicon 等文档中把 ManuallyDrop 作为"显式控制结构体字段析构顺序"的标准答案提及,让遇到这类问题的开发者能顺利找到它。
备选方案:为什么不做别的
RFC 如实记录了当时考虑过的三条替代路线及其否决理由:
- 稳定某种析构顺序,让大家去写"一眼看不出来"的代码。这在技术上是可行的,但正如 RFC 1857 所揭示的,稳定化本身无法解决"隐式性"问题——字段重排依然可能无声无息地破坏依赖。
- "Bikeshed colour"(纠结无关紧要的细枝末节)——原文以自嘲口吻记录了这个不构成实质方案的方向。
- 稳定 union,让人们自己实现类似机制。这条路线的问题在于:它会排除(或大幅增加难度)把"依赖型析构器"模式推荐为惯用写法的可能性。因为 union 字段不能有 drop glue,用 union 自研会引入大量不安全代码和额外复杂度;而
ManuallyDrop作为语言项,让编译器保证"不生成 drop glue"这一关键性质,是第三方自研方案无法复制的。
最终 RFC 的"未解决问题(Unresolved questions)"一栏为空——设计在提出时已足够自洽。
仓库内的后续佐证:ManuallyDrop 在 Rust 生态中的实际地位
虽然 RFC 1860 本身是一份提案文档,但仓库中多个后续 RFC 都以"既存事实"的方式引用 ManuallyDrop,共同印证了该类型从提案走向实现、并在标准库内部被广泛使用的全过程:
- RFC 2514(union 初始化与析构):把
ManuallyDrop作为 union 字段"消除 drop glue"的标准手段,并给出完整的初始化跟踪语义示例(如u.f1 = ManuallyDrop::new(Vec::new()))。 - RFC 1892(MaybeUninit):
MaybeUninit的整个实现建立在value: ManuallyDrop<T>这一 union 字段之上,是ManuallyDrop最著名的"内部消费者"之一。 - RFC 3336(MaybeDangling):该 RFC 指出
ManuallyDrop存在一个著名的"脚枪(footgun)"场景——在ManuallyDrop::drop之后继续移动或遗忘包装器(如id(x)、let y = x;、mem::forget(x))会传递悬垂引用,构成 UB;并说明现代实现中ManuallyDrop<T>内部会将T包裹在MaybeDangling中,从而在语言语义层面豁免这部分引用约束。这体现了ManuallyDrop与 Rust 内存模型同步演进的深度。 - RFC 3458(unsafe 字段):展示了库作者将带安全不变量的字段标记为
unsafe后,如何按编译器的诊断提示将其包装为ManuallyDrop<Box<NotCopy>>,并在Drop实现中用unsafe { ManuallyDrop::drop(&mut self.unsafe_field) }手动析构、避免内存泄漏——这是ManuallyDrop在真实库设计中的直接使用案例。 - RFC 1066(mem::forget 去 unsafe):确立了"析构函数可能不会运行"的语言级前提(
mem::forget因此成为安全函数),与ManuallyDrop所代表的"显式接管析构"哲学一脉相承。 - RFC 2349(Pin):为
!Unpin类型提供不可移动保证的PinBox<T>等设计,与ManuallyDrop一样属于"低层原语 + 显式生命周期管理"的思路,共同构成 Rust 内存安全工具箱的组成部分。
总结
RFC 1860 以一份简洁的提案确立了 ManuallyDrop<T> 在 Rust 中的核心语义:作为一个 lang item,编译器不为其生成 drop glue,析构时机由此完全由开发者显式掌控。它解决了 Rust 析构顺序"未指定且隐式"的双重困境,让字段间存在析构依赖的结构体能够以自文档化、可自由重排字段的方式编写,并最终成为 MaybeUninit 等底层原语和 unsafe 库代码的基石。对于今天的 Rust 开发者而言,理解 ManuallyDrop 意味着同时理解了"自动析构"的边界在哪里,以及"显式析构"的正确姿势是什么——这正是编写安全的不安全代码所不可或缺的一课。
进一步阅读:完整的 RFC 原文见 text/1860-manually-drop.md;相关的析构顺序稳定化提案见 text/1857-stabilize-drop-order.md;ManuallyDrop 在 union 与 MaybeUninit 中的运用分别见 text/2514-union-initialization-and-drop.md 与 text/1892-uninitialized-uninhabited.md。