Skip to main content

Casting and testing for class conformance in Swift

EDIT: The previous answers alluded to in the comments can be used to solve the problem, although the question there lay in determining a Type from an Any vs my question here, which was how to determine if any given Type was a reference type and how to safely conform said type to AnyObject.

So I have a new dependency injection framework, Factory.

Factory allows for scoped instances, basically allowing you to cache services once they're created. And one of those scopes is shared. Any instance shared will be cached and returned just as long as someone in the outside world maintains a strong reference to it. After the last reference releases the object the cache releases the object and a new instance will be created on the next resolution.

This is implemented, obviously, as simply maintaining a weak reference to the created object. If the weak reference is nil it's time to create a new object.

And therein lies the problem

Weak references can only apply to reference types.

Factory uses generics internally to manage type information. But I can create Factories of any type: Classes, structs, strings, whatever.)

Scopes use dictionaries of boxed types internally. If an instance exists in the cache and in the box it's returned. So what I'd like to do is create this...

private struct WeakBox<T:AnyObject>: AnyBox {
    weak var boxed: T
}

The AnyObject conformance is need in order to allow weak. You get a compiler error otherwise. Now I want to box and cache an object in my shared scope with something like this...

func cache<T>(id: Int, instance: T) {
    cache[id] = WeakBox(boxed: instance)
}

But this also gives a compiler error. (Generic struct WeakBox requires T to be a class type.)

So how to bridge from on to the other? Doing the following doesn't work. Swift shows a warning that "Conditional cast from 'T' to 'AnyObject' always succeeds" and then converts the type anyway.

func cache<T>(id: Int, instance: T) {
    if let instance = instance as? AnyObject {
        cache[id] = WeakBox(boxed: instance)
    }
}

I'd be happy with the following, but again, same problem. You can't test for class conformance and you can't conditionally cast to AnyObject. Again, it always succeeds.

private struct WeakBox: AnyBox {
    weak var boxed: AnyObject?
}
func cache<T>(id: Int, instance: T) {
    if let instance = instance as? AnyObject {
        cache[id] = WeakBox(boxed: instance)
    }
}

What I'm doing at the moment is something like...

private struct WeakBox: AnyBox {
    weak var boxed: AnyObject?
}
func cache<T>(id: Int, instance: T) {
    cache[id] = WeakBox(boxed: instance as AnyObject)
}

Which works, but that instance as AnyObject cast depends on some very weird Swift to Objective-C bridging behavior.

Not being able to test for class conformance at runtime is driving me bonkers, and seems like a semi-major loophole in the language.

You can't test for conformance, and you can't cast for conformance.

So what can you do?

by Michael Long in StackOverflow on July 02, 2022.
Answer

As Martin notes in a comment, any value can be cast to AnyObject in Swift, because Swift will wrap value types in an opaque _SwiftValue class, and the cast will always succeed. There is a way around this, though.

The way to check whether a value is a reference type without this implicit casting is to check whether its type is AnyObject.Type, like so:

func printIsObject<T>(_: T) {
    if T.self is AnyObject.Type {
        print("Object")
    } else {
        print("Other")
    }
}

class Foo {}
struct Bar {}
enum Quux { case q }

printIsObject(Foo()) // => Object
printIsObject(Bar()) // => Other
printIsObject(Quux.q) // => Other

Note that it's crucial that you check whether the type is AnyObject.Type not is AnyObject. T.self, the object representing the type of the value, is itself an object, so is AnyObject will always succeed. Instead, is AnyObject.Type asks "does this inherit from the metatype of all objects", i.e., "does this object which represents a type inherit from an object that represents all object types?"

Edit: Evidently, I'd forgotten that Swift includes AnyClass as a synonym for AnyObject.Type, so the check can be simplified to be is AnyClass. However, leaving the above as a marginally-expanded explanation for how this works.

To integrate this into your caching mechanism, you'll want to check the incoming generic type to see if it is AnyObject.Type, and only if it's already an object, cast it to AnyObject to store in a weak box:

func cache<T>(id: Int, instance: T) {
    if T.self is AnyObject.Type {
        cache[id] = WeakBox(boxed: instance as AnyObject)
    } else {
        // Store in a different cache, or do whatever.
    }
}
by Itai Ferber on July 02, 2022.

Comments

Post a Comment