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.

171 KB
Raw Blame
/*
 * cs_lsp.c — C# Light Semantic Pass.
 *
 * Reverse-engineered from Roslyn (dotnet/roslyn). Roslyn's resolution
 * pipeline is built on a chain of `Binder` objects representing lexical
 * scopes (namespace, type, member, block). LookupSymbolsInternal walks
 * the chain inside-out and merges results. We model the same chain with
 * a CBMScope stack plus a CSLSPContext that tracks type/namespace/using
 * state that does not naturally live in the value scope.
 *
 * Resolution order for a bare identifier `X` inside member `M` in type
 * `T` in namespace `N`:
 *
 *    1. local variables / parameters in the current block          (CBMScope)
 *    2. type members of T (and base types, transitively)           (registry)
 *    3. type members of any enclosing-type chain                   (registry)
 *    4. members of N, then enclosing namespaces outward            (registry)
 *    5. types/aliases in `using` directives (in declaration order) (CSUsing)
 *    6. static members imported by `using static`                  (CSUsing)
 *    7. extension methods imported by `using` directives           (registry)
 *
 * All lookups eventually short-circuit to a registry.
 *
 * tree-sitter-c-sharp grammar reference (relevant node kinds):
 *   compilation_unit, namespace_declaration, file_scoped_namespace_declaration,
 *   using_directive, class_declaration, struct_declaration, record_declaration,
 *   interface_declaration, enum_declaration, base_list, type_parameter_list,
 *   method_declaration, constructor_declaration, property_declaration,
 *   indexer_declaration, field_declaration, event_declaration,
 *   parameter_list, parameter, type_parameter_constraints_clause,
 *   block, local_declaration_statement, variable_declaration,
 *   variable_declarator, expression_statement, return_statement,
 *   if_statement, switch_statement, for_statement, foreach_statement,
 *   identifier, qualified_name, generic_name, member_access_expression,
 *   invocation_expression, object_creation_expression, anonymous_object_creation_expression,
 *   implicit_object_creation_expression, lambda_expression, conditional_expression,
 *   tuple_expression, await_expression, cast_expression, as_expression,
 *   is_expression, predefined_type, nullable_type, array_type, pointer_type,
 *   tuple_type, function_pointer_type.
 */

#include "cs_lsp.h"
#include "lsp_node_iter.h"
#include "../helpers.h"
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define CS_EVAL_MAX_DEPTH 64
#define CS_USING_INITIAL_CAP 16
#define CS_NAMESPACE_INITIAL_CAP 8
#define CS_LSP_PARENT_WALK_MAX 32
/* Nested-type qualifier walk depth: one level per type nesting step of `A.B.C`
 * (a namespace-qualified top-level type binds without recursing), so 8 covers
 * real nesting while a cyclic alias such as `using A = A.B;` stops after 8. */
#define CS_QUALIFIER_MAX_DEPTH 8

extern const TSLanguage *tree_sitter_c_sharp(void);

/* ── forward decls ──────────────────────────────────────────────── */

static void cs_resolve_calls_in_node(CSLSPContext *ctx, TSNode node);
static void cs_process_function_like(CSLSPContext *ctx, TSNode node);
static void cs_process_type_decl(CSLSPContext *ctx, TSNode node);
static const CBMType *cs_eval_invocation_type(CSLSPContext *ctx, TSNode call);
static const CBMType *cs_eval_member_access_type(CSLSPContext *ctx, TSNode node);
static const CBMType *cs_eval_object_creation_type(CSLSPContext *ctx, TSNode node);
static const CBMType *cs_eval_identifier_type(CSLSPContext *ctx, TSNode node);
static const CBMType *cs_substitute_type_params(CBMArena *arena, const CBMType *t,
                                                const char **param_names,
                                                const CBMType **param_args);
static void cs_collect_imports(CSLSPContext *ctx, TSNode root);
static void cs_collect_namespace(CSLSPContext *ctx, TSNode ns_node, bool file_scoped);
static const char *cs_namespace_qn(CSLSPContext *ctx);
static void cs_register_type_decls(CSLSPContext *ctx, CBMTypeRegistry *reg, TSNode root);
static char *cs_node_text_cached(CSLSPContext *ctx, TSNode node);
static const CBMType *cs_unwrap_task(CSLSPContext *ctx, const CBMType *t);
static const CBMType *cs_unwrap_nullable(const CBMType *t);
static const char *cs_resolve_callable_value(CSLSPContext *ctx, TSNode node, TSNode *callable_leaf);
static const char *cs_top_level_namespace(const char *type_qn, const char *short_name,
                                          const char *module_qn, const char *namespace_name);

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

static char *cs_node_text(CSLSPContext *ctx, TSNode node) {
    return cbm_node_text(ctx->arena, node, ctx->source);
}

static char *cs_node_text_cached(CSLSPContext *ctx, TSNode node) {
    return cs_node_text(ctx, node);
}

static bool cs_node_is(TSNode n, const char *kind) {
    if (ts_node_is_null(n))
        return false;
    return strcmp(ts_node_type(n), kind) == 0;
}

static TSNode cs_child_named_kind(TSNode parent, const char *kind) {
    if (ts_node_is_null(parent))
        return parent;
    uint32_t nc = ts_node_child_count(parent);
    for (uint32_t i = 0; i < nc; i++) {
        TSNode c = ts_node_child(parent, i);
        if (!ts_node_is_null(c) && strcmp(ts_node_type(c), kind) == 0)
            return c;
    }
    TSNode null_node;
    memset(&null_node, 0, sizeof(null_node));
    return null_node;
}

static TSNode cs_first_named_child(TSNode parent) {
    if (ts_node_is_null(parent))
        return parent;
    uint32_t nc = ts_node_child_count(parent);
    for (uint32_t i = 0; i < nc; i++) {
        TSNode c = ts_node_child(parent, i);
        if (!ts_node_is_null(c) && ts_node_is_named(c))
            return c;
    }
    TSNode null_node;
    memset(&null_node, 0, sizeof(null_node));
    return null_node;
}

/* Last segment after '.'. */
static const char *cs_short_name(const char *qn) {
    if (!qn)
        return NULL;
    const char *last = qn;
    for (const char *p = qn; *p; p++) {
        if (*p == '.')
            last = p + 1;
    }
    return last;
}

/* C# uses '.' separators natively; no conversion needed for identifiers.
 * Strip leading "global::" / "::" if present. */
static const char *cs_strip_global(const char *name) {
    if (!name)
        return name;
    if (strncmp(name, "global::", 8) == 0)
        return name + 8;
    if (strncmp(name, "::", 2) == 0)
        return name + 2;
    return name;
}

static char *cs_normalize_name(CBMArena *a, const char *name) {
    if (!name)
        return NULL;
    name = cs_strip_global(name);
    /* Replace "::" with "." (C# scope qualifier in source forms like
     * `global::System.Foo` becomes `System.Foo`). */
    size_t n = strlen(name);
    char *out = (char *)cbm_arena_alloc(a, n + 1);
    if (!out)
        return NULL;
    size_t w = 0;
    for (size_t i = 0; i < n; i++) {
        if (name[i] == ':' && i + 1 < n && name[i + 1] == ':') {
            out[w++] = '.';
            i++;
            continue;
        }
        out[w++] = name[i];
    }
    out[w] = '\0';
    return out;
}

/* Walk up from `name` past any leading '<' or whitespace. */
static char *cs_strip_generic_args(CBMArena *a, const char *name) {
    if (!name)
        return NULL;
    const char *lt = strchr(name, '<');
    if (!lt)
        return cbm_arena_strdup(a, name);
    size_t len = (size_t)(lt - name);
    return cbm_arena_strndup(a, name, len);
}

/* Predefined C# type aliases: int → System.Int32, etc. */
static const char *cs_predefined_alias(const char *name) {
    if (!name)
        return NULL;
    /* Roslyn predefined-type list: Binder_Symbols.cs BindPredefinedTypeSymbol */
    if (strcmp(name, "int") == 0)
        return "System.Int32";
    if (strcmp(name, "uint") == 0)
        return "System.UInt32";
    if (strcmp(name, "long") == 0)
        return "System.Int64";
    if (strcmp(name, "ulong") == 0)
        return "System.UInt64";
    if (strcmp(name, "short") == 0)
        return "System.Int16";
    if (strcmp(name, "ushort") == 0)
        return "System.UInt16";
    if (strcmp(name, "byte") == 0)
        return "System.Byte";
    if (strcmp(name, "sbyte") == 0)
        return "System.SByte";
    if (strcmp(name, "float") == 0)
        return "System.Single";
    if (strcmp(name, "double") == 0)
        return "System.Double";
    if (strcmp(name, "decimal") == 0)
        return "System.Decimal";
    if (strcmp(name, "bool") == 0)
        return "System.Boolean";
    if (strcmp(name, "char") == 0)
        return "System.Char";
    if (strcmp(name, "string") == 0)
        return "System.String";
    if (strcmp(name, "object") == 0)
        return "System.Object";
    if (strcmp(name, "nint") == 0)
        return "System.IntPtr";
    if (strcmp(name, "nuint") == 0)
        return "System.UIntPtr";
    if (strcmp(name, "void") == 0)
        return "System.Void";
    if (strcmp(name, "dynamic") == 0)
        return "System.Object"; /* dynamic ≈ object */
    return NULL;
}

static bool cs_is_keyword_self(const char *name) {
    if (!name)
        return false;
    return strcmp(name, "this") == 0 || strcmp(name, "base") == 0;
}

/* ── init ───────────────────────────────────────────────────────── */

void cs_lsp_init(CSLSPContext *ctx, CBMArena *arena, const char *source, int source_len,
                 const CBMTypeRegistry *registry, const char *module_qn,
                 CBMResolvedCallArray *out) {
    memset(ctx, 0, sizeof(*ctx));
    ctx->arena = arena;
    ctx->source = source;
    ctx->source_len = source_len;
    ctx->registry = registry;
    ctx->module_qn = module_qn;
    ctx->resolved_calls = out;
    ctx->current_scope = cbm_scope_push(arena, NULL);

    /* Implicit `using System;` — C# always brings in System. We pretend
     * Program.cs has it explicitly so primitive aliases and System.Console
     * resolve out of the box. The real LSP picks this up from the project
     * file's <ImplicitUsings>; we just always include it. */
    cs_lsp_add_using(ctx, CBM_CS_USING_NAMESPACE, "", "System", false);

    const char *dbg = getenv("CBM_LSP_DEBUG");
    ctx->debug = (dbg && dbg[0]);
}

/* ── using management ───────────────────────────────────────────── */

/* Append a using directive; `in_namespace` marks one declared inside a
 * namespace body (CBMCSUsing.in_namespace). */
static void cs_add_using_scoped(CSLSPContext *ctx, CBMCSUsingKind kind, const char *local_name,
                                const char *target_qn, bool is_global, bool in_namespace) {
    if (!target_qn)
        return;
    /* Dedupe by (kind, local_name, target). The cross-file entry pre-loads
     * the pipeline's import list without placement; the AST walk then finds
     * the same directive and is the authority on where it was declared. */
    for (int i = 0; i < ctx->using_count; i++) {
        CBMCSUsing *u = &ctx->usings[i];
        if (u->kind != kind)
            continue;
        if (strcmp(u->target_qn, target_qn) != 0)
            continue;
        const char *a = local_name ? local_name : "";
        const char *b = u->local_name ? u->local_name : "";
        if (strcmp(a, b) != 0)
            continue;
        u->in_namespace = u->in_namespace || in_namespace;
        return;
    }
    if (ctx->using_count >= ctx->using_cap) {
        int new_cap = ctx->using_cap ? ctx->using_cap * 2 : CS_USING_INITIAL_CAP;
        CBMCSUsing *nu = (CBMCSUsing *)cbm_arena_alloc(ctx->arena, (size_t)new_cap * sizeof(*nu));
        if (!nu)
            return;
        for (int i = 0; i < ctx->using_count; i++)
            nu[i] = ctx->usings[i];
        ctx->usings = nu;
        ctx->using_cap = new_cap;
    }
    CBMCSUsing *slot = &ctx->usings[ctx->using_count++];
    slot->kind = kind;
    slot->local_name = local_name ? cbm_arena_strdup(ctx->arena, local_name) : "";
    slot->target_qn = cbm_arena_strdup(ctx->arena, target_qn);
    slot->is_global = is_global;
    slot->in_namespace = in_namespace;
}

void cs_lsp_add_using(CSLSPContext *ctx, CBMCSUsingKind kind, const char *local_name,
                      const char *target_qn, bool is_global) {
    cs_add_using_scoped(ctx, kind, local_name, target_qn, is_global, false);
}

/* ── namespace stack ────────────────────────────────────────────── */

static void cs_namespace_push(CSLSPContext *ctx, const char *ns_name) {
    if (!ns_name || !*ns_name)
        return;
    if (ctx->namespace_count >= ctx->namespace_cap) {
        int new_cap = ctx->namespace_cap ? ctx->namespace_cap * 2 : CS_NAMESPACE_INITIAL_CAP;
        const char **arr =
            (const char **)cbm_arena_alloc(ctx->arena, (size_t)new_cap * sizeof(*arr));
        if (!arr)
            return;
        for (int i = 0; i < ctx->namespace_count; i++)
            arr[i] = ctx->namespace_stack[i];
        ctx->namespace_stack = arr;
        ctx->namespace_cap = new_cap;
    }
    ctx->namespace_stack[ctx->namespace_count++] = cbm_arena_strdup(ctx->arena, ns_name);
}

static void cs_namespace_pop(CSLSPContext *ctx) {
    if (ctx->namespace_count > 0)
        ctx->namespace_count--;
}

/* Concatenate the namespace stack into a dotted QN (outer to inner). */
static const char *cs_namespace_qn(CSLSPContext *ctx) {
    if (ctx->namespace_count == 0)
        return "";
    /* Compute total length first. */
    size_t total = 0;
    for (int i = 0; i < ctx->namespace_count; i++) {
        total += strlen(ctx->namespace_stack[i]);
        if (i > 0)
            total += 1; /* dot */
    }
    char *out = (char *)cbm_arena_alloc(ctx->arena, total + 1);
    if (!out)
        return "";
    size_t w = 0;
    for (int i = 0; i < ctx->namespace_count; i++) {
        if (i > 0)
            out[w++] = '.';
        size_t len = strlen(ctx->namespace_stack[i]);
        memcpy(out + w, ctx->namespace_stack[i], len);
        w += len;
    }
    out[w] = '\0';
    return out;
}

/* ── type-name resolution ───────────────────────────────────────── */

static const CBMRegisteredType *cs_lookup_type_qn(CSLSPContext *ctx, const char *qn) {
    if (!ctx->registry || !qn)
        return NULL;
    return cbm_registry_lookup_type(ctx->registry, qn);
}

/* Try a candidate QN; if found, return it (interned in arena). */
static const char *cs_try_type_qn(CSLSPContext *ctx, const char *qn) {
    if (!qn)
        return NULL;
    if (cs_lookup_type_qn(ctx, qn))
        return qn;
    return NULL;
}

/* Append the file's using-namespace targets declared inside (`in_namespace`)
 * or outside a namespace body. */
static int cs_append_using_namespaces(const CSLSPContext *ctx, bool in_namespace, const char **out,
                                      int n, int cap) {
    for (int i = 0; i < ctx->using_count && n < cap; i++) {
        const CBMCSUsing *u = &ctx->usings[i];
        if (u->kind == CBM_CS_USING_NAMESPACE && u->in_namespace == in_namespace && u->target_qn &&
            u->target_qn[0])
            out[n++] = u->target_qn;
    }
    return n;
}

/* Namespaces through which `qualifier` (the part of a type reference before
 * its simple name, NULL for a simple name) can reach a top-level type, in C#
 * lookup order: each enclosing namespace innermost outward, then the global
 * namespace (qualified references only) or, for a simple name, the usings
 * of the enclosing namespace bodies, the global namespace "" and last the
 * compilation-unit usings (a using-namespace directive does not import nested
 * namespaces). C# consults the members of the global namespace BEFORE the
 * compilation unit's usings: a top-level type declared without a namespace
 * hides an imported type of the same name. Returns the count written to
 * `out` (at most `cap`). */
static int cs_visible_namespaces(CSLSPContext *ctx, const char *qualifier, const char **out,
                                 int cap) {
    int n = 0;
    const char *ns = ctx->namespace_count > 0 ? cs_namespace_qn(ctx) : NULL;
    while (ns && *ns && n < cap) {
        out[n++] = qualifier ? cbm_arena_sprintf(ctx->arena, "%s.%s", ns, qualifier) : ns;
        const char *dot = strrchr(ns, '.');
        ns = dot ? cbm_arena_strndup(ctx->arena, ns, (size_t)(dot - ns)) : NULL;
    }
    if (qualifier) {
        if (n < cap)
            out[n++] = qualifier;
        return n;
    }
    n = cs_append_using_namespaces(ctx, true, out, n, cap);
    /* The global namespace (#2120 residual: such types used to be invisible
     * to step 8b) ranks after every enclosing namespace and namespace-body
     * using, and before the compilation-unit usings. */
    if (n < cap)
        out[n++] = "";
    return cs_append_using_namespaces(ctx, false, out, n, cap);
}

/* Bind a (possibly namespace-qualified) type reference to the project type
 * whose DECLARED namespace the current file can see, preferring the earliest
 * namespace in C# lookup order; equal ranks keep registration order. NULL when
 * no top-level type with that simple name is visible (#2120). */
static const char *cs_resolve_by_declared_namespace(CSLSPContext *ctx, const char *name) {
    if (!ctx->registry || !name || !*name)
        return NULL;
    const char *simple = cs_short_name(name);
    if (!simple || !*simple)
        return NULL;
    const char *qualifier =
        simple > name ? cbm_arena_strndup(ctx->arena, name, (size_t)(simple - name - 1)) : NULL;
    enum { CS_VISIBLE_NS_MAX = 128 };
    const char *visible[CS_VISIBLE_NS_MAX];
    int visible_count = cs_visible_namespaces(ctx, qualifier, visible, CS_VISIBLE_NS_MAX);
    if (visible_count == 0)
        return NULL;

    const CBMRegisteredType *best = NULL;
    int best_rank = visible_count;
    CBMTypeShortIter it;
    cbm_registry_types_by_short_name_chain(ctx->registry, simple, &it);
    int i;
    while ((i = cbm_type_short_iter_next(&it)) >= 0) {
        const CBMRegisteredType *cand = &it.reg->types[i];
        if (!cand->namespace_qn || !cand->short_name || strcmp(cand->short_name, simple) != 0)
            continue;
        for (int r = 0; r < best_rank; r++) {
            if (strcmp(cand->namespace_qn, visible[r]) == 0) {
                best = cand;
                best_rank = r;
                break;
            }
        }
    }
    /* No namespace-qualified hit: a qualified `A.B` may name a NESTED type —
     * A a type in scope (resolved recursively, one segment shorter), B a
     * member type of it. Nested QNs are the parent QN plus the simple name,
     * which step 8b's namespace scan can never produce because nested types
     * carry no namespace_qn (#2120 residual: `new Command.Result(...)`,
     * `new Grain.Handler(dep).Handle(...)`). The walk is depth-bounded: an
     * alias whose target names the alias itself (`using A = A.B;`, or a
     * mutual pair) re-enters this path through step 8 with no end. */
    if (!best && qualifier && ctx->qualifier_depth < CS_QUALIFIER_MAX_DEPTH) {
        ctx->qualifier_depth++;
        const char *qtype = cs_resolve_type_name(ctx, qualifier);
        ctx->qualifier_depth--;
        if (qtype) {
            const char *nested = cbm_arena_sprintf(ctx->arena, "%s.%s", qtype, simple);
            if (cs_lookup_type_qn(ctx, nested))
                return nested;
        }
    }
    return best ? best->qualified_name : NULL;
}

/* Returns a fully-qualified type name resolved against:
 *   1. predefined alias (int -> System.Int32)
 *   2. type-parameter substitution map
 *   3. exact registry hit
 *   4. nested type / current type (for unqualified inside-class refs)
 *   5. each namespace prefix from innermost outward
 *   6. module-prefixed (file-local QN that the unified extractor produced)
 *   7. each `using namespace X` prefix
 *   8. each `using A = X` alias substitution
 *   8b. declared namespace of a top-level project type (enclosing namespaces,
 *       then `using` namespaces)
 *   9. short-name fallback, then the bare name (registry miss drops the call)
 */
