universal-ast-mapper 0.5.3 → 0.7.0

package/dist/crosslang.js

@@ -0,0 +1,312 @@
+import fs from "node:fs";
+import path from "node:path";
+const TYPE_KINDS = new Set(["class", "interface", "enum", "struct"]);
+/** Walk a symbol tree and yield each top-level type-like symbol. */
+function topTypeSymbols(symbols) {
+    return symbols.filter((s) => TYPE_KINDS.has(s.kind));
+}
+function getDirectiveValue(skel, prefix) {
+    const hit = (skel.directives ?? []).find((d) => d.startsWith(prefix));
+    return hit ? hit.slice(prefix.length) : null;
+}
+function getAllDirectiveValues(skel, prefix) {
+    return (skel.directives ?? [])
+        .filter((d) => d.startsWith(prefix))
+        .map((d) => d.slice(prefix.length));
+}
+/**
+ * Build Java + C# indexes from already-parsed skeletons.
+ * Cheap: O(symbols), no extra file reads.
+ */
+export function buildCrossLangIndex(skeletons) {
+    const index = {
+        javaFqcn: new Map(),
+        javaPackages: new Map(),
+        csharpNamespaces: new Map(),
+        csharpTypes: new Map(),
+    };
+    for (const skel of skeletons) {
+        if (skel.language === "java") {
+            const pkg = getDirectiveValue(skel, "package:");
+            if (!pkg)
+                continue;
+            const pkgFiles = index.javaPackages.get(pkg) ?? [];
+            pkgFiles.push(skel.file);
+            index.javaPackages.set(pkg, pkgFiles);
+            for (const sym of topTypeSymbols(skel.symbols)) {
+                index.javaFqcn.set(`${pkg}.${sym.name}`, skel.file);
+            }
+        }
+        else if (skel.language === "csharp") {
+            const namespaces = getAllDirectiveValues(skel, "namespace:");
+            for (const ns of namespaces) {
+                const arr = index.csharpNamespaces.get(ns) ?? [];
+                if (!arr.includes(skel.file))
+                    arr.push(skel.file);
+                index.csharpNamespaces.set(ns, arr);
+            }
+            // Map every top-level type to <ns>.<TypeName>. For files with multiple
+            // namespaces this is approximate (we don't know per-symbol scoping
+            // without per-symbol namespace tracking) but accurate for the common case
+            // of one namespace per file.
+            for (const sym of topTypeSymbols(skel.symbols)) {
+                for (const ns of namespaces) {
+                    index.csharpTypes.set(`${ns}.${sym.name}`, skel.file);
+                }
+            }
+        }
+    }
+    return index;
+}
+/* ─── Rust module resolution ──────────────────────────────────────────────── */
+function findCargoRoot(fromAbs, projectRoot) {
+    let dir = path.dirname(fromAbs);
+    const stop = path.resolve(projectRoot);
+    while (true) {
+        if (fs.existsSync(path.join(dir, "Cargo.toml")))
+            return dir;
+        if (dir === stop || dir === path.dirname(dir))
+            return null;
+        dir = path.dirname(dir);
+    }
+}
+function existsFile(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function existsDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Walk module path segments down from a base dir, returning the resolved .rs file. */
+function walkRustModule(base, segs) {
+    if (segs.length === 0) {
+        // base IS the target module dir/file. Try canonical roots.
+        for (const candidate of ["mod.rs", "lib.rs", "main.rs"]) {
+            const p = path.join(base, candidate);
+            if (existsFile(p))
+                return p;
+        }
+        if (existsFile(base + ".rs"))
+            return base + ".rs";
+        return null;
+    }
+    const [head, ...rest] = segs;
+    if (rest.length === 0) {
+        // Terminal segment: `head.rs` or `head/mod.rs`.
+        const p1 = path.join(base, `${head}.rs`);
+        if (existsFile(p1))
+            return p1;
+        const p2 = path.join(base, head, "mod.rs");
+        if (existsFile(p2))
+            return p2;
+        return null;
+    }
+    // Non-terminal: descend into a directory module.
+    const subDir = path.join(base, head);
+    if (existsDir(subDir))
+        return walkRustModule(subDir, rest);
+    // Rust-2018 style: `head.rs` next to a sibling `head/` directory.
+    if (existsFile(path.join(base, `${head}.rs`)) && existsDir(path.join(base, head))) {
+        return walkRustModule(path.join(base, head), rest);
+    }
+    return null;
+}
+/**
+ * Resolve a Rust `use` path to an absolute .rs file.
+ * Handles `crate::`, `self::`, `super::` prefixes; anything else is treated
+ * as an external crate (e.g. `std::`, `tokio::`) and returns null.
+ *
+ * @param importFrom Full use path, e.g. "crate::foo::Bar"
+ * @param fromAbs   Absolute path of the importing file
+ * @param projectRoot Absolute project root (security boundary)
+ */
+export function resolveRustModule(importFrom, fromAbs, projectRoot) {
+    const segs = importFrom.split("::");
+    if (segs.length === 0)
+        return null;
+    // Strip the imported item name (last segment) — leaves the module path.
+    const moduleSegs = segs.slice(0, -1);
+    if (moduleSegs.length === 0)
+        return null;
+    const head = moduleSegs[0];
+    let base;
+    let remaining;
+    if (head === "crate") {
+        const cargoRoot = findCargoRoot(fromAbs, projectRoot);
+        if (!cargoRoot)
+            return null;
+        base = path.join(cargoRoot, "src");
+        if (!existsDir(base))
+            base = cargoRoot;
+        remaining = moduleSegs.slice(1);
+    }
+    else if (head === "self") {
+        base = path.dirname(fromAbs);
+        remaining = moduleSegs.slice(1);
+    }
+    else if (head === "super") {
+        let dir = path.dirname(fromAbs);
+        let i = 0;
+        while (moduleSegs[i] === "super") {
+            dir = path.dirname(dir);
+            i++;
+        }
+        base = dir;
+        remaining = moduleSegs.slice(i);
+    }
+    else {
+        return null; // external crate
+    }
+    return walkRustModule(base, remaining);
+}
+// Cache per project root.
+const goModuleCache = new Map();
+function readGoModulePath(modFile) {
+    try {
+        const txt = fs.readFileSync(modFile, "utf8");
+        const m = /^\s*module\s+(\S+)/m.exec(txt);
+        return m ? m[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Locate the go.mod ancestor (within projectRoot) of `fromAbs`. */
+function findGoModule(fromAbs, projectRoot) {
+    const key = path.resolve(projectRoot);
+    if (goModuleCache.has(key)) {
+        // Cached at the project root level — assumes one go.mod per project root.
+        // For monorepos with multiple modules, ResolveGoImport falls back to a
+        // walk-up search below.
+        const cached = goModuleCache.get(key);
+        if (cached)
+            return cached;
+    }
+    let dir = path.dirname(fromAbs);
+    const stop = key;
+    while (true) {
+        const modFile = path.join(dir, "go.mod");
+        if (existsFile(modFile)) {
+            const modPath = readGoModulePath(modFile);
+            if (modPath) {
+                const result = { modulePath: modPath, moduleDir: dir };
+                if (dir === stop)
+                    goModuleCache.set(key, result);
+                return result;
+            }
+        }
+        if (dir === stop || dir === path.dirname(dir))
+            return null;
+        dir = path.dirname(dir);
+    }
+}
+/**
+ * Resolve a Go import path to a list of .go files in the resolved package
+ * directory. Returns null for stdlib / third-party / unresolvable paths.
+ *
+ * Go semantics:
+ *   - A package is a directory containing one or more .go files.
+ *   - `import "github.com/x/y/z"` maps to <moduleDir>/<subpath> when the prefix
+ *     matches the current module's path.
+ */
+export function resolveGoImport(importFrom, fromAbs, projectRoot) {
+    const mod = findGoModule(fromAbs, projectRoot);
+    if (!mod)
+        return null;
+    let subPath;
+    if (importFrom === mod.modulePath) {
+        subPath = "";
+    }
+    else if (importFrom.startsWith(mod.modulePath + "/")) {
+        subPath = importFrom.slice(mod.modulePath.length + 1);
+    }
+    else {
+        return null; // external / stdlib
+    }
+    const pkgDir = subPath ? path.join(mod.moduleDir, subPath) : mod.moduleDir;
+    if (!existsDir(pkgDir))
+        return null;
+    // Collect every .go file in the directory (Go packages span all files in dir).
+    // Skip _test.go files — call graph cares about production code.
+    let entries;
+    try {
+        entries = fs.readdirSync(pkgDir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    const files = [];
+    for (const e of entries) {
+        if (!e.isFile())
+            continue;
+        if (!e.name.endsWith(".go"))
+            continue;
+        if (e.name.endsWith("_test.go"))
+            continue;
+        const abs = path.join(pkgDir, e.name);
+        const rel = path.relative(projectRoot, abs).split(path.sep).join("/");
+        files.push(rel);
+    }
+    return files.length > 0 ? files : null;
+}
+/** Test/debug hook: drop the cached Go module info. */
+export function clearGoModuleCache() {
+    goModuleCache.clear();
+}
+/**
+ * Resolve an ImportRef in a non-relative-path language to a graph target.
+ * Returns null for unresolvable / external imports.
+ */
+export function resolveCrossLangTarget(imp, skel, fromAbs, projectRoot, index) {
+    if (skel.language === "java") {
+        if (imp.symbol === "*") {
+            // wildcard: pull all files in the package
+            const files = index.javaPackages.get(imp.from);
+            if (files && files.length > 0)
+                return { kind: "file", files: files.slice() };
+            return null;
+        }
+        const targetFile = index.javaFqcn.get(imp.from);
+        if (targetFile)
+            return { kind: "symbol", file: targetFile, symbol: imp.symbol };
+        return null;
+    }
+    if (skel.language === "csharp") {
+        const files = index.csharpNamespaces.get(imp.from);
+        if (files && files.length > 0) {
+            // Exclude self — a file `using App;` while declaring in App shouldn't self-edge.
+            const filtered = files.filter((f) => f !== skel.file);
+            if (filtered.length > 0)
+                return { kind: "file", files: filtered };
+        }
+        return null;
+    }
+    if (skel.language === "rust") {
+        const abs = resolveRustModule(imp.from, fromAbs, projectRoot);
+        if (!abs)
+            return null;
+        const rel = path.relative(projectRoot, abs).split(path.sep).join("/");
+        return { kind: "symbol", file: rel, symbol: imp.symbol };
+    }
+    if (skel.language === "go") {
+        const files = resolveGoImport(imp.from, fromAbs, projectRoot);
+        if (!files || files.length === 0)
+            return null;
+        // Exclude self (a file in package X importing X is unusual but possible
+        // for cyclic / generated cases — don't draw a self-edge).
+        const filtered = files.filter((f) => f !== skel.file);
+        if (filtered.length === 0)
+            return null;
+        return { kind: "file", files: filtered };
+    }
+    return null;
+}

package/dist/extractors/csharp.js

@@ -0,0 +1,209 @@
+import { namedChildren, nameOf, headerSignature, leadingComment } from "../parser.js";
+import { makeSymbol } from "./common.js";
+/* ─── helpers ─────────────────────────────────────────────────────────────── */
+function childOfType(node, type) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === type)
+            return c;
+    }
+    return null;
+}
+function modifiersText(node) {
+    let s = "";
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === "modifier")
+            s += c.text + " ";
+    }
+    return s;
+}
+function vis(node) {
+    return /\bpublic\b/.test(modifiersText(node)) ? "public" : "private";
+}
+function exported(node) {
+    return /\bpublic\b/.test(modifiersText(node));
+}
+function bodyLike(node) {
+    return (node.childForFieldName("body") ??
+        childOfType(node, "accessor_list") ??
+        childOfType(node, "arrow_expression_clause") ??
+        childOfType(node, "block"));
+}
+/* ─── directives (namespace declarations) ─────────────────────────────────── */
+export function extractDirectivesCSharp(root, _source) {
+    const out = [];
+    const visit = (node) => {
+        for (const c of namedChildren(node)) {
+            if (c.type === "namespace_declaration" || c.type === "file_scoped_namespace_declaration") {
+                const name = c.childForFieldName("name");
+                if (name)
+                    out.push(`namespace:${name.text}`);
+                const body = c.childForFieldName("body");
+                if (body)
+                    visit(body);
+            }
+        }
+    };
+    visit(root);
+    return out;
+}
+/* ─── import extraction ───────────────────────────────────────────────────── */
+export function extractImportsCSharp(root, _source) {
+    const out = [];
+    walkUsings(root, out);
+    return out;
+}
+function walkUsings(node, out) {
+    for (const child of namedChildren(node)) {
+        if (child.type === "using_directive") {
+            const isStatic = /\bstatic\b/.test(child.text);
+            const alias = childOfType(child, "name_equals");
+            const pathNode = childOfType(child, "qualified_name") ?? childOfType(child, "identifier");
+            const from = pathNode ? pathNode.text : child.text.replace(/^using\s+|;\s*$/g, "").trim();
+            const symbol = from.split(".").pop() ?? from;
+            const ref = { symbol, from, isNamespaceImport: !isStatic && !alias };
+            if (alias) {
+                const aliasId = childOfType(alias, "identifier");
+                if (aliasId)
+                    ref.alias = aliasId.text;
+            }
+            out.push(ref);
+        }
+        else if (child.type === "namespace_declaration" ||
+            child.type === "file_scoped_namespace_declaration") {
+            const body = child.childForFieldName("body");
+            if (body)
+                walkUsings(body, out);
+        }
+    }
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractCSharp(root, _source) {
+    return collect(namedChildren(root));
+}
+function collect(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        const res = handle(n);
+        if (Array.isArray(res))
+            out.push(...res);
+        else if (res)
+            out.push(res);
+    }
+    return out;
+}
+function handle(node) {
+    switch (node.type) {
+        case "namespace_declaration":
+        case "file_scoped_namespace_declaration": {
+            const body = node.childForFieldName("body");
+            return body ? collect(namedChildren(body)) : null;
+        }
+        case "class_declaration":
+        case "record_declaration":
+        case "record_struct_declaration": {
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name: nameOf(node) ?? "(class)",
+                kind: "class",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body)) : [],
+            });
+        }
+        case "struct_declaration": {
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name: nameOf(node) ?? "(struct)",
+                kind: "struct",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body)) : [],
+            });
+        }
+        case "interface_declaration": {
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name: nameOf(node) ?? "(interface)",
+                kind: "interface",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body)) : [],
+            });
+        }
+        case "enum_declaration":
+            return makeSymbol({
+                name: nameOf(node) ?? "(enum)",
+                kind: "enum",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+            });
+        case "method_declaration":
+        case "constructor_declaration":
+        case "destructor_declaration":
+        case "operator_declaration":
+            return makeSymbol({
+                name: nameOf(node) ?? "(method)",
+                kind: "method",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, bodyLike(node)),
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+            });
+        case "property_declaration":
+            return makeSymbol({
+                name: nameOf(node) ?? "(property)",
+                kind: "field",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, bodyLike(node)),
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+            });
+        case "field_declaration":
+            return fieldDeclarators(node);
+        default:
+            return null;
+    }
+}
+function fieldDeclarators(node) {
+    const m = modifiersText(node);
+    const kind = /\bconst\b/.test(m) || (/\bstatic\b/.test(m) && /\breadonly\b/.test(m)) ? "const" : "field";
+    const decl = childOfType(node, "variable_declaration");
+    if (!decl)
+        return [];
+    const out = [];
+    for (const d of namedChildren(decl)) {
+        if (d.type !== "variable_declarator")
+            continue;
+        const id = childOfType(d, "identifier") ?? d.namedChild(0);
+        if (!id)
+            continue;
+        out.push(makeSymbol({
+            name: id.text,
+            kind,
+            node: d,
+            rawKind: node.type,
+            signature: node.text.replace(/\s+/g, " ").replace(/;$/, "").trim(),
+            visibility: vis(node),
+            exported: exported(node),
+        }));
+    }
+    return out;
+}

