Kotlin 2.1: K2 Compiler + Context Parameters Yenilikler

Kotlin 2.1 (2024 Q4 release) K2 compiler'ı default yaptı — %2 daha hızlı compilation, daha iyi IDE experience. Context parameters experimental olarak geldi — dependency injection'ı simplify ediyor. Guard conditions, non-local break/continue, multi-dollar string interpolation gibi syntax iyileştirmeleri. Bu yazı Kotlin 2.1'in önemli yeniliklerini ve migration stratejisini anlatır.

💡 Pro Tip: Kotlin 2.0 → 2.1 major change K2 compiler default. Mevcut projelerde %95 sorunsuz geçer ama annotation processor'lar (KAPT → KSP2 migration) edge case'leri var.

İçindekiler

• K2 Compiler: Default Değişiklik
• Context Parameters (Experimental)
• Guard Conditions in when
• Non-local break/continue
• Multi-dollar String Interpolation
• KMP İyileştirmeleri
• Gradle + Maven Compatibility
• Deprecations
• Migration Guide
• Sonuç

K2 Compiler: Default Değişiklik

K2 Kotlin compiler rewrite'ı 4 yıl sürdü, 2.0'da stable, 2.1'de default.

Performance

• %2x daha hızlı compilation (büyük projeler)
• %40 daha az memory (IDE'de)
• %60 daha az recompilation (incremental)
• Better type inference (generics, inline class)

Yeni Özellikler

• Smart cast improvements (nullable types)
• Sealed class exhaustiveness (better)
• Data class @JvmRecord support
• Inline class compile time %40 hızlı

Migration Issues

1// K1'de sessizce çalışan ama K2'de hata
2class Foo {
3    val bar: String
4        get() = bar  // K1: runtime StackOverflow, K2: compile error
5}

K2 daha strict — bu gibi edge case'leri compile time'da yakalıyor.

Context Parameters (Experimental)

Dependency injection'ı simplify eden yeni syntax:

1// Old way — her fonksiyonda parametre passing
2fun Logger.processOrder(order: Order) {
3    this.log("Processing ${order.id}")
4    // ...
5}
6 
7// New context parameters (2.1 experimental)
8context(logger: Logger)
9fun processOrder(order: Order) {
10    logger.log("Processing ${order.id}")
11    // ...
12}
13 
14// Call side
15with(logger) {
16    processOrder(myOrder)
17}

Multiple Context

1context(logger: Logger, transaction: Transaction)
2suspend fun chargeCustomer(amount: Money) {
3    logger.log("Charging ${amount.display}")
4    transaction.withCustomer { customer ->
5        customer.charge(amount)
6    }
7}

DI framework'lere (Koin, Hilt) alternative.

Guard Conditions in when

Pattern matching improvement:

1when (x) {
2    is Int -> println("int")
3    is String if x.length > 0 -> println("non-empty string")
4    is String -> println("empty string")
5    is List<*> if x.all { it is Number } -> println("number list")
6    else -> println("other")
7}

Swift'in guard clauses'ına benzer — sealed class handling'de çok güçlü.

Non-local break/continue

Inline function içinde outer loop kontrolü:

1inline fun processItems(items: List<Item>, action: (Item) -> Unit) {
2    items.forEach { action(it) }
3}
4 
5fun main() {
6    processItems(items) { item ->
7        if (item.invalid) break  // 2.1: outer loop'u break eder
8        if (item.skip) continue  // 2.1: supported
9        println(item)
10    }
11}

Önceden çalışmıyordu, şimdi idiomatic.

Multi-dollar String Interpolation

1val dollar = "$100"
2val message = $$"Price: $dollar, tax: $tax"$$
3// String içinde $ escape gereksiz

Regex ve JSON template'leri için çok daha temiz.

KMP İyileştirmeleri

Kotlin Multiplatform 2.1'de major improvements:

Swift Export (Preview)

Kotlin kod'u Swift için native binding üretiyor — iOS team için daha iyi DX:

1// Kotlin
2class UserRepository {
3    suspend fun fetchUser(id: String): User { ... }
4}

1// Otomatik üretilen Swift wrapper
2class UserRepository {
3    func fetchUser(id: String) async throws -> User { ... }
4    // async/await natively, not callback-based
5}

Compose Multiplatform 1.7

iOS support stable. Tek codebase → Android + iOS + Desktop + Web.

Native Shared State

kotlinx.atomicfu ile thread-safe shared state KMP'de.

Gradle + Maven Compatibility

• Gradle 8.10+: Kotlin 2.1 uyumlu
• JVM target: 8, 11, 17, 21 (21 default recommendation)
• Android AGP: 8.6+
• KAPT: Deprecated (KSP2 migrate)

build.gradle.kts

1plugins {
2    kotlin("jvm") version "2.1.0"
3    kotlin("plugin.serialization") version "2.1.0"
4    id("com.google.devtools.ksp") version "2.1.0-1.0.28"
5}
6 
7kotlin {
8    jvmToolchain(21)
9    compilerOptions {
10        freeCompilerArgs.add("-Xcontext-parameters")  // Experimental
11    }
12}

Deprecations

• KAPT: Deprecated, KSP2 migrate et
• Old K1 compiler: Deprecated, removed in 2.2
• Native memory manager legacy: Yeni memory manager zorunlu

Migration Guide

1. ✅ Kotlin version: 2.0.x → 2.1.0
2. ✅ Gradle: 8.8+ gerekir
3. ✅ AGP: 8.6+
4. ✅ KAPT → KSP2: Room, Hilt gibi annotation processor'lar
5. ✅ Compose Compiler: 1.5.15+ (Compose 1.7 ile uyumlu)
6. ✅ KSP2 migrate: KSP1 removed 2026 Q2
7. ✅ Dependencies check: kotlinx.serialization, coroutines, etc.

// Guard conditions + context parameters
context(logger: Logger)
fun processValue(value: Any?) = when (value) {
    null -> logger.warn("Null value")
    is Int if value > 0 -> logger.info("Positive: $value")
    is Int if value < 0 -> logger.warn("Negative: $value")
    is String if value.isBlank() -> logger.warn("Blank string")
    is String -> logger.info("String: $value")
    is List<*> if value.isEmpty() -> logger.warn("Empty list")
    is List<*> -> logger.info("List of ${value.size}")
    else -> logger.error("Unknown type: ${value::class}")
}

Sonuç

Kotlin 2.1 K2 compiler'ı cement etti — %2x hız artışı, daha iyi type inference, cleaner IDE experience. Context parameters DI'ı simplify ediyor. KMP 2.1'de iOS production-ready. Migration çoğunlukla smooth; KAPT → KSP2 ve annotation processor compatibility tek edge case. 2.2'de bekleniyor: stable context parameters, stable Swift export, Kotlin LSP 2.0.

*İlgili yazılar: [Kotlin Coroutines Flow](./kotlin-coroutines-flow), [Compose 1.7](./jetpack-compose-1-7-performance-strong-skipping), [Android 15](./android-15-developer-privacy-sandbox-edge-foreground).*