Por que os inicializadores do Swift não podem chamar inicializadores de conveniência em sua superclasse?

Considere as duas classes:

class A {
    var x: Int

    init(x: Int) {
        self.x = x
    }

    convenience init() {
        self.init(x: 0)
    }
}

class B: A {
    init() {
        super.init() // Error: Must call a designated initializer of the superclass 'A'
    }
}

Não vejo por que isso não é permitido. No final das contas, o inicializador designado de cada classe é chamado com quaisquer valores de que precisam, então por que preciso me repetir em B's initespecificando um valor padrão para xnovamente, quando a conveniência initem Abastará?

Esta é a Regra 1 das regras de "Encadeamento de inicializador" conforme especificado no Guia de programação Swift, que diz:

Regra 1: os inicializadores designados devem chamar um inicializador designado de sua superclasse imediata.

https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html

Ênfase minha. Os inicializadores designados não podem chamar inicializadores de conveniência.

Há um diagrama que acompanha as regras para demonstrar quais "direções" do inicializador são permitidas:

Considerar

class A
{
    var a: Int
    var b: Int

    init (a: Int, b: Int) {
        print("Entering A.init(a,b)")
        self.a = a; self.b = b
    }

    convenience init(a: Int) {
        print("Entering A.init(a)")
        self.init(a: a, b: 0)
    }

    convenience init() {
        print("Entering A.init()")
        self.init(a:0)
    }
}


class B : A
{
    var c: Int

    override init(a: Int, b: Int)
    {
        print("Entering B.init(a,b)")
        self.c = 0; super.init(a: a, b: b)
    }
}

var b = B()

Como todos os inicializadores designados da classe A são substituídos, a classe B herdará todos os inicializadores de conveniência de A. Portanto, a execução disso resultará

Entering A.init()
Entering A.init(a:)
Entering B.init(a:,b:)
Entering A.init(a:,b:)

Agora, se o inicializador designado B.init (a: b :) tivesse permissão para chamar o inicializador de conveniência da classe base A.init (a :), isso resultaria em uma chamada recursiva para B.init (a:, b: )

É porque você pode acabar com uma recursão infinita. Considerar:

class SuperClass {
    init() {
    }

    convenience init(value: Int) {
        // calls init() of the current class
        // so init() for SubClass if the instance
        // is a SubClass
        self.init()
    }
}

class SubClass : SuperClass {
    override init() {
        super.init(value: 10)
    }
}

e olhe para:

let a = SubClass()

que chamará SubClass.init()que ligará SuperClass.init(value:)que ligará SubClass.init().

As regras de inicialização designadas / de conveniência são projetadas de forma que a inicialização de uma classe esteja sempre correta.

Eu encontrei uma solução alternativa para isso. Não é muito bonito, mas resolve o problema de não saber os valores de uma superclasse ou de querer definir os valores padrão.

Tudo o que você precisa fazer é criar uma instância da superclasse, usando a conveniência init, diretamente initda subclasse. Em seguida, você chama o designado initdo super usando a instância que acabou de criar.

class A {
    var x: Int

    init(x: Int) {
        self.x = x
    }

    convenience init() {
        self.init(x: 0)
    }
}

class B: A {
    init() {
        // calls A's convenience init, gets instance of A with default x value
        let intermediate = A() 

        super.init(x: intermediate.x) 
    }
}

Considere extrair o código de inicialização de sua função conveniente init()para uma nova função auxiliar foo(), chamada foo(...)para fazer a inicialização em sua subclasse.

Veja o vídeo WWDC "403 intermediário Swift" às 18:30 para uma explicação detalhada dos inicializadores e sua herança. Pelo que entendi, considere o seguinte:

class Dragon {
    var legs: Int
    var isFlying: Bool

    init(legs: Int, isFlying: Bool) {
        self.legs = legs
        self.isFlying = isFlying
    }

    convenience initWyvern() { 
        self.init(legs: 2, isFlying: true)
    }
}

Mas agora considere uma subclasse da Wyrm: Uma Wyrm é um Dragão sem pernas e sem asas. Portanto, o inicializador para um Wyvern (2 pernas, 2 asas) é errado para isso! Esse erro pode ser evitado se o Wyvern-Initializer de conveniência simplesmente não puder ser chamado, mas apenas o Initializer completo designado:

class Wyrm: Dragon {
    init() {
        super.init(legs: 0, isFlying: false)
    }
}

Por que você não tem apenas dois inicializadores - um com um valor padrão?

class A {
  var x: Int

  init(x: Int) {
    self.x = x
  }

  init() {
    self.x = 0
  }
}

class B: A {
  override init() {
    super.init()

    // Do something else
  }
}

let s = B()
s.x // 0