const char *cs_resolve_type_name(CSLSPContext *ctx, const char *raw) {
    if (!raw || !*raw)
        return NULL;
    char *name = cs_normalize_name(ctx->arena, raw);
    if (!name)
        return NULL;

    /* Strip generic args for lookup purposes; the caller can re-attach
     * a TEMPLATE wrapping. */
    char *bare = cs_strip_generic_args(ctx->arena, name);
    if (!bare)
        bare = name;

    /* 1. Predefined. */
    const char *pre = cs_predefined_alias(bare);
    if (pre)
        return pre;

    /* 2. Type-parameter substitution. */
    for (int i = 0; i < ctx->type_param_count; i++) {
        if (strcmp(ctx->type_param_names[i], bare) == 0) {
            const CBMType *arg = ctx->type_param_args[i];
            if (arg && arg->kind == CBM_TYPE_NAMED)
                return arg->data.named.qualified_name;
            /* Builtin or unknown — fall through. */
        }
    }

    /* 3. Exact registry hit. */
    if (cs_lookup_type_qn(ctx, bare))
        return bare;

    /* 4. Inside the current class? Try enclosing class's nested type. */
    if (ctx->enclosing_class_qn) {
        const char *try_qn = cbm_arena_sprintf(ctx->arena, "%s.%s", ctx->enclosing_class_qn, bare);
        if (cs_lookup_type_qn(ctx, try_qn))
            return try_qn;
    }

    /* 5. Each namespace prefix from innermost outward. */
    if (ctx->namespace_count > 0) {
        const char *ns = cs_namespace_qn(ctx);
        for (;;) {
            if (!ns || !*ns)
                break;
            const char *try_qn = cbm_arena_sprintf(ctx->arena, "%s.%s", ns, bare);
            if (cs_lookup_type_qn(ctx, try_qn))
                return try_qn;
            const char *dot = strrchr(ns, '.');
            if (!dot)
                break;
            char *trim = cbm_arena_strndup(ctx->arena, ns, (size_t)(dot - ns));
            ns = trim;
        }
    }

    /* 6. Module-prefixed (matches what unified extractor produces for file-
     * local types). */
    if (ctx->module_qn && ctx->module_qn[0]) {
        const char *try_qn = cbm_arena_sprintf(ctx->arena, "%s.%s", ctx->module_qn, bare);
        if (cs_lookup_type_qn(ctx, try_qn))
            return try_qn;
    }

    /* 7. using namespace X — try X.bare. */
    for (int i = 0; i < ctx->using_count; i++) {
        const CBMCSUsing *u = &ctx->usings[i];
        if (u->kind != CBM_CS_USING_NAMESPACE)
            continue;
        const char *try_qn = cbm_arena_sprintf(ctx->arena, "%s.%s", u->target_qn, bare);
        if (cs_lookup_type_qn(ctx, try_qn))
            return try_qn;
    }

    /* 8. using A = X — substitute. The target may include generic args
     * (e.g. `using IL = ...List<int>`). The registry stores the bare
     * type name only, so we strip generic args before returning. */
    for (int i = 0; i < ctx->using_count; i++) {
        const CBMCSUsing *u = &ctx->usings[i];
        if (u->kind != CBM_CS_USING_ALIAS)
            continue;
        if (!u->local_name)
            continue;
        size_t alias_len = strlen(u->local_name);
        if (strncmp(bare, u->local_name, alias_len) == 0) {
            if (bare[alias_len] == '\0') {
                /* Whole name is the alias. Strip generic args from target. */
                char *target_bare = cs_strip_generic_args(ctx->arena, u->target_qn);
                if (target_bare && cs_lookup_type_qn(ctx, target_bare))
                    return target_bare;
                /* A project type is registered under its path-derived QN, so
                 * `using A = Ns.Type;` binds through the declared namespace. */
                const char *declared = cs_resolve_by_declared_namespace(ctx, target_bare);
                if (declared)
                    return declared;
                return cbm_arena_strdup(ctx->arena, u->target_qn);
            }
            if (bare[alias_len] == '.') {
                /* `Alias.Sub` -> `Target.Sub` */
                char *target_bare = cs_strip_generic_args(ctx->arena, u->target_qn);
                const char *base = target_bare ? target_bare : u->target_qn;
                const char *try_qn = cbm_arena_sprintf(ctx->arena, "%s%s", base, bare + alias_len);
                if (cs_lookup_type_qn(ctx, try_qn))
                    return try_qn;
            }
        }
    }

    /* 8b. Declared-namespace binding for project types (#2120): their QNs are
     * path-derived, so steps 5 and 7 cannot hit them; bind by the namespace
     * each top-level type declares, in C# lookup order. */
    {
        const char *declared = cs_resolve_by_declared_namespace(ctx, bare);
        if (declared)
            return declared;
    }

    /* 9. Short-name fallback: scan the registry for any type whose
     * short_name equals `bare` and whose QN shares the longest namespace
     * prefix with the file's namespace stack. This recovers cross-file
     * lookups that the namespace heuristics miss when the file's
     * `namespace` declaration doesn't line up with the directory tree. */
    {
        const char *the_short = cs_short_name(bare);
        if (the_short && *the_short) {
            const CBMRegisteredType *best = NULL;
            int best_score = -1;
            int best_idx = -1;
            const char *namespace_dotted = cs_namespace_qn(ctx);
            /* Candidates come from the type short-name index, not a scan over
             * every registered type: against the shared Tier-2 registry this
             * fallback ran per unresolved type name during BOTH the registry
             * build and per-file resolution, making each linear in the whole
             * corpus (#1669 follow-up). The iterator degrades to the same full
             * scan on an unfinalized registry, and best-score ties keep the
             * scan's first-in-registration-order winner via best_idx. */
            CBMTypeShortIter ts_it;
            int i;
            if (ctx->registry) {
                cbm_registry_types_by_short_name_chain(ctx->registry, the_short, &ts_it);
            }
            while (ctx->registry && (i = cbm_type_short_iter_next(&ts_it)) >= 0) {
                const CBMRegisteredType *cand = &ts_it.reg->types[i];
                if (!cand->short_name || strcmp(cand->short_name, the_short) != 0)
                    continue;
                int score = 0;
                if (cand->qualified_name && namespace_dotted && *namespace_dotted) {
                    const char *m = namespace_dotted;
                    const char *q = cand->qualified_name;
                    while (*m && *q && *m == *q) {
                        if (*m == '.')
                            score++;
                        m++;
                        q++;
                    }
                }
                if (score > best_score || (score == best_score && best_idx >= 0 && i < best_idx)) {
                    best_score = score;
                    best = cand;
                    best_idx = i;
                }
            }
            if (best)
                return best->qualified_name;
        }
    }

    /* 10. Last-resort: return bare so the caller can build a NAMED type even
     * if not registered. The registry-miss path simply drops the edge. */
    return bare;
}

/* Other top-level declarations of the type `t` names: same simple name, same
 * declared namespace, different entry. Registration order; at most `cap`.
 * A type in the global namespace ("") has no twins: without a namespace the
 * same name across a repository is a different type per assembly (every test
 * project's own `Program`), so pooling them would bind a member of one to an
 * unrelated other, ahead of the type's own base classes. */
static int cs_namespace_twins(CSLSPContext *ctx, const CBMRegisteredType *t,
                              const CBMRegisteredType **out, int cap) {
    if (!ctx->registry || !t || !t->namespace_qn || !t->namespace_qn[0] || !t->short_name)
        return 0;
    int n = 0;
    CBMTypeShortIter it;
    cbm_registry_types_by_short_name_chain(ctx->registry, t->short_name, &it);
    int i;
    while (n < cap && (i = cbm_type_short_iter_next(&it)) >= 0) {
        const CBMRegisteredType *c = &it.reg->types[i];
        if (!c->namespace_qn || !c->short_name || !c->qualified_name ||
            strcmp(c->short_name, t->short_name) != 0 ||
            strcmp(c->namespace_qn, t->namespace_qn) != 0 ||
            strcmp(c->qualified_name, t->qualified_name) == 0)
            continue;
        out[n++] = c;
    }
    return n;
}

/* Look up a method on a type, walking inheritance chain. */
const CBMRegisteredFunc *cs_lookup_method(CSLSPContext *ctx, const char *type_qn,
                                          const char *method_name) {
    if (!type_qn || !method_name)
        return NULL;

    const CBMRegisteredFunc *f = cbm_registry_lookup_method(ctx->registry, type_qn, method_name);
    if (f)
        return f;

    const CBMRegisteredType *t = cs_lookup_type_qn(ctx, type_qn);
    if (!t)
        return NULL;

    /* The other declarations of this same type -- `partial` pieces in other
     * files, reference-assembly copies -- are separate registry entries
     * (path-derived QNs) but one C# type: a member declared on any of them is
     * a member of this one, and so is a base declared on any of them. */
    const CBMRegisteredType *twins[CS_LSP_PARENT_WALK_MAX] = {0};
    int twin_count = cs_namespace_twins(ctx, t, twins, CS_LSP_PARENT_WALK_MAX);
    for (int k = 0; k < twin_count; k++) {
        f = cbm_registry_lookup_method(ctx->registry, twins[k]->qualified_name, method_name);
        if (f)
            return f;
    }

    /* Walk inheritance chain (base + interfaces + transitive bases). */
    const char *visited[CS_LSP_PARENT_WALK_MAX];
    int visited_count = 0;
    const char *frontier[CS_LSP_PARENT_WALK_MAX];
    int frontier_count = 0;

    for (int k = -1; k < twin_count; k++) {
        const CBMRegisteredType *decl = k < 0 ? t : twins[k];
        for (int i = 0; decl->embedded_types && decl->embedded_types[i] &&
                        frontier_count < CS_LSP_PARENT_WALK_MAX;
             i++) {
            frontier[frontier_count++] = decl->embedded_types[i];
        }
    }

    /* Always try System.Object as the universal root. */
    while (frontier_count > 0 && visited_count < CS_LSP_PARENT_WALK_MAX) {
        const char *parent = frontier[--frontier_count];
        bool seen = false;
        for (int v = 0; v < visited_count; v++) {
            if (strcmp(visited[v], parent) == 0) {
                seen = true;
                break;
            }
        }
        if (seen)
            continue;
        visited[visited_count++] = parent;

        f = cbm_registry_lookup_method(ctx->registry, parent, method_name);
        if (f)
            return f;

        const CBMRegisteredType *next = cs_lookup_type_qn(ctx, parent);
        if (!next)
            continue;
        if (next->embedded_types) {
            for (int i = 0; next->embedded_types[i] && frontier_count < CS_LSP_PARENT_WALK_MAX;
                 i++) {
                frontier[frontier_count++] = next->embedded_types[i];
            }
        }
    }

    /* Fall back to System.Object root members (ToString, Equals, GetHashCode). */
    if (strcmp(type_qn, "System.Object") != 0) {
        f = cbm_registry_lookup_method(ctx->registry, "System.Object", method_name);
        if (f)
            return f;
    }
    return NULL;
}

/* A static import is precise only when every matching directive reaches the
 * same method. Repeated imports of one type are harmless, but selecting the
 * first of two distinct targets would make resolution declaration-order
 * dependent. */
static const CBMRegisteredFunc *cs_lookup_using_static_method(CSLSPContext *ctx,
                                                              const char *method_name,
                                                              bool *ambiguous) {
    if (ambiguous)
        *ambiguous = false;
    if (!ctx || !method_name)
        return NULL;

    const CBMRegisteredFunc *only = NULL;
    for (int i = 0; i < ctx->using_count; i++) {
        const CBMCSUsing *u = &ctx->usings[i];
        if (u->kind != CBM_CS_USING_STATIC)
            continue;
        const char *host = cs_resolve_type_name(ctx, u->target_qn);
        const CBMRegisteredFunc *candidate =
            cs_lookup_method(ctx, host ? host : u->target_qn, method_name);
        if (!candidate || !candidate->qualified_name)
            continue;
        if (only && strcmp(only->qualified_name, candidate->qualified_name) != 0) {
            if (ambiguous)
                *ambiguous = true;
            return NULL;
        }
        only = candidate;
    }
    return only;
}

/* ── extension methods ──────────────────────────────────────────── */

/* Search for a static extension method `M(this U self, ...)` accessible
 * via using-imported namespaces. Returns the func entry or NULL. */
static const CBMRegisteredFunc *cs_lookup_extension(CSLSPContext *ctx, const char *receiver_qn,
                                                    const char *method_name) {
    if (!ctx->registry || !receiver_qn || !method_name)
        return NULL;
    /* Walk every static class accessible in scope. We approximate accessibility
     * by checking that the function's qualified_name's first dotted prefixes
     * line up with one of: the file's namespace, an imported using namespace,
     * or the file's module.
     *
     * Candidates come from the free-function short-name index, NOT a scan over
     * reg->funcs: against the shared Tier-2 registry (963k funcs on
     * dotnet/runtime) the old full scan ran per unresolved invocation and made
     * per-file resolve cost proportional to the whole corpus (#1669 follow-up).
     * The iterator degrades to the same full scan on an unfinalized registry,
     * and the min-index selection below preserves the scan's first-match-in-
     * registration-order tie-break exactly (bucket chains are not in funcs[]
     * order). */
    CBMFreeFuncIter ext_it;
    cbm_registry_free_funcs_by_short_name_chain(ctx->registry, method_name, &ext_it);
    const CBMRegisteredFunc *best = NULL;
    int best_idx = -1;
    int i;
    while ((i = cbm_free_func_iter_next(&ext_it)) >= 0) {
        const CBMRegisteredFunc *cand = &ext_it.reg->funcs[i];
        if (!cand->short_name || strcmp(cand->short_name, method_name) != 0)
            continue;
        if (cand->receiver_type)
            continue; /* must be a free static method */
        if (!cand->signature || cand->signature->kind != CBM_TYPE_FUNC)
            continue;
        const CBMType *sig = cand->signature;
        if (!sig->data.func.param_types)
            continue;
        const CBMType *first = sig->data.func.param_types[0];
        if (!first)
            continue;
        /* Only consider candidates marked as extensions (param[0] is named
         * "this" in our convention). param_names[0] == "this self" or "this". */
        if (!sig->data.func.param_names || !sig->data.func.param_names[0])
            continue;
        const char *p0 = sig->data.func.param_names[0];
        if (strncmp(p0, "this", 4) != 0)
            continue;

        /* Receiver compatibility: NAMED receiver must match receiver_qn or
         * one of receiver_qn's bases. TEMPLATE receiver (e.g. IEnumerable<T>)
         * matches if receiver type or any base shares the template name. */
        bool match = false;
        if (first->kind == CBM_TYPE_NAMED && first->data.named.qualified_name) {
            if (strcmp(first->data.named.qualified_name, receiver_qn) == 0)
                match = true;
            if (!match && strcmp(first->data.named.qualified_name, "System.Object") == 0)
                match = true;
            /* Walk receiver's bases. */
            const CBMRegisteredType *rt = cs_lookup_type_qn(ctx, receiver_qn);
            if (rt && rt->embedded_types && !match) {
                for (int j = 0; rt->embedded_types[j]; j++) {
                    if (strcmp(rt->embedded_types[j], first->data.named.qualified_name) == 0) {
                        match = true;
                        break;
                    }
                }
            }
        } else if (first->kind == CBM_TYPE_TEMPLATE) {
            const char *tn = first->data.template_type.template_name;
            const CBMRegisteredType *rt = cs_lookup_type_qn(ctx, receiver_qn);
            if (rt && rt->embedded_types) {
                for (int j = 0; rt->embedded_types[j]; j++) {
                    if (strcmp(rt->embedded_types[j], tn) == 0) {
                        match = true;
                        break;
                    }
                }
            }
            if (!match && strcmp(receiver_qn, tn) == 0)
                match = true;
        }
        if (!match)
            continue;

        /* Accessibility check: the candidate's namespace must be in
         * usings or namespace stack. We'll be lenient here — the user's
         * project tree generally has consistent namespaces. */
        if (best_idx < 0 || i < best_idx) {
            best = cand;
            best_idx = i;
        }
    }
    return best;
}

/* ── type AST parsing ───────────────────────────────────────────── */

const CBMType *cs_parse_type_node(CSLSPContext *ctx, TSNode node) {
    if (ts_node_is_null(node))
        return cbm_type_unknown();
    const char *kind = ts_node_type(node);

    if (strcmp(kind, "predefined_type") == 0) {
        char *t = cs_node_text(ctx, node);
        if (!t)
            return cbm_type_unknown();
        const char *aliased = cs_predefined_alias(t);
        if (aliased)
            return cbm_type_named(ctx->arena, aliased);
        return cbm_type_builtin(ctx->arena, t);
    }
    if (strcmp(kind, "nullable_type") == 0) {
        /* Recurse into the underlying. */
        TSNode inner = ts_node_child_by_field_name(node, "type", 4);
        if (ts_node_is_null(inner))
            inner = cs_first_named_child(node);
        if (ts_node_is_null(inner))
            return cbm_type_unknown();
        return cs_parse_type_node(ctx, inner);
    }
    if (strcmp(kind, "array_type") == 0) {
        TSNode inner = ts_node_child_by_field_name(node, "type", 4);
        if (ts_node_is_null(inner))
            inner = cs_first_named_child(node);
        const CBMType *elem = cs_parse_type_node(ctx, inner);
        return cbm_type_template(ctx->arena, "System.Array", (const CBMType *[]){elem, NULL}, 1);
    }
    if (strcmp(kind, "pointer_type") == 0) {
        TSNode inner = ts_node_child_by_field_name(node, "type", 4);
        if (ts_node_is_null(inner))
            inner = cs_first_named_child(node);
        return cs_parse_type_node(ctx, inner);
    }
    if (strcmp(kind, "tuple_type") == 0) {
        /* Build a TUPLE of element types. */
        uint32_t nc = ts_node_child_count(node);
        const CBMType **elems =
            (const CBMType **)cbm_arena_alloc(ctx->arena, (size_t)(nc + 1) * sizeof(*elems));
        if (!elems)
            return cbm_type_unknown();
        int count = 0;
        for (uint32_t i = 0; i < nc; i++) {
            TSNode c = ts_node_child(node, i);
            if (ts_node_is_null(c) || !ts_node_is_named(c))
                continue;
            const char *ck = ts_node_type(c);
            if (strcmp(ck, "tuple_element") != 0)
                continue;
            TSNode te = ts_node_child_by_field_name(c, "type", 4);
            if (ts_node_is_null(te))
                te = cs_first_named_child(c);
            elems[count++] = cs_parse_type_node(ctx, te);
        }
        return cbm_type_tuple(ctx->arena, elems, count);
    }
    if (strcmp(kind, "generic_name") == 0) {
        TSNode name_node = ts_node_child_by_field_name(node, "name", 4);
        if (ts_node_is_null(name_node))
            name_node = cs_child_named_kind(node, "identifier");
        TSNode args_node = ts_node_child_by_field_name(node, "type_arguments", 14);
        if (ts_node_is_null(args_node))
            args_node = cs_child_named_kind(node, "type_argument_list");
        if (ts_node_is_null(name_node))
            return cbm_type_unknown();
        char *raw = cs_node_text(ctx, name_node);
        if (!raw)
            return cbm_type_unknown();
        const char *resolved = cs_resolve_type_name(ctx, raw);
        if (!resolved)
            return cbm_type_unknown();

        if (ts_node_is_null(args_node)) {
            return cbm_type_named(ctx->arena, resolved);
        }
        /* Parse args. */
        uint32_t nc = ts_node_child_count(args_node);
        const CBMType **args =
            (const CBMType **)cbm_arena_alloc(ctx->arena, (size_t)(nc + 1) * sizeof(*args));
        if (!args)
            return cbm_type_named(ctx->arena, resolved);
        int count = 0;
        for (uint32_t i = 0; i < nc; i++) {
            TSNode c = ts_node_child(args_node, i);
            if (ts_node_is_null(c) || !ts_node_is_named(c))
                continue;
            args[count++] = cs_parse_type_node(ctx, c);
        }
        args[count] = NULL;
        return cbm_type_template(ctx->arena, resolved, args, count);
    }
    if (strcmp(kind, "qualified_name") == 0 || strcmp(kind, "identifier") == 0 ||
        strcmp(kind, "alias_qualified_name") == 0 || strcmp(kind, "name") == 0) {
        char *t = cs_node_text(ctx, node);
        if (!t)
            return cbm_type_unknown();
        const char *resolved = cs_resolve_type_name(ctx, t);
        if (!resolved)
            return cbm_type_unknown();
        const char *pre = cs_predefined_alias(resolved);
        if (pre)
            return cbm_type_named(ctx->arena, pre);
        return cbm_type_named(ctx->arena, resolved);
    }
    if (strcmp(kind, "ref_type") == 0) {
        TSNode inner = ts_node_child_by_field_name(node, "type", 4);
        if (ts_node_is_null(inner))
            inner = cs_first_named_child(node);
        const CBMType *t = cs_parse_type_node(ctx, inner);
        return cbm_type_reference(ctx->arena, t);
    }
    if (strcmp(kind, "implicit_type") == 0 || strcmp(kind, "var") == 0) {
        return cbm_type_unknown();
    }
    /* Fallback: read raw text + resolve. */
    char *t = cs_node_text(ctx, node);
    if (!t)
        return cbm_type_unknown();
    const char *resolved = cs_resolve_type_name(ctx, t);
    if (!resolved)
        return cbm_type_unknown();
    const char *pre = cs_predefined_alias(resolved);
    if (pre)
        return cbm_type_named(ctx->arena, pre);
    return cbm_type_named(ctx->arena, resolved);
}

/* ── expression evaluation ──────────────────────────────────────── */

