Rust中可变→不可变→可变引用转换是否属于未定义行为？

无论不可变引用的原始来源是否为可变引用，将不可变引用强制转换为可变引用始终属于未定义行为（UB）。

Rust的借用规则是编译期静态约束，与内存实际可变性无关：

• 一旦创建不可变引用，编译器会假定其生命周期内对应内存不会被可变引用访问/修改。
• 哪怕通过unsafe绕过检查，这种转换也会破坏内存安全契约，导致编译器优化逻辑（如指令重排序、常量折叠）失效，引发不可预测的运行时问题。

你给出的query_mut实现既过不了编译，也存在UB风险：

pub fn query_mut<'a>(&'a mut self, query: &str) -> Option<&'a mut SchemaNode> {
    let node = self.query(query)?; // 生成&self类型的不可变引用
    unsafe {
        let const_ptr = node as *const SchemaNode;
        let mut_ptr = const_ptr as *mut SchemaNode;
        mut_ptr.as_mut()
    }
}

1. 编译错误：query_mut持有&mut self可变引用，此时调用self.query会生成&self不可变引用——违反Rust核心规则：同一时间不能共存可变和不可变引用。
2. UB风险：就算绕过编译，unsafe转换依然违反编译器对内存访问的假设，会导致优化错误。

最佳做法是分别实现可变/不可变版本的查询逻辑，或抽象通用逻辑避免重复。以下是直接实现的版本：

impl Schema {
    pub fn query(&self, query: &str) -> Option<&SchemaNode> {
        let mut fragments = query.split(".");

        let name = fragments.next()?;
        let mut node = self.fields.iter().find(|n| n.name == name)?;

        for name in fragments {
            match &node.dtype {
                DType::Base => return None,
                DType::Complex { name: type_name } => {
                    node = self
                        .types
                        .get(type_name)?
                        .children
                        .iter()
                        .find(|c| c.name == name)?;
                }
            };
        }

        Some(node)
    }

    pub fn query_mut(&mut self, query: &str) -> Option<&mut SchemaNode> {
        let mut fragments = query.split(".");

        let name = fragments.next()?;
        let mut node = self.fields.iter_mut().find(|n| n.name == name)?;

        for name in fragments {
            match &mut node.dtype {
                DType::Base => return None,
                DType::Complex { name: type_name } => {
                    // 使用get_mut获取可变ComplexType引用，再通过iter_mut获取子节点可变引用
                    node = self
                        .types
                        .get_mut(type_name)?
                        .children
                        .iter_mut()
                        .find(|c| c.name == name)?;
                }
            };
        }

        Some(node)
    }
}

若想避免重复代码，可抽象内部通用遍历函数，但可变引用的处理需要额外注意（因&mut self无法直接适配&self的泛型逻辑），直接实现可变版本反而更简洁。

• 禁止通过unsafe将不可变引用转为可变引用，这是明确的UB。
• 严格遵循Rust借用规则，分别实现可变/不可变查询函数，或通过合理抽象减少重复代码。

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