Kotlin 1.6.20 veröffentlicht

Elizaveta Semakova

Read this post in other languages:

• English
,
• Français
,
• 日本語
,
• 한국어
,
• 简体中文

Kotlin 1.6.20 wurde offiziell veröffentlicht. Die neue Version zeigt eine Vorschau auf zukünftige Sprachmerkmale, verwendet die hierarchische Struktur als Standard für Multiplattform-Projekte und bietet Performance-Verbesserungen für die Plattformen JVM, JS und Native.

In diesem Blogeintrag finden Sie einen Überblick über die folgenden Verbesserungen sowie eine komplette Liste der weiteren evolutionären Änderungen:

• Neu eingeführte Unterstützung für die Definition kontextabhängiger Deklarationen in Kotlin/JVM, abgeleitet aus dem Prototyp für Kontext-Receiver.
• Verbesserte Interoperabilität mit generischen Java-Klassen und -Schnittstellen dank definitiv nicht-nullbarer Typen.
• Kürzere Build-Zeiten durch die parallele Kompilierung von Einzelmodulen im JVM-IR-Backend.
• Optimierte Entwicklungserfahrung durch inkrementelle Kompilierung in Kotlin/JS IR.
• Performance-Verbesserungen für Kotlin/Native.
• Einfachere plattformübergreifende Codeverwendung durch hierarchische Strukturierung von Multiplattform-Projekten.

So führen Sie das Update durch

Wenn Sie IntelliJ IDEA oder Android Studio verwenden, haben Sie die Möglichkeit, automatisch auf die neue Kotlin-Version zu aktualisieren.

Auf Kotlin 1.6.20 aktualisieren

Wichtige Updates

Kontext-Receiver für Kotlin/JVM als Prototyp

Mit Kotlin 1.6.20 sind Sie nicht mehr auf einen einzigen Receiver beschränkt. Wenn Sie mehrere benötigen, können Sie Funktionen, Eigenschaften und Klassen kontextabhängig (oder kontextuell) machen, indem Sie der Deklaration Kontext-Receiver hinzufügen. Eine kontextuelle Deklaration hat folgende Auswirkungen:

• Sie erfordert, dass alle deklarierten Kontext-Receiver im Geltungsbereich eines Aufrufers als implizite Receiver vorhanden sind.
• Sie nimmt deklarierte Kontext-Receiver als implizite Receiver in ihren Geltungsbereich auf.

<br />
interface LoggingContext {<br />
    val log: Logger // This context provides a reference to a logger<br />
}</p>
<p>context(LoggingContext)<br />
fun startBusinessOperation() {<br />
    // You can access the log property since LoggingContext is an implicit receiver<br />
    log.info("Operation has started")<br />
}</p>
<p>fun test(loggingContext: LoggingContext) {<br />
    with(loggingContext) {<br />
        // You need to have LoggingContext in a scope as an implicit receiver<br />
        // to call startBusinessOperation()<br />
        startBusinessOperation()<br />
    }<br />
}<br />

Um Kontext-Receiver in Ihrem Projekt zu aktivieren, verwenden Sie die Compileroption -Xcontext-receivers. Eine ausführliche Beschreibung der Funktionalität und ihrer Syntax finden Sie im entsprechenden KEEP.

Bitte beachten Sie, dass die Implementierung ein Prototyp ist: 

• Wenn -Xcontext-receivers aktiviert wird, erzeugt der Compiler Pre-Release-Binärdateien, die nicht in Produktionscode verwendet werden können. 
• Die IDE-Unterstützung für Kontext-Receiver ist im Moment minimal.

Definitiv nicht-nullbare Typen

Um die Interoperabilität bei der Erweiterung von generischen Java-Klassen und -Schnittstellen zu verbessern, können Sie in Kotlin 1.6.20 einen generischen Typparameter am Verwendungsort mit der neuen Syntax T & Any als definitiv nicht-nullbar markieren. Die syntaktische Form entstammt der Intersection-Typnotation und ist hier auf einen Typparameter mit nullfähigen oberen Grenzen links vom & und einem nicht nullfähigen Any auf der rechten Seite beschränkt:

