chiasmus 0.1.14 → 0.1.15

package/dist/graph/extractor.js

@@ -74,10 +74,52 @@ function extractFromTree(tree, filePath, lang, defines, calls, imports, exports,
     }
     else {
         const scopeStack = [];
-        walkNode(tree.rootNode, filePath, lang, scopeStack, defines, calls, imports, exports, contains, callSet);
+        // Per-file alias map: local name → imported name. Populated as
+        // `import_statement` nodes are encountered during the walk, read by
+        // `resolveCallee` so a call to `bar()` from `import { foo as bar }`
+        // records an edge to `foo`, matching the exported name on the other
+        // side of the module boundary. ES imports are syntactically required
+        // to appear before any executable code, so building the map lazily
+        // during the walk is safe.
+        const aliasMap = new Map();
+        // Function-reference queue: every `foo` identifier passed as a direct
+        // call argument is recorded here during the walk, then resolved after
+        // the walk against the file's final defines + imports. Deferred
+        // resolution is necessary because the reference can appear *before*
+        // the callee is defined in source order (e.g. `names.map(quoteIfNeeded)`
+        // above a `function quoteIfNeeded(...)` declaration).
+        const pendingRefs = [];
+        walkNode(tree.rootNode, filePath, lang, scopeStack, aliasMap, pendingRefs, defines, calls, imports, exports, contains, callSet);
+        // Resolve pending references. A ref becomes a real edge iff the target
+        // name is a function/method defined in this file or an import binding
+        // this file owns. Non-matching names are dropped so local variable
+        // identifiers (req, opts, config, etc.) don't pollute the graph.
+        const knownNames = new Set();
+        for (const d of defines) {
+            if (d.file !== filePath)
+                continue;
+            if (d.kind === "function" || d.kind === "method" || d.kind === "class") {
+                knownNames.add(d.name);
+            }
+        }
+        for (const imp of imports) {
+            if (imp.file === filePath)
+                knownNames.add(imp.name);
+        }
+        for (const ref of pendingRefs) {
+            if (!knownNames.has(ref.callee))
+                continue;
+            if (ref.caller === ref.callee)
+                continue;
+            const key = `${ref.caller}->${ref.callee}`;
+            if (callSet.has(key))
+                continue;
+            callSet.add(key);
+            calls.push({ caller: ref.caller, callee: ref.callee });
+        }
     }
 }