static const CBMType *cs_unwrap_task(CSLSPContext *ctx, const CBMType *t) {
    (void)ctx;
    if (!t)
        return cbm_type_unknown();
    if (t->kind == CBM_TYPE_TEMPLATE) {
        const char *n = t->data.template_type.template_name;
        if (n && (strcmp(n, "System.Threading.Tasks.Task") == 0 ||
                  strcmp(n, "System.Threading.Tasks.ValueTask") == 0)) {
            if (t->data.template_type.template_args && t->data.template_type.template_args[0]) {
                return t->data.template_type.template_args[0];
            }
        }
    }
    if (t->kind == CBM_TYPE_NAMED) {
        const char *qn = t->data.named.qualified_name;
        if (qn && (strcmp(qn, "System.Threading.Tasks.Task") == 0 ||
                   strcmp(qn, "System.Threading.Tasks.ValueTask") == 0)) {
            return cbm_type_unknown();
        }
    }
    return t;
}

static const CBMType *cs_unwrap_nullable(const CBMType *t) {
    if (!t)
        return t;
    if (t->kind == CBM_TYPE_TEMPLATE) {
        const char *n = t->data.template_type.template_name;
        if (n && strcmp(n, "System.Nullable") == 0) {
            if (t->data.template_type.template_args && t->data.template_type.template_args[0]) {
                return t->data.template_type.template_args[0];
            }
        }
    }
    return t;
}

const CBMType *cs_eval_expr_type(CSLSPContext *ctx, TSNode node) {
    if (ts_node_is_null(node) || ctx->eval_depth >= CS_EVAL_MAX_DEPTH) {
        return cbm_type_unknown();
    }
    ctx->eval_depth++;
    const CBMType *result = cbm_type_unknown();
    const char *kind = ts_node_type(node);

    if (strcmp(kind, "identifier") == 0) {
        result = cs_eval_identifier_type(ctx, node);
    } else if (strcmp(kind, "this_expression") == 0 || strcmp(kind, "this") == 0) {
        if (ctx->enclosing_class_qn) {
            result = cbm_type_named(ctx->arena, ctx->enclosing_class_qn);
        }
    } else if (strcmp(kind, "base_expression") == 0 || strcmp(kind, "base") == 0) {
        if (ctx->enclosing_base_qn) {
            result = cbm_type_named(ctx->arena, ctx->enclosing_base_qn);
        }
    } else if (strcmp(kind, "invocation_expression") == 0) {
        result = cs_eval_invocation_type(ctx, node);
    } else if (strcmp(kind, "member_access_expression") == 0 ||
               strcmp(kind, "conditional_access_expression") == 0) {
        result = cs_eval_member_access_type(ctx, node);
    } else if (strcmp(kind, "object_creation_expression") == 0 ||
               strcmp(kind, "implicit_object_creation_expression") == 0) {
        result = cs_eval_object_creation_type(ctx, node);
    } else if (strcmp(kind, "string_literal") == 0 ||
               strcmp(kind, "verbatim_string_literal") == 0 ||
               strcmp(kind, "interpolated_string_expression") == 0 ||
               strcmp(kind, "raw_string_literal") == 0) {
        result = cbm_type_named(ctx->arena, "System.String");
    } else if (strcmp(kind, "character_literal") == 0) {
        result = cbm_type_named(ctx->arena, "System.Char");
    } else if (strcmp(kind, "integer_literal") == 0) {
        result = cbm_type_named(ctx->arena, "System.Int32");
    } else if (strcmp(kind, "real_literal") == 0) {
        result = cbm_type_named(ctx->arena, "System.Double");
    } else if (strcmp(kind, "boolean_literal") == 0) {
        result = cbm_type_named(ctx->arena, "System.Boolean");
    } else if (strcmp(kind, "null_literal") == 0) {
        result = cbm_type_unknown();
    } else if (strcmp(kind, "parenthesized_expression") == 0) {
        TSNode c = cs_first_named_child(node);
        if (!ts_node_is_null(c))
            result = cs_eval_expr_type(ctx, c);
    } else if (strcmp(kind, "cast_expression") == 0) {
        TSNode tnode = ts_node_child_by_field_name(node, "type", 4);
        if (!ts_node_is_null(tnode))
            result = cs_parse_type_node(ctx, tnode);
    } else if (strcmp(kind, "as_expression") == 0) {
        /* x as T → T */
        TSNode rhs = ts_node_child_by_field_name(node, "right", 5);
        if (ts_node_is_null(rhs)) {
            uint32_t nc = ts_node_child_count(node);
            for (uint32_t i = 0; i < nc; i++) {
                TSNode c = ts_node_child(node, i);
                if (!ts_node_is_null(c) && ts_node_is_named(c))
                    rhs = c;
            }
        }
        if (!ts_node_is_null(rhs))
            result = cs_parse_type_node(ctx, rhs);
    } else if (strcmp(kind, "is_expression") == 0 || strcmp(kind, "is_pattern_expression") == 0) {
        result = cbm_type_named(ctx->arena, "System.Boolean");
    } else if (strcmp(kind, "await_expression") == 0) {
        TSNode inner = cs_first_named_child(node);
        if (!ts_node_is_null(inner)) {
            const CBMType *t = cs_eval_expr_type(ctx, inner);
            result = cs_unwrap_task(ctx, t);
        }
    } else if (strcmp(kind, "binary_expression") == 0 ||
               strcmp(kind, "prefix_unary_expression") == 0 ||
               strcmp(kind, "postfix_unary_expression") == 0) {
        /* Best-effort: take left's type. For comparisons, return Boolean. */
        TSNode op = ts_node_child_by_field_name(node, "operator", 8);
        char *opt = ts_node_is_null(op) ? NULL : cs_node_text(ctx, op);
        if (opt && (strcmp(opt, "==") == 0 || strcmp(opt, "!=") == 0 || strcmp(opt, "<") == 0 ||
                    strcmp(opt, ">") == 0 || strcmp(opt, "<=") == 0 || strcmp(opt, ">=") == 0 ||
                    strcmp(opt, "&&") == 0 || strcmp(opt, "||") == 0 || strcmp(opt, "!") == 0)) {
            result = cbm_type_named(ctx->arena, "System.Boolean");
        } else {
            TSNode left = ts_node_child_by_field_name(node, "left", 4);
            if (ts_node_is_null(left))
                left = cs_first_named_child(node);
            if (!ts_node_is_null(left))
                result = cs_eval_expr_type(ctx, left);
        }
    } else if (strcmp(kind, "assignment_expression") == 0) {
        TSNode rhs = ts_node_child_by_field_name(node, "right", 5);
        if (!ts_node_is_null(rhs))
            result = cs_eval_expr_type(ctx, rhs);
    } else if (strcmp(kind, "conditional_expression") == 0 ||
               strcmp(kind, "switch_expression") == 0) {
        /* a ? b : c → take b's type. */
        TSNode b = ts_node_child_by_field_name(node, "consequence", 11);
        if (ts_node_is_null(b))
            b = ts_node_child_by_field_name(node, "alternative", 11);
        if (ts_node_is_null(b)) {
            uint32_t nc = ts_node_child_count(node);
            for (uint32_t i = 0; i < nc; i++) {
                TSNode c = ts_node_child(node, i);
                if (!ts_node_is_null(c) && ts_node_is_named(c)) {
                    const CBMType *t = cs_eval_expr_type(ctx, c);
                    if (t && t->kind != CBM_TYPE_UNKNOWN) {
                        result = t;
                        break;
                    }
                }
            }
        } else {
            result = cs_eval_expr_type(ctx, b);
        }
    } else if (strcmp(kind, "tuple_expression") == 0) {
        /* (a, b) -> tuple of element types. */
        uint32_t nc = ts_node_child_count(node);
        const CBMType **elems =
            (const CBMType **)cbm_arena_alloc(ctx->arena, (size_t)(nc + 1) * sizeof(*elems));
        if (!elems) {
            ctx->eval_depth--;
            return cbm_type_unknown();
        }
        int count = 0;
        for (uint32_t i = 0; i < nc; i++) {
            TSNode c = ts_node_child(node, i);
            if (ts_node_is_null(c) || !ts_node_is_named(c))
                continue;
            elems[count++] = cs_eval_expr_type(ctx, c);
        }
        elems[count] = NULL;
        result = cbm_type_tuple(ctx->arena, elems, count);
    } else if (strcmp(kind, "lambda_expression") == 0 ||
               strcmp(kind, "anonymous_method_expression") == 0) {
        /* We approximate the lambda's type as System.Func<TR>; we don't
         * walk the body here. */
        result = cbm_type_unknown();
    } else if (strcmp(kind, "typeof_expression") == 0) {
        result = cbm_type_named(ctx->arena, "System.Type");
    } else if (strcmp(kind, "nameof_expression") == 0) {
        result = cbm_type_named(ctx->arena, "System.String");
    } else if (strcmp(kind, "default_expression") == 0) {
        TSNode tnode = ts_node_child_by_field_name(node, "type", 4);
        if (!ts_node_is_null(tnode))
            result = cs_parse_type_node(ctx, tnode);
    } else if (strcmp(kind, "element_access_expression") == 0) {
        /* arr[i] — return element type of receiver. */
        TSNode obj = ts_node_child_by_field_name(node, "expression", 10);
        if (ts_node_is_null(obj))
            obj = cs_first_named_child(node);
        if (!ts_node_is_null(obj)) {
            const CBMType *recv = cs_eval_expr_type(ctx, obj);
            if (recv && recv->kind == CBM_TYPE_TEMPLATE) {
                const CBMType *const *args = recv->data.template_type.template_args;
                if (args) {
                    int n = 0;
                    while (args[n])
                        n++;
                    if (n >= 2 && args[1])
                        result = args[1];
                    else if (n >= 1 && args[0])
                        result = args[0];
                }
            }
        }
    } else if (strcmp(kind, "checked_expression") == 0 ||
               strcmp(kind, "unchecked_expression") == 0) {
        TSNode c = cs_first_named_child(node);
        if (!ts_node_is_null(c))
            result = cs_eval_expr_type(ctx, c);
    } else if (strcmp(kind, "array_creation_expression") == 0) {
        TSNode tnode = ts_node_child_by_field_name(node, "type", 4);
        if (!ts_node_is_null(tnode)) {
            const CBMType *elem = cs_parse_type_node(ctx, tnode);
            result =
                cbm_type_template(ctx->arena, "System.Array", (const CBMType *[]){elem, NULL}, 1);
        }
    } else if (strcmp(kind, "implicit_array_creation_expression") == 0) {
        result = cbm_type_template(ctx->arena, "System.Array",
                                   (const CBMType *[]){cbm_type_unknown(), NULL}, 1);
    }

    ctx->eval_depth--;
    return result ? result : cbm_type_unknown();
}

/* ── identifier resolution ──────────────────────────────────────── */

static const CBMType *cs_eval_identifier_type(CSLSPContext *ctx, TSNode node) {
    char *name = cs_node_text(ctx, node);
    if (!name)
        return cbm_type_unknown();

    /* Local / parameter scope. cbm_scope_lookup returns cbm_type_unknown()
     * (a non-NULL singleton) when the name isn't bound, so we need to
     * check the kind, not just the pointer. */
    const CBMType *bound = cbm_scope_lookup(ctx->current_scope, name);
    if (bound && bound->kind != CBM_TYPE_UNKNOWN)
        return bound;

    /* Implicit `this` member. Try to find a field on the enclosing class. */
    if (ctx->enclosing_class_qn) {
        const CBMRegisteredType *rt = cs_lookup_type_qn(ctx, ctx->enclosing_class_qn);
        if (rt && rt->field_names) {
            for (int i = 0; rt->field_names[i]; i++) {
                if (strcmp(rt->field_names[i], name) == 0) {
                    if (rt->field_types && rt->field_types[i])
                        return rt->field_types[i];
                    return cbm_type_unknown();
                }
            }
        }
    }

    /* Predefined alias: e.g. `int.Parse(...)` — but that's parsed as a
     * predefined_type, not identifier. Still: handle bare type names. */
    const char *resolved = cs_resolve_type_name(ctx, name);
    if (resolved) {
        const CBMRegisteredType *rt = cs_lookup_type_qn(ctx, resolved);
        if (rt)
            return cbm_type_named(ctx->arena, rt->qualified_name);
    }

    return cbm_type_unknown();
}

/* ── invocation ─────────────────────────────────────────────────── */

static int cs_count_args(TSNode args_node) {
    if (ts_node_is_null(args_node))
        return 0;
    int count = 0;
    uint32_t nc = ts_node_child_count(args_node);
    for (uint32_t i = 0; i < nc; i++) {
        TSNode c = ts_node_child(args_node, i);
        if (!ts_node_is_null(c) && ts_node_is_named(c)) {
            const char *k = ts_node_type(c);
            if (strcmp(k, "argument") == 0)
                count++;
        }
    }
    return count;
}

static const CBMType *cs_eval_invocation_type(CSLSPContext *ctx, TSNode call) {
    TSNode fn = ts_node_child_by_field_name(call, "function", 8);
    if (ts_node_is_null(fn)) {
        /* tree-sitter sometimes uses "expression" instead of "function". */
        uint32_t nc = ts_node_child_count(call);
        for (uint32_t i = 0; i < nc; i++) {
            TSNode c = ts_node_child(call, i);
            if (!ts_node_is_null(c) && ts_node_is_named(c)) {
                const char *k = ts_node_type(c);
                if (strcmp(k, "argument_list") == 0)
                    continue;
                fn = c;
                break;
            }
        }
    }
    if (ts_node_is_null(fn))
        return cbm_type_unknown();
    const char *fk = ts_node_type(fn);

    /* Member call: `recv.Method` or `recv?.Method`. */
    if (strcmp(fk, "member_access_expression") == 0 ||
        strcmp(fk, "conditional_access_expression") == 0) {
        TSNode recv = ts_node_child_by_field_name(fn, "expression", 10);
        TSNode name = ts_node_child_by_field_name(fn, "name", 4);
        if (ts_node_is_null(recv))
            recv = cs_first_named_child(fn);
        if (ts_node_is_null(name)) {
            uint32_t fnc = ts_node_child_count(fn);
            for (uint32_t i = 0; i < fnc; i++) {
                TSNode c = ts_node_child(fn, i);
                if (ts_node_is_null(c) || !ts_node_is_named(c))
                    continue;
                const char *k = ts_node_type(c);
                if (strcmp(k, "identifier") == 0 || strcmp(k, "generic_name") == 0)
                    name = c;
            }
        }
        if (ts_node_is_null(name))
            return cbm_type_unknown();
        char *mname = cs_node_text(ctx, name);
        if (!mname)
            return cbm_type_unknown();
        char *bare_name = cs_strip_generic_args(ctx->arena, mname);

        const CBMType *recv_type = cbm_type_unknown();
        if (!ts_node_is_null(recv))
            recv_type = cs_eval_expr_type(ctx, recv);
        recv_type = cs_unwrap_nullable(recv_type);

        const char *type_qn = NULL;
        if (recv_type && recv_type->kind == CBM_TYPE_NAMED) {
            type_qn = recv_type->data.named.qualified_name;
        } else if (recv_type && recv_type->kind == CBM_TYPE_TEMPLATE) {
            type_qn = recv_type->data.template_type.template_name;
        }
        if (!type_qn)
            return cbm_type_unknown();

        const CBMRegisteredFunc *f = cs_lookup_method(ctx, type_qn, bare_name);
        if (!f)
            f = cs_lookup_extension(ctx, type_qn, bare_name);
        if (!f || !f->signature)
            return cbm_type_unknown();
        if (f->signature->kind == CBM_TYPE_FUNC && f->signature->data.func.return_types &&
            f->signature->data.func.return_types[0]) {
            const CBMType *ret = f->signature->data.func.return_types[0];
            /* If receiver is templated and method's return type contains type
             * parameters, substitute. */
            if (recv_type && recv_type->kind == CBM_TYPE_TEMPLATE) {
                const CBMRegisteredType *rt = cs_lookup_type_qn(ctx, type_qn);
                if (rt && rt->type_param_names && recv_type->data.template_type.template_args) {
                    return cs_substitute_type_params(ctx->arena, ret, rt->type_param_names,
                                                     recv_type->data.template_type.template_args);
                }
            }
            return ret;
        }
        return cbm_type_unknown();
    }

    /* Bare invocation: `Method(args)`. */
    if (strcmp(fk, "identifier") == 0 || strcmp(fk, "generic_name") == 0) {
        char *fname = cs_node_text(ctx, fn);
        if (!fname)
            return cbm_type_unknown();
        char *bare = cs_strip_generic_args(ctx->arena, fname);

        /* Contextual keywords that tree-sitter parses as invocation
         * expressions but the C# language treats specially. */
        if (strcmp(bare, "nameof") == 0) {
            return cbm_type_named(ctx->arena, "System.String");
        }
        if (strcmp(bare, "typeof") == 0) {
            return cbm_type_named(ctx->arena, "System.Type");
        }

        /* Try enclosing class member. */
        if (ctx->enclosing_class_qn) {
            const CBMRegisteredFunc *f = cs_lookup_method(ctx, ctx->enclosing_class_qn, bare);
            if (f && f->signature && f->signature->kind == CBM_TYPE_FUNC &&
                f->signature->data.func.return_types && f->signature->data.func.return_types[0]) {
                return f->signature->data.func.return_types[0];
            }
        }
        /* Try free function in current namespace / using static targets. */
        const char *ns = cs_namespace_qn(ctx);
        if (ns && *ns) {
            const char *qn = cbm_arena_sprintf(ctx->arena, "%s.%s", ns, bare);
            const CBMRegisteredFunc *f = cbm_registry_lookup_func(ctx->registry, qn);
            if (f && f->signature && f->signature->data.func.return_types &&
                f->signature->data.func.return_types[0]) {
                return f->signature->data.func.return_types[0];
            }
        }
        bool ambiguous = false;
        const CBMRegisteredFunc *f = cs_lookup_using_static_method(ctx, bare, &ambiguous);
        if (ambiguous)
            return cbm_type_unknown();
        if (f && f->signature && f->signature->data.func.return_types &&
            f->signature->data.func.return_types[0]) {
            return f->signature->data.func.return_types[0];
        }
    }

    return cbm_type_unknown();
}

/* ── member access (no invocation) ──────────────────────────────── */

static const CBMType *cs_eval_member_access_type(CSLSPContext *ctx, TSNode node) {
    TSNode obj = ts_node_child_by_field_name(node, "expression", 10);
    TSNode name = ts_node_child_by_field_name(node, "name", 4);
    if (ts_node_is_null(obj))
        obj = cs_first_named_child(node);
    if (ts_node_is_null(name)) {
        uint32_t nc = ts_node_child_count(node);
        for (uint32_t i = 0; i < nc; i++) {
            TSNode c = ts_node_child(node, i);
            if (ts_node_is_null(c) || !ts_node_is_named(c))
                continue;
            const char *k = ts_node_type(c);
            if (strcmp(k, "identifier") == 0 || strcmp(k, "generic_name") == 0)
                name = c;
        }
    }
    if (ts_node_is_null(obj) || ts_node_is_null(name))
        return cbm_type_unknown();
    char *fname = cs_node_text(ctx, name);
    if (!fname)
        return cbm_type_unknown();
    fname = cs_strip_generic_args(ctx->arena, fname);

    /* If obj is a type identifier → static member access */
    char *obj_text = cs_node_text(ctx, obj);
    if (obj_text) {
        const char *type_qn = cs_resolve_type_name(ctx, obj_text);
        if (type_qn && cs_lookup_type_qn(ctx, type_qn)) {
            const CBMRegisteredType *rt = cs_lookup_type_qn(ctx, type_qn);
            if (rt && rt->field_names) {
                for (int i = 0; rt->field_names[i]; i++) {
                    if (strcmp(rt->field_names[i], fname) == 0) {
                        if (rt->field_types && rt->field_types[i])
                            return rt->field_types[i];
                    }
                }
            }
            /* Try as method (returns its return type, which is what
             * `Math.Sqrt(...)` would propagate via invocation). */
            const CBMRegisteredFunc *f = cs_lookup_method(ctx, type_qn, fname);
            if (f && f->signature && f->signature->kind == CBM_TYPE_FUNC &&
                f->signature->data.func.return_types && f->signature->data.func.return_types[0]) {
                return f->signature->data.func.return_types[0];
            }
        }
    }

    const CBMType *recv = cs_eval_expr_type(ctx, obj);
    recv = cs_unwrap_nullable(recv);
    if (!recv)
        return cbm_type_unknown();

    const char *type_qn = NULL;
    if (recv->kind == CBM_TYPE_NAMED) {
        type_qn = recv->data.named.qualified_name;
    } else if (recv->kind == CBM_TYPE_TEMPLATE) {
        type_qn = recv->data.template_type.template_name;
    }
    if (!type_qn)
        return cbm_type_unknown();
    const CBMRegisteredType *rt = cs_lookup_type_qn(ctx, type_qn);
    if (rt && rt->field_names) {
        for (int i = 0; rt->field_names[i]; i++) {
            if (strcmp(rt->field_names[i], fname) == 0) {
                if (rt->field_types && rt->field_types[i]) {
                    const CBMType *ft = rt->field_types[i];
                    if (recv->kind == CBM_TYPE_TEMPLATE && rt->type_param_names &&
                        recv->data.template_type.template_args) {
                        return cs_substitute_type_params(ctx->arena, ft, rt->type_param_names,
                                                         recv->data.template_type.template_args);
                    }
                    return ft;
                }
            }
        }
    }
    /* Treat as property — call lookup_method with `get_<name>` or just `name`.
     * Properties are stored as methods in our registry with return type. */
    const CBMRegisteredFunc *f = cs_lookup_method(ctx, type_qn, fname);
    if (f && f->signature && f->signature->kind == CBM_TYPE_FUNC &&
        f->signature->data.func.return_types && f->signature->data.func.return_types[0]) {
        const CBMType *ret = f->signature->data.func.return_types[0];
        if (recv->kind == CBM_TYPE_TEMPLATE && rt && rt->type_param_names &&
            recv->data.template_type.template_args) {
            return cs_substitute_type_params(ctx->arena, ret, rt->type_param_names,
                                             recv->data.template_type.template_args);
        }
        return ret;
    }

    return cbm_type_unknown();
}

