4. Region-Based Isolation (Swift 6)

Region-based isolation adalah fitur Swift 6 yang memungkinkan transfer nilai non-Sendable antar isolation domain jika compiler bisa membuktikan nilai itu tidak diakses lagi dari region asal.

Konsep Region

Setiap nilai hidup dalam sebuah "region". Region bisa:

Digunakan lokal: nilai tidak pernah keluar isolation domain
Dikirim (sending): nilai dipindah ke domain lain, region asal tidak boleh akses lagi
Merged: dua region menjadi satu saat nilai dari dua region berinteraksi

swift
// Ilustrasi region tracking oleh compiler
func example() async {
    let doc = Document()          // doc ada di region R1
    doc.content = "hello"         // akses R1 — ✓

    await processOnBackground(doc)  // R1 "dikirim" ke domain lain
                                    // R1 sekarang "consumed"

    // doc.content = "world"      // ❌ Compiler error: R1 sudah consumed
}

Transferring Values

Nilai non-Sendable bisa dikirim ke isolation domain lain jika compiler bisa membuktikan tidak ada akses konkuren:

swift
class Configuration {  // Non-Sendable
    var settings: [String: Any] = [:]
}

// Transfer ownership ke background task
func configureAndProcess() async {
    let config = Configuration()
    config.settings["theme"] = "dark"
    config.settings["language"] = "id"

    // Compiler analisis: setelah Task.detached, 'config' tidak digunakan lagi
    // di scope ini → region merge dianggap aman
    let result = await Task.detached {
        // config digunakan di sini — satu-satunya yang akses
        return processConfiguration(config)
    }.value

    print(result)
    // config tidak diakses lagi di sini → tidak ada data race
}

// Jika masih diakses setelah transfer — compiler error
func unsafeExample() async {
    let config = Configuration()
    config.settings["key"] = "value"

    Task.detached {
        _ = processConfiguration(config)
    }

    config.settings["key"] = "modified"  // ❌ Error: region sudah consumed
}

Isolation Region dalam Struct vs Class

swift
// Struct value semantics — copy membuat region baru
struct DTO {
    var data: [String] = []
}

func useStruct() async {
    let dto = DTO()
    let copy = dto  // Region baru — modifikasi independen
    
    Task.detached { _ = copy.data }  // copy di region baru — aman
    // dto masih bisa digunakan
}

// Class reference semantics — sharing region
class Ref {
    var data: [String] = []
}

func useClass() async {
    let ref = Ref()
    let alias = ref  // SAMA region — bukan copy

    Task.detached { _ = alias.data }  // alias dan ref di region sama!
    // ref.data = []  // ❌ Error: data race — alias sudah di task lain
}