Kotlin 1.6.20 Released

Andrey Polyakov

Read this post in other languages:

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

Kotlin 1.6.20 has officially been released. It offers previews of future language features, makes the hierarchical structure the default for multiplatform projects, and brings performance improvements for the JVM, JS, and Native platforms.

In this blog post, you’ll find an overview of the following improvements, along with a complete list of the other evolutionary changes:

• New support for defining context-dependent declarations in Kotlin/JVM, resulting from the prototype of context receivers.
• Better interoperability with generic Java classes and interfaces, thanks to definitely non-nullable types.
• Faster build times resulting from the parallel compilation of a single module in the JVM IR backend.
• Streamlined development experience, facilitated by incremental compilation in Kotlin/JS IR.
• Kotlin/Native performance improvements.
• Easier code sharing thanks to the hierarchical structure of multiplatform projects.

How to update

If you use IntelliJ IDEA or Android Studio, you have the option to automatically update to the new Kotlin release as soon as it becomes available.

Update to Kotlin 1.6.20

Major updates

Prototype of context receivers for Kotlin/JVM

With Kotlin 1.6.20, you are no longer limited to having one receiver. If you need more, you can make functions, properties, and classes context-dependent (or contextual) by adding context receivers to their declaration. A contextual declaration does the following:

• It requires all declared context receivers to be present in a caller’s scope as implicit receivers.
• It brings declared context receivers into its body scope as implicit receivers.

interface LoggingContext {
    val log: Logger // This context provides a reference to a logger 
}

context(LoggingContext)
fun startBusinessOperation() {
    // You can access the log property since LoggingContext is an implicit receiver
    log.info("Operation has started")
}

fun test(loggingContext: LoggingContext) {
    with(loggingContext) {
        // You need to have LoggingContext in a scope as an implicit receiver
        // to call startBusinessOperation()
        startBusinessOperation()
    }
}

To enable context receivers in your project, use the -Xcontext-receivers compiler option. You can find a detailed description of the feature and its syntax in the KEEP.

Please note that the implementation is a prototype: 

• With -Xcontext-receivers enabled, the compiler will produce pre-release binaries that cannot be used in production code. 
• The IDE support for context receivers is minimal for now.

Definitely non-nullable types

To provide better interoperability when extending generic Java classes and interfaces, Kotlin 1.6.20 allows you to mark a generic type parameter as definitely non-nullable on the use site with the new syntax T & Any. The syntactic form comes from a notation of intersection types and is now limited to a type parameter with nullable upper bounds on the left side of & and non-nullable Any on the right side:

fun <T> elvisLike(x: T, y: T & Any): T & Any = x ?: y

fun main() {
   // OK
   elvisLike<String>("", "").length
   // Error: 'null' cannot be a value of a non-null type
   elvisLike<String>("", null).length

   // OK
   elvisLike<String?>(null, "").length
   // Error: 'null' cannot be a value of a non-null type
   elvisLike<String?>(null, null).length
}

Set the language version to 1.7 to enable the feature:

kotlin {
   sourceSets.all {
       languageSettings.apply {
           languageVersion = "1.7"
       }
   }
}

Learn more about definitely non-nullable types in the KEEP.

Please note that definitely non-nullable types are in Beta. They are almost stable, but migration steps may be required in the future. We’ll do our best to minimize any changes you have to make.

Support for parallel compilation of a single module in the JVM backend

In Kotlin 1.6.20, we added the experimental JVM IR backend mode to compile all the files in a module in parallel. Parallel compilation can reduce the total compilation time by up to 15%.

Enable the experimental parallel backend mode with the compiler option -Xbackend-threads. Use the following arguments for this option:

• N is equal to the number of threads you want to use. It should not be greater than your number of CPU cores; otherwise, parallelization stops being effective because of switching context between threads
• 0 to use one thread for each CPU core

Gradle can run tasks in parallel, but this type of parallelization doesn’t help a lot when a project (or a major part of a project) is just one big task from Gradle’s perspective. If you have a very big monolithic module, use parallel compilation to compile more quickly. If your project consists of lots of small modules and has a build parallelized by Gradle, adding another layer of parallelization may hurt performance because of context switching.

Parallel compilation has some constraints:

• It doesn’t work with kapt because kapt disables the IR backend.
• It requires more JVM heap by design. The amount of heap is proportional to the number of threads.

Incremental compilation for development binaries with Kotlin/JS IR compiler

To make Kotlin/JS development with the IR compiler more efficient, we’re introducing a new incremental compilation mode.

When building development binaries with the compileDevelopmentExecutableKotlinJs Gradle task in this mode, the compiler caches the results of previous compilations on the module level. It uses the cached compilation results for unchanged source files during subsequent compilations, making them complete more quickly, especially with small changes. Note that this improvement exclusively targets the development process (shortening the edit-build-debug cycle) and doesn’t affect the building of production artifacts.

To enable incremental compilation for development binaries, add the following line to the project’s gradle.properties:

kotlin.incremental.js.ir=true // false by default

In our test projects, the new mode made incremental compilation up to 30% faster. However, the clean build in this mode became slower because of the need to create and populate the caches.

Kotlin/Native performance improvements

Kotlin 1.6.20 brings some performance updates and bug fixes that affect the LLVM IR that Kotlin generates. According to the benchmarks on our internal projects, we achieved the following performance boosts on average:

• 15% reduction in execution time
• 20% reduction in the code size of both release and debug binaries
• 26% reduction in the compilation time of release binaries

