Decoding a Codable with class type returned from a function actually returns an item with its superclass as type - swift

Question

I wrote a custom decoder for a json response where I have a "content" field that can be decoded to various different classes, all of them inheriting from the same ContentItem superclass. I also have a function that returns a class type, which I use in my decoder (I know that there may be different ways to do this, but that's not the problem):
init(from decoder: Decoder) throws {
...
guard let type = type, let contentItemType = getItemClass(from: type) else { return }
content = try container.decode(contentItemType, forKey: .content)
}
func getItemClass(from type: ProductContentType) -> ContentItem.Type? {...}
ProductContentType is a String enum. The getItemClass function returns the correct class, I've checked while debugging:
getItemClass(from: .type1) === Item1Class.self //<-- this returns true
The problem is the following:
guard let type = type, let contentItemType = getItemClass(from: type) else { return }
content = try container.decode(contentItemType, forKey: .content)
// ^ In this case content is kind of class ContentItem
let downcastContent = content as? Item1Class // <- downcastContent is nil
content = try container.decode(Item1Class.self, forKey: .content)
// ^ In this case content is kind of class Item1Class
let downcastContent = content as? Item1Class // this works
Downcasting with the content in the first case returns nil, but it doesn't make sense to me. Also I've noticed that when decoding the item the init(from: Decoder) in the subclass is never called.
Is it supposed to be this way? I was expecting both decode to return a content with class Item1Class. Am I missing something in the decode process in the first case?

Answer 1

Is it supposed to be this way?
Yes. Note that you don't know exactly what the decoded type is - getItemClass could have returned Item1Class.self, or Item2Class.self, or Item3Class.self, and so on. But you do know that whatever it returns, it is a subclass of ContentItem, so at least, you can assign it to a variable of type ContentItem, so content could only be of type ContentItem.Type.
More accurately, getItemClass returns ContentItem.Type, which becomes the inferred type of contentItemType, and when you passed it to the decode method, the generic parameter T is inferred to be ContentItem. The return type of decode is also T, so content has the type ContentItem.
However, just like how even though contentItemType has the type ContentItem.Type, its value is actually a Item1Class.self, even though content has the type ContentItem, it actually has a reference to a Item1Class instance. You can show this by showing that casting succeeds:
let item1 = content as! Item1Class // this succeeds
or you can check the runtime type of content directly:
type(of: content) == Item1Class.self / true
JSONDecoder will actually look at the contentItemType that you passed to it. That parameter is not just used to infer T.
Here is a minimal reproducible example:
class Foo : Decodable {
let a: String
}
class Bar: Foo {
enum CodingKeys: CodingKey {
case b
}
let b: String
required init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
b = try container.decode(String.self, forKey: .b)
try super.init(from: decoder)
}
}
let json = """
{"a": "Foo", "b": "Bar"}
""".data(using: .utf8)
func getItemClass() -> Foo.Type {
Bar.self
}
let type = getItemClass()
let fooButItsActuallyBar = try JSONDecoder().decode(type, from: json!)
let bar = fooButItsActuallyBar as! Bar // this succeeds
print(bar.a, bar.b)
Note that in the above example, the subclass Bar has overridden the required initialiser to implement custom decoding, because the auto-generated implementation isn't generated for subclasses (See also). If you didn't override it, you will see the subclass's properties uninitialised. That could be another reason why you think decode decodes an instance of ContentItem.