universal-ast-mapper 2.0.0 → 2.0.2

package/dist/extractors/cpp.js

@@ -0,0 +1,272 @@
+import { namedChildren, nameOf, headerSignature, leadingComment } from "../parser.js";
+import { makeSymbol } from "./common.js";
+/* ─── helpers (shared with C extractor in spirit but kept local) ──────────── */
+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 nameFromDeclarator(node) {
+    if (!node)
+        return null;
+    switch (node.type) {
+        case "identifier":
+        case "field_identifier":
+        case "type_identifier":
+            return node.text;
+        case "pointer_declarator":
+        case "array_declarator":
+        case "parenthesized_declarator":
+        case "reference_declarator":
+            return nameFromDeclarator(node.childForFieldName("declarator") ?? node.namedChild(0));
+        case "function_declarator":
+        case "init_declarator":
+            return nameFromDeclarator(node.childForFieldName("declarator"));
+        case "qualified_identifier": {
+            // Foo::bar — use "bar" as the leaf name
+            const last = node.childForFieldName("name");
+            return last ? last.text : node.text;
+        }
+        case "operator_name":
+        case "destructor_name":
+            return node.text;
+        default:
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const c = node.namedChild(i);
+                if (c && (c.type === "identifier" || c.type === "field_identifier" || c.type === "type_identifier"))
+                    return c.text;
+            }
+            return null;
+    }
+}
+function containsFunctionDeclarator(node) {
+    if (node.type === "function_declarator")
+        return true;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && containsFunctionDeclarator(c))
+            return true;
+    }
+    return false;
+}
+function hasStaticStorage(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === "storage_class_specifier" && c.text === "static")
+            return true;
+    }
+    return false;
+}
+/* ─── imports (#include) ──────────────────────────────────────────────────── */
+export function extractImportsCpp(root, _source) {
+    const out = [];
+    const visit = (n) => {
+        for (const c of namedChildren(n)) {
+            if (c.type === "preproc_include") {
+                const p = childOfType(c, "system_lib_string") ?? childOfType(c, "string_literal");
+                if (p) {
+                    const raw = p.text.replace(/^[<"]|[>"]$/g, "");
+                    const base = raw.split("/").pop() ?? raw;
+                    out.push({ symbol: base.replace(/\.[hH](pp|xx|h)?$/, ""), from: raw });
+                }
+            }
+            else if (c.type === "namespace_definition" || c.type === "linkage_specification") {
+                const body = c.childForFieldName("body");
+                if (body)
+                    visit(body);
+            }
+        }
+    };
+    visit(root);
+    return out;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractCpp(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_definition":
+        case "linkage_specification": {
+            // Recurse into body, flattening namespace contents to top level.
+            const body = node.childForFieldName("body");
+            return body ? collect(namedChildren(body)) : null;
+        }
+        case "class_specifier": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name,
+                kind: "class",
+                node,
+                rawKind: node.type,
+                doc: leadingComment(node),
+                children: body ? classMembers(body, "private") : [],
+            });
+        }
+        case "struct_specifier": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name,
+                kind: "struct",
+                node,
+                rawKind: node.type,
+                doc: leadingComment(node),
+                children: body ? classMembers(body, "public") : [],
+            });
+        }
+        case "enum_specifier": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "enum",
+                node,
+                rawKind: node.type,
+                doc: leadingComment(node),
+            });
+        }
+        case "function_definition": {
+            const decl = node.childForFieldName("declarator");
+            const name = nameFromDeclarator(decl);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("body")),
+                visibility: hasStaticStorage(node) ? "private" : "public",
+                exported: !hasStaticStorage(node),
+                doc: leadingComment(node),
+            });
+        }
+        case "template_declaration": {
+            // The actual declaration is buried; recurse to find it.
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const c = node.namedChild(i);
+                if (!c)
+                    continue;
+                if (c.type === "class_specifier" ||
+                    c.type === "struct_specifier" ||
+                    c.type === "function_definition" ||
+                    c.type === "declaration") {
+                    const res = handle(c);
+                    if (res)
+                        return res;
+                }
+            }
+            return null;
+        }
+        case "alias_declaration":
+        case "type_definition": {
+            const decl = node.childForFieldName("declarator");
+            const name = nameOf(node) ?? nameFromDeclarator(decl);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "type",
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").replace(/;$/, "").trim(),
+            });
+        }
+        case "declaration": {
+            const decl = node.childForFieldName("declarator");
+            const name = nameFromDeclarator(decl);
+            if (!name)
+                return null;
+            if (decl && containsFunctionDeclarator(decl))
+                return null; // prototype
+            return makeSymbol({
+                name,
+                kind: "var",
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").replace(/;$/, "").trim(),
+            });
+        }
+        case "preproc_def":
+        case "preproc_function_def": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "const",
+                node,
+                rawKind: node.type,
+            });
+        }
+        default:
+            return null;
+    }
+}
+/** Walk class/struct body, tracking the current access_specifier (default given). */
+function classMembers(body, defaultAccess) {
+    let current = defaultAccess;
+    const out = [];
+    for (let i = 0; i < body.childCount; i++) {
+        const c = body.child(i);
+        if (!c)
+            continue;
+        if (c.type === "access_specifier") {
+            current = /\bpublic\b/.test(c.text) ? "public" : "private";
+            continue;
+        }
+        if (!c.isNamed)
+            continue;
+        if (c.type === "field_declaration") {
+            const dec = c.childForFieldName("declarator");
+            const name = nameFromDeclarator(dec);
+            if (!name)
+                continue;
+            const isFunc = dec && containsFunctionDeclarator(dec);
+            out.push(makeSymbol({
+                name,
+                kind: isFunc ? "method" : "field",
+                node: c,
+                rawKind: c.type,
+                signature: c.text.replace(/\s+/g, " ").replace(/;$/, "").trim(),
+                visibility: current,
+            }));
+        }
+        else if (c.type === "function_definition") {
+            const dec = c.childForFieldName("declarator");
+            const name = nameFromDeclarator(dec);
+            if (!name)
+                continue;
+            out.push(makeSymbol({
+                name,
+                kind: "method",
+                node: c,
+                rawKind: c.type,
+                signature: headerSignature(c, c.childForFieldName("body")),
+                visibility: current,
+            }));
+        }
+    }
+    return out;
+}

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/go.js