<br />
fun <T> elvisLike(x: T, y: T & Any): T & Any = x ?: y</p>
<p>fun main() {<br />
   // OK<br />
   elvisLike<String>("", "").length<br />
   // Error: 'null' cannot be a value of a non-null type<br />
   elvisLike<String>("", null).length</p>
<p>   // OK<br />
   elvisLike<String?>(null, "").length<br />
   // Error: 'null' cannot be a value of a non-null type<br />
   elvisLike<String?>(null, null).length<br />
}<br />

Setzen Sie die Sprachversion auf 1.7, um die Funktionalität zu aktivieren:

<br />
kotlin {<br />
   sourceSets.all {<br />
       languageSettings.apply {<br />
           languageVersion = "1.7"<br />
       }<br />
   }<br />
}<br />

Weitere Informationen zu definitiv nicht-nullbaren Typen finden Sie im KEEP.

Bitte beachten Sie, dass definitiv nicht-nullbare Typen Beta-Status haben. Sie sind nahezu stabil, aber in Zukunft könnten Migrationsschritte erforderlich werden. Wir werden uns bemühen, Änderungen, die Sie später durchführen müssen, zu minimieren.

Unterstützung für paralleles Kompilieren eines Einzelmoduls im JVM-Backend

In Kotlin 1.6.20 haben wir den experimentellen JVM-IR-Backend-Modus hinzugefügt, um alle Dateien eines Moduls parallel zu kompilieren. Durch paralleles Kompilieren kann die gesamte Kompilierungszeit um bis zu 15% reduziert werden.

Sie können den experimentellen parallelen Backend-Modus mit der Compileroption -Xbackend-threads aktivieren. Verwenden Sie die folgenden Argumente für diese Option:

• N gibt die Anzahl der Threads an, die Sie verwenden möchten. Der Wert sollte nicht größer sein als die Anzahl Ihrer CPU-Kerne, da sonst die Parallelisierung aufgrund von Kontextwechseln zwischen den Threads nicht mehr effektiv ist.
• 0 bedeutet, dass ein Thread pro CPU-Kern verwendet wird.

Gradle kann Tasks zwar parallel ausführen, aber diese Art der Parallelisierung ist nicht sehr hilfreich, wenn ein Projekt (oder ein großer Teil davon) aus der Perspektive von Gradle ein einziger großer Task ist. Wenn Sie ein sehr großes monolithisches Modul haben, verwenden Sie die parallele Kompilierung, um den Vorgang zu beschleunigen. Wenn Ihr Projekt aus zahlreichen kleinen Modulen besteht und der Build-Prozess von Gradle parallelisiert wird, kann das Hinzufügen einer weiteren Parallelisierungsebene aufgrund von Kontextwechseln die Leistung mindern.

Die parallele Kompilierung unterliegt einigen Beschränkungen:

• Sie funktioniert nicht mit kapt, da kapt das IR-Backend deaktiviert.
• Sie benötigt bauartbedingt mehr JVM-Heap. Die Heap-Größe ist proportional zur Anzahl der Threads.

Inkrementelle Kompilierung für Entwicklungs-Binaries mit dem Kotlin/JS-IR-Compiler

Um die Kotlin/JS-Entwicklung mit dem IR-Compiler effizienter zu gestalten, haben wir einen neuen inkrementellen Kompiliermodus eingeführt.

Beim Kompilieren von Entwicklungs-Binärdateien mit dem Gradle-Task compileDevelopmentExecutableKotlinJs speichert der Compiler in diesem Modus die Ergebnisse früherer Kompilierungen auf der Modulebene in einem Cache. Bei nachfolgenden Kompilierungen werden bei unveränderten Quellcode-Dateien die im Cache gespeicherten Kompilierungsergebnisse verwendet. Dadurch wird der Vorgang insbesondere bei kleinen Änderungen beschleunigt. Zu beachten ist, dass diese Verbesserung ausschließlich auf den Entwicklungsprozess abzielt (Verkürzung des Edit-Build-Debug-Zyklus) und keinen Einfluss auf die Kompilierung von Produktionsartefakten hat.

