universal-ast-mapper 0.5.3 → 0.8.0

package/dist/extractors/kotlin.js

@@ -0,0 +1,159 @@
+import { namedChildren, 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 firstChildOfTypes(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && types.has(c.type))
+            return c;
+    }
+    return null;
+}
+const TYPE_NAME_NODES = new Set(["type_identifier", "simple_identifier"]);
+const SIMPLE_NAME_NODES = new Set(["simple_identifier"]);
+function modifiersText(node) {
+    const m = childOfType(node, "modifiers");
+    return m ? m.text : "";
+}
+function vis(node) {
+    const m = modifiersText(node);
+    if (/\b(private|protected|internal)\b/.test(m))
+        return "private";
+    return "public"; // Kotlin default is public
+}
+function exported(node) {
+    const m = modifiersText(node);
+    if (/\b(private|protected|internal)\b/.test(m))
+        return false;
+    return true;
+}
+function classKind(node) {
+    const m = modifiersText(node);
+    if (/\bdata\b/.test(node.text.slice(0, 80)))
+        return "class";
+    if (/\benum\b/.test(node.text.slice(0, 80)))
+        return "enum";
+    return "class";
+}
+/* ─── imports + package ───────────────────────────────────────────────────── */
+export function extractDirectivesKotlin(root, _source) {
+    for (const c of namedChildren(root)) {
+        if (c.type === "package_header") {
+            const id = childOfType(c, "identifier");
+            if (id)
+                return [`package:${id.text}`];
+        }
+    }
+    return [];
+}
+export function extractImportsKotlin(root, _source) {
+    const out = [];
+    const list = childOfType(root, "import_list");
+    if (!list)
+        return out;
+    for (const h of namedChildren(list)) {
+        if (h.type !== "import_header")
+            continue;
+        const id = childOfType(h, "identifier");
+        if (!id)
+            continue;
+        const isWildcard = /\.\*\s*$/.test(h.text);
+        const from = id.text;
+        const sym = isWildcard ? "*" : (from.split(".").pop() ?? from);
+        out.push({ symbol: sym, from, isNamespaceImport: isWildcard });
+    }
+    return out;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractKotlin(root, _source) {
+    return collect(namedChildren(root), false);
+}
+function collect(nodes, insideClass) {
+    const out = [];
+    for (const n of nodes) {
+        const res = handle(n, insideClass);
+        if (res)
+            out.push(res);
+    }
+    return out;
+}
+function handle(node, insideClass) {
+    switch (node.type) {
+        case "class_declaration": {
+            const nameNode = firstChildOfTypes(node, TYPE_NAME_NODES);
+            if (!nameNode)
+                return null;
+            const body = childOfType(node, "class_body") ?? childOfType(node, "enum_class_body");
+            return makeSymbol({
+                name: nameNode.text,
+                kind: classKind(node),
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body), true) : [],
+            });
+        }
+        case "object_declaration": {
+            const nameNode = firstChildOfTypes(node, TYPE_NAME_NODES);
+            if (!nameNode)
+                return null;
+            const body = childOfType(node, "class_body");
+            return makeSymbol({
+                name: nameNode.text,
+                kind: "class",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body), true) : [],
+            });
+        }
+        case "function_declaration": {
+            const nameNode = firstChildOfTypes(node, SIMPLE_NAME_NODES);
+            if (!nameNode)
+                return null;
+            const body = childOfType(node, "function_body");
+            return makeSymbol({
+                name: nameNode.text,
+                kind: insideClass ? "method" : "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, body),
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+            });
+        }
+        case "property_declaration": {
+            // variable_declaration → simple_identifier
+            const vd = childOfType(node, "variable_declaration");
+            const nameNode = vd ? firstChildOfTypes(vd, SIMPLE_NAME_NODES) : firstChildOfTypes(node, SIMPLE_NAME_NODES);
+            if (!nameNode)
+                return null;
+            const m = modifiersText(node);
+            const kind = insideClass ? "field" : (/\bconst\b/.test(m) ? "const" : "var");
+            return makeSymbol({
+                name: nameNode.text,
+                kind,
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").trim(),
+                visibility: vis(node),
+                exported: exported(node),
+            });
+        }
+        default:
+            return null;
+    }
+}

package/dist/extractors/rust.js

