wehub-resource-sync
3046 lines
135 KiB
C
3046 lines
135 KiB
C
/*
|
|
* 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
|
|
|
|
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);
|
|
|
|
/* ── 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 ───────────────────────────────────────────── */
|
|
|
|
void cs_lsp_add_using(CSLSPContext *ctx, CBMCSUsingKind kind, const char *local_name,
|
|
const char *target_qn, bool is_global) {
|
|
if (!target_qn) return;
|
|
/* Dedupe by (kind, local_name, target). */
|
|
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;
|
|
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;
|
|
}
|
|
|
|
/* ── 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;
|
|
}
|
|
|
|
/* 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
|
|
* 9. fall back to bare name (registry will fail; pipeline 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;
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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;
|
|
const char *namespace_dotted = cs_namespace_qn(ctx);
|
|
for (int i = 0; ctx->registry && i < ctx->registry->type_count; i++) {
|
|
const CBMRegisteredType *cand = &ctx->registry->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) {
|
|
best_score = score;
|
|
best = cand;
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
/* Walk inheritance chain (base + interfaces + transitive bases). */
|
|
const CBMRegisteredType *t = cs_lookup_type_qn(ctx, type_qn);
|
|
if (!t) return NULL;
|
|
|
|
const char *visited[CS_LSP_PARENT_WALK_MAX];
|
|
int visited_count = 0;
|
|
const char *frontier[CS_LSP_PARENT_WALK_MAX];
|
|
int frontier_count = 0;
|
|
|
|
if (t->embedded_types) {
|
|
for (int i = 0; t->embedded_types[i] && frontier_count < CS_LSP_PARENT_WALK_MAX; i++) {
|
|
frontier[frontier_count++] = t->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;
|
|
}
|
|
|
|
/* ── 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. */
|
|
for (int i = 0; i < ctx->registry->func_count; i++) {
|
|
const CBMRegisteredFunc *cand = &ctx->registry->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. */
|
|
return cand;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* ── 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];
|
|
}
|
|
}
|
|
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 *qn = cbm_arena_sprintf(ctx->arena, "%s.%s", u->target_qn, 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];
|
|
}
|
|
}
|
|
}
|
|
|
|
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 ───────────────────────────────────────── */
|
|
|
|
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);
|
|
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_t = cs_eval_expr_type(ctx, rhs);
|
|
} else {
|
|
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)) {
|
|
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) {
|
|
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();
|
|
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 CBMType *t = cs_eval_expr_type(ctx, rhs);
|
|
if (!t || t->kind == CBM_TYPE_UNKNOWN) return;
|
|
/* Don't override more-specific bindings with weaker ones. */
|
|
const CBMType *existing = cbm_scope_lookup(ctx->current_scope, vname);
|
|
if (existing && existing->kind == CBM_TYPE_NAMED && t->kind == CBM_TYPE_UNKNOWN) return;
|
|
cbm_scope_bind(ctx->current_scope, vname, t);
|
|
}
|
|
|
|
/* ── call resolution + emit ─────────────────────────────────────── */
|
|
|
|
static void cs_emit_resolved(CSLSPContext *ctx, const char *callee_qn, const char *strategy,
|
|
float confidence) {
|
|
if (!ctx->resolved_calls || !callee_qn || !ctx->enclosing_func_qn) return;
|
|
CBMResolvedCall rc;
|
|
rc.caller_qn = ctx->enclosing_func_qn;
|
|
rc.callee_qn = callee_qn;
|
|
rc.strategy = strategy;
|
|
rc.confidence = confidence;
|
|
rc.reason = NULL;
|
|
cbm_resolvedcall_push(ctx->resolved_calls, ctx->arena, rc);
|
|
}
|
|
|
|
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);
|
|
|
|
/* 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. */
|
|
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 *f = cs_lookup_method(ctx, host ? host : u->target_qn, bare);
|
|
if (f) {
|
|
cs_emit_resolved(ctx, f->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;
|
|
for (int i = 0; ctx->registry && i < ctx->registry->func_count; i++) {
|
|
const CBMRegisteredFunc *cand = &ctx->registry->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) {
|
|
cs_resolve_invocation(ctx, node);
|
|
} else if (strcmp(kind, "object_creation_expression") == 0) {
|
|
cs_resolve_object_creation(ctx, 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);
|
|
}
|
|
|
|
/* ── 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. */
|
|
TSNode stack[256];
|
|
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);
|
|
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_lsp_add_using(ctx, CBM_CS_USING_ALIAS, alias_name ? alias_name : "",
|
|
target, is_global);
|
|
} else if (is_static) {
|
|
cs_lsp_add_using(ctx, CBM_CS_USING_STATIC, "", target, is_global);
|
|
} else {
|
|
cs_lsp_add_using(ctx, CBM_CS_USING_NAMESPACE, "", target, is_global);
|
|
}
|
|
}
|
|
}
|
|
/* Push children for traversal. We don't recurse into method bodies
|
|
* (using directives can't appear there), but namespace bodies may
|
|
* contain more usings. */
|
|
uint32_t cnc = ts_node_child_count(n);
|
|
for (uint32_t i = 0; i < cnc && top < 256; 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;
|
|
}
|
|
stack[top++] = c;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ── 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ── 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);
|
|
}
|
|
|
|
/* ── 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(®, arena);
|
|
|
|
/* Phase A: stdlib. */
|
|
cbm_csharp_stdlib_register(®, 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.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(®, 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(®, rf);
|
|
}
|
|
}
|
|
|
|
/* Phase C: build context for type resolution + run the resolver. */
|
|
CSLSPContext ctx;
|
|
cs_lsp_init(&ctx, arena, source, source_len, ®, module_qn, &result->resolved_calls);
|
|
|
|
/* Pass 1: collect imports + namespaces (for type-resolution context). */
|
|
cs_collect_imports(&ctx, root);
|
|
|
|
/* 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(arena, NULL, NULL, 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. */
|
|
{
|
|
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(arena, 2 * sizeof(const CBMType *));
|
|
if (rets) {
|
|
rets[0] = rt;
|
|
rets[1] = NULL;
|
|
reg.funcs[j].signature = cbm_type_func(arena, NULL, NULL, rets);
|
|
}
|
|
patched = true;
|
|
break;
|
|
}
|
|
}
|
|
(void)patched;
|
|
}
|
|
}
|
|
|
|
/* Phase B.1: collect typed properties + fields. */
|
|
{
|
|
cs_fields_table_t tab = {0};
|
|
cs_collect_class_fields(&ctx, ®, 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 ───────────────────────────────────────────── */
|
|
|
|
/* 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.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;
|
|
}
|
|
const CBMType **rets =
|
|
(const CBMType **)cbm_arena_alloc(arena, 2 * sizeof(const CBMType *));
|
|
if (rets) {
|
|
rets[0] = cbm_type_unknown();
|
|
rets[1] = NULL;
|
|
}
|
|
rf.signature = cbm_type_func(arena, NULL, NULL, 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. */
|
|
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);
|
|
for (int i = 0; i < def_count; i++) {
|
|
if (defs[i].lang != CBM_LANG_CSHARP) continue;
|
|
cs_register_lsp_defs(arena, reg, &defs[i], 1);
|
|
}
|
|
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 = ts_parser_parse_string(parser, NULL, source,
|
|
source_len > 0 ? (uint32_t)source_len : (uint32_t)strlen(source));
|
|
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(®, arena);
|
|
cbm_csharp_stdlib_register(®, arena);
|
|
cs_register_lsp_defs(arena, ®, 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 = ts_parser_parse_string(parser, NULL, source,
|
|
source_len > 0 ? (uint32_t)source_len : (uint32_t)strlen(source));
|
|
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(®);
|
|
|
|
CSLSPContext ctx;
|
|
cs_lsp_init(&ctx, arena, source, source_len, ®, 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]);
|
|
}
|
|
}
|