-function walkNode(node, filePath, language, scopeStack, defines, calls, imports, exports, contains, callSet) {
+function walkNode(node, filePath, language, scopeStack, aliasMap, pendingRefs, defines, calls, imports, exports, contains, callSet) {
     const type = node.type;
     switch (type) {
         case "function_declaration": {
@@ -85,7 +127,7 @@ function walkNode(node, filePath, language, scopeStack, defines, calls, imports,
             if (name) {
                 defines.push({ file: filePath, name, kind: "function", line: node.startPosition.row + 1 });
                 scopeStack.push(name);
-                walkChildren(node, filePath, language, scopeStack, defines, calls, imports, exports, contains, callSet);
+                walkChildren(node, filePath, language, scopeStack, aliasMap, pendingRefs, defines, calls, imports, exports, contains, callSet);
                 scopeStack.pop();
                 return; // already walked children
             }
@@ -101,7 +143,7 @@ function walkNode(node, filePath, language, scopeStack, defines, calls, imports,
                     contains.push({ parent: className, child: name });
                 }
                 scopeStack.push(name);
-                walkChildren(node, filePath, language, scopeStack, defines, calls, imports, exports, contains, callSet);
+                walkChildren(node, filePath, language, scopeStack, aliasMap, pendingRefs, defines, calls, imports, exports, contains, callSet);
                 scopeStack.pop();
                 return;
             }
@@ -112,7 +154,7 @@ function walkNode(node, filePath, language, scopeStack, defines, calls, imports,
             if (name) {
                 defines.push({ file: filePath, name, kind: "class", line: node.startPosition.row + 1 });
                 scopeStack.push(name);
-                walkChildren(node, filePath, language, scopeStack, defines, calls, imports, exports, contains, callSet);
+                walkChildren(node, filePath, language, scopeStack, aliasMap, pendingRefs, defines, calls, imports, exports, contains, callSet);
                 scopeStack.pop();
                 return;
             }
@@ -130,12 +172,12 @@ function walkNode(node, filePath, language, scopeStack, defines, calls, imports,
                         const name = nameNode.text;
                         defines.push({ file: filePath, name, kind: "function", line: node.startPosition.row + 1 });
                         scopeStack.push(name);
-                        walkChildren(valueNode, filePath, language, scopeStack, defines, calls, imports, exports, contains, callSet);
+                        walkChildren(valueNode, filePath, language, scopeStack, aliasMap, pendingRefs, defines, calls, imports, exports, contains, callSet);
                         scopeStack.pop();
                         foundArrow = true;
                     }
                     else if (valueNode) {
-                        walkChildren(child, filePath, language, scopeStack, defines, calls, imports, exports, contains, callSet);
+                        walkChildren(child, filePath, language, scopeStack, aliasMap, pendingRefs, defines, calls, imports, exports, contains, callSet);
                     }
                 }
             }
@@ -144,7 +186,7 @@ function walkNode(node, filePath, language, scopeStack, defines, calls, imports,
             break;
         }
         case "call_expression": {
-            const callee = resolveCallee(node);
+            const callee = resolveCallee(node, aliasMap);
             const caller = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
             if (callee && caller) {
                 const key = `${caller}->${callee}`;
@@ -153,6 +195,29 @@ function walkNode(node, filePath, language, scopeStack, defines, calls, imports,
                     calls.push({ caller, callee });
                 }
             }
+            // Record identifier arguments as potential function references.
+            // Passing a fn by reference (arr.map(fn), emitter.on("sig", fn))
+            // doesn't generate a call_expression for `fn` itself, so without
+            // this pass the target looks unused and dead-code analysis flags
+            // it as dead. We collect the (caller, argIdentifier) pairs here
+            // and resolve them against the file's known function names after
+            // the walk finishes.
+            if (caller) {
+                const argsNode = node.childForFieldName("arguments");
+                if (argsNode) {
+                    for (let i = 0; i < argsNode.childCount; i++) {
+                        const arg = argsNode.child(i);
+                        if (arg.type !== "identifier")
+                            continue;
+                        const argName = arg.text;
+                        // Rewrite through aliasMap so a reference to an aliased
+                        // import resolves to the canonical exported name, matching
+                        // what resolveCallee does for direct calls.
+                        const canonical = aliasMap.get(argName) ?? argName;
+                        pendingRefs.push({ caller, callee: canonical });
+                    }
+                }
+            }
             break; // fall through to walk children (nested calls)
         }
         case "import_statement": {
@@ -161,7 +226,7 @@ function walkNode(node, filePath, language, scopeStack, defines, calls, imports,
             if (source) {
                 const importClause = node.children.find((c) => c.type === "import_clause");
                 if (importClause) {
-                    extractImportNames(importClause, filePath, source, imports);
+                    extractImportNames(importClause, filePath, source, imports, aliasMap);
                 }
             }
             return; // no need to walk deeper
@@ -222,21 +287,29 @@ function walkNode(node, filePath, language, scopeStack, defines, calls, imports,
             break; // fall through to walk children (may contain function_declaration etc.)
         }
     }
-    walkChildren(node, filePath, language, scopeStack, defines, calls, imports, exports, contains, callSet);
+    walkChildren(node, filePath, language, scopeStack, aliasMap, pendingRefs, defines, calls, imports, exports, contains, callSet);
 }
-function walkChildren(node, filePath, language, scopeStack, defines, calls, imports, exports, contains, callSet) {
+function walkChildren(node, filePath, language, scopeStack, aliasMap, pendingRefs, defines, calls, imports, exports, contains, callSet) {
     for (let i = 0; i < node.childCount; i++) {
-        walkNode(node.child(i), filePath, language, scopeStack, defines, calls, imports, exports, contains, callSet);
+        walkNode(node.child(i), filePath, language, scopeStack, aliasMap, pendingRefs, defines, calls, imports, exports, contains, callSet);
     }
 }
-/** Resolve the callee name from a call_expression node */
-function resolveCallee(callNode) {
+/**
+ * Resolve the callee name from a call_expression node. If the identifier
+ * matches a local alias from `import { foo as bar }`, the call is
+ * rewritten to the original export name (`foo`) so cross-file analyses
+ * see the link. Member-expression callees aren't rewritten — they reach
+ * into an object, not a top-level binding.
+ */
+function resolveCallee(callNode, aliasMap) {
     const fnNode = callNode.childForFieldName("function");
     if (!fnNode)
         return null;
     switch (fnNode.type) {
-        case "identifier":
-            return fnNode.text;
+        case "identifier": {
+            const name = fnNode.text;
+            return aliasMap.get(name) ?? name;
+        }
         case "member_expression": {
             // obj.method() → method, this.method() → method
             const property = fnNode.childForFieldName("property");
@@ -265,23 +338,36 @@ function findEnclosingClassName(node) {
     }
     return null;
 }
-/** Extract import names from an import_clause */
-function extractImportNames(clause, filePath, source, imports) {
+/**
+ * Extract import names from an import_clause. For each named specifier
+ * we push an ImportsFact keyed by the *imported* name (so the imports
+ * list reflects the exported identifier as seen by the module being
+ * imported), and — when the local binding differs (an `as` alias) —
+ * register a `local → imported` entry in `aliasMap` so call-site
+ * resolution can rewrite calls through the alias back to the canonical
+ * name used by the call graph.
+ */
+function extractImportNames(clause, filePath, source, imports, aliasMap) {
     for (let i = 0; i < clause.childCount; i++) {
         const child = clause.child(i);
         // Default import: import foo from './bar'
         if (child.type === "identifier") {
             imports.push({ file: filePath, name: child.text, source });
         }
-        // Named imports: import { foo, bar } from './baz'
+        // Named imports: import { foo, bar, baz as qux } from './mod'
         if (child.type === "named_imports") {
             for (let j = 0; j < child.childCount; j++) {
                 const spec = child.child(j);
-                if (spec.type === "import_specifier") {
-                    const name = spec.childForFieldName("name")?.text;
-                    if (name) {
-                        imports.push({ file: filePath, name, source });
-                    }
+                if (spec.type !== "import_specifier")
+                    continue;
+                const name = spec.childForFieldName("name")?.text;
+                if (!name)
+                    continue;
+                imports.push({ file: filePath, name, source });
+                // `alias` field only exists when the specifier has an `as` clause.
+                const alias = spec.childForFieldName("alias")?.text;
+                if (alias && alias !== name) {
+                    aliasMap.set(alias, name);
                 }
             }
         }
@@ -588,20 +674,70 @@ function extractGoReceiverType(receiver) {
     return null;
 }
 // ── Clojure extraction ──────────────────────────────────────────────
-/** Get the text of the first sym_name child (direct or nested in sym_lit) */
+/**
+ * Get the textual name of a Clojure symbol, preserving any namespace
+ * prefix. tree-sitter-clojure parses a qualified symbol like `db/query`
+ * into a sym_lit containing a `sym_ns` child ("db") and a `sym_name`
+ * child ("query"); returning just the `sym_name` loses the ns info and
+ * conflates cross-namespace calls. Reconstruct `ns/name` when both are
+ * present, otherwise fall back to the bare `sym_name`.
+ */
 function cljSymName(node) {
     if (node.type === "sym_name")
         return node.text;
     if (node.type === "sym_lit") {
+        let ns = null;
+        let name = null;
         for (let i = 0; i < node.childCount; i++) {
-            if (node.child(i).type === "sym_name")
-                return node.child(i).text;
+            const c = node.child(i);
+            if (c.type === "sym_ns")
+                ns = c.text;
+            else if (c.type === "sym_name" && name === null)
+                name = c.text;
         }
+        if (name === null)
+            return null;
+        return ns ? `${ns}/${name}` : name;
     }
     return null;
 }
-/** Extract ns form: (ns foo.bar (:require [baz.qux :as q] [x.y :refer [z]])) */
-function cljExtractNs(listNode, filePath, imports) {
+/**
+ * Resolve a Clojure call target to its canonical form. Rules:
+ *   - `alias/name` where alias is in aliasMap → `<full-ns>/name`
+ *   - `prefix/name` where prefix is unknown → returned as-is (already fully
+ *     qualified, or an alias we couldn't resolve — either way, leave it)
+ *   - bare `name` where `<currentNs>/name` is defined in this file → qualify
+ *     to the current ns (same-file reference)
+ *   - bare `name` otherwise → returned as-is (external, clojure.core, etc.)
+ *
+ * When `currentNs` is null (file has no ns form) the bare path just returns
+ * the input, preserving the legacy "bare names everywhere" behavior for
+ * script-style files.
+ */
+function qualifyCljName(name, ctx) {
+    const slashIdx = name.indexOf("/");
+    if (slashIdx >= 0) {
+        const prefix = name.slice(0, slashIdx);
+        const local = name.slice(slashIdx + 1);
+        const fullNs = ctx.aliasMap.get(prefix);
+        if (fullNs)
+            return `${fullNs}/${local}`;
+        return name;
+    }
+    if (ctx.currentNs === null)
+        return name;
+    const candidate = `${ctx.currentNs}/${name}`;
+    if (ctx.inFileDefns.has(candidate))
+        return candidate;
+    return name;
+}
+/**
+ * Extract ns form: (ns foo.bar (:require [baz.qux :as q] [x.y :refer [z]])).
+ * Populates `imports` with the required namespaces and `aliasMap` with any
+ * `:as` bindings so the call extractor can resolve `q/some-fn` to
+ * `baz.qux/some-fn`.
+ */
+function cljExtractNs(listNode, filePath, imports, aliasMap) {
     let symIdx = -1;
     for (let i = 0; i < listNode.childCount; i++) {
         if (listNode.child(i).type === "sym_lit") {
@@ -638,16 +774,38 @@ function cljExtractNs(listNode, filePath, imports) {
                     for (let k = j + 1; k < child.childCount; k++) {
                         const vec = child.child(k);
                         if (vec.type === "vec_lit") {
-                            // First sym_lit in vector is the required namespace
+                            // First sym_lit in vector is the required namespace; scan for
+                            // a trailing `:as alias` pair so alias → full-ns can be
+                            // resolved at call sites.
+                            let reqNs = null;
                             for (let l = 0; l < vec.childCount; l++) {
-                                if (vec.child(l).type === "sym_lit") {
-                                    const reqNs = cljSymName(vec.child(l));
-                                    if (reqNs) {
-                                        imports.push({ file: filePath, name: reqNs, source: reqNs });
-                                    }
+                                const vc = vec.child(l);
+                                if (vc.type === "sym_lit") {
+                                    reqNs = cljSymName(vc);
                                     break;
                                 }
                             }
+                            if (!reqNs)
+                                continue;
+                            imports.push({ file: filePath, name: reqNs, source: reqNs });
+                            for (let l = 0; l < vec.childCount; l++) {
+                                const vc = vec.child(l);
+                                if (vc.type !== "kwd_lit")
+                                    continue;
+                                const kname = vc.children?.find((c) => c.type === "kwd_name")?.text;
+                                if (kname !== "as")
+                                    continue;
+                                for (let m = l + 1; m < vec.childCount; m++) {
+                                    const asSym = vec.child(m);
+                                    if (asSym.type === "sym_lit") {
+                                        const alias = cljSymName(asSym);
+                                        if (alias)
+                                            aliasMap.set(alias, reqNs);
+                                        break;
+                                    }
+                                }
+                                break;
+                            }
                         }
                     }
                 }
@@ -736,14 +894,17 @@ function cljMethodImplName(listNode) {
  * extend-protocol form, extracting call edges from each method impl body
  * using the method name as the caller.
  */
-function cljWalkDispatchMethods(parentList, inFileDefns, calls, callSet) {
+function cljWalkDispatchMethods(parentList, ctx, calls, callSet) {
     for (let i = 0; i < parentList.childCount; i++) {
         const child = parentList.child(i);
         if (child.type !== "list_lit")
             continue;
         const methodName = cljMethodImplName(child);
         if (methodName) {
-            cljExtractCalls(child, methodName, inFileDefns, calls, callSet);
+            // Method implementations are attributed to the bare method name
+            // (not qualified): dispatch method names are looked up by unqualified
+            // identifier and usually match a defprotocol entry elsewhere.
+            cljExtractCalls(child, methodName, ctx, calls, callSet);
         }
     }
 }
@@ -763,7 +924,12 @@ const CLJ_RECOGNIZED_TOPLEVEL = new Set([
 /** Walk a Clojure AST and extract defines, calls, imports */
 function walkClojure(rootNode, filePath, defines, calls, imports, exports, callSet) {
     let nsName = null;
+    const aliasMap = new Map();
     const definesBeforePhase1 = defines.length;
+    // Phase 1 pushes bare names and records the boundaries; after phase 1
+    // finishes we'll rewrite them in-place to qualified form once we know the
+    // final ns. Deferring the rewrite avoids having to know the ns before
+    // seeing the (ns ...) form, which can appear anywhere in the file.
     // ── Phase 1: collect top-level definitions ────────────────────────
     // In addition to defn/defn-, we also register defmulti, defprotocol
     // (and its declared methods), defrecord, deftype, definterface,
@@ -773,9 +939,9 @@ function walkClojure(rootNode, filePath, defines, calls, imports, exports, callS
         const child = rootNode.child(i);
         if (child.type !== "list_lit")
             continue;
-        // ns form — harvest requires and capture the namespace name for use
-        // as the top-level caller in phase 2.
-        const ns = cljExtractNs(child, filePath, imports);
+        // ns form — harvest requires, :as aliases, and the namespace name for
+        // use as the top-level caller in phase 2.
+        const ns = cljExtractNs(child, filePath, imports, aliasMap);
         if (ns) {
             nsName = ns;
             continue;
@@ -848,21 +1014,53 @@ function walkClojure(rootNode, filePath, defines, calls, imports, exports, callS
             }
         }
     }
+    // Post-phase-1 qualification: now that the (ns ...) form has been seen
+    // (or confirmed absent), rewrite each define pushed during phase 1 to
+    // its namespace-qualified form. `defprotocol`/`definterface` method rows
+    // (kind === "function" nested inside a class define) are qualified too —
+    // they look identical to defn from the graph's perspective. Classes
+    // (defrecord/deftype/definterface) are also qualified.
+    //
+    // If nsName is null the file is in legacy "bare" mode and names stay as
+    // they were pushed — this keeps script-style .clj fixtures working.
+    if (nsName !== null) {
+        for (let k = definesBeforePhase1; k < defines.length; k++) {
+            defines[k].name = `${nsName}/${defines[k].name}`;
+        }
+        // Exports were pushed alongside defines in phase 1. They were appended
+        // after definesBeforePhase1 as we went, but exports and defines are
+        // separate arrays — rewrite exports for this file by walking from the
+        // pre-phase-1 length of the exports array.
+        // We don't have a snapshot of the export length, so scan the tail for
+        // entries belonging to this file and qualify those whose name still
+        // looks bare.
+        for (let k = exports.length - 1; k >= 0 && exports[k].file === filePath; k--) {
+            if (!exports[k].name.includes("/")) {
+                exports[k].name = `${nsName}/${exports[k].name}`;
+            }
+        }
+    }
     // Snapshot the set of names defined in *this file* during phase 1.
     // Phase 2's cljExtractCalls uses this to recognize in-file references:
     // whenever it encounters a sym_lit whose name matches one of these,
-    // it emits a reference edge. This covers user-defined HOFs, map-value
-    // registrations (`{:home home-handler}`), `(def h my-fn)`, and similar
-    // patterns where a fn is passed by value rather than called directly.
+    // it emits a reference edge. Names here are already qualified if the
+    // file had an ns form.
     const inFileDefns = new Set();
     for (let k = definesBeforePhase1; k < defines.length; k++) {
         inFileDefns.add(defines[k].name);
     }
+    const ctx = { currentNs: nsName, aliasMap, inFileDefns };
     // Synthetic caller for top-level side-effecting forms. If the file has
     // no ns declaration, fall back to the file path — it's still a unique
     // identifier that downstream analyses can treat as "always live".
     const topLevelCaller = nsName ?? `<toplevel:${filePath}>`;
     // ── Phase 2: walk bodies for call edges ──────────────────────────
+    //
+    // Phase-2 callers are qualified whenever the file has an ns form: `defn
+    // foo` in `ns myapp.core` becomes the caller `myapp.core/foo`. This
+    // matches the (already rewritten) entries in `defines` so cross-file
+    // analyses see a consistent graph.
+    const qualifyCaller = (bare) => nsName !== null ? `${nsName}/${bare}` : bare;
     for (let i = 0; i < rootNode.childCount; i++) {
         const child = rootNode.child(i);
         if (child.type !== "list_lit")
@@ -871,7 +1069,7 @@ function walkClojure(rootNode, filePath, defines, calls, imports, exports, callS
         if (!head) {
             // Non-symbolic head (keyword-first, map-first, etc.) at top level.
             // Still walk it as file-level init — unusual but possible.
-            cljExtractCalls(child, topLevelCaller, inFileDefns, calls, callSet);
+            cljExtractCalls(child, topLevelCaller, ctx, calls, callSet);
             continue;
         }
         switch (head.name) {
@@ -883,7 +1081,7 @@ function walkClojure(rootNode, filePath, defines, calls, imports, exports, callS
             case "deftest": {
                 const name = cljNextSymNameAfter(child, head.symIdx);
                 if (name)
-                    cljExtractCalls(child, name, inFileDefns, calls, callSet);
+                    cljExtractCalls(child, qualifyCaller(name), ctx, calls, callSet);
                 break;
             }
             case "defmulti": {
@@ -893,7 +1091,7 @@ function walkClojure(rootNode, filePath, defines, calls, imports, exports, callS
                 // named. Attribute to the multi name.
                 const name = cljNextSymNameAfter(child, head.symIdx);
                 if (name)
-                    cljExtractCalls(child, name, inFileDefns, calls, callSet);
+                    cljExtractCalls(child, qualifyCaller(name), ctx, calls, callSet);
                 break;
             }
             case "defmethod": {
@@ -902,14 +1100,14 @@ function walkClojure(rootNode, filePath, defines, calls, imports, exports, callS
                 // is recorded as "called by" the multi and won't look dead.
                 const multiName = cljNextSymNameAfter(child, head.symIdx);
                 if (multiName)
-                    cljExtractCalls(child, multiName, inFileDefns, calls, callSet);
+                    cljExtractCalls(child, qualifyCaller(multiName), ctx, calls, callSet);
                 break;
             }
             case "defrecord":
             case "deftype":
             case "extend-type":
             case "extend-protocol": {
-                cljWalkDispatchMethods(child, inFileDefns, calls, callSet);
+                cljWalkDispatchMethods(child, ctx, calls, callSet);
                 break;
             }
             default: {
@@ -917,7 +1115,7 @@ function walkClojure(rootNode, filePath, defines, calls, imports, exports, callS
                 // ns name as caller. Catches use-fixtures, (def x (compute)),
                 // (require '[...]), raw println calls, etc.
                 if (!CLJ_RECOGNIZED_TOPLEVEL.has(head.name)) {
-                    cljExtractCalls(child, topLevelCaller, inFileDefns, calls, callSet);
+                    cljExtractCalls(child, topLevelCaller, ctx, calls, callSet);
                 }
                 break;
             }
@@ -1017,12 +1215,20 @@ const CLJ_RECURSE_TYPES = new Set([
  * site: emit its head as a callee, then apply HOF / threading-macro
  * reference rules to its arguments.
  */
-function cljProcessCallSite(listLike, enclosingFn, calls, callSet) {
+function cljProcessCallSite(listLike, enclosingFn, ctx, calls, callSet) {
     const emit = (calleeRaw) => {
-        const callee = calleeRaw.includes("/") ? calleeRaw.split("/").pop() : calleeRaw;
-        if (!callee || callee === enclosingFn)
+        if (!calleeRaw)
             return;
-        if (CLJ_SPECIAL_FORMS.has(callee))
+        // Special-form filtering happens on the bare tail: `let` is a special
+        // form whether written as `let` or `some.ns/let` (the latter is
+        // degenerate but the filter shouldn't care). The aliased test lets
+        // us shed def/let/if/etc. before paying for resolution.
+        const slashIdx = calleeRaw.indexOf("/");
+        const bareTail = slashIdx >= 0 ? calleeRaw.slice(slashIdx + 1) : calleeRaw;
+        if (slashIdx < 0 && CLJ_SPECIAL_FORMS.has(bareTail))
+            return;
+        const callee = qualifyCljName(calleeRaw, ctx);
+        if (!callee || callee === enclosingFn)
             return;
         const key = `${enclosingFn}->${callee}`;
         if (callSet.has(key))
@@ -1094,33 +1300,33 @@ function cljProcessCallSite(listLike, enclosingFn, calls, callSet) {
  * as its own call site via the same top-of-function check.
  *
  * Every sym_lit encountered at any depth is also checked against
- * `inFileDefns`: if its name matches a definition in the current file,
- * an edge is emitted. This covers in-file references that aren't at
- * list-head position — e.g. fns passed to user-defined HOFs, fn values
- * in map literals, `(def h my-fn)`, and registration-style calls like
- * `(reg-event-fx :k handler)`.
+ * `ctx.inFileDefns`: if its qualified form matches a definition in the
+ * current file, an edge is emitted. This covers in-file references that
+ * aren't at list-head position — e.g. fns passed to user-defined HOFs,
+ * fn values in map literals, `(def h my-fn)`, and registration-style
+ * calls like `(reg-event-fx :k handler)`.
  */
-function cljExtractCalls(node, enclosingFn, inFileDefns, calls, callSet) {
+function cljExtractCalls(node, enclosingFn, ctx, calls, callSet) {
     if (node.type === "list_lit" || node.type === "anon_fn_lit") {
-        cljProcessCallSite(node, enclosingFn, calls, callSet);
+        cljProcessCallSite(node, enclosingFn, ctx, calls, callSet);
     }
     for (let i = 0; i < node.childCount; i++) {
         const child = node.child(i);
         if (child.type === "sym_lit") {
             const name = cljSymName(child);
             if (name) {
-                const bare = name.includes("/") ? name.split("/").pop() : name;
-                if (bare && bare !== enclosingFn && inFileDefns.has(bare)) {
-                    const key = `${enclosingFn}->${bare}`;
+                const qualified = qualifyCljName(name, ctx);
+                if (qualified && qualified !== enclosingFn && ctx.inFileDefns.has(qualified)) {
+                    const key = `${enclosingFn}->${qualified}`;
                     if (!callSet.has(key)) {
                         callSet.add(key);
-                        calls.push({ caller: enclosingFn, callee: bare });
+                        calls.push({ caller: enclosingFn, callee: qualified });
                     }
                 }
             }
         }
         if (CLJ_RECURSE_TYPES.has(child.type)) {
-            cljExtractCalls(child, enclosingFn, inFileDefns, calls, callSet);
+            cljExtractCalls(child, enclosingFn, ctx, calls, callSet);
         }
     }
 }