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.

13.5 KB
Raw Blame
#ifndef CBM_LSP_C_LSP_H
#define CBM_LSP_C_LSP_H

#include "type_rep.h"
#include "scope.h"
#include "type_registry.h"
#include "../cbm.h"
#include "go_lsp.h" // for CBMLSPDef, CBMResolvedCallArray

// CLSPContext holds state for C/C++ expression type evaluation within a file.
typedef struct {
    CBMArena *arena;
    const char *source;
    int source_len;
    const CBMTypeRegistry *registry;
    /* The writable head of the registry chain: the per-file overlay the
     * dispatcher hands in, or the per-file registry on the non-cross path.
     * Every refinement (lazy add, min_params, template params) goes here
     * via cbm_registry_*_for_update; nothing behind ->fallback is written. */
    CBMTypeRegistry *registry_head;
    CBMScope *current_scope;

    // Include map: header_path -> namespace QN prefix
    const char **include_paths;
    const char **include_ns_qns;
    int include_count;

    // Namespace state
    const char *current_namespace; // current namespace QN (e.g., "proj.ns1.ns2")

    // Using namespace directives
    const char **using_namespaces;
    int using_ns_count;
    int using_ns_cap;

    // Using declarations: specific names imported into scope
    const char **using_decl_names;
    const char **using_decl_qns;
    int using_decl_count;
    int using_decl_cap;

    // Namespace aliases: short -> full QN
    const char **ns_alias_names;
    const char **ns_alias_qns;
    int ns_alias_count;
    int ns_alias_cap;

    // Current context
    const char *enclosing_func_qn;
    const char *enclosing_class_qn; // for implicit `this` resolution
    const char *module_qn;
    size_t module_qn_len; // cached strlen(module_qn); for stack-buffer QN building

    // Negative-lookup memo for c_lookup_member_depth (depth==0 misses only).
    // Open-addressing uint64 hash SET; 0 is the empty-slot sentinel. Populated
    // ONLY when the Tier-2 registry is shared+read-only (registry_shared), where
    // the module-prefix/base-class/short-name cascades are pure, stable functions
    // of (type_qn, registry) — so a recorded miss can never turn into a hit. Lets
    // the hot resolve path skip the sprintf("%s.%s") strlen storm + the O(type_count)
    // short-name scan on repeated misses of the same (type_qn, member). malloc-owned;
    // freed at end of c_lsp_process_file.
    uint64_t *neg_memo;
    int neg_memo_cap;   // power-of-two; 0 until first insert
    int neg_memo_count; // live entries (grow by rehash at 70% load)

    // Field references already emitted for this file, keyed by (enclosing
    // function, owner type, field). The function -> Field edge needs one row
    // per pair; a row per occurrence would cost a record for every member
    // access in the corpus. Same uint64 hash-set shape and ownership as
    // neg_memo; freed at end of c_lsp_process_file.
    uint64_t *field_ref_seen;
    int field_ref_seen_cap;
    int field_ref_seen_count;

    // The type an initializer_list is about to initialize, handed from the
    // declarator / compound literal / enclosing list that knows it to the walk
    // of that list. Bound to the list's node id: a hint nothing consumed must
    // never type a later, unrelated list.
    const CBMType *init_list_type;
    const void *init_list_id;

    // Output
    CBMResolvedCallArray *resolved_calls;
    CBMSourceOrigin source_origin; // source buffer represented by emitted occurrence spans
    const CBMFileResult *test_definition_owners; /* borrowed, prevalidated raw source identity */
    int test_owner_seen_count;
    bool test_owner_error;

    // Function pointer targets: lexical binding -> exact target function QN.
    // A NULL target is an explicitly unknown/ambiguous binding and must shadow
    // any outer exact target of the same name.
    const char **fp_var_names;
    const char **fp_target_qns;
    const CBMScope **fp_binding_scopes;
    int fp_count;
    int fp_cap;

    // Template parameter defaults for current template scope
    const char **template_param_names;       // e.g., ["T", "U"]
    const CBMType **template_param_defaults; // e.g., [int_type, NULL]
    int template_param_count;

    // Pending template calls: member calls on TYPE_PARAM inside template functions.
    // At call sites with known arg types, these are resolved retroactively.
    struct {
        const char *func_qn;     // enclosing template function
        const char *type_param;  // e.g., "T"
        const char *method_name; // e.g., "draw"
        int arg_count;
    } *pending_template_calls;
    int pending_tc_count;
    int pending_tc_cap;

    // Flags
    bool cpp_mode;        // C++ features enabled
    bool in_template;     // currently inside template declaration
    bool registry_shared; // ctx->registry is the Tier-2 cross registry, shared
                          // READ-ONLY across resolve workers — never mutate it
                          // (and never store per-worker arena pointers into it)
    bool debug;
    int eval_depth;            // recursion depth for c_eval_expr_type (crash guard)
    uint32_t eval_truncations; // depth-cap cutoffs; a truncated result is never memoized
    // Per-evaluation memo (#1527): results of the sub-expressions evaluated
    // during ONE outermost c_eval_expr_type call, keyed by node identity. The
    // evaluator re-evaluates a call's receiver (member lookup, then template
    // substitution), which made an N-link fluent chain cost 2^N; the per-file
    // step cap that used to hide that is gone. Evaluation never mutates scope
    // or context, so within one outermost call a node's type cannot change;
    // the memo is emptied when the next outermost call starts, because the
    // resolver walk mutates scope between calls.
    struct CLSPEvalMemoSlot *eval_memo; // open addressing, arena-owned
    int *eval_memo_used;                // slots filled by the current evaluation
    int eval_memo_cap;                  // power of two, or 0
    int eval_memo_count;
    // Pending links of the left-associative chains being evaluated
    // iteratively (operator, receiver, subscript, conditional, parenthesis and
    // comma chains): one stack shared by nested evaluations, arena-owned.
    TSNode *eval_chain;
    int eval_chain_len;
    int eval_chain_cap;
    CBMLSPStatus eval_failure; // sticky: stop refinement rather than repeat uncached work
#ifdef CBM_ENABLE_TEST_SEAMS
    int test_memo_allocations_left; // -1 = normal; 0 = fail the next memo allocation
#endif
    int walk_depth;         // c_resolve_calls_in_node self-recursion (AST nesting)
    int control_flow_depth; // if/loop/switch/catch nesting; assignments merge fail-closed
} CLSPContext;

