In the case of classes, we might want to always be willing to call a superclass's default constructor if it's not Codable. Regardless, we need to provide a better diagnostic in this case.

Comment by Kashif Shaikh (JIRA)

The same problem can be manifested without required init:

class TestObject {
    let x: String
    
    init(x:String) {
        self.x = x
    }
}

class TestCodable : TestObject, Codable {
    let y: String
    let z: String
    init(x:String, y:String, z:String) {
        self.y = y
        self.z = z
        super.init(x:x)
    }
}

The compiler fails with:

<unknown>:0: error: super.init isn't called on all paths before returning from initializer

If I manually add the decodable methods, it compiles successfully.

class TestCodable : TestObject, Codable {
    let y: String
    let z: String
    init(x:String, y:String, z:String) {
        self.y = y
        self.z = z
        super.init(x:x)
    }
    
    required init(from decoder: Decoder) throws {
        let x = "decode x"
        let y = "decode y"
        let z = "decode z"
        self.y = y
        self.z = z
        super.init(x:x)
    }
}

Because the code generated for the Decodable init method can't know for certain which super.init method to call.

Normally we could code our model objects such that we don't have inheritance, which kind of solves the problem. But many of us are using Realm, and when we add Codable to our Realm model objects, the compiler fails with the same error.

I've thought some more about it and I think it would be really beneficial for the compiler to not error out when the super class has an argument-less initialiser. It's going to be such a common case that it would be really a pity to force users to implement their own initializer just to call super.init(). Especially as it's always an option for users to implement it manually when they intend to call a different super initialiser.

@swift-ci Create

I think the problem can be expressed far more compactly:

class Superclass : Codable {}
class Subclass : Superclass {
    var prop : String?
    init(prop:String) {
        self.prop = prop
    }
}

This gives:

error: 'required' initializer 'init(from:)' must be provided by subclass of 'Superclass'

The problem is that giving the subclass a designated initializer has cut off inheritance of the Codable injected init(from:). We are therefore forced to write init(from:) manually in the subclass. That's ugly.

This was actually fixed a while back before the Swift 4.0 release.

@mattneub That looks like a separate issue. Let me look into that.

@itaiferber Sorry about that: would you like me to submit it separately? I couldn't find anything comparable and this looked very close.

@mattneub Yeah, that's not Codable-specific (and is correct behavior AFAICT):

class Super {
    required init() {}
}

class Sub : Super {
    var prop: String?
    init(prop: String) {
        self.prop = prop
    }
}

produces

Untitled 2.swift:10:1: error: 'required' initializer 'init()' must be provided by subclass of 'Super'
}
^
Untitled 2.swift:2:14: note: 'required' initializer is declared in superclass here
    required init() {}

If your superclass has a required initializer, you can only inherit it if you don't add your own initializer. If you remove sub's init(prop: String) it compiles just fine.

I know, but this undoes all the good done by Codable's injected init(from:). That's very hard on users (esp. beginners who expect declaring Codable to make all the good stuff happen automagically). I'm asking whether we couldn't somehow stretch a point and make this work.

@mattneub That might be possible, but I'm not sure if it would be worth it. Codable just performs codegen; there's nothing it can do that you can't write yourself, and vice versa. Special-casing it through the various levels of the compiler would get real nasty real quick, I think.

That being said, I think that the compiler diagnostic could certainly be improved. Given that it took me a sec to figure out why you were getting that message, I think we can do better (e.g. "note: subclass initializer 'init(prop: String)' prevented inheritance of 'required init()'; 'required init()' must be overridden"). That should be filed separately, though, if you don't mind. 🙂

@itaiferber will do.

@mattneub Thanks! 🙂

https://bugs.swift.org/browse/SR-6875