These changes also provide a 10% reduction in compilation time for a debug binary on a large internal project.

To achieve this, we’ve implemented static initialization for some of the compiler-generated synthetic objects, improved the way we structure LLVM IR for every function, and optimized the compiler caches.

Hierarchical structure support for multiplatform projects

Kotlin 1.6.20 comes with hierarchical structure support enabled by default. Since introducing it in Kotlin 1.4.0, we’ve significantly improved the frontend and made IDE import stable.

Previously, there were two ways to add code in a multiplatform project. The first was to insert it in a platform-specific source set, which is limited to one target and can’t be reused by other platforms. The second is to use a common source set shared across all the platforms that are currently supported by Kotlin.

Now you can share source code among several similar native targets that reuse a lot of the common logic and third-party APIs. The technology will provide the correct default dependencies and find the exact API available in the shared code. This eliminates a complex build setup and having to use workarounds to get IDE support for sharing source sets among native targets. It also helps prevent unsafe API usages meant for a different target.

The technology will come in handy for library authors too, as a hierarchical project structure allows them to publish and consume libraries with common APIs for a subset of targets.
By default, libraries published with the hierarchical project structure are compatible only with hierarchical structure projects. Learn more about project-library compatibility.

Better code-sharing in your project

Without hierarchical structure support, there is no straightforward way to share code across some but not all Kotlin targets. One popular example is sharing code across all iOS targets and having access to iOS-specific dependencies, like Foundation.

Thanks to the hierarchical project structure support, you can now achieve this out of the box. In the new structure, source sets form a hierarchy. You can use platform-specific language features and dependencies available for each target that a given source set compiles to.

For example, consider a typical multiplatform project with two targets — iosArm64 and iosX64 for iOS devices and simulators. The Kotlin tooling understands that both targets have the same function and allows you to access that function from the intermediate source set, iosMain.

The Kotlin toolchain provides the correct default dependencies, like Kotlin/Native stdlib or native libraries. Moreover, Kotlin tooling will try its best to find exactly the API surface area available in the shared code. This prevents such cases as, for example, the use of a macOS-specific function in code shared for Windows.

More opportunities for library authors

When a multiplatform library is published, the API of its intermediate source sets is now properly published alongside it, making it available for consumers. Again, the Kotlin toolchain will automatically figure out the API available in the consumer source set while carefully watching out for unsafe usages, like using an API meant for the JVM in JS code. Learn more about sharing code in libraries.

Configuration and setup

Starting with Kotlin 1.6.20, all your new multiplatform projects will have a hierarchical project structure. No additional setup is required.

• If you’ve already turned it on manually, you can remove the deprecated options from gradle.properties:

kotlin.mpp.enableGranularSourceSetsMetadata=true
kotlin.native.enableDependencyPropagation=true

• For Kotlin 1.6.20, we recommend using Android Studio 2021.1.1 (Bumblebee) or later to get the best experience.
• You can also opt out. To disable hierarchical structure support, set the following options in gradle.properties:

kotlin.mpp.hierarchicalStructureSupport=false

Complete list of improvements

Language

• Prototype of context receivers for Kotlin/JVM
• Definitely non-nullable types

Kotlin/JVM

• New @JvmDefaultWithCompatibility annotation for interfaces
• Compatibility changes in the -Xjvm-default` modes
• Support for parallel compilation of a single module in the JVM backend
• Support for callable references to function interface constructors

Kotlin/Native

• An update on the new memory manager
• Concurrent implementation for the sweep phase in the new memory manager
• Instantiation of annotation classes
• Interop with Swift async/await: returning Void instead of KotlinUnit
• Better stack traces with libbacktrace
• Support for standalone Android executables
• Performance improvements
• Improved error handling during cinterop modules import
• Support for Xcode 13 libraries

Kotlin Multiplatform

• Hierarchical structure support for multiplatform projects
• Kotlin CocoaPods Gradle plugin updates

Kotlin/JS

• Incremental compilation for development binaries with IR compiler
• Lazy initialization of top-level properties by default with IR compiler
• Separate JS files for project modules by default with IR compiler
• Char class optimization
• Improvements to export and TypeScript declaration generation
• @AfterTest guarantees for asynchronous tests

Security

• Using relative paths in klibs
• Persisting yarn.lock for Kotlin/JS Gradle projects
• Installation of npm dependencies with --ignore-scripts by default

Gradle

• Properties for defining Kotlin compiler execution strategy
• Deprecation of build options for kapt and coroutines
• Removal of the kotlin.parallel.tasks.in.project build option

How to install Kotlin 1.6.20

If you already use IntelliJ IDEA or Android Studio, your IDE will suggest updating Kotlin to 1.6.20 automatically. You can also update manually by following these instructions. 

You can download the latest versions of these IDEs to get extensive support for Kotlin:

• IntelliJ IDEA – for developing Kotlin applications for various platforms.
• Android Studio –  for developing Android and cross-platform mobile applications.

Make sure that you have also updated the kotlinx libraries to compatible versions and specified version 1.6.20 of Kotlin in the build scripts of your existing projects.

If you need the command-line compiler, download it from the Github release page.

If you run into any problems

• Find help on Slack (get an invite).
• Report issues to our issue tracker, YouTrack.

What else to read and watch

• Kotlin roadmap
• What’s new in Kotlin 1.6.20 in the documentation
• Compatibility guide for Kotlin 1.6
• Kotlin 1.6.0 Is Released!

Subscribe to Kotlin Blog updates

Subscribe form

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

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!