/* ── object creation ────────────────────────────────────────────── */

static const CBMType *cs_eval_object_creation_type(CSLSPContext *ctx, TSNode node) {
    if (cs_node_is(node, "implicit_object_creation_expression")) {
        /* `new(...)` — target-typed; we don't have the target binding here. */
        return cbm_type_unknown();
    }
    TSNode tnode = ts_node_child_by_field_name(node, "type", 4);
    if (ts_node_is_null(tnode)) {
        uint32_t nc = ts_node_child_count(node);
        for (uint32_t i = 0; i < nc; i++) {
            TSNode c = ts_node_child(node, i);
            if (ts_node_is_null(c) || !ts_node_is_named(c))
                continue;
            const char *k = ts_node_type(c);
            if (strcmp(k, "argument_list") == 0 || strcmp(k, "initializer_expression") == 0)
                continue;
            tnode = c;
            break;
        }
    }
    if (ts_node_is_null(tnode))
        return cbm_type_unknown();
    return cs_parse_type_node(ctx, tnode);
}

/* ── generic substitution ───────────────────────────────────────── */

static const CBMType *cs_substitute_type_params(CBMArena *arena, const CBMType *t,
                                                const char **param_names,
                                                const CBMType **param_args) {
    if (!t || !param_names || !param_args)
        return t;
    if (t->kind == CBM_TYPE_NAMED) {
        const char *qn = t->data.named.qualified_name;
        if (!qn)
            return t;
        for (int i = 0; param_names[i]; i++) {
            if (strcmp(param_names[i], qn) == 0) {
                /* If the type is `T` and we have an arg for T, substitute. */
                return param_args[i] ? param_args[i] : t;
            }
        }
        return t;
    }
    if (t->kind == CBM_TYPE_TEMPLATE) {
        const CBMType *const *old_args = t->data.template_type.template_args;
        if (!old_args)
            return t;
        int n = 0;
        while (old_args[n])
            n++;
        const CBMType **new_args =
            (const CBMType **)cbm_arena_alloc(arena, (size_t)(n + 1) * sizeof(*new_args));
        if (!new_args)
            return t;
        for (int i = 0; i < n; i++) {
            new_args[i] = cs_substitute_type_params(arena, old_args[i], param_names, param_args);
        }
        new_args[n] = NULL;
        return cbm_type_template(arena, t->data.template_type.template_name, new_args, n);
    }
    if (t->kind == CBM_TYPE_TYPE_PARAM) {
        const char *p = t->data.type_param.name;
        if (!p)
            return t;
        for (int i = 0; param_names[i]; i++) {
            if (strcmp(param_names[i], p) == 0)
                return param_args[i] ? param_args[i] : t;
        }
    }
    return t;
}

/* ── parameter binding ──────────────────────────────────────────── */

static void cs_bind_parameters(CSLSPContext *ctx, TSNode params_node, bool is_extension) {
    if (ts_node_is_null(params_node))
        return;
    uint32_t nc = ts_node_child_count(params_node);
    int idx = 0;
    for (uint32_t i = 0; i < nc; i++) {
        TSNode c = ts_node_child(params_node, i);
        if (ts_node_is_null(c) || !ts_node_is_named(c))
            continue;
        const char *k = ts_node_type(c);
        if (strcmp(k, "parameter") != 0)
            continue;

        /* Detect `this` modifier (extension methods). */
        bool has_this = is_extension && (idx == 0);
        TSNode tnode = ts_node_child_by_field_name(c, "type", 4);
        TSNode nnode = ts_node_child_by_field_name(c, "name", 4);
        if (ts_node_is_null(tnode) || ts_node_is_null(nnode)) {
            uint32_t pc = ts_node_child_count(c);
            for (uint32_t j = 0; j < pc; j++) {
                TSNode cc = ts_node_child(c, j);
                if (ts_node_is_null(cc) || !ts_node_is_named(cc))
                    continue;
                const char *ck = ts_node_type(cc);
                if (strcmp(ck, "identifier") == 0 && ts_node_is_null(nnode))
                    nnode = cc;
                else if (ts_node_is_null(tnode) && strcmp(ck, "identifier") != 0)
                    tnode = cc;
            }
        }
        if (ts_node_is_null(nnode)) {
            idx++;
            continue;
        }
        char *pname = cs_node_text(ctx, nnode);
        if (!pname) {
            idx++;
            continue;
        }
        const CBMType *ptype = cbm_type_unknown();
        if (!ts_node_is_null(tnode))
            ptype = cs_parse_type_node(ctx, tnode);
        cbm_scope_bind(ctx->current_scope, pname, ptype);
        (void)has_this;
        idx++;
    }
}

/* ── statement processing ───────────────────────────────────────── */

/* Resolve a source expression only when it denotes one exact callable value.
 * This deliberately accepts just direct method groups (bare or member access):
 * conditional/switch/lambda expressions remain ordinary usages because they
 * do not prove one target at this occurrence. */
static const char *cs_resolve_callable_name(CSLSPContext *ctx, const char *name) {
    if (!ctx || !name || !name[0])
        return NULL;

    /* A lexical binding always wins, including an UNKNOWN ordinary binding:
     * a nearer non-callable value must suppress a same-named class method. */
    if (cbm_scope_contains(ctx->current_scope, name)) {
        return cbm_scope_lookup_callable(ctx->current_scope, name);
    }

    if (ctx->enclosing_class_qn) {
        const CBMRegisteredFunc *f = cs_lookup_method(ctx, ctx->enclosing_class_qn, name);
        if (f && f->qualified_name)
            return f->qualified_name;
    }
    if (ctx->enclosing_base_qn) {
        const CBMRegisteredFunc *f = cs_lookup_method(ctx, ctx->enclosing_base_qn, name);
        if (f && f->qualified_name)
            return f->qualified_name;
    }

    bool using_static_ambiguous = false;
    const CBMRegisteredFunc *using_static =
        cs_lookup_using_static_method(ctx, name, &using_static_ambiguous);
    if (using_static_ambiguous)
        return NULL;
    if (using_static)
        return using_static->qualified_name;

    const char *ns = cs_namespace_qn(ctx);
    if (ns && ns[0]) {
        const char *qn = cbm_arena_sprintf(ctx->arena, "%s.%s", ns, name);
        const CBMRegisteredFunc *f = cbm_registry_lookup_func(ctx->registry, qn);
        if (f && f->qualified_name)
            return f->qualified_name;
    }

    /* C# has no true namespace-level functions, but error-tolerant parses and
     * generated fixtures can register receiverless callables. Only accept a
     * unique short-name match; ambiguity is intentionally not guessed. */
    const CBMRegisteredFunc *only = NULL;
    CBMFreeFuncIter all_funcs;
    if (ctx->registry) {
        cbm_registry_all_funcs_chain(ctx->registry, &all_funcs);
    }
    for (int i = -1; ctx->registry && (i = cbm_free_func_iter_next(&all_funcs)) >= 0;) {
        const CBMRegisteredFunc *candidate = &all_funcs.reg->funcs[i];
        if (candidate->receiver_type || !candidate->short_name ||
            strcmp(candidate->short_name, name) != 0) {
            continue;
        }
        if (only && strcmp(only->qualified_name, candidate->qualified_name) != 0) {
            return NULL;
        }
        only = candidate;
    }
    return only ? only->qualified_name : NULL;
}

static TSNode cs_callable_name_leaf(TSNode node) {
    if (ts_node_is_null(node) || strcmp(ts_node_type(node), "generic_name") != 0) {
        return node;
    }

    TSNode leaf = ts_node_child_by_field_name(node, "name", 4);
    if (!ts_node_is_null(leaf))
        return leaf;
    uint32_t nc = ts_node_child_count(node);
    for (uint32_t i = 0; i < nc; i++) {
        TSNode child = ts_node_child(node, i);
        if (!ts_node_is_null(child) && ts_node_is_named(child) &&
            strcmp(ts_node_type(child), "identifier") == 0) {
            return child;
        }
    }
    return node;
}

static const char *cs_resolve_callable_value(CSLSPContext *ctx, TSNode node,
                                             TSNode *callable_leaf) {
    if (callable_leaf)
        memset(callable_leaf, 0, sizeof(*callable_leaf));
    if (!ctx || ts_node_is_null(node))
        return NULL;
    const char *kind = ts_node_type(node);

    if (strcmp(kind, "argument") == 0 || strcmp(kind, "parenthesized_expression") == 0 ||
        strcmp(kind, "equals_value_clause") == 0) {
        TSNode inner = ts_node_child_by_field_name(node, "expression", 10);
        if (ts_node_is_null(inner))
            inner = ts_node_child_by_field_name(node, "value", 5);
        if (ts_node_is_null(inner))
            inner = cs_first_named_child(node);
        return ts_node_is_null(inner) ? NULL : cs_resolve_callable_value(ctx, inner, callable_leaf);
    }

    if (strcmp(kind, "identifier") == 0 || strcmp(kind, "generic_name") == 0) {
        char *raw = cs_node_text(ctx, node);
        char *bare = raw ? cs_strip_generic_args(ctx->arena, raw) : NULL;
        const char *target = bare ? cs_resolve_callable_name(ctx, bare) : NULL;
        if (target && callable_leaf)
            *callable_leaf = cs_callable_name_leaf(node);
        return target;
    }

    if (strcmp(kind, "member_access_expression") != 0)
        return NULL;
    TSNode receiver = ts_node_child_by_field_name(node, "expression", 10);
    TSNode member = ts_node_child_by_field_name(node, "name", 4);
    if (ts_node_is_null(receiver))
        receiver = cs_first_named_child(node);
    if (ts_node_is_null(member)) {
        uint32_t nc = ts_node_child_count(node);
        for (uint32_t i = 0; i < nc; i++) {
            TSNode child = ts_node_child(node, i);
            if (ts_node_is_null(child) || !ts_node_is_named(child) || ts_node_eq(child, receiver)) {
                continue;
            }
            const char *child_kind = ts_node_type(child);
            if (strcmp(child_kind, "identifier") == 0 || strcmp(child_kind, "generic_name") == 0) {
                member = child;
            }
        }
    }
    if (ts_node_is_null(receiver) || ts_node_is_null(member))
        return NULL;

    char *member_raw = cs_node_text(ctx, member);
    char *member_name = member_raw ? cs_strip_generic_args(ctx->arena, member_raw) : NULL;
    if (!member_name)
        return NULL;

    char *receiver_text = cs_node_text(ctx, receiver);
    if (receiver_text) {
        const char *type_qn = cs_resolve_type_name(ctx, receiver_text);
        if (type_qn && cs_lookup_type_qn(ctx, type_qn)) {
            const CBMRegisteredFunc *f = cs_lookup_method(ctx, type_qn, member_name);
            if (f && callable_leaf)
                *callable_leaf = cs_callable_name_leaf(member);
            return f ? f->qualified_name : NULL;
        }
    }

    const CBMType *receiver_type = cs_unwrap_nullable(cs_eval_expr_type(ctx, receiver));
    const char *type_qn = NULL;
    if (receiver_type && receiver_type->kind == CBM_TYPE_NAMED) {
        type_qn = receiver_type->data.named.qualified_name;
    } else if (receiver_type && receiver_type->kind == CBM_TYPE_TEMPLATE) {
        type_qn = receiver_type->data.template_type.template_name;
    }
    if (!type_qn)
        return NULL;
    const CBMRegisteredFunc *f = cs_lookup_method(ctx, type_qn, member_name);
    if (!f)
        f = cs_lookup_extension(ctx, type_qn, member_name);
    if (f && callable_leaf)
        *callable_leaf = cs_callable_name_leaf(member);
    return f ? f->qualified_name : NULL;
}

static void cs_process_local_decl(CSLSPContext *ctx, TSNode node) {
    /* local_declaration_statement -> variable_declaration */
    TSNode vd = cs_child_named_kind(node, "variable_declaration");
    if (ts_node_is_null(vd))
        return;
    TSNode tnode = ts_node_child_by_field_name(vd, "type", 4);
    if (ts_node_is_null(tnode))
        tnode = cs_first_named_child(vd);
    /* For each declarator, bind the variable to (rhs_type or declared type). */
    uint32_t nc = ts_node_child_count(vd);
    bool is_var = false;
    if (!ts_node_is_null(tnode)) {
        char *tt = cs_node_text(ctx, tnode);
        if (tt && (strcmp(tt, "var") == 0 || strcmp(ts_node_type(tnode), "implicit_type") == 0)) {
            is_var = true;
        }
    }
    const CBMType *declared_type =
        ts_node_is_null(tnode) ? cbm_type_unknown() : cs_parse_type_node(ctx, tnode);
    for (uint32_t i = 0; i < nc; i++) {
        TSNode c = ts_node_child(vd, i);
        if (ts_node_is_null(c) || !ts_node_is_named(c))
            continue;
        const char *k = ts_node_type(c);
        if (strcmp(k, "variable_declarator") != 0)
            continue;
        TSNode nm = cs_child_named_kind(c, "identifier");
        if (ts_node_is_null(nm)) {
            nm = ts_node_child_by_field_name(c, "name", 4);
        }
        if (ts_node_is_null(nm))
            continue;
        char *vname = cs_node_text(ctx, nm);
        if (!vname)
            continue;
        /* Find initializer (= rhs). variable_declarator children depend on
         * the grammar: tree-sitter-c-sharp emits `_identifier_or_global`
         * (the name) + optional `=` token + value-expression; the value
         * may also be wrapped in equals_value_clause in some grammar
         * variants. Try the field-name path first, then fall back to
         * walking named children for any expression after the identifier. */
        TSNode init = ts_node_child_by_field_name(c, "value", 5);
        TSNode rhs_node;
        memset(&rhs_node, 0, sizeof(rhs_node));
        const CBMType *rhs_t = NULL;
        if (!ts_node_is_null(init)) {
            if (strcmp(ts_node_type(init), "equals_value_clause") == 0) {
                TSNode rhs = cs_first_named_child(init);
                if (!ts_node_is_null(rhs)) {
                    rhs_node = rhs;
                    rhs_t = cs_eval_expr_type(ctx, rhs);
                }
            } else {
                rhs_node = init;
                rhs_t = cs_eval_expr_type(ctx, init);
            }
        }
        if (!rhs_t || rhs_t->kind == CBM_TYPE_UNKNOWN) {
            /* Walk named children: skip identifier (the name), evaluate
             * the next named child as the rhs expression. Also catch the
             * legacy equals_value_clause shape. */
            uint32_t cc = ts_node_child_count(c);
            int seen_named = 0;
            for (uint32_t j = 0; j < cc; j++) {
                TSNode cn = ts_node_child(c, j);
                if (ts_node_is_null(cn) || !ts_node_is_named(cn))
                    continue;
                const char *ck = ts_node_type(cn);
                if (strcmp(ck, "equals_value_clause") == 0) {
                    TSNode rhs = cs_first_named_child(cn);
                    if (!ts_node_is_null(rhs)) {
                        rhs_node = rhs;
                        const CBMType *t = cs_eval_expr_type(ctx, rhs);
                        if (t && t->kind != CBM_TYPE_UNKNOWN)
                            rhs_t = t;
                    }
                    break;
                }
                if (seen_named == 0) {
                    seen_named++;
                    continue; /* the identifier name */
                }
                if (seen_named >= 1) {
                    rhs_node = cn;
                    const CBMType *t = cs_eval_expr_type(ctx, cn);
                    if (t && t->kind != CBM_TYPE_UNKNOWN) {
                        rhs_t = t;
                        break;
                    }
                }
            }
        }
        const CBMType *bind = is_var ? (rhs_t ? rhs_t : declared_type) : declared_type;
        if (!bind)
            bind = cbm_type_unknown();
        const char *callable_qn =
            ts_node_is_null(rhs_node) ? NULL : cs_resolve_callable_value(ctx, rhs_node, NULL);
        if (callable_qn) {
            cbm_scope_bind_callable(ctx->current_scope, vname, bind, callable_qn);
        } else {
            cbm_scope_bind(ctx->current_scope, vname, bind);
        }
    }
}

static void cs_process_foreach(CSLSPContext *ctx, TSNode node) {
    /* foreach_statement: type, identifier, expression. */
    TSNode tnode = ts_node_child_by_field_name(node, "type", 4);
    TSNode nnode = ts_node_child_by_field_name(node, "left", 4);
    if (ts_node_is_null(nnode))
        nnode = cs_child_named_kind(node, "identifier");
    TSNode iter = ts_node_child_by_field_name(node, "right", 5);
    if (ts_node_is_null(iter)) {
        /* Fallback: look for an expression-shaped child after the type. */
        uint32_t nc = ts_node_child_count(node);
        bool past_id = false;
        for (uint32_t i = 0; i < nc; i++) {
            TSNode c = ts_node_child(node, i);
            if (ts_node_is_null(c) || !ts_node_is_named(c))
                continue;
            const char *k = ts_node_type(c);
            if (strcmp(k, "identifier") == 0 && !past_id) {
                past_id = true;
                continue;
            }
            if (past_id) {
                if (strcmp(k, "block") == 0)
                    break;
                iter = c;
                break;
            }
        }
    }
    if (ts_node_is_null(nnode))
        return;
    char *vname = cs_node_text(ctx, nnode);
    if (!vname)
        return;

    const CBMType *element_t = cbm_type_unknown();
    if (!ts_node_is_null(iter)) {
        const CBMType *iter_t = cs_eval_expr_type(ctx, iter);
        if (iter_t && iter_t->kind == CBM_TYPE_TEMPLATE) {
            const CBMType *const *args = iter_t->data.template_type.template_args;
            if (args && args[0])
                element_t = args[0];
        }
    }
    if (!ts_node_is_null(tnode)) {
        const CBMType *declared = cs_parse_type_node(ctx, tnode);
        char *tt = cs_node_text(ctx, tnode);
        bool is_var = (tt && (strcmp(tt, "var") == 0));
        if (!is_var && declared && declared->kind != CBM_TYPE_UNKNOWN)
            element_t = declared;
    }
    cbm_scope_bind(ctx->current_scope, vname, element_t);
}

static void cs_process_using_statement(CSLSPContext *ctx, TSNode node) {
    /* `using (var x = expr) { ... }` — bind x. */
    TSNode vd = cs_child_named_kind(node, "variable_declaration");
    if (!ts_node_is_null(vd)) {
        /* Wrap as if it were a local_declaration_statement and dispatch. */
        TSNode wrapper;
        memset(&wrapper, 0, sizeof(wrapper));
        cs_process_local_decl(ctx, node);
    }
}

static void cs_process_assignment(CSLSPContext *ctx, TSNode node) {
    TSNode lhs = ts_node_child_by_field_name(node, "left", 4);
    TSNode rhs = ts_node_child_by_field_name(node, "right", 5);
    if (ts_node_is_null(lhs) || ts_node_is_null(rhs))
        return;
    if (!cs_node_is(lhs, "identifier"))
        return;
    char *vname = cs_node_text(ctx, lhs);
    if (!vname)
        return;
    const char *callable_qn = cs_resolve_callable_value(ctx, rhs, NULL);
    (void)cs_eval_expr_type(ctx, rhs);
    if (callable_qn) {
        cbm_scope_update_callable(ctx->current_scope, vname, callable_qn);
    } else {
        /* An ordinary or ambiguous reassignment clears stale callable identity
         * while retaining the best type already known for the variable. */
        cbm_scope_update_callable(ctx->current_scope, vname, NULL);
    }
}

/* ── call resolution + emit ─────────────────────────────────────── */

static void cs_invalidate_conditionally_assigned_callables(CSLSPContext *ctx, TSNode node) {
    if (!ctx || ts_node_is_null(node))
        return;
    const char *kind = ts_node_type(node);
    if (strcmp(kind, "method_declaration") == 0 || strcmp(kind, "local_function_statement") == 0 ||
        strcmp(kind, "lambda_expression") == 0 ||
        strcmp(kind, "anonymous_method_expression") == 0 ||
        strcmp(kind, "class_declaration") == 0 || strcmp(kind, "struct_declaration") == 0) {
        return;
    }
    if (strcmp(kind, "assignment_expression") == 0) {
        TSNode lhs = ts_node_child_by_field_name(node, "left", 4);
        if (ts_node_is_null(lhs))
            lhs = cs_first_named_child(node);
        if (cs_node_is(lhs, "identifier")) {
            char *name = cs_node_text(ctx, lhs);
            if (name)
                cbm_scope_update_callable(ctx->current_scope, name, NULL);
        }
        return;
    }
    uint32_t nc = ts_node_child_count(node);
    for (uint32_t i = 0; i < nc; i++) {
        TSNode child = ts_node_child(node, i);
        if (!ts_node_is_null(child) && ts_node_is_named(child)) {
            cs_invalidate_conditionally_assigned_callables(ctx, child);
        }
    }
}

