I'll copy the explanation from the Radar out to share publicly.

Unlike the existing NSCoding API (NSKeyedArchiver), the new Swift 4 Codable implementations do not write out type information about encoded types into generated archives, for both flexibility and security. As such, at decode time, the API can only use the concrete type your provide in order to decode the values (in your case, the superclass type).

This is by design — if you need the dynamism required to do this, we recommend that you adopt NSSecureCoding and use NSKeyedArchiver/NSKeyedUnarchiver, which will allow you to decode based on the class found in the archive rather than what is requested at runtime. See https://developer.apple.com/documentation/foundation/nscoding and https://developer.apple.com/documentation/foundation/nssecurecoding for more info.

Alternatively, if you know the possible subclasses which can be decoded from the payload, you can get an unkeyed container (instead of requesting Array<Superclass>) and attempt to decode instances of the subclasses out of the container; if those fail, you can decode the superclass successfully.

Comment by Joshua Nozzi (JIRA)

Thank you for this explanation. I'm not sure I agree with the approach if the goal is to be a Swiftlier serialization system than NSCoding but I see the value in it. What led me to discover this (I'll call it a) limitation is that I was converting a document-based application from NSCoding and couldn't understand why this was happening.

I feel that I'm missing something though, concerning your comment about getting an unkeyed container instead of Array<Superclass>. Could you elaborate a bit?

I think the responder (who wasn't me) was going for something like

let element: Superclass
do {
  element = try container.decode(Subclass.self)
} catch let error {
  element = try container.decode(Superclass.self)
}

But this would be trickier if you had multiple subclasses, and wouldn't work if the coded representation doesn't have enough information to distinguish subclasses and superclasses, of course.