struct CLSPEvalMemoSlot {
    const void *node_id; // TSNode.id; NULL = empty
    const CBMType *result;
};

// --- API ---

void c_lsp_init(CLSPContext *ctx, CBMArena *arena, const char *source, int source_len,
                const CBMTypeRegistry *registry, const char *module_qn, bool cpp_mode,
                CBMResolvedCallArray *out);

void c_lsp_add_include(CLSPContext *ctx, const char *header_path, const char *ns_qn);

void c_lsp_process_file(CLSPContext *ctx, TSNode root);

const CBMType *c_eval_expr_type(CLSPContext *ctx, TSNode node);
const CBMType *c_parse_type_node(CLSPContext *ctx, TSNode node);
void c_process_statement(CLSPContext *ctx, TSNode node);

// Look up a member (method/field) on a type, traversing base classes.
const CBMRegisteredFunc *c_lookup_member(CLSPContext *ctx, const char *type_qn,
                                         const char *member_name);

// Type simplification: unwrap refs, aliases, pointers (like clangd simplifyType).
const CBMType *c_simplify_type(CLSPContext *ctx, const CBMType *t, bool unwrap_pointer);

// --- Entry points ---

// Single-file LSP: build registry from file defs + stdlib, run resolution.
void cbm_run_c_lsp(CBMArena *arena, CBMFileResult *result, const char *source, int source_len,
                   TSNode root, bool cpp_mode, CBMSourceOrigin source_origin);

// A memo allocation/capacity failure is an explicit incomplete-refinement error.
#define CBM_C_LSP_DEPTH_ERROR "C/C++ expression recursion depth limit exceeded"
#define CBM_C_LSP_MEMO_ERROR "C/C++ expression memo allocation or capacity failure"
void cbm_c_lsp_record_failure(CBMFileResult *result, CBMLSPStatus status);
#ifdef CBM_ENABLE_TEST_SEAMS
// Thread-local, scoped to memo allocations only; restore with -1 after a test.
void cbm_c_lsp_test_memo_fail_after(int successful_allocations);
void cbm_c_lsp_test_depth_fail(bool enabled);
uint32_t cbm_c_lsp_test_walks_take(void);
#endif

// Cross-file LSP: build registry from defs + stdlib, re-parse and resolve.
// Status variants distinguish memo/depth failure. Bool wrappers report success.
// Completed output before a failed walk is kept.
CBMLSPStatus cbm_run_c_lsp_cross_status(CBMArena *arena, const char *source, int source_len,
                                        const char *module_qn, bool cpp_mode, CBMLSPDef *defs,
                                        int def_count, const char **include_paths,
                                        const char **include_ns_qns, int include_count,
                                        TSTree *cached_tree, // NULL = parse internally
                                        CBMResolvedCallArray *out);

