wehub-resource-sync
2961 lines
117 KiB
C
2961 lines
117 KiB
C
#include "cbm.h"
|
|
#include "arena.h" // CBMArena, cbm_arena_strdup/strndup/sprintf
|
|
#include "helpers.h"
|
|
#include "lang_specs.h" // CBMLangSpec, CBMEmbeddedLangSpec, cbm_lang_spec, cbm_ts_language
|
|
#include "tree_sitter/api.h" // TSNode, ts_node_*
|
|
#include "foundation/constants.h"
|
|
#include "extract_node_stack.h"
|
|
#include <stdint.h> // uint32_t
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
|
|
/* Local constants for magic number elimination. */
|
|
enum {
|
|
USE_PREFIX_LEN = 4, /* strlen("use ") */
|
|
MIN_WOLFRAM_CHILDREN = 2,
|
|
SECOND_IDX = 1,
|
|
};
|
|
|
|
// Field name length for ts_node_child_by_field_name() calls.
|
|
#define FIELD_LEN_MODULE_NAME 11 // strlen("module_name")
|
|
|
|
// Forward declarations
|
|
static void parse_go_imports(CBMExtractCtx *ctx);
|
|
static void parse_python_imports(CBMExtractCtx *ctx);
|
|
static void parse_es_imports(CBMExtractCtx *ctx);
|
|
static void parse_java_imports(CBMExtractCtx *ctx);
|
|
static void parse_rust_imports(CBMExtractCtx *ctx);
|
|
static void parse_c_imports(CBMExtractCtx *ctx);
|
|
static void parse_ruby_imports(CBMExtractCtx *ctx);
|
|
static void parse_lua_imports(CBMExtractCtx *ctx);
|
|
static void parse_r_imports(CBMExtractCtx *ctx);
|
|
static void parse_kotlin_imports(CBMExtractCtx *ctx);
|
|
static void parse_dart_imports(CBMExtractCtx *ctx);
|
|
static void parse_haskell_imports(CBMExtractCtx *ctx);
|
|
static void parse_zig_imports(CBMExtractCtx *ctx);
|
|
static void parse_generic_imports(CBMExtractCtx *ctx, const char *node_type);
|
|
static void parse_wolfram_imports(CBMExtractCtx *ctx);
|
|
static void parse_php_imports(CBMExtractCtx *ctx);
|
|
static void parse_csharp_imports(CBMExtractCtx *ctx);
|
|
static void parse_spec_imports(CBMExtractCtx *ctx);
|
|
static void parse_hare_imports(CBMExtractCtx *ctx);
|
|
static void parse_pascal_imports(CBMExtractCtx *ctx);
|
|
static void parse_powershell_imports(CBMExtractCtx *ctx);
|
|
static void parse_lisp_imports(CBMExtractCtx *ctx);
|
|
static void parse_starlark_imports(CBMExtractCtx *ctx);
|
|
static void parse_tcl_imports(CBMExtractCtx *ctx);
|
|
static void parse_teal_imports(CBMExtractCtx *ctx);
|
|
static void parse_zsh_imports(CBMExtractCtx *ctx);
|
|
static void parse_css_imports(CBMExtractCtx *ctx);
|
|
static void parse_html_imports(CBMExtractCtx *ctx);
|
|
static void parse_cmake_imports(CBMExtractCtx *ctx);
|
|
static void parse_bitbake_imports(CBMExtractCtx *ctx);
|
|
static void parse_kconfig_imports(CBMExtractCtx *ctx);
|
|
static void parse_gn_imports(CBMExtractCtx *ctx);
|
|
static void parse_just_imports(CBMExtractCtx *ctx);
|
|
static void parse_nix_imports(CBMExtractCtx *ctx);
|
|
static void parse_jsonnet_imports(CBMExtractCtx *ctx);
|
|
static void parse_pkl_imports(CBMExtractCtx *ctx);
|
|
static void parse_nickel_imports(CBMExtractCtx *ctx);
|
|
static void parse_thrift_imports(CBMExtractCtx *ctx);
|
|
static void parse_capnp_imports(CBMExtractCtx *ctx);
|
|
static void parse_dlang_imports(CBMExtractCtx *ctx);
|
|
static void parse_tablegen_imports(CBMExtractCtx *ctx);
|
|
static void parse_crystal_imports(CBMExtractCtx *ctx);
|
|
static void parse_fsharp_imports(CBMExtractCtx *ctx);
|
|
static void parse_ada_imports(CBMExtractCtx *ctx);
|
|
static void parse_elm_imports(CBMExtractCtx *ctx);
|
|
static void parse_move_imports(CBMExtractCtx *ctx);
|
|
static void parse_smali_imports(CBMExtractCtx *ctx);
|
|
static void parse_tlaplus_imports(CBMExtractCtx *ctx);
|
|
static void parse_vhdl_imports(CBMExtractCtx *ctx);
|
|
static void parse_wit_imports(CBMExtractCtx *ctx);
|
|
static void parse_smithy_imports(CBMExtractCtx *ctx);
|
|
static void parse_hyprlang_imports(CBMExtractCtx *ctx);
|
|
|
|
// Helper: strip quotes from a string literal
|
|
static char *strip_quotes(CBMArena *a, const char *s) {
|
|
if (!s) {
|
|
return NULL;
|
|
}
|
|
size_t len = strlen(s);
|
|
if (len >= CBM_QUOTE_PAIR && (s[0] == '"' || s[0] == '\'') && s[len - SKIP_ONE] == s[0]) {
|
|
return cbm_arena_strndup(a, s + SKIP_ONE, len - PAIR_LEN);
|
|
}
|
|
return cbm_arena_strdup(a, s);
|
|
}
|
|
|
|
// Helper: get last path component as local name.
|
|
// Recognizes every separator used across the supported import syntaxes:
|
|
// '/' (Go / TS / JS paths), '.' (Java / Kotlin / C# / Python dotted names),
|
|
// '::' (Rust / C++ scope), '\\' (PHP namespaces). The last separator of any
|
|
// kind wins, so "std::collections::HashMap" → "HashMap" and
|
|
// "App\\Http\\Controller" → "Controller".
|
|
static const char *path_last(CBMArena *a, const char *path) {
|
|
if (!path) {
|
|
return NULL;
|
|
}
|
|
const char *last_sep = NULL;
|
|
for (const char *p = path; *p; p++) {
|
|
if (*p == '/' || *p == '.' || *p == ':' || *p == '\\') {
|
|
last_sep = p;
|
|
}
|
|
}
|
|
if (last_sep) {
|
|
return cbm_arena_strdup(a, last_sep + SKIP_ONE);
|
|
}
|
|
return path;
|
|
}
|
|
|
|
// --- Go imports ---
|
|
// import_declaration -> import_spec_list -> import_spec -> (name, path)
|
|
|
|
// Parse a single Go import_spec node.
|
|
static void parse_go_import_spec(CBMExtractCtx *ctx, TSNode spec) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNode path_node = ts_node_child_by_field_name(spec, TS_FIELD("path"));
|
|
if (ts_node_is_null(path_node)) {
|
|
return;
|
|
}
|
|
char *path = strip_quotes(a, cbm_node_text(a, path_node, ctx->source));
|
|
if (!path || !path[0]) {
|
|
return;
|
|
}
|
|
|
|
TSNode name_node = ts_node_child_by_field_name(spec, TS_FIELD("name"));
|
|
const char *local_name =
|
|
!ts_node_is_null(name_node) ? cbm_node_text(a, name_node, ctx->source) : path_last(a, path);
|
|
|
|
CBMImport imp = {.local_name = local_name, .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
|
|
static void parse_go_imports(CBMExtractCtx *ctx) {
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode decl = ts_tree_cursor_current_node(&cursor);
|
|
if (strcmp(ts_node_type(decl), "import_declaration") != 0) {
|
|
continue;
|
|
}
|
|
|
|
uint32_t dc = ts_node_child_count(decl);
|
|
for (uint32_t j = 0; j < dc; j++) {
|
|
TSNode child = ts_node_child(decl, j);
|
|
const char *ck = ts_node_type(child);
|
|
if (strcmp(ck, "import_spec") == 0) {
|
|
parse_go_import_spec(ctx, child);
|
|
} else if (strcmp(ck, "import_spec_list") == 0) {
|
|
uint32_t sc = ts_node_child_count(child);
|
|
for (uint32_t k = 0; k < sc; k++) {
|
|
TSNode spec = ts_node_child(child, k);
|
|
if (strcmp(ts_node_type(spec), "import_spec") == 0) {
|
|
parse_go_import_spec(ctx, spec);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Python imports ---
|
|
// import_statement: import X, import X as Y
|
|
// import_from_statement: from X import Y, from X import Y as Z
|
|
|
|
// Emit a Python aliased_import (import X as Y / from X import Y as Z).
|
|
static void emit_py_aliased_import(CBMExtractCtx *ctx, TSNode child, const char *mod_prefix) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNode mod_node = ts_node_child_by_field_name(child, TS_FIELD("name"));
|
|
TSNode alias_node = ts_node_child_by_field_name(child, TS_FIELD("alias"));
|
|
if (ts_node_is_null(mod_node)) {
|
|
return;
|
|
}
|
|
char *name = cbm_node_text(a, mod_node, ctx->source);
|
|
if (!name || !name[0]) {
|
|
return;
|
|
}
|
|
const char *local = !ts_node_is_null(alias_node) ? cbm_node_text(a, alias_node, ctx->source)
|
|
: path_last(a, name);
|
|
const char *full = mod_prefix ? cbm_arena_sprintf(a, "%s.%s", mod_prefix, name) : name;
|
|
CBMImport imp = {.local_name = local, .module_path = full};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
|
|
// Process a single Python import_statement node (import X, import X as Y).
|
|
static void process_py_import_stmt(CBMExtractCtx *ctx, TSNode node) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNode name_node = ts_node_child_by_field_name(node, TS_FIELD("name"));
|
|
if (ts_node_is_null(name_node)) {
|
|
uint32_t nc = ts_node_child_count(node);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode child = ts_node_child(node, j);
|
|
const char *ck = ts_node_type(child);
|
|
if (strcmp(ck, "dotted_name") == 0 || strcmp(ck, "identifier") == 0) {
|
|
char *mod = cbm_node_text(a, child, ctx->source);
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
} else if (strcmp(ck, "aliased_import") == 0) {
|
|
emit_py_aliased_import(ctx, child, NULL);
|
|
}
|
|
}
|
|
} else if (strcmp(ts_node_type(name_node), "aliased_import") == 0) {
|
|
/* `import util as u` — the import_statement's `name` field points at the
|
|
* aliased_import; extract its real module name (not "util as u"). */
|
|
emit_py_aliased_import(ctx, name_node, NULL);
|
|
} else {
|
|
char *mod = cbm_node_text(a, name_node, ctx->source);
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Resolve the module_name node for a Python import_from_statement.
|
|
static TSNode resolve_py_module_node(TSNode node) {
|
|
TSNode module_node = ts_node_child_by_field_name(node, "module_name", FIELD_LEN_MODULE_NAME);
|
|
if (ts_node_is_null(module_node)) {
|
|
uint32_t nc = ts_node_child_count(node);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode c = ts_node_child(node, j);
|
|
if (strcmp(ts_node_type(c), "dotted_name") == 0 ||
|
|
strcmp(ts_node_type(c), "relative_import") == 0) {
|
|
return c;
|
|
}
|
|
}
|
|
}
|
|
return module_node;
|
|
}
|
|
|
|
// Emit a Python import-from name child (identifier/dotted_name).
|
|
static void emit_py_import_from_name(CBMExtractCtx *ctx, TSNode child, const char *mod_path) {
|
|
CBMArena *a = ctx->arena;
|
|
char *name = cbm_node_text(a, child, ctx->source);
|
|
if (name && name[0]) {
|
|
const char *full = mod_path ? cbm_arena_sprintf(a, "%s.%s", mod_path, name) : name;
|
|
CBMImport imp = {.local_name = name, .module_path = full};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
|
|
// Process a single Python import_from_statement node (from X import Y [as Z]).
|
|
static void process_py_import_from(CBMExtractCtx *ctx, TSNode node) {
|
|
CBMArena *a = ctx->arena;
|
|
// `from __future__ import annotations` is a dedicated node type whose first
|
|
// child is the literal `__future__` keyword (an identifier, not a
|
|
// dotted_name). Emit a single import for `__future__` and return.
|
|
if (strcmp(ts_node_type(node), "future_import_statement") == 0) {
|
|
CBMImport imp = {.local_name = cbm_arena_strdup(a, "__future__"),
|
|
.module_path = cbm_arena_strdup(a, "__future__")};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
return;
|
|
}
|
|
TSNode module_node = resolve_py_module_node(node);
|
|
char *mod_path =
|
|
ts_node_is_null(module_node) ? NULL : cbm_node_text(a, module_node, ctx->source);
|
|
|
|
uint32_t nc = ts_node_child_count(node);
|
|
bool emitted = false;
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode child = ts_node_child(node, j);
|
|
const char *ck = ts_node_type(child);
|
|
if (strcmp(ck, "identifier") == 0 || strcmp(ck, "dotted_name") == 0) {
|
|
if (!ts_node_is_null(module_node) &&
|
|
ts_node_start_byte(child) == ts_node_start_byte(module_node)) {
|
|
continue;
|
|
}
|
|
emit_py_import_from_name(ctx, child, mod_path);
|
|
emitted = true;
|
|
} else if (strcmp(ck, "aliased_import") == 0) {
|
|
emit_py_aliased_import(ctx, child, mod_path);
|
|
emitted = true;
|
|
} else if (strcmp(ck, "wildcard_import") == 0) {
|
|
// `from os.path import *` — the module itself is the import.
|
|
if (mod_path && mod_path[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod_path), .module_path = mod_path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
emitted = true;
|
|
}
|
|
}
|
|
}
|
|
// Defensive: a from-import with a module but no recognized name child
|
|
// (grammar variant) still records the module as an import.
|
|
if (!emitted && mod_path && mod_path[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod_path), .module_path = mod_path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
|
|
static void parse_python_imports(CBMExtractCtx *ctx) {
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
const char *kind = ts_node_type(node);
|
|
|
|
if (strcmp(kind, "import_statement") == 0) {
|
|
process_py_import_stmt(ctx, node);
|
|
} else if (strcmp(kind, "import_from_statement") == 0 ||
|
|
strcmp(kind, "future_import_statement") == 0) {
|
|
// `from __future__ import annotations` is a distinct node type in
|
|
// tree-sitter-python but has the same shape (module + name list).
|
|
process_py_import_from(ctx, node);
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- ES module imports (JS/TS/TSX) ---
|
|
// import X from "Y"; import {A, B} from "Y"; import * as X from "Y"
|
|
// const X = require("Y")
|
|
|
|
// Find the source string node in an ES import_statement.
|
|
static TSNode find_es_source_node(TSNode node) {
|
|
TSNode source_node = ts_node_child_by_field_name(node, TS_FIELD("source"));
|
|
if (ts_node_is_null(source_node)) {
|
|
uint32_t nc = ts_node_child_count(node);
|
|
for (int j = (int)nc - SKIP_ONE; j >= 0; j--) {
|
|
TSNode c = ts_node_child(node, (uint32_t)j);
|
|
const char *ck = ts_node_type(c);
|
|
if (strcmp(ck, "string") == 0 || strcmp(ck, "string_literal") == 0) {
|
|
return c;
|
|
}
|
|
}
|
|
}
|
|
return source_node;
|
|
}
|
|
|
|
// Process named_imports: import {A, B as C} from "path".
|
|
static bool process_named_imports(CBMExtractCtx *ctx, TSNode sub, const char *path) {
|
|
CBMArena *a = ctx->arena;
|
|
bool found = false;
|
|
uint32_t nc2 = ts_node_child_count(sub);
|
|
for (uint32_t m = 0; m < nc2; m++) {
|
|
TSNode imp_spec = ts_node_child(sub, m);
|
|
if (strcmp(ts_node_type(imp_spec), "import_specifier") != 0) {
|
|
continue;
|
|
}
|
|
TSNode local = ts_node_child_by_field_name(imp_spec, TS_FIELD("alias"));
|
|
TSNode orig = ts_node_child_by_field_name(imp_spec, TS_FIELD("name"));
|
|
if (ts_node_is_null(orig) && ts_node_child_count(imp_spec) > 0) {
|
|
orig = ts_node_child(imp_spec, 0);
|
|
}
|
|
if (!ts_node_is_null(orig)) {
|
|
char *local_name = !ts_node_is_null(local) ? cbm_node_text(a, local, ctx->source)
|
|
: cbm_node_text(a, orig, ctx->source);
|
|
CBMImport imp = {.local_name = local_name, .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
found = true;
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
|
|
// Process an import_clause node: default, namespace, and named imports.
|
|
static bool process_import_clause(CBMExtractCtx *ctx, TSNode clause, const char *path) {
|
|
CBMArena *a = ctx->arena;
|
|
bool found = false;
|
|
uint32_t cc = ts_node_child_count(clause);
|
|
for (uint32_t k = 0; k < cc; k++) {
|
|
TSNode sub = ts_node_child(clause, k);
|
|
const char *sk = ts_node_type(sub);
|
|
if (strcmp(sk, "identifier") == 0) {
|
|
char *name = cbm_node_text(a, sub, ctx->source);
|
|
CBMImport imp = {.local_name = name, .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
found = true;
|
|
} else if (strcmp(sk, "namespace_import") == 0) {
|
|
TSNode as_name = ts_node_child_by_field_name(sub, TS_FIELD("name"));
|
|
if (ts_node_is_null(as_name) && ts_node_child_count(sub) > 0) {
|
|
as_name = ts_node_child(sub, ts_node_child_count(sub) - SKIP_ONE);
|
|
}
|
|
if (!ts_node_is_null(as_name)) {
|
|
char *name = cbm_node_text(a, as_name, ctx->source);
|
|
CBMImport imp = {.local_name = name, .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
found = true;
|
|
}
|
|
} else if (strcmp(sk, "named_imports") == 0) {
|
|
if (process_named_imports(ctx, sub, path)) {
|
|
found = true;
|
|
}
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
|
|
/* Process a single ES import_statement node. Returns true if fully handled. */
|
|
static bool process_es_import_statement(CBMExtractCtx *ctx, TSNode node) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNode source_node = find_es_source_node(node);
|
|
if (ts_node_is_null(source_node)) {
|
|
return false;
|
|
}
|
|
char *path = strip_quotes(a, cbm_node_text(a, source_node, ctx->source));
|
|
if (!path || !path[0]) {
|
|
return false;
|
|
}
|
|
uint32_t nc = ts_node_child_count(node);
|
|
bool found = false;
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode child = ts_node_child(node, j);
|
|
const char *ck = ts_node_type(child);
|
|
if (strcmp(ck, "identifier") == 0) {
|
|
char *name = cbm_node_text(a, child, ctx->source);
|
|
CBMImport imp = {.local_name = name, .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
found = true;
|
|
} else if (strcmp(ck, "import_clause") == 0) {
|
|
if (process_import_clause(ctx, child, path)) {
|
|
found = true;
|
|
}
|
|
}
|
|
}
|
|
if (!found) {
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* Handle CommonJS `require("path")` call_expression nodes. The local name
|
|
* is derived from the enclosing variable_declarator / assignment when
|
|
* possible (so `const foo = require('./foo')` emits local_name="foo"),
|
|
* otherwise falls back to the last path component. */
|
|
static bool process_commonjs_require(CBMExtractCtx *ctx, TSNode call) {
|
|
CBMArena *a = ctx->arena;
|
|
if (ts_node_child_count(call) < MIN_WOLFRAM_CHILDREN) {
|
|
return false;
|
|
}
|
|
/* Callee must be the identifier "require". */
|
|
TSNode fn = ts_node_child_by_field_name(call, TS_FIELD("function"));
|
|
if (ts_node_is_null(fn)) {
|
|
fn = ts_node_child(call, 0);
|
|
}
|
|
if (ts_node_is_null(fn)) {
|
|
return false;
|
|
}
|
|
const char *fn_kind = ts_node_type(fn);
|
|
if (strcmp(fn_kind, "identifier") != 0) {
|
|
return false;
|
|
}
|
|
char *fn_name = cbm_node_text(a, fn, ctx->source);
|
|
if (!fn_name || strcmp(fn_name, "require") != 0) {
|
|
return false;
|
|
}
|
|
|
|
/* First string literal child of the argument list is the module path. */
|
|
TSNode args = ts_node_child_by_field_name(call, TS_FIELD("arguments"));
|
|
if (ts_node_is_null(args)) {
|
|
return false;
|
|
}
|
|
uint32_t argc = ts_node_named_child_count(args);
|
|
char *path = NULL;
|
|
for (uint32_t i = 0; i < argc; i++) {
|
|
TSNode arg = ts_node_named_child(args, i);
|
|
const char *ak = ts_node_type(arg);
|
|
if (strcmp(ak, "string") == 0 || strcmp(ak, "string_literal") == 0 ||
|
|
strcmp(ak, "template_string") == 0) {
|
|
path = strip_quotes(a, cbm_node_text(a, arg, ctx->source));
|
|
break;
|
|
}
|
|
}
|
|
if (!path || !path[0]) {
|
|
return false;
|
|
}
|
|
|
|
/* Infer local name from enclosing variable_declarator. Tree-sitter's JS
|
|
* grammar wraps `const foo = require(..)` as
|
|
* lexical_declaration → variable_declarator { name: identifier, value: call } */
|
|
const char *local_name = NULL;
|
|
TSNode parent = ts_node_parent(call);
|
|
if (!ts_node_is_null(parent) && strcmp(ts_node_type(parent), "variable_declarator") == 0) {
|
|
TSNode name_node = ts_node_child_by_field_name(parent, TS_FIELD("name"));
|
|
if (!ts_node_is_null(name_node) && strcmp(ts_node_type(name_node), "identifier") == 0) {
|
|
local_name = cbm_node_text(a, name_node, ctx->source);
|
|
}
|
|
}
|
|
if (!local_name) {
|
|
local_name = path_last(a, path);
|
|
}
|
|
|
|
CBMImport imp = {.local_name = local_name, .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
return true;
|
|
}
|
|
|
|
static void walk_es_imports(CBMExtractCtx *ctx, TSNode root) {
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, ctx->arena, CBM_SZ_512);
|
|
ts_nstack_push(&stack, ctx->arena, root);
|
|
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *kind = ts_node_type(node);
|
|
bool push_children = true;
|
|
|
|
if (strcmp(kind, "import_statement") == 0) {
|
|
if (process_es_import_statement(ctx, node)) {
|
|
push_children = false;
|
|
}
|
|
} else if (strcmp(kind, "export_statement") == 0) {
|
|
/* Re-export: `export { x } from './mod'` / `export * from './mod'`.
|
|
* It carries a `source` string just like an import and creates the
|
|
* same module dependency. */
|
|
TSNode src = ts_node_child_by_field_name(node, TS_FIELD("source"));
|
|
if (!ts_node_is_null(src)) {
|
|
char *path = strip_quotes(ctx->arena, cbm_node_text(ctx->arena, src, ctx->source));
|
|
if (path && path[0]) {
|
|
CBMImport imp = {.local_name = path_last(ctx->arena, path),
|
|
.module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, ctx->arena, imp);
|
|
}
|
|
}
|
|
} else if (strcmp(kind, "call_expression") == 0) {
|
|
/* CommonJS require() — only consume the node if we recognized
|
|
* it as a require call; otherwise keep traversing the children. */
|
|
if (process_commonjs_require(ctx, node)) {
|
|
push_children = false;
|
|
}
|
|
}
|
|
|
|
if (push_children) {
|
|
ts_nstack_push_children(&stack, ctx->arena, node);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void parse_es_imports(CBMExtractCtx *ctx) {
|
|
walk_es_imports(ctx, ctx->root);
|
|
}
|
|
|
|
// --- Java imports ---
|
|
// import_declaration -> scoped_identifier
|
|
|
|
static void parse_java_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
if (strcmp(ts_node_type(node), "import_declaration") != 0) {
|
|
continue;
|
|
}
|
|
|
|
// Get the full import path (skip "import" and "static" keywords)
|
|
uint32_t nc = ts_node_child_count(node);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode child = ts_node_child(node, j);
|
|
const char *ck = ts_node_type(child);
|
|
if (strcmp(ck, "scoped_identifier") == 0 || strcmp(ck, "identifier") == 0) {
|
|
char *path = cbm_node_text(a, child, ctx->source);
|
|
if (path && path[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Rust imports ---
|
|
// use_declaration -> use_list or scoped_use_list
|
|
|
|
static void parse_rust_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
if (strcmp(ts_node_type(node), "use_declaration") != 0) {
|
|
continue;
|
|
}
|
|
|
|
char *full = cbm_node_text(a, node, ctx->source);
|
|
if (!full) {
|
|
continue;
|
|
}
|
|
// Strip "use " prefix and trailing ";"
|
|
if (strncmp(full, "use ", USE_PREFIX_LEN) == 0) {
|
|
full += USE_PREFIX_LEN;
|
|
}
|
|
size_t len = strlen(full);
|
|
if (len > 0 && full[len - SKIP_ONE] == ';') {
|
|
full[len - SKIP_ONE] = '\0';
|
|
}
|
|
|
|
CBMImport imp = {.local_name = path_last(a, full), .module_path = full};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- C/C++ imports ---
|
|
// preproc_include -> path or string_literal
|
|
|
|
// Find the path node inside a preproc_include/preproc_import node.
|
|
static TSNode find_include_path_node(TSNode node) {
|
|
TSNode path_node = ts_node_child_by_field_name(node, TS_FIELD("path"));
|
|
if (ts_node_is_null(path_node)) {
|
|
uint32_t nc = ts_node_child_count(node);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode c = ts_node_child(node, j);
|
|
const char *ck = ts_node_type(c);
|
|
if (strcmp(ck, "string_literal") == 0 || strcmp(ck, "system_lib_string") == 0) {
|
|
return c;
|
|
}
|
|
}
|
|
}
|
|
return path_node;
|
|
}
|
|
|
|
// Strip angle brackets from a system include path (<stdio.h> → stdio.h).
|
|
static char *strip_angle_brackets(CBMArena *a, char *path) {
|
|
if (path && path[0] == '<') {
|
|
size_t len = strlen(path);
|
|
if (len > SKIP_ONE && path[len - SKIP_ONE] == '>') {
|
|
return cbm_arena_strndup(a, path + SKIP_ONE, len - PAIR_LEN);
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
|
|
static void parse_c_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
const char *kind = ts_node_type(node);
|
|
if (strcmp(kind, "preproc_include") != 0 && strcmp(kind, "preproc_import") != 0) {
|
|
continue;
|
|
}
|
|
|
|
TSNode path_node = find_include_path_node(node);
|
|
if (ts_node_is_null(path_node)) {
|
|
continue;
|
|
}
|
|
|
|
char *path = strip_quotes(a, cbm_node_text(a, path_node, ctx->source));
|
|
path = strip_angle_brackets(a, path);
|
|
if (!path || !path[0]) {
|
|
continue;
|
|
}
|
|
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Ruby imports ---
|
|
// call nodes: require("X"), require_relative("X")
|
|
|
|
// Check if a Ruby call node is a require/require_relative, return method name or NULL.
|
|
static const char *ruby_require_method(CBMArena *a, TSNode node, const char *source) {
|
|
TSNode method = ts_node_child_by_field_name(node, TS_FIELD("method"));
|
|
if (ts_node_is_null(method) && ts_node_child_count(node) > 0) {
|
|
method = ts_node_child(node, 0);
|
|
}
|
|
if (ts_node_is_null(method)) {
|
|
return NULL;
|
|
}
|
|
char *name = cbm_node_text(a, method, source);
|
|
if (!name || (strcmp(name, "require") != 0 && strcmp(name, "require_relative") != 0)) {
|
|
return NULL;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
// Extract string argument from a Ruby require/require_relative call.
|
|
static char *extract_ruby_require_arg(CBMArena *a, TSNode node, const char *source) {
|
|
TSNode args = ts_node_child_by_field_name(node, TS_FIELD("arguments"));
|
|
if (ts_node_is_null(args)) {
|
|
if (ts_node_child_count(node) > SECOND_IDX) {
|
|
args = ts_node_child(node, SECOND_IDX);
|
|
}
|
|
}
|
|
if (ts_node_is_null(args)) {
|
|
return NULL;
|
|
}
|
|
|
|
uint32_t ac = ts_node_child_count(args);
|
|
for (uint32_t j = 0; j < ac; j++) {
|
|
TSNode c = ts_node_child(args, j);
|
|
const char *ck = ts_node_type(c);
|
|
if (strcmp(ck, "string") == 0 || strcmp(ck, "string_literal") == 0) {
|
|
return strip_quotes(a, cbm_node_text(a, c, source));
|
|
}
|
|
}
|
|
return strip_quotes(a, cbm_node_text(a, args, source));
|
|
}
|
|
|
|
static void parse_ruby_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
const char *kind = ts_node_type(node);
|
|
if (strcmp(kind, "call") != 0 && strcmp(kind, "command_call") != 0) {
|
|
continue;
|
|
}
|
|
|
|
if (!ruby_require_method(a, node, ctx->source)) {
|
|
continue;
|
|
}
|
|
|
|
char *arg_text = extract_ruby_require_arg(a, node, ctx->source);
|
|
if (!arg_text || !arg_text[0]) {
|
|
continue;
|
|
}
|
|
|
|
CBMImport imp = {.local_name = path_last(a, arg_text), .module_path = arg_text};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Lua imports ---
|
|
// function_call: require("X")
|
|
|
|
static void parse_lua_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
// Lua: local X = require("Y") → assignment_statement or variable_declaration
|
|
// containing function_call(require, "Y")
|
|
char *text = cbm_node_text(a, node, ctx->source);
|
|
if (!text) {
|
|
continue;
|
|
}
|
|
if (strstr(text, "require") == NULL) {
|
|
continue;
|
|
}
|
|
|
|
// Simple extraction: find require("...") pattern in node text
|
|
const char *req = strstr(text, "require");
|
|
if (!req) {
|
|
continue;
|
|
}
|
|
|
|
// Find the string argument
|
|
const char *open = strchr(req, '(');
|
|
if (!open) {
|
|
open = strchr(req, '"');
|
|
}
|
|
if (!open) {
|
|
open = strchr(req, '\'');
|
|
}
|
|
if (!open) {
|
|
continue;
|
|
}
|
|
|
|
const char *q1 = strchr(open, '"');
|
|
const char *q2 = strchr(open, '\'');
|
|
if (!q1 && !q2) {
|
|
continue;
|
|
}
|
|
const char *start = q1 && (!q2 || q1 < q2) ? q1 : q2;
|
|
char delim = *start;
|
|
start++;
|
|
const char *end = strchr(start, delim);
|
|
if (!end) {
|
|
continue;
|
|
}
|
|
|
|
char *mod = cbm_arena_strndup(a, start, (size_t)(end - start));
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- R imports: library()/require()/source() + box::use() (#218) ---
|
|
|
|
// Emit an IMPORTS edge for a module path string (strips a trailing [symbols]
|
|
// list and surrounding quotes; uses the last path segment as the local name).
|
|
static void r_push_import(CBMExtractCtx *ctx, const char *raw) {
|
|
CBMArena *a = ctx->arena;
|
|
if (!raw || !raw[0]) {
|
|
return;
|
|
}
|
|
char *mod = strip_quotes(a, raw);
|
|
// box::use specs look like "shiny[moduleServer, NS]" or
|
|
// "app/logic/validation[validate_input]" — the module path is the part
|
|
// before the '[' symbol list.
|
|
char *bracket = strchr(mod, '[');
|
|
if (bracket) {
|
|
*bracket = '\0';
|
|
}
|
|
// Trim trailing whitespace left by truncation.
|
|
size_t len = strlen(mod);
|
|
while (len > 0 && (mod[len - SKIP_ONE] == ' ' || mod[len - SKIP_ONE] == '\t' ||
|
|
mod[len - SKIP_ONE] == '\n')) {
|
|
mod[--len] = '\0';
|
|
}
|
|
if (mod[0] == '\0') {
|
|
return;
|
|
}
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
|
|
// Recursively scan R for import-producing calls.
|
|
static void r_collect_imports(CBMExtractCtx *ctx, TSNode node) { // NOLINT(misc-no-recursion)
|
|
if (strcmp(ts_node_type(node), "call") == 0) {
|
|
TSNode fn = ts_node_child_by_field_name(node, TS_FIELD("function"));
|
|
TSNode args = ts_node_child_by_field_name(node, TS_FIELD("arguments"));
|
|
if (!ts_node_is_null(fn) && !ts_node_is_null(args)) {
|
|
const char *ft = ts_node_type(fn);
|
|
if (strcmp(ft, "namespace_operator") == 0) {
|
|
// box::use(mod[syms], pkg/path[syms], ...) — one IMPORTS per arg.
|
|
TSNode lhs = ts_node_child_by_field_name(fn, TS_FIELD("lhs"));
|
|
TSNode rhs = ts_node_child_by_field_name(fn, TS_FIELD("rhs"));
|
|
char *lt =
|
|
ts_node_is_null(lhs) ? NULL : cbm_node_text(ctx->arena, lhs, ctx->source);
|
|
char *rt =
|
|
ts_node_is_null(rhs) ? NULL : cbm_node_text(ctx->arena, rhs, ctx->source);
|
|
if (lt && rt && strcmp(lt, "box") == 0 && strcmp(rt, "use") == 0) {
|
|
uint32_t na = ts_node_named_child_count(args);
|
|
for (uint32_t i = 0; i < na; i++) {
|
|
TSNode arg = ts_node_named_child(args, i);
|
|
if (strcmp(ts_node_type(arg), "argument") != 0) {
|
|
continue;
|
|
}
|
|
TSNode val = ts_node_child_by_field_name(arg, TS_FIELD("value"));
|
|
if (!ts_node_is_null(val)) {
|
|
r_push_import(ctx, cbm_node_text(ctx->arena, val, ctx->source));
|
|
}
|
|
}
|
|
}
|
|
} else if (strcmp(ft, "identifier") == 0) {
|
|
// library(pkg) / require(pkg) / requireNamespace("pkg") /
|
|
// loadNamespace("pkg") / source("file.R") — first arg is the module.
|
|
char *fname = cbm_node_text(ctx->arena, fn, ctx->source);
|
|
if (fname &&
|
|
(strcmp(fname, "library") == 0 || strcmp(fname, "require") == 0 ||
|
|
strcmp(fname, "requireNamespace") == 0 ||
|
|
strcmp(fname, "loadNamespace") == 0 || strcmp(fname, "source") == 0)) {
|
|
uint32_t na = ts_node_named_child_count(args);
|
|
for (uint32_t i = 0; i < na; i++) {
|
|
TSNode arg = ts_node_named_child(args, i);
|
|
if (strcmp(ts_node_type(arg), "argument") != 0) {
|
|
continue;
|
|
}
|
|
TSNode val = ts_node_child_by_field_name(arg, TS_FIELD("value"));
|
|
if (!ts_node_is_null(val)) {
|
|
r_push_import(ctx, cbm_node_text(ctx->arena, val, ctx->source));
|
|
}
|
|
break; // first positional argument only
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
uint32_t n = ts_node_named_child_count(node);
|
|
for (uint32_t i = 0; i < n; i++) {
|
|
r_collect_imports(ctx, ts_node_named_child(node, i));
|
|
}
|
|
}
|
|
|
|
static void parse_r_imports(CBMExtractCtx *ctx) {
|
|
r_collect_imports(ctx, ctx->root);
|
|
}
|
|
|
|
// --- Generic import parsing for languages with simple import_declaration ---
|
|
|
|
// Try known field names (path/source/module/name) to extract import path.
|
|
static bool try_generic_path_fields(CBMExtractCtx *ctx, TSNode node) {
|
|
CBMArena *a = ctx->arena;
|
|
static const char *path_fields[] = {"path", "source", "module", "name", NULL};
|
|
for (const char **f = path_fields; *f; f++) {
|
|
TSNode path_node = ts_node_child_by_field_name(node, *f, (uint32_t)strlen(*f));
|
|
if (!ts_node_is_null(path_node)) {
|
|
char *path = strip_quotes(a, cbm_node_text(a, path_node, ctx->source));
|
|
if (path && path[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Fallback: extract import path from full node text, stripping keyword and semicolon.
|
|
static void generic_import_from_text(CBMExtractCtx *ctx, TSNode node) {
|
|
CBMArena *a = ctx->arena;
|
|
char *text = cbm_node_text(a, node, ctx->source);
|
|
if (!text || !text[0]) {
|
|
return;
|
|
}
|
|
char *space = strchr(text, ' ');
|
|
if (space) {
|
|
text = space + SKIP_ONE;
|
|
}
|
|
size_t len = strlen(text);
|
|
if (len > 0 && text[len - SKIP_ONE] == ';') {
|
|
text[len - SKIP_ONE] = '\0';
|
|
}
|
|
/* Strip surrounding quotes (Pony `use "util"`, func `#include "utils.fc"`)
|
|
* so the module path is a clean filename the resolver can match. */
|
|
text = strip_quotes(a, text);
|
|
if (text && text[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, text), .module_path = text};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
|
|
static void parse_generic_imports(CBMExtractCtx *ctx, const char *node_type) {
|
|
/* Use TSTreeCursor for O(1)-per-step sibling traversal. */
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
if (strcmp(ts_node_type(node), node_type) != 0) {
|
|
continue;
|
|
}
|
|
|
|
if (!try_generic_path_fields(ctx, node)) {
|
|
generic_import_from_text(ctx, node);
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Kotlin imports ---
|
|
// tree-sitter-kotlin nests imports: source_file -> import_list -> import_header*.
|
|
// parse_generic_imports only scans the DIRECT children of root, and "import" is
|
|
// the keyword token (anon_sym_import), not a statement node — so a generic
|
|
// match on "import" finds nothing. Descend into import_list (and accept a bare
|
|
// import_header for grammar variants) and reuse the generic path extractors.
|
|
static void extract_one_import_header(CBMExtractCtx *ctx, TSNode header) {
|
|
if (!try_generic_path_fields(ctx, header)) {
|
|
generic_import_from_text(ctx, header);
|
|
}
|
|
}
|
|
|
|
static void parse_kotlin_imports(CBMExtractCtx *ctx) {
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
const char *kind = ts_node_type(node);
|
|
if (strcmp(kind, "import_header") == 0) {
|
|
extract_one_import_header(ctx, node);
|
|
} else if (strcmp(kind, "import_list") == 0) {
|
|
uint32_t nc = ts_node_child_count(node);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode child = ts_node_child(node, j);
|
|
if (strcmp(ts_node_type(child), "import_header") == 0) {
|
|
extract_one_import_header(ctx, child);
|
|
}
|
|
}
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// Find the first descendant node of `type` (DFS, pre-order). Returns true and
|
|
// writes *out on the first match. Shared by the Dart/Zig import parsers, whose
|
|
// URI/string is nested several levels below the import node.
|
|
static bool find_first_descendant_of(TSNode node, const char *type, // NOLINT(misc-no-recursion)
|
|
TSNode *out) {
|
|
if (strcmp(ts_node_type(node), type) == 0) {
|
|
*out = node;
|
|
return true;
|
|
}
|
|
uint32_t n = ts_node_named_child_count(node);
|
|
for (uint32_t i = 0; i < n; i++) {
|
|
if (find_first_descendant_of(ts_node_named_child(node, i), type, out)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// --- Dart imports ---
|
|
// tree-sitter-dart wraps each top-level import as `import_or_export`; the URI is
|
|
// a `string_literal` nested under library_import -> import_specification ->
|
|
// configurable_uri -> uri. The old dispatch matched "import_declaration" (which
|
|
// tree-sitter-dart never emits) -> 0 imports. Find the first string_literal under
|
|
// each import_or_export and strip its quotes.
|
|
static void parse_dart_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
if (strcmp(ts_node_type(node), "import_or_export") != 0) {
|
|
continue;
|
|
}
|
|
TSNode uri = node;
|
|
if (find_first_descendant_of(node, "string_literal", &uri)) {
|
|
char *path = strip_quotes(a, cbm_node_text(a, uri, ctx->source));
|
|
if (path && path[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Haskell imports ---
|
|
// tree-sitter-haskell nests imports under an `imports` container (and/or lists
|
|
// `import` nodes); each `import` carries a `module` field. parse_generic_imports
|
|
// only scanned root children for "import", missing the container -> 0 imports.
|
|
// Descend into `imports` (and accept a root-level `import`) and reuse the generic
|
|
// path extractors, which pick up the "module" field.
|
|
static void parse_haskell_imports(CBMExtractCtx *ctx) {
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
const char *kind = ts_node_type(node);
|
|
if (strcmp(kind, "import") == 0) {
|
|
extract_one_import_header(ctx, node);
|
|
} else if (strcmp(kind, "imports") == 0) {
|
|
uint32_t nc = ts_node_child_count(node);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode child = ts_node_child(node, j);
|
|
if (strcmp(ts_node_type(child), "import") == 0) {
|
|
extract_one_import_header(ctx, child);
|
|
}
|
|
}
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Zig imports ---
|
|
// Zig imports are `const std = @import("std");` — a `builtin_function` (@import)
|
|
// nested inside a variable_declaration, NOT a root child. The old dispatch scanned
|
|
// root for "builtin_function" -> 0. DFS the whole tree for builtin_function nodes
|
|
// whose text starts with @import/@cImport and take their first string argument.
|
|
static void parse_zig_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "builtin_function") == 0) {
|
|
char *bf = cbm_node_text(a, node, ctx->source);
|
|
if (bf && (strncmp(bf, "@import", sizeof("@import") - 1) == 0 ||
|
|
strncmp(bf, "@cImport", sizeof("@cImport") - 1) == 0)) {
|
|
TSNode str = node;
|
|
if (find_first_descendant_of(node, "string", &str)) {
|
|
char *path = strip_quotes(a, cbm_node_text(a, str, ctx->source));
|
|
if (path && path[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Wolfram imports ---
|
|
// get_top: << "package" (Get["file"])
|
|
// apply where first child is builtin_symbol "Needs" with string arg
|
|
|
|
// Handle Wolfram get_top: << "path" → import.
|
|
static void process_wolfram_get_top(CBMExtractCtx *ctx, TSNode node) {
|
|
CBMArena *a = ctx->arena;
|
|
uint32_t nc = ts_node_named_child_count(node);
|
|
for (uint32_t i = 0; i < nc; i++) {
|
|
TSNode child = ts_node_named_child(node, i);
|
|
const char *ck = ts_node_type(child);
|
|
if (strcmp(ck, "string") == 0 || strcmp(ck, "user_symbol") == 0) {
|
|
char *text = cbm_node_text(a, child, ctx->source);
|
|
if (text && text[0]) {
|
|
char *path = strip_quotes(a, text);
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle Wolfram Needs["package`"] — apply where head is builtin_symbol "Needs".
|
|
static void process_wolfram_needs(CBMExtractCtx *ctx, TSNode node) {
|
|
CBMArena *a = ctx->arena;
|
|
if (ts_node_named_child_count(node) < MIN_WOLFRAM_CHILDREN) {
|
|
return;
|
|
}
|
|
TSNode head = ts_node_named_child(node, 0);
|
|
if (strcmp(ts_node_type(head), "builtin_symbol") != 0) {
|
|
return;
|
|
}
|
|
char *name = cbm_node_text(a, head, ctx->source);
|
|
if (!name || strcmp(name, "Needs") != 0) {
|
|
return;
|
|
}
|
|
TSNode arg = ts_node_named_child(node, SECOND_IDX);
|
|
char *text = cbm_node_text(a, arg, ctx->source);
|
|
if (text && text[0]) {
|
|
char *path = strip_quotes(a, text);
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
|
|
static void walk_wolfram_imports(CBMExtractCtx *ctx, TSNode root) {
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, ctx->arena, CBM_SZ_512);
|
|
ts_nstack_push(&stack, ctx->arena, root);
|
|
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *kind = ts_node_type(node);
|
|
|
|
if (strcmp(kind, "get_top") == 0) {
|
|
process_wolfram_get_top(ctx, node);
|
|
} else if (strcmp(kind, "apply") == 0) {
|
|
process_wolfram_needs(ctx, node);
|
|
}
|
|
|
|
ts_nstack_push_children(&stack, ctx->arena, node);
|
|
}
|
|
}
|
|
|
|
static void parse_wolfram_imports(CBMExtractCtx *ctx) {
|
|
walk_wolfram_imports(ctx, ctx->root);
|
|
}
|
|
|
|
// --- PHP imports ---
|
|
// tree-sitter-php models `use Foo\Bar;` as a `namespace_use_declaration`
|
|
// containing one or more `namespace_use_clause` nodes (each a qualified_name,
|
|
// optionally aliased via `as`). Grouped `use Foo\{A, B};` uses a
|
|
// `namespace_use_group` with `namespace_use_group_clause` children. The bare
|
|
// require/include forms remain `expression_statement`s and are still handled by
|
|
// the text fallback. Take the first qualified_name/name descendant of each
|
|
// clause as the module path.
|
|
static void emit_php_use_clause(CBMExtractCtx *ctx, TSNode clause, const char *group_prefix) {
|
|
CBMArena *a = ctx->arena;
|
|
// The path node is the qualified_name / namespace_name / name child.
|
|
TSNode path_node = clause;
|
|
bool found = false;
|
|
static const char *path_kinds[] = {"qualified_name", "namespace_name", "name", NULL};
|
|
for (const char **k = path_kinds; *k && !found; k++) {
|
|
if (find_first_descendant_of(clause, *k, &path_node)) {
|
|
found = true;
|
|
}
|
|
}
|
|
if (!found) {
|
|
return;
|
|
}
|
|
char *path = cbm_node_text(a, path_node, ctx->source);
|
|
if (!path || !path[0]) {
|
|
return;
|
|
}
|
|
if (group_prefix && group_prefix[0]) {
|
|
path = cbm_arena_sprintf(a, "%s\\%s", group_prefix, path);
|
|
}
|
|
// Alias: an `as` clause provides a trailing identifier (the second name).
|
|
TSNode alias = ts_node_child_by_field_name(clause, TS_FIELD("alias"));
|
|
const char *local =
|
|
!ts_node_is_null(alias) ? cbm_node_text(a, alias, ctx->source) : path_last(a, path);
|
|
CBMImport imp = {.local_name = local, .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
|
|
static void emit_php_use_decl(CBMExtractCtx *ctx, TSNode decl) {
|
|
CBMArena *a = ctx->arena;
|
|
// Grouped form: namespace_use_group with a leading prefix qualified_name.
|
|
TSNode group = decl;
|
|
if (find_first_descendant_of(decl, "namespace_use_group", &group)) {
|
|
// The prefix is the qualified_name sibling preceding the group within decl.
|
|
char *prefix = NULL;
|
|
uint32_t dc = ts_node_named_child_count(decl);
|
|
for (uint32_t i = 0; i < dc; i++) {
|
|
TSNode c = ts_node_named_child(decl, i);
|
|
const char *ck = ts_node_type(c);
|
|
if (strcmp(ck, "qualified_name") == 0 || strcmp(ck, "namespace_name") == 0 ||
|
|
strcmp(ck, "name") == 0) {
|
|
prefix = cbm_node_text(a, c, ctx->source);
|
|
break;
|
|
}
|
|
}
|
|
uint32_t gc = ts_node_named_child_count(group);
|
|
for (uint32_t i = 0; i < gc; i++) {
|
|
TSNode clause = ts_node_named_child(group, i);
|
|
const char *ck = ts_node_type(clause);
|
|
if (strcmp(ck, "namespace_use_group_clause") == 0 ||
|
|
strcmp(ck, "namespace_use_clause") == 0) {
|
|
emit_php_use_clause(ctx, clause, prefix);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
// Flat form: one or more namespace_use_clause children.
|
|
uint32_t dc = ts_node_named_child_count(decl);
|
|
bool any = false;
|
|
for (uint32_t i = 0; i < dc; i++) {
|
|
TSNode clause = ts_node_named_child(decl, i);
|
|
if (strcmp(ts_node_type(clause), "namespace_use_clause") == 0) {
|
|
emit_php_use_clause(ctx, clause, NULL);
|
|
any = true;
|
|
}
|
|
}
|
|
if (!any) {
|
|
// Some grammar versions inline the path directly under the declaration.
|
|
emit_php_use_clause(ctx, decl, NULL);
|
|
}
|
|
}
|
|
|
|
static void parse_php_imports(CBMExtractCtx *ctx) {
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
const char *kind = ts_node_type(node);
|
|
if (strcmp(kind, "namespace_use_declaration") == 0) {
|
|
emit_php_use_decl(ctx, node);
|
|
} else if (strcmp(kind, "expression_statement") == 0) {
|
|
// require / include / require_once / include_once
|
|
if (!try_generic_path_fields(ctx, node)) {
|
|
generic_import_from_text(ctx, node);
|
|
}
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- C# imports ---
|
|
// tree-sitter-c-sharp models `using System.Text;` as a `using_directive`.
|
|
// The namespace path is a `qualified_name`/`identifier` child. For an alias
|
|
// form `using F = System.IO.File;` the directive has a `name` field holding the
|
|
// alias identifier `F` and a separate qualified_name on the right of `=` — the
|
|
// generic path-field extractor wrongly returns the alias `F`, so we instead
|
|
// take the LAST qualified_name/identifier (the real namespace/type), and use
|
|
// the `name` field as local_name when present.
|
|
static void parse_csharp_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
if (strcmp(ts_node_type(node), "using_directive") != 0) {
|
|
continue;
|
|
}
|
|
// Find the right-most qualified_name / identifier (the namespace/type),
|
|
// which is the import target even in the alias form `using F = X;`.
|
|
TSNode path_node = node;
|
|
bool found = false;
|
|
uint32_t nc = ts_node_named_child_count(node);
|
|
for (int i = (int)nc - 1; i >= 0; i--) {
|
|
TSNode c = ts_node_named_child(node, (uint32_t)i);
|
|
const char *ck = ts_node_type(c);
|
|
if (strcmp(ck, "qualified_name") == 0 || strcmp(ck, "identifier") == 0 ||
|
|
strcmp(ck, "member_access_expression") == 0 || strcmp(ck, "name") == 0) {
|
|
path_node = c;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
char *path = found ? cbm_node_text(a, path_node, ctx->source) : NULL;
|
|
if (!path || !path[0]) {
|
|
// Fallback to text stripping (handles `using static X;`).
|
|
if (!try_generic_path_fields(ctx, node)) {
|
|
generic_import_from_text(ctx, node);
|
|
}
|
|
continue;
|
|
}
|
|
// Alias name, if any.
|
|
TSNode alias = ts_node_child_by_field_name(node, TS_FIELD("alias"));
|
|
const char *local =
|
|
!ts_node_is_null(alias) ? cbm_node_text(a, alias, ctx->source) : path_last(a, path);
|
|
CBMImport imp = {.local_name = local, .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Generic spec-driven imports ---
|
|
// For grammar-only languages that have no dedicated parser above, consume the
|
|
// `import_node_types` declared in the language's CBMLangSpec. Each root-level
|
|
// child whose type matches one of those node types is treated as an import:
|
|
// first try the known path fields (path/source/module/name), then fall back to
|
|
// stripping the leading keyword + trailing ';' from the node text. This is the
|
|
// same extraction strategy the dedicated `parse_generic_imports` used, but the
|
|
// node-type set comes from the spec instead of a hardcoded string, so every
|
|
// language with `import_node_types` configured gets imports extracted.
|
|
static bool spec_type_matches(const char **types, const char *kind) {
|
|
if (!types) {
|
|
return false;
|
|
}
|
|
for (const char **t = types; *t; t++) {
|
|
if (strcmp(*t, kind) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void parse_spec_imports(CBMExtractCtx *ctx) {
|
|
const CBMLangSpec *spec = cbm_lang_spec(ctx->language);
|
|
if (!spec || !spec->import_node_types) {
|
|
return;
|
|
}
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
const char *kind = ts_node_type(node);
|
|
if (!spec_type_matches(spec->import_node_types, kind)) {
|
|
continue;
|
|
}
|
|
if (!try_generic_path_fields(ctx, node)) {
|
|
generic_import_from_text(ctx, node);
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Embedded-language imports ---
|
|
// Generic walker for host grammars (Svelte, Vue, HTML, Astro, ...) whose AST
|
|
// keeps embedded sub-language source as raw_text (or similar) without parsing
|
|
// it. The host's CBMLangSpec.embedded_imports declares which content nodes
|
|
// hold which sub-language; we re-parse each match with the embedded grammar
|
|
// and run the standard ES import walker over the inner AST.
|
|
//
|
|
// No grammar symbols are referenced here — the embedded TSLanguage is
|
|
// resolved through cbm_ts_language(spec->embedded_language), the same hook
|
|
// that the main parser uses. Adding another host language is a one-line
|
|
// declaration in lang_specs.c.
|
|
|
|
static void embedded_collect_content_nodes(TSNode root, const CBMEmbeddedLangSpec *spec,
|
|
TSNode *out, int *out_count, int max_out) {
|
|
/* Iterative DFS so deeply-nested script blocks are still found. Cap the
|
|
* stack to a sane bound (host grammars do not have million-deep markup
|
|
* trees) — no need to introduce TSNodeStack here. */
|
|
enum { EMBED_STACK_CAP = 1024 };
|
|
TSNode stack[EMBED_STACK_CAP];
|
|
int top = 0;
|
|
stack[top++] = root;
|
|
while (top > 0 && *out_count < max_out) {
|
|
TSNode node = stack[--top];
|
|
const char *kind = ts_node_type(node);
|
|
if (strcmp(kind, spec->script_node_type) == 0) {
|
|
uint32_t cc = ts_node_child_count(node);
|
|
for (uint32_t k = 0; k < cc; k++) {
|
|
TSNode c = ts_node_child(node, k);
|
|
if (strcmp(ts_node_type(c), spec->content_node_type) == 0) {
|
|
out[(*out_count)++] = c;
|
|
if (*out_count >= max_out) {
|
|
return;
|
|
}
|
|
break; /* one content node per script element */
|
|
}
|
|
}
|
|
/* Do not descend into <script>'s children — content already taken. */
|
|
continue;
|
|
}
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (int i = (int)count - 1; i >= 0 && top < EMBED_STACK_CAP; i--) {
|
|
stack[top++] = ts_node_child(node, (uint32_t)i);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void parse_embedded_imports(CBMExtractCtx *ctx) {
|
|
const CBMLangSpec *spec = cbm_lang_spec(ctx->language);
|
|
if (!spec || !spec->embedded_imports) {
|
|
return;
|
|
}
|
|
for (const CBMEmbeddedLangSpec *e = spec->embedded_imports; e->script_node_type != NULL; e++) {
|
|
const TSLanguage *embedded_lang = cbm_ts_language(e->embedded_language);
|
|
if (!embedded_lang) {
|
|
continue; /* embedded grammar not linked in — silently skip */
|
|
}
|
|
enum { MAX_EMBEDDED_BLOCKS = 16 };
|
|
TSNode hits[MAX_EMBEDDED_BLOCKS];
|
|
int hit_count = 0;
|
|
embedded_collect_content_nodes(ctx->root, e, hits, &hit_count, MAX_EMBEDDED_BLOCKS);
|
|
if (hit_count == 0) {
|
|
continue;
|
|
}
|
|
TSParser *parser = ts_parser_new();
|
|
if (!parser) {
|
|
continue;
|
|
}
|
|
if (!ts_parser_set_language(parser, embedded_lang)) {
|
|
ts_parser_delete(parser);
|
|
continue;
|
|
}
|
|
for (int i = 0; i < hit_count; i++) {
|
|
uint32_t s = ts_node_start_byte(hits[i]);
|
|
uint32_t end = ts_node_end_byte(hits[i]);
|
|
if (end <= s) {
|
|
continue;
|
|
}
|
|
const char *sub_src = ctx->source + s;
|
|
uint32_t sub_len = end - s;
|
|
TSTree *sub_tree = ts_parser_parse_string(parser, NULL, sub_src, sub_len);
|
|
if (!sub_tree) {
|
|
continue;
|
|
}
|
|
CBMExtractCtx sub_ctx = *ctx;
|
|
sub_ctx.source = sub_src;
|
|
sub_ctx.root = ts_tree_root_node(sub_tree);
|
|
walk_es_imports(&sub_ctx, sub_ctx.root);
|
|
ts_tree_delete(sub_tree);
|
|
}
|
|
ts_parser_delete(parser);
|
|
}
|
|
}
|
|
|
|
// --- Namespace / package declaration capture ---
|
|
// Java/Kotlin/C#/PHP put the file's symbols inside a namespace/package whose
|
|
// name is NOT reflected in the path-based QN scheme. Capturing it lets the
|
|
// pipeline resolve `using App.Utils` / `import com.example.Foo` to the File
|
|
// node(s) that declare that namespace, which the path-derived QN alone cannot.
|
|
static void capture_namespace_decl(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
static const char *ns_kinds[] = {"namespace_declaration", // C#
|
|
"file_scoped_namespace_declaration", // C# 10
|
|
"package_declaration", // Java / Kotlin
|
|
"package_header", // Kotlin
|
|
"namespace_definition", // PHP
|
|
NULL};
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
const char *kind = ts_node_type(node);
|
|
if (!spec_type_matches(ns_kinds, kind)) {
|
|
continue;
|
|
}
|
|
// The namespace name is the first qualified_name / scoped_identifier /
|
|
// namespace_name / identifier descendant.
|
|
static const char *name_kinds[] = {"qualified_name",
|
|
"scoped_identifier",
|
|
"namespace_name",
|
|
"identifier",
|
|
"dotted_name",
|
|
"name",
|
|
NULL};
|
|
for (const char **nk = name_kinds; *nk; nk++) {
|
|
TSNode nn = node;
|
|
if (find_first_descendant_of(node, *nk, &nn)) {
|
|
char *ns = cbm_node_text(a, nn, ctx->source);
|
|
if (ns && ns[0]) {
|
|
ctx->result->namespace_name = ns;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (ctx->result->namespace_name) {
|
|
break;
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Hare imports ---
|
|
// tree-sitter-hare nests imports: module -> imports -> use_statement* ->
|
|
// identifier. The use_statement is not a root child, so a generic scan misses
|
|
// it. Descend into the `imports` container and take each use_statement's
|
|
// identifier text (a `::`-separated module path).
|
|
static void parse_hare_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "use_statement") == 0) {
|
|
uint32_t nc = ts_node_named_child_count(node);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode c = ts_node_named_child(node, j);
|
|
const char *ck = ts_node_type(c);
|
|
if (strcmp(ck, "identifier") == 0 || strcmp(ck, "scoped_identifier") == 0) {
|
|
char *mod = cbm_node_text(a, c, ctx->source);
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Pascal imports ---
|
|
// tree-sitter-pascal: declUses (uses Foo, Bar, Baz;) is nested under
|
|
// unit -> interface (or implementation), NOT a root child, and carries one
|
|
// `moduleName` child per imported unit. DFS for declUses nodes and emit one
|
|
// import per moduleName.
|
|
static void parse_pascal_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "declUses") == 0) {
|
|
uint32_t nc = ts_node_named_child_count(node);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode c = ts_node_named_child(node, j);
|
|
if (strcmp(ts_node_type(c), "moduleName") != 0) {
|
|
continue;
|
|
}
|
|
char *mod = cbm_node_text(a, c, ctx->source);
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- PowerShell imports ---
|
|
// tree-sitter-powershell models `using module ./M` / `using namespace System.IO`
|
|
// as a plain `command` whose command_name is "using" — deeply nested under
|
|
// statement_list -> pipeline -> pipeline_chain. The module path is the LAST
|
|
// generic_token child of command_elements (after the "module"/"namespace"/
|
|
// "assembly" qualifier). DFS for such commands.
|
|
static void parse_powershell_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "command") == 0) {
|
|
TSNode name = ts_node_child_by_field_name(node, TS_FIELD("command_name"));
|
|
char *nm = ts_node_is_null(name) ? NULL : cbm_node_text(a, name, ctx->source);
|
|
if (nm && strcmp(nm, "using") == 0) {
|
|
/* Find the last generic_token anywhere under the command — that
|
|
* is the module path / namespace / assembly being imported. */
|
|
TSNodeStack inner;
|
|
ts_nstack_init(&inner, a, CBM_SZ_512);
|
|
ts_nstack_push(&inner, a, node);
|
|
const char *last_tok = NULL;
|
|
uint32_t last_start = 0;
|
|
while (inner.count > 0) {
|
|
TSNode c = ts_nstack_pop(&inner);
|
|
if (strcmp(ts_node_type(c), "generic_token") == 0) {
|
|
char *t = cbm_node_text(a, c, ctx->source);
|
|
uint32_t sb = ts_node_start_byte(c);
|
|
if (t && t[0] && strcmp(t, "module") != 0 && strcmp(t, "namespace") != 0 &&
|
|
strcmp(t, "assembly") != 0 && (last_tok == NULL || sb > last_start)) {
|
|
last_tok = t;
|
|
last_start = sb;
|
|
}
|
|
}
|
|
ts_nstack_push_children(&inner, a, c);
|
|
}
|
|
if (last_tok && last_tok[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, last_tok),
|
|
.module_path = (char *)last_tok};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
continue; /* commands don't nest imports further */
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Lisp-family imports (Scheme, Racket) ---
|
|
// S-expression grammars model (import (lib ...)) / (require mod) / (load "f")
|
|
// as a `list` whose first named child is a `symbol` naming the form. Walk
|
|
// top-level lists; for import/require/load/use, take the remaining children as
|
|
// module references (a symbol, a string, or a nested list whose meaningful
|
|
// module symbol we take as-is).
|
|
static void lisp_push_module(CBMExtractCtx *ctx, TSNode mod_node) {
|
|
CBMArena *a = ctx->arena;
|
|
const char *mk = ts_node_type(mod_node);
|
|
char *mod = NULL;
|
|
if (strcmp(mk, "symbol") == 0 || strcmp(mk, "string") == 0 || strcmp(mk, "sym_lit") == 0 ||
|
|
strcmp(mk, "str_lit") == 0 || strcmp(mk, "kwd_lit") == 0) {
|
|
mod = strip_quotes(a, cbm_node_text(a, mod_node, ctx->source));
|
|
/* Clojure/Fennel keyword module refs carry a leading ':' (e.g. `:util`,
|
|
* `(require :util)`); strip it so the name matches the sibling file. */
|
|
if (mod && mod[0] == ':') {
|
|
mod = cbm_arena_strdup(a, mod + 1);
|
|
}
|
|
} else if (strcmp(mk, "list") == 0 || strcmp(mk, "list_lit") == 0 ||
|
|
strcmp(mk, "vec_lit") == 0) {
|
|
/* (only-in racket/math pi) → take first symbol after a leading keyword,
|
|
* else join inner symbols with '/'. Simplest robust choice: the whole
|
|
* list text minus the parens. */
|
|
mod = cbm_node_text(a, mod_node, ctx->source);
|
|
if (mod) {
|
|
size_t len = strlen(mod);
|
|
if (len >= 2 && mod[0] == '(' && mod[len - 1] == ')') {
|
|
mod = cbm_arena_strndup(a, mod + 1, len - 2);
|
|
}
|
|
}
|
|
}
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
|
|
/* Strip a leading ':' from a lisp keyword/symbol token (Clojure/Fennel/CL
|
|
* package keywords carry it: `:util` → `util`). Returns an arena copy. */
|
|
static char *lisp_strip_kw(CBMArena *a, const char *s) {
|
|
if (!s) {
|
|
return NULL;
|
|
}
|
|
if (s[0] == ':') {
|
|
s++;
|
|
}
|
|
return cbm_arena_strdup(a, s);
|
|
}
|
|
|
|
/* Record the file's declared namespace/package so the pipeline namespace map
|
|
* can resolve `(:require ns)` / `(:use :pkg)` to the declaring file. First
|
|
* declaration wins (mirrors capture_namespace_decl). */
|
|
static void lisp_set_namespace(CBMExtractCtx *ctx, TSNode name_node) {
|
|
CBMArena *a = ctx->arena;
|
|
char *ns = lisp_strip_kw(a, cbm_node_text(a, name_node, ctx->source));
|
|
if (ns && ns[0] && !ctx->result->namespace_name) {
|
|
ctx->result->namespace_name = ns;
|
|
}
|
|
}
|
|
|
|
/* Clojure `(ns app.core (:require [app.util :as u]) (:use app.io))` and Common
|
|
* Lisp `(defpackage :main (:use :cl :util))` carry their dependency list inside
|
|
* nested keyword clauses (`:require`/`:use`/`:import`). Walk such a clause and
|
|
* push each referenced module/package as an import. `clause` is the
|
|
* `(:require ...)` / `(:use ...)` list. */
|
|
static void lisp_push_clause_modules(CBMExtractCtx *ctx, TSNode clause) {
|
|
uint32_t cc = ts_node_named_child_count(clause);
|
|
for (uint32_t j = 1; j < cc; j++) { /* skip the leading keyword head */
|
|
TSNode item = ts_node_named_child(clause, j);
|
|
const char *ik = ts_node_type(item);
|
|
/* `[app.util :as u]` — the module is the vector's first symbol. */
|
|
if (strcmp(ik, "vec_lit") == 0 || strcmp(ik, "list_lit") == 0 || strcmp(ik, "list") == 0) {
|
|
uint32_t vc = ts_node_named_child_count(item);
|
|
if (vc > 0) {
|
|
lisp_push_module(ctx, ts_node_named_child(item, 0));
|
|
}
|
|
} else {
|
|
/* bare symbol/keyword: `:util`, `app.io`. */
|
|
lisp_push_module(ctx, item);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* The s-expression head symbol text, or NULL if the list has no symbol head. */
|
|
static char *lisp_head_text(CBMExtractCtx *ctx, TSNode list, TSNode *out_head) {
|
|
if (ts_node_named_child_count(list) < 1) {
|
|
return NULL;
|
|
}
|
|
TSNode head = ts_node_named_child(list, 0);
|
|
const char *ht = ts_node_type(head);
|
|
if (strcmp(ht, "symbol") != 0 && strcmp(ht, "sym_lit") != 0) {
|
|
return NULL;
|
|
}
|
|
if (out_head) {
|
|
*out_head = head;
|
|
}
|
|
return cbm_node_text(ctx->arena, head, ctx->source);
|
|
}
|
|
|
|
/* Process one s-expression list as a potential import/namespace form. */
|
|
static void lisp_process_list(CBMExtractCtx *ctx, TSNode node) {
|
|
CBMArena *a = ctx->arena;
|
|
(void)a;
|
|
TSNode head = node;
|
|
char *hn = lisp_head_text(ctx, node, &head);
|
|
if (!hn) {
|
|
return;
|
|
}
|
|
uint32_t nc = ts_node_named_child_count(node);
|
|
|
|
/* Clojure namespace form: `(ns app.core (:require ...) (:use ...))`.
|
|
* 2nd child is the namespace symbol; later keyword-headed lists are
|
|
* dependency clauses. */
|
|
if (strcmp(hn, "ns") == 0 && nc >= 2) {
|
|
lisp_set_namespace(ctx, ts_node_named_child(node, 1));
|
|
for (uint32_t j = 2; j < nc; j++) {
|
|
TSNode clause = ts_node_named_child(node, j);
|
|
const char *ck = ts_node_type(clause);
|
|
if (strcmp(ck, "list_lit") == 0 || strcmp(ck, "list") == 0) {
|
|
lisp_push_clause_modules(ctx, clause);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* Common Lisp package form: `(defpackage :main (:use :cl :util) ...)`.
|
|
* 2nd child is the package name keyword; nested `(:use ...)` lists name the
|
|
* imported packages. */
|
|
if (strcmp(hn, "defpackage") == 0 && nc >= 2) {
|
|
lisp_set_namespace(ctx, ts_node_named_child(node, 1));
|
|
for (uint32_t j = 2; j < nc; j++) {
|
|
TSNode clause = ts_node_named_child(node, j);
|
|
const char *ck = ts_node_type(clause);
|
|
if (strcmp(ck, "list_lit") != 0 && strcmp(ck, "list") != 0) {
|
|
continue;
|
|
}
|
|
/* Only `:use` / `:import-from` clauses denote dependencies. */
|
|
char *chn = lisp_head_text(ctx, clause, NULL);
|
|
if (chn && (strcmp(chn, ":use") == 0 || strstr(chn, "import-from"))) {
|
|
lisp_push_clause_modules(ctx, clause);
|
|
} else if (ts_node_named_child_count(clause) > 0) {
|
|
TSNode ch0 = ts_node_named_child(clause, 0);
|
|
const char *c0k = ts_node_type(ch0);
|
|
/* CL `(:use ...)` head is a `kwd_lit`, not a symbol. */
|
|
if (strcmp(c0k, "kwd_lit") == 0) {
|
|
char *kw = cbm_node_text(ctx->arena, ch0, ctx->source);
|
|
if (kw && (strstr(kw, "use") || strstr(kw, "import-from"))) {
|
|
lisp_push_clause_modules(ctx, clause);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* Common Lisp `(in-package :util)` also declares the file's package. */
|
|
if (strcmp(hn, "in-package") == 0 && nc >= 2) {
|
|
lisp_set_namespace(ctx, ts_node_named_child(node, 1));
|
|
return;
|
|
}
|
|
|
|
/* Plain import head: `(require :util)`, `(import ...)`, `(use ...)`. */
|
|
if (strcmp(hn, "import") == 0 || strcmp(hn, "require") == 0 || strcmp(hn, "load") == 0 ||
|
|
strcmp(hn, "use") == 0 || strcmp(hn, "include") == 0) {
|
|
for (uint32_t j = 1; j < nc; j++) {
|
|
TSNode mod_node = ts_node_named_child(node, j);
|
|
const char *mk = ts_node_type(mod_node);
|
|
/* (require 'json) — the quoted datum is a `quote` wrapping a symbol. */
|
|
if ((strcmp(mk, "quote") == 0 || strcmp(mk, "quoting_lit") == 0) &&
|
|
ts_node_named_child_count(mod_node) > 0) {
|
|
lisp_push_module(ctx, ts_node_named_child(mod_node, 0));
|
|
} else {
|
|
lisp_push_module(ctx, mod_node);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Iteratively walk lisp lists. Fennel binds requires inside other forms
|
|
* (`(local util (require :util))`), so we must descend into every list, not
|
|
* just root children. Stack-based (not recursive) to avoid deep-nesting stack
|
|
* overflow, matching the other walkers in this file. */
|
|
static void parse_lisp_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *nt = ts_node_type(node);
|
|
if (strcmp(nt, "list") == 0 || strcmp(nt, "list_lit") == 0) {
|
|
lisp_process_list(ctx, node);
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Starlark imports ---
|
|
// load("//pkg:file.bzl", "sym", ...) — an expression_statement -> call whose
|
|
// function identifier is "load"; the first string argument is the module path.
|
|
static void parse_starlark_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "call") == 0) {
|
|
TSNode fn = ts_node_child_by_field_name(node, TS_FIELD("function"));
|
|
char *fname = ts_node_is_null(fn) ? NULL : cbm_node_text(a, fn, ctx->source);
|
|
if (fname && strcmp(fname, "load") == 0) {
|
|
TSNode args = ts_node_child_by_field_name(node, TS_FIELD("arguments"));
|
|
if (!ts_node_is_null(args)) {
|
|
TSNode str = args;
|
|
if (find_first_descendant_of(args, "string", &str)) {
|
|
char *path = strip_quotes(a, cbm_node_text(a, str, ctx->source));
|
|
/* string node may carry string_start/_content/_end; if the
|
|
* stripped text still has quotes, fall back to content. */
|
|
if (path && path[0] && (path[0] == '"' || path[0] == '\'')) {
|
|
TSNode content = str;
|
|
if (find_first_descendant_of(str, "string_content", &content)) {
|
|
path = cbm_node_text(a, content, ctx->source);
|
|
}
|
|
}
|
|
if (path && path[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Tcl imports ---
|
|
// source path / package require name — `command` nodes whose `name` field is
|
|
// "source" (file include) or "package" (package require). Take the first
|
|
// simple_word argument as the module.
|
|
static void parse_tcl_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "command") == 0) {
|
|
TSNode name = ts_node_child_by_field_name(node, TS_FIELD("name"));
|
|
char *nm = ts_node_is_null(name) ? NULL : cbm_node_text(a, name, ctx->source);
|
|
if (nm && strcmp(nm, "source") == 0) {
|
|
TSNode args = ts_node_child_by_field_name(node, TS_FIELD("arguments"));
|
|
if (!ts_node_is_null(args)) {
|
|
uint32_t nc = ts_node_named_child_count(args);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode c = ts_node_named_child(args, j);
|
|
char *mod = strip_quotes(a, cbm_node_text(a, c, ctx->source));
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Teal imports ---
|
|
// Teal is a typed Lua dialect: `local m = require("mod")` — a function_call
|
|
// whose called_object identifier is "require"; the first string argument is the
|
|
// module. DFS for such calls (mirrors the Lua require pattern at AST level).
|
|
static void parse_teal_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "function_call") == 0) {
|
|
TSNode callee = ts_node_child_by_field_name(node, "called_object", 13);
|
|
char *cn = ts_node_is_null(callee) ? NULL : cbm_node_text(a, callee, ctx->source);
|
|
if (cn && strcmp(cn, "require") == 0) {
|
|
TSNode args = ts_node_child_by_field_name(node, TS_FIELD("arguments"));
|
|
TSNode str = ts_node_is_null(args) ? node : args;
|
|
if (!ts_node_is_null(args) && find_first_descendant_of(args, "string", &str)) {
|
|
char *mod = strip_quotes(a, cbm_node_text(a, str, ctx->source));
|
|
if (mod && mod[0] && (mod[0] == '"' || mod[0] == '\'')) {
|
|
TSNode content = str;
|
|
if (find_first_descendant_of(str, "string_content", &content)) {
|
|
mod = cbm_node_text(a, content, ctx->source);
|
|
}
|
|
}
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Zsh imports ---
|
|
// source file / . file — `command` nodes whose command_name is "source" or ".".
|
|
// The argument field carries the sourced path.
|
|
static void parse_zsh_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "command") == 0) {
|
|
TSNode name = ts_node_child_by_field_name(node, TS_FIELD("name"));
|
|
char *nm = ts_node_is_null(name) ? NULL : cbm_node_text(a, name, ctx->source);
|
|
if (nm && (strcmp(nm, "source") == 0 || strcmp(nm, ".") == 0)) {
|
|
TSNode arg = ts_node_child_by_field_name(node, TS_FIELD("argument"));
|
|
if (ts_node_is_null(arg)) {
|
|
arg = ts_node_child_by_field_name(node, TS_FIELD("arguments"));
|
|
}
|
|
if (!ts_node_is_null(arg)) {
|
|
char *mod = strip_quotes(a, cbm_node_text(a, arg, ctx->source));
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- CSS / SCSS imports ---
|
|
// CSS @import "x.css" and SCSS @use/@forward 'x' are top-level statements that
|
|
// carry a `string_value` (whose `string_content` is the unquoted path). The
|
|
// generic text fallback mangled these (kept the surrounding quotes), so the
|
|
// resolver couldn't match the target file. Extract the clean string content.
|
|
static void css_push_import_from_stmt(CBMExtractCtx *ctx, TSNode stmt) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNode sv = stmt;
|
|
if (!find_first_descendant_of(stmt, "string_value", &sv)) {
|
|
/* CSS @import url("x") uses a `call_expression`/`plain_value`; fall back
|
|
* to the first string node. */
|
|
if (!find_first_descendant_of(stmt, "string_content", &sv)) {
|
|
return;
|
|
}
|
|
}
|
|
/* Prefer the inner string_content (already unquoted) when present. */
|
|
TSNode content = sv;
|
|
char *path = NULL;
|
|
if (find_first_descendant_of(sv, "string_content", &content)) {
|
|
path = cbm_node_text(a, content, ctx->source);
|
|
} else {
|
|
path = strip_quotes(a, cbm_node_text(a, sv, ctx->source));
|
|
}
|
|
if (!path || !path[0]) {
|
|
return;
|
|
}
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
|
|
static void parse_css_imports(CBMExtractCtx *ctx) {
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
const char *k = ts_node_type(node);
|
|
if (strcmp(k, "import_statement") == 0 || strcmp(k, "use_statement") == 0 ||
|
|
strcmp(k, "forward_statement") == 0 || strcmp(k, "include_statement") == 0) {
|
|
css_push_import_from_stmt(ctx, node);
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- HTML imports ---
|
|
// `<script src="app.js">` and `<link href="style.css">` reference sibling
|
|
// files. tree-sitter-html exposes these as `start_tag` -> `attribute`
|
|
// (attribute_name src/href) -> quoted_attribute_value -> attribute_value. DFS
|
|
// for start_tags and emit one import per src/href value. (Embedded <script>
|
|
// bodies are still handled separately by parse_embedded_imports.)
|
|
static void html_extract_tag_src(CBMExtractCtx *ctx, TSNode tag) {
|
|
CBMArena *a = ctx->arena;
|
|
uint32_t nc = ts_node_named_child_count(tag);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode attr = ts_node_named_child(tag, j);
|
|
if (strcmp(ts_node_type(attr), "attribute") != 0) {
|
|
continue;
|
|
}
|
|
TSNode name = ts_node_named_child_count(attr) > 0 ? ts_node_named_child(attr, 0) : attr;
|
|
char *an = cbm_node_text(a, name, ctx->source);
|
|
if (!an || (strcmp(an, "src") != 0 && strcmp(an, "href") != 0)) {
|
|
continue;
|
|
}
|
|
TSNode val = attr;
|
|
char *path = NULL;
|
|
if (find_first_descendant_of(attr, "attribute_value", &val)) {
|
|
path = cbm_node_text(a, val, ctx->source);
|
|
}
|
|
if (path && path[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void parse_html_imports(CBMExtractCtx *ctx) {
|
|
/* First run the embedded-language walker (inline <script> JS imports). */
|
|
parse_embedded_imports(ctx);
|
|
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, ctx->arena, CBM_SZ_512);
|
|
ts_nstack_push(&stack, ctx->arena, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "start_tag") == 0 ||
|
|
strcmp(ts_node_type(node), "self_closing_tag") == 0) {
|
|
html_extract_tag_src(ctx, node);
|
|
}
|
|
ts_nstack_push_children(&stack, ctx->arena, node);
|
|
}
|
|
}
|
|
|
|
// Shared: push an import whose path is the (quote-stripped) text of `node`.
|
|
// Strips a leading "./" so relative-import resolution matches the sibling file.
|
|
static void push_path_import(CBMExtractCtx *ctx, TSNode node) {
|
|
CBMArena *a = ctx->arena;
|
|
char *path = strip_quotes(a, cbm_node_text(a, node, ctx->source));
|
|
if (!path || !path[0]) {
|
|
return;
|
|
}
|
|
/* Trim surrounding whitespace (some grammars include a leading space). */
|
|
while (*path == ' ' || *path == '\t') {
|
|
path++;
|
|
}
|
|
size_t len = strlen(path);
|
|
while (len > 0 && (path[len - 1] == ' ' || path[len - 1] == '\t' || path[len - 1] == '\n')) {
|
|
path[--len] = '\0';
|
|
}
|
|
if (!path[0]) {
|
|
return;
|
|
}
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
|
|
// Shared: find a node's clean string path — prefers an inner unquoted content
|
|
// child (string_content / str_literal / …); else an inner quoted `string`
|
|
// (whose quotes push_path_import strips); else the node's own text. Never falls
|
|
// back to text that still contains a directive keyword.
|
|
static void push_string_descendant_import(CBMExtractCtx *ctx, TSNode node) {
|
|
TSNode hit = node;
|
|
static const char *content_kinds[] = {
|
|
"string_content", "str_literal", "slStringLiteralPart",
|
|
"include_path", "attribute_value", "path_fragment",
|
|
"string_fragment", "literal_content", NULL};
|
|
for (const char **k = content_kinds; *k; k++) {
|
|
if (find_first_descendant_of(node, *k, &hit)) {
|
|
push_path_import(ctx, hit);
|
|
return;
|
|
}
|
|
}
|
|
/* Quoted string nodes (Just/Pkl/Jsonnet variants): strip the quotes. */
|
|
static const char *string_kinds[] = {"string", "string_value", "string_literal",
|
|
"static_string", "stringConstant", NULL};
|
|
for (const char **k = string_kinds; *k; k++) {
|
|
if (find_first_descendant_of(node, *k, &hit)) {
|
|
push_path_import(ctx, hit);
|
|
return;
|
|
}
|
|
}
|
|
push_path_import(ctx, node);
|
|
}
|
|
|
|
// --- CMake imports: include(path) / add_subdirectory(dir) ---
|
|
static void parse_cmake_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "normal_command") == 0) {
|
|
TSNode id = ts_node_named_child_count(node) > 0 ? ts_node_named_child(node, 0) : node;
|
|
char *cmd = cbm_node_text(a, id, ctx->source);
|
|
if (cmd && (strcmp(cmd, "include") == 0 || strcmp(cmd, "add_subdirectory") == 0)) {
|
|
TSNode args = cbm_find_child_by_kind(node, "argument_list");
|
|
if (!ts_node_is_null(args)) {
|
|
uint32_t nc = ts_node_named_child_count(args);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode arg = ts_node_named_child(args, j);
|
|
push_string_descendant_import(ctx, arg);
|
|
break; /* first argument is the module/dir */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- BitBake imports: require/include path ---
|
|
static void parse_bitbake_imports(CBMExtractCtx *ctx) {
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, ctx->arena, CBM_SZ_512);
|
|
ts_nstack_push(&stack, ctx->arena, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *k = ts_node_type(node);
|
|
if (strcmp(k, "require_directive") == 0 || strcmp(k, "include_directive") == 0 ||
|
|
strcmp(k, "inherit_directive") == 0) {
|
|
push_string_descendant_import(ctx, node);
|
|
}
|
|
ts_nstack_push_children(&stack, ctx->arena, node);
|
|
}
|
|
}
|
|
|
|
// --- Meson imports: subdir('name') → descend into name/meson.build ---
|
|
// Meson's subdir() includes a child directory's meson.build into the build.
|
|
// The grammar models a call as `function_expression` (id + argument_list).
|
|
// Find subdir() calls and push the directory name as the module path; the
|
|
// pipeline resolver maps "name" → "name/meson.build".
|
|
static void parse_meson_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *k = ts_node_type(node);
|
|
/* tree-sitter-meson models a call as `normal_command` (identifier +
|
|
* arguments) and string arguments as `string`. */
|
|
if (strcmp(k, "normal_command") == 0) {
|
|
uint32_t nc = ts_node_named_child_count(node);
|
|
if (nc >= 1) {
|
|
TSNode fn = ts_node_named_child(node, 0);
|
|
char *fname = cbm_node_text(a, fn, ctx->source);
|
|
if (fname && strcmp(fname, "subdir") == 0) {
|
|
TSNode str = node;
|
|
if (find_first_descendant_of(node, "string", &str)) {
|
|
char *path = strip_quotes(a, cbm_node_text(a, str, ctx->source));
|
|
if (path && path[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Kconfig imports: source "path" ---
|
|
static void parse_kconfig_imports(CBMExtractCtx *ctx) {
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, ctx->arena, CBM_SZ_512);
|
|
ts_nstack_push(&stack, ctx->arena, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (ts_node_is_named(node) && strcmp(ts_node_type(node), "source") == 0) {
|
|
push_string_descendant_import(ctx, node);
|
|
}
|
|
ts_nstack_push_children(&stack, ctx->arena, node);
|
|
}
|
|
}
|
|
|
|
// --- GN imports: import("//path") ---
|
|
static void parse_gn_imports(CBMExtractCtx *ctx) {
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, ctx->arena, CBM_SZ_512);
|
|
ts_nstack_push(&stack, ctx->arena, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "import_statement") == 0) {
|
|
push_string_descendant_import(ctx, node);
|
|
}
|
|
ts_nstack_push_children(&stack, ctx->arena, node);
|
|
}
|
|
}
|
|
|
|
// --- Just imports: import 'path' ---
|
|
static void parse_just_imports(CBMExtractCtx *ctx) {
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
if (strcmp(ts_node_type(node), "import") == 0) {
|
|
push_string_descendant_import(ctx, node);
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Nix imports: import ./path ---
|
|
static void parse_nix_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "apply_expression") == 0) {
|
|
/* import <path> — the function position is the identifier "import",
|
|
* the argument a path_expression / path_fragment / string. */
|
|
TSNode fn = ts_node_named_child_count(node) > 0 ? ts_node_named_child(node, 0) : node;
|
|
char *fname = cbm_node_text(a, fn, ctx->source);
|
|
if (fname && strcmp(fname, "import") == 0 && ts_node_named_child_count(node) > 1) {
|
|
TSNode arg = ts_node_named_child(node, 1);
|
|
TSNode frag = arg;
|
|
if (find_first_descendant_of(arg, "path_fragment", &frag) ||
|
|
find_first_descendant_of(arg, "string_content", &frag)) {
|
|
push_path_import(ctx, frag);
|
|
} else {
|
|
push_path_import(ctx, arg);
|
|
}
|
|
}
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Jsonnet imports: import 'path' / importstr 'path' ---
|
|
static void parse_jsonnet_imports(CBMExtractCtx *ctx) {
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, ctx->arena, CBM_SZ_512);
|
|
ts_nstack_push(&stack, ctx->arena, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *k = ts_node_type(node);
|
|
if (ts_node_is_named(node) && (strcmp(k, "import") == 0 || strcmp(k, "importstr") == 0 ||
|
|
strcmp(k, "importbin") == 0)) {
|
|
push_string_descendant_import(ctx, node);
|
|
}
|
|
ts_nstack_push_children(&stack, ctx->arena, node);
|
|
}
|
|
}
|
|
|
|
// --- Pkl imports: amends/extends/import "path" ---
|
|
static void parse_pkl_imports(CBMExtractCtx *ctx) {
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, ctx->arena, CBM_SZ_512);
|
|
ts_nstack_push(&stack, ctx->arena, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *k = ts_node_type(node);
|
|
if (strcmp(k, "extendsOrAmendsClause") == 0 || strcmp(k, "importClause") == 0 ||
|
|
strcmp(k, "importExpr") == 0) {
|
|
push_string_descendant_import(ctx, node);
|
|
}
|
|
ts_nstack_push_children(&stack, ctx->arena, node);
|
|
}
|
|
}
|
|
|
|
// --- Nickel imports: import "path" ---
|
|
static void parse_nickel_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
/* The grammar emits an anonymous `import` token followed by a
|
|
* static_string sibling. Detect any node carrying a static_string whose
|
|
* preceding sibling text is "import". Simpler: scan children for the
|
|
* "import" keyword token and take the next static_string. */
|
|
uint32_t nc = ts_node_child_count(node);
|
|
for (uint32_t j = 0; j + 1 < nc; j++) {
|
|
TSNode c = ts_node_child(node, j);
|
|
char *t = cbm_node_text(a, c, ctx->source);
|
|
if (t && strcmp(t, "import") == 0) {
|
|
for (uint32_t m = j + 1; m < nc; m++) {
|
|
TSNode s = ts_node_child(node, m);
|
|
if (strcmp(ts_node_type(s), "static_string") == 0) {
|
|
push_string_descendant_import(ctx, s);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Thrift imports: include "path" ---
|
|
static void parse_thrift_imports(CBMExtractCtx *ctx) {
|
|
TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
|
|
if (!ts_tree_cursor_goto_first_child(&cursor)) {
|
|
ts_tree_cursor_delete(&cursor);
|
|
return;
|
|
}
|
|
do {
|
|
TSNode node = ts_tree_cursor_current_node(&cursor);
|
|
const char *k = ts_node_type(node);
|
|
if (strcmp(k, "include_statement") == 0 || strcmp(k, "cpp_include_statement") == 0) {
|
|
push_string_descendant_import(ctx, node);
|
|
}
|
|
} while (ts_tree_cursor_goto_next_sibling(&cursor));
|
|
ts_tree_cursor_delete(&cursor);
|
|
}
|
|
|
|
// --- Cap'n Proto imports: using X = import "path" ---
|
|
static void parse_capnp_imports(CBMExtractCtx *ctx) {
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, ctx->arena, CBM_SZ_512);
|
|
ts_nstack_push(&stack, ctx->arena, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *k = ts_node_type(node);
|
|
if (ts_node_is_named(node) &&
|
|
(strcmp(k, "import_using") == 0 || strcmp(k, "import_path") == 0)) {
|
|
push_string_descendant_import(ctx, node);
|
|
continue; /* don't double-emit from nested import_path */
|
|
}
|
|
ts_nstack_push_children(&stack, ctx->arena, node);
|
|
}
|
|
}
|
|
|
|
// --- D imports: import module.path; (nested under module_def) ---
|
|
static void parse_dlang_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "import_declaration") == 0) {
|
|
TSNode fqn = node;
|
|
if (find_first_descendant_of(node, "module_fqn", &fqn)) {
|
|
char *mod = cbm_node_text(a, fqn, ctx->source);
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- TableGen imports: include "path.td" ---
|
|
static void parse_tablegen_imports(CBMExtractCtx *ctx) {
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, ctx->arena, CBM_SZ_512);
|
|
ts_nstack_push(&stack, ctx->arena, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *k = ts_node_type(node);
|
|
if (ts_node_is_named(node) &&
|
|
(strcmp(k, "include_directive") == 0 || strcmp(k, "include") == 0)) {
|
|
push_string_descendant_import(ctx, node);
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, ctx->arena, node);
|
|
}
|
|
}
|
|
|
|
// --- Crystal imports: require "./path" ---
|
|
static void parse_crystal_imports(CBMExtractCtx *ctx) {
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, ctx->arena, CBM_SZ_512);
|
|
ts_nstack_push(&stack, ctx->arena, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (ts_node_is_named(node) && strcmp(ts_node_type(node), "require") == 0) {
|
|
push_string_descendant_import(ctx, node);
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, ctx->arena, node);
|
|
}
|
|
}
|
|
|
|
// --- F# imports: open Module.Path ---
|
|
static void parse_fsharp_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *k = ts_node_type(node);
|
|
if (strcmp(k, "import_decl") == 0 || strcmp(k, "open_expression") == 0) {
|
|
TSNode id = node;
|
|
if (find_first_descendant_of(node, "long_identifier", &id) ||
|
|
find_first_descendant_of(node, "identifier", &id)) {
|
|
char *mod = cbm_node_text(a, id, ctx->source);
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Ada imports: with Pkg.Child; ---
|
|
static void parse_ada_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "with_clause") == 0) {
|
|
uint32_t nc = ts_node_named_child_count(node);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode c = ts_node_named_child(node, j);
|
|
const char *ck = ts_node_type(c);
|
|
if (strcmp(ck, "identifier") == 0 || strcmp(ck, "selected_component") == 0 ||
|
|
strcmp(ck, "name") == 0) {
|
|
char *mod = cbm_node_text(a, c, ctx->source);
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Elm imports: `import Module.Path [as X] [exposing (..)]` ---
|
|
// AST: file -> import_clause(moduleName: upper_case_qid). The module path maps
|
|
// to a sibling file (`import Utils` -> Utils.elm), resolved by the pipeline's
|
|
// sibling-file resolver.
|
|
static void parse_elm_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "import_clause") == 0) {
|
|
TSNode name = node;
|
|
if (find_first_descendant_of(node, "upper_case_qid", &name)) {
|
|
char *mod = cbm_node_text(a, name, ctx->source);
|
|
if (mod && mod[0]) {
|
|
/* Elm module dots map to directory separators on disk
|
|
* (Math.Util -> Math/Util.elm); '.'-> '/' so the sibling
|
|
* resolver builds the right path. */
|
|
for (char *p = mod; *p; p++) {
|
|
if (*p == '.') {
|
|
*p = '/';
|
|
}
|
|
}
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Move imports: `use 0xADDR::module [::member];` ---
|
|
// AST: use_declaration with `argument: identifier` = the module name. The
|
|
// leading hex address parses as an error node but the module identifier is
|
|
// captured cleanly via the `argument` field. Resolves to a sibling file.
|
|
static void parse_move_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "use_declaration") == 0) {
|
|
TSNode arg = ts_node_child_by_field_name(node, TS_FIELD("argument"));
|
|
char *mod = NULL;
|
|
if (!ts_node_is_null(arg)) {
|
|
mod = cbm_node_text(a, arg, ctx->source);
|
|
} else if (find_first_descendant_of(node, "identifier", &arg)) {
|
|
mod = cbm_node_text(a, arg, ctx->source);
|
|
}
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Smali imports: `.super Lpkg/Name;` / `.implements Lpkg/Iface;` ---
|
|
// AST: super_directive / implements_directive -> class_identifier holding a JVM
|
|
// type descriptor `Lpkg/Name;`. Demangle the descriptor (drop leading 'L',
|
|
// trailing ';', '/'->'.') so the bare class name resolves to its sibling file.
|
|
static char *smali_demangle_descriptor(CBMArena *a, const char *desc) {
|
|
if (!desc || !desc[0]) {
|
|
return NULL;
|
|
}
|
|
const char *start = desc;
|
|
if (start[0] == 'L') {
|
|
start++;
|
|
}
|
|
size_t len = strlen(start);
|
|
if (len > 0 && start[len - 1] == ';') {
|
|
len--;
|
|
}
|
|
char *out = cbm_arena_strndup(a, start, len);
|
|
if (out) {
|
|
for (char *p = out; *p; p++) {
|
|
if (*p == '/') {
|
|
*p = '.';
|
|
}
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
static void parse_smali_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *k = ts_node_type(node);
|
|
if (strcmp(k, "super_directive") == 0 || strcmp(k, "implements_directive") == 0) {
|
|
TSNode cid = node;
|
|
if (find_first_descendant_of(node, "class_identifier", &cid)) {
|
|
char *mod = smali_demangle_descriptor(a, cbm_node_text(a, cid, ctx->source));
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- TLA+ imports: `EXTENDS Foo, Bar` / `INSTANCE Foo` ---
|
|
// AST: extends -> identifier_ref* (one per extended module). Each module maps
|
|
// to a sibling `Foo.tla` file.
|
|
static void parse_tlaplus_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
const char *k = ts_node_type(node);
|
|
if (strcmp(k, "extends") == 0 || strcmp(k, "instance") == 0) {
|
|
uint32_t nc = ts_node_named_child_count(node);
|
|
for (uint32_t j = 0; j < nc; j++) {
|
|
TSNode c = ts_node_named_child(node, j);
|
|
const char *ck = ts_node_type(c);
|
|
if (strcmp(ck, "identifier_ref") == 0 || strcmp(ck, "identifier") == 0) {
|
|
char *mod = cbm_node_text(a, c, ctx->source);
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- VHDL imports: `use work.pkg.all;` ---
|
|
// AST: use_clause -> selected_name(library:, package:, ...). The `package`
|
|
// field names the imported package, which maps to a sibling file (math_pkg ->
|
|
// math_pkg.vhd) declaring `package math_pkg`. `library_clause` (`library work;`)
|
|
// names no file and is skipped.
|
|
static void parse_vhdl_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "use_clause") == 0) {
|
|
TSNode sel = node;
|
|
if (find_first_descendant_of(node, "selected_name", &sel)) {
|
|
TSNode pkg = ts_node_child_by_field_name(sel, TS_FIELD("package"));
|
|
char *mod = NULL;
|
|
if (!ts_node_is_null(pkg)) {
|
|
mod = cbm_node_text(a, pkg, ctx->source);
|
|
}
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- WIT imports: `use types.{point};` / `use pkg/iface;` ---
|
|
// AST: use_item -> use_path(id...). The leading path segment names the imported
|
|
// interface/package, mapping to a sibling `types.wit` file.
|
|
static void parse_wit_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "use_item") == 0) {
|
|
TSNode path = node;
|
|
if (find_first_descendant_of(node, "use_path", &path)) {
|
|
/* First `id` child of the path is the interface/package name. */
|
|
TSNode idn = path;
|
|
if (find_first_descendant_of(path, "id", &idn)) {
|
|
char *mod = cbm_node_text(a, idn, ctx->source);
|
|
if (mod && mod[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Smithy imports: `use com.example.common#Shape` ---
|
|
// AST: use_statement -> absolute_root_shape_id(namespace, identifier). Emit a
|
|
// dotted path `<namespace>.<Shape>` so the pipeline's symbol-name fallback links
|
|
// it to the declaring shape (a Class/Struct node) in the namespace's file.
|
|
static void parse_smithy_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "use_statement") == 0) {
|
|
TSNode sid = node;
|
|
if (find_first_descendant_of(node, "absolute_root_shape_id", &sid) ||
|
|
find_first_descendant_of(node, "shape_id", &sid)) {
|
|
char *mod = cbm_node_text(a, sid, ctx->source);
|
|
if (mod && mod[0]) {
|
|
/* `com.example.common#Timestamp` -> dotted path so the last
|
|
* segment (Timestamp) resolves to the declaring shape. */
|
|
for (char *p = mod; *p; p++) {
|
|
if (*p == '#') {
|
|
*p = '.';
|
|
}
|
|
}
|
|
CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Hyprlang imports: `source = ~/path/to/file.conf` ---
|
|
// AST: source -> string. Emit the referenced path; the pipeline's sibling-file
|
|
// resolver matches it (by full path, then by basename) to the included file.
|
|
static void parse_hyprlang_imports(CBMExtractCtx *ctx) {
|
|
CBMArena *a = ctx->arena;
|
|
TSNodeStack stack;
|
|
ts_nstack_init(&stack, a, CBM_SZ_512);
|
|
ts_nstack_push(&stack, a, ctx->root);
|
|
while (stack.count > 0) {
|
|
TSNode node = ts_nstack_pop(&stack);
|
|
if (strcmp(ts_node_type(node), "source") == 0) {
|
|
TSNode str = node;
|
|
char *path = NULL;
|
|
if (find_first_descendant_of(node, "string", &str)) {
|
|
path = strip_quotes(a, cbm_node_text(a, str, ctx->source));
|
|
} else {
|
|
path = strip_quotes(a, cbm_node_text(a, node, ctx->source));
|
|
}
|
|
if (path && path[0]) {
|
|
CBMImport imp = {.local_name = path_last(a, path), .module_path = path};
|
|
cbm_imports_push(&ctx->result->imports, a, imp);
|
|
}
|
|
continue;
|
|
}
|
|
ts_nstack_push_children(&stack, a, node);
|
|
}
|
|
}
|
|
|
|
// --- Main dispatch ---
|
|
|
|
void cbm_extract_imports(CBMExtractCtx *ctx) {
|
|
switch (ctx->language) {
|
|
case CBM_LANG_JAVA:
|
|
case CBM_LANG_KOTLIN:
|
|
case CBM_LANG_CSHARP:
|
|
case CBM_LANG_PHP:
|
|
capture_namespace_decl(ctx);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch (ctx->language) {
|
|
case CBM_LANG_GO:
|
|
parse_go_imports(ctx);
|
|
break;
|
|
case CBM_LANG_PYTHON:
|
|
parse_python_imports(ctx);
|
|
break;
|
|
case CBM_LANG_JAVASCRIPT:
|
|
case CBM_LANG_TYPESCRIPT:
|
|
case CBM_LANG_TSX:
|
|
parse_es_imports(ctx);
|
|
break;
|
|
case CBM_LANG_JAVA:
|
|
parse_java_imports(ctx);
|
|
break;
|
|
case CBM_LANG_KOTLIN:
|
|
parse_kotlin_imports(ctx);
|
|
break;
|
|
case CBM_LANG_SCALA:
|
|
parse_generic_imports(ctx, "import_declaration");
|
|
break;
|
|
case CBM_LANG_CSHARP:
|
|
parse_csharp_imports(ctx);
|
|
break;
|
|
case CBM_LANG_RUST:
|
|
parse_rust_imports(ctx);
|
|
break;
|
|
case CBM_LANG_C:
|
|
case CBM_LANG_CPP:
|
|
case CBM_LANG_OBJC:
|
|
parse_c_imports(ctx);
|
|
break;
|
|
case CBM_LANG_PHP:
|
|
// PHP `use Foo\Bar;` is a namespace_use_declaration; require/include are
|
|
// expression_statements. parse_php_imports handles both.
|
|
parse_php_imports(ctx);
|
|
break;
|
|
case CBM_LANG_RUBY:
|
|
parse_ruby_imports(ctx);
|
|
break;
|
|
case CBM_LANG_LUA:
|
|
parse_lua_imports(ctx);
|
|
break;
|
|
case CBM_LANG_R:
|
|
parse_r_imports(ctx);
|
|
break;
|
|
case CBM_LANG_ELIXIR:
|
|
// Elixir: import/use/alias/require are call nodes
|
|
parse_generic_imports(ctx, "call");
|
|
break;
|
|
case CBM_LANG_BASH:
|
|
// source/. commands
|
|
parse_generic_imports(ctx, "command");
|
|
break;
|
|
case CBM_LANG_ZIG:
|
|
parse_zig_imports(ctx);
|
|
break;
|
|
case CBM_LANG_ERLANG:
|
|
parse_generic_imports(ctx, "module_attribute");
|
|
break;
|
|
case CBM_LANG_HASKELL:
|
|
parse_haskell_imports(ctx);
|
|
break;
|
|
case CBM_LANG_OCAML:
|
|
parse_generic_imports(ctx, "open_module");
|
|
break;
|
|
case CBM_LANG_CSS:
|
|
case CBM_LANG_SCSS:
|
|
parse_css_imports(ctx);
|
|
break;
|
|
case CBM_LANG_PERL:
|
|
parse_generic_imports(ctx, "use_statement");
|
|
break;
|
|
case CBM_LANG_GROOVY:
|
|
parse_generic_imports(ctx, "groovy_import");
|
|
break;
|
|
case CBM_LANG_SWIFT:
|
|
parse_generic_imports(ctx, "import_declaration");
|
|
break;
|
|
case CBM_LANG_DART:
|
|
parse_dart_imports(ctx);
|
|
break;
|
|
case CBM_LANG_LEAN:
|
|
parse_generic_imports(ctx, "import");
|
|
break;
|
|
case CBM_LANG_FORM:
|
|
parse_generic_imports(ctx, "include_directive");
|
|
break;
|
|
case CBM_LANG_MAGMA:
|
|
parse_generic_imports(ctx, "load_statement");
|
|
break;
|
|
case CBM_LANG_WOLFRAM:
|
|
parse_wolfram_imports(ctx);
|
|
break;
|
|
case CBM_LANG_HARE:
|
|
parse_hare_imports(ctx);
|
|
break;
|
|
case CBM_LANG_PASCAL:
|
|
parse_pascal_imports(ctx);
|
|
break;
|
|
case CBM_LANG_POWERSHELL:
|
|
parse_powershell_imports(ctx);
|
|
break;
|
|
case CBM_LANG_SCHEME:
|
|
case CBM_LANG_RACKET:
|
|
case CBM_LANG_EMACSLISP:
|
|
case CBM_LANG_FENNEL:
|
|
case CBM_LANG_COMMONLISP:
|
|
case CBM_LANG_CLOJURE:
|
|
parse_lisp_imports(ctx);
|
|
break;
|
|
case CBM_LANG_STARLARK:
|
|
parse_starlark_imports(ctx);
|
|
break;
|
|
case CBM_LANG_TCL:
|
|
parse_tcl_imports(ctx);
|
|
break;
|
|
case CBM_LANG_TEAL:
|
|
parse_teal_imports(ctx);
|
|
break;
|
|
case CBM_LANG_ZSH:
|
|
parse_zsh_imports(ctx);
|
|
break;
|
|
case CBM_LANG_CMAKE:
|
|
parse_cmake_imports(ctx);
|
|
break;
|
|
case CBM_LANG_BITBAKE:
|
|
parse_bitbake_imports(ctx);
|
|
break;
|
|
case CBM_LANG_KCONFIG:
|
|
parse_kconfig_imports(ctx);
|
|
break;
|
|
case CBM_LANG_GN:
|
|
parse_gn_imports(ctx);
|
|
break;
|
|
case CBM_LANG_JUST:
|
|
parse_just_imports(ctx);
|
|
break;
|
|
case CBM_LANG_MESON:
|
|
parse_meson_imports(ctx);
|
|
break;
|
|
case CBM_LANG_NIX:
|
|
parse_nix_imports(ctx);
|
|
break;
|
|
case CBM_LANG_JSONNET:
|
|
parse_jsonnet_imports(ctx);
|
|
break;
|
|
case CBM_LANG_PKL:
|
|
parse_pkl_imports(ctx);
|
|
break;
|
|
case CBM_LANG_NICKEL:
|
|
parse_nickel_imports(ctx);
|
|
break;
|
|
case CBM_LANG_THRIFT:
|
|
parse_thrift_imports(ctx);
|
|
break;
|
|
case CBM_LANG_CAPNP:
|
|
parse_capnp_imports(ctx);
|
|
break;
|
|
case CBM_LANG_DLANG:
|
|
parse_dlang_imports(ctx);
|
|
break;
|
|
case CBM_LANG_TABLEGEN:
|
|
parse_tablegen_imports(ctx);
|
|
break;
|
|
case CBM_LANG_CRYSTAL:
|
|
parse_crystal_imports(ctx);
|
|
break;
|
|
case CBM_LANG_FSHARP:
|
|
parse_fsharp_imports(ctx);
|
|
break;
|
|
case CBM_LANG_ADA:
|
|
parse_ada_imports(ctx);
|
|
break;
|
|
case CBM_LANG_ELM:
|
|
parse_elm_imports(ctx);
|
|
break;
|
|
case CBM_LANG_MOVE:
|
|
parse_move_imports(ctx);
|
|
break;
|
|
case CBM_LANG_SMALI:
|
|
parse_smali_imports(ctx);
|
|
break;
|
|
case CBM_LANG_TLAPLUS:
|
|
parse_tlaplus_imports(ctx);
|
|
break;
|
|
case CBM_LANG_VHDL:
|
|
parse_vhdl_imports(ctx);
|
|
break;
|
|
case CBM_LANG_WIT:
|
|
parse_wit_imports(ctx);
|
|
break;
|
|
case CBM_LANG_SMITHY:
|
|
parse_smithy_imports(ctx);
|
|
break;
|
|
case CBM_LANG_HYPRLANG:
|
|
parse_hyprlang_imports(ctx);
|
|
break;
|
|
/* Host languages whose tree-sitter grammar leaves <script> bodies as raw
|
|
* text — re-parse the embedded slice via the embedded-language spec. */
|
|
case CBM_LANG_HTML:
|
|
parse_html_imports(ctx);
|
|
break;
|
|
case CBM_LANG_SVELTE:
|
|
case CBM_LANG_VUE:
|
|
case CBM_LANG_ASTRO:
|
|
parse_embedded_imports(ctx);
|
|
break;
|
|
default:
|
|
// Grammar-only languages with no dedicated parser: consume the
|
|
// import_node_types declared in their CBMLangSpec generically.
|
|
parse_spec_imports(ctx);
|
|
break;
|
|
}
|
|
}
|