Skip to content

Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

61.6 KB
Raw Blame
/*
 * test_kotlin_lsp.c — Tests for Kotlin LSP type-aware call resolution.
 *
 * Coverage areas (mirrors fwcd kotlin-language-server's reference test
 * suite at a feature level — we don't run their JVM tests, we test
 * equivalent semantic outcomes through our pure-C resolver):
 *
 *   1. Package + import resolution (default, explicit, alias, wildcard)
 *   2. Top-level function calls
 *   3. Class instantiation (constructor calls)
 *   4. Method dispatch on instance
 *   5. Companion object dispatch (Foo.bar() static-style)
 *   6. Object singleton dispatch
 *   7. Extension functions
 *   8. Inheritance / super-method lookup
 *   9. Smart-casts after `is`, `as`, `as?`
 *  10. Nullable types and safe calls (?.)
 *  11. Lambda `it` parameter type propagation
 *  12. Scope functions (let, run, also, apply, with, takeIf, takeUnless)
 *  13. Type aliases
 *  14. Generic type parameters (basic)
 *  15. Constructor parameter properties (val/var in primary constructor)
 *  16. Enum classes
 *  17. Data classes
 *  18. Sealed classes
 *  19. Interface dispatch
 *  20. Stdlib resolution (println, listOf, mapOf, ...)
 *  21. Quality parity benchmarks vs tree-sitter-only baseline
 */
#include "test_framework.h"
#include "cbm.h"
#include "../src/pipeline/lsp_resolve.h"
#include "lsp/kotlin_lsp.h"
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

/* ── helpers ───────────────────────────────────────────────── */

static CBMFileResult *extract_kotlin(const char *source) {
    return cbm_extract_file(source, (int)strlen(source), CBM_LANG_KOTLIN, "test", "Main.kt", 0,
                            NULL, NULL);
}

static CBMFileResult *extract_kotlin_path(const char *source, const char *rel_path) {
    return cbm_extract_file(source, (int)strlen(source), CBM_LANG_KOTLIN, "test", rel_path, 0,
                            NULL, NULL);
}

/* Search resolved_calls for a match where caller contains callerSub
 * and callee contains calleeSub. Returns index or -1. */
static int find_resolved(const CBMFileResult *r, const char *callerSub, const char *calleeSub) {
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[i];
        if (rc->caller_qn && strstr(rc->caller_qn, callerSub) && rc->callee_qn &&
            strstr(rc->callee_qn, calleeSub)) {
            return i;
        }
    }
    return -1;
}

static int require_resolved(const CBMFileResult *r, const char *callerSub, const char *calleeSub) {
    int idx = find_resolved(r, callerSub, calleeSub);
    if (idx < 0) {
        printf("  MISSING resolved call: caller~%s -> callee~%s (have %d)\n", callerSub, calleeSub,
               r->resolved_calls.count);
        for (int i = 0; i < r->resolved_calls.count; i++) {
            const CBMResolvedCall *rc = &r->resolved_calls.items[i];
            printf("    %s -> %s [%s %.2f]\n", rc->caller_qn ? rc->caller_qn : "(null)",
                   rc->callee_qn ? rc->callee_qn : "(null)", rc->strategy ? rc->strategy : "(null)",
                   rc->confidence);
        }
    }
    return idx;
}

static int count_resolved(const CBMFileResult *r, const char *callerSub, const char *calleeSub) {
    int n = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[i];
        if (rc->caller_qn && strstr(rc->caller_qn, callerSub) && rc->callee_qn &&
            strstr(rc->callee_qn, calleeSub)) {
            n++;
        }
    }
    return n;
}

static int count_exact_resolved_site(const CBMFileResult *r, const char *callerSub,
                                     const char *calleeSub, uint32_t start, uint32_t end) {
    int n = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[i];
        if (rc->kind == CBM_RESOLVED_INVOCATION && rc->caller_qn &&
            strstr(rc->caller_qn, callerSub) && rc->callee_qn && strstr(rc->callee_qn, calleeSub) &&
            rc->strategy && strcmp(rc->strategy, "lsp_kt_delegate_access") == 0 &&
            rc->site_start_byte == start && rc->site_end_byte == end) {
            n++;
        }
    }
    return n;
}

static int count_exact_synthetic_call(const CBMFileResult *r, const char *callerSub,
                                      const char *callee, uint32_t start, uint32_t end) {
    int n = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *call = &r->calls.items[i];
        if (call->requires_lsp_resolution && call->enclosing_func_qn &&
            strstr(call->enclosing_func_qn, callerSub) && call->callee_name &&
            strcmp(call->callee_name, callee) == 0 && call->site_start_byte == start &&
            call->site_end_byte == end) {
            n++;
        }
    }
    return n;
}

static int count_synthetic_call(const CBMFileResult *r, const char *callee) {
    int n = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *call = &r->calls.items[i];
        if (call->requires_lsp_resolution && call->callee_name &&
            strcmp(call->callee_name, callee) == 0) {
            n++;
        }
    }
    return n;
}

/* ── 1. Package + import resolution ────────────────────────── */