Um die inkrementelle Kompilierung für Entwicklungs-Binärdateien zu aktivieren, fügen Sie der gradle.properties-Datei im Projekt die folgende Zeile hinzu:

<br />
kotlin.incremental.js.ir=true // false by default<br />

Bei unseren Testprojekten hat der neue Modus das inkrementelle Kompilieren um bis zu 30% beschleunigt. Der erste Build wird in diesem Modus jedoch verlangsamt, da die Caches angelegt und gefüllt werden müssen.

Performance-Verbesserungen für Kotlin/Native

Kotlin 1.6.20 enthält einige Leistungsupdates und Bugfixes, die den von Kotlin generierten LLVM-Zwischencode betreffen. In den Benchmarks mit unseren internen Projekten haben wir im Durchschnitt folgende Leistungssteigerungen erzielt:

• Um 15% kürzere Ausführungszeit
• Um 20% reduzierte Codegröße von Release- und Debug-Binärdateien
• Um 26% kürzere Kompilierungszeit von Release-Binärdateien

Außerdem ermöglichten diese Änderungen in einem großen internen Projekt eine um 10% kürzere Kompilierungszeit von Debug-Binärdateien.

Um dies zu erreichen, haben wir eine statische Initialisierung für einige der vom Compiler erzeugten synthetischen Objekte implementiert, die Strukturierung des LLVM-Zwischencodes für jede Funktion verbessert und die Compiler-Caches optimiert.

Hierarchische Strukturen für Multiplattform-Projekte

In Kotlin 1.6.20 ist die Unterstützung für hierarchische Strukturen standardmäßig aktiviert. Seit der Einführung in Kotlin 1.4.0 haben wir das Frontend erheblich verbessert und den IDE-Import stabilisiert.

Früher gab es zwei Möglichkeiten, Code zu einem Multiplattform-Projekt hinzuzufügen. Die erste Möglichkeit besteht darin, den Code in ein plattformspezifisches Quellcode-Set aufzunehmen, das auf eine einzige Zielplattform beschränkt ist und nicht für andere Plattformen verwendet werden kann. Die zweite Möglichkeit ist die Verwendung eines gemeinsamen Quellcode-Sets für alle Plattformen, die derzeit von Kotlin unterstützt werden.

Jetzt haben Sie auch die Möglichkeit, gemeinsamen Quellcode für mehrere ähnliche native Zielplattformen zu nutzen und dadurch einen Großteil der gemeinsamen Logik und der Drittanbieter-APIs gemeinsam zu verwenden. Die Technologie stellt die korrekten Standardabhängigkeiten bereit und findet die genaue API, die im gemeinsamen Code verfügbar ist. Dadurch entfällt die Notwendigkeit komplexer Build-Setups und Workarounds, um IDE-Unterstützung für gemeinsame Quellcode-Sets für native Kompilierungsziele zu erhalten. Außerdem wird dadurch die unsichere Nutzung von APIs verhindert, die für eine andere Zielplattform bestimmt sind.

Diese Technologie ist auch bei der Entwicklung von Bibliotheken sehr nützlich, da eine hierarchische Projektstruktur die Möglichkeit bietet, Bibliotheken mit gemeinsamen APIs für eine Untermenge von Zielplattformen zu veröffentlichen und zu konsumieren.
Standardmäßig sind Bibliotheken, die mit einer hierarchischen Projektstruktur veröffentlicht werden, nur mit Projekten kompatibel, die ebenfalls eine hierarchische Struktur verwenden. Erfahren Sie mehr über die Kompatibilität zwischen Projekten und Bibliotheken.

Verbesserte gemeinsame Codeverwendung in Ihrem Projekt