@@ -0,0 +1,249 @@
+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;
+}
+/** Rust: `pub`, `pub(crate)`, ... = public; anything else = module-private. */
+function isPub(node) {
+    const vis = childOfType(node, "visibility_modifier");
+    return !!vis && vis.text.startsWith("pub");
+}
+function vis(node) {
+    return isPub(node) ? "public" : "private";
+}
+/* ─── import extraction ───────────────────────────────────────────────────── */
+export function extractImportsRust(root, _source) {
+    const out = [];
+    for (const child of namedChildren(root)) {
+        if (child.type === "use_declaration") {
+            const arg = child.namedChild(0);
+            if (arg)
+                resolveUse(arg, "", out);
+        }
+    }
+    return out;
+}
+function resolveUse(node, prefix, out) {
+    switch (node.type) {
+        case "identifier":
+        case "type_identifier":
+            out.push({ symbol: node.text, from: join(prefix, node.text) });
+            return;
+        case "scoped_identifier": {
+            const full = node.text;
+            const sym = full.split("::").pop() ?? full;
+            out.push({ symbol: sym, from: full });
+            return;
+        }
+        case "use_as_clause": {
+            const path = node.namedChild(0);
+            const alias = node.namedChild(1);
+            const full = path ? path.text : "";
+            const sym = full.split("::").pop() ?? full;
+            out.push({ symbol: sym, from: full, alias: alias?.text });
+            return;
+        }
+        case "use_wildcard": {
+            const path = node.namedChild(0);
+            out.push({ symbol: "*", from: path ? path.text : prefix, isNamespaceImport: true });
+            return;
+        }
+        case "scoped_use_list": {
+            const base = node.namedChild(0);
+            const list = childOfType(node, "use_list");
+            const newPrefix = base ? base.text : prefix;
+            if (list) {
+                for (const item of namedChildren(list))
+                    resolveUse(item, newPrefix, out);
+            }
+            return;
+        }
+        case "use_list":
+            for (const item of namedChildren(node))
+                resolveUse(item, prefix, out);
+            return;
+        default:
+            return;
+    }
+}
+function join(prefix, name) {
+    return prefix ? `${prefix}::${name}` : name;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractRust(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 "struct_item": {
+            const name = nameOf(node) ?? "(struct)";
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name,
+                kind: "struct",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+                children: body && body.type === "field_declaration_list" ? structFields(body) : [],
+            });
+        }
+        case "trait_item": {
+            const name = nameOf(node) ?? "(trait)";
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name,
+                kind: "interface",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+                children: body ? traitMethods(body) : [],
+            });
+        }
+        case "enum_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(enum)",
+                kind: "enum",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+            });
+        case "function_item": {
+            const name = nameOf(node) ?? "(fn)";
+            return makeSymbol({
+                name,
+                kind: "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("body")),
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+            });
+        }
+        case "impl_item": {
+            // Surface impl methods as `Type::method` so the association is visible.
+            const typeNode = node.childForFieldName("type");
+            const typeName = typeNode ? typeNode.text : "";
+            const body = node.childForFieldName("body");
+            const out = [];
+            if (body) {
+                for (const m of namedChildren(body)) {
+                    if (m.type !== "function_item")
+                        continue;
+                    const mName = nameOf(m) ?? "(fn)";
+                    out.push(makeSymbol({
+                        name: typeName ? `${typeName}::${mName}` : mName,
+                        kind: "method",
+                        node: m,
+                        rawKind: m.type,
+                        signature: headerSignature(m, m.childForFieldName("body")),
+                        visibility: vis(m),
+                        exported: isPub(m),
+                        doc: leadingComment(m),
+                    }));
+                }
+            }
+            return out;
+        }
+        case "const_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(const)",
+                kind: "const",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("value")),
+                visibility: vis(node),
+                exported: isPub(node),
+            });
+        case "static_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(static)",
+                kind: "var",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("value")),
+                visibility: vis(node),
+                exported: isPub(node),
+            });
+        case "type_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(type)",
+                kind: "type",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, null),
+                visibility: vis(node),
+                exported: isPub(node),
+            });
+        case "mod_item": {
+            // Flatten module contents to the top level.
+            const body = node.childForFieldName("body");
+            return body ? collect(namedChildren(body)) : null;
+        }
+        default:
+            return null;
+    }
+}
+function structFields(list) {
+    const out = [];
+    for (const field of namedChildren(list)) {
+        if (field.type !== "field_declaration")
+            continue;
+        const name = nameOf(field);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind: "field",
+            node: field,
+            rawKind: field.type,
+            signature: field.text.replace(/\s+/g, " ").trim(),
+            visibility: vis(field),
+            exported: isPub(field),
+        }));
+    }
+    return out;
+}
+function traitMethods(body) {
+    const out = [];
+    for (const m of namedChildren(body)) {
+        if (m.type !== "function_signature_item" && m.type !== "function_item")
+            continue;
+        const name = nameOf(m);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind: "method",
+            node: m,
+            rawKind: m.type,
+            signature: headerSignature(m, m.childForFieldName("body")),
+            visibility: "public",
+            exported: true,
+        }));
+    }
+    return out;
+}