static void cs_emit_resolved_kind_reason(CSLSPContext *ctx, const char *callee_qn,
                                         const char *strategy, float confidence,
                                         CBMResolvedKind kind, const char *reason) {
    if (!ctx->resolved_calls || !callee_qn || !ctx->enclosing_func_qn)
        return;
    CBMResolvedCall rc = {0};
    rc.caller_qn = ctx->enclosing_func_qn;
    rc.callee_qn = callee_qn;
    rc.strategy = strategy;
    rc.confidence = confidence;
    rc.reason = reason;
    rc.kind = kind;
    cbm_resolvedcall_push(ctx->resolved_calls, ctx->arena, rc);
}

static void cs_emit_resolved_kind(CSLSPContext *ctx, const char *callee_qn, const char *strategy,
                                  float confidence, CBMResolvedKind kind) {
    cs_emit_resolved_kind_reason(ctx, callee_qn, strategy, confidence, kind, NULL);
}

static void cs_emit_resolved(CSLSPContext *ctx, const char *callee_qn, const char *strategy,
                             float confidence) {
    cs_emit_resolved_kind(ctx, callee_qn, strategy, confidence, CBM_RESOLVED_INVOCATION);
}

static void cs_emit_resolved_reason(CSLSPContext *ctx, const char *callee_qn, const char *strategy,
                                    float confidence, const char *reason) {
    cs_emit_resolved_kind_reason(ctx, callee_qn, strategy, confidence, CBM_RESOLVED_INVOCATION,
                                 reason);
}

static void cs_stamp_resolved_site(CSLSPContext *ctx, int first, TSNode site) {
    if (!ctx->resolved_calls || ts_node_is_null(site) || first < 0)
        return;
    for (int i = first; i < ctx->resolved_calls->count; i++) {
        ctx->resolved_calls->items[i].site_start_byte = ts_node_start_byte(site);
        ctx->resolved_calls->items[i].site_end_byte = ts_node_end_byte(site);
    }
}

static void cs_emit_resolved_kind_reason_at(CSLSPContext *ctx, const char *callee_qn,
                                            const char *strategy, float confidence,
                                            CBMResolvedKind kind, const char *reason, TSNode site) {
    int first = ctx->resolved_calls ? ctx->resolved_calls->count : -1;
    cs_emit_resolved_kind_reason(ctx, callee_qn, strategy, confidence, kind, reason);
    cs_stamp_resolved_site(ctx, first, site);
}

static void cs_retarget_callable_carrier(CSLSPContext *ctx, TSNode site, const char *source_name,
                                         const char *target_qn) {
    if (!ctx || !ctx->call_carriers || ts_node_is_null(site) || !source_name || !target_qn ||
        !ctx->enclosing_func_qn) {
        return;
    }
    const char *target_name = cs_short_name(target_qn);
    uint32_t start = ts_node_start_byte(site);
    uint32_t end = ts_node_end_byte(site);
    for (int i = 0; i < ctx->call_carriers->count; i++) {
        CBMCall *call = &ctx->call_carriers->items[i];
        if (!call->callee_name || !call->enclosing_func_qn ||
            strcmp(call->callee_name, source_name) != 0 ||
            strcmp(call->enclosing_func_qn, ctx->enclosing_func_qn) != 0 ||
            call->site_start_byte < start || call->site_end_byte > end) {
            continue;
        }
        call->callee_name = cbm_arena_strdup(ctx->arena, target_name);
        call->requires_lsp_resolution = true;
    }
}

/* Promote only direct argument expressions whose value resolves to one exact
 * method group. Wrappers are peeled, but conditionals/switches/lambdas are not
 * traversed, so complex values retain parser-produced USAGE edges. */
static void cs_resolve_callable_arguments(CSLSPContext *ctx, TSNode call) {
    TSNode args = ts_node_child_by_field_name(call, "arguments", 9);
    if (ts_node_is_null(args))
        args = cs_child_named_kind(call, "argument_list");
    if (ts_node_is_null(args))
        return;

    uint32_t nc = ts_node_child_count(args);
    for (uint32_t i = 0; i < nc; i++) {
        TSNode argument = ts_node_child(args, i);
        if (ts_node_is_null(argument) || !ts_node_is_named(argument) ||
            strcmp(ts_node_type(argument), "argument") != 0) {
            continue;
        }
        TSNode value = ts_node_child_by_field_name(argument, "expression", 10);
        if (ts_node_is_null(value))
            value = ts_node_child_by_field_name(argument, "value", 5);
        if (ts_node_is_null(value)) {
            uint32_t ac = ts_node_child_count(argument);
            for (uint32_t j = ac; j > 0; j--) {
                TSNode child = ts_node_child(argument, j - 1);
                if (!ts_node_is_null(child) && ts_node_is_named(child)) {
                    value = child;
                    break;
                }
            }
        }
        if (ts_node_is_null(value))
            continue;
        TSNode callable_leaf;
        memset(&callable_leaf, 0, sizeof(callable_leaf));
        const char *target = cs_resolve_callable_value(ctx, value, &callable_leaf);
        if (!target)
            continue;
        if (ts_node_is_null(callable_leaf))
            continue;
        char *source_name = cs_node_text(ctx, callable_leaf);
        cs_emit_resolved_kind_reason_at(ctx, target, "lsp_callable_value_reference", 0.95f,
                                        CBM_RESOLVED_CALL_REFERENCE, source_name, callable_leaf);
    }
}

static void cs_resolve_invocation(CSLSPContext *ctx, TSNode call) {
    TSNode fn = ts_node_child_by_field_name(call, "function", 8);
    if (ts_node_is_null(fn)) {
        uint32_t nc = ts_node_child_count(call);
        for (uint32_t i = 0; i < nc; i++) {
            TSNode c = ts_node_child(call, i);
            if (!ts_node_is_null(c) && ts_node_is_named(c)) {
                const char *k = ts_node_type(c);
                if (strcmp(k, "argument_list") == 0)
                    continue;
                fn = c;
                break;
            }
        }
    }
    if (ts_node_is_null(fn))
        return;
    const char *fk = ts_node_type(fn);

    /* Member call. */
    if (strcmp(fk, "member_access_expression") == 0 ||
        strcmp(fk, "conditional_access_expression") == 0) {
        TSNode recv = ts_node_child_by_field_name(fn, "expression", 10);
        TSNode name = ts_node_child_by_field_name(fn, "name", 4);
        if (ts_node_is_null(recv))
            recv = cs_first_named_child(fn);
        if (ts_node_is_null(name)) {
            uint32_t fnc = ts_node_child_count(fn);
            for (uint32_t i = 0; i < fnc; i++) {
                TSNode c = ts_node_child(fn, i);
                if (!ts_node_is_null(c) && ts_node_is_named(c)) {
                    const char *k = ts_node_type(c);
                    if (strcmp(k, "identifier") == 0 || strcmp(k, "generic_name") == 0)
                        name = c;
                }
            }
        }
        if (ts_node_is_null(name))
            return;
        char *mname = cs_node_text(ctx, name);
        if (!mname)
            return;
        char *bare = cs_strip_generic_args(ctx->arena, mname);

        /* Static member call: receiver is a type identifier. */
        char *recv_text = ts_node_is_null(recv) ? NULL : cs_node_text(ctx, recv);
        if (recv_text) {
            const char *type_qn = cs_resolve_type_name(ctx, recv_text);
            if (type_qn && cs_lookup_type_qn(ctx, type_qn)) {
                const CBMRegisteredFunc *f = cs_lookup_method(ctx, type_qn, bare);
                if (f) {
                    cs_emit_resolved(ctx, f->qualified_name, "cs_static_typed", 0.95f);
                    return;
                }
                /* Type known, method not in registry — synth a call. */
                cs_emit_resolved(ctx, cbm_arena_sprintf(ctx->arena, "%s.%s", type_qn, bare),
                                 "cs_static_typed_unindexed", 0.55f);
                return;
            }
        }

        /* Instance call. */
        const CBMType *recv_type = cbm_type_unknown();
        if (!ts_node_is_null(recv))
            recv_type = cs_eval_expr_type(ctx, recv);
        recv_type = cs_unwrap_nullable(recv_type);
        const char *type_qn = NULL;
        if (recv_type && recv_type->kind == CBM_TYPE_NAMED) {
            type_qn = recv_type->data.named.qualified_name;
        } else if (recv_type && recv_type->kind == CBM_TYPE_TEMPLATE) {
            type_qn = recv_type->data.template_type.template_name;
        }
        if (!type_qn)
            return;
        const CBMRegisteredFunc *f = cs_lookup_method(ctx, type_qn, bare);
        if (f) {
            const char *strategy = (f->receiver_type && strcmp(f->receiver_type, type_qn) == 0)
                                       ? "cs_method_typed"
                                       : "cs_method_inherited";
            cs_emit_resolved(ctx, f->qualified_name, strategy, 0.95f);
            return;
        }
        /* Try extension method. */
        f = cs_lookup_extension(ctx, type_qn, bare);
        if (f) {
            cs_emit_resolved(ctx, f->qualified_name, "cs_extension_method", 0.90f);
            return;
        }
        /* Type known, method missing — emit unindexed marker so the textual
         * fallback in the pipeline is suppressed. */
        cs_emit_resolved(ctx, cbm_arena_sprintf(ctx->arena, "%s.%s", type_qn, bare),
                         "cs_method_typed_unindexed", 0.55f);
        return;
    }

    /* Bare invocation: `Method()` */
    if (strcmp(fk, "identifier") == 0 || strcmp(fk, "generic_name") == 0) {
        char *fname = cs_node_text(ctx, fn);
        if (!fname)
            return;
        char *bare = cs_strip_generic_args(ctx->arena, fname);

        /* Callable-valued locals and parameters shadow class/static methods.
         * An exact alias carries its real target; an ordinary lexical value
         * suppresses all same-name fallbacks so we never fabricate a call. */
        if (cbm_scope_contains(ctx->current_scope, bare)) {
            const char *target = cbm_scope_lookup_callable(ctx->current_scope, bare);
            if (target) {
                cs_emit_resolved_reason(ctx, target, "lsp_callable_alias", 0.98f, bare);
                cs_retarget_callable_carrier(ctx, call, bare, target);
            }
            return;
        }

        /* Try enclosing class member. cs_lookup_method walks the base chain, so
         * a bare call may resolve to an INHERITED method. Distinguish, exactly
         * as the instance-call path does: a method actually declared on the
         * enclosing class is cs_self_method; one found on a base is
         * cs_inherited_method. */
        if (ctx->enclosing_class_qn) {
            const CBMRegisteredFunc *f = cs_lookup_method(ctx, ctx->enclosing_class_qn, bare);
            if (f) {
                bool own =
                    f->receiver_type && strcmp(f->receiver_type, ctx->enclosing_class_qn) == 0;
                cs_emit_resolved(ctx, f->qualified_name,
                                 own ? "cs_self_method" : "cs_inherited_method",
                                 own ? 0.95f : 0.92f);
                return;
            }
        }
        /* Try base class chain explicitly (for `base.Foo()` style calls
         * happen via base_expression handled above; this is for inherited
         * methods invoked without `this.`). */
        if (ctx->enclosing_base_qn) {
            const CBMRegisteredFunc *f = cs_lookup_method(ctx, ctx->enclosing_base_qn, bare);
            if (f) {
                cs_emit_resolved(ctx, f->qualified_name, "cs_inherited_method", 0.92f);
                return;
            }
        }
        /* Try `using static` imports. The directive target is the namespace-
         * qualified name as written ("Demo.MathUtil"), but types register under
         * the file-stem QN ("proj.Client.MathUtil"); resolve the target through
         * the type-name resolver (its short-name fallback bridges the two)
         * before the method lookup. */
        bool using_static_ambiguous = false;
        const CBMRegisteredFunc *using_static =
            cs_lookup_using_static_method(ctx, bare, &using_static_ambiguous);
        if (using_static_ambiguous)
            return;
        if (using_static) {
            cs_emit_resolved(ctx, using_static->qualified_name, "cs_using_static", 0.90f);
            return;
        }

        /* Free function in current namespace. */
        const char *ns = cs_namespace_qn(ctx);
        if (ns && *ns) {
            const char *qn = cbm_arena_sprintf(ctx->arena, "%s.%s", ns, bare);
            const CBMRegisteredFunc *f = cbm_registry_lookup_func(ctx->registry, qn);
            if (f) {
                cs_emit_resolved(ctx, f->qualified_name, "cs_namespace_func", 0.92f);
                return;
            }
        }
        /* Last resort: any free function with this short name in registry. */
        const CBMRegisteredFunc *best = NULL;
        int best_score = -1;
        CBMFreeFuncIter all_funcs;
        if (ctx->registry) {
            cbm_registry_all_funcs_chain(ctx->registry, &all_funcs);
        }
        for (int i = -1; ctx->registry && (i = cbm_free_func_iter_next(&all_funcs)) >= 0;) {
            const CBMRegisteredFunc *cand = &all_funcs.reg->funcs[i];
            if (cand->receiver_type)
                continue;
            if (!cand->short_name || strcmp(cand->short_name, bare) != 0)
                continue;
            int score = 0;
            if (cand->qualified_name && ctx->module_qn) {
                const char *m = ctx->module_qn;
                const char *q = cand->qualified_name;
                while (*m && *q && *m == *q) {
                    if (*m == '.')
                        score++;
                    m++;
                    q++;
                }
            }
            if (score > best_score) {
                best_score = score;
                best = cand;
            }
        }
        if (best) {
            cs_emit_resolved(ctx, best->qualified_name, "cs_free_func_fallback", 0.65f);
            return;
        }
    }
}

static void cs_resolve_object_creation(CSLSPContext *ctx, TSNode call) {
    /* `new Foo(...)` adds an implicit constructor CALLS edge: to Foo's ctor
     * Method node when one is indexed, otherwise to the Foo class node. */
    TSNode tnode = ts_node_child_by_field_name(call, "type", 4);
    if (ts_node_is_null(tnode))
        return;
    const CBMType *t = cs_parse_type_node(ctx, tnode);
    const char *tqn = NULL;
    if (t && t->kind == CBM_TYPE_NAMED)
        tqn = t->data.named.qualified_name;
    else if (t && t->kind == CBM_TYPE_TEMPLATE)
        tqn = t->data.template_type.template_name;
    if (!tqn)
        return;
    /* A C# constructor is extracted as a Method whose short name is the class's
     * short name (the constructor_declaration `name` field is the class
     * identifier), so the ctor QN is `<type_qn>.<ShortName>` — never ".ctor".
     * Look it up by the class short name, mirroring the Java resolver. */
    const char *dot = strrchr(tqn, '.');
    const char *short_name = dot ? dot + 1 : tqn;
    const CBMRegisteredFunc *f = cs_lookup_method(ctx, tqn, short_name);
    if (f) {
        cs_emit_resolved(ctx, f->qualified_name, "cs_ctor", 0.95f);
        return;
    }
    /* No explicit constructor in the registry. Resolve the `new Foo()` call to
     * the Foo CLASS node (`tqn`): its short name equals the call's textual
     * callee_name ("Foo"), so the pipeline join matches, and the class node
     * always exists, so a CALLS edge forms carrying the strategy — rather than
     * the old `Foo..ctor`, whose ".ctor" short name joined nothing and resolved
     * to no node. */
    cs_emit_resolved(ctx, tqn, "cs_ctor_synthetic", 0.85f);
}

static void cs_resolve_calls_in_node(CSLSPContext *ctx, TSNode node) {
    if (ts_node_is_null(node))
        return;
    const char *kind = ts_node_type(node);

    /* Scope-shaping nodes. */
    if (strcmp(kind, "block") == 0) {
        CBMScope *prev = ctx->current_scope;
        ctx->current_scope = cbm_scope_push(ctx->arena, prev);
        // Cursor walk (O(n)); ts_node_child(node,i) is O(i) → O(n²) on a wide block.
        TSTreeCursor cursor = ts_tree_cursor_new(node);
        if (ts_tree_cursor_goto_first_child(&cursor)) {
            do {
                cs_resolve_calls_in_node(ctx, ts_tree_cursor_current_node(&cursor));
            } while (ts_tree_cursor_goto_next_sibling(&cursor));
        }
        ts_tree_cursor_delete(&cursor);
        ctx->current_scope = prev;
        return;
    }

    if (strcmp(kind, "local_declaration_statement") == 0) {
        cs_process_local_decl(ctx, node);
    } else if (strcmp(kind, "for_each_statement") == 0 || strcmp(kind, "foreach_statement") == 0) {
        cs_process_foreach(ctx, node);
    } else if (strcmp(kind, "using_statement") == 0) {
        cs_process_using_statement(ctx, node);
    } else if (strcmp(kind, "assignment_expression") == 0) {
        cs_process_assignment(ctx, node);
    } else if (strcmp(kind, "invocation_expression") == 0) {
        int first = ctx->resolved_calls ? ctx->resolved_calls->count : -1;
        cs_resolve_invocation(ctx, node);
        cs_stamp_resolved_site(ctx, first, node);
        cs_resolve_callable_arguments(ctx, node);
    } else if (strcmp(kind, "object_creation_expression") == 0) {
        int first = ctx->resolved_calls ? ctx->resolved_calls->count : -1;
        cs_resolve_object_creation(ctx, node);
        cs_stamp_resolved_site(ctx, first, node);
    }

    /* Recurse into children. We do NOT pre-bind anything that would only be
     * available after the child is processed — left-to-right walk is fine for
     * most C# constructs at a Light-Semantic-Pass level. */
    // Cursor walk (O(n)); ts_node_child(node,i) is O(i) → O(n²) on a wide node.
    TSTreeCursor cursor = ts_tree_cursor_new(node);
    if (!ts_tree_cursor_goto_first_child(&cursor)) {
        ts_tree_cursor_delete(&cursor);
        return;
    }
    do {
        TSNode c = ts_tree_cursor_current_node(&cursor);
        const char *ck = ts_node_type(c);
        /* Don't recurse into nested type/method bodies — they're processed by
         * the pass-2 walker which rebuilds enclosing context. */
        if (strcmp(ck, "class_declaration") == 0 || strcmp(ck, "struct_declaration") == 0 ||
            strcmp(ck, "record_declaration") == 0 || strcmp(ck, "interface_declaration") == 0 ||
            strcmp(ck, "enum_declaration") == 0 || strcmp(ck, "method_declaration") == 0 ||
            strcmp(ck, "constructor_declaration") == 0 ||
            strcmp(ck, "destructor_declaration") == 0 || strcmp(ck, "operator_declaration") == 0 ||
            strcmp(ck, "conversion_operator_declaration") == 0 ||
            strcmp(ck, "indexer_declaration") == 0 || strcmp(ck, "property_declaration") == 0 ||
            strcmp(ck, "event_declaration") == 0 || strcmp(ck, "local_function_statement") == 0 ||
            strcmp(ck, "namespace_declaration") == 0 ||
            strcmp(ck, "file_scoped_namespace_declaration") == 0) {
            continue;
        }
        cs_resolve_calls_in_node(ctx, c);
    } while (ts_tree_cursor_goto_next_sibling(&cursor));
    ts_tree_cursor_delete(&cursor);
    if (strcmp(kind, "if_statement") == 0 || strcmp(kind, "switch_statement") == 0 ||
        strcmp(kind, "switch_expression") == 0 || strcmp(kind, "for_statement") == 0 ||
        strcmp(kind, "for_each_statement") == 0 || strcmp(kind, "foreach_statement") == 0 ||
        strcmp(kind, "while_statement") == 0 || strcmp(kind, "do_statement") == 0 ||
        strcmp(kind, "try_statement") == 0) {
        cs_invalidate_conditionally_assigned_callables(ctx, node);
    }
}

/* ── method/constructor processing ──────────────────────────────── */

static void cs_collect_type_params(CSLSPContext *ctx, TSNode node, const char ***out_names,
                                   int *out_count) {
    *out_names = NULL;
    *out_count = 0;
    TSNode tplist = ts_node_child_by_field_name(node, "type_parameters", 15);
    if (ts_node_is_null(tplist))
        tplist = cs_child_named_kind(node, "type_parameter_list");
    if (ts_node_is_null(tplist))
        return;
    uint32_t nc = ts_node_child_count(tplist);
    int cap = 4;
    const char **arr = (const char **)cbm_arena_alloc(ctx->arena, (size_t)cap * sizeof(*arr));
    if (!arr)
        return;
    int n = 0;
    for (uint32_t i = 0; i < nc; i++) {
        TSNode c = ts_node_child(tplist, i);
        if (ts_node_is_null(c) || !ts_node_is_named(c))
            continue;
        if (strcmp(ts_node_type(c), "type_parameter") != 0)
            continue;
        TSNode id = cs_first_named_child(c);
        if (ts_node_is_null(id))
            continue;
        char *name = cs_node_text(ctx, id);
        if (!name)
            continue;
        if (n + 1 >= cap) {
            int new_cap = cap * 2;
            const char **ne =
                (const char **)cbm_arena_alloc(ctx->arena, (size_t)new_cap * sizeof(*ne));
            if (!ne)
                break;
            for (int j = 0; j < n; j++)
                ne[j] = arr[j];
            arr = ne;
            cap = new_cap;
        }
        arr[n++] = name;
    }
    arr[n] = NULL;
    *out_names = arr;
    *out_count = n;
}

