Function java_find_sole_impl

internal/cbm/lsp/java_lsp.c:1823–1888

Find a sole concrete in-project implementer of interface `iface_qn` that * declares method `mname`. Returns the implementer's QN when exactly ONE * exists (else NULL), and sets *out_count to the number found (capped at 2, * so 2 means "two or more"). Walks the registered-type parent chain to * confirm true subtyping. Mirrors the inline detection that used to live in * resolve_method_call so b

 * resolve_method_call so both the f-found and f-absent interface paths share
 * identical semantics. */
static const char *java_find_sole_impl(JavaLSPContext *ctx, const char *iface_qn, const char *mname,
                                       int *out_count) {
    const char *first = NULL; /* first distinct impl QN seen */
    int distinct = 0;         /* distinct impl classes (capped at 2) */
    const char *iface_dot = strrchr(iface_qn, '.');
    const char *iface_bare = iface_dot ? iface_dot + 1 : iface_qn;
    for (int ti = 0; ti < ctx->registry->type_count && distinct < 2; ti++) {
        const CBMRegisteredType *cand = &ctx->registry->types[ti];
        if (cand->is_interface || !cand->qualified_name || cand->alias_of)
            continue;
        /* Does cand declare `mname`? The method-name array is often empty for
         * fixture classes; the method REGISTRY is the authoritative source the
         * dispatch path already uses, so consult it first and fall back to the
         * name array. */
        bool has = cbm_registry_lookup_method(ctx->registry, cand->qualified_name, mname) != NULL;
        if (!has && cand->method_names) {
            for (int mi = 0; cand->method_names[mi]; mi++) {
                if (strcmp(cand->method_names[mi], mname) == 0) {
                    has = true;
                    break;
                }
            }
        }
        if (!has)
            continue;
        /* Subtype check: walk cand's supertype chain, matching iface by FULL
         * QN or BARE name. The registry holds duplicate type entries whose
         * `embedded_types` list a supertype sometimes by short name ("Shape")
         * and sometimes by full QN ("proj.Shape"); a full-QN-only comparison
         * silently misses the short-name form, so compare both. */
        const char *cur = cand->qualified_name;
        bool subtype = false;
        for (int hops = 0; hops < JAVA_LSP_MAX_INHERIT_HOPS && cur && !subtype; hops++) {
            const CBMRegisteredType *ct = cbm_registry_lookup_type(ctx->registry, cur);
            if (!ct || !ct->embedded_types)
                break;
            const char *next = NULL;
            for (int pi = 0; ct->embedded_types[pi]; pi++) {
                const char *e = ct->embedded_types[pi];
                const char *edot = strrchr(e, '.');
                const char *ebare = edot ? edot + 1 : e;
                if (strcmp(e, iface_qn) == 0 || strcmp(ebare, iface_bare) == 0) {
                    subtype = true;
                    break;
                }
                if (!next)
                    next = e; /* first supertype → continue the walk upward */
            }
            cur = next;
        }
        if (!subtype)
            continue;
        /* Count DISTINCT impl classes: the registry duplicates entries per
         * class, so dedup by QN — two entries of one class must not read as
         * two implementers. */
        if (!first) {
            first = cand->qualified_name;
            distinct = 1;