Ohne hierarchische Struktur gibt es keine einfache Möglichkeit, gemeinsamen Code für einige, aber nicht alle Kotlin-Zielplattformen zu verwenden. Ein häufiges Beispiel ist die gemeinsame Codeverwendung für alle iOS-Plattformen einschließlich Zugriff auf iOS-spezifische Abhängigkeiten wie Foundation.

Durch die hierarchische Projektstruktur ist dies jetzt standardmäßig möglich. In der neuen Struktur bilden die Quellcode-Sets eine Hierarchie. Sie können plattformspezifische Sprachmerkmale und Abhängigkeiten verwenden, die für alle Zielplattformen verfügbar sind, für die ein bestimmtes Quellcode-Set kompiliert wird.

Betrachten wir als Beispiel ein typisches Multiplattform-Projekt mit zwei Zielplattformen: iosArm64 und iosX64 für iOS-Geräte und -Simulatoren. Die Kotlin-Tools erkennen, dass beide Ziele über die gleiche Funktion verfügen und ermöglichen Ihnen den Zugriff auf diese Funktion aus dem intermediären Quellcode-Set iosMain.

Die Kotlin-Toolchain stellt die korrekten Standardabhängigkeiten bereit, z. B. die Kotlin/Native-Standardbibliothek oder native Bibliotheken. Außerdem versucht das Kotlin-Tool, den genauen API-Umfang zu ermitteln, der für den gemeinsamen Code verfügbar ist. Dadurch wird zum Beispiel verhindert, dass eine macOS-spezifische Funktion in gemeinsamem Code verwendet wird, der auch auf Windows abzielt.

Mehr Möglichkeiten für die Bibliotheksentwicklung

Wenn eine Multiplattform-Bibliothek veröffentlicht wird, wird die API der intermediären Quellcode-Sets jetzt ordnungsgemäß mitveröffentlicht, sodass sie verwendet werden kann. Auch hier ermittelt die Kotlin-Toolchain automatisch, welche API im Quellcode-Set des Konsumenten verfügbar ist. Dabei wird sorgfältig auf unsichere Verwendungen geachtet, zum Beispiel die Verwendung einer für die JVM bestimmten API in JS-Code. Erfahren Sie mehr über die gemeinsame Codeverwendung in Bibliotheken.

Konfiguration und Einrichtung

Ab Kotlin 1.6.20 werden alle Ihre neuen Multiplattform-Projekte eine hierarchische Projektstruktur haben. Eine weitere Einrichtung ist nicht erforderlich.

• Wenn Sie diese Funktion bereits manuell aktiviert haben, können Sie die nunmehr veralteten Optionen aus gradle.properties entfernen:

<br />
kotlin.mpp.enableGranularSourceSetsMetadata=true<br />
kotlin.native.enableDependencyPropagation=true<br />

• Für eine optimale Erfahrung empfehlen wir, Kotlin 1.6.20 mit Android Studio 2021.1.1 (Bumblebee) oder höher zu verwenden.
• Sie können die Funktion auch deaktivieren. Um hierarchische Strukturen zu deaktivieren, speichern Sie die folgenden Optionen in gradle.properties:

<br />
kotlin.mpp.hierarchicalStructureSupport=false<br />

Komplette Liste der Verbesserungen

Sprache

• Kontext-Receiver für Kotlin/JVM als Prototyp
• Definitiv nicht-nullbare Typen

Kotlin/JVM

• Neue @JvmDefaultWithCompatibility-Annotation für Schnittstellen
• Kompatibilitätsänderungen in den -Xjvm-default-Modi
• Unterstützung für paralleles Kompilieren eines Einzelmoduls im JVM-Backend
• Unterstützung für aufrufbare Referenzen auf Funktionsschnittstellen-Konstruktoren

Kotlin/Native

