Kotlin 2.4 im Detail: Weiterentwicklung der Multiplattform-Interoperabilität und Optimierung der Standardbibliothek

Kotlin · Release 2.4

Kotlin 2.4 im Detail: Weiterentwicklung der Multiplattform-Interoperabilität und Optimierung der Standardbibliothek

kotlinKotlinRelease2.4.20Programmiersprachen

Quellen:GitHub Releases + 官方博客 + HN

Das Kotlin-Team hat am 7. September 2026 offiziell Kotlin 2.4.20 veröffentlicht. Mit diesem Release erreicht die invokedynamic-Kompilierungsoptimierung für when-Ausdrücke auf der JVM den stabilen Zustand. Darüber hinaus bringt die neue Version wesentliche Verbesserungen für die Standardbibliothek, Kotlin/Native und Kotlin/Wasm mit sich. Im Folgenden werden die wichtigsten Neuerungen im Detail vorgestellt.

Stabile invokedynamic-Kompilierung für when-Ausdrücke

Bereits in Kotlin 2.2.20 wurde experimentelle Unterstützung eingeführt, um when-Ausdrücke auf JVM 21 und höher mittels invokedynamic zu kompilieren. Nach kontinuierlicher Weiterentwicklung und Optimierung ist diese Funktion in Kotlin 2.4.20 nun als stabil (Stable) eingestuft und standardmäßig aktiviert. Diese Optimierung reduziert die Bytecode-Größe spürbar und beschleunigt die Ausführung von Pattern-Matching-Operationen.

Neue Funktionen zur Prüfung von Elementgleichheit und Eindeutigkeit in Collections

In früheren Kotlin-Versionen erforderte die Prüfung, ob alle Elemente einer Collection identisch oder vollständig eindeutig sind, oft umständlichen und ineffizienten Boilerplate-Code. Um diese Lücke zu schließen, führt Kotlin 2.4.20 vier experimentelle Funktionen in der Standardbibliothek ein: allDistinct(), allDistinctBy(), allEqual() und allEqualBy().

Analog zu bestehenden Collection-Operationen vergleichen diese Funktionen Elemente anhand struktureller Gleichheit (equals()) und unterstützen Collections, Sequenzen sowie Arrays. Als experimentelles Feature ist die Annotation @OptIn(ExperimentalStdlibApi::class) erforderlich.

Offizielles Codebeispiel:

@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")
    )

    // Prüfen, ob alle Teilnehmer dieselbe Antwort eingereicht haben
    println(responses.allEqualBy { it.answer })
    // false

    // Prüfen, ob es doppelte Teilnehmer gibt
    println(responses.allDistinctBy { it.participantId })
    // true

    // Prüfen, ob alle Antworten am selben Tag eingereicht wurden
    println(responses.allEqualBy { it.responseDate })
    // true

    val answers = responses.map { it.answer }

    // Prüfen, ob alle Antworten identisch sind
    println(answers.allEqual())
    // false

    // Prüfen, ob alle Antworten vollständig voneinander verschieden sind
    println(answers.allDistinct())
    // true
}

Neue Überladungen für kotlin.test-Assertions

Kotlin 2.4.20 ergänzt gängige Assertions des Pakets kotlin.test (wie assertTrue(), assertEquals(), assertSame() und assertContains()) um neue Überladungen.

Bisher akzeptierten diese Assertion-Funktionen lediglich vorformatierte String-Fehlermeldungen, sodass der Fehlertext selbst bei erfolgreicher Prüfung erzeugt wurde. Die neuen Überladungen nehmen ein Lambda entgegen, das erst im Fehlerfall lazy evaluiert wird, um die Fehlermeldung zu erstellen.

Dies gleicht den API-Stil an JUnit 5 an und führt zu deutlichen Leistungsgewinnen – insbesondere in Projekten, die Compiler-Plugins wie Power-assert für detaillierte Fehlerdiagnosen einsetzen.

Offizielles Codebeispiel:

import kotlin.test.ExperimentalKotlinTestApi
import kotlin.test.assertEquals
import kotlin.test.assertTrue

@OptIn(ExperimentalKotlinTestApi::class)
fun testValues(actual: Int, expected: Int, items: List<String>) {
    // Fehlermeldung wird nur konstruiert, wenn die Assertion fehlschlägt
    assertTrue(actual > 0) { "Expected a positive value but got $actual" }

    // Unnötige Listenformatierung wird vermieden, sofern die Assertion erfolgreich ist
    assertEquals(expected, actual) { "Unexpected value for items: ${items.joinToString()}" }
}

Unterstützung für Coroutine-Stacktrace-Wiederherstellung

Mit Kotlin 2.4.20 erhält die Standardbibliothek das Interface StackTraceRecoverable. Diese praxisnahe, experimentelle Low-Level-Verbesserung vertieft das Zusammenspiel zwischen der Kernsprache und der Bibliothek kotlinx.coroutines.

Beim Debuggen asynchronen Codes gehen oft entscheidende Kontextinformationen verloren, wenn Exceptions über Coroutine-Grenzen hinweg erneut geworfen werden. Die Stacktrace-Wiederherstellung hilft dabei, den ursprünglichen Entstehungsort des Fehlers zu rekonstruieren. Falls eine benutzerdefinierte Exception-Klasse zusätzliche Pflichtparameter im Konstruktor verlangt (z. B. eine Zeilennummer), genügt es, StackTraceRecoverable zu implementieren und copyForStackTraceRecovery() zu überschreiben. Auf diese Weise können Regeln zur Instanziierung neuer Exceptions definiert werden, ohne eine explizite Abhängigkeit von kotlinx.coroutines einführen zu müssen.

