如何为重叠实现者正确实现Rust的DynConvert trait？

现有这段Rust代码：

pub trait DynConvert<T> {
    fn dyn__convert(&self) -> &T;
}

impl<T, U: AsRef<T>> DynConvert<T> for U {
    fn dyn__convert(&self) -> &T {
        self.as_ref()
    }
}

impl<T, U: Into<T> + Clone> DynConvert<T> for U {
    fn dyn__convert(&self) -> &T {
        &(self.clone().into())
    }
}

struct A;
impl AsRef<SomeType> for A { /* ... */ }
impl Into<SomeType> for A { /* ... */ }
struct B;
impl Into<SomeType> for B { /* ... */ }

我有两组类型：T0到Tn、U0到Un。所有类型都实现了Into<目标类型>，只有U0到Un额外实现了AsRef<目标类型>。现在要调整DynConvert trait的实现，让：

• 实现了AsRef<T>的类型（也就是U0到Un）调用as_ref来完成转换
• 只实现Into<T>但没实现AsRef<T>的类型（也就是T0到Tn）调用clone().into()来完成转换

原代码的核心问题 #

原代码里的两个impl会产生冲突——像A这种同时实现AsRef<T>和Into<T>+Clone的类型，会同时匹配到两个实现，编译器无法确定选择哪一个，直接报错。所以核心要做的就是让AsRef相关的实现优先级更高，或者限制第二个impl仅适用于未实现AsRef<T>的类型。

方案1：Nightly版本用负约束（简洁直接） #

如果使用Rust Nightly版本，可以直接用负trait约束（!Trait语法），让第二个impl只适配未实现AsRef<T>的类型：

#![feature(negative_impls)]
#![feature(impl_trait_projections)]

pub trait DynConvert<T> {
    fn dyn__convert(&self) -> &T;
}

// 优先匹配实现AsRef<T>的类型
impl<T, U: AsRef<T>> DynConvert<T> for U {
    fn dyn__convert(&self) -> &T {
        self.as_ref()
    }
}

// 仅匹配未实现AsRef<T>、但实现Into<T>+Clone的类型
impl<T, U: Into<T> + Clone + !AsRef<T>> DynConvert<T> for U {
    fn dyn__convert(&self) -> &T {
        // 注意：原代码存在悬垂引用问题！clone().into()生成的临时栈对象会在方法结束后销毁
        // 改用Box将对象分配到堆上，解决引用失效问题
        &*Box::new(self.clone().into())
    }
}

方案2：稳定版用特化（兼容性好） #

稳定版中可以启用min_specialization特性，通过trait特化让AsRef的实现优先级更高：

#![feature(min_specialization)]

pub trait DynConvert<T> {
    fn dyn__convert(&self) -> &T;
}

// 基础实现：适配所有Into<T>+Clone的类型，用default标记为可被特化
impl<T, U: Into<T> + Clone> DynConvert<T> for U {
    default fn dyn__convert(&self) -> &T {
        &*Box::new(self.clone().into())
    }
}

// 特化实现：适配同时实现AsRef<T>的类型，优先级高于基础实现
impl<T, U: AsRef<T> + Into<T> + Clone> DynConvert<T> for U {
    fn dyn__convert(&self) -> &T {
        self.as_ref()
    }
}

编译器会优先选择特化版本，从而避免实现冲突。

关键提醒：修复悬垂引用问题 #

原代码中第二个impl返回临时栈对象的引用是严重错误——临时对象在方法执行完毕后会被销毁，返回的引用会变成无效的野指针，要么编译报错，要么引发运行时未定义行为。除了用Box堆分配的方式，更稳妥的做法是修改trait的返回值为所有权类型T，彻底避开引用生命周期问题：

pub trait DynConvert<T> {
    fn dyn__convert(&self) -> T;
}

// 对实现AsRef<T>的类型，克隆出所有权对象
impl<T, U: AsRef<T>> DynConvert<T> for U
where T: Clone {
    fn dyn__convert(&self) -> T {
        self.as_ref().clone()
    }
}

// 对实现Into<T>+Clone的类型，直接clone后转换
impl<T, U: Into<T> + Clone> DynConvert<T> for U {
    fn dyn__convert(&self) -> T {
        self.clone().into()
    }
}

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