@nanonets/graft 0.12.1 → 0.15.0

package/dist/graph/extract.js

@@ -10,7 +10,10 @@ import Parser from "tree-sitter";
 import TypeScript from "tree-sitter-typescript";
 import Python from "tree-sitter-python";
 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";
@@ -43,7 +46,13 @@ const EXTENSIONS = [
     { ext: ".py", grammar: "python", label: "python" },
     { ext: ".go", grammar: "go", label: "go" },
     { 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`.
+    { ext: ".r", grammar: "r", label: "r" },
 ];
 function entryFor(path) {
     const p = path.toLowerCase();
@@ -124,6 +133,11 @@ const GO_KINDS = {
     function_declaration: "function",
     method_declaration: "method",
 };
+// R: `function_definition` carries no name field at all (unlike every other
+// supported language) — its identifier always comes from context (an
+// assignment's other side), resolved dynamically in describeR(). Empty, like
+// Go's own table — never consulted, kept only to satisfy KINDS_BY_LANG's type.
+const R_KINDS = {};
 // Java: a record is a nominal data carrier, so it takes "struct" — the same role
 // Go's struct plays — rather than "class", which would make a service and a DTO
 // indistinguishable in a repo where DTOs are most of the type surface.
@@ -140,6 +154,41 @@ const JAVA_KINDS = {
 /** Java type declarations: they set `enclosingClass` for the methods nested in them,
  * which "class"-only logic would miss for a record's or interface's members. */
 const JAVA_TYPE_KINDS = new Set(["class", "interface", "enum", "struct"]);
+const KOTLIN_KINDS = {
+    class_declaration: "class", // → "interface" / "enum" / "interface" (annotation) in describeKotlin
+    object_declaration: "class", // a singleton object is class-like (companion objects included)
+    function_declaration: "function", // → "method" inside a type (resolved in the walk)
+    secondary_constructor: "method", // the class's own secondary constructor
+    type_alias: "type",
+    property_declaration: "variable", // top-level `val`/`var` only (fields resolved in the walk)
+};
+/** Kotlin type declarations: they set `enclosingClass` for the members nested in them.
+ * "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.
@@ -156,7 +205,10 @@ const KINDS_BY_LANG = {
     tsx: TS_KINDS,
     python: PY_KINDS,
     go: GO_KINDS,
+    r: R_KINDS,
     java: JAVA_KINDS,
+    kotlin: KOTLIN_KINDS,
+    swift: SWIFT_KINDS,
     php: PHP_KINDS,
 };
 /**
@@ -174,12 +226,15 @@ const CALL_TYPES = {
     python: new Set(["call"]),
     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",
         "nullsafe_member_call_expression",
         "scoped_call_expression",
     ]),
+    r: new Set(["call"]),
 };
 const FUNCTION_VALUE_TYPES = new Set([
     "arrow_function",
@@ -187,13 +242,17 @@ const FUNCTION_VALUE_TYPES = new Set([
     "function_expression",
     "generator_function",
 ]);
+const EMPTY_SET = new Set();
 const parser = new Parser();
 const GRAMMARS = {
     typescript: TypeScript.typescript,
     tsx: TypeScript.tsx,
     python: Python,
     go: Go,
+    r: R,
     java: Java,
+    kotlin: Kotlin,
+    swift: Swift,
     php: PHP.php,
 };
 /** tree-sitter's string `parse()` fails with "Invalid argument" on any input
@@ -210,6 +269,7 @@ export function extractFile(rel, source, lang) {
     const root = parseSource(source);
     const bindings = collectBindings(root, lang);
     const importedSymbols = collectImportedSymbols(root, lang);
+    const rGenerics = lang === "r" ? collectRGenerics(root) : EMPTY_SET;
     const nodes = [
         {
             id: rel,
@@ -240,6 +300,9 @@ export function extractFile(rel, source, lang) {
         enclosingClass: null,
         goReceiverVar: null,
         importedSymbols,
+        rR6Access: null,
+        rGenerics,
+        rSuperClass: null,
     };
     // Every id minted this file, seeded with the file node's own id (`rel`) so a
     // top-level definition can never collide with it. Threaded as its own
@@ -247,8 +310,7 @@ export function extractFile(rel, source, lang) {
     // childCtx, so a by-ref Set there would read as ordinary inherited context
     // when it's actually accidental shared mutable state across the whole walk.
     const minted = new Set([rel]);
-    for (const child of root.namedChildren)
-        walk(child, ctx, nodes, rawEdges, minted);
+    walkNamedChildren(root.namedChildren, ctx, nodes, rawEdges, minted);
     // nodes[0] is the file node; the rest are its symbols. Index the module-level
     // residual on the file node so a term outside every symbol still surfaces it.
     nodes[0].body_text = fileResidual(source, nodes.slice(1));
@@ -268,6 +330,97 @@ export function mintId(base, minted) {
     minted.add(id);
     return id;
 }
+/**
+ * tree-sitter-php 0.23.x cannot parse a `const` inside an enum body (#145). An
+ * array initializer collapses the whole `enum_declaration` into ERROR; the
+ * method is recovered as a sibling `function_definition`. 0.24.2 parses this
+ * natively but is ABI 15 and cannot load on Graft's tree-sitter 0.21.1.
+ *
+ * Bound: only an ERROR that already contains `enum_case` + `name` is treated as
+ * a collapsed enum. Only `const_declaration` / `function_definition` /
+ * `method_declaration` / ERROR siblings are absorbed, stopping at a `}` ERROR.
+ * Unknown ERROR nodes are still walked, never mapped to a type. Clean
+ * class/enum trees are `class_declaration` / `enum_declaration` and skip this.
+ */
+function phpCollapsedEnumName(node) {
+    if (node.type !== "ERROR")
+        return null;
+    if (!node.namedChildren.some((c) => c.type === "enum_case"))
+        return null;
+    return node.namedChildren.find((c) => c.type === "name")?.text ?? null;
+}
+function phpCollapsedEnumHold(node) {
+    return (node.type === "const_declaration" ||
+        node.type === "function_definition" ||
+        node.type === "method_declaration" ||
+        node.type === "ERROR");
+}
+function phpCollapsedEnumClose(node) {
+    return node.type === "ERROR" && node.text.trim() === "}";
+}
+function walkNamedChildren(children, ctx, out, edges, minted) {
+    if (ctx.lang !== "php") {
+        for (const child of children)
+            walk(child, ctx, out, edges, minted);
+        return;
+    }
+    for (let i = 0; i < children.length;) {
+        const n = children[i];
+        const enumName = phpCollapsedEnumName(n);
+        if (enumName) {
+            const group = [n];
+            let j = i + 1;
+            while (j < children.length && phpCollapsedEnumHold(children[j])) {
+                const next = children[j];
+                group.push(next);
+                j++;
+                if (phpCollapsedEnumClose(next))
+                    break;
+            }
+            emitPhpCollapsedEnum(enumName, n, group, ctx, out, edges, minted);
+            i = j;
+            continue;
+        }
+        walk(n, ctx, out, edges, minted);
+        i++;
+    }
+}
+function emitPhpCollapsedEnum(name, errorNode, group, ctx, out, edges, minted) {
+    const last = group[group.length - 1];
+    const id = mintId(`${ctx.rel}#${[...ctx.scope, name].join(".")}`, minted);
+    const body = ctx.source.slice(errorNode.startIndex, last.endIndex);
+    out.push({
+        id,
+        name,
+        kind: "enum",
+        path: ctx.rel,
+        span: `L${errorNode.startPosition.row + 1}-L${last.endPosition.row + 1}`,
+        signature: `enum ${name}`,
+        exported: true,
+        origin: "ast",
+        body_hash: contentHash(body),
+        body_text: searchBody(body),
+        summary_state: "pending",
+        summary: null,
+        crux: null,
+    });
+    edges.push({ source: ctx.parentId, relation: "contains", targetId: id, file: ctx.rel });
+    const childCtx = {
+        ...ctx,
+        scope: [...ctx.scope, name],
+        enclosingKind: "enum",
+        parentId: id,
+    };
+    for (const g of group) {
+        if (phpCollapsedEnumClose(g))
+            continue;
+        if (phpCollapsedEnumName(g)) {
+            walkNamedChildren(g.namedChildren, childCtx, out, edges, minted);
+            continue;
+        }
+        walk(g, childCtx, out, edges, minted);
+    }
+}
 function walk(node, ctx, out, edges, minted) {
     const desc = describe(node, ctx);
     if (desc) {
@@ -279,10 +432,14 @@ function walk(node, ctx, out, edges, minted) {
         const isGoMethod = ctx.lang === "go" && node.type === "method_declaration";
         // The bare name of this node's OWN immediate enclosing class/receiver — for a
         // Go method that's its receiver type (methods aren't nested, so ctx.enclosingClass
-        // wouldn't see it); for every other method it's simply what the nearest ancestor
-        // class already set as ctx.enclosingClass. Only method nodes carry it — resolve.ts's
+        // wouldn't see it); for an R S3/S4 method it's the qualifier/class describeR
+        // already resolved (desc.owner — these don't lexically nest inside their class
+        // either); for every other method it's simply what the nearest ancestor class
+        // already set as ctx.enclosingClass. Only method nodes carry it — resolve.ts's
         // ownerMethod index is the sole consumer (see NodeV1.owner's doc comment).
-        const owner = desc.kind === "method" ? (isGoMethod ? (goReceiverType(node) ?? undefined) : (ctx.enclosingClass ?? undefined)) : undefined;
+        const owner = desc.kind === "method"
+            ? (isGoMethod ? (goReceiverType(node) ?? undefined) : (desc.owner ?? ctx.enclosingClass ?? undefined))
+            : undefined;
         out.push({
             id,
             name: desc.name,
@@ -294,11 +451,17 @@ function walk(node, ctx, out, edges, minted) {
                 ? !desc.name.startsWith("_")
                 : ctx.lang === "go"
                     ? goExported(desc.name)
-                    : ctx.lang === "java"
-                        ? javaExported(node)
-                        : ctx.lang === "php"
-                            ? phpExported(node)
-                            : tsExported(node),
+                    : ctx.lang === "r"
+                        ? rExported(desc.name, ctx, node)
+                        : ctx.lang === "java"
+                            ? javaExported(node)
+                            : ctx.lang === "kotlin"
+                                ? kotlinExported(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),
@@ -314,13 +477,19 @@ function walk(node, ctx, out, edges, minted) {
         // class heritage — in Java an interface may also `extends`, and a record/enum
         // 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);
-        if (desc.kind === "class" || javaTypeDecl)
+        const kotlinTypeDecl = ctx.lang === "kotlin" && KOTLIN_TYPE_KINDS.has(desc.kind);
+        const swiftTypeDecl = ctx.lang === "swift" && SWIFT_TYPE_KINDS.has(desc.kind);
+        if (desc.kind === "class" || javaTypeDecl || kotlinTypeDecl || swiftTypeDecl)
             edges.push(...heritageEdges(node, id, ctx));
-        const enclosingClass = desc.kind === "class" || javaTypeDecl
+        if (ctx.lang === "php")
+            edges.push(...phpAttributeReferenceEdges(node, id, ctx));
+        if (ctx.lang === "java")
+            edges.push(...javaAnnotationReferenceEdges(node, id, ctx));
+        const enclosingClass = desc.kind === "class" || javaTypeDecl || kotlinTypeDecl || swiftTypeDecl
             ? desc.name
             : isGoMethod
                 ? goReceiverType(node)
-                : ctx.enclosingClass;
+                : (desc.owner ?? ctx.enclosingClass);
         const childCtx = {
             ...ctx,
             scope: [...ctx.scope, idPart],
@@ -331,15 +500,79 @@ function walk(node, ctx, out, edges, minted) {
             importedSymbols: desc.kind === "function" || desc.kind === "method"
                 ? withoutShadowedImports(ctx.importedSymbols, node)
                 : ctx.importedSymbols,
+            // Reset on every new definition — this is a purely local marker for "we're
+            // still inside THIS class-defining call's own public=/private=/active=
+            // argument chain," not something that should leak into a nested definition
+            // (a method's own body, or — vanishingly rare but possible — another class
+            // 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$ / 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,
         };
-        for (const child of node.namedChildren)
-            walk(child, childCtx, out, edges, minted);
+        walkNamedChildren(node.namedChildren, childCtx, out, edges, minted);
         return;
     }
+    // R6 (Phase 2): `public =`/`private =`/`active =` inside an R6Class(...) call's
+    // own arguments is a `list(...)` call whose named entries become methods —
+    // this is R's version of a class body, but structurally it's several levels of
+    // ordinary call/argument nodes rather than a dedicated grammar construct, so it
+    // needs its own interception (mirrors how every other stateful/pattern-matched
+    // R construct in this walk needs one). `ctx.enclosingKind === "class"` scopes
+    // this to the class-defining call's own direct structure — once we're inside
+    // an actual method's body, enclosingKind has moved on to "method" and an
+    // unrelated nested `list(public = list(fn = function() {}))` elsewhere won't
+    // be misread as another class body.
+    if (ctx.lang === "r" &&
+        ctx.enclosingKind === "class" &&
+        ctx.rR6Access === null &&
+        node.type === "argument") {
+        const argName = node.childForFieldName("name");
+        const value = node.childForFieldName("value");
+        if (argName?.type === "identifier" &&
+            (argName.text === "public" || argName.text === "private" || argName.text === "active") &&
+            value?.type === "call" &&
+            rCalleeName(value) === "list") {
+            const access = argName.text;
+            for (const entry of rCallArgs(value)) {
+                walk(entry, { ...ctx, rR6Access: access }, out, edges, minted);
+            }
+            return;
+        }
+    }
     // not a definition — capture calls/imports/references, then descend with the same context
+    // R's `call` node is also its ONLY vehicle for library()/require()/source() —
+    // there's no separate import-statement grammar construct to key off, so isImport
+    // must be checked before the generic calls path or every import call would be
+    // captured as a (harmlessly unresolvable, but wrong) `calls` edge instead.
     const callTypes = CALL_TYPES[ctx.lang];
-    if (callTypes.has(node.type)) {
-        const callee = calleeName(node, ctx.lang);
+    if (isImport(node, ctx.lang)) {
+        const spec = importSpecifier(node, ctx.lang);
+        if (spec)
+            edges.push({ source: ctx.rel, relation: "imports", specifier: spec, file: ctx.rel });
+        // Imported identifiers are declarations, not uses. The import-binding pass
+        // above already recorded them, so do not descend and emit false references.
+        return;
+    }
+    else if (callTypes.has(node.type)) {
+        // R6Class(...) / a Phase-5 mixin list(...) is already consumed by its
+        // enclosing binary_operator as the class definition (see describeR) — the
+        // walk still reaches this SAME call node again, recursing generically to
+        // find its public=/private=/active= arguments (there's no other path to
+        // them), and it must not ALSO be treated as an ordinary call to a
+        // function literally named "R6Class"/"list".
+        const consumedCallee = ctx.lang === "r" && node.type === "call" ? rCalleeName(node) : null;
+        const isConsumedRClassCall = consumedCallee === "R6Class" || (consumedCallee === "list" && rIsMixinContainer(node));
+        const callee = isConsumedRClassCall ? null : calleeName(node, ctx.lang);
         if (callee) {
             const callEdge = {
                 source: ctx.parentId,
@@ -347,23 +580,48 @@ function walk(node, ctx, out, edges, minted) {
                 name: callee.name,
                 viaMember: callee.viaMember,
                 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 (isImport(node, ctx.lang)) {
-        const spec = importSpecifier(node, ctx.lang);
-        if (spec)
-            edges.push({ source: ctx.rel, relation: "imports", specifier: spec, file: ctx.rel });
-        // Imported identifiers are declarations, not uses. The import-binding pass
-        // above already recorded them, so do not descend and emit false references.
-        return;
-    }
     else if (ctx.lang === "php" && node.type === "use_declaration") {
         // Trait composition inside a class body (`use HasFactory, Notifiable;`).
         // Modelled as `implements`: like an interface, a trait is a contract of
@@ -389,6 +647,54 @@ function walk(node, ctx, out, edges, minted) {
             });
         }
     }
+    // Java anonymous class (`new Type() { … }`): tree-sitter-java has no
+    // `anonymous_class` node (unlike PHP) — the body is an optional `class_body`
+    // on `object_creation_expression`. Mint `{anonymous}` (mirroring PHP #144 /
+    // `{closure}`) so nested methods take that owner instead of the enclosing
+    // type's, which otherwise pollutes `ownerMethod` and steals real call edges
+    // (#161). The constructor call edge above still fires for `new Type()`.
+    if (ctx.lang === "java" && node.type === "object_creation_expression") {
+        const body = node.namedChildren.find((c) => c.type === "class_body");
+        if (body) {
+            const idPart = "{anonymous}";
+            const base = `${ctx.rel}#${[...ctx.scope, idPart].join(".")}`;
+            const id = mintId(base, minted);
+            out.push({
+                id,
+                name: "{anonymous}",
+                kind: "class",
+                path: ctx.rel,
+                span: `L${node.startPosition.row + 1}-L${node.endPosition.row + 1}`,
+                signature: clean(ctx.source.slice(node.startIndex, body.startIndex)),
+                exported: false,
+                origin: "ast",
+                body_hash: contentHash(node.text),
+                body_text: searchBody(node.text),
+                summary_state: "pending",
+                summary: null,
+                crux: null,
+            });
+            edges.push({ source: ctx.parentId, relation: "contains", targetId: id, file: ctx.rel });
+            // Single supertype from `new Type()`: emit `implements` so an interface
+            // target resolves (adapters are the common case; a class target drops
+            // under resolve's implements kind filter — drop-not-guess).
+            const superName = javaConstructedTypeName(node.childForFieldName("type"));
+            if (superName) {
+                edges.push({ source: id, relation: "implements", name: superName, file: ctx.rel });
+            }
+            const anonCtx = {
+                ...ctx,
+                scope: [...ctx.scope, idPart],
+                enclosingKind: "class",
+                parentId: id,
+                enclosingClass: "{anonymous}",
+            };
+            for (const child of node.namedChildren) {
+                walk(child, child.type === "class_body" ? anonCtx : ctx, out, edges, minted);
+            }
+            return;
+        }
+    }
     for (const child of node.namedChildren)
         walk(child, ctx, out, edges, minted);
 }
@@ -398,15 +704,32 @@ function walk(node, ctx, out, edges, minted) {
  * the exported symbol name, so wiring them would require guessing.
  */
 function collectImportedSymbols(root, lang) {
-    const out = new Map();
-    if (lang !== "typescript" && lang !== "tsx")
+    if (lang === "typescript" || lang === "tsx") {
+        const out = new Map();
+        const visit = (node) => {
+            if (node.type === "import_statement") {
+                const specifier = importSpecifier(node, lang);
+                if (!specifier)
+                    return;
+                collectTsImportBindings(node, specifier, out);
+                return;
+            }
+            for (const child of node.namedChildren)
+                visit(child);
+        };
+        visit(root);
         return out;
+    }
+    if (lang === "php")
+        return collectPhpImportedSymbols(root);
+    return new Map();
+}
+/** PHP `use` bindings: local alias → { exported name, FQN specifier }. */
+function collectPhpImportedSymbols(root) {
+    const out = new Map();
     const visit = (node) => {
-        if (node.type === "import_statement") {
-            const specifier = importSpecifier(node, lang);
-            if (!specifier)
-                return;
-            collectTsImportBindings(node, specifier, out);
+        if (node.type === "namespace_use_declaration") {
+            collectPhpUseDeclaration(node, out);
             return;
         }
         for (const child of node.namedChildren)
@@ -415,6 +738,123 @@ function collectImportedSymbols(root, lang) {
     visit(root);
     return out;
 }
+function collectPhpUseDeclaration(decl, out) {
+    const prefix = decl.namedChildren.find((c) => c.type === "namespace_name")?.text.replace(/\\$/, "") ?? "";
+    const clauses = [];
+    for (const child of decl.namedChildren) {
+        if (child.type === "namespace_use_clause")
+            clauses.push(child);
+        if (child.type === "namespace_use_group") {
+            for (const c of child.namedChildren) {
+                if (c.type === "namespace_use_clause")
+                    clauses.push(c);
+            }
+        }
+    }
+    for (const clause of clauses) {
+        const binding = phpUseClauseBinding(clause, prefix);
+        if (binding)
+            out.set(binding.local, { name: binding.name, specifier: binding.specifier });
+    }
+}
+function phpUseClauseBinding(clause, prefix) {
+    const names = clause.namedChildren.filter((c) => c.type === "name");
+    const qualified = clause.namedChildren.find((c) => c.type === "qualified_name");
+    let fqn;
+    let importedName;
+    if (qualified) {
+        fqn = qualified.text.replace(/^\\/, "");
+        importedName = fqn.replace(/^.*\\/, "");
+    }
+    else if (names[0]) {
+        importedName = names[0].text;
+        fqn = prefix ? `${prefix}\\${importedName}` : importedName;
+    }
+    else {
+        return null;
+    }
+    const alias = qualified && names.length >= 1
+        ? names[names.length - 1].text
+        : names.length >= 2
+            ? names[1].text
+            : undefined;
+    const local = alias ?? importedName;
+    return { local, name: importedName, specifier: fqn };
+}
+/** PHP 8 attributes on a definition → `references` edges to the attribute class. */
+function phpAttributeReferenceEdges(node, sourceId, ctx) {
+    const edges = [];
+    for (const child of node.namedChildren) {
+        if (child.type !== "attribute_list")
+            continue;
+        for (const group of child.namedChildren) {
+            if (group.type !== "attribute_group")
+                continue;
+            for (const attr of group.namedChildren) {
+                if (attr.type !== "attribute")
+                    continue;
+                const ref = phpAttributeClassRef(attr, ctx);
+                if (ref) {
+                    edges.push({
+                        source: sourceId,
+                        relation: "references",
+                        name: ref.name,
+                        ...(ref.specifier ? { specifier: ref.specifier } : {}),
+                        file: ctx.rel,
+                    });
+                }
+            }
+        }
+    }
+    return edges;
+}
+function phpAttributeClassRef(attr, ctx) {
+    const nameNode = attr.childForFieldName("name") ??
+        attr.namedChildren.find((c) => c.type === "name" || c.type === "qualified_name");
+    if (!nameNode)
+        return null;
+    if (nameNode.type === "qualified_name") {
+        const fqn = nameNode.text.replace(/^\\/, "");
+        return { name: fqn.replace(/^.*\\/, ""), specifier: fqn };
+    }
+    const bare = nameNode.text;
+    const imported = ctx.importedSymbols.get(bare);
+    if (imported)
+        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;
@@ -505,8 +945,14 @@ function isDeclarationName(node) {
 function describe(node, ctx) {
     if (ctx.lang === "go")
         return describeGo(node, ctx);
+    if (ctx.lang === "r")
+        return describeR(node, ctx);
     if (ctx.lang === "java")
         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
@@ -520,6 +966,21 @@ function describe(node, ctx) {
             hashNode: node,
         };
     }
+    // PHP anonymous classes (`new class implements I {…}`): minted as a class
+    // node named `{anonymous}` (mirroring `{closure}`, deduplicated per file by
+    // mintId). Without this the type vanished — no node, no heritage edge — and
+    // its methods mis-attributed to the enclosing function (issue #144). The
+    // class kind makes the walk emit heritageEdges (base_clause /
+    // class_interface_clause are direct children) and own the nested methods.
+    if (ctx.lang === "php" && node.type === "anonymous_class") {
+        const body = node.childForFieldName("body");
+        return {
+            name: "{anonymous}",
+            kind: "class",
+            headerEnd: body ? body.startIndex : node.endIndex,
+            hashNode: node,
+        };
+    }
     const mapped = ctx.kinds[node.type];
     if (mapped) {
         const name = node.childForFieldName("name")?.text;
@@ -529,6 +990,12 @@ function describe(node, ctx) {
         if (ctx.lang === "python" && mapped === "function" && ctx.enclosingKind === "class") {
             kind = "method";
         }
+        // tree-sitter-php 0.23.x recovers a collapsed enum method as function_definition
+        // at program scope; walkNamedChildren reparents it under the enum, and this
+        // promotion is what keeps the kind `method` rather than a leaked `function`.
+        if (ctx.lang === "php" && mapped === "function" && ctx.enclosingKind === "enum") {
+            kind = "method";
+        }
         const body = node.childForFieldName("body");
         return { name, kind, headerEnd: body ? body.startIndex : node.endIndex, hashNode: node };
     }
@@ -591,6 +1058,432 @@ function describeGo(node, _ctx) {
     }
     return null;
 }
+/**
+ * R definition shapes. `function_definition` carries no name field at all, so
+ * unlike every other supported language the name always comes from an
+ * enclosing assignment, detected here. The plain-function assignment check
+ * (op-filtering `binary_operator`, the right-assign body-swap) is duplicated
+ * in bindings.ts's own `rDefName` rather than imported — same reasoning as
+ * this file's Go receiver helpers: bindings.ts can't take a value import back
+ * on extract.ts. bindings.ts doesn't need the S3/S4/R6 half of this at all
+ * (no handleR binding collector exists — see bindings.ts's own doc comment).
+ *
+ * Phase 1 (flat extraction — every named function is a plain `function` node)
+ * plus Phase 2 (S3/S4/R6 class awareness, R's class systems being library
+ * *convention* rather than grammar syntax, unlike every other language graft
+ * supports):
+ *   - left-assign (`<-`/`<<-`/`=`) / right-assign (`->`/`->>`) function
+ *     assignment — Phase 1's shape, see the two `binary_operator`/
+ *     `function_definition` branches below. Right-assign's AST shape does NOT
+ *     mirror left-assign's the way it looks like it should (confirmed
+ *     empirically, not assumed — R's `->` has low enough precedence that it's
+ *     absorbed into the function's own `body` field as a `binary_operator`
+ *     instead of the function sitting inside an outer wrapper); only an
+ *     explicitly parenthesized `(function() {}) -> foo` produces the
+ *     "expected" outer-wrapping shape, which isn't specially handled (falls
+ *     through as an anonymous function).
+ *   - `name.Class <- function() {}` — an S3 method, IF `name` is a known
+ *     generic (registered locally via `UseMethod()` in this file, or one of a
+ *     curated set of common base-R generics — see `rS3Split`'s doc comment
+ *     for the false-positive risk this guards against).
+ *   - `Foo <- R6::R6Class("Foo", public = list(...), private = list(...))` —
+ *     an R6 class; its `public =`/`private =`/`active =` list entries become
+ *     methods, handled by walk()'s own `argument`-node interception (this
+ *     function only recognizes the class itself; the "a call defines a
+ *     symbol" list-walking lives in walk() since it needs to mint several
+ *     nodes, not describe a single one).
+ *   - `Foo <- list(public = list(...), private = list(...))` (Phase 5) — a
+ *     plain-list "mixin"/"extension" bundle, NOT wrapped in `R6::R6Class(...)`
+ *     at all: a real, deliberate convention found dogfooding against a real
+ *     R6-heavy corpus (25 files, 11 of them entirely invisible to the graph
+ *     without this) for sharing method bundles across classes via splicing
+ *     (`public = c(Foo$public, list(...))`) rather than `inherit =`. Only
+ *     recognized when the list actually has a `public =`/`private =` entry
+ *     (see `rIsMixinContainer`) — an ordinary data/config list never matches.
+ *     Reuses kind "class" (nothing better-fitting exists, and everything
+ *     downstream — the method-list walking, visibility — only cares that
+ *     ctx.enclosingKind is "class", not how the container was spelled); no
+ *     heritage edge, since splicing isn't `inherit =`-based inheritance.
+ *   - `setClass("Foo", ...)` / `setMethod("generic", "Foo", function() {})`
+ *     — S4 class/method calls, recognized as bare top-level `call` nodes
+ *     (setClass/setMethod have side effects registering with the S4 system;
+ *     they're essentially never assigned to a variable). `setGeneric()` is
+ *     NOT specially extracted — it doesn't naturally map to a class or method
+ *     kind, and the plan flags it as a case not worth the design risk.
+ */
+function describeR(node, ctx) {
+    if (node.type === "binary_operator") {
+        const op = node.childForFieldName("operator")?.text;
+        if (!op || !R_ASSIGN_OPS.has(op))
+            return null;
+        const lhs = node.childForFieldName("lhs");
+        const rhs = node.childForFieldName("rhs");
+        if (lhs?.type !== "identifier")
+            return null;
+        if (rhs?.type === "function_definition") {
+            return rFunctionDescriptor(lhs.text, rhs, rhs.childForFieldName("body"), ctx);
+        }
+        if (rhs?.type === "call" && rCalleeName(rhs) === "R6Class") {
+            // The class node itself; its public=/private=/active= method lists are
+            // handled by walk()'s own `argument`-node interception, not here.
+            return { name: lhs.text, kind: "class", headerEnd: rhs.endIndex, hashNode: rhs };
+        }
+        if (rhs?.type === "call" && rCalleeName(rhs) === "list" && rIsMixinContainer(rhs)) {
+            // Phase 5: a plain-list mixin/extension bundle — same treatment as R6Class.
+            return { name: lhs.text, kind: "class", headerEnd: rhs.endIndex, hashNode: rhs };
+        }
+        return null;
+    }
+    if (node.type === "function_definition") {
+        // Right-assign (`function() {} -> foo`): see this function's own doc
+        // comment for why this doesn't mirror the binary_operator branch above.
+        const body = node.childForFieldName("body");
+        if (body?.type !== "binary_operator")
+            return null;
+        const op = body.childForFieldName("operator")?.text;
+        if (!op || !R_RIGHT_ASSIGN_OPS.has(op))
+            return null;
+        const rhs = body.childForFieldName("rhs");
+        if (rhs?.type !== "identifier")
+            return null;
+        return rFunctionDescriptor(rhs.text, node, body.childForFieldName("lhs"), ctx);
+    }
+    if (node.type === "call") {
+        return describeRTopLevelCall(node);
+    }
+    // R6 (Phase 2): reached via walk()'s own `argument`-node interception for a
+    // `public =`/`private =`/`active =` list entry — see the special case there
+    // for why this can't just be a flat kind-table/node-type check like every
+    // other definition shape.
+    if (node.type === "argument" && ctx.rR6Access !== null) {
+        const argName = node.childForFieldName("name");
+        const value = node.childForFieldName("value");
+        if (argName?.type !== "identifier" || value?.type !== "function_definition")
+            return null;
+        const body = value.childForFieldName("body");
+        return {
+            name: argName.text,
+            kind: "method",
+            headerEnd: body ? body.startIndex : value.endIndex,
+            hashNode: value,
+            // owner deliberately unset — R6 methods DO lexically nest inside the
+            // class-defining call, so ctx.enclosingClass already has it.
+        };
+    }
+    return null;
+}
+const R_ASSIGN_OPS = new Set(["<-", "<<-", "="]);
+const R_RIGHT_ASSIGN_OPS = new Set(["->", "->>"]);
+/** A plain function assignment (left- or right-assign), OR — if `name` matches
+ * a known S3 generic's `generic.Class` pattern — an S3 method instead. `body`
+ * is the function's REAL content node (already resolved by the caller for
+ * either assignment direction), used only for `headerEnd`; `hashNode` is
+ * always the `function_definition` itself. */
+function rFunctionDescriptor(name, hashNode, body, ctx) {
+    const headerEnd = body ? body.startIndex : hashNode.endIndex;
+    const s3 = rS3Split(name, ctx.rGenerics);
+    if (s3) {
+        return {
+            name: s3.generic,
+            idName: `${s3.className}.${s3.generic}`,
+            kind: "method",
+            headerEnd,
+            hashNode,
+            owner: s3.className,
+        };
+    }
+    return { name, kind: "function", headerEnd, hashNode };
+}
+/**
+ * S3 dispatch detection: does `name` split as `generic.Class` for some KNOWN
+ * generic? Tries the longest possible generic prefix first (so a dotted
+ * generic itself, like `as.character`, is found before a shorter false match)
+ * and only ever matches a generic that's either registered locally via
+ * `UseMethod()` in this file (see `collectRGenerics`) or in the small curated
+ * `R_BASE_GENERICS` set below.
+ *
+ * This is the genuinely ambiguous part of R support the plan calls out:
+ * `read.csv`, `data.frame`, and `as.character` used as an ordinary helper
+ * name are NOT S3 dispatch, and nothing in the grammar distinguishes them
+ * from `print.MyClass`. Erring toward the curated set staying small — a
+ * missed S3 method (false negative, falls back to an ordinary `function`
+ * node) is a much smaller problem than a false positive misfiling an
+ * unrelated dotted-name function as some other class's method.
+ */
+function rS3Split(name, generics) {
+    const parts = name.split(".");
+    if (parts.length < 2)
+        return null;
+    for (let i = parts.length - 1; i >= 1; i--) {
+        const generic = parts.slice(0, i).join(".");
+        if (generics.has(generic) || R_BASE_GENERICS.has(generic)) {
+            return { generic, className: parts.slice(i).join(".") };
+        }
+    }
+    return null;
+}
+/** Common base-R S3 generics worth assuming even without local evidence —
+ * print.Foo/format.Foo etc. are the single most common real-world S3
+ * pattern, and a local `UseMethod()` call will never exist for them (they
+ * ship in base/methods/stats, not the user's own repo). Deliberately small
+ * and unsurprising rather than exhaustive — see `rS3Split`'s doc comment. */
+const R_BASE_GENERICS = new Set([
+    "print",
+    "format",
+    "summary",
+    "plot",
+    "str",
+    "toString",
+    "as.character",
+    "as.list",
+    "as.data.frame",
+    "as.vector",
+    "as.numeric",
+    "as.matrix",
+    "length",
+    "dim",
+    "names",
+    "rev",
+    "sort",
+    "unique",
+    "predict",
+    "coef",
+    "residuals",
+    "fitted",
+    "update",
+    "merge",
+    "all.equal",
+    "anova",
+    "confint",
+    "vcov",
+    "logLik",
+]);
+/** Every S3 generic THIS file registers via a local `UseMethod()` call, so
+ * `rS3Split` can recognize `generic.Class` methods for a repo's own generics,
+ * not just the base-R ones. Runs once per file, ahead of the main walk (same
+ * pre-pass shape as `collectImportedSymbols`). Cross-file generics — a
+ * generic defined in one file, dispatched on in another — aren't found this
+ * way; that would need a whole-repo pass extractFile has no visibility into,
+ * the same limitation Go/C++'s per-file bindings already accept. */
+function collectRGenerics(root) {
+    const generics = new Set();
+    const visit = (node) => {
+        let fnDef = null;
+        let ownName = null;
+        if (node.type === "binary_operator") {
+            const op = node.childForFieldName("operator")?.text;
+            const lhs = node.childForFieldName("lhs");
+            const rhs = node.childForFieldName("rhs");
+            if (op && R_ASSIGN_OPS.has(op) && lhs?.type === "identifier" && rhs?.type === "function_definition") {
+                fnDef = rhs;
+                ownName = lhs.text;
+            }
+        }
+        else if (node.type === "function_definition") {
+            const body = node.childForFieldName("body");
+            if (body?.type === "binary_operator") {
+                const op = body.childForFieldName("operator")?.text;
+                const rhs = body.childForFieldName("rhs");
+                if (op && R_RIGHT_ASSIGN_OPS.has(op) && rhs?.type === "identifier") {
+                    fnDef = node;
+                    ownName = rhs.text;
+                }
+            }
+        }
+        if (fnDef && ownName) {
+            const arg = findUseMethodArg(fnDef.childForFieldName("body"));
+            if (arg !== undefined)
+                generics.add(arg || ownName); // "" means UseMethod() with no args
+        }
+        for (const child of node.namedChildren)
+            visit(child);
+    };
+    visit(root);
+    return generics;
+}
+/** Searches a function body for a `UseMethod(...)` call and returns its
+ * string-literal generic-name argument, `""` if called with no arguments
+ * (defaults to the enclosing function's own name), or `undefined` if no
+ * `UseMethod` call is found at all. */
+function findUseMethodArg(node) {
+    if (!node)
+        return undefined;
+    if (node.type === "call" && rCalleeName(node) === "UseMethod") {
+        const first = rCallArgs(node)[0]?.childForFieldName("value");
+        return first?.type === "string" ? (rStringContent(first) ?? "") : "";
+    }
+    for (const child of node.namedChildren) {
+        const found = findUseMethodArg(child);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+/** S4: `setClass("Foo", ...)` → a class; `setMethod("generic", "Foo",
+ * function() {})` → a method owned by "Foo". Both are ordinary top-level
+ * `call` nodes — S4's registration functions have side effects and are
+ * essentially never assigned to a variable, unlike R6Class. */
+function describeRTopLevelCall(node) {
+    const callee = rCalleeName(node);
+    if (callee === "setClass") {
+        const first = rCallArgs(node)[0]?.childForFieldName("value");
+        const name = first?.type === "string" ? rStringContent(first) : null;
+        if (!name)
+            return null;
+        return { name, kind: "class", headerEnd: node.endIndex, hashNode: node };
+    }
+    if (callee === "setMethod") {
+        const args = rCallArgs(node);
+        const generic = args[0] ? rStringContent(args[0].childForFieldName("value") ?? null) : null;
+        const className = args[1] ? rStringContent(args[1].childForFieldName("value") ?? null) : null;
+        const defArg = args.find((a) => a.childForFieldName("name")?.text === "definition") ?? args[2];
+        const fnDef = defArg?.childForFieldName("value");
+        if (!generic || !className || fnDef?.type !== "function_definition")
+            return null;
+        const body = fnDef.childForFieldName("body");
+        return {
+            name: generic,
+            idName: `${className}.${generic}`,
+            kind: "method",
+            headerEnd: body ? body.startIndex : fnDef.endIndex,
+            hashNode: fnDef,
+            owner: className,
+        };
+    }
+    return null;
+}
+/** A call's callee name, whether bare (`R6Class(...)`) or namespace-qualified
+ * (`R6::R6Class(...)`). Null if the callee isn't a simple name (e.g. itself a
+ * call, or a `$`-based access). */
+function rCalleeName(node) {
+    const fn = node.childForFieldName("function");
+    if (fn?.type === "identifier")
+        return fn.text;
+    if (fn?.type === "namespace_operator") {
+        const rhs = fn.childForFieldName("rhs");
+        return rhs?.type === "identifier" ? rhs.text : null;
+    }
+    return null;
+}
+/** A call's positional/named `argument` children (skipping the `,`/`(`/`)`
+ * punctuation tokens that share the `arguments` node's child list). */
+function rCallArgs(node) {
+    return node.childForFieldName("arguments")?.namedChildren.filter((c) => c.type === "argument") ?? [];
+}
+/** An R `string` node's unquoted text, or null if `node` isn't a string. */
+function rStringContent(node) {
+    if (node?.type !== "string")
+        return null;
+    const content = node.namedChildren.find((c) => c.type === "string_content");
+    return content?.text ?? null;
+}
+/** The value of a call's named argument (`setClass("Foo", contains = "Base")`
+ * → the `contains` argument), or null if absent. */
+function rNamedArg(node, argName) {
+    const arg = rCallArgs(node).find((a) => a.childForFieldName("name")?.text === argName);
+    return arg?.childForFieldName("value") ?? null;
+}
+/** An R6 class-defining node's `inherit =` parent class name (a bare
+ * identifier — the parent's own generator variable, not a string), for
+ * `super$` call resolution (Phase 3). `node` is whatever describeR matched: a
+ * binary_operator for R6 (`Foo <- R6::R6Class(...)`) or, for any other kind of
+ * class (S4's setClass, which has no `super`), the call itself — always null
+ * there since `rCalleeName(call) !== "R6Class"`. */
+function rR6ParentClass(node) {
+    const call = node.type === "binary_operator" ? node.childForFieldName("rhs") : node;
+    if (call?.type !== "call" || rCalleeName(call) !== "R6Class")
+        return null;
+    const value = rNamedArg(call, "inherit");
+    return value?.type === "identifier" ? value.text : null;
+}
+/** Does this `list(...)` call look like a Phase-5 mixin/extension bundle —
+ * i.e. does it have a `public =` or `private =` entry whose own value is
+ * itself a `list(...)` call? This is the one check standing between "class-
+ * like container" and an ordinary data/config list (`list(a = 1, b = 2)`,
+ * or even one that happens to have a field named "public" holding something
+ * else) — real code never coincidentally shapes plain data this way, so it's
+ * a safe, precise signal without needing a naming-convention heuristic. */
+function rIsMixinContainer(node) {
+    return rCallArgs(node).some((a) => {
+        const name = a.childForFieldName("name")?.text;
+        if (name !== "public" && name !== "private")
+            return false;
+        const value = a.childForFieldName("value");
+        return value?.type === "call" && rCalleeName(value) === "list";
+    });
+}
+/** A base-class name list from either a bare string (`contains = "Base"`) or
+ * a `c(...)` call of strings (`contains = c("Base1", "Base2")`) — S4's
+ * multiple-inheritance form. */
+function rStringOrCVector(value) {
+    if (!value)
+        return [];
+    const single = rStringContent(value);
+    if (single)
+        return [single];
+    if (value.type === "call" && rCalleeName(value) === "c") {
+        return rCallArgs(value)
+            .map((a) => rStringContent(a.childForFieldName("value")))
+            .filter((s) => !!s);
+    }
+    return [];
+}
+/** R6 visibility follows the `public =`/`private =`/`active =` section a
+ * method was declared in (see walk()'s `argument`-node interception) —
+ * `ctx.rR6Access` is only set for that direct span, so a plain function or an
+ * S3/S4 method (neither of which has a real visibility concept) checks for a
+ * roxygen `@export` tag next (Phase 3), falling back to the leading-dot naming
+ * convention only when there's no roxygen evidence to go on at all. `node` is
+ * the exact node describeR matched — see `rRoxygenExported`'s doc comment for
+ * why that's always the right one to check for a preceding comment block. */
+function rExported(name, ctx, node) {
+    if (ctx.rR6Access !== null)
+        return ctx.rR6Access !== "private";
+    const roxygen = rRoxygenExported(node);
+    if (roxygen !== null)
+        return roxygen;
+    return !name.startsWith(".");
+}
+/**
+ * Roxygen `@export` detection (Phase 3): does `node` — a top-level definition
+ * statement (a `binary_operator` assignment, a right-assigned
+ * `function_definition`, or an S4 `setClass`/`setMethod` call) — have a
+ * roxygen doc block immediately preceding it, and if so, is it tagged
+ * `@export`?
+ *
+ * `comment` is a grammar EXTRA in this grammar (floats loosely between
+ * sibling nodes rather than attaching to "the next statement" via a field),
+ * so this walks backward through `previousNamedSibling` collecting a
+ * contiguous run of `comment` nodes — the run ends at the first non-comment
+ * sibling, or at the first comment that isn't itself a roxygen (`#'`) line,
+ * either of which is roxygen's own "this block documents the next statement"
+ * boundary.
+ *
+ * Returns:
+ *  - `true` — a roxygen block was found and it contains `@export`.
+ *  - `false` — a roxygen block was found but it does NOT contain `@export`.
+ *    This is deliberately a confident "not exported," not "unknown": roxygen
+ *    generates a package's NAMESPACE from exactly its `@export`-tagged items,
+ *    so a documented-but-untagged function is an explicit "internal, for
+ *    maintainers only" signal, not an absence of evidence.
+ *  - `null` — no roxygen block at all, so the caller should fall back to the
+ *    leading-dot naming convention instead of guessing.
+ */
+function rRoxygenExported(node) {
+    let sib = node.previousNamedSibling;
+    let sawRoxygen = false;
+    let exported = false;
+    while (sib?.type === "comment") {
+        const text = sib.text.trim();
+        if (!text.startsWith("#'"))
+            break; // an ordinary # comment ends the roxygen block
+        sawRoxygen = true;
+        if (/^#'\s*@export\b/.test(text))
+            exported = true;
+        sib = sib.previousNamedSibling;
+    }
+    return sawRoxygen ? exported : null;
+}
 /** Java definition shapes. Uniform in a way Go's are not: every declaration carries
  * a `name` field and (for types and most members) a `body`, so one mapped lookup
  * covers classes, interfaces, enums, records, methods, and constructors. Methods are
@@ -622,6 +1515,202 @@ function describeJava(node, ctx) {
     }
     return desc;
 }
+/** Kotlin definition shapes. Unlike Java's, tree-sitter-kotlin exposes no `name`
+ * or `body` fields: a definition's name is an unnamed `simple_identifier` (functions)
+ * or `type_identifier` (types) child, and its body is a `class_body` / `function_body`
+ * / `statements` child. `class_declaration` also folds classes, interfaces, and enum
+ * classes into one node type — the kind is read off the declaration's own keywords. */
+function describeKotlin(node, ctx) {
+    // The first direct `type_identifier` is the declared name (type parameters, primary
+    // constructor parameters and delegation specifiers are all nested beneath it).
+    const typeName = () => node.namedChildren.find((c) => c.type === "type_identifier")?.text ?? null;
+    // The first direct `simple_identifier` is the function name (receiver type, params
+    // and type parameters are all nested beneath other child nodes).
+    const funcName = () => node.namedChildren.find((c) => c.type === "simple_identifier")?.text ?? null;
+    // `class X : A, B()` heritage lives in `delegation_specifier` children; a nested
+    // type parameter's identifier is one of the same node type, so only direct children
+    // count as the declared name.
+    const headEnd = (type) => {
+        const body = node.namedChildren.find((c) => c.type === type);
+        return body ? body.startIndex : node.endIndex;
+    };
+    if (node.type === "class_declaration") {
+        const name = typeName();
+        if (!name)
+            return null;
+        let kind = "class";
+        if (node.namedChildren.some((c) => c.type === "enum_class_body"))
+            kind = "enum";
+        else if (node.children.some((c) => c.type === "interface"))
+            kind = "interface";
+        else {
+            const mods = node.namedChildren.find((c) => c.type === "modifiers");
+            // `annotation class` → the interface role Java's annotation_type_declaration plays.
+            if (mods?.namedChildren.some((c) => c.type === "class_modifier" && c.text === "annotation"))
+                kind = "interface";
+        }
+        const body = node.namedChildren.find((c) => c.type === "class_body" || c.type === "enum_class_body");
+        return { name, kind, headerEnd: body ? body.startIndex : node.endIndex, hashNode: node };
+    }
+    if (node.type === "object_declaration") {
+        const name = typeName();
+        if (!name)
+            return null;
+        return { name, kind: "class", headerEnd: headEnd("class_body"), hashNode: node };
+    }
+    if (node.type === "function_declaration") {
+        const name = funcName();
+        if (!name)
+            return null;
+        const kind = KOTLIN_TYPE_KINDS.has(ctx.enclosingKind ?? "file") ? "method" : "function";
+        return { name, kind, headerEnd: headEnd("function_body"), hashNode: node };
+    }
+    if (node.type === "secondary_constructor") {
+        // Constructors carry no name of their own — they are the class's own, so scope the
+        // node under the enclosing class the same way Java's constructor_declaration does.
+        if (!ctx.enclosingClass)
+            return null;
+        return {
+            name: ctx.enclosingClass,
+            kind: "method",
+            headerEnd: headEnd("statements"),
+            hashNode: node,
+        };
+    }
+    if (node.type === "type_alias") {
+        const name = typeName();
+        if (!name)
+            return null;
+        return { name, kind: "type", headerEnd: node.endIndex, hashNode: node };
+    }
+    if (node.type === "property_declaration") {
+        // Top-level `val`/`var` only — a class property is a field, not a definition node
+        // (no depth tier emits fields), so it must not become one.
+        if (ctx.enclosingKind !== null)
+            return null;
+        const decl = node.namedChildren.find((c) => c.type === "variable_declaration");
+        const name = decl?.namedChildren.find((c) => c.type === "simple_identifier")?.text;
+        if (!name)
+            return null;
+        return { name, kind: "variable", headerEnd: node.endIndex, hashNode: node };
+    }
+    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. */
@@ -631,6 +1720,65 @@ function javaExported(node) {
         return false;
     return mods.children.some((c) => c.type === "public" || c.type === "protected");
 }
+/** Kotlin visibility: exported by default (`public` is implicit); only an explicit
+ * `internal` / `private` / `protected` visibility modifier hides a definition. */
+function kotlinExported(node) {
+    const mods = node.namedChildren.find((c) => c.type === "modifiers");
+    if (!mods)
+        return true;
+    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) {
@@ -679,6 +1827,7 @@ function heritageEdges(node, classId, ctx) {
         // `superclass` holds `extends X`; `super_interfaces` holds `implements A, B`
         // (and, on an interface declaration, `extends A, B` — which tree-sitter-java
         // still spells `extends_interfaces`).
+        const typeParams = javaTypeParameterNames(node);
         for (const child of node.namedChildren) {
             const relation = child.type === "superclass"
                 ? "extends"
@@ -687,12 +1836,56 @@ function heritageEdges(node, classId, ctx) {
                     : null;
             if (!relation)
                 continue;
-            for (const t of typeIdentifiersIn(child)) {
-                edges.push({ source: classId, relation, name: t, file: ctx.rel });
+            for (const entry of javaSupertypeEntries(child)) {
+                const name = javaSupertypeName(entry);
+                // Belt-and-braces. A type VARIABLE is never a supertype, and erasing the
+                // arguments already removes every case measured on gson and spring-petclinic
+                // (identical output with this filter removed) — Java cannot extend or implement
+                // a type variable, so a surviving `T` would have to come from a shape neither
+                // repo contains. Kept because a wrong supertype is not a cosmetic edge: it
+                // feeds `classParents` and from there call resolution.
+                if (!name || typeParams.has(name))
+                    continue;
+                edges.push({ source: classId, relation, name, file: ctx.rel });
             }
         }
         return edges;
     }
+    if (ctx.lang === "kotlin") {
+        // The `:` clause is a list of `delegation_specifier`s — a superclass construction
+        // (`class A : B()`), an interface, or `by` delegation. The first `type_identifier`
+        // under each names the type; everything else (type args, delegation target) is not
+        // the heritage target, so only the head type counts.
+        for (const child of node.namedChildren) {
+            if (child.type !== "delegation_specifier")
+                continue;
+            const t = child.namedChildren.find((c) => c.type === "user_type")?.namedChildren.find((c) => c.type === "type_identifier");
+            if (t)
+                edges.push({ source: classId, relation: "extends", name: t.text, file: ctx.rel });
+        }
+        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 ?? []) {
@@ -702,6 +1895,31 @@ function heritageEdges(node, classId, ctx) {
         }
         return edges;
     }
+    if (ctx.lang === "r") {
+        // `node` is whatever describeR matched: a binary_operator for R6
+        // (`Foo <- R6::R6Class(...)`) or the call itself for S4 (`setClass(...)`
+        // is a bare top-level statement, essentially never assigned).
+        const call = node.type === "binary_operator" ? node.childForFieldName("rhs") : node;
+        if (call?.type !== "call")
+            return edges;
+        const callee = rCalleeName(call);
+        if (callee === "R6Class") {
+            // `inherit = ParentClass` — a bare identifier (the parent's own
+            // generator variable), not a string; R6 supports single inheritance only.
+            const value = rNamedArg(call, "inherit");
+            if (value?.type === "identifier") {
+                edges.push({ source: classId, relation: "extends", name: value.text, file: ctx.rel });
+            }
+        }
+        else if (callee === "setClass") {
+            // `contains = "Base"` or `contains = c("Base1", "Base2")` — S4 supports
+            // multiple inheritance.
+            for (const name of rStringOrCVector(rNamedArg(call, "contains"))) {
+                edges.push({ source: classId, relation: "extends", name, file: ctx.rel });
+            }
+        }
+        return edges;
+    }
     if (ctx.lang === "php") {
         // `class C extends B implements I, J` → base_clause (extends) +
         // class_interface_clause (implements); names may be namespace-qualified.
@@ -734,17 +1952,58 @@ function heritageEdges(node, classId, ctx) {
     }
     return edges;
 }
-/** Every `type_identifier` under a heritage clause, so `implements A, B<C>` yields
- * each named type rather than the clause's raw text. */
-function typeIdentifiersIn(node) {
-    const out = [];
+/**
+ * The supertypes a heritage clause names, one node each — NOT every `type_identifier`
+ * beneath it.
+ *
+ * `superclass` wraps a single type; `super_interfaces`/`extends_interfaces` wrap a
+ * `type_list` of them. Descending blindly instead walked into `type_arguments`, so
+ * `implements Comparable<Item>` reported `Item` as a supertype too.
+ */
+function javaSupertypeEntries(clause) {
+    const list = clause.namedChildren.find((c) => c.type === "type_list");
+    return list ? [...list.namedChildren] : [...clause.namedChildren];
+}
+/**
+ * What a supertype entry is CALLED, or null when this pass cannot say.
+ *
+ * Type arguments are erased, because they are not part of the supertype's identity:
+ *
+ *     Base           |  Base<Item>          -> Base
+ *
+ * A qualified name is kept WHOLE rather than reduced to its final segment:
+ *
+ *     Outer.Inner    |  Outer.Inner<K>      -> Outer.Inner
+ *
+ * Heritage keeps an unresolved base as the edge target by design ("usually an
+ * external/imported type — keep the name"), so the full string is both truthful and
+ * unable to false-match a node id, where a bare `Inner` could collide with an
+ * unrelated in-repo type. That differs from construction (#103), which drops a
+ * qualified name instead — construction has no keep-the-name contract to fall back on.
+ */
+function javaSupertypeName(node) {
+    if (!node)
+        return null;
+    if (node.type === "generic_type")
+        return javaSupertypeName(node.namedChildren[0]);
+    if (node.type === "scoped_type_identifier")
+        return node.text;
+    return node.type === "type_identifier" ? node.text : null;
+}
+/** The names a declaration binds as its own type parameters (`class C<T, U>` → T, U),
+ * so they can never be mistaken for supertypes. */
+function javaTypeParameterNames(decl) {
+    const params = decl.childForFieldName("type_parameters");
+    if (!params)
+        return new Set();
+    const out = new Set();
     const visit = (n) => {
         if (n.type === "type_identifier")
-            out.push(n.text);
+            out.add(n.text);
         for (const c of n.namedChildren)
             visit(c);
     };
-    visit(node);
+    visit(params);
     return out;
 }
 function calleeName(node, lang) {
@@ -772,6 +2031,67 @@ function calleeName(node, lang) {
             return { name: nameNode.text, viaMember: true, receiver: "this" };
         return { name: nameNode.text, viaMember: true, receiver: javaReceiver(obj) };
     }
+    if (lang === "kotlin") {
+        // `call_expression` = callee expression + `call_suffix`. A bare `foo()` names a
+        // plain call; `obj.foo()` is a `navigation_expression` whose trailing
+        // `navigation_suffix` holds the method name and whose object 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 === "this_expression" || receiver?.type === "super_expression")
+                return { name: name.text, viaMember: true, receiver: receiver.type === "this_expression" ? "this" : "super" };
+        }
+        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");
@@ -794,6 +2114,48 @@ function calleeName(node, lang) {
         const p = fn.childForFieldName("property") ?? fn.namedChildren.at(-1);
         return p ? { name: p.text, viaMember: true, receiver: tsReceiver(fn) } : null;
     }
+    if (lang === "r" && (fn.type === "extract_operator" || fn.type === "namespace_operator")) {
+        const rhs = fn.childForFieldName("rhs");
+        if (rhs?.type !== "identifier")
+            return null;
+        if (fn.type === "extract_operator") {
+            const lhs = fn.childForFieldName("lhs");
+            if (lhs?.type === "identifier" && (lhs.text === "self" || lhs.text === "private")) {
+                // R6 (Phase 2): `self$method()` / `private$method()` — resolves directly to
+                // the enclosing class via ctx.enclosingClass, same mechanism (and same
+                // magic receiver string) as Python/TS's self/cls/this — see
+                // resolveRecvType, which already special-cases "self" generically.
+                return { name: rhs.text, viaMember: true, receiver: "self" };
+            }
+            if (lhs?.type === "identifier" && lhs.text === "super") {
+                // R6 (Phase 3): `super$method()` — R6's inheritance-dispatch keyword,
+                // resolves directly to the PARENT class via ctx.rSuperClass (NOT
+                // ctx.enclosingClass — that would wrongly find the current class's own
+                // same-named override instead of climbing to the parent).
+                return { name: rhs.text, viaMember: true, receiver: "super" };
+            }
+            // Any other `obj$method()` (Phase 4): still a PLAIN name match, not a
+            // typed member call — there's no general field-type-binding table for
+            // R6 composition (`private$other_obj$method()`), and a real codebase's
+            // dominant field-assignment shape (constructor-parameter pass-through,
+            // `do.call(class_var$new, ...)` dynamic dispatch) turned out to defeat
+            // the simple "field <- SomeClass$new()" pattern every other language's
+            // binding table relies on anyway — see plan_r_language_support.md's
+            // Phase 2 "known gaps" and the follow-up investigation against a real
+            // R6-heavy corpus. What DOES help: bare-name resolution must be allowed
+            // to match a "method" node here, not just "function" — R6 methods are
+            // always kind "method", so without `kinds` below, EVERY untyped `$`
+            // call would be unconditionally unresolvable rather than just
+            // occasionally ambiguous (resolve.ts already drops a genuinely
+            // ambiguous bare-name match rather than guessing, so this only adds
+            // resolutions for uniquely-named methods, never a wrong-class guess).
+            return { name: rhs.text, viaMember: false, kinds: ["function", "method"] };
+        }
+        // `pkg::fun()` (qualified call) — always a real function/exported symbol,
+        // never an R6 method (those are only ever reached via `$` on an instance),
+        // so no need to widen the match kinds here.
+        return { name: rhs.text, viaMember: false };
+    }
     return null;
 }
 /** The number of arguments at a Java call site (`method_invocation` or
@@ -938,13 +2300,29 @@ function tsReceiver(fn) {
     }
     return undefined;
 }
+/** R has no import statement at the grammar level — `library(x)`, `require(x)`,
+ * and `source("f.R")` are ordinary `call` nodes, indistinguishable from any other
+ * call except by their callee name. This is call-SITE pattern matching, a first
+ * for this function's normal node-type switch — every other language's import
+ * shape is a dedicated grammar construct. */
+const R_IMPORT_CALLS = new Set(["library", "require", "source"]);
 function isImport(node, lang) {
     // Go: match the per-import leaf, so single (`import "fmt"`) and grouped
     // (`import ( … )`) forms each yield one edge as the walk recurses into the list.
     if (lang === "go")
         return node.type === "import_spec";
+    if (lang === "r") {
+        if (node.type !== "call")
+            return false;
+        const fn = node.childForFieldName("function");
+        return fn?.type === "identifier" && R_IMPORT_CALLS.has(fn.text);
+    }
     if (lang === "java")
         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")
@@ -967,6 +2345,14 @@ function importSpecifier(node, lang) {
         const path = node.childForFieldName("path") ?? node.namedChildren.at(-1);
         return path ? path.text.replace(/^["`]|["`]$/g, "") : null;
     }
+    if (lang === "r") {
+        // library(pkg) / library("pkg") / require(pkg) / source("f.R") — the target is
+        // always the first (and normally only) positional argument, bare symbol or string.
+        const value = rCallArgs(node)[0]?.childForFieldName("value") ?? null;
+        if (value?.type === "identifier")
+            return value.text;
+        return rStringContent(value);
+    }
     if (lang === "java") {
         // `import a.b.C;` / `import static a.b.C.d;` / `import a.b.*;` — the fully
         // qualified name is the scoped_identifier; a wildcard `*` is a separate token
@@ -974,6 +2360,20 @@ function importSpecifier(node, lang) {
         const id = node.namedChildren.find((c) => c.type === "scoped_identifier" || c.type === "identifier");
         return id?.text ?? null;
     }
+    if (lang === "kotlin") {
+        // `import com.example.Foo` — the dotted path is the `identifier` child. A
+        // wildcard (`import a.b.*`) and an `as` alias are separate children, so the
+        // 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;