@nanonets/graft 0.13.0 → 0.16.0

package/dist/graph/extract.js

@@ -13,6 +13,7 @@ import Go from "tree-sitter-go";
 import R from "tree-sitter-r";
 import Java from "tree-sitter-java";
 import Kotlin from "tree-sitter-kotlin";
+import Swift from "tree-sitter-swift";
 import PHP from "tree-sitter-php";
 import { basename } from "node:path";
 import { contentHash } from "../util/id.js";
@@ -47,6 +48,7 @@ const EXTENSIONS = [
     { ext: ".java", grammar: "java", label: "java" },
     { ext: ".kt", grammar: "kotlin", label: "kotlin" },
     { ext: ".kts", grammar: "kotlin", label: "kotlin" },
+    { ext: ".swift", grammar: "swift", label: "swift" },
     { ext: ".php", grammar: "php", label: "php" },
     // `entryFor` lower-cases the path before matching, so this one entry covers
     // both `.R` (the conventional case in real R codebases) and `.r`.
@@ -164,6 +166,29 @@ const KOTLIN_KINDS = {
  * "class" also covers object_declaration (it maps to "class"); interface/enum are the
  * same class_declaration node rekinded in describeKotlin, so all three land in the set. */
 const KOTLIN_TYPE_KINDS = new Set(["class", "interface", "enum"]);
+const SWIFT_KINDS = {
+    class_declaration: "class", // → "struct" / "enum" in describeSwift (one node type covers all five keywords)
+    protocol_declaration: "interface",
+    function_declaration: "function", // → "method" inside a type (resolved in the walk)
+    protocol_function_declaration: "method", // a protocol requirement is always a member
+    init_declaration: "method", // the type's own initializer (named after it, like a Java constructor)
+    typealias_declaration: "type",
+    property_declaration: "variable", // top-level `let`/`var` only (fields resolved in the walk)
+};
+/** Swift type declarations: they set `enclosingClass` for the members nested in them.
+ * class/struct/enum are the same class_declaration node rekinded in describeSwift
+ * (an actor takes "class"); protocols are "interface". "module" is an extension
+ * body — a member-contributing scope named after the extended type, deliberately
+ * NOT a type kind in the graph so it can never make the real declaration's name
+ * ambiguous (see describeSwift's extension branch) — but its members still
+ * promote to methods owned by that type, which is why it belongs in this set. */
+const SWIFT_TYPE_KINDS = new Set([
+    "class",
+    "struct",
+    "enum",
+    "interface",
+    "module",
+]);
 // PHP: definition node types are all distinct (no py-style function→method
 // promotion needed — a class body uses `method_declaration`, not
 // `function_definition`). `trait_declaration` maps to the PHP-only `trait` kind.
@@ -183,6 +208,7 @@ const KINDS_BY_LANG = {
     r: R_KINDS,
     java: JAVA_KINDS,
     kotlin: KOTLIN_KINDS,
+    swift: SWIFT_KINDS,
     php: PHP_KINDS,
 };
 /**
@@ -201,6 +227,7 @@ const CALL_TYPES = {
     go: new Set(["call_expression"]),
     java: new Set(["method_invocation", "object_creation_expression"]),
     kotlin: new Set(["call_expression"]),
+    swift: new Set(["call_expression"]),
     php: new Set([
         "function_call_expression",
         "member_call_expression",
@@ -225,6 +252,7 @@ const GRAMMARS = {
     r: R,
     java: Java,
     kotlin: Kotlin,
+    swift: Swift,
     php: PHP.php,
 };
 /** tree-sitter's string `parse()` fails with "Invalid argument" on any input
@@ -429,9 +457,11 @@ function walk(node, ctx, out, edges, minted) {
                             ? javaExported(node)
                             : ctx.lang === "kotlin"
                                 ? kotlinExported(node)
-                                : ctx.lang === "php"
-                                    ? phpExported(node)
-                                    : tsExported(node),
+                                : ctx.lang === "swift"
+                                    ? swiftExported(node)
+                                    : ctx.lang === "php"
+                                        ? phpExported(node)
+                                        : tsExported(node),
             origin: "ast",
             body_hash: contentHash(desc.hashNode.text),
             body_text: searchBody(desc.hashNode.text),
@@ -448,11 +478,14 @@ function walk(node, ctx, out, edges, minted) {
         // may `implements`, so every type declaration is a heritage site, not just a class.
         const javaTypeDecl = ctx.lang === "java" && JAVA_TYPE_KINDS.has(desc.kind);
         const kotlinTypeDecl = ctx.lang === "kotlin" && KOTLIN_TYPE_KINDS.has(desc.kind);
-        if (desc.kind === "class" || javaTypeDecl || kotlinTypeDecl)
+        const swiftTypeDecl = ctx.lang === "swift" && SWIFT_TYPE_KINDS.has(desc.kind);
+        if (desc.kind === "class" || javaTypeDecl || kotlinTypeDecl || swiftTypeDecl)
             edges.push(...heritageEdges(node, id, ctx));
         if (ctx.lang === "php")
             edges.push(...phpAttributeReferenceEdges(node, id, ctx));
-        const enclosingClass = desc.kind === "class" || javaTypeDecl || kotlinTypeDecl
+        if (ctx.lang === "java")
+            edges.push(...javaAnnotationReferenceEdges(node, id, ctx));
+        const enclosingClass = desc.kind === "class" || javaTypeDecl || kotlinTypeDecl || swiftTypeDecl
             ? desc.name
             : isGoMethod
                 ? goReceiverType(node)
@@ -474,9 +507,17 @@ function walk(node, ctx, out, edges, minted) {
             // defined inside one).
             rR6Access: null,
             // Unlike rR6Access, only reset when entering a genuinely new class (so it
-            // stays live through a method's whole body, where super$ calls actually
-            // happen) — inherited unchanged for every other definition kind.
-            rSuperClass: desc.kind === "class" ? (ctx.lang === "r" ? rR6ParentClass(node) : null) : ctx.rSuperClass,
+            // stays live through a method's whole body, where super$ / super. calls
+            // actually happen) — inherited unchanged for every other definition kind.
+            // Swift reads it off the declaration's own `:` clause, so `super.ping()`
+            // resolves against the PARENT type, not the overriding current one.
+            rSuperClass: desc.kind === "class"
+                ? ctx.lang === "r"
+                    ? rR6ParentClass(node)
+                    : ctx.lang === "swift"
+                        ? swiftSuperClassName(node)
+                        : null
+                : ctx.rSuperClass,
         };
         walkNamedChildren(node.namedChildren, childCtx, out, edges, minted);
         return;
@@ -541,12 +582,44 @@ function walk(node, ctx, out, edges, minted) {
                 file: ctx.rel,
                 ...(callee.kinds ? { kinds: callee.kinds } : {}),
             };
-            // Java only: the call site's argument count, to pick the right overload.
-            const argCount = ctx.lang === "java" ? javaArgCount(node) : undefined;
+            // Overloading languages: the call site's argument count, to pick the right
+            // overload (see RawEdge.argCount).
+            const argCount = ctx.lang === "java" ? javaArgCount(node) : ctx.lang === "swift" ? swiftArgCount(node) : undefined;
             if (argCount !== undefined)
                 callEdge.argCount = argCount;
-            const recvType = resolveRecvType(callee.receiver, ctx);
-            edges.push(recvType ? { ...callEdge, recvType } : callEdge);
+            // Swift: a bare lowercase call inside a type body may be an implicit-`self`
+            // member call (`walk()` for `self.walk()`), syntactically indistinguishable
+            // from a free-function call — and Swift's own lookup is member-FIRST (inner
+            // scope wins). So the edge is emitted as the member reading, typed to the
+            // enclosing class — resolved through the owner-qualified method index and
+            // the class's in-repo ancestor chain (`clearLogs()` in a test subclass
+            // finds the base class's method) — with `implicitSelf` letting resolve.ts
+            // fall back to the free-function reading only when no member exists on the
+            // chain. One edge, both readings, language-order precedence. This is
+            // deliberately NOT a bare-name kind widening: dogfooding on
+            // swift-composable-architecture, a global unique-name match bound
+            // `contains(element)` inside `extension Set` — a stdlib call — to an
+            // unrelated type's only in-repo `contains`. And not for an UpperCamelCase
+            // callee: that is an initializer call (`Text("hi")`), which takes
+            // resolve.ts's class/struct/enum fallback instead — extension nodes (kind
+            // "module") can never false-match it.
+            const swiftImplicitSelf = ctx.lang === "swift" &&
+                !callee.viaMember &&
+                !callee.kinds &&
+                ctx.enclosingClass &&
+                !/^[A-Z]/.test(callee.name);
+            if (swiftImplicitSelf) {
+                edges.push({
+                    ...callEdge,
+                    viaMember: true,
+                    recvType: ctx.enclosingClass,
+                    implicitSelf: true,
+                });
+            }
+            else {
+                const recvType = resolveRecvType(callee.receiver, ctx);
+                edges.push(recvType ? { ...callEdge, recvType } : callEdge);
+            }
         }
     }
     else if (ctx.lang === "php" && node.type === "use_declaration") {
@@ -750,6 +823,38 @@ function phpAttributeClassRef(attr, ctx) {
         return { name: imported.name, specifier: imported.specifier };
     return { name: bare };
 }
+/** Java annotations on a definition → `references` edges to the annotation type. */
+function javaAnnotationReferenceEdges(node, sourceId, ctx) {
+    const edges = [];
+    const mods = node.namedChildren.find((c) => c.type === "modifiers");
+    if (!mods)
+        return edges;
+    for (const child of mods.namedChildren) {
+        if (child.type !== "marker_annotation" && child.type !== "annotation")
+            continue;
+        const name = javaAnnotationTypeName(child);
+        if (name) {
+            edges.push({
+                source: sourceId,
+                relation: "references",
+                name,
+                file: ctx.rel,
+            });
+        }
+    }
+    return edges;
+}
+/** The type named by `@Foo` / `@a.b.Foo(...)`. Arguments are ignored (issue #89).
+ * A scoped name is kept whole, matching heritage: a bare last segment would
+ * false-match an unrelated in-repo type (#103). */
+function javaAnnotationTypeName(anno) {
+    const nameNode = anno.childForFieldName("name");
+    if (!nameNode)
+        return null;
+    if (nameNode.type === "identifier" || nameNode.type === "scoped_identifier")
+        return nameNode.text;
+    return null;
+}
 function collectTsImportBindings(node, specifier, out) {
     if (node.type === "import_specifier") {
         const name = node.childForFieldName("name")?.text;
@@ -846,6 +951,8 @@ function describe(node, ctx) {
         return describeJava(node, ctx);
     if (ctx.lang === "kotlin")
         return describeKotlin(node, ctx);
+    if (ctx.lang === "swift")
+        return describeSwift(node, ctx);
     // PHP closures: `$h = function () {…}` / `fn() => …`, and bare callbacks
     // (`$routes->get('/x', function () {…})`). Captured as function nodes so a
     // closure-only file (a routing table, a DI container) keeps its structure
@@ -1489,6 +1596,121 @@ function describeKotlin(node, ctx) {
     }
     return null;
 }
+/** Swift definition shapes. Like Kotlin's, tree-sitter-swift exposes no `name` or
+ * `body` fields: a definition's name is a direct `type_identifier` (types) or
+ * `simple_identifier` (functions) child, and its body is a `class_body` /
+ * `enum_class_body` / `protocol_body` / `function_body` child. One
+ * `class_declaration` node type covers `class`, `struct`, `enum`, `actor` AND
+ * `extension` — the declaration's own keyword token tells them apart. */
+function describeSwift(node, ctx) {
+    // The first direct `type_identifier` is the declared name (generic parameters and
+    // inheritance specifiers are all nested beneath other child nodes).
+    const typeName = () => node.namedChildren.find((c) => c.type === "type_identifier")?.text ?? null;
+    // The first direct `simple_identifier` is the function name (parameters and
+    // generic parameters are all nested beneath other child nodes).
+    const funcName = () => node.namedChildren.find((c) => c.type === "simple_identifier")?.text ?? null;
+    const headEnd = (...types) => {
+        const body = node.namedChildren.find((c) => types.includes(c.type));
+        return body ? body.startIndex : node.endIndex;
+    };
+    if (node.type === "class_declaration") {
+        const kw = node.children.find((c) => c.type === "class" ||
+            c.type === "struct" ||
+            c.type === "enum" ||
+            c.type === "actor" ||
+            c.type === "extension")?.type;
+        let name;
+        if (kw === "extension") {
+            // `extension Point { … }` has no name of its own — the extended type's IS its
+            // identity, so the node takes that name: members mint as `Point.method`,
+            // `enclosingClass` becomes `Point`, and a member call on a Point receiver
+            // resolves to them exactly as if they were declared on the type. A qualified
+            // target (`extension Swift.Array`) reduces to its last component, matching
+            // how the extended type is itself named in the graph.
+            //
+            // Its KIND is "module", not "class": the type usually already has a real
+            // declaration, and a second same-named "class" node would make the name
+            // AMBIGUOUS to resolveName — every `Point(...)` initializer call and every
+            // `: Point` heritage target would then drop instead of resolving (resolve
+            // never guesses between same-named candidates). "module" keeps the node out
+            // of type-name resolution entirely while SWIFT_TYPE_KINDS still makes it
+            // own its members; typed member calls are untouched either way, since they
+            // go through the owner-qualified method index, not the type's own node.
+            const ut = node.namedChildren.find((c) => c.type === "user_type");
+            const ids = ut?.namedChildren.filter((c) => c.type === "type_identifier") ?? [];
+            name = ids.length ? ids[ids.length - 1].text : null;
+        }
+        else {
+            name = typeName();
+        }
+        if (!name)
+            return null;
+        // An actor is class-like (reference semantics, methods) and there is no
+        // dedicated actor kind, so it takes "class".
+        const kind = kw === "extension" ? "module" : kw === "struct" ? "struct" : kw === "enum" ? "enum" : "class";
+        return { name, kind, headerEnd: headEnd("class_body", "enum_class_body"), hashNode: node };
+    }
+    if (node.type === "protocol_declaration") {
+        const name = typeName();
+        if (!name)
+            return null;
+        return { name, kind: "interface", headerEnd: headEnd("protocol_body"), hashNode: node };
+    }
+    // A protocol requirement (`protocol_function_declaration`) has no body and is
+    // always a member; an ordinary `function_declaration` is a method exactly when
+    // it is nested in a type (or an extension of one).
+    if (node.type === "function_declaration" || node.type === "protocol_function_declaration") {
+        const name = funcName();
+        if (!name)
+            return null;
+        const kind = node.type === "protocol_function_declaration" ||
+            SWIFT_TYPE_KINDS.has(ctx.enclosingKind ?? "file")
+            ? "method"
+            : "function";
+        return {
+            name,
+            kind,
+            headerEnd: headEnd("function_body"),
+            hashNode: node,
+            ...swiftArity(node),
+        };
+    }
+    if (node.type === "init_declaration") {
+        // Initializers carry no name of their own — they are the type's own, so scope
+        // the node under the enclosing type the same way Java's constructor_declaration
+        // does. (A protocol's `init` requirement lands here too, owned by the protocol.)
+        if (!ctx.enclosingClass)
+            return null;
+        return {
+            name: ctx.enclosingClass,
+            kind: "method",
+            headerEnd: headEnd("function_body"),
+            hashNode: node,
+            ...swiftArity(node),
+        };
+    }
+    if (node.type === "typealias_declaration") {
+        const name = typeName();
+        if (!name)
+            return null;
+        return { name, kind: "type", headerEnd: node.endIndex, hashNode: node };
+    }
+    if (node.type === "property_declaration") {
+        // Top-level `let`/`var` only — a stored/computed property inside a type is a
+        // field, not a definition node (no depth tier emits fields), so it must not
+        // become one. `deinit` and `subscript` are likewise skipped: neither is ever
+        // the target of a resolvable call edge, and neither carries a usable name.
+        if (ctx.enclosingKind !== null)
+            return null;
+        const name = node.namedChildren
+            .find((c) => c.type === "pattern")
+            ?.namedChildren.find((c) => c.type === "simple_identifier")?.text;
+        if (!name)
+            return null;
+        return { name, kind: "variable", headerEnd: node.endIndex, hashNode: node };
+    }
+    return null;
+}
 /** Java visibility: `public` (or `protected`) on the declaration's own modifier list.
  * A package-private or private member is not part of the API surface. Read off the
  * `modifiers` child's tokens, ignoring annotations, which live in the same node. */
@@ -1507,6 +1729,56 @@ function kotlinExported(node) {
     const vis = mods.namedChildren.find((c) => c.type === "visibility_modifier");
     return !vis || vis.text === "public";
 }
+/** Declared parameter count for a Swift callable, for overload disambiguation
+ * (the same role Java's `arity`/`argCount` pair plays). `parameter` nodes are
+ * direct children of the declaration; a default value's `=` sits as a SIBLING
+ * token after its parameter, and a variadic `...` sits inside its parameter.
+ * `arity` is the REQUIRED minimum (parameters minus defaults) and `variadic`
+ * marks any default or variadic parameter, so `narrowByArity`'s at-least
+ * semantics keeps every overload a call of that shape could reach. */
+function swiftArity(node) {
+    const params = node.children.filter((c) => c.type === "parameter");
+    const defaults = node.children.filter((c) => c.type === "=").length;
+    const hasVariadic = params.some((p) => p.children.some((c) => c.type === "..."));
+    const arity = Math.max(0, params.length - defaults);
+    return hasVariadic || defaults > 0 ? { arity, variadic: true } : { arity };
+}
+/** Argument count at a Swift call site: the `value_argument`s plus one for a
+ * trailing closure (`run(x) { … }` calls a two-parameter function). */
+function swiftArgCount(node) {
+    const suffix = node.namedChildren.find((c) => c.type === "call_suffix");
+    if (!suffix)
+        return undefined;
+    const args = suffix.namedChildren
+        .find((c) => c.type === "value_arguments")
+        ?.namedChildren.filter((c) => c.type === "value_argument").length ?? 0;
+    const trailing = suffix.namedChildren.some((c) => c.type === "lambda_literal") ? 1 : 0;
+    return args + trailing;
+}
+/** Swift visibility: the default (`internal`) is module-wide, and a repo is
+ * typically one module — so `public` / `open` / `package` / `internal` all count
+ * as API surface, and only an explicit `private` / `fileprivate` hides a
+ * definition. A setter-only restriction (`private(set)`) leaves the getter
+ * visible, so it does not hide the symbol either. */
+function swiftExported(node) {
+    const mods = node.namedChildren.find((c) => c.type === "modifiers");
+    const vis = mods?.namedChildren.find((c) => c.type === "visibility_modifier");
+    return !vis || (vis.text !== "private" && vis.text !== "fileprivate");
+}
+/** The superclass a Swift class declaration names: its FIRST inheritance
+ * specifier — Swift's grammar requires the superclass to precede any protocol
+ * in the `:` list, so when a superclass exists it is always this entry. A
+ * class conforming only to protocols yields that protocol's name instead, but
+ * `super` is illegal in such a class, so no call site ever consults it. Null
+ * for a bare `class Foo` (and for an extension, whose declaration carries no
+ * heritage for the original type — `super` inside one stays unresolved). */
+function swiftSuperClassName(node) {
+    const spec = node.namedChildren.find((c) => c.type === "inheritance_specifier");
+    const ids = spec?.namedChildren
+        .find((c) => c.type === "user_type")
+        ?.namedChildren.filter((c) => c.type === "type_identifier");
+    return ids?.length ? ids[ids.length - 1].text : null;
+}
 /** The receiver's base type name for a Go method, unwrapping a pointer receiver
  * (`func (u *User) …` → `User`). Null if it can't be read. */
 function goReceiverType(node) {
@@ -1593,6 +1865,27 @@ function heritageEdges(node, classId, ctx) {
         }
         return edges;
     }
+    if (ctx.lang === "swift") {
+        // `class A: B, C` — each `inheritance_specifier` (a direct child of the
+        // declaration; protocols and extensions carry them too) wraps a `user_type`
+        // whose LAST direct `type_identifier` is the bare supertype name: a
+        // module-qualified `Foundation.NSObject` reduces to `NSObject`, and generic
+        // arguments live in nested nodes so they never leak in. Swift cannot say
+        // syntactically whether a specifier is the superclass or a protocol
+        // conformance (that needs the target's kind), so every edge is `extends` —
+        // the same collapse Kotlin's delegation specifiers make.
+        for (const child of node.namedChildren) {
+            if (child.type !== "inheritance_specifier")
+                continue;
+            const ids = child.namedChildren
+                .find((c) => c.type === "user_type")
+                ?.namedChildren.filter((c) => c.type === "type_identifier");
+            const t = ids?.length ? ids[ids.length - 1] : undefined;
+            if (t)
+                edges.push({ source: classId, relation: "extends", name: t.text, file: ctx.rel });
+        }
+        return edges;
+    }
     if (ctx.lang === "python") {
         const supers = node.childForFieldName("superclasses"); // argument_list
         for (const c of supers?.namedChildren ?? []) {
@@ -1758,6 +2051,47 @@ function calleeName(node, lang) {
         }
         return null;
     }
+    if (lang === "swift") {
+        // Same shape as Kotlin's: `call_expression` = callee expression + `call_suffix`.
+        // A bare `foo()` names a plain call (this also covers `Animal()` initializer
+        // calls, which have no distinguishing syntax); `obj.foo()` is a
+        // `navigation_expression` whose trailing `navigation_suffix` holds the member
+        // name and whose head is the receiver.
+        const target = node.namedChildren[0];
+        if (target?.type === "simple_identifier")
+            return { name: target.text, viaMember: false };
+        if (target?.type === "navigation_expression") {
+            const suffix = target.namedChildren.find((c) => c.type === "navigation_suffix");
+            const name = suffix?.namedChildren.find((c) => c.type === "simple_identifier");
+            const receiver = target.namedChildren[0];
+            if (!name)
+                return null;
+            if (receiver?.type === "simple_identifier")
+                return { name: name.text, viaMember: true, receiver: receiver.text };
+            if (receiver?.type === "self_expression" || receiver?.type === "super_expression")
+                return {
+                    name: name.text,
+                    viaMember: true,
+                    receiver: receiver.type === "self_expression" ? "self" : "super",
+                };
+            if (receiver?.type === "navigation_expression") {
+                // `self.repo.save()` — one hop off self is a field access and binds like
+                // TS's `this.x`. Deeper chains and call-result receivers carry no
+                // confident local clue, so those fall through with no receiver.
+                const head = receiver.namedChildren[0];
+                const field = receiver.namedChildren
+                    .find((c) => c.type === "navigation_suffix")
+                    ?.namedChildren.find((c) => c.type === "simple_identifier");
+                if (head?.type === "self_expression" && field)
+                    return { name: name.text, viaMember: true, receiver: `self.${field.text}` };
+            }
+            // Still a member call even with an unknowable receiver (a chained call, a
+            // literal, a subscript): recvType stays unset and resolve drops it rather
+            // than guessing — same contract as Java's and TS's unknown receivers.
+            return { name: name.text, viaMember: true };
+        }
+        return null;
+    }
     if (lang === "php")
         return phpCallee(node);
     const fn = node.childForFieldName("function");
@@ -1987,6 +2321,8 @@ function isImport(node, lang) {
         return node.type === "import_declaration";
     if (lang === "kotlin")
         return node.type === "import_header";
+    if (lang === "swift")
+        return node.type === "import_declaration";
     // PHP: one edge per imported symbol — the clause leaf inside a (possibly
     // grouped) `use A\B, C\D;` / `use A\{B, C};` declaration.
     if (lang === "php")
@@ -2030,6 +2366,14 @@ function importSpecifier(node, lang) {
         // identifier text is already the module path (wildcards dropped, like Java).
         return node.namedChildren.find((c) => c.type === "identifier")?.text ?? null;
     }
+    if (lang === "swift") {
+        // `import UIKit` / `import struct Foundation.Date` — the dotted path is the
+        // `identifier` child (an import-kind keyword like `struct` is a separate
+        // token). Swift imports name MODULES, not files, so the specifier resolves
+        // to a repo file only when a same-named module target exists; external
+        // frameworks stay as unresolved (but truthful) import intents.
+        return node.namedChildren.find((c) => c.type === "identifier")?.text ?? null;
+    }
     const str = node.namedChildren.find((c) => c.type === "string");
     if (!str)
         return null;