Forcer l'erreur de compilation avec les classes scellées

Question

Avec les classes scellées, vous pouvez utiliser des when et omettre l'expression else lorsque l'expression renvoie un résultat :

sealed class SealedClass {
  class First : SealedClass()
  class Second : SealedClass()
}

fun test(sealedClass: SealedClass) : String =
    when (sealedClass) {
      is SealedClass.First -> "First"
      is SealedClass.Second -> "Second"
    }

Maintenant, si je devais ajouter un Third à SealedClass le compilateur se plaindra que l'option when l'expression dans test() n'est pas exhaustive, et je dois ajouter une clause de Third o else .

Je me demande cependant si ce contrôle peut également être appliqué lorsque test() ne renvoie rien :

fun test(sealedClass: SealedClass) {
    when (sealedClass) {
      is SealedClass.First -> doSomething()
      is SealedClass.Second -> doSomethingElse()
    }
}

Cet extrait n'est pas cassé si Third est ajouté. Je peux ajouter un return déclaration avant when mais cela peut facilement être oublié et peut être rompu si le type de retour de l'une des clauses n'est pas Unit .

Comment puis-je m'assurer que je n'oublie pas d'ajouter une branche à mon when clauses ?

Answer 1

La manière d'imposer l'exhaustivité when est d'en faire une expression en utilisant sa valeur :

sealed class SealedClass {
    class First : SealedClass()
    class Second : SealedClass()
    class Third : SealedClass()
}

fun test(sealedClass: SealedClass) {
    val x = when (sealedClass) {
        is SealedClass.First -> doSomething()
        is SealedClass.Second -> doSomethingElse()
    }  // ERROR here

    // or

    when (sealedClass) {
        is SealedClass.First -> doSomething()
        is SealedClass.Second -> doSomethingElse()
    }.let {}  // ERROR here
}

Answer 2

En s'inspirant de la réponse de Voddan, vous pouvez construire une propriété appelée safe que vous pouvez utiliser :

val Any?.safe get() = Unit

A utiliser :

when (sealedClass) {
    is SealedClass.First -> doSomething()
    is SealedClass.Second -> doSomethingElse()
}.safe

Je pense que cela fournit un message plus clair que le simple fait d'annexer .let{} ou en assignant le résultat à une valeur.

---

Il existe un problème ouvert sur le tracker Kotlin qui envisage de supporter les "sealed whens".

Answer 3

Notre approche évite d'avoir la fonction partout lors de l'autocomplétion. Avec cette solution, vous disposez également du type de retour when au moment de la compilation, ce qui vous permet de continuer à utiliser les fonctions du type de retour when.

Do exhaustive when (sealedClass) {
  is SealedClass.First -> doSomething()
  is SealedClass.Second -> doSomethingElse()
}

Vous pouvez définir cet objet comme suit :

object Do {
    inline infix fun<reified T> exhaustive(any: T?) = any
}

Answer 4

Nous pouvons créer une propriété d'extension sur le type T avec un nom qui permet d'expliquer le but recherché

val <T> T.exhaustive: T
    get() = this

et ensuite l'utiliser n'importe où comme

when (sealedClass) {
        is SealedClass.First -> doSomething()
        is SealedClass.Second -> doSomethingElse()
    }.exhaustive

Il est lisible, montre exactement ce qu'il fait et indique une erreur si tous les cas ne sont pas couverts. Plus d'informations ici

Answer 5

A discussion m'a incité à chercher une solution plus générale et j'en ai trouvé une, pour les constructions Gradle. Il n'est pas nécessaire de modifier le code source ! L'inconvénient est que la compilation peut devenir bruyante.

build.gradle.kts

tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
    val taskOutput = StringBuilder()
    logging.level = LogLevel.INFO
    logging.addStandardOutputListener { taskOutput.append(it) }
    doLast {
        fun CharSequence.hasInfoWithError(): Boolean =
            "'when' expression on sealed classes is recommended to be exhaustive" in this
        if (taskOutput.hasInfoWithError()) {
            throw Exception("kotlinc infos considered as errors found, see compiler output for details.")
        }
    }
}

build.gradle

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
    def taskOutput = new StringBuilder()
    logging.level = LogLevel.INFO
    logging.addStandardOutputListener(new StandardOutputListener() {
        void onOutput(CharSequence text) { taskOutput.append(text) }
    })
    doLast {
        def hasInfoWithError = { CharSequence output ->
            output.contains("'when' expression on sealed classes is recommended to be exhaustive")
        }
        if (hasInfoWithError(taskOutput)) {
            throw new Exception("kotlinc infos considered as errors found, see compiler output for details.")
        }
    }
}

Notes :

• Modifier la mise en œuvre de hasInfoWithError de généraliser à d'autres i: s.
• Mettez ce code dans subprojects { } o allprojects { } à appliquer à l'ensemble du projet.

Références :

• Suivi de l'émission faisant de l'affaire scellée manquante un avertissement :
  (qui, avec kotlinOptions.allWarningsAsErrors résoudrait le problème)
  https://youtrack.jetbrains.com/issue/KT-37651
• Discussion déclenchant cette solution :
  https://youtrack.jetbrains.com/issue/KT-12380#focus=streamItem-27-4017839.0-0
• Repo avec exemple de travail :
  https://github.com/TWiStErRob/repros/tree/master/kotlin/fail-on-sealed-when-info