static void cs_process_function_like(CSLSPContext *ctx, TSNode node) {
    const char *kind = ts_node_type(node);
    bool is_method =
        (strcmp(kind, "method_declaration") == 0 || strcmp(kind, "local_function_statement") == 0);
    bool is_ctor = strcmp(kind, "constructor_declaration") == 0;
    bool is_dtor = strcmp(kind, "destructor_declaration") == 0;
    bool is_property = strcmp(kind, "property_declaration") == 0;
    bool is_indexer = strcmp(kind, "indexer_declaration") == 0;
    bool is_op = strcmp(kind, "operator_declaration") == 0 ||
                 strcmp(kind, "conversion_operator_declaration") == 0;

    CBMScope *saved_scope = ctx->current_scope;
    const char *saved_func = ctx->enclosing_func_qn;
    const char **saved_tp = ctx->type_param_names;
    const CBMType **saved_tp_args = ctx->type_param_args;
    int saved_tp_count = ctx->type_param_count;

    ctx->current_scope = cbm_scope_push(ctx->arena, ctx->current_scope);

    /* Determine func short name + QN. */
    const char *short_name = NULL;
    if (is_method) {
        TSNode nm = ts_node_child_by_field_name(node, "name", 4);
        if (!ts_node_is_null(nm))
            short_name = cs_node_text(ctx, nm);
    } else if (is_ctor) {
        short_name = ".ctor";
    } else if (is_dtor) {
        short_name = ".dtor";
    } else if (is_property) {
        TSNode nm = ts_node_child_by_field_name(node, "name", 4);
        if (!ts_node_is_null(nm))
            short_name = cs_node_text(ctx, nm);
    } else if (is_indexer) {
        short_name = "this[]";
    } else if (is_op) {
        TSNode op = ts_node_child_by_field_name(node, "operator", 8);
        if (!ts_node_is_null(op))
            short_name = cs_node_text(ctx, op);
    }

    if (short_name) {
        if (ctx->enclosing_class_qn) {
            ctx->enclosing_func_qn =
                cbm_arena_sprintf(ctx->arena, "%s.%s", ctx->enclosing_class_qn, short_name);
        } else if (ctx->module_qn) {
            ctx->enclosing_func_qn =
                cbm_arena_sprintf(ctx->arena, "%s.%s", ctx->module_qn, short_name);
        } else {
            ctx->enclosing_func_qn = cbm_arena_strdup(ctx->arena, short_name);
        }
    }

    /* Collect generic type parameters. */
    if (is_method) {
        const char **tp_names = NULL;
        int tp_count = 0;
        cs_collect_type_params(ctx, node, &tp_names, &tp_count);
        if (tp_count > 0) {
            const CBMType **args = (const CBMType **)cbm_arena_alloc(
                ctx->arena, (size_t)(tp_count + 1) * sizeof(*args));
            if (args) {
                for (int i = 0; i < tp_count; i++) {
                    args[i] = cbm_type_type_param(ctx->arena, tp_names[i]);
                }
                args[tp_count] = NULL;
                ctx->type_param_names = tp_names;
                ctx->type_param_args = args;
                ctx->type_param_count = tp_count;
            }
        }
    }

    /* Bind parameters. Detect extension method (first param has `this`). */
    bool is_extension = false;
    if (is_method) {
        TSNode params = ts_node_child_by_field_name(node, "parameters", 10);
        if (ts_node_is_null(params))
            params = cs_child_named_kind(node, "parameter_list");
        if (!ts_node_is_null(params)) {
            /* Detect `this` modifier on first parameter. */
            uint32_t nc = ts_node_child_count(params);
            for (uint32_t i = 0; i < nc; i++) {
                TSNode c = ts_node_child(params, i);
                if (ts_node_is_null(c) || !ts_node_is_named(c))
                    continue;
                if (strcmp(ts_node_type(c), "parameter") != 0)
                    continue;
                /* Look for "this" keyword child. */
                uint32_t pc = ts_node_child_count(c);
                for (uint32_t j = 0; j < pc; j++) {
                    TSNode cc = ts_node_child(c, j);
                    if (ts_node_is_null(cc))
                        continue;
                    if (strcmp(ts_node_type(cc), "this") == 0) {
                        is_extension = true;
                        break;
                    }
                }
                break;
            }
            cs_bind_parameters(ctx, params, is_extension);
        }
    } else if (is_indexer) {
        TSNode params = cs_child_named_kind(node, "bracketed_parameter_list");
        if (!ts_node_is_null(params))
            cs_bind_parameters(ctx, params, false);
    } else if (is_ctor || is_op) {
        TSNode params = cs_child_named_kind(node, "parameter_list");
        if (!ts_node_is_null(params))
            cs_bind_parameters(ctx, params, false);
    }

    /* Walk body. */
    TSNode body = ts_node_child_by_field_name(node, "body", 4);
    if (ts_node_is_null(body)) {
        /* Expression-bodied: => expr; */
        TSNode arrow = cs_child_named_kind(node, "arrow_expression_clause");
        if (!ts_node_is_null(arrow)) {
            TSNode expr = cs_first_named_child(arrow);
            if (!ts_node_is_null(expr))
                cs_resolve_calls_in_node(ctx, expr);
        }
    } else {
        cs_resolve_calls_in_node(ctx, body);
    }

    /* Property accessors */
    if (is_property || is_indexer) {
        TSNode accessors = cs_child_named_kind(node, "accessor_list");
        if (!ts_node_is_null(accessors)) {
            uint32_t nc = ts_node_child_count(accessors);
            for (uint32_t i = 0; i < nc; i++) {
                TSNode a = ts_node_child(accessors, i);
                if (ts_node_is_null(a) || !ts_node_is_named(a))
                    continue;
                if (strcmp(ts_node_type(a), "accessor_declaration") != 0)
                    continue;
                TSNode abody = ts_node_child_by_field_name(a, "body", 4);
                if (ts_node_is_null(abody))
                    abody = cs_child_named_kind(a, "block");
                if (!ts_node_is_null(abody))
                    cs_resolve_calls_in_node(ctx, abody);
                else {
                    TSNode arrow = cs_child_named_kind(a, "arrow_expression_clause");
                    if (!ts_node_is_null(arrow)) {
                        TSNode expr = cs_first_named_child(arrow);
                        if (!ts_node_is_null(expr))
                            cs_resolve_calls_in_node(ctx, expr);
                    }
                }
            }
        }
    }

    /* Restore. */
    ctx->current_scope = saved_scope;
    ctx->enclosing_func_qn = saved_func;
    ctx->type_param_names = saved_tp;
    ctx->type_param_args = saved_tp_args;
    ctx->type_param_count = saved_tp_count;
}

/* ── type declaration processing ────────────────────────────────── */

static void cs_process_type_decl(CSLSPContext *ctx, TSNode node) {
    const char *kind = ts_node_type(node);
    bool is_class = strcmp(kind, "class_declaration") == 0;
    bool is_struct = strcmp(kind, "struct_declaration") == 0;
    bool is_record =
        strcmp(kind, "record_declaration") == 0 || strcmp(kind, "record_struct_declaration") == 0;
    bool is_iface = strcmp(kind, "interface_declaration") == 0;
    bool is_enum = strcmp(kind, "enum_declaration") == 0;
    (void)is_struct;
    (void)is_record;
    (void)is_iface;

    TSNode nm = ts_node_child_by_field_name(node, "name", 4);
    if (ts_node_is_null(nm)) {
        ctx->debug &&fprintf(stderr, "[cs_lsp] type decl missing name\n");
        return;
    }
    char *cname = cs_node_text(ctx, nm);
    if (!cname)
        return;

    const char *saved_class = ctx->enclosing_class_qn;
    const char *saved_base = ctx->enclosing_base_qn;
    const char **saved_ifs = ctx->enclosing_iface_qns;
    const char **saved_tp = ctx->type_param_names;
    const CBMType **saved_tp_args = ctx->type_param_args;
    int saved_tp_count = ctx->type_param_count;

    /* Compute QN: prefer module-qn-prefixed (matches unified extractor),
     * even though the C# `namespace` is also tracked for resolution. */
    if (ctx->module_qn) {
        ctx->enclosing_class_qn = cbm_arena_sprintf(ctx->arena, "%s.%s", ctx->module_qn, cname);
    } else {
        ctx->enclosing_class_qn = cbm_arena_strdup(ctx->arena, cname);
    }

    /* Type parameters. */
    const char **tp_names = NULL;
    int tp_count = 0;
    cs_collect_type_params(ctx, node, &tp_names, &tp_count);
    if (tp_count > 0) {
        const CBMType **args =
            (const CBMType **)cbm_arena_alloc(ctx->arena, (size_t)(tp_count + 1) * sizeof(*args));
        if (args) {
            for (int i = 0; i < tp_count; i++) {
                args[i] = cbm_type_type_param(ctx->arena, tp_names[i]);
            }
            args[tp_count] = NULL;
            ctx->type_param_names = tp_names;
            ctx->type_param_args = args;
            ctx->type_param_count = tp_count;
        }
    }

    /* Base list -> enclosing_base_qn + enclosing_iface_qns. */
    {
        TSNode bl = cs_child_named_kind(node, "base_list");
        if (!ts_node_is_null(bl)) {
            uint32_t nc = ts_node_child_count(bl);
            int icap = 4, icount = 0;
            const char **ifs =
                (const char **)cbm_arena_alloc(ctx->arena, (size_t)icap * sizeof(*ifs));
            for (uint32_t i = 0; i < nc; i++) {
                TSNode c = ts_node_child(bl, i);
                if (ts_node_is_null(c) || !ts_node_is_named(c))
                    continue;
                char *t = cs_node_text(ctx, c);
                if (!t)
                    continue;
                /* Strip generic args for QN resolution. */
                char *bare = cs_strip_generic_args(ctx->arena, t);
                const char *qn = cs_resolve_type_name(ctx, bare ? bare : t);
                if (!qn)
                    continue;
                /* Heuristic: first base whose registry says is_interface=true
                 * goes to interfaces; first non-interface goes to base. */
                const CBMRegisteredType *rt = cs_lookup_type_qn(ctx, qn);
                if (rt && rt->is_interface) {
                    if (icount + 1 >= icap) {
                        int nc2 = icap * 2;
                        const char **ne =
                            (const char **)cbm_arena_alloc(ctx->arena, (size_t)nc2 * sizeof(*ne));
                        if (!ne)
                            continue;
                        for (int j = 0; j < icount; j++)
                            ne[j] = ifs[j];
                        ifs = ne;
                        icap = nc2;
                    }
                    ifs[icount++] = qn;
                } else {
                    if (!ctx->enclosing_base_qn)
                        ctx->enclosing_base_qn = qn;
                    else {
                        if (icount + 1 >= icap) {
                            int nc2 = icap * 2;
                            const char **ne = (const char **)cbm_arena_alloc(
                                ctx->arena, (size_t)nc2 * sizeof(*ne));
                            if (!ne)
                                continue;
                            for (int j = 0; j < icount; j++)
                                ne[j] = ifs[j];
                            ifs = ne;
                            icap = nc2;
                        }
                        ifs[icount++] = qn;
                    }
                }
            }
            ifs[icount] = NULL;
            ctx->enclosing_iface_qns = ifs;
        }
    }

    /* Walk body. Enums don't have methods worth resolving; skip recurse. */
    if (!is_enum) {
        TSNode body = ts_node_child_by_field_name(node, "body", 4);
        if (ts_node_is_null(body))
            body = cs_child_named_kind(node, "declaration_list");
        if (!ts_node_is_null(body)) {
            uint32_t nc = ts_node_child_count(body);
            for (uint32_t i = 0; i < nc; i++) {
                TSNode c = ts_node_child(body, i);
                if (ts_node_is_null(c) || !ts_node_is_named(c))
                    continue;
                const char *k = ts_node_type(c);
                if (strcmp(k, "method_declaration") == 0 ||
                    strcmp(k, "constructor_declaration") == 0 ||
                    strcmp(k, "destructor_declaration") == 0 ||
                    strcmp(k, "operator_declaration") == 0 ||
                    strcmp(k, "conversion_operator_declaration") == 0 ||
                    strcmp(k, "indexer_declaration") == 0 ||
                    strcmp(k, "property_declaration") == 0 || strcmp(k, "event_declaration") == 0) {
                    cs_process_function_like(ctx, c);
                } else if (strcmp(k, "class_declaration") == 0 ||
                           strcmp(k, "struct_declaration") == 0 ||
                           strcmp(k, "record_declaration") == 0 ||
                           strcmp(k, "interface_declaration") == 0 ||
                           strcmp(k, "enum_declaration") == 0) {
                    /* Nested type. Recurse, but with the OUTER class's
                     * enclosing_class_qn replaced. */
                    cs_process_type_decl(ctx, c);
                }
            }
        }
        /* Records with primary constructor parameter list — bind in a synthetic
         * `.ctor` scope so any default-value expressions get resolved. */
        TSNode pctor = cs_child_named_kind(node, "parameter_list");
        if (!ts_node_is_null(pctor)) {
            CBMScope *prev = ctx->current_scope;
            ctx->current_scope = cbm_scope_push(ctx->arena, prev);
            const char *prev_func = ctx->enclosing_func_qn;
            ctx->enclosing_func_qn =
                cbm_arena_sprintf(ctx->arena, "%s..ctor", ctx->enclosing_class_qn);
            cs_bind_parameters(ctx, pctor, false);
            ctx->enclosing_func_qn = prev_func;
            ctx->current_scope = prev;
        }
    }
    (void)is_class;

    ctx->enclosing_class_qn = saved_class;
    ctx->enclosing_base_qn = saved_base;
    ctx->enclosing_iface_qns = saved_ifs;
    ctx->type_param_names = saved_tp;
    ctx->type_param_args = saved_tp_args;
    ctx->type_param_count = saved_tp_count;
}

/* ── using collection ───────────────────────────────────────────── */

static void cs_collect_imports(CSLSPContext *ctx, TSNode root) {
    /* Walk the entire tree once at top — using directives can appear at file
     * scope or inside namespace blocks. `in_ns` records per stacked node
     * whether it sits inside a namespace declaration: a block namespace's
     * body, or the compilation-unit siblings after a file-scoped namespace
     * (the grammar may attach those either way). */
    enum { CS_IMPORT_WALK_MAX = 256 };
    TSNode stack[CS_IMPORT_WALK_MAX];
    bool in_ns[CS_IMPORT_WALK_MAX];
    int top = 0;
    in_ns[top] = false;
    stack[top++] = root;
    while (top > 0) {
        TSNode n = stack[--top];
        bool n_in_ns = in_ns[top];
        if (ts_node_is_null(n))
            continue;
        const char *k = ts_node_type(n);
        if (strcmp(k, "using_directive") == 0) {
            /* Inspect modifiers and target. tree-sitter-c-sharp uses the
             * `alias` field on using_directive for the alias name (in
             * `using A = X;` the field "alias" holds A). When the field
             * isn't populated (older grammar), we detect aliasing by the
             * presence of an `=` token between identifier children. */
            bool is_global = false;
            bool is_static = false;
            bool is_alias = false;
            const char *alias_name = NULL;
            const char *target = NULL;
            TSNode alias_node = ts_node_child_by_field_name(n, "alias", 5);
            if (!ts_node_is_null(alias_node)) {
                is_alias = true;
                char *t = cs_node_text(ctx, alias_node);
                if (t)
                    alias_name = t;
            }
            /* Detect `=` token between named children to flag aliasing
             * even when the `alias` field isn't populated. */
            uint32_t nc = ts_node_child_count(n);
            bool seen_equals = false;
            TSNode pre_eq;
            memset(&pre_eq, 0, sizeof(pre_eq));
            TSNode post_eq;
            memset(&post_eq, 0, sizeof(post_eq));
            for (uint32_t i = 0; i < nc; i++) {
                TSNode c = ts_node_child(n, i);
                if (ts_node_is_null(c))
                    continue;
                const char *ck = ts_node_type(c);
                /* Tokens (anonymous and named alike) for keywords + `=`. */
                if (strcmp(ck, "global") == 0) {
                    is_global = true;
                    continue;
                }
                if (strcmp(ck, "static") == 0) {
                    is_static = true;
                    continue;
                }
                if (strcmp(ck, "=") == 0) {
                    seen_equals = true;
                    continue;
                }
                if (!ts_node_is_named(c))
                    continue;
                if (strcmp(ck, "name_equals") == 0) {
                    /* Older grammar variant. */
                    is_alias = true;
                    TSNode id = cs_first_named_child(c);
                    if (!ts_node_is_null(id))
                        alias_name = cs_node_text(ctx, id);
                    continue;
                }
                /* identifier / qualified_name / generic_name. */
                if (!seen_equals && ts_node_is_null(pre_eq)) {
                    pre_eq = c;
                } else if (seen_equals && ts_node_is_null(post_eq)) {
                    post_eq = c;
                }
            }
            if (seen_equals && !ts_node_is_null(pre_eq) && !ts_node_is_null(post_eq)) {
                /* `using <pre_eq> = <post_eq>;` — aliasing. */
                is_alias = true;
                if (!alias_name) {
                    char *t = cs_node_text(ctx, pre_eq);
                    if (t)
                        alias_name = t;
                }
                char *t = cs_node_text(ctx, post_eq);
                if (t)
                    target = cs_normalize_name(ctx->arena, t);
            } else if (!ts_node_is_null(pre_eq) && !target) {
                /* Non-aliased: `using X;` — pre_eq is the target. */
                char *t = cs_node_text(ctx, pre_eq);
                if (t)
                    target = cs_normalize_name(ctx->arena, t);
            }
            if (target) {
                if (is_alias) {
                    cs_add_using_scoped(ctx, CBM_CS_USING_ALIAS, alias_name ? alias_name : "",
                                        target, is_global, n_in_ns);
                } else if (is_static) {
                    cs_add_using_scoped(ctx, CBM_CS_USING_STATIC, "", target, is_global, n_in_ns);
                } else {
                    cs_add_using_scoped(ctx, CBM_CS_USING_NAMESPACE, "", target, is_global,
                                        n_in_ns);
                }
            }
        }
        /* Push children for traversal. We don't recurse into method bodies
         * (using directives can't appear there), but namespace bodies may
         * contain more usings. */
        bool child_in_ns = n_in_ns || strcmp(k, "namespace_declaration") == 0 ||
                           strcmp(k, "file_scoped_namespace_declaration") == 0;
        uint32_t cnc = ts_node_child_count(n);
        for (uint32_t i = 0; i < cnc && top < CS_IMPORT_WALK_MAX; i++) {
            TSNode c = ts_node_child(n, i);
            if (ts_node_is_null(c))
                continue;
            const char *ck = ts_node_type(c);
            if (strcmp(ck, "method_declaration") == 0 ||
                strcmp(ck, "constructor_declaration") == 0 || strcmp(ck, "block") == 0) {
                continue;
            }
            in_ns[top] = child_in_ns;
            stack[top++] = c;
            /* A file-scoped namespace covers the siblings that follow it. */
            if (strcmp(ck, "file_scoped_namespace_declaration") == 0)
                child_in_ns = true;
        }
    }
}

/* ── namespace collection ───────────────────────────────────────── */

static void cs_collect_namespace(CSLSPContext *ctx, TSNode ns_node, bool file_scoped) {
    TSNode nm = ts_node_child_by_field_name(ns_node, "name", 4);
    if (ts_node_is_null(nm))
        return;
    char *raw = cs_node_text(ctx, nm);
    if (!raw)
        return;
    const char *normalized = cs_normalize_name(ctx->arena, raw);
    cs_namespace_push(ctx, normalized);
    /* Walk body — file-scoped namespaces have body items as siblings of nm.
     * Block-style have a body node. */
    if (file_scoped) {
        /* The file-scoped namespace's siblings (in the compilation_unit, after
         * the namespace decl) are the contents — handled by the caller's
         * top-level walk. We just push the namespace and return. */
        return;
    }
    TSNode body = ts_node_child_by_field_name(ns_node, "body", 4);
    if (ts_node_is_null(body))
        body = cs_child_named_kind(ns_node, "declaration_list");
    if (!ts_node_is_null(body)) {
        uint32_t nc = ts_node_child_count(body);
        for (uint32_t i = 0; i < nc; i++) {
            TSNode c = ts_node_child(body, i);
            if (ts_node_is_null(c) || !ts_node_is_named(c))
                continue;
            const char *ck = ts_node_type(c);
            if (strcmp(ck, "namespace_declaration") == 0) {
                cs_collect_namespace(ctx, c, false);
            } else if (strcmp(ck, "file_scoped_namespace_declaration") == 0) {
                cs_collect_namespace(ctx, c, true);
            } else if (strcmp(ck, "class_declaration") == 0 ||
                       strcmp(ck, "struct_declaration") == 0 ||
                       strcmp(ck, "record_declaration") == 0 ||
                       strcmp(ck, "interface_declaration") == 0 ||
                       strcmp(ck, "enum_declaration") == 0) {
                cs_process_type_decl(ctx, c);
            }
        }
    }
    cs_namespace_pop(ctx);
}

/* ── top-level walk ─────────────────────────────────────────────── */

