Rust中仅需实现可变Getter的Trait设计方案是否安全？

我希望设计一个Trait，包含对self某字段的可变Getter（inside_mut）和不可变Getter（inside_ref），但要求Trait的实现者仅需实现其中一个方法（通常是可变Getter）。我找到了如下实现方案：

pub trait MyTrait<T> {
    fn inside_mut(&mut self) -> &mut T; 
    
    fn inside_ref(&self) -> &T {
        let ptr = self as *const Self as *mut Self;
        &* unsafe { &mut *ptr }.inside_mut()
    }
}

pub struct Data(String);
impl MyTrait<String> for Data {
    fn inside_mut(&mut self) -> &mut String { &mut self.0 }
}

fn main() {
    let mut data = Data(format!("Foo"));
    let x: &String = data.inside_ref();
    let y: &String = data.inside_ref();
    println!("x -> {x}");
    println!("y -> {y}");
    *data.inside_mut() = format!("Bar");
    println!("data.0 -> {}", data.0);
}

运行结果：

Standard Error

   Compiling playground v0.0.1 (/playground)
    Finished release [optimized] target(s) in 0.93s
     Running `target/release/playground`

Standard Output

x -> Foo
y -> Foo
data.0 -> Bar

请问该实现方案是否符合Rust的内存安全规范？

这个实现不符合Rust的内存安全规范，核心问题出在inside_ref的默认实现里的unsafe代码直接违反了Rust的核心借用规则：

1. 违反可变/不可变借用互斥规则
   当调用inside_ref时，当前持有&self（不可变借用），但代码通过self as *const Self as *mut Self强制转换为可变指针，再通过unsafe { &mut *ptr }制造出一个&mut Self。这相当于在已有不可变借用的场景下，凭空生成了可变借用，完全打破了Rust的安全承诺：同一时间不能同时存在可变借用和任意数量的不可变借用。

当前示例运行正常只是巧合，这种写法属于未定义行为——编译器的借用检查器无法追踪手动制造的可变借用，后续如果出现复杂的借用场景，极可能引发数据竞争、悬垂引用或内存损坏。

2. Trait实现者的行为会放大风险
   如果inside_mut的实现包含修改结构体内部布局、使引用失效的逻辑，这种unsafe转换会将风险进一步放大，因为默认实现完全依赖inside_mut的行为是“安全的”，但Trait并没有对此做出约束。

安全替代方案 #

要实现“仅需实现一个Getter即可获得另一个”的需求，更安全的方式包括：

• 反转依赖：让Trait默认实现inside_mut调用inside_ref的可变转换（需配合UnsafeCell保证安全），要求实现者先提供不可变Getter；
• 使用派生宏自动为结构体生成两个Getter方法，完全避免手动编写unsafe代码；
• 定义核心访问方法，基于此安全实现两个Getter：

use std::cell::UnsafeCell;

pub trait MyTrait<T> {
    fn inner_cell(&self) -> &UnsafeCell<T>;
    
    fn inside_ref(&self) -> &T {
        unsafe { &*self.inner_cell().get() }
    }
    
    fn inside_mut(&mut self) -> &mut T {
        unsafe { &mut *self.inner_cell().get() }
    }
}

pub struct Data(UnsafeCell<String>);
impl MyTrait<String> for Data {
    fn inner_cell(&self) -> &UnsafeCell<String> { &self.0 }
}

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