Eu entendo perfeitamente no que você está se metendo.

Mesmo que Plugin: AnyObject, quando você se refere a any Plugin, ele seja tratado como um existencial — e existenciais em Swift não são tipos de classe , mesmo que o protocolo de onde eles vêm seja AnyObject.
É por isso que ObjectHashable<T: AnyObject>se recusa a aceitar any Plugincomo T— porque any Pluginnão é em si uma classe, mesmo que as implementações de Plugindevam ser.

Por que qualquer plugin é um problema

any Plugin é um tipo de valor que representa "qualquer instância em conformidade com Plugin".

Isso não garante que seja uma instância de classe no nível de tipo de uma forma que restrições genéricas possam verificar.

O Swift trata qualquer Plugin de forma diferente dos tipos concretos que estão em conformidade com o Plugin.

Então... como resolver sua situação?

Aqui está o truque: em vez de escrever ObjectHashable<any Plugin>,
você precisa ObjectHashable<some Plugin> usar sites ou
redesenhar ObjectHashableum pouco para aceitar valores existenciais.

Uma solução limpa para o seu caso

Mude ObjectHashablepara aceitar qualquer um AnyObject (mesmo any Pluginos existenciais).

Aqui está uma versão ligeiramente atualizada de ObjectHashable:

public struct ObjectHashable: Hashable {
    public let object: AnyObject

    public init(_ object: AnyObject) {
        self.object = object
    }

    public static func ==(lhs: Self, rhs: Self) -> Bool {
        return ObjectIdentifier(lhs.object) == ObjectIdentifier(rhs.object)
    }

    public func hash(into hasher: inout Hasher) {
        hasher.combine(ObjectIdentifier(object))
    }
}

Agora você não precisa mais se preocupar com genéricos.
Você pode armazenar qualquer objeto de classe — inclusive any Plugin— encapsulado corretamente.

Uso:

var dict: [ObjectHashable: String] = [:]
let pluginInstance: any Plugin = SomePlugin()
dict[ObjectHashable(pluginInstance)] = "some value"

Mas você pediu rigor (não tão aberto assim AnyObject)...

Se você ainda quiser restringir apenas ao Plugin (não a qualquer classe), veja como fazer isso de forma mais restrita:

public struct PluginHashable: Hashable {
    public let plugin: any Plugin

    public init(_ plugin: any Plugin) {
        self.plugin = plugin
    }

    public static func ==(lhs: Self, rhs: Self) -> Bool {
        return ObjectIdentifier(lhs.plugin as AnyObject) == ObjectIdentifier(rhs.plugin as AnyObject)
    }

    public func hash(into hasher: inout Hasher) {
        hasher.combine(ObjectIdentifier(plugin as AnyObject))
    }
}

- Isso garante que você só possa encapsular any Plugin, e não qualquer AnyObject .
- E você ainda faz o hash com base na identidade do objeto.

Uso:

var pluginDict: [PluginHashable: String] = [:]
let p1: any Plugin = MyPlugin()
let p2: any Plugin = MyOtherPlugin()
pluginDict[PluginHashable(p1)] = "First Plugin"
pluginDict[PluginHashable(p2)] = "Second Plugin"

Por que você não pode usar ObjectHashable<Plugin>?

Porque ObjectHashable<T: AnyObject>espera um tipo de classe T ,
mas any Pluginnão é um tipo de classe — é um valor existencial.

Você tem que:

• fazer ObjectHashablenão genérico, armazenar AnyObject, OU

• especialize-o para seu protocolo (como PluginHashableacima).

Espero que isso ajude. Avise-me se o seu problema for resolvido.

EDITAR:

Já que você mencionou que essa solução anterior não funciona para você, vou seguir minha sugestão no comentário: especializar ObjectHashable para existenciais que são somente de classe.

Veja como você pode fazer isso:

public struct ObjectHashable<T>: Hashable {
    public let object: T

    public init(_ object: T) {
        self.object = object
    }

    public static func ==(lhs: ObjectHashable<T>, rhs: ObjectHashable<T>) -> Bool {
        ObjectIdentifier(lhs.object as AnyObject) == ObjectIdentifier(rhs.object as AnyObject)
    }

    public func hash(into hasher: inout Hasher) {
        hasher.combine(ObjectIdentifier(object as AnyObject))
    }
}

Observe atentamente :

• Té genérico .

• Em tempo de execução, fazemos a conversão AnyObjectmanualmente para dentro ==e hash(into:).

• Em tempo de compilação , você ainda pode fazer uma verificação de tipo rigorosa para ObjectHashable<Plugin>etc.

Agora o uso parece super limpo:

typealias PluginHashable = ObjectHashable<qualquer Plugin>

var pluginDict: [PluginHashable: String] = [:]
let plugin1: any Plugin = MyPlugin()
let plugin2: any Plugin = AnotherPlugin()
pluginDict[PluginHashable(plugin1)] = "Plugin 1"
pluginDict[PluginHashable(plugin2)] = "Plugin 2"

Com isso, você obtém:
- Aplicação rigorosa de tipos em tempo de compilação.
- Reutilizável também para outros protocolos somente de classe, sem precisar de um wrapper personalizado todas as vezes.

Caso você queira uma proteção de tempo de compilação ainda mais rigorosa, que seja opcional, você pode adicionar uma asserção de tempo de execução. Isso proibiria o uso indevido (por exemplo: alguém tentando passar uma struct). Você teria um código como este:

public init(_ object: T) {
    precondition(Mirror(reflecting: object).subjectType is AnyObject.Type, "T must be a class type")
    self.object = object
}

Mas, sinceramente, como você está escolhendoany Plugin o PluginHashablealias manualmente, já está tudo bem. Não precisa verificar em tempo de execução, a menos que você seja superparanoico, rs.