bool cbm_run_c_lsp_cross(CBMArena *arena, const char *source, int source_len, const char *module_qn,
                         bool cpp_mode, CBMLSPDef *defs, int def_count, const char **include_paths,
                         const char **include_ns_qns, int include_count,
                         TSTree *cached_tree, // NULL = parse internally
                         CBMResolvedCallArray *out);

// Tier 2: build a project-wide C/C++/CUDA registry ONCE from all defs
// (filters by lang). Shared READ-ONLY across resolve workers. Def-driven
// (no AST field collection) → identical entries to the per-file build.
CBMTypeRegistry *cbm_c_build_cross_registry(CBMArena *arena, CBMLSPDef *defs, int def_count);

// Cross-file LSP using a pre-built shared registry (Tier 2). Skips the
// per-file registry build; just parse + resolve.
CBMLSPStatus cbm_run_c_lsp_cross_with_registry_status(
    CBMArena *arena, const char *source, int source_len, const char *module_qn, bool cpp_mode,
    CBMTypeRegistry *reg, // pre-built, finalized, READ-ONLY
    const char **include_paths, const char **include_ns_qns, int include_count,
    TSTree *cached_tree, // NULL = parse internally
    CBMResolvedCallArray *out);

bool cbm_run_c_lsp_cross_with_registry(CBMArena *arena, const char *source, int source_len,
                                       const char *module_qn, bool cpp_mode,
                                       CBMTypeRegistry *reg, // pre-built, finalized, READ-ONLY
                                       const char **include_paths, const char **include_ns_qns,
                                       int include_count,
                                       TSTree *cached_tree, // NULL = parse internally
                                       CBMResolvedCallArray *out);

/* Additive configured-owner entrypoints. Owners must outlive the call. With
 * owners, RAW origin, exact source identity and module identity are required.
 * Configured owners fresh-parse verified source: supplied roots/cached trees
 * have no source provenance and are not trusted. NULL owners retain caching.
 * False leaves output untouched when identity validation fails. A later
 * mapping/OOM failure may leave partial output that callers must discard. QNs
 * in successful output belong to the supplied output arena. Callers must
 * abort publication on false. Legacy wrappers pass NULL and retain previous behavior. */
bool cbm_run_c_lsp_with_test_owners(
    CBMArena *arena, CBMFileResult *result, const char *source, int source_len,
    TSNode root, bool cpp_mode, CBMSourceOrigin source_origin,
    const CBMFileResult *test_owners);
bool cbm_run_c_lsp_cross_with_test_owners(
    CBMArena *arena, const char *source, int source_len, const char *module_qn,
    bool cpp_mode, CBMLSPDef *defs, int def_count, const char **include_paths,
    const char **include_ns_qns, int include_count, TSTree *cached_tree,
    CBMResolvedCallArray *out, CBMSourceOrigin source_origin,
    const CBMFileResult *test_owners);
bool cbm_run_c_lsp_cross_with_registry_with_test_owners(
    CBMArena *arena, const char *source, int source_len, const char *module_qn,
    bool cpp_mode, CBMTypeRegistry *reg, const char **include_paths,
    const char **include_ns_qns, int include_count, TSTree *cached_tree,
    CBMResolvedCallArray *out, CBMSourceOrigin source_origin,
    const CBMFileResult *test_owners);

// Register C stdlib types and functions into a registry.
void cbm_c_stdlib_register(CBMTypeRegistry *reg, CBMArena *arena);

// Register C++ stdlib types and functions into a registry.
void cbm_cpp_stdlib_register(CBMTypeRegistry *reg, CBMArena *arena);

// --- Batch cross-file LSP ---

// Per-file input for batch C/C++ LSP processing.
typedef struct {
    const char *source;
    int source_len;
    const char *module_qn;
    bool cpp_mode;
    TSTree *cached_tree; // from TSTree caching (NULL = parse internally)
    CBMLSPDef *defs;     // combined file-local + cross-file defs
    int def_count;
    const char **include_paths; // parallel arrays, include_count long
    const char **include_ns_qns;
    int include_count;
} CBMBatchCLSPFile;

// Process multiple C/C++ files' cross-file LSP in one CGo call.
// out must point to file_count pre-zeroed CBMResolvedCallArray structs.
bool cbm_batch_c_lsp_cross(CBMArena *arena, CBMBatchCLSPFile *files, int file_count,
                           CBMResolvedCallArray *out);

#endif // CBM_LSP_C_LSP_H