Kotlin 2.4 : L'essor de l'interopérabilité multiplateforme et l'optimisation de la bibliothèque standard

Kotlin · Release 2.4

Kotlin 2.4 : L'essor de l'interopérabilité multiplateforme et l'optimisation de la bibliothèque standard

kotlinKotlinVersion2.4.20Langages de programmation

Sources:GitHub Releases + 官方博客 + HN

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 :

  1. 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 via switch, sans devoir ajouter de clause default superflue.
  2. 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 watchosArm32 de 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 inline ou des fonctions internal inline appelé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 plus import.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 wasmExports dans Kotlin/Wasm : L’API JavaScript générée wasmExports est dorénavant dépréciée. Hormis wasmExports.memory temporairement tolérée, le compilateur bloque l’accès à toute autre déclaration exportée.

Recommandations de mise à niveau

DimensionRecommandations
Pour quiTous 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 migrerUne 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’attentionLes 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.

Ressources documentaires