• Update zum neuen Speichermanager
• Nebenläufige Implementierung der Sweep-Phase im neuen Speichermanager
• Instanziierung von Annotation-Klassen
• Interoperabilität mit async/await in Swift: Rückgabe von Void statt KotlinUnit
• Bessere Stack-Traces mit libbacktrace
• Unterstützung für eigenständige Android-Programmdateien
• Leistungsverbesserungen
• Verbesserte Fehlerbehandlung beim Importieren von Cinterop-Modulen
• Unterstützung für Xcode-13-Bibliotheken

Kotlin Multiplatform

• Hierarchische Strukturen für Multiplattform-Projekte
• Updates für das Kotlin-CocoaPods-Plugin für Gradle

Kotlin/JS

• Inkrementelle Kompilierung von Entwicklungs-Binaries mit dem IR-Compiler
• Lazy-Initialisierung von Top-Level-Eigenschaften bei IR-Compiler standardmäßig
• Separate JS-Dateien für Projektmodule bei IR-Compiler standardmäßig
• Optimierte Char-Klasse
• Verbesserungen beim Export und bei der Generierung von TypeScript-Deklarationen
• @AfterTest-Garantien für asynchrone Tests

Sicherheit

• Verwendung relativer Pfade in klibs
• Persistenz von yarn.lock in Kotlin/JS-Gradle-Projekten
• Installation von npm-Abhängigkeiten mit --ignore-scripts standardmäßig

Gradle

• Eigenschaften zur Festlegung der Ausführungsstrategie des Kotlin-Compilers
• Deprecation der Build-Optionen für kapt und Coroutinen
• Entfernung der Build-Option kotlin.parallel.tasks.in.project

Installation von Kotlin 1.6.20

Wenn Sie IntelliJ IDEA oder Android Studio bereits verwenden, schlägt Ihnen die IDE automatisch die Aktualisierung auf Kotlin 1.6.20 vor. Eine manuelle Aktualisierung ist ebenfalls möglich. Folgen Sie dazu diesen Anweisungen. 

Sie können die neuesten Versionen dieser IDEs herunterladen, um eine umfassende Kotlin-Unterstützung zu erhalten:

• IntelliJ IDEA – zur Entwicklung von Kotlin-Anwendungen für verschiedene Plattformen.
• Android Studio – zur Entwicklung von Android-Apps und plattformübergreifenden Mobilanwendungen.

Achten Sie darauf, auch die kotlinx-Bibliotheken auf die kompatiblen Versionen zu aktualisieren und die Kotlin-Version 1.6.20 in den Build-Skripten Ihrer bestehenden Projekte anzugeben.

Den Befehlszeilen-Compiler können Sie bei Bedarf von der GitHub-Release-Seite herunterladen.

Hilfe bei Problemen

• Holen Sie sich Unterstützung auf Slack (eine Einladung erhalten Sie hier).
• Melden Sie Probleme in unserem Issue-Tracker, YouTrack.

Weitere Informationen zum Lesen und Ansehen

• Kotlin-Roadmap
• Das ist neu in Kotlin 1.6.20 (Dokumentation)
• Kompatibilitätsleitfaden für Kotlin 1.6
• Kotlin 1.6.0 ist veröffentlicht!

Autor des Original-Blogposts:

Subscribe to Kotlin Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

Mit dem Absenden dieses Formulars erkläre ich mich damit einverstanden, dass mein Name, meine E-Mail-Adresse und meine Ortsdaten von JetBrains s.r.o. ("JetBrains") verwendet werden, um mir Newsletter, einschließlich kommerzieller Mitteilungen, zuzusenden und meine persönlichen Daten für diesen Zweck zu verarbeiten. Ich bin damit einverstanden, dass JetBrains diese Daten zu diesem Zweck unter Verwendung von Drittanbieterdiensten gemäß den JetBrains-Datenschutzrichtlinien verarbeitet. Mir ist bekannt, dass ich diese Einwilligung jederzeit in meinem Profil widerrufen kann. Außerdem ist in jeder E-Mail ein Link zum Abbestellen enthalten.

Submit

Danke! Wir haben Ihre Daten erhalten.