@@ -0,0 +1,212 @@
+import { namedChildren, nameOf, headerSignature, leadingComment } from "../parser.js";
+import { makeSymbol, startsUpper } from "./common.js";
+// ─── Import extraction ────────────────────────────────────────────────────────
+export function extractImportsGo(root, _source) {
+    const imports = [];
+    for (const child of namedChildren(root)) {
+        if (child.type === "import_declaration")
+            parseGoImportDecl(child, imports);
+    }
+    return imports;
+}
+function parseGoImportDecl(node, out) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c)
+            continue;
+        if (c.type === "import_spec")
+            parseGoImportSpec(c, out);
+        else if (c.type === "import_spec_list") {
+            for (let j = 0; j < c.namedChildCount; j++) {
+                const spec = c.namedChild(j);
+                if (spec && spec.type === "import_spec")
+                    parseGoImportSpec(spec, out);
+            }
+        }
+    }
+}
+function parseGoImportSpec(spec, out) {
+    const pathNode = spec.childForFieldName("path");
+    const nameNode = spec.childForFieldName("name");
+    if (!pathNode)
+        return;
+    const from = pathNode.text.replace(/^['"`]|['"`]$/g, "");
+    const pkgName = from.split("/").pop() ?? from;
+    if (!nameNode) {
+        out.push({ symbol: pkgName, from });
+    }
+    else if (nameNode.text === ".") {
+        out.push({ symbol: ".", from, isNamespaceImport: true });
+    }
+    else if (nameNode.text === "_") {
+        out.push({ symbol: "_", from, isSideEffect: true });
+    }
+    else {
+        out.push({ symbol: pkgName, from, alias: nameNode.text });
+    }
+}
+// ─── Symbol extraction ────────────────────────────────────────────────────────
+export function extractGo(root, _source) {
+    const out = [];
+    for (const n of namedChildren(root)) {
+        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 "function_declaration": {
+            const name = nameOf(node) ?? "(func)";
+            return makeSymbol({
+                name,
+                kind: "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("body")),
+                visibility: startsUpper(name) ? "public" : "private",
+                exported: startsUpper(name),
+                doc: leadingComment(node),
+            });
+        }
+        case "method_declaration": {
+            const name = nameOf(node) ?? "(method)";
+            return makeSymbol({
+                name,
+                kind: "method",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("body")),
+                visibility: startsUpper(name) ? "public" : "private",
+                exported: startsUpper(name),
+                doc: leadingComment(node),
+            });
+        }
+        case "type_declaration": {
+            const out = [];
+            for (const spec of namedChildren(node)) {
+                if (spec.type === "type_spec" || spec.type === "type_alias") {
+                    const sym = fromTypeSpec(spec, node);
+                    if (sym)
+                        out.push(sym);
+                }
+            }
+            return out;
+        }
+        case "const_declaration":
+            return fromValueSpecs(node, "const");
+        case "var_declaration":
+            return fromValueSpecs(node, "var");
+        default:
+            return null;
+    }
+}
+function fromTypeSpec(spec, declNode) {
+    const name = nameOf(spec);
+    if (!name)
+        return null;
+    const typeNode = spec.childForFieldName("type");
+    const exported = startsUpper(name);
+    const visibility = exported ? "public" : "private";
+    const doc = leadingComment(declNode);
+    if (typeNode && typeNode.type === "struct_type") {
+        return makeSymbol({
+            name,
+            kind: "struct",
+            node: spec,
+            rawKind: spec.type,
+            visibility,
+            exported,
+            doc,
+            children: structFields(typeNode),
+        });
+    }
+    if (typeNode && typeNode.type === "interface_type") {
+        return makeSymbol({
+            name,
+            kind: "interface",
+            node: spec,
+            rawKind: spec.type,
+            visibility,
+            exported,
+            doc,
+            children: interfaceMethods(typeNode),
+        });
+    }
+    return makeSymbol({
+        name,
+        kind: "type",
+        node: spec,
+        rawKind: spec.type,
+        signature: headerSignature(spec, null),
+        visibility,
+        exported,
+        doc,
+    });
+}
+function structFields(structType) {
+    const list = namedChildren(structType).find((c) => c.type === "field_declaration_list");
+    if (!list)
+        return [];
+    const out = [];
+    for (const field of namedChildren(list)) {
+        if (field.type !== "field_declaration")
+            continue;
+        const name = nameOf(field);
+        if (!name)
+            continue; // skip embedded fields
+        out.push(makeSymbol({
+            name,
+            kind: "field",
+            node: field,
+            rawKind: field.type,
+            signature: field.text.replace(/\s+/g, " ").trim(),
+            visibility: startsUpper(name) ? "public" : "private",
+            exported: startsUpper(name),
+        }));
+    }
+    return out;
+}
+function interfaceMethods(interfaceType) {
+    const out = [];
+    for (const m of namedChildren(interfaceType)) {
+        if (m.type !== "method_spec" && m.type !== "method_elem")
+            continue;
+        const name = nameOf(m);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind: "method",
+            node: m,
+            rawKind: m.type,
+            signature: headerSignature(m, null),
+            visibility: startsUpper(name) ? "public" : "private",
+            exported: startsUpper(name),
+        }));
+    }
+    return out;
+}
+function fromValueSpecs(node, kind) {
+    const out = [];
+    for (const spec of namedChildren(node)) {
+        if (spec.type !== "const_spec" && spec.type !== "var_spec")
+            continue;
+        const name = nameOf(spec);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind,
+            node: spec,
+            rawKind: spec.type,
+            signature: spec.text.replace(/\s+/g, " ").trim(),
+            visibility: startsUpper(name) ? "public" : "private",
+            exported: startsUpper(name),
+        }));
+    }
+    return out;
+}