void cs_lsp_process_file(CSLSPContext *ctx, TSNode root) {
    if (ts_node_is_null(root))
        return;

    /* Pass 1: collect using directives. */
    cs_collect_imports(ctx, root);

    /* Pass 2: walk top-level. file-scoped namespaces apply to ALL siblings,
     * so we keep the namespace pushed for the rest of the walk. */
    // Collect top-level children once (O(n)); ts_node_child(root,i) is O(i) → O(n²).
    uint32_t kn = 0;
    TSNode *kids = cbm_lsp_collect_children(ctx->arena, root, &kn);
    bool file_scoped_active = false;
    for (uint32_t i = 0; i < kn; i++) {
        TSNode c = kids[i];
        if (!ts_node_is_named(c))
            continue;
        const char *k = ts_node_type(c);
        if (strcmp(k, "using_directive") == 0)
            continue;
        if (strcmp(k, "file_scoped_namespace_declaration") == 0) {
            cs_collect_namespace(ctx, c, true);
            file_scoped_active = true;
        } else if (strcmp(k, "namespace_declaration") == 0) {
            cs_collect_namespace(ctx, c, false);
        } else if (strcmp(k, "class_declaration") == 0 || strcmp(k, "struct_declaration") == 0 ||
                   strcmp(k, "record_declaration") == 0 ||
                   strcmp(k, "interface_declaration") == 0 || strcmp(k, "enum_declaration") == 0) {
            cs_process_type_decl(ctx, c);
        } else if (strcmp(k, "global_statement") == 0 || strcmp(k, "expression_statement") == 0 ||
                   strcmp(k, "if_statement") == 0 || strcmp(k, "for_statement") == 0 ||
                   strcmp(k, "foreach_statement") == 0 || strcmp(k, "for_each_statement") == 0 ||
                   strcmp(k, "while_statement") == 0 ||
                   strcmp(k, "local_declaration_statement") == 0 ||
                   strcmp(k, "return_statement") == 0) {
            /* Top-level statements (Program.cs without explicit Main).
             * We treat them as a synthetic enclosing function `<top>` so
             * the resolved-call array carries the caller correctly. */
            const char *saved = ctx->enclosing_func_qn;
            if (!saved && ctx->module_qn) {
                ctx->enclosing_func_qn = ctx->module_qn;
            }
            cs_resolve_calls_in_node(ctx, c);
            ctx->enclosing_func_qn = saved;
        }
    }
    if (file_scoped_active && ctx->namespace_count > 0)
        cs_namespace_pop(ctx);
}

/* ── registry building from defs ─────────────────────────────────── */

/* Parse a parenthesized signature like `(int x, string s = "")` into
 * NULL-terminated arrays of param names + types. Best-effort: drops
 * default-value expressions, ignores ref/out/in modifiers. */
static void cs_parse_signature(CBMArena *arena, const char *signature, CSLSPContext *ctx,
                               const char ***out_names, const CBMType ***out_types) {
    *out_names = NULL;
    *out_types = NULL;
    if (!signature)
        return;
    const char *p = signature;
    while (*p == ' ' || *p == '(')
        p++;
    /* Walk param-by-param. We split on top-level ',' (ignoring those inside
     * generic <> brackets). */
    int cap = 8;
    int count = 0;
    const char **names = (const char **)cbm_arena_alloc(arena, (size_t)cap * sizeof(*names));
    const CBMType **types = (const CBMType **)cbm_arena_alloc(arena, (size_t)cap * sizeof(*types));
    if (!names || !types)
        return;

    while (*p && *p != ')') {
        /* Skip leading whitespace. */
        while (*p == ' ' || *p == '\t' || *p == ',')
            p++;
        if (!*p || *p == ')')
            break;
        /* Skip param modifiers: ref, out, in, params, this. */
        const char *modifiers[] = {"ref ", "out ", "in ", "params ", "this "};
        bool ate;
        do {
            ate = false;
            for (int m = 0; m < 5; m++) {
                size_t ml = strlen(modifiers[m]);
                if (strncmp(p, modifiers[m], ml) == 0) {
                    p += ml;
                    ate = true;
                }
            }
        } while (ate);
        /* Read type tokens until we hit a name. The type may include '<...>'
         * or '[]'. The name is the last token before ',' or '=' or ')'. */
        const char *type_start = p;
        int depth = 0;
        const char *last_space = NULL;
        while (*p && (depth > 0 || (*p != ',' && *p != ')' && *p != '='))) {
            if (*p == '<')
                depth++;
            else if (*p == '>')
                depth--;
            else if (depth == 0 && (*p == ' ' || *p == '\t'))
                last_space = p;
            p++;
        }
        const char *name_end = p;
        while (name_end > type_start && (name_end[-1] == ' ' || name_end[-1] == '\t'))
            name_end--;
        if (!last_space) {
            /* No name — treat the whole token as the type with synthetic name. */
            char *type_text = cbm_arena_strndup(arena, type_start, (size_t)(name_end - type_start));
            const CBMType *t = cbm_type_unknown();
            if (ctx)
                t = cs_resolve_type_name(ctx, type_text)
                        ? cbm_type_named(ctx->arena, cs_resolve_type_name(ctx, type_text))
                        : cbm_type_unknown();
            (void)t;
            if (count + 1 >= cap)
                break;
            names[count] = cbm_arena_sprintf(arena, "_arg%d", count);
            types[count] = t;
            count++;
        } else {
            char *type_text =
                cbm_arena_strndup(arena, type_start, (size_t)(last_space - type_start));
            char *pname =
                cbm_arena_strndup(arena, last_space + 1, (size_t)(name_end - last_space - 1));
            const CBMType *t = cbm_type_unknown();
            if (ctx) {
                const char *resolved = cs_resolve_type_name(ctx, type_text);
                if (resolved)
                    t = cbm_type_named(ctx->arena, resolved);
            }
            if (count + 1 >= cap)
                break;
            names[count] = pname;
            types[count] = t;
            count++;
        }
        /* Skip default value if any. */
        if (*p == '=') {
            int d = 0;
            while (*p && (d > 0 || (*p != ',' && *p != ')'))) {
                if (*p == '(' || *p == '<')
                    d++;
                else if (*p == ')' || *p == '>') {
                    if (d == 0)
                        break;
                    d--;
                }
                p++;
            }
        }
        if (*p == ',')
            p++;
    }
    if (count + 1 < cap) {
        names[count] = NULL;
        types[count] = NULL;
        *out_names = names;
        *out_types = types;
    }
}

static void cs_register_type_decls(CSLSPContext *ctx, CBMTypeRegistry *reg, TSNode root) {
    /* We rely on CBMFileResult.defs entries already being filled by the
     * unified extractor. This function is reserved for future expansions
     * (e.g. parsing field declarations directly from the AST). */
    (void)ctx;
    (void)reg;
    (void)root;
}

/* ── field/property collection from AST ─────────────────────────── */

typedef struct {
    const char *class_qn;
    const char **field_names;
    const CBMType **field_types;
    int count;
    int cap;
} cs_fields_t;

typedef struct {
    cs_fields_t *items;
    int count;
    int cap;
} cs_fields_table_t;

static cs_fields_t *cs_fields_get(CBMArena *arena, cs_fields_table_t *tab, const char *class_qn) {
    for (int i = 0; i < tab->count; i++) {
        if (strcmp(tab->items[i].class_qn, class_qn) == 0)
            return &tab->items[i];
    }
    if (tab->count + 1 >= tab->cap) {
        int new_cap = tab->cap ? tab->cap * 2 : 8;
        cs_fields_t *ne = (cs_fields_t *)cbm_arena_alloc(arena, (size_t)new_cap * sizeof(*ne));
        if (!ne)
            return NULL;
        for (int i = 0; i < tab->count; i++)
            ne[i] = tab->items[i];
        tab->items = ne;
        tab->cap = new_cap;
    }
    cs_fields_t *slot = &tab->items[tab->count++];
    memset(slot, 0, sizeof(*slot));
    slot->class_qn = class_qn;
    slot->cap = 8;
    slot->field_names =
        (const char **)cbm_arena_alloc(arena, (size_t)slot->cap * sizeof(*slot->field_names));
    slot->field_types =
        (const CBMType **)cbm_arena_alloc(arena, (size_t)slot->cap * sizeof(*slot->field_types));
    return slot;
}

static void cs_fields_add_debug(CBMArena *arena, cs_fields_t *f, const char *name,
                                const CBMType *type, bool debug);

static void cs_fields_add(CBMArena *arena, cs_fields_t *f, const char *name, const CBMType *type) {
    cs_fields_add_debug(arena, f, name, type, false);
}

static void cs_fields_add_debug(CBMArena *arena, cs_fields_t *f, const char *name,
                                const CBMType *type, bool debug) {
    (void)debug;
    if (!f || !name)
        return;
    /* Dedupe. */
    for (int i = 0; i < f->count; i++) {
        if (strcmp(f->field_names[i], name) == 0)
            return;
    }
    if (f->count + 2 >= f->cap) {
        int new_cap = f->cap * 2;
        const char **nn = (const char **)cbm_arena_alloc(arena, (size_t)new_cap * sizeof(*nn));
        const CBMType **nt =
            (const CBMType **)cbm_arena_alloc(arena, (size_t)new_cap * sizeof(*nt));
        if (!nn || !nt)
            return;
        for (int i = 0; i < f->count; i++) {
            nn[i] = f->field_names[i];
            nt[i] = f->field_types[i];
        }
        f->field_names = nn;
        f->field_types = nt;
        f->cap = new_cap;
    }
    f->field_names[f->count] = cbm_arena_strdup(arena, name);
    f->field_types[f->count] = type ? type : cbm_type_unknown();
    f->count++;
    f->field_names[f->count] = NULL;
    f->field_types[f->count] = NULL;
}

static void cs_collect_class_fields(CSLSPContext *ctx, CBMTypeRegistry *reg, TSNode root,
                                    cs_fields_table_t *tab) {
    /* Walk the AST and collect field/property/event declarations into tab.
     * We need the namespace + using context to resolve types, so this runs
     * after cs_collect_imports. */
    TSNode stack[512];
    int top = 0;
    stack[top++] = root;
    /* Maintain enclosing class for each decl we visit. We simply re-derive it
     * via parent_chain inspection (limited to direct class parent). */
    while (top > 0) {
        TSNode n = stack[--top];
        if (ts_node_is_null(n))
            continue;
        const char *k = ts_node_type(n);

        if (strcmp(k, "field_declaration") == 0 || strcmp(k, "property_declaration") == 0 ||
            strcmp(k, "event_field_declaration") == 0) {
            /* Find enclosing class/struct/record. */
            TSNode p = ts_node_parent(n);
            const char *cls_short = NULL;
            while (!ts_node_is_null(p)) {
                const char *pk = ts_node_type(p);
                if (strcmp(pk, "class_declaration") == 0 || strcmp(pk, "struct_declaration") == 0 ||
                    strcmp(pk, "record_declaration") == 0 ||
                    strcmp(pk, "record_struct_declaration") == 0 ||
                    strcmp(pk, "interface_declaration") == 0) {
                    TSNode nm = ts_node_child_by_field_name(p, "name", 4);
                    if (!ts_node_is_null(nm)) {
                        cls_short = cs_node_text(ctx, nm);
                    }
                    break;
                }
                p = ts_node_parent(p);
            }
            if (cls_short) {
                const char *cls_qn = ctx->module_qn ? cbm_arena_sprintf(ctx->arena, "%s.%s",
                                                                        ctx->module_qn, cls_short)
                                                    : cbm_arena_strdup(ctx->arena, cls_short);
                cs_fields_t *f = cs_fields_get(ctx->arena, tab, cls_qn);
                if (strcmp(k, "field_declaration") == 0 ||
                    strcmp(k, "event_field_declaration") == 0) {
                    TSNode vd = cs_child_named_kind(n, "variable_declaration");
                    if (!ts_node_is_null(vd)) {
                        TSNode tnode = ts_node_child_by_field_name(vd, "type", 4);
                        if (ts_node_is_null(tnode))
                            tnode = cs_first_named_child(vd);
                        const CBMType *t = ts_node_is_null(tnode) ? cbm_type_unknown()
                                                                  : cs_parse_type_node(ctx, tnode);
                        uint32_t vc = ts_node_child_count(vd);
                        for (uint32_t i = 0; i < vc; i++) {
                            TSNode c = ts_node_child(vd, i);
                            if (ts_node_is_null(c) || !ts_node_is_named(c))
                                continue;
                            if (strcmp(ts_node_type(c), "variable_declarator") != 0)
                                continue;
                            TSNode id = cs_child_named_kind(c, "identifier");
                            if (ts_node_is_null(id))
                                id = ts_node_child_by_field_name(c, "name", 4);
                            if (ts_node_is_null(id))
                                continue;
                            char *fn = cs_node_text(ctx, id);
                            if (fn)
                                cs_fields_add_debug(ctx->arena, f, fn, t, ctx->debug);
                        }
                    }
                } else {
                    /* property */
                    TSNode tnode = ts_node_child_by_field_name(n, "type", 4);
                    TSNode nm = ts_node_child_by_field_name(n, "name", 4);
                    if (!ts_node_is_null(tnode) && !ts_node_is_null(nm)) {
                        const CBMType *t = cs_parse_type_node(ctx, tnode);
                        char *fn = cs_node_text(ctx, nm);
                        if (fn)
                            cs_fields_add_debug(ctx->arena, f, fn, t, ctx->debug);
                    }
                }
            }
        }

        /* Primary constructor parameters of records / classes — register as fields */
        if (strcmp(k, "record_declaration") == 0 || strcmp(k, "record_struct_declaration") == 0 ||
            strcmp(k, "class_declaration") == 0 || strcmp(k, "struct_declaration") == 0) {
            TSNode params = cs_child_named_kind(n, "parameter_list");
            TSNode nm = ts_node_child_by_field_name(n, "name", 4);
            if (!ts_node_is_null(params) && !ts_node_is_null(nm)) {
                char *cls_short = cs_node_text(ctx, nm);
                if (cls_short) {
                    const char *cls_qn =
                        ctx->module_qn
                            ? cbm_arena_sprintf(ctx->arena, "%s.%s", ctx->module_qn, cls_short)
                            : cbm_arena_strdup(ctx->arena, cls_short);
                    cs_fields_t *f = cs_fields_get(ctx->arena, tab, cls_qn);
                    uint32_t pc = ts_node_child_count(params);
                    for (uint32_t i = 0; i < pc; i++) {
                        TSNode c = ts_node_child(params, i);
                        if (ts_node_is_null(c) || !ts_node_is_named(c))
                            continue;
                        if (strcmp(ts_node_type(c), "parameter") != 0)
                            continue;
                        TSNode tn = ts_node_child_by_field_name(c, "type", 4);
                        TSNode pn = ts_node_child_by_field_name(c, "name", 4);
                        if (ts_node_is_null(tn) || ts_node_is_null(pn))
                            continue;
                        const CBMType *t = cs_parse_type_node(ctx, tn);
                        char *pname = cs_node_text(ctx, pn);
                        if (pname)
                            cs_fields_add(ctx->arena, f, pname, t);
                    }
                }
            }
        }

        uint32_t cnc = ts_node_child_count(n);
        for (uint32_t i = 0; i < cnc && top + 1 < 512; i++) {
            TSNode c = ts_node_child(n, i);
            if (ts_node_is_null(c))
                continue;
            const char *ck = ts_node_type(c);
            /* Skip method/ctor bodies — fields can't be there. */
            if (strcmp(ck, "method_declaration") == 0 ||
                strcmp(ck, "constructor_declaration") == 0 ||
                strcmp(ck, "destructor_declaration") == 0 ||
                strcmp(ck, "operator_declaration") == 0 || strcmp(ck, "indexer_declaration") == 0 ||
                strcmp(ck, "block") == 0) {
                continue;
            }
            stack[top++] = c;
        }
    }
    (void)reg;
}

/* ── extract method return types directly from AST ──────────────
 *
 * The unified extractor leaves CBMDefinition.return_type NULL for C#
 * methods (the C# code path takes a different branch). Without return
 * types, method-chain resolution like `a.GetB().Tag()` can't propagate
 * the result type from GetB into the next dispatch. To restore the
 * chain we do our own AST pass here, mapping method QNs to their
 * declared return type, then patching the registry's signatures.
 */

typedef struct {
    const char *qn;
    const CBMType *rt;
} cs_method_rt_entry_t;

typedef struct {
    cs_method_rt_entry_t *items;
    int count;
    int cap;
} cs_method_rt_table_t;

static void cs_method_rt_add(CBMArena *arena, cs_method_rt_table_t *tab, const char *qn,
                             const CBMType *rt) {
    if (!qn || !rt)
        return;
    for (int i = 0; i < tab->count; i++) {
        if (strcmp(tab->items[i].qn, qn) == 0)
            return;
    }
    if (tab->count + 1 >= tab->cap) {
        int new_cap = tab->cap ? tab->cap * 2 : 16;
        cs_method_rt_entry_t *ne =
            (cs_method_rt_entry_t *)cbm_arena_alloc(arena, (size_t)new_cap * sizeof(*ne));
        if (!ne)
            return;
        for (int i = 0; i < tab->count; i++)
            ne[i] = tab->items[i];
        tab->items = ne;
        tab->cap = new_cap;
    }
    tab->items[tab->count].qn = qn;
    tab->items[tab->count].rt = rt;
    tab->count++;
}

/* Walk the tree, finding method_declaration / property_declaration nodes
 * and recording (parent_class_qn + "." + method_name → return type). */
static void cs_collect_method_return_types(CSLSPContext *ctx, TSNode root,
                                           cs_method_rt_table_t *tab) {
    TSNode stack[512];
    int top = 0;
    stack[top++] = root;
    while (top > 0) {
        TSNode n = stack[--top];
        if (ts_node_is_null(n))
            continue;
        const char *k = ts_node_type(n);

        bool is_method = (strcmp(k, "method_declaration") == 0);
        bool is_property = (strcmp(k, "property_declaration") == 0);
        bool is_indexer = (strcmp(k, "indexer_declaration") == 0);
        if (is_method || is_property || is_indexer) {
            /* Find enclosing class. */
            TSNode p = ts_node_parent(n);
            const char *cls_short = NULL;
            while (!ts_node_is_null(p)) {
                const char *pk = ts_node_type(p);
                if (strcmp(pk, "class_declaration") == 0 || strcmp(pk, "struct_declaration") == 0 ||
                    strcmp(pk, "record_declaration") == 0 ||
                    strcmp(pk, "record_struct_declaration") == 0 ||
                    strcmp(pk, "interface_declaration") == 0) {
                    TSNode pn = ts_node_child_by_field_name(p, "name", 4);
                    if (!ts_node_is_null(pn))
                        cls_short = cs_node_text(ctx, pn);
                    break;
                }
                p = ts_node_parent(p);
            }
            if (!cls_short) {
                uint32_t cnc = ts_node_child_count(n);
                for (uint32_t i = 0; i < cnc && top + 1 < 512; i++) {
                    TSNode c = ts_node_child(n, i);
                    if (!ts_node_is_null(c))
                        stack[top++] = c;
                }
                continue;
            }
            const char *cls_qn =
                ctx->module_qn ? cbm_arena_sprintf(ctx->arena, "%s.%s", ctx->module_qn, cls_short)
                               : cbm_arena_strdup(ctx->arena, cls_short);
            TSNode tnode = ts_node_child_by_field_name(n, "type", 4);
            TSNode nm = ts_node_child_by_field_name(n, "name", 4);
            /* tree-sitter-c-sharp doesn't always set the type field on
             * method_declaration. Walk named children to find the return
             * type: it's the first non-modifier non-attribute named child
             * whose kind isn't an identifier matching the method name. */
            if (ts_node_is_null(tnode)) {
                uint32_t cn = ts_node_child_count(n);
                for (uint32_t i = 0; i < cn; i++) {
                    TSNode c = ts_node_child(n, i);
                    if (ts_node_is_null(c) || !ts_node_is_named(c))
                        continue;
                    const char *ck = ts_node_type(c);
                    if (strcmp(ck, "modifier") == 0 || strcmp(ck, "attribute_list") == 0 ||
                        strcmp(ck, "type_parameter_list") == 0)
                        continue;
                    /* The name comes after the type; skip it. */
                    if (!ts_node_is_null(nm) && ts_node_eq(c, nm))
                        continue;
                    if (strcmp(ck, "parameter_list") == 0 || strcmp(ck, "block") == 0 ||
                        strcmp(ck, "arrow_expression_clause") == 0 ||
                        strcmp(ck, "type_parameter_constraints_clause") == 0)
                        break;
                    /* Heuristic: the first remaining named child is the
                     * return type. */
                    tnode = c;
                    break;
                }
            }
            if (is_indexer) {
                const char *short_name = "this[]";
                if (!ts_node_is_null(tnode)) {
                    const CBMType *rt = cs_parse_type_node(ctx, tnode);
                    cs_method_rt_add(ctx->arena, tab,
                                     cbm_arena_sprintf(ctx->arena, "%s.%s", cls_qn, short_name),
                                     rt);
                }
            } else if (!ts_node_is_null(tnode) && !ts_node_is_null(nm)) {
                char *short_name = cs_node_text(ctx, nm);
                if (short_name) {
                    const CBMType *rt = cs_parse_type_node(ctx, tnode);
                    cs_method_rt_add(ctx->arena, tab,
                                     cbm_arena_sprintf(ctx->arena, "%s.%s", cls_qn, short_name),
                                     rt);
                }
            }
        }

        /* Push children unless we're inside a method body. */
        uint32_t cnc = ts_node_child_count(n);
        for (uint32_t i = 0; i < cnc && top + 1 < 512; i++) {
            TSNode c = ts_node_child(n, i);
            if (ts_node_is_null(c))
                continue;
            const char *ck = ts_node_type(c);
            if (strcmp(ck, "block") == 0 || strcmp(ck, "arrow_expression_clause") == 0) {
                continue;
            }
            stack[top++] = c;
        }
    }
}