Offizielles Codebeispiel:

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)
}

Neue Swift-Export-Funktionen

Kotlin/Native baut die Plattform-Interoperabilität in dieser Version weiter aus und liefert zwei zentrale Verbesserungen für den Swift-Export:

  1. Unterstützung für versiegelte Klassen (Sealed Classes): In Kotlin definierte Sealed-Class-Hierarchien werden nun nativ auf Swift-Enums abgebildet. Swift-Entwickler können dadurch in Xcode vollständige, erschöpfende switch-Anweisungen mit Autovervollständigung nutzen, ohne künstliche default-Zweige einfügen zu müssen.
  2. Sprachübergreifende Vererbung (Cross-Language Inheritance): Entwickler können Interfaces und Basisklassen in Kotlin definieren und diese auf Swift-Seite mit reinen Swift-Bibliotheken implementieren, um die resultierenden Swift-Objekte anschließend an Kotlin zurückzugeben. Dieses Reverse-Import-Muster verleiht hybriden Architekturen ein hohes Maß an Flexibilität.

Offizielles Codebeispiel (Unterstützung für Sealed Classes):

// Kotlin-Seite
sealed interface Shape
class Circle : Shape { override fun toString(): String = "Circle" }
class Rectangle : Shape { override fun toString(): String = "Rectangle" }
fun createCircle(): Shape = Circle()
// Swift-Seite
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"

Neue Kompilierungsmodi für Kotlin/Wasm

Bislang unterstützte der Kotlin/Wasm-Compiler lediglich eine monolithische Kompilierung (monolith), bei der das gesamte Projekt samt Abhängigkeiten zusammengefasst wurde, um maximale Dead-Code-Elimination und minimale Binärgrößen zu erzielen. Kotlin 2.4.20 führt Multi-Modul-Kompilierungsmodi für Kotlin/Wasm ein, die über gradle.properties konfiguriert werden können:

  • monolith (Standard): Kompiliert das Gesamtprogramm, entfernt unerreichbare Deklarationen und wendet globale Optimierungen an.
  • multimodule-open-world: Kompiliert Module separat ohne modulübergreifende Optimierungen und erzeugt separate Binärdateien, was die Kompilierungsgeschwindigkeit während der Entwicklung deutlich steigert.
  • multimodule-closed-world: Verarbeitet alle Module in einem Aufruf, entfernt unerreichbare Deklarationen und optimiert jede Wasm-Binärdatei einzeln.

Für die tägliche Entwicklung empfiehlt sich die Einstellung kotlin.wasm.compilationMode=multimodule-closed-world-only-in-dev, um Rebuild-Zeiten im Entwicklungsalltag zu minimieren, während im Release-Build eine minimale Ausgabegröße gewahrt bleibt.

Breaking Changes und Deprecations

Vor dem Wechsel auf Kotlin 2.4.20 sollten folgende Änderungen und Abkündigungen beachtet werden:

  • Abkündigung von Apple watchOS 32-Bit: Da Apple die Unterstützung für 32-Bit-watchOS eingestellt hat, wird das Kotlin/Native-Target watchosArm32 nun offiziell als veraltet eingestuft und soll in Kotlin 2.5.0 vollständig entfernt werden.
  • Einschränkung von AtomicFU in Inline-Funktionen: In public inline-Funktionen sowie dateiübergreifend aufgerufenen internal inline-Funktionen untersagt der Compiler nun atomare Operationen via AtomicFU vollständig.
  • Geändertes Verhalten von Webpack bei import.meta: Kotlin 2.4.20 aktualisiert Webpack auf Version 5.108.1. Die neuere Webpack-Version ignoriert import.meta nicht mehr, wodurch CommonJS-kompatibler Code mit diesem Token zwingend als ES-Modul geparst wird, was zu Build-Fehlern führen kann.
  • Abkündigung von wasmExports in Kotlin/Wasm: Die generierte JavaScript-API wasmExports wurde als veraltet markiert. Abgesehen von wasmExports.memory, das vorübergehend weiterhin zulässig bleibt, blockiert der Compiler den Zugriff auf andere exportierte Deklarationen.

Upgrade-Empfehlungen

DimensionEmpfehlung
ZielgruppeAlle Kotlin-Entwickler, insbesondere Teams mit starkem Fokus auf Multiplattform-Interoperabilität (Native, Wasm, JS) oder dem Wunsch nach höherer Assertion-Performance in Test-Suites.
ZeitpunktEin sofortiges Upgrade wird empfohlen. Stellen Sie sicher, dass Ihre IDE (IntelliJ IDEA oder Android Studio) auf dem aktuellen Stand ist, und aktualisieren Sie die Kotlin-Version in Ihren Build-Skripten auf 2.4.20.
Zu beachtenMigrieren Sie frühzeitig weg vom veralteten Target watchosArm32. Prüfen Sie bei JS- und Wasm-Projekten, ob das Webpack-Upgrade Probleme bei der Modulauflösung im Zusammenhang mit import.meta verursacht, und passen Sie Ihre Konfiguration bei Bedarf an.

Referenzen