What's new in Kotlin 2.2.21 (and 2.2.20!)

Summary

Kotlin 2220 introduces exciting new features for developers, including enhanced compiler checks with data flow analysis, powerful Kotlin contracts, and improved language flexibility. Key updates include experimental data flow-based exhaustiveness checks, streamlined expression bodies for nullable types, and advanced contract capabilities like `returnsNotNull`. Kotlin 2220 also enhances Kotlin for WebAssembly with built-in browser debugging and introduces experimental support for Kotlin-to-Swift export. Additionally, mobile developers benefit from optimizations for smaller binary sizes. With numerous other improvements, Kotlin continues to evolve and offer better tools for cross-platform and mobile development.

Takeaways

• 😀 Kotlin 2220 introduces data flow-based exhaustiveness checks, allowing the compiler to infer more context and accept logically correct code that was previously rejected.
• 😀 Kotlin now allows expression bodies in functions with return statements, making small functions like `getDisplayNameOrDefault` more expressive and concise.
• 😀 Kotlin contracts are enhanced with generics in contract type assertions and the new `returnsNotNull` function, improving non-null return inference under specific conditions.
• 😀 New Kotlin atomic operations for multiplatform support, such as `updateOrFetch` and `fetchAndUpdate`, simplify working with atomic variables in concurrent scenarios.
• 😀 Kotlin for WebAssembly is now in beta, bringing improvements in NPM dependency handling, JavaScript exception handling, and built-in browser debugging support.
• 😀 Kotlin 2220 adds experimental support for Kotlin-to-Swift export, allowing direct Kotlin code usage in Swift without needing Objective-C headers.
• 😀 Kotlin introduces a flag for smaller binary sizes in Kotlin Native (especially for iOS), reducing the size of release builds by up to 20%.
• 😀 Reified types can now be used in `catch` clauses, allowing inline functions to work with reified generics in exception handling.
• 😀 Kotlin improves JVM bytecode generation by using `invokeDynamic`, resulting in more compact and efficient bytecode for `when` expressions.
• 😀 Kotlin 2220 introduces a more intuitive overload resolution for suspending and non-suspending lambdas, enabling easier specification with the `suspend` modifier.

Q & A

What are the key highlights introduced in Kotlin 2220?

Kotlin 2220 introduces several new features, including data flow-based exhaustiveness checks, experimental Swift export support for mobile, improvements to Kotlin contracts, and new functionality in Kotlin for web assembly and multiplatform support. Additionally, it brings enhancements in the standard library like atomic operations and array manipulations.

What is the purpose of the new data flow-based exhaustiveness check in Kotlin 2220?

The data flow-based exhaustiveness check helps the Kotlin compiler understand context around conditional statements like 'when'. This ensures that branches, even those with early returns, are properly validated for exhaustiveness, allowing developers more flexibility in writing concise code.

How does Kotlin 2220 improve the use of expression bodies in functions?

Kotlin 2220 allows the use of expression bodies in functions that return a default value, such as returning 'unknown' for a nullable string. This was previously restricted, but now developers can use expression bodies for simple functions with default return values, making the language more expressive.

What is the significance of the 'returns not null' function in Kotlin contracts?

The 'returns not null' function in Kotlin contracts helps ensure that nullable return values are correctly inferred when certain conditions are met. This allows for better type inference and avoids unnecessary null safety checks, improving the developer experience when working with nullable types.

How does Kotlin 2220 handle atomic operations in multiplatform code?

Kotlin 2220 introduces experimental support for atomic operations in multiplatform code, allowing developers to use atomic abstractions like atomic integers across different platforms. New methods such as 'update' and 'fetchAndUpdate' help handle atomic operations more efficiently in a cross-platform environment.

What changes have been made to Kotlin's array handling in Kotlin 2220?

Kotlin 2220 introduces a new overload for array resizing, where developers can specify an initializer function to avoid creating nullable arrays. This change simplifies the code and ensures that arrays can be resized without introducing nullability where it is not required.

What improvements have been made to Kotlin for WebAssembly in Kotlin 2220?

Kotlin for WebAssembly in Kotlin 2220 moves to beta and introduces built-in browser debugging support, allowing developers to debug Kotlin code directly in the browser's dev tools. It also improves npm dependencies and exception handling in JavaScript interop.

How does Kotlin 2220 enable direct Kotlin-to-Swift export for mobile development?

Kotlin 2220 introduces experimental support for direct Kotlin-to-Swift export, eliminating the need for Objective-C headers. This feature allows developers to write Kotlin code that can be directly called from Swift, simplifying the integration process for mobile applications.

What is the 'small binary' optimization flag in Kotlin 2220, and how does it benefit mobile developers?

The 'small binary' optimization flag in Kotlin 2220 reduces the size of release binaries for Kotlin Native code by modifying the LLVM compiler's default optimization arguments. This can result in up to a 20% reduction in binary size, but developers should test for potential performance trade-offs.

What other minor improvements have been introduced in Kotlin 2220?

Kotlin 2220 introduces several smaller changes, such as reified types in catch clauses, new overload resolution rules for suspending and regular lambdas, and improvements in the bytecode generation for 'when' expressions on the JVM. These changes aim to optimize language features and improve performance.