package/dist/extractors/java.js

@@ -0,0 +1,152 @@
+import { namedChildren, nameOf, headerSignature, leadingComment } from "../parser.js";
+import { makeSymbol } from "./common.js";
+/* ─── helpers ─────────────────────────────────────────────────────────────── */
+function childOfType(node, type) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === type)
+            return c;
+    }
+    return null;
+}
+function modifiersText(node) {
+    const m = childOfType(node, "modifiers");
+    return m ? m.text : "";
+}
+function vis(node) {
+    const m = modifiersText(node);
+    if (/\b(private|protected)\b/.test(m))
+        return "private";
+    return "public";
+}
+function exported(node) {
+    return /\bpublic\b/.test(modifiersText(node));
+}
+/* ─── directives (package declaration) ────────────────────────────────────── */
+export function extractDirectivesJava(root, _source) {
+    for (const child of namedChildren(root)) {
+        if (child.type !== "package_declaration")
+            continue;
+        const id = childOfType(child, "scoped_identifier") ?? childOfType(child, "identifier");
+        if (id)
+            return [`package:${id.text}`];
+    }
+    return [];
+}
+/* ─── import extraction ───────────────────────────────────────────────────── */
+export function extractImportsJava(root, _source) {
+    const out = [];
+    for (const child of namedChildren(root)) {
+        if (child.type !== "import_declaration")
+            continue;
+        const isStatic = /\bstatic\b/.test(child.text);
+        const isWildcard = /\.\s*\*/.test(child.text);
+        const pathNode = childOfType(child, "scoped_identifier") ?? childOfType(child, "identifier");
+        const from = pathNode ? pathNode.text : child.text.replace(/^import\s+|;\s*$/g, "").trim();
+        if (isWildcard) {
+            out.push({ symbol: "*", from, isNamespaceImport: true, isTypeOnly: !isStatic });
+        }
+        else {
+            const symbol = from.split(".").pop() ?? from;
+            out.push({ symbol, from, isTypeOnly: !isStatic });
+        }
+    }
+    return out;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractJava(root, _source) {
+    return collect(namedChildren(root));
+}
+function collect(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        const res = handle(n);
+        if (Array.isArray(res))
+            out.push(...res);
+        else if (res)
+            out.push(res);
+    }
+    return out;
+}
+function handle(node) {
+    switch (node.type) {
+        case "class_declaration":
+        case "record_declaration": {
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name: nameOf(node) ?? "(class)",
+                kind: "class",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body)) : [],
+            });
+        }
+        case "interface_declaration": {
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name: nameOf(node) ?? "(interface)",
+                kind: "interface",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body)) : [],
+            });
+        }
+        case "enum_declaration": {
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name: nameOf(node) ?? "(enum)",
+                kind: "enum",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body).filter((c) => c.type !== "enum_constant")) : [],
+            });
+        }
+        case "method_declaration":
+        case "constructor_declaration":
+            return makeSymbol({
+                name: nameOf(node) ?? "(method)",
+                kind: "method",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("body")),
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+            });
+        case "field_declaration":
+            return fieldDeclarators(node);
+        default:
+            return null;
+    }
+}
+function fieldDeclarators(node) {
+    const m = modifiersText(node);
+    const kind = /\bstatic\b/.test(m) && /\bfinal\b/.test(m) ? "const" : "field";
+    const out = [];
+    for (const decl of namedChildren(node)) {
+        if (decl.type !== "variable_declarator")
+            continue;
+        const name = nameOf(decl);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind,
+            node: decl,
+            rawKind: node.type,
+            signature: node.text.replace(/\s+/g, " ").replace(/;$/, "").trim(),
+            visibility: vis(node),
+            exported: exported(node),
+        }));
+    }
+    return out;
+}