void cbm_cs_refine_ast_return_types(CSLSPContext *ctx, CBMTypeRegistry *reg, TSNode root) {
    if (!ctx || !reg || ts_node_is_null(root))
        return;

    cs_method_rt_table_t mtab = {0};
    cs_collect_method_return_types(ctx, root, &mtab);
    for (int i = 0; i < mtab.count; i++) {
        const char *qn = mtab.items[i].qn;
        const CBMType *rt = mtab.items[i].rt;
        bool patched = false;
        for (int j = 0; j < reg->func_count; j++) {
            if (strcmp(reg->funcs[j].qualified_name, qn) == 0) {
                const CBMType **rets =
                    (const CBMType **)cbm_arena_alloc(ctx->arena, 2 * sizeof(const CBMType *));
                if (rets) {
                    rets[0] = rt;
                    rets[1] = NULL;
                    reg->funcs[j].signature =
                        cbm_type_func_replace_returns(ctx->arena, reg->funcs[j].signature, rets);
                }
                patched = true;
                break;
            }
        }
        (void)patched;
    }
}

/* ── parse return type from CBMDefinition.return_type ──────────── */

static const CBMType *cs_parse_return_type_text(CSLSPContext *ctx, const char *text) {
    if (!text || !*text)
        return cbm_type_unknown();
    const char *p = text;
    while (*p == ' ' || *p == ':')
        p++;
    if (!*p)
        return cbm_type_unknown();
    /* Strip trailing whitespace + '?' nullability. */
    size_t n = strlen(p);
    while (n > 0 && (p[n - 1] == ' ' || p[n - 1] == '?'))
        n--;
    if (n == 0)
        return cbm_type_unknown();
    char *trimmed = cbm_arena_strndup(ctx->arena, p, n);
    const char *resolved = cs_resolve_type_name(ctx, trimmed);
    if (!resolved)
        return cbm_type_unknown();
    const char *pre = cs_predefined_alias(resolved);
    if (pre)
        return cbm_type_named(ctx->arena, pre);
    return cbm_type_named(ctx->arena, resolved);
}

static const CBMType *cs_signature_param_type_adapter(CBMArena *arena, const char *text,
                                                      void *parser_ctx) {
    (void)arena;
    CSLSPContext *ctx = (CSLSPContext *)parser_ctx;
    return ctx ? cs_parse_return_type_text(ctx, text) : cbm_type_unknown();
}

/* ── single-file entry: cbm_run_cs_lsp ──────────────────────────── */

void cbm_run_cs_lsp(CBMArena *arena, CBMFileResult *result, const char *source, int source_len,
                    TSNode root) {
    if (!result || !arena || ts_node_is_null(root))
        return;

    CBMTypeRegistry reg;
    cbm_registry_init(&reg, arena);

    /* Phase A: stdlib. */
    cbm_csharp_stdlib_register(&reg, arena);

    const char *module_qn = result->module_qn;

    /* Phase B: register types + functions from this file's defs. */
    for (int i = 0; i < result->defs.count; i++) {
        CBMDefinition *d = &result->defs.items[i];
        if (!d->qualified_name || !d->name || !d->label)
            continue;

        if (strcmp(d->label, "Class") == 0 || strcmp(d->label, "Interface") == 0 ||
            strcmp(d->label, "Struct") == 0 || strcmp(d->label, "Record") == 0 ||
            strcmp(d->label, "Enum") == 0 || strcmp(d->label, "Type") == 0) {
            CBMRegisteredType rt;
            memset(&rt, 0, sizeof(rt));
            rt.qualified_name = d->qualified_name;
            rt.short_name = d->name;
            rt.namespace_qn =
                cs_top_level_namespace(d->qualified_name, d->name, module_qn, d->decl_namespace);
            rt.is_interface = (strcmp(d->label, "Interface") == 0);
            if (d->base_classes) {
                int bc = 0;
                while (d->base_classes[bc])
                    bc++;
                if (bc > 0) {
                    const char **emb = (const char **)cbm_arena_alloc(
                        arena, (size_t)(bc + 1) * sizeof(const char *));
                    if (emb) {
                        for (int j = 0; j < bc; j++) {
                            const char *base = d->base_classes[j];
                            const char *q = base;
                            if (base[0] != '.' && !strchr(base, '.') && module_qn) {
                                q = cbm_arena_sprintf(arena, "%s.%s", module_qn, base);
                            }
                            emb[j] = q;
                        }
                        emb[bc] = NULL;
                        rt.embedded_types = emb;
                    }
                }
            }
            cbm_registry_add_type(&reg, rt);
        }

        if (strcmp(d->label, "Function") == 0 || strcmp(d->label, "Method") == 0) {
            CBMRegisteredFunc rf;
            memset(&rf, 0, sizeof(rf));
            rf.qualified_name = d->qualified_name;
            rf.short_name = d->name;
            rf.min_params = -1;
            if (strcmp(d->label, "Method") == 0 && d->parent_class) {
                rf.receiver_type = d->parent_class;
            }
            const CBMType *rt = d->return_type ? cbm_type_unknown() /* will refine below with ctx */
                                               : cbm_type_unknown();
            const CBMType **rets =
                (const CBMType **)cbm_arena_alloc(arena, 2 * sizeof(const CBMType *));
            if (rets) {
                rets[0] = rt;
                rets[1] = NULL;
            }
            rf.signature = cbm_type_func(arena, NULL, NULL, rets);
            cbm_registry_add_func(&reg, rf);
        }
    }

    /* Phase C: build context for type resolution + run the resolver. */
    CSLSPContext ctx;
    cs_lsp_init(&ctx, arena, source, source_len, &reg, module_qn, &result->resolved_calls);
    ctx.call_carriers = &result->calls;

    /* Pass 1: collect imports + namespaces (for type-resolution context). */
    cs_collect_imports(&ctx, root);

    /* The counted carrier is authoritative even when count is zero. Install it
     * only after imports are available so textual types use the same local
     * resolution context as declared returns. A truly absent carrier keeps the
     * legacy zero-parameter behavior. */
    for (int i = 0; i < result->defs.count; i++) {
        CBMDefinition *d = &result->defs.items[i];
        if (!d->qualified_name || !d->label ||
            (strcmp(d->label, "Function") != 0 && strcmp(d->label, "Method") != 0) ||
            (!d->signature_param_types && d->signature_param_count <= 0)) {
            continue;
        }
        const CBMType **param_types = cbm_type_materialize_signature_params(
            arena, d->signature_param_types, d->signature_param_count,
            cs_signature_param_type_adapter, &ctx);
        for (int j = 0; j < reg.func_count; j++) {
            if (strcmp(reg.funcs[j].qualified_name, d->qualified_name) != 0)
                continue;
            const CBMType **return_types = NULL;
            if (reg.funcs[j].signature && reg.funcs[j].signature->kind == CBM_TYPE_FUNC) {
                return_types = reg.funcs[j].signature->data.func.return_types;
            }
            reg.funcs[j].signature = cbm_type_func(arena, NULL, param_types, return_types);
            break;
        }
    }

    /* Now refine return types of registered funcs using ctx (which has using
     * directives). Also refine field types via collect_class_fields. */
    for (int i = 0; i < result->defs.count; i++) {
        CBMDefinition *d = &result->defs.items[i];
        if (!d->qualified_name || !d->return_type)
            continue;
        if (strcmp(d->label, "Function") != 0 && strcmp(d->label, "Method") != 0)
            continue;
        const CBMType *rt = cs_parse_return_type_text(&ctx, d->return_type);
        /* Find the registered func and patch its signature. */
        for (int j = 0; j < reg.func_count; j++) {
            if (strcmp(reg.funcs[j].qualified_name, d->qualified_name) == 0) {
                const CBMType **rets =
                    (const CBMType **)cbm_arena_alloc(arena, 2 * sizeof(const CBMType *));
                if (rets) {
                    rets[0] = rt;
                    rets[1] = NULL;
                    reg.funcs[j].signature =
                        cbm_type_func_replace_returns(arena, reg.funcs[j].signature, rets);
                }
                break;
            }
        }
    }

    /* Phase B.1.5: AST-driven return-type patch. The unified extractor
     * leaves CBMDefinition.return_type NULL for C# methods, so we walk the
     * AST ourselves to recover declared return types. */
    cbm_cs_refine_ast_return_types(&ctx, &reg, root);

    /* Phase B.1: collect typed properties + fields. */
    {
        cs_fields_table_t tab = {0};
        cs_collect_class_fields(&ctx, &reg, root, &tab);
        for (int i = 0; i < tab.count; i++) {
            cs_fields_t *f = &tab.items[i];
            if (f->count == 0)
                continue;
            for (int t = 0; t < reg.type_count; t++) {
                if (strcmp(reg.types[t].qualified_name, f->class_qn) == 0) {
                    reg.types[t].field_names = f->field_names;
                    reg.types[t].field_types = f->field_types;
                    break;
                }
            }
        }
    }

    /* Re-bind ctx state since collect_class_fields may have temporarily
     * adjusted namespace stack (it doesn't, but be safe). */
    ctx.namespace_count = 0;
    /* Restore implicit `using System;`. */

    cs_lsp_process_file(&ctx, root);

    if (ctx.debug) {
        fprintf(stderr, "[cs_lsp] module=%s defs=%d types=%d funcs=%d resolved=%d\n",
                module_qn ? module_qn : "?", result->defs.count, reg.type_count, reg.func_count,
                result->resolved_calls.count);
        for (int i = 0; i < result->resolved_calls.count; i++) {
            const CBMResolvedCall *rc = &result->resolved_calls.items[i];
            fprintf(stderr, "[cs_lsp]   %s -> %s [%s %.2f]\n", rc->caller_qn ? rc->caller_qn : "?",
                    rc->callee_qn ? rc->callee_qn : "?", rc->strategy ? rc->strategy : "?",
                    rc->confidence);
        }
    }
}

/* ── cross-file entry ───────────────────────────────────────────── */

/* The type's declared `namespace_name` when `type_qn` is a TOP-LEVEL type of
 * the file whose module QN is `module_qn` (top-level C# type QNs are exactly
 * module.Name; nested ones are module.Outer.Name and stay NULL, since a nested
 * type is not reachable by its simple name through a namespace). */
static const char *cs_top_level_namespace(const char *type_qn, const char *short_name,
                                          const char *module_qn, const char *namespace_name) {
    if (!type_qn || !short_name || !module_qn)
        return NULL;
    size_t mlen = strlen(module_qn);
    if (strncmp(type_qn, module_qn, mlen) != 0 || type_qn[mlen] != '.' ||
        strcmp(type_qn + mlen + 1, short_name) != 0)
        return NULL;
    /* Top-level C# type: its declared namespace, "" for the global namespace
     * so step 8b can bind it, NULL when extraction could not tell (a parse
     * error dissolved the namespace; see cs_type_decl_namespace). NULL stays
     * invisible to step 8b, as do nested types. */
    return namespace_name;
}

/* Register one batch of CBMLSPDef[] into a registry. Shared by the
 * per-file cross-LSP path and the Tier 2 pre-built registry builder.
 * Def-driven (no per-file AST mutation) so deterministic per def set. */
static void cs_register_lsp_defs(CBMArena *arena, CBMTypeRegistry *reg, CBMLSPDef *defs,
                                 int def_count) {
    for (int i = 0; i < def_count; i++) {
        CBMLSPDef *d = &defs[i];
        if (!d->qualified_name || !d->short_name || !d->label)
            continue;
        if (strcmp(d->label, "Class") == 0 || strcmp(d->label, "Interface") == 0 ||
            strcmp(d->label, "Struct") == 0 || strcmp(d->label, "Record") == 0 ||
            strcmp(d->label, "Enum") == 0 || strcmp(d->label, "Type") == 0) {
            CBMRegisteredType rt;
            memset(&rt, 0, sizeof(rt));
            rt.qualified_name = d->qualified_name;
            rt.short_name = d->short_name;
            rt.namespace_qn = cs_top_level_namespace(d->qualified_name, d->short_name,
                                                     d->def_module_qn, d->namespace_name);
            rt.is_interface = d->is_interface || (strcmp(d->label, "Interface") == 0);
            if (d->embedded_types && *d->embedded_types) {
                /* Parse "|"-separated list. */
                int n = 1;
                for (const char *p = d->embedded_types; *p; p++)
                    if (*p == '|')
                        n++;
                const char **arr =
                    (const char **)cbm_arena_alloc(arena, (size_t)(n + 1) * sizeof(*arr));
                if (arr) {
                    int idx = 0;
                    const char *start = d->embedded_types;
                    for (const char *p = d->embedded_types;; p++) {
                        if (*p == '|' || *p == '\0') {
                            size_t len = (size_t)(p - start);
                            if (len > 0) {
                                arr[idx++] = cbm_arena_strndup(arena, start, len);
                            }
                            if (*p == '\0')
                                break;
                            start = p + 1;
                        }
                    }
                    arr[idx] = NULL;
                    rt.embedded_types = arr;
                }
            }
            cbm_registry_add_type(reg, rt);
        }
        if (strcmp(d->label, "Function") == 0 || strcmp(d->label, "Method") == 0) {
            CBMRegisteredFunc rf;
            memset(&rf, 0, sizeof(rf));
            rf.qualified_name = d->qualified_name;
            rf.short_name = d->short_name;
            rf.min_params = -1;
            if (strcmp(d->label, "Method") == 0 && d->receiver_type) {
                rf.receiver_type = d->receiver_type;
            }
            CSLSPContext parser_ctx = {0};
            parser_ctx.arena = arena;
            parser_ctx.registry = reg;
            parser_ctx.module_qn = d->def_module_qn;
            const CBMType **rets =
                (const CBMType **)cbm_arena_alloc(arena, 2 * sizeof(const CBMType *));
            if (rets) {
                rets[0] = d->return_types && d->return_types[0]
                              ? cs_parse_return_type_text(&parser_ctx, d->return_types)
                              : cbm_type_unknown();
                rets[1] = NULL;
            }
            const CBMType **param_types = cbm_type_materialize_signature_params(
                arena, d->signature_param_types, d->signature_param_count,
                cs_signature_param_type_adapter, &parser_ctx);
            rf.signature = cbm_type_func(arena, NULL, param_types, rets);
            cbm_registry_add_func(reg, rf);
        }
    }
}

/* Tier 2: build a project-wide C# registry ONCE from all defs (filters
 * by lang). Shared READ-ONLY across resolve workers. Def-driven →
 * identical entries to the per-file build, zero quality loss. */
/* True iff a CS def registers as a TYPE — must mirror cs_register_lsp_defs'
 * own label branch exactly, or the two-phase split below silently mis-buckets. */
static bool cs_def_is_type(const CBMLSPDef *d) {
    return d->label && (strcmp(d->label, "Class") == 0 || strcmp(d->label, "Interface") == 0 ||
                        strcmp(d->label, "Struct") == 0 || strcmp(d->label, "Record") == 0 ||
                        strcmp(d->label, "Enum") == 0 || strcmp(d->label, "Type") == 0);
}

CBMTypeRegistry *cbm_cs_build_cross_registry(CBMArena *arena, CBMLSPDef *defs, int def_count) {
    if (!arena)
        return NULL;
    CBMTypeRegistry *reg = (CBMTypeRegistry *)cbm_arena_alloc(arena, sizeof(*reg));
    if (!reg)
        return NULL;
    cbm_registry_init(reg, arena);
    cbm_csharp_stdlib_register(reg, arena);
    /* Two-phase registration, same fix as the Java builder: func registration
     * parses signatures, and type-name qualification does registry lookups
     * that are LINEAR scans until finalize builds the hash buckets — one
     * mixed pass over a 963k-def corpus measured ~280 s of lsp_cross_prepare.
     * Register all TYPES (no lookups in their registration), finalize once so
     * the type buckets exist, then register FUNCS with O(1) lookups, and
     * finalize again to index them. Stable order per phase: overload ties
     * resolve to the first registered QN match. */
    /* def_count == 0 is a valid corpus (no C# files): arena_alloc(0) returns
     * NULL, which must not be mistaken for OOM — the empty registry is still
     * built, finalized, and shared. */
    CBMLSPDef *cs = NULL;
    if (def_count > 0) {
        cs = (CBMLSPDef *)cbm_arena_alloc(arena, (size_t)def_count * sizeof(*cs));
        if (!cs)
            return NULL;
    }
    int total = 0;
    for (int i = 0; i < def_count; i++) {
        if (defs[i].lang == CBM_LANG_CSHARP && cs_def_is_type(&defs[i]))
            cs[total++] = defs[i];
    }
    int type_count = total;
    for (int i = 0; i < def_count; i++) {
        if (defs[i].lang == CBM_LANG_CSHARP && !cs_def_is_type(&defs[i]))
            cs[total++] = defs[i];
    }
    cs_register_lsp_defs(arena, reg, cs, type_count);
    cbm_registry_finalize(reg);
    if (total > type_count) { /* cs is NULL for an empty corpus: no offset */
        cs_register_lsp_defs(arena, reg, cs + type_count, total - type_count);
    }
    cbm_registry_finalize(reg);
    reg->read_only = true; /* seal: shared Tier-2 registry is read-only during resolve */
    return reg;
}

void cbm_run_cs_lsp_cross_with_registry(CBMArena *arena, const char *source, int source_len,
                                        const char *module_qn, CBMTypeRegistry *reg,
                                        const char **using_targets, int using_count,
                                        TSTree *cached_tree, CBMResolvedCallArray *out) {
    if (!source || !arena || !out || !reg)
        return;

    TSTree *tree = cached_tree;
    bool owns = false;
    if (!tree) {
        TSParser *parser = ts_parser_new();
        if (!parser)
            return;
        ts_parser_set_language(parser, tree_sitter_c_sharp());
        tree = cbm_parse_source(parser, source,
                                source_len > 0 ? (uint32_t)source_len : (uint32_t)strlen(source),
                                (TSParseOptions){0});
        ts_parser_delete(parser);
        owns = true;
    }
    if (!tree)
        return;
    TSNode root = ts_tree_root_node(tree);

    CSLSPContext ctx;
    cs_lsp_init(&ctx, arena, source, source_len, reg, module_qn, out);
    for (int i = 0; i < using_count; i++) {
        if (using_targets[i]) {
            cs_lsp_add_using(&ctx, CBM_CS_USING_NAMESPACE, "", using_targets[i], false);
        }
    }
    cs_lsp_process_file(&ctx, root);

    if (owns)
        ts_tree_delete(tree);
}

void cbm_run_cs_lsp_cross(CBMArena *arena, const char *source, int source_len,
                          const char *module_qn, CBMLSPDef *defs, int def_count,
                          const char **using_targets, int using_count, TSTree *cached_tree,
                          CBMResolvedCallArray *out) {
    if (!source || !arena)
        return;

    CBMTypeRegistry reg;
    cbm_registry_init(&reg, arena);
    cbm_csharp_stdlib_register(&reg, arena);
    cs_register_lsp_defs(arena, &reg, defs, def_count);

    /* Parse if needed. */
    TSTree *tree = cached_tree;
    bool owns = false;
    if (!tree) {
        TSParser *parser = ts_parser_new();
        if (!parser)
            return;
        ts_parser_set_language(parser, tree_sitter_c_sharp());
        tree = cbm_parse_source(parser, source,
                                source_len > 0 ? (uint32_t)source_len : (uint32_t)strlen(source),
                                (TSParseOptions){0});
        ts_parser_delete(parser);
        owns = true;
    }
    if (!tree)
        return;
    TSNode root = ts_tree_root_node(tree);

    /* Finalize registry — O(1) lookups. See go_lsp.c "3c. Finalize"
     * comment for the rationale. */
    cbm_registry_finalize(&reg);

    CSLSPContext ctx;
    cs_lsp_init(&ctx, arena, source, source_len, &reg, module_qn, out);

    /* Pre-populate using directives from the supplied list. */
    for (int i = 0; i < using_count; i++) {
        if (using_targets[i]) {
            cs_lsp_add_using(&ctx, CBM_CS_USING_NAMESPACE, "", using_targets[i], false);
        }
    }
    cs_lsp_process_file(&ctx, root);

    if (owns)
        ts_tree_delete(tree);
}

void cbm_batch_cs_lsp_cross(CBMArena *arena, CBMBatchCSLSPFile *files, int file_count,
                            CBMResolvedCallArray *out) {
    if (!arena || !files)
        return;
    for (int i = 0; i < file_count; i++) {
        CBMBatchCSLSPFile *f = &files[i];
        cbm_run_cs_lsp_cross(arena, f->source, f->source_len, f->module_qn, f->defs, f->def_count,
                             f->using_targets, f->using_count, f->cached_tree, &out[i]);
    }
}