TEST(ktlsp_package_set) {
    CBMFileResult *r = extract_kotlin("package com.example.foo\n\n"
                                      "fun greet() { println(\"hi\") }\n");
    ASSERT_NOT_NULL(r);
    /* greet should resolve to println in kotlin.io */
    ASSERT_GTE(require_resolved(r, "greet", "println"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_explicit_import_function) {
    CBMFileResult *r = extract_kotlin("package com.example\n\n"
                                      "import kotlin.io.println\n\n"
                                      "fun greet() { println(\"hi\") }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "greet", "println"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_explicit_import_type) {
    CBMFileResult *r = extract_kotlin("package com.example\n\n"
                                      "import java.io.File\n\n"
                                      "fun open(): File = File(\"/tmp/x\")\n");
    ASSERT_NOT_NULL(r);
    /* File() constructor resolved */
    ASSERT_GTE(require_resolved(r, "open", "File"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_import_alias) {
    CBMFileResult *r = extract_kotlin("package com.example\n\n"
                                      "import java.io.File as JFile\n\n"
                                      "fun open(): JFile = JFile(\"/tmp/x\")\n");
    ASSERT_NOT_NULL(r);
    /* The constructor target should still resolve to java.io.File */
    ASSERT_GTE(require_resolved(r, "open", "File"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_wildcard_import) {
    CBMFileResult *r = extract_kotlin("package com.example\n\n"
                                      "import kotlin.collections.*\n\n"
                                      "fun build() = listOf(1, 2, 3)\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "build", "listOf"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 2. Top-level function calls ───────────────────────────── */

TEST(ktlsp_top_level_call_default_imports) {
    CBMFileResult *r = extract_kotlin("fun main() { println(\"hi\") }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "main", "println"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_top_level_listof) {
    CBMFileResult *r = extract_kotlin("fun build() { val xs = listOf(1, 2, 3) }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "build", "listOf"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_top_level_setof_mapof) {
    CBMFileResult *r = extract_kotlin("fun build() {\n"
                                      "    val s = setOf(1, 2, 3)\n"
                                      "    val m = mapOf(\"a\" to 1, \"b\" to 2)\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "build", "setOf"), 0);
    ASSERT_GTE(require_resolved(r, "build", "mapOf"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_intra_file_top_level) {
    CBMFileResult *r = extract_kotlin("package myapp\n\n"
                                      "fun helper(x: Int): Int = x + 1\n"
                                      "fun main() { val r = helper(42) }\n");
    ASSERT_NOT_NULL(r);
    /* main should resolve to helper */
    ASSERT_GTE(require_resolved(r, "main", "helper"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 3. Class instantiation ────────────────────────────────── */

TEST(ktlsp_class_constructor) {
    CBMFileResult *r = extract_kotlin("class Greeter(val name: String) {\n"
                                      "    fun greet() = println(\"Hello, $name\")\n"
                                      "}\n"
                                      "fun main() { val g = Greeter(\"world\"); g.greet() }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "main", "Greeter"), 0);
    /* Method dispatch on g */
    ASSERT_GTE(require_resolved(r, "main", "greet"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_data_class) {
    CBMFileResult *r = extract_kotlin("data class User(val id: Int, val name: String)\n"
                                      "fun create(): User = User(1, \"Alice\")\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "create", "User"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_secondary_constructor) {
    CBMFileResult *r = extract_kotlin("class Box {\n"
                                      "    constructor() {}\n"
                                      "    constructor(x: Int) {}\n"
                                      "    fun open() {}\n"
                                      "}\n"
                                      "fun main() { val b = Box(); b.open() }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "main", "Box"), 0);
    ASSERT_GTE(require_resolved(r, "main", "open"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 4. Method dispatch ────────────────────────────────────── */

TEST(ktlsp_method_on_known_type) {
    CBMFileResult *r = extract_kotlin("class Service {\n"
                                      "    fun query(sql: String): String = \"\"\n"
                                      "}\n"
                                      "fun work(s: Service) { s.query(\"SELECT 1\") }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "work", "query"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_method_chain) {
    CBMFileResult *r = extract_kotlin("class Builder {\n"
                                      "    fun add(s: String): Builder = this\n"
                                      "    fun build(): String = \"\"\n"
                                      "}\n"
                                      "fun make(b: Builder): String = b.add(\"x\").build()\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "make", "add"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_string_method_dispatch) {
    CBMFileResult *r = extract_kotlin("fun shout(s: String): String = s.uppercase()\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "shout", "uppercase"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_list_method_dispatch) {
    CBMFileResult *r = extract_kotlin("fun first_n(xs: List<Int>): List<Int> = xs.take(3)\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "first_n", "take"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 5. Companion object dispatch ──────────────────────────── */

TEST(ktlsp_companion_object_call) {
    CBMFileResult *r = extract_kotlin("class Logger {\n"
                                      "    companion object {\n"
                                      "        fun create(): Logger = Logger()\n"
                                      "    }\n"
                                      "}\n"
                                      "fun main() { val log = Logger.create() }\n");
    ASSERT_NOT_NULL(r);
    /* Foo.bar() with bar in Companion */
    ASSERT_GTE(require_resolved(r, "main", "create"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 6. Object singleton ───────────────────────────────────── */

TEST(ktlsp_object_singleton) {
    CBMFileResult *r = extract_kotlin("object Constants {\n"
                                      "    fun get(key: String): String = \"\"\n"
                                      "}\n"
                                      "fun read() { val v = Constants.get(\"name\") }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "read", "get"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 7. Extension functions ────────────────────────────────── */

TEST(ktlsp_extension_function) {
    CBMFileResult *r =
        extract_kotlin("fun String.shout(): String = this.uppercase() + \"!\"\n"
                       "fun cheer(s: String): String = s.shout()\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "cheer", "shout"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_extension_method_on_list) {
    CBMFileResult *r = extract_kotlin("fun List<Int>.sumPlus(n: Int): Int = this.sum() + n\n"
                                      "fun calc(xs: List<Int>): Int = xs.sumPlus(10)\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "calc", "sumPlus"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 8. Inheritance ────────────────────────────────────────── */

TEST(ktlsp_super_call) {
    CBMFileResult *r = extract_kotlin("open class Animal {\n"
                                      "    open fun speak() = println(\"...\")\n"
                                      "}\n"
                                      "class Dog : Animal() {\n"
                                      "    override fun speak() {\n"
                                      "        super.speak()\n"
                                      "        println(\"Woof\")\n"
                                      "    }\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    /* Inside Dog.speak, the super.speak should resolve. */
    ASSERT_GTE(require_resolved(r, "speak", "speak"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_interface_dispatch) {
    CBMFileResult *r = extract_kotlin("interface Closer { fun close() }\n"
                                      "class FileHandle : Closer { override fun close() {} }\n"
                                      "fun shutdown(c: Closer) { c.close() }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "shutdown", "close"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 9. Smart casts ────────────────────────────────────────── */

TEST(ktlsp_smartcast_is) {
    CBMFileResult *r = extract_kotlin("class Animal { fun speak() {} }\n"
                                      "fun handle(x: Any) {\n"
                                      "    if (x is Animal) {\n"
                                      "        x.speak()\n"
                                      "    }\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "handle", "speak"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_smartcast_as) {
    CBMFileResult *r = extract_kotlin("class Animal { fun speak() {} }\n"
                                      "fun handle(x: Any) { (x as Animal).speak() }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "handle", "speak"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_when_smartcast) {
    CBMFileResult *r = extract_kotlin("interface Shape { fun area(): Double }\n"
                                      "class Square(val side: Double) : Shape {\n"
                                      "    override fun area() = side * side\n"
                                      "}\n"
                                      "fun describe(s: Any): Double = when (s) {\n"
                                      "    is Square -> s.area()\n"
                                      "    else -> 0.0\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "describe", "area"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 10. Safe calls / nullable ─────────────────────────────── */

TEST(ktlsp_safe_call) {
    CBMFileResult *r = extract_kotlin("class User { fun getName(): String = \"\" }\n"
                                      "fun displayName(u: User?): String? = u?.getName()\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "displayName", "getName"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_not_null_assertion) {
    CBMFileResult *r = extract_kotlin("class User { fun getName(): String = \"\" }\n"
                                      "fun mustHave(u: User?): String = u!!.getName()\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "mustHave", "getName"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 11. Lambda `it` parameter ─────────────────────────────── */

TEST(ktlsp_lambda_it_string) {
    CBMFileResult *r = extract_kotlin("fun upper(s: String): String = s.let { it.uppercase() }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "upper", "uppercase"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_lambda_it_object) {
    CBMFileResult *r = extract_kotlin("class User { fun login() {} }\n"
                                      "fun signIn(u: User) { u.let { it.login() } }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "signIn", "login"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 12. Scope functions ───────────────────────────────────── */

TEST(ktlsp_scope_let) {
    CBMFileResult *r =
        extract_kotlin("fun upper(s: String?): String? = s?.let { it.uppercase() }\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "upper", "uppercase"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_scope_apply) {
    CBMFileResult *r = extract_kotlin("class Builder { fun setName(n: String) {} }\n"
                                      "fun build() = Builder().apply { setName(\"x\") }\n");
    ASSERT_NOT_NULL(r);
    /* `Builder()` is a constructor */
    ASSERT_GTE(require_resolved(r, "build", "Builder"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 13. Type aliases ──────────────────────────────────────── */

TEST(ktlsp_typealias) {
    CBMFileResult *r = extract_kotlin("typealias UserId = Int\n"
                                      "fun id(): UserId = 42\n"
                                      "fun show(id: UserId): String = id.toString()\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "show", "toString"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 14. Enums ────────────────────────────────────────────── */

TEST(ktlsp_enum_class) {
    CBMFileResult *r = extract_kotlin("enum class Color { RED, GREEN, BLUE }\n"
                                      "fun pick(): Color = Color.RED\n");
    ASSERT_NOT_NULL(r);
    /* Color.RED — for our purposes, the enum entry access doesn't need a
     * resolved call edge. We just verify it doesn't crash. */
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}

/* ── 15. Sealed classes ────────────────────────────────────── */

TEST(ktlsp_sealed_when) {
    CBMFileResult *r = extract_kotlin("sealed class Event\n"
                                      "class Login(val user: String) : Event()\n"
                                      "class Logout : Event()\n"
                                      "fun handle(e: Event): String = when (e) {\n"
                                      "    is Login -> e.user\n"
                                      "    is Logout -> \"bye\"\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}

/* ── 16. Generics (basic) ──────────────────────────────────── */

TEST(ktlsp_generic_call) {
    CBMFileResult *r = extract_kotlin("class Box<T>(val value: T) {\n"
                                      "    fun unwrap(): T = value\n"
                                      "}\n"
                                      "fun get(b: Box<String>): String = b.unwrap()\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "get", "unwrap"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 17. Stdlib resolution ─────────────────────────────────── */

TEST(ktlsp_stdlib_println) {
    CBMFileResult *r = extract_kotlin("fun main() {\n"
                                      "    println(\"a\")\n"
                                      "    print(\"b\")\n"
                                      "    error(\"c\")\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "main", "println"), 0);
    ASSERT_GTE(require_resolved(r, "main", "print"), 0);
    ASSERT_GTE(require_resolved(r, "main", "error"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_stdlib_collection_builders) {
    CBMFileResult *r = extract_kotlin("fun build() {\n"
                                      "    val a = arrayOf(1, 2, 3)\n"
                                      "    val l = listOf(1, 2, 3)\n"
                                      "    val ml = mutableListOf(1, 2, 3)\n"
                                      "    val m = mapOf(\"a\" to 1)\n"
                                      "    val mm = mutableMapOf<String, Int>()\n"
                                      "    val s = setOf(1, 2, 3)\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "build", "arrayOf"), 0);
    ASSERT_GTE(require_resolved(r, "build", "listOf"), 0);
    ASSERT_GTE(require_resolved(r, "build", "mutableListOf"), 0);
    ASSERT_GTE(require_resolved(r, "build", "mapOf"), 0);
    ASSERT_GTE(require_resolved(r, "build", "mutableMapOf"), 0);
    ASSERT_GTE(require_resolved(r, "build", "setOf"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_stdlib_require_check) {
    CBMFileResult *r = extract_kotlin("fun validate(x: Int) {\n"
                                      "    require(x > 0)\n"
                                      "    check(x < 100)\n"
                                      "    requireNotNull(x)\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "validate", "require"), 0);
    ASSERT_GTE(require_resolved(r, "validate", "check"), 0);
    ASSERT_GTE(require_resolved(r, "validate", "requireNotNull"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_stdlib_string_chain) {
    CBMFileResult *r = extract_kotlin("fun proc(s: String): String =\n"
                                      "    s.trim().uppercase().replace(\"x\", \"y\")\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "proc", "trim"), 0);
    ASSERT_GTE(require_resolved(r, "proc", "uppercase"), 0);
    ASSERT_GTE(require_resolved(r, "proc", "replace"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_stdlib_collection_pipe) {
    CBMFileResult *r =
        extract_kotlin("fun pipe(xs: List<Int>): Int = xs.filter { it > 0 }.map { it * 2 }.sum()\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "pipe", "filter"), 0);
    ASSERT_GTE(require_resolved(r, "pipe", "map"), 0);
    ASSERT_GTE(require_resolved(r, "pipe", "sum"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 18. Function reference handling ───────────────────────── */

TEST(ktlsp_constructor_param_property) {
    CBMFileResult *r = extract_kotlin("class Repo(val name: String) {\n"
                                      "    fun describe(): String = name.uppercase()\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    /* `name.uppercase()` inside describe should resolve via String.uppercase() */
    ASSERT_GTE(require_resolved(r, "describe", "uppercase"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 19. Local function ────────────────────────────────────── */

TEST(ktlsp_local_function) {
    CBMFileResult *r = extract_kotlin("fun outer() {\n"
                                      "    fun inner() { println(\"hi\") }\n"
                                      "    inner()\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "inner", "println"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 20. Companion + factory pattern ───────────────────────── */

TEST(ktlsp_factory_pattern) {
    CBMFileResult *r = extract_kotlin("class Database private constructor() {\n"
                                      "    fun query() {}\n"
                                      "    companion object {\n"
                                      "        fun create(): Database = Database()\n"
                                      "    }\n"
                                      "}\n"
                                      "fun main() {\n"
                                      "    val db = Database.create()\n"
                                      "    db.query()\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "main", "create"), 0);
    ASSERT_GTE(require_resolved(r, "main", "query"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 21. Quality parity vs tree-sitter baseline ────────────── */

TEST(ktlsp_resolves_more_than_textual) {
    /* Without LSP, a simple textual matcher would attribute foo() to any
     * function named foo. The LSP resolver disambiguates by package. */
    CBMFileResult *r = extract_kotlin("package myapp\n\n"
                                      "fun helper() = println(\"x\")\n"
                                      "fun main() { helper() }\n");
    ASSERT_NOT_NULL(r);
    /* helper() must resolve to myapp.helper, not some random helper. */
    int idx = require_resolved(r, "main", "helper");
    ASSERT_GTE(idx, 0);
    if (idx >= 0) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[idx];
        /* Confidence should be >= 0.9 for a top-level call. */
        ASSERT_TRUE(rc->confidence >= 0.85f);
    }
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_empty_file) {
    CBMFileResult *r = extract_kotlin("");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(r->resolved_calls.count, 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_only_package) {
    CBMFileResult *r = extract_kotlin("package myapp\n");
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(r->resolved_calls.count, 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_only_imports) {
    CBMFileResult *r = extract_kotlin("package myapp\n"
                                      "import java.io.File\n"
                                      "import kotlin.collections.List as KList\n"
                                      "import kotlin.text.*\n");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_kts_script) {
    CBMFileResult *r =
        extract_kotlin_path("println(\"hello from script\")\n", "build.gradle.kts");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}

/* ── 22. No regressions for unresolvable code ──────────────── */

TEST(ktlsp_unknown_external_unresolved) {
    /* Calls to symbols we have no info about should not produce
     * spurious LSP overrides. They fall through to the registry. */
    CBMFileResult *r = extract_kotlin("fun work(x: SomeUnknownType): UnknownReturn {\n"
                                      "    return x.doMagic()\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    /* x.doMagic should NOT be in resolved_calls — it's unresolvable. */
    ASSERT_EQ(find_resolved(r, "work", "doMagic"), -1);
    cbm_free_result(r);
    PASS();
}

/* A call_expression contains a navigation_expression, and the Kotlin walker
 * currently visits both.  Keep one occurrence-exact semantic record per full
 * parser call so same-leaf methods cannot duplicate or join the other target. */
TEST(ktlsp_ordinary_same_leaf_calls_join_by_exact_site) {
    const char *source = "class Alpha { fun render(): String = \"alpha\" }\n"
                         "class Beta { fun render(): String = \"beta\" }\n"
                         "fun occurrenceProbe(alpha: Alpha, beta: Beta) {\n"
                         "    alpha.render()\n"
                         "    beta.render()\n"
                         "}\n";
    static const char alpha_text[] = "alpha.render()";
    static const char beta_text[] = "beta.render()";
    const char *alpha_site = strstr(source, alpha_text);
    const char *beta_site = strstr(source, beta_text);
    ASSERT_NOT_NULL(alpha_site);
    ASSERT_NOT_NULL(beta_site);
    const uint32_t alpha_start = (uint32_t)(alpha_site - source);
    const uint32_t alpha_end = alpha_start + (uint32_t)strlen(alpha_text);
    const uint32_t beta_start = (uint32_t)(beta_site - source);
    const uint32_t beta_end = beta_start + (uint32_t)strlen(beta_text);

    CBMFileResult *r = extract_kotlin(source);
    ASSERT_NOT_NULL(r);

    const CBMCall *alpha_call = NULL;
    const CBMCall *beta_call = NULL;
    int carrier_count = 0;
    int zero_span_carriers = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const CBMCall *call = &r->calls.items[i];
        if (!call->enclosing_func_qn || !strstr(call->enclosing_func_qn, "occurrenceProbe") ||
            !call->callee_name || !strstr(call->callee_name, "render")) {
            continue;
        }
        carrier_count++;
        if (call->site_end_byte <= call->site_start_byte)
            zero_span_carriers++;
        if (call->site_start_byte == alpha_start && call->site_end_byte == alpha_end)
            alpha_call = call;
        if (call->site_start_byte == beta_start && call->site_end_byte == beta_end)
            beta_call = call;
    }

    ASSERT_EQ(carrier_count, 2);
    ASSERT_EQ(zero_span_carriers, 0);
    ASSERT_NOT_NULL(alpha_call);
    ASSERT_NOT_NULL(beta_call);
    ASSERT_NEQ(alpha_call->site_start_byte, beta_call->site_start_byte);

    const CBMResolvedCall *alpha_semantic = NULL;
    const CBMResolvedCall *beta_semantic = NULL;
    int semantic_count = 0;
    int zero_span_semantics = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[i];
        if (rc->kind != CBM_RESOLVED_INVOCATION || rc->confidence <= 0.0f || !rc->caller_qn ||
            !strstr(rc->caller_qn, "occurrenceProbe") || !rc->callee_qn ||
            !strstr(rc->callee_qn, ".render")) {
            continue;
        }
        semantic_count++;
        if (rc->site_end_byte <= rc->site_start_byte)
            zero_span_semantics++;
        if (strstr(rc->callee_qn, ".Alpha.render") && rc->site_start_byte == alpha_start &&
            rc->site_end_byte == alpha_end) {
            alpha_semantic = rc;
        }
        if (strstr(rc->callee_qn, ".Beta.render") && rc->site_start_byte == beta_start &&
            rc->site_end_byte == beta_end) {
            beta_semantic = rc;
        }
    }

    ASSERT_EQ(semantic_count, 2);
    ASSERT_EQ(zero_span_semantics, 0);
    ASSERT_NOT_NULL(alpha_semantic);
    ASSERT_NOT_NULL(beta_semantic);
    ASSERT_TRUE(alpha_semantic != beta_semantic);

    const CBMResolvedCall *alpha_joined =
        cbm_pipeline_find_lsp_resolution(&r->resolved_calls, alpha_call, false);
    const CBMResolvedCall *beta_joined =
        cbm_pipeline_find_lsp_resolution(&r->resolved_calls, beta_call, false);
    ASSERT_TRUE(alpha_joined == alpha_semantic);
    ASSERT_TRUE(beta_joined == beta_semantic);

    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_no_duplicate_emission) {
    /* Same call shouldn't emit twice. */
    CBMFileResult *r = extract_kotlin("fun main() { println(\"a\"); println(\"b\") }\n");
    ASSERT_NOT_NULL(r);
    int n = count_resolved(r, "main", "println");
    /* We expect 2 entries (one per call), not duplicated more than that. */
    ASSERT_TRUE(n >= 2 && n <= 4);
    cbm_free_result(r);
    PASS();
}

/* ── 23. Confidence sanity ─────────────────────────────────── */

TEST(ktlsp_constructor_high_confidence) {
    CBMFileResult *r = extract_kotlin("class Foo\n"
                                      "fun make(): Foo = Foo()\n");
    ASSERT_NOT_NULL(r);
    int idx = require_resolved(r, "make", "Foo");
    ASSERT_GTE(idx, 0);
    if (idx >= 0) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[idx];
        ASSERT_TRUE(rc->confidence >= 0.90f);
        ASSERT_TRUE(rc->strategy != NULL);
        ASSERT_TRUE(strstr(rc->strategy, "lsp_kt_") != NULL);
    }
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_method_high_confidence) {
    CBMFileResult *r = extract_kotlin("class Service { fun run() {} }\n"
                                      "fun start(s: Service) { s.run() }\n");
    ASSERT_NOT_NULL(r);
    int idx = require_resolved(r, "start", "run");
    ASSERT_GTE(idx, 0);
    if (idx >= 0) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[idx];
        ASSERT_TRUE(rc->confidence >= 0.85f);
    }
    cbm_free_result(r);
    PASS();
}

/* ── 24. Mixed real-world patterns ─────────────────────────── */

TEST(ktlsp_real_world_repository_pattern) {
    CBMFileResult *r =
        extract_kotlin("package myapp.repo\n\n"
                       "import kotlin.collections.List\n\n"
                       "interface UserRepository {\n"
                       "    fun findById(id: Int): User?\n"
                       "    fun all(): List<User>\n"
                       "}\n"
                       "class User(val id: Int, val name: String)\n"
                       "class InMemoryRepo : UserRepository {\n"
                       "    private val data = mutableListOf<User>()\n"
                       "    override fun findById(id: Int): User? = data.find { it.id == id }\n"
                       "    override fun all(): List<User> = data.toList()\n"
                       "}\n"
                       "fun main(repo: UserRepository) {\n"
                       "    val u = repo.findById(42)\n"
                       "    val xs = repo.all()\n"
                       "    println(xs.size)\n"
                       "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "main", "findById"), 0);
    ASSERT_GTE(require_resolved(r, "main", "all"), 0);
    ASSERT_GTE(require_resolved(r, "main", "println"), 0);
    /* InMemoryRepo.findById uses .find { ... } on the list */
    ASSERT_GTE(require_resolved(r, "findById", "find"), 0);
    /* and .toList in `all` */
    ASSERT_GTE(require_resolved(r, "all", "toList"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_real_world_builder) {
    CBMFileResult *r = extract_kotlin("class StringBuilder {\n"
                                      "    fun append(s: String): StringBuilder = this\n"
                                      "    fun build(): String = \"\"\n"
                                      "}\n"
                                      "fun build(): String = StringBuilder()\n"
                                      "    .append(\"a\")\n"
                                      "    .append(\"b\")\n"
                                      "    .build()\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "build", "StringBuilder"), 0);
    /* append should resolve through the chained returns */
    int n_append = count_resolved(r, "build", "append");
    ASSERT_TRUE(n_append >= 1);  /* tree-sitter only would get 0 */
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_real_world_dsl) {
    CBMFileResult *r = extract_kotlin("class Html {\n"
                                      "    fun head(block: Head.() -> Unit) {}\n"
                                      "    fun body(block: Body.() -> Unit) {}\n"
                                      "}\n"
                                      "class Head { fun title(s: String) {} }\n"
                                      "class Body { fun p(s: String) {} }\n"
                                      "fun page() {\n"
                                      "    val h = Html()\n"
                                      "    h.head { title(\"X\") }\n"
                                      "    h.body { p(\"hi\") }\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "page", "Html"), 0);
    ASSERT_GTE(require_resolved(r, "page", "head"), 0);
    ASSERT_GTE(require_resolved(r, "page", "body"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 25. Defensive — malformed input ───────────────────────── */

TEST(ktlsp_malformed_recovery) {
    /* Tree-sitter recovers — LSP must not crash. */
    CBMFileResult *r = extract_kotlin("fun broken( {\n}\n");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_unicode_identifier) {
    CBMFileResult *r = extract_kotlin("class Café {\n"
                                      "    fun servir() = println(\"ok\")\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_long_chain) {
    /* Stress the chain depth */
    CBMFileResult *r =
        extract_kotlin("fun chain(s: String) =\n"
                       "    s.trim().uppercase().replace(\"a\",\"b\").substring(0).reversed()\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "chain", "trim"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 26. Operator conventions ───────────────────────────────── */

TEST(ktlsp_operator_plus) {
    /* `a + b` desugars to `a.plus(b)` for any registered type. */
    CBMFileResult *r = extract_kotlin("class Money(val cents: Int) {\n"
                                      "    operator fun plus(o: Money): Money = Money(cents + o.cents)\n"
                                      "}\n"
                                      "fun add(a: Money, b: Money): Money = a + b\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "add", "plus"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_operator_compareTo) {
    CBMFileResult *r = extract_kotlin("class Version(val n: Int) {\n"
                                      "    operator fun compareTo(o: Version): Int = n - o.n\n"
                                      "}\n"
                                      "fun cmp(a: Version, b: Version): Boolean = a < b\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "cmp", "compareTo"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_operator_in_contains) {
    CBMFileResult *r = extract_kotlin("class Bag(val items: List<String>) {\n"
                                      "    operator fun contains(s: String): Boolean = items.contains(s)\n"
                                      "}\n"
                                      "fun has(b: Bag): Boolean = \"x\" in b\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "has", "contains"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_operator_get) {
    CBMFileResult *r = extract_kotlin("class Cache {\n"
                                      "    operator fun get(key: String): Int = 0\n"
                                      "}\n"
                                      "fun lookup(c: Cache): Int = c[\"k\"]\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "lookup", "get"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_operator_unary) {
    CBMFileResult *r = extract_kotlin("class Vec(val x: Int) {\n"
                                      "    operator fun unaryMinus(): Vec = Vec(-x)\n"
                                      "}\n"
                                      "fun negate(v: Vec): Vec = -v\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "negate", "unaryMinus"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_operator_int_plus) {
    /* Builtin Int.plus dispatch via stdlib method_names. */
    CBMFileResult *r = extract_kotlin("fun add(a: Int, b: Int): Int = a + b\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "add", "plus"), 0);
    cbm_free_result(r);
    PASS();
}

#if defined(CBM_KOTLIN_DEDUP_TEST_API) && CBM_KOTLIN_DEDUP_TEST_API
TEST(ktlsp_operator_dedup_comparison_growth_is_linear) {
    /* Each distinct operator site appends one exact-span carrier.  Comparing a
     * new site with every carrier already emitted costs at least
     * N*(N-1)/2 comparisons: 18,336 at N=192.  A constant-work dedup check
     * (the duplicate wrapper, when present, is adjacent) stays near N.  Count
     * operations instead of elapsed time so this guard is deterministic under
     * sanitizers, emulation, and loaded CI hosts. */
    enum { OPERATOR_SITE_COUNT = 192, SOURCE_CAPACITY = 32768 };
    char source[SOURCE_CAPACITY];
    size_t used = 0;
    int written = snprintf(source, sizeof(source),
                           "class Token {\n"
                           "    operator fun plus(other: Token): Token = this\n"
                           "}\n"
                           "fun exercise(a: Token, b: Token) {\n");
    ASSERT_GT(written, 0);
    used = (size_t)written;

    for (int i = 0; i < OPERATOR_SITE_COUNT; i++) {
        written = snprintf(source + used, sizeof(source) - used, "    val r%03d = a + b\n", i);
        ASSERT_GT(written, 0);
        ASSERT_LT((size_t)written, sizeof(source) - used);
        used += (size_t)written;
    }
    written = snprintf(source + used, sizeof(source) - used, "}\n");
    ASSERT_GT(written, 0);
    ASSERT_LT((size_t)written, sizeof(source) - used);

    cbm_kotlin_operator_dedup_test_reset();
    CBMFileResult *r = extract_kotlin(source);
    ASSERT_NOT_NULL(r);
    ASSERT_EQ(count_synthetic_call(r, "plus"), OPERATOR_SITE_COUNT);

    uint64_t comparisons = cbm_kotlin_operator_dedup_test_comparisons();
    uint64_t linear_budget = (uint64_t)OPERATOR_SITE_COUNT * 8U;
    printf("    Kotlin operator dedup: %" PRIu64 " comparisons for %d sites "
           "(linear budget %" PRIu64 ")\n",
           comparisons, OPERATOR_SITE_COUNT, linear_budget);
    cbm_free_result(r);
    ASSERT_LTE(comparisons, linear_budget);
    PASS();
}
#endif

/* ── 27. Iterator protocol ──────────────────────────────────── */

TEST(ktlsp_for_iterator_protocol) {
    /* `for (x in xs)` should emit iterator/hasNext/next */
    CBMFileResult *r = extract_kotlin("fun walk(xs: List<Int>) {\n"
                                      "    for (x in xs) { println(x) }\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "walk", "iterator"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_for_range_iterator) {
    CBMFileResult *r = extract_kotlin("fun count() {\n"
                                      "    for (i in 1..10) { println(i) }\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    /* The for loop should emit println at minimum; iterator protocol is
     * a bonus when range type is detected. */
    ASSERT_GTE(require_resolved(r, "count", "println"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 28. Destructuring ──────────────────────────────────────── */

TEST(ktlsp_destructuring_pair) {
    CBMFileResult *r = extract_kotlin("fun unpack(p: Pair<String, Int>): String {\n"
                                      "    val (a, b) = p\n"
                                      "    return a\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    /* Destructuring should emit component1 and component2 calls. */
    ASSERT_GTE(require_resolved(r, "unpack", "component1"), 0);
    ASSERT_GTE(require_resolved(r, "unpack", "component2"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_destructuring_data_class) {
    CBMFileResult *r = extract_kotlin("data class Point(val x: Int, val y: Int)\n"
                                      "fun split(p: Point): Int {\n"
                                      "    val (xx, yy) = p\n"
                                      "    return xx + yy\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    /* For data classes, componentN is auto-generated; we don't track that
     * explicitly, but we still want the call to attempt to emit. */
    cbm_free_result(r);
    PASS();
}

/* ── 29. Property delegation ───────────────────────────────── */

TEST(ktlsp_property_delegation_lazy) {
    CBMFileResult *r = extract_kotlin("class Service {\n"
                                      "    val expensive: String by lazy { computeIt() }\n"
                                      "    fun computeIt(): String = \"x\"\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    /* Should emit at least the lazy() top-level call. getValue support
     * comes from KT_LAZY_METHODS. */
    int n_lazy = count_resolved(r, "expensive", "lazy");
    int n_get = count_resolved(r, "expensive", "getValue");
    ASSERT_TRUE(n_lazy + n_get >= 1);
    cbm_free_result(r);
    PASS();
}

/* Access-level delegated-property contract. */

TEST(ktlsp_property_delegate_declaration_emits_no_access_operator) {
    static const char source[] =
        "import kotlin.reflect.KProperty\n"
        "class Slot {\n"
        "    operator fun getValue(thisRef: Any?, property: KProperty<*>): Int = 1\n"
        "    operator fun setValue(thisRef: Any?, property: KProperty<*>, next: Int) {}\n"
        "}\n"
        "class Holder {\n"
        "    var value: Int by Slot()\n"
        "}\n";
    CBMFileResult *r = extract_kotlin(source);
    ASSERT_NOT_NULL(r);
    /* Declaring a delegated property selects its operators but does not invoke
     * either one. Access edges belong exclusively to source read/write sites. */
    ASSERT_EQ(count_resolved(r, "", "getValue"), 0);
    ASSERT_EQ(count_resolved(r, "", "setValue"), 0);
    ASSERT_EQ(count_synthetic_call(r, "getValue"), 0);
    ASSERT_EQ(count_synthetic_call(r, "setValue"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_property_delegate_read_emits_exact_get_only) {
    static const char source[] =
        "import kotlin.reflect.KProperty\n"
        "class Slot {\n"
        "    operator fun getValue(thisRef: Any?, property: KProperty<*>): Int = 1\n"
        "    operator fun setValue(thisRef: Any?, property: KProperty<*>, next: Int) {}\n"
        "}\n"
        "class Holder {\n"
        "    var value: Int by Slot()\n"
        "    fun read(): Int = value\n"
        "}\n";
    CBMFileResult *r = extract_kotlin(source);
    ASSERT_NOT_NULL(r);
    const char *access = strstr(source, "fun read(): Int = value");
    ASSERT_NOT_NULL(access);
    uint32_t start = (uint32_t)(access - source) + (uint32_t)strlen("fun read(): Int = ");
    uint32_t end = start + (uint32_t)strlen("value");
    ASSERT_EQ(count_exact_resolved_site(r, "read", "getValue", start, end), 1);
    ASSERT_EQ(count_exact_resolved_site(r, "read", "setValue", start, end), 0);
    ASSERT_EQ(count_exact_synthetic_call(r, "read", "getValue", start, end), 1);
    ASSERT_EQ(count_exact_synthetic_call(r, "read", "setValue", start, end), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_property_delegate_write_emits_exact_set_only) {
    static const char source[] =
        "import kotlin.reflect.KProperty\n"
        "class Slot {\n"
        "    operator fun getValue(thisRef: Any?, property: KProperty<*>): Int = 1\n"
        "    operator fun setValue(thisRef: Any?, property: KProperty<*>, next: Int) {}\n"
        "}\n"
        "class Holder {\n"
        "    var value: Int by Slot()\n"
        "    fun write() { value = 2 }\n"
        "}\n";
    CBMFileResult *r = extract_kotlin(source);
    ASSERT_NOT_NULL(r);
    const char *access = strstr(source, "value = 2");
    ASSERT_NOT_NULL(access);
    uint32_t start = (uint32_t)(access - source);
    uint32_t end = start + (uint32_t)strlen("value");
    ASSERT_EQ(count_exact_resolved_site(r, "write", "getValue", start, end), 0);
    ASSERT_EQ(count_exact_resolved_site(r, "write", "setValue", start, end), 1);
    ASSERT_EQ(count_exact_synthetic_call(r, "write", "getValue", start, end), 0);
    ASSERT_EQ(count_exact_synthetic_call(r, "write", "setValue", start, end), 1);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_property_delegate_compound_write_emits_get_and_set) {
    static const char source[] =
        "import kotlin.reflect.KProperty\n"
        "class Slot {\n"
        "    operator fun getValue(thisRef: Any?, property: KProperty<*>): Int = 1\n"
        "    operator fun setValue(thisRef: Any?, property: KProperty<*>, next: Int) {}\n"
        "}\n"
        "class Holder {\n"
        "    var value: Int by Slot()\n"
        "    fun increment() { value += 2 }\n"
        "}\n";
    CBMFileResult *r = extract_kotlin(source);
    ASSERT_NOT_NULL(r);
    const char *access = strstr(source, "value += 2");
    ASSERT_NOT_NULL(access);
    uint32_t start = (uint32_t)(access - source);
    uint32_t end = start + (uint32_t)strlen("value");
    /* Compound assignment is read-modify-write in Kotlin, so both operators
     * are real access-level calls at the same source occurrence. */
    ASSERT_EQ(count_exact_resolved_site(r, "increment", "getValue", start, end), 1);
    ASSERT_EQ(count_exact_resolved_site(r, "increment", "setValue", start, end), 1);
    ASSERT_EQ(count_exact_synthetic_call(r, "increment", "getValue", start, end), 1);
    ASSERT_EQ(count_exact_synthetic_call(r, "increment", "setValue", start, end), 1);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_local_shadow_does_not_inherit_member_delegate) {
    static const char source[] =
        "import kotlin.reflect.KProperty\n"
        "class Slot {\n"
        "    operator fun getValue(thisRef: Any?, property: KProperty<*>): Int = 1\n"
        "    operator fun setValue(thisRef: Any?, property: KProperty<*>, next: Int) {}\n"
        "}\n"
        "class Holder {\n"
        "    var value: Int by Slot()\n"
        "    fun memberRead(): Int = value\n"
        "    fun localRead(): Int {\n"
        "        val value: Int = 7\n"
        "        return value\n"
        "    }\n"
        "}\n";
    CBMFileResult *r = extract_kotlin(source);
    ASSERT_NOT_NULL(r);

    const char *member = strstr(source, "fun memberRead(): Int = value");
    ASSERT_NOT_NULL(member);
    uint32_t member_start =
        (uint32_t)(member - source) + (uint32_t)strlen("fun memberRead(): Int = ");
    uint32_t member_end = member_start + (uint32_t)strlen("value");
    ASSERT_EQ(count_exact_resolved_site(r, "memberRead", "getValue", member_start, member_end), 1);

    const char *local = strstr(source, "return value");
    ASSERT_NOT_NULL(local);
    uint32_t local_start = (uint32_t)(local - source) + (uint32_t)strlen("return ");
    uint32_t local_end = local_start + (uint32_t)strlen("value");
    ASSERT_EQ(count_exact_resolved_site(r, "localRead", "getValue", local_start, local_end), 0);
    ASSERT_EQ(count_exact_resolved_site(r, "localRead", "setValue", local_start, local_end), 0);
    ASSERT_EQ(count_exact_synthetic_call(r, "localRead", "getValue", local_start, local_end), 0);
    ASSERT_EQ(count_exact_synthetic_call(r, "localRead", "setValue", local_start, local_end), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 30. String template / interpolation ───────────────────── */

TEST(ktlsp_string_interpolation) {
    /* String templates with $expr internally call toString. We don't
     * desugar this, but at minimum the inner expression should be
     * evaluated for any embedded calls. */
    CBMFileResult *r = extract_kotlin("class Item { fun label(): String = \"x\" }\n"
                                      "fun show(item: Item): String = \"Got: ${item.label()}\"\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "show", "label"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 31. Range / progression operations ────────────────────── */

TEST(ktlsp_range_rangeTo) {
    /* `1..10` desugars to `1.rangeTo(10)`. */
    CBMFileResult *r = extract_kotlin("fun mkRange(): IntRange = 1..10\n");
    ASSERT_NOT_NULL(r);
    /* Best-effort — if rangeTo is in stdlib method_names for Int, emit. */
    cbm_free_result(r);
    PASS();
}

/* ── 32. Inline function lambda body attribution ───────────── */

TEST(ktlsp_inline_lambda_body_to_caller) {
    /* For inline functions, the lambda body conceptually expands into the
     * caller. Our walker already attributes calls inside trailing lambdas
     * to the OUTER caller (we don't change enclosing_func_qn when entering
     * the lambda). This matches the LSP's effective output. */
    CBMFileResult *r =
        extract_kotlin("inline fun retry(block: () -> Unit) { block() }\n"
                       "fun main() {\n"
                       "    retry {\n"
                       "        println(\"hi\")\n"
                       "    }\n"
                       "}\n");
    ASSERT_NOT_NULL(r);
    /* main → retry edge */
    ASSERT_GTE(require_resolved(r, "main", "retry"), 0);
    /* Inline expansion: println should be attributed to main (the outer
     * caller), not to retry. */
    ASSERT_GTE(require_resolved(r, "main", "println"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_inline_run_block) {
    /* `run { ... }` is a stdlib inline function. Inside the block, calls
     * should be attributed to the enclosing function. */
    CBMFileResult *r =
        extract_kotlin("class Logger { fun log(msg: String) {} }\n"
                       "fun setup(l: Logger) {\n"
                       "    run {\n"
                       "        l.log(\"started\")\n"
                       "    }\n"
                       "}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "setup", "log"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 33. Reified generics ───────────────────────────────────── */

TEST(ktlsp_reified_class_literal) {
    /* `T::class` inside reified inline functions doesn't crash; we treat
     * it as a class-literal and don't emit a call edge for it. The
     * function and its callers should still resolve normally. */
    CBMFileResult *r =
        extract_kotlin("inline fun <reified T> typeName(): String = T::class.toString()\n"
                       "fun main(): String = typeName<String>()\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(require_resolved(r, "main", "typeName"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_reified_doesnt_crash) {
    /* Reified inline functions with `<reified T>` declaration parse and
     * their bodies/calls resolve. The call site uses explicit type
     * arguments which the grammar accepts via the standard
     * `simple_user_type` syntax; we don't track T-substitution but we do
     * emit the function call edge. */
    CBMFileResult *r = extract_kotlin(
        "inline fun <reified T> classify(x: Any): Boolean = x is T\n"
        "fun pickFirst(): Boolean = classify<String>(\"hi\")\n"
        "fun pickSecond(): Boolean = classify<Int>(42)\n");
    ASSERT_NOT_NULL(r);
    /* The grammar may not produce a clean call_expression for explicit-
     * generic calls; accept either a direct hit OR no crash. The test
     * documents the limitation. */
    cbm_free_result(r);
    PASS();
}

/* ── 34. Callable references ────────────────────────────────── */

TEST(ktlsp_callable_ref_top_level) {
    /* `::topLevelFn` references a top-level function. */
    CBMFileResult *r = extract_kotlin("fun helper(x: Int): Int = x + 1\n"
                                      "fun main() {\n"
                                      "    val ref = ::helper\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    /* Should emit a callable-ref edge. */
    int idx = find_resolved(r, "main", "helper");
    ASSERT_GTE(idx, 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_callable_ref_method) {
    /* `Foo::method` references a class method. */
    CBMFileResult *r = extract_kotlin("class Service { fun run() {} }\n"
                                      "fun main() {\n"
                                      "    val ref = Service::run\n"
                                      "}\n");
    ASSERT_NOT_NULL(r);
    int idx = find_resolved(r, "main", "run");
    ASSERT_GTE(idx, 0);
    cbm_free_result(r);
    PASS();
}

TEST(ktlsp_callable_ref_class_literal) {
    /* `Foo::class` produces a KClass — should not emit a method-call edge
     * but should not crash. */
    CBMFileResult *r =
        extract_kotlin("class Service\n"
                       "fun main() {\n"
                       "    val k = Service::class\n"
                       "}\n");
    ASSERT_NOT_NULL(r);
    /* Specifically NO call edge for `class` since it's a literal. */
    cbm_free_result(r);
    PASS();
}

/* ── suite registration ────────────────────────────────────── */

SUITE(kotlin_lsp) {
    RUN_TEST(ktlsp_package_set);
    RUN_TEST(ktlsp_explicit_import_function);
    RUN_TEST(ktlsp_explicit_import_type);
    RUN_TEST(ktlsp_import_alias);
    RUN_TEST(ktlsp_wildcard_import);
    RUN_TEST(ktlsp_top_level_call_default_imports);
    RUN_TEST(ktlsp_top_level_listof);
    RUN_TEST(ktlsp_top_level_setof_mapof);
    RUN_TEST(ktlsp_intra_file_top_level);
    RUN_TEST(ktlsp_class_constructor);
    RUN_TEST(ktlsp_data_class);
    RUN_TEST(ktlsp_secondary_constructor);
    RUN_TEST(ktlsp_method_on_known_type);
    RUN_TEST(ktlsp_method_chain);
    RUN_TEST(ktlsp_string_method_dispatch);
    RUN_TEST(ktlsp_list_method_dispatch);
    RUN_TEST(ktlsp_companion_object_call);
    RUN_TEST(ktlsp_object_singleton);
    RUN_TEST(ktlsp_extension_function);
    RUN_TEST(ktlsp_extension_method_on_list);
    RUN_TEST(ktlsp_super_call);
    RUN_TEST(ktlsp_interface_dispatch);
    RUN_TEST(ktlsp_smartcast_is);
    RUN_TEST(ktlsp_smartcast_as);
    RUN_TEST(ktlsp_when_smartcast);
    RUN_TEST(ktlsp_safe_call);
    RUN_TEST(ktlsp_not_null_assertion);
    RUN_TEST(ktlsp_lambda_it_string);
    RUN_TEST(ktlsp_lambda_it_object);
    RUN_TEST(ktlsp_scope_let);
    RUN_TEST(ktlsp_scope_apply);
    RUN_TEST(ktlsp_typealias);
    RUN_TEST(ktlsp_enum_class);
    RUN_TEST(ktlsp_sealed_when);
    RUN_TEST(ktlsp_generic_call);
    RUN_TEST(ktlsp_stdlib_println);
    RUN_TEST(ktlsp_stdlib_collection_builders);
    RUN_TEST(ktlsp_stdlib_require_check);
    RUN_TEST(ktlsp_stdlib_string_chain);
    RUN_TEST(ktlsp_stdlib_collection_pipe);
    RUN_TEST(ktlsp_constructor_param_property);
    RUN_TEST(ktlsp_local_function);
    RUN_TEST(ktlsp_factory_pattern);
    RUN_TEST(ktlsp_resolves_more_than_textual);
    RUN_TEST(ktlsp_empty_file);
    RUN_TEST(ktlsp_only_package);
    RUN_TEST(ktlsp_only_imports);
    RUN_TEST(ktlsp_kts_script);
    RUN_TEST(ktlsp_unknown_external_unresolved);
    RUN_TEST(ktlsp_ordinary_same_leaf_calls_join_by_exact_site);
    RUN_TEST(ktlsp_no_duplicate_emission);
    RUN_TEST(ktlsp_constructor_high_confidence);
    RUN_TEST(ktlsp_method_high_confidence);
    RUN_TEST(ktlsp_real_world_repository_pattern);
    RUN_TEST(ktlsp_real_world_builder);
    RUN_TEST(ktlsp_real_world_dsl);
    RUN_TEST(ktlsp_malformed_recovery);
    RUN_TEST(ktlsp_unicode_identifier);
    RUN_TEST(ktlsp_long_chain);
    /* Operator conventions */
    RUN_TEST(ktlsp_operator_plus);
    RUN_TEST(ktlsp_operator_compareTo);
    RUN_TEST(ktlsp_operator_in_contains);
    RUN_TEST(ktlsp_operator_get);
    RUN_TEST(ktlsp_operator_unary);
    RUN_TEST(ktlsp_operator_int_plus);
#if defined(CBM_KOTLIN_DEDUP_TEST_API) && CBM_KOTLIN_DEDUP_TEST_API
    RUN_TEST(ktlsp_operator_dedup_comparison_growth_is_linear);
#endif
    /* Iterator protocol */
    RUN_TEST(ktlsp_for_iterator_protocol);
    RUN_TEST(ktlsp_for_range_iterator);
    /* Destructuring */
    RUN_TEST(ktlsp_destructuring_pair);
    RUN_TEST(ktlsp_destructuring_data_class);
    /* Property delegation */
    RUN_TEST(ktlsp_property_delegation_lazy);
    RUN_TEST(ktlsp_property_delegate_declaration_emits_no_access_operator);
    RUN_TEST(ktlsp_property_delegate_read_emits_exact_get_only);
    RUN_TEST(ktlsp_property_delegate_write_emits_exact_set_only);
    RUN_TEST(ktlsp_property_delegate_compound_write_emits_get_and_set);
    RUN_TEST(ktlsp_local_shadow_does_not_inherit_member_delegate);
    /* String interpolation */
    RUN_TEST(ktlsp_string_interpolation);
    /* Range */
    RUN_TEST(ktlsp_range_rangeTo);
    /* Inline expansion */
    RUN_TEST(ktlsp_inline_lambda_body_to_caller);
    RUN_TEST(ktlsp_inline_run_block);
    /* Reified generics */
    RUN_TEST(ktlsp_reified_class_literal);
    RUN_TEST(ktlsp_reified_doesnt_crash);
    /* Callable references */
    RUN_TEST(ktlsp_callable_ref_top_level);
    RUN_TEST(ktlsp_callable_ref_method);
    RUN_TEST(ktlsp_callable_ref_class_literal);
}