Kotlin K2 Compiler

// kotlin_k2_compiler.kt
// Mendemonstrasikan dampak K2 compiler terhadap kode yang kita tulis:
// - inferensi tipe yang lebih akurat
// - smart cast lebih luas
// - destrukturisasi otomatis untuk lambda
// - performa kompilasi lebih cepat
//
// Catatan: K2 adalah kompilator internal; kita tidak bisa "menjalankan" K2
// lewat file .kt ini. Yang bisa kita lakukan adalah menunjukkan kode-kode
// yang diperbaiki inferensinya oleh K2.

// 1. Smart cast yang lebih luas di K2 — bahkan lewat or / safe call
data class Pengguna(val nama: String?, val alamat: String?)

fun sapa(u: Pengguna): String {
    return if (u.nama != null && u.alamat != null) {
        // K1 sering memerlukan `u.nama!!`; K2 smart-cast otomatis
        "Halo ${u.nama} dari ${u.alamat}"
    } else {
        "Data tidak lengkap"
    }
}

// 2. Inferensi tipe lambda parameter — K2 menangkap tipe dari konteks
fun pakaiList(block: (List<String>) -> Unit) {
    block(listOf("alpha", "beta", "gamma"))
}

// 3. Destructuring di lambda parameter (data class with componentN)
data class Titik(val x: Int, val y: Int)

fun prosesTitik(block: (Titik) -> String) = block(Titik(3, 4))

// 4. Inferensi return type yang lebih akurat
fun <T> identitas(x: T): T = x

fun ambilString(): String = identitas("halo")  // T disimpulkan = String

// 5. Builder inference tidak butuh -Xskip-prerelease-check
fun buatMap(): Map<String, Int> = buildMap {
    put("satu", 1)
    put("dua", 2)
}

fun main() {
    println("=== K2 Compiler (Kotlin 2.0+) ===")
    println()

    println("--- 1. Smart cast lebih luas ---")
    println(sapa(Pengguna("Budi", "Jakarta")))
    println(sapa(Pengguna("Siti", null)))
    println(sapa(Pengguna(null, "Bandung")))

    println()
    println("--- 2. Inferensi lambda parameter ---")
    pakaiList { daftar ->
        println("Daftar diterima: $daftar")
        println("Ukuran: ${daftar.size}")
    }

    println()
    println("--- 3. Destructuring di lambda ---")
    prosesTitik { (x, y) ->
        val jarak = x * x + y * y
        "Titik($x,$y) kuadrat-jarak=$jarak"
    }.let { println(it) }

    println()
    println("--- 4. Return type inferensi akurat ---")
    val s: String = ambilString()
    println("Hasil: $s  (panjang=${s.length})")

    println()
    println("--- 5. Builder inference stabil ---")
    val peta = buatMap()
    peta.forEach { (k, v) -> println("  $k -> $v") }

    println()
    println("--- 6. Perbandingan K1 vs K2 (ringkasan) ---")
    val perbandingan = listOf(
        Triple("Frontend", "2-phase Fir/Psi", "FIR unifikasi"),
        Triple("Smart cast", "terbatas pada if-lokal", "menjangkau && dan or"),
        Triple("Inferensi lambda", "sering perlu eksplisit", "otomatis"),
        Triple("Kecepatan", "baseline", "1.5-2x lebih cepat"),
        Triple("Compile error", "kadang membingungkan", "lebih akurat")
    )
    perbandingan.forEach { (aspek, k1, k2) ->
        println("  $aspek")
        println("    K1: $k1")
        println("    K2: $k2")
    }

    println()
    println("--- 7. Cara mengaktifkan K2 ---")
    println("Kotlin 2.0+ memakai K2 sebagai default compiler.")
    println("Tidak perlu flag tambahan — Gradle/Maven otomatis memakai K2.")
    println("Untuk menonaktifkan (kasus lama): -Xuse-old-backend (deprecated)")
}

=== K2 Compiler (Kotlin 2.0+) ===

--- 1. Smart cast lebih luas ---
Halo Budi dari Jakarta
Data tidak lengkap
Data tidak lengkap

--- 2. Inferensi lambda parameter ---
Daftar diterima: [alpha, beta, gamma]
Ukuran: 3

--- 3. Destructuring di lambda ---
Titik(3,4) kuadrat-jarak=25

--- 4. Return type inferensi akurat ---
Hasil: halo  (panjang=4)

--- 5. Builder inference stabil ---
  satu -> 1
  dua -> 2

--- 6. Perbandingan K1 vs K2 (ringkasan) ---
  Frontend
    K1: 2-phase Fir/Psi
    K2: FIR unifikasi
  Smart cast
    K1: terbatas pada if-lokal
    K2: menjangkau && dan or
  Inferensi lambda
    K1: sering perlu eksplisit
    K2: otomatis
  Kecepatan
    K1: baseline
    K2: 1.5-2x lebih cepat
  Compile error
    K1: kadang membingungkan
    K2: lebih akurat

--- 7. Cara mengaktifkan K2 ---
Kotlin 2.0+ memakai K2 sebagai default compiler.
Tidak perlu flag tambahan — Gradle/Maven otomatis memakai K2.
Untuk menonaktifkan (kasus lama): -Xuse-old-backend (deprecated)

plugins {
    kotlin("jvm") version "2.0.21"
}

// Tidak perlu flag tambahan — K2 aktif default
kotlin {
    compilerOptions {
        // Untuk menonaktifkan K2 (kasus lama):
        // freeCompilerArgs.add("-Xuse-old-backend")  // deprecated
    }
}