跨Xcode框架/SPM模块时，DI框架类型强制转换失败问题

问题背景 #

项目正从Xcode框架+CocoaPods架构迁移至SPM模块，自研DI框架在跨模块注册/解析依赖时出现类型转换失败。核心代码如下：

protocol Dependency {
    associatedtype BoxType
    var value: BoxType { get }
}

struct Box<T>: Dependency {
   let value: T
}

private var dependencies: [String: any Dependency]

func resolve<T>(key: String) -> T {
    (dependencies[key] as! Box<T>).value
}

调试发现，存储的依赖类型为MySPMModule.MyType.Protocol，但解析时泛型类型为@Thick MySPMModule.MyType.Protocol，导致Box<T>与Box<@Thick T>类型不匹配，强制转换失败。

问题根源 #

Swift中协议类型存在厚度差异：跨模块边界时，协议类型的元数据会被标记为@Thick（包含完整类型信息的厚协议），而模块内部可能使用默认的普通协议类型。这种差异让Box<T>和Box<@Thick T>被视为完全不同的类型，即使T指向同一协议，也无法直接强制转换。

解决思路与实现 #

1. 重构DI框架，用类型擦除绕过关联类型依赖 #

原方案中Dependency的关联类型要求Box<T>的泛型参数必须精确匹配，这在跨模块协议厚度变化时会失效。改用无关联类型的类型擦除协议，直接关注最终值的类型转换：

// 替换原Dependency协议，实现类型擦除
protocol AnyDependency {
    func resolve() -> Any
}

// 调整Box结构体适配新协议
struct Box<T>: AnyDependency {
    let value: T
    
    func resolve() -> Any {
        value
    }
}

private var dependencies: [String: AnyDependency]

// 修改resolve函数，直接从Any转换为目标类型T
func resolve<T>(key: String) -> T {
    guard let dependency = dependencies[key],
          let resolvedValue = dependency.resolve() as? T else {
        fatalError("Failed to resolve dependency for key: \(key), type: \(T.self)")
    }
    return resolvedValue
}

这种方式不再依赖Box<T>的泛型参数匹配，自然兼容@Thick和普通协议类型的差异。

2. 在resolve函数中兼容两种协议厚度类型 #

如果不想大规模重构原框架，可以修改resolve函数，同时尝试匹配普通协议和@Thick协议对应的Box类型：

func resolve<T>(key: String) -> T {
    // 先尝试匹配普通Box<T>
    if let box = dependencies[key] as? Box<T> {
        return box.value
    }
    // 若T是协议类型，尝试匹配Box<@Thick T>
    if T.self is Any.Type,
       let thickBox = dependencies[key] as? Box<@Thick T> {
        return thickBox.value
    }
    fatalError("Failed to resolve \(T.self) for key \(key)")
}

3. 使用类型标识替代字符串Key #

字符串Key容易出现人为失误，改用ObjectIdentifier作为Key，确保注册和解析的类型完全对应，减少跨模块类型匹配的不确定性：

private var dependencies: [ObjectIdentifier: AnyDependency]

// 注册函数示例
func register<T>(_ dependency: T) {
    let key = ObjectIdentifier(T.self)
    dependencies[key] = Box(value: dependency)
}

// 修改resolve函数
func resolve<T>() -> T {
    let key = ObjectIdentifier(T.self)
    guard let dependency = dependencies[key],
          let resolvedValue = dependency.resolve() as? T else {
        fatalError("Failed to resolve dependency for type: \(T.self)")
    }
    return resolvedValue
}

总结 #

跨模块协议厚度差异是Swift模块边界的底层特性，核心解决思路是避免依赖泛型参数的精确匹配：要么通过类型擦除直接处理值的类型转换，要么在解析逻辑中兼容两种协议厚度的情况。使用类型标识替代字符串Key能进一步减少类型匹配的潜在问题。

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