L’équipe Kotlin a officiellement annoncé la sortie de Kotlin 2.4.20 le 7 septembre 2026. Cette mouture stabilise la compilation via invokedynamic des expressions when sur la JVM, tout en apportant des enrichissements majeurs à la bibliothèque standard, à Kotlin/Native et à Kotlin/Wasm. Découvrons en détail les principales nouveautés de cette version.
Compilation invokedynamic pour les expressions when (Stable)
Apparue de manière expérimentale dans Kotlin 2.2.20 pour la JVM 21 et ses versions ultérieures, la compilation des expressions when reposant sur invokedynamic passe désormais au statut stable dans Kotlin 2.4.20 et se trouve activée par défaut. Cette optimisation permet de réduire significativement la taille du bytecode généré et d’accélérer l’exécution du filtrage par motif (pattern matching).
Nouvelles fonctions pour vérifier l’égalité et l’unicité des éléments de collections
Dans les versions antérieures de Kotlin, vérifier si tous les éléments d’une collection étaient strictement identiques ou tous distincts imposait d’écrire un code verbeux et sous-optimal. Pour combler ce manque, Kotlin 2.4.20 intègre quatre nouvelles fonctions expérimentales à la bibliothèque standard : allDistinct(), allDistinctBy(), allEqual() et allEqualBy().
À l’instar des autres opérations de collections, elles s’appuient sur l’égalité structurelle (equals()) et fonctionnent avec les collections, les séquences et les tableaux. S’agissant d’une fonctionnalité expérimentale, l’annotation @OptIn(ExperimentalStdlibApi::class) est requise.
Exemple officiel :
@OptIn(ExperimentalStdlibApi::class)
fun main() {
data class Response(
val participantId: String,
val answer: String,
val responseDate: String
)
val responses = listOf(
Response("P001", "Yes", "2026-07-21"),
Response("P002", "Maybe", "2026-07-21"),
Response("P003", "No", "2026-07-21")
)
// Vérifier si tous les participants ont donné la même réponse
println(responses.allEqualBy { it.answer })
// false
// Vérifier s'il y a des participants en double
println(responses.allDistinctBy { it.participantId })
// true
// Vérifier si toutes les réponses ont été soumises à la même date
println(responses.allEqualBy { it.responseDate })
// true
val answers = responses.map { it.answer }
// Vérifier si toutes les réponses sont identiques
println(answers.allEqual())
// false
// Vérifier si toutes les réponses sont distinctes
println(answers.allDistinct())
// true
}
Nouvelles surcharges pour les assertions kotlin.test
Kotlin 2.4.20 dote les assertions courantes du package kotlin.test (notamment assertTrue(), assertEquals(), assertSame() et assertContains()) de nouvelles surcharges.
Auparavant, ces assertions n’acceptaient que des messages d’erreur sous forme de chaînes préformatées, contraignant le runtime à allouer la chaîne même en cas de test réussi. Les nouvelles surcharges acceptent une lambda dont l’évaluation paresseuse (lazy evaluation) n’a lieu que si l’assertion échoue.
Cette évolution aligne l’API sur JUnit 5 et procure un gain de performances appréciable, particulièrement lors de l’utilisation de plugins de compilation comme Power-assert générant des diagnostics d’erreurs détaillés.
Exemple officiel :
import kotlin.test.ExperimentalKotlinTestApi
import kotlin.test.assertEquals
import kotlin.test.assertTrue
@OptIn(ExperimentalKotlinTestApi::class)
fun testValues(actual: Int, expected: Int, items: List<String>) {
// Le message d'erreur n'est construit que si l'assertion échoue
assertTrue(actual > 0) { "Expected a positive value but got $actual" }
// Évite le formatage inutile de la liste sauf si l'assertion échoue
assertEquals(expected, actual) { "Unexpected value for items: ${items.joinToString()}" }
}
Prise en charge de la récupération de la trace de pile des coroutines
Kotlin 2.4.20 ajoute l’interface StackTraceRecoverable à la bibliothèque standard. Cette avancée bas niveau expérimentale resserre encore l’intégration entre le langage et la bibliothèque kotlinx.coroutines.
Lors du débogage asynchrone, les exceptions relancées d’une coroutine à une autre perdent souvent leur contexte d’origine. La récupération de trace de pile permet de remonter avec précision à la source de l’exception. Si une classe d’exception personnalisée requiert des paramètres indispensables dans son constructeur (comme un numéro de ligne), il suffit d’implémenter StackTraceRecoverable et de redéfinir la méthode copyForStackTraceRecovery(). Les bibliothèques et applications peuvent ainsi définir la logique d’instanciation sans dépendre explicitement de kotlinx.coroutines.
Exemple officiel :
import kotlin.coroutines.ExperimentalStdlibCoroutineSupportApi
import kotlin.coroutines.debug.StackTraceRecoverable
@OptIn(ExperimentalStdlibCoroutineSupportApi::class)
class FileEditException
private constructor(
val line: Int,
private val detail: String,
cause: Throwable?,
) : IllegalStateException("When editing line $line: $detail", cause),
StackTraceRecoverable<FileEditException> {
constructor(line: Int, detail: String) : this(line, detail, null)
override fun copyForStackTraceRecovery(): FileEditException =
FileEditException(line, detail, this)
}
Nouvelles fonctionnalités d’export vers Swift
Kotlin/Native renforce à nouveau sa polyvalence multiplateforme en introduisant deux fonctionnalités clés dédiées à l’export vers Swift :
- Prise en charge des classes scellées (Sealed classes) : Les hiérarchies de classes scellées définies en Kotlin sont désormais associées nativement aux énumérations (
enum) Swift. Les développeurs Swift profitent ainsi dans Xcode d’une autocomplétion intégrale et d’un filtrage exhaustif viaswitch, sans devoir ajouter de clausedefaultsuperflue. - Héritage inter-langages (Cross-language inheritance) : Il est dorénavant possible de définir des interfaces et des classes de base en Kotlin, de les implémenter en Swift à l’aide de bibliothèques Swift pures, puis de retourner ces objets Swift à Kotlin. Ce modèle d’import inversé offre une liberté d’architecture précieuse pour les projets hybrides.
Exemple officiel (support des classes scellées) :
// Côté Kotlin
sealed interface Shape
class Circle : Shape { override fun toString(): String = "Circle" }
class Rectangle : Shape { override fun toString(): String = "Rectangle" }
fun createCircle(): Shape = Circle()
// Côté Swift
let shape = createCircle()
let name = switch shape.sealedType() {
case let .circle(type): "It's a \(type.value)"
case let .rectangle(type): "It's a \(type.value)"
}
// name == "It's a Circle"
Nouveaux modes de compilation pour Kotlin/Wasm
Jusqu’alors, le compilateur Kotlin/Wasm ne proposait qu’un mode monolithique (monolith), regroupant l’ensemble du projet et ses dépendances pour maximiser l’élimination du code mort et produire des binaires légers. Kotlin 2.4.20 introduit des modes de compilation multi-modules paramétrables dans gradle.properties :
monolith(par défaut) : Compilation globale de l’application avec suppression des déclarations inaccessibles et application d’optimisations globales.multimodule-open-world: Compile chaque module de façon autonome sans optimisations croisées, produisant des binaires séparés pour accélérer considérablement les compilations incrémentales pendant le développement.multimodule-closed-world: Traite tous les modules en un seul appel, supprimant le code mort et optimisant chaque binaire Wasm individuellement.
Pour le flux de développement quotidien, l’option kotlin.wasm.compilationMode=multimodule-closed-world-only-in-dev est préconisée : elle raccourcit les délais de recompilation en phase de développement tout en conservant une taille minimale de binaire pour les builds de production.
Changements cassants et dépréciations
Avant d’effectuer la mise à niveau vers Kotlin 2.4.20, prenez connaissance des dépréciations et incompatibilités suivantes :
- Dépréciation de watchOS 32 bits (Apple) : Apple ayant abandonné la prise en charge de watchOS 32 bits, la cible
watchosArm32de Kotlin/Native est formellement déclarée obsolète et sera définitivement retirée avec Kotlin 2.5.0. - Restrictions d’AtomicFU dans les fonctions inline : Le compilateur interdit désormais strictement l’usage des opérations atomiques d’AtomicFU au sein des fonctions
public inlineou des fonctionsinternal inlineappelées d’un fichier à un autre. - Évolution de Webpack sur
import.meta: Kotlin 2.4.20 intègre Webpack 5.108.1. La nouvelle mouture d’Webpack n’ignore plusimport.meta, contraignant le code compatible CommonJS renfermant cet identifiant à être analysé comme un module ES, ce qui peut engendrer des erreurs de bundling. - Dépréciation de
wasmExportsdans Kotlin/Wasm : L’API JavaScript généréewasmExportsest dorénavant dépréciée. HormiswasmExports.memorytemporairement tolérée, le compilateur bloque l’accès à toute autre déclaration exportée.
Recommandations de mise à niveau
| Dimension | Recommandations |
|---|---|
| Pour qui | Tous les développeurs Kotlin, particulièrement ceux qui s’appuient sur l’interopérabilité multiplateforme (Native, Wasm, JS) ou qui souhaitent optimiser les performances d’assertions de leurs suites de tests. |
| Quand migrer | Une mise à niveau immédiate est recommandée. Vérifiez que votre IDE (IntelliJ IDEA ou Android Studio) est à jour, puis définissez la version de Kotlin sur 2.4.20 dans vos scripts de build. |
| Points d’attention | Les projets dépendant de la cible watchosArm32 doivent migrer au plus tôt. Pour les projets JS et Wasm, vérifiez si l’adoption de Webpack 5.108.1 génère des erreurs de résolution de modules liées à import.meta et adaptez la configuration en conséquence. |