为何内存布局完全相同的类型无法使用std::mem::transmute？

问题背景 #

我正在开发一个Builder派生库，利用const泛型实现编译时字段初始化检查。基础功能已完成，但在添加新特性时尝试用std::mem::transmute转换不同布尔const参数的FooBuilder实例时，编译失败。

使用transmute的setter代码示例：

#[derive(Builder)]
pub struct Foo<const SIZE: usize> {
    bar: [usize; SIZE],
}

// 宏展开后的setter部分
impl<const SIZE: usize> FooBuilder<SIZE, false> {
    pub fn bar(mut self, bar: [usize; SIZE]) -> FooBuilder<SIZE, true> {
        self.data.bar = Some(bar);
        unsafe { std::mem::transmute(self) }
    }
}

编译报错：

cannot transmute between types of different sizes, or dependently-sized types
source type: `test::const_generic::FooBuilder<SIZE, false>` (size can vary because of [usize; SIZE])
target type: `test::const_generic::FooBuilder<SIZE, true>` (size can vary because of [usize; SIZE])

简化后的宏展开代码如下：

// simplified macro expansion:
pub struct Foo<const SIZE: usize> {
    bar: [usize; SIZE],
}

impl <const SIZE: usize> Foo<SIZE> {
    fn builder() -> FooBuilder<SIZE, false> {
        FooBuilder::new()
    }
}

pub struct FooBuilder<const SIZE: usize, const __BUILDER_CONST: bool> {
    bar: Option<[usize; SIZE]>,
}

impl<const SIZE: usize> FooBuilder<SIZE, false> {
    pub fn new() -> FooBuilder<SIZE, false> {
        FooBuilder {
            bar: None,
        }
    }
}

impl<const SIZE: usize> FooBuilder<SIZE, false> {
    pub fn bar(mut self, bar: [usize; SIZE]) -> FooBuilder<SIZE, true> {
        self.bar = Some(bar);
        unsafe { std::mem::transmute(self) } 
              // ^ 逻辑上应该可行，因为__BUILDER_CONST不影响结构体布局，且SIZE完全相同
    }
}

impl<const SIZE: usize> FooBuilder<SIZE, true> {
    pub fn build(self) -> Foo<SIZE> {
        Foo::<SIZE> {
            bar: self.bar.unwrap()
        }
    }
}

注：原本的setter实现是安全的，只是在添加impl AsRef<T>作为输入类型时遇到生命周期问题，才尝试用transmute：

impl<const SIZE: usize> FooBuilder<SIZE, false> {
    pub fn bar(self, bar: [usize; SIZE]) -> FooBuilder<SIZE, true> {
        let mut data = self.data;
        data.bar = Some(bar);
        FooBuilder { data }
    }
}

原因解释 #

std::mem::transmute的核心限制是：必须在编译期确定源类型和目标类型的内存尺寸完全相同，且不允许转换依赖大小类型（DST）或尺寸可能变化的类型。

虽然FooBuilder<SIZE, false>和FooBuilder<SIZE, true>的内存布局完全一致（布尔const参数不影响结构体字段），但在泛型代码上下文中，编译器不会针对每个具体的SIZE值做布局兼容性验证。对编译器而言，这是两个不同的泛型实例化类型，且它们的尺寸依赖于SIZE这个const参数——编译器无法在泛型代码中提前确认，对所有可能的SIZE值，这两个类型的尺寸都完全一致，因此直接触发错误。

简单来说：Rust的类型系统将每个const参数组合视为独立类型，transmute不会跨类型做“布局等价”的深层检查，只看类型本身的尺寸是否在编译期固定且相等。

解决方案 #

1. 优先使用安全的构造方式 #

回到最初的安全实现，针对AsRef<T>的生命周期问题，可以调整代码如下：

impl<const SIZE: usize> FooBuilder<SIZE, false> {
    pub fn bar<T: AsRef<[usize; SIZE]>>(self, bar: T) -> FooBuilder<SIZE, true> {
        FooBuilder {
            bar: Some(*bar.as_ref()),
        }
    }
}

这种方式完全安全，且能避免transmute带来的所有unsafe风险，是推荐的做法。

2. 若必须使用unsafe转换：用std::mem::transmute_copy #

如果确实需要绕过类型系统，可以使用std::mem::transmute_copy，它按字节复制内存，不要求类型尺寸在编译期固定，但需要手动保证两个类型布局完全一致：

impl<const SIZE: usize> FooBuilder<SIZE, false> {
    pub fn bar(mut self, bar: [usize; SIZE]) -> FooBuilder<SIZE, true> {
        self.bar = Some(bar);
        unsafe {
            let result = std::mem::transmute_copy(&self);
            // 手动丢弃self，避免双重释放
            std::mem::forget(self);
            result
        }
    }
}

注意：这种写法是unsafe的，必须确保两个FooBuilder的布局100%一致，否则会导致未定义行为。

内容的提问来源于stack exchange，提问作者Typhaon