package/dist/extractors/swift.js

@@ -0,0 +1,192 @@
+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|fileprivate)\b/.test(m))
+        return "private";
+    return "public"; // treat internal/public/open as public
+}
+function exported(node) {
+    const m = modifiersText(node);
+    return /\b(public|open)\b/.test(m) || !/\b(private|fileprivate|internal)\b/.test(m);
+}
+/** Swift uses class_declaration for `class`, `struct`, `enum`, `actor`, `extension`. */
+function classDeclKind(node) {
+    const head = node.text.slice(0, 80);
+    if (/\bstruct\b/.test(head))
+        return "struct";
+    if (/\benum\b/.test(head))
+        return "enum";
+    const body = childOfType(node, "enum_class_body");
+    if (body)
+        return "enum";
+    return "class";
+}
+/* ─── imports ─────────────────────────────────────────────────────────────── */
+export function extractImportsSwift(root, _source) {
+    const out = [];
+    for (const c of namedChildren(root)) {
+        if (c.type !== "import_declaration")
+            continue;
+        const id = childOfType(c, "identifier");
+        const text = id ? id.text : c.text.replace(/^import\s+/, "").trim();
+        out.push({ symbol: text.split(".").pop() ?? text, from: text });
+    }
+    return out;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractSwift(root, _source) {
+    return collect(namedChildren(root), false);
+}
+function collect(nodes, insideClass) {
+    const out = [];
+    for (const n of nodes) {
+        const res = handle(n, insideClass);
+        if (res)
+            out.push(res);
+    }
+    return out;
+}
+function handle(node, insideClass) {
+    switch (node.type) {
+        case "class_declaration": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const kind = classDeclKind(node);
+            const body = childOfType(node, "class_body") ?? childOfType(node, "enum_class_body");
+            return makeSymbol({
+                name,
+                kind,
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body), true) : [],
+            });
+        }
+        case "protocol_declaration": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const body = childOfType(node, "protocol_body");
+            const kids = [];
+            if (body) {
+                for (const m of namedChildren(body)) {
+                    if (m.type === "protocol_function_declaration") {
+                        const n = nameOf(m);
+                        if (n) {
+                            kids.push(makeSymbol({
+                                name: n,
+                                kind: "method",
+                                node: m,
+                                rawKind: m.type,
+                                signature: headerSignature(m, null),
+                                visibility: "public",
+                                exported: true,
+                            }));
+                        }
+                    }
+                }
+            }
+            return makeSymbol({
+                name,
+                kind: "interface",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: kids,
+            });
+        }
+        case "function_declaration": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const body = childOfType(node, "function_body");
+            return makeSymbol({
+                name,
+                kind: insideClass ? "method" : "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, body),
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+            });
+        }
+        case "init_declaration": {
+            return makeSymbol({
+                name: "init",
+                kind: "method",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, childOfType(node, "function_body")),
+                visibility: vis(node),
+                exported: exported(node),
+            });
+        }
+        case "property_declaration": {
+            // name is `pattern` field; the pattern contains simple_identifier
+            const pat = node.childForFieldName("name");
+            let name = null;
+            if (pat) {
+                const id = pat.type === "simple_identifier" ? pat : findFirstNamed(pat, "simple_identifier");
+                name = id ? id.text : null;
+            }
+            if (!name)
+                return null;
+            const isLet = /\blet\b/.test(node.text.slice(0, 30));
+            return makeSymbol({
+                name,
+                kind: insideClass ? "field" : (isLet ? "const" : "var"),
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").trim(),
+                visibility: vis(node),
+                exported: exported(node),
+            });
+        }
+        case "enum_entry": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "field",
+                node,
+                rawKind: node.type,
+            });
+        }
+        default:
+            return null;
+    }
+}
+function findFirstNamed(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c)
+            continue;
+        if (c.type === type)
+            return c;
+        const deep = findFirstNamed(c, type);
+        if (deep)
+            return deep;
+    }
+    return null;
+}