@colbymchenry/codegraph-darwin-x64 0.9.5 → 0.9.6

package/lib/dist/extraction/mybatis-extractor.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyBatisExtractor = void 0;
+const tree_sitter_helpers_1 = require("./tree-sitter-helpers");
+/**
+ * MyBatisExtractor — parses MyBatis mapper XML files.
+ *
+ * MyBatis splits a DAO interface across two files: a Java interface (parsed by
+ * tree-sitter) declares the method, and an XML mapper file holds the SQL keyed
+ * by `<namespace>` (the fully-qualified Java type name) and `id` (the method
+ * name). Without the XML side in the graph, `trace(Controller, ...DAO.method)`
+ * dead-ends at the interface method — the SQL it actually runs is invisible,
+ * and "what does this query touch" / "where is this column written" can't be
+ * answered.
+ *
+ * This extractor emits one method-shaped node per `<select|insert|update|
+ * delete>` and per `<sql>` fragment, qualified as `<namespace>::<id>` so the
+ * MyBatis framework synthesizer (`src/resolution/frameworks/mybatis.ts`) can
+ * link the matching Java method → XML statement by suffix-matching qualified
+ * names. `<include refid="...">` inside a statement yields an unresolved
+ * reference to the SQL fragment, also keyed by `<namespace>::<refid>`.
+ *
+ * Non-mapper XML (Maven `pom.xml`, Spring beans XML, `web.xml`, log4j config,
+ * etc.) is detected by the absence of a `<mapper namespace="...">` root and
+ * returns just a file node — we still need the file row so the watcher can
+ * track it, but we emit no symbols.
+ */
+class MyBatisExtractor {
+    filePath;
+    source;
+    nodes = [];
+    edges = [];
+    unresolvedReferences = [];
+    errors = [];
+    lineStarts = [];
+    constructor(filePath, source) {
+        this.filePath = filePath;
+        this.source = source;
+        this.computeLineStarts();
+    }
+    extract() {
+        const startTime = Date.now();
+        const fileNode = this.createFileNode();
+        try {
+            const mapperMatch = this.findMapperRoot();
+            if (mapperMatch) {
+                this.extractMapper(fileNode.id, mapperMatch.namespace, mapperMatch.bodyStart, mapperMatch.bodyEnd);
+            }
+        }
+        catch (error) {
+            this.errors.push({
+                message: `MyBatis extraction error: ${error instanceof Error ? error.message : String(error)}`,
+                severity: 'error',
+                code: 'parse_error',
+            });
+        }
+        return {
+            nodes: this.nodes,
+            edges: this.edges,
+            unresolvedReferences: this.unresolvedReferences,
+            errors: this.errors,
+            durationMs: Date.now() - startTime,
+        };
+    }
+    createFileNode() {
+        const lines = this.source.split('\n');
+        const id = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'file', this.filePath, 1);
+        const node = {
+            id,
+            kind: 'file',
+            name: this.filePath.split('/').pop() || this.filePath,
+            qualifiedName: this.filePath,
+            filePath: this.filePath,
+            language: 'xml',
+            startLine: 1,
+            endLine: lines.length || 1,
+            startColumn: 0,
+            endColumn: lines[lines.length - 1]?.length ?? 0,
+            updatedAt: Date.now(),
+        };
+        this.nodes.push(node);
+        return node;
+    }
+    /**
+     * Find the `<mapper namespace="X">` opening tag. Returns the namespace and
+     * the byte offsets of the body (between the opening and closing tag) so
+     * statement extraction can be scoped to mapper contents.
+     */
+    findMapperRoot() {
+        const open = /<mapper\b([^>]*)>/.exec(this.source);
+        if (!open)
+            return null;
+        const attrs = open[1] ?? '';
+        const nsMatch = /\bnamespace\s*=\s*"([^"]+)"/.exec(attrs);
+        if (!nsMatch)
+            return null;
+        const bodyStart = open.index + open[0].length;
+        const closeIdx = this.source.indexOf('</mapper>', bodyStart);
+        const bodyEnd = closeIdx >= 0 ? closeIdx : this.source.length;
+        return { namespace: nsMatch[1], bodyStart, bodyEnd };
+    }
+    extractMapper(fileNodeId, namespace, bodyStart, bodyEnd) {
+        const body = this.source.slice(bodyStart, bodyEnd);
+        // Match each top-level statement-shaped element. The body may have nested
+        // tags (`<if>`, `<foreach>`, `<include>`), so we scan with a regex that
+        // pairs an opening tag to its matching close — the simple form below works
+        // because MyBatis statement elements are not themselves nested.
+        const stmtRegex = /<(select|insert|update|delete|sql)\b([^>]*)>([\s\S]*?)<\/\1>/g;
+        let m;
+        while ((m = stmtRegex.exec(body)) !== null) {
+            const elemType = m[1];
+            const attrs = m[2] ?? '';
+            const elemBody = m[3] ?? '';
+            const idMatch = /\bid\s*=\s*"([^"]+)"/.exec(attrs);
+            if (!idMatch)
+                continue;
+            const id = idMatch[1];
+            const absoluteIndex = bodyStart + m.index;
+            const startLine = this.getLineNumber(absoluteIndex);
+            const endLine = this.getLineNumber(absoluteIndex + m[0].length);
+            const qualified = `${namespace}::${id}`;
+            const isSqlFragment = elemType === 'sql';
+            const nodeId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'method', qualified, startLine);
+            const node = {
+                id: nodeId,
+                kind: 'method',
+                name: id,
+                qualifiedName: qualified,
+                filePath: this.filePath,
+                language: 'xml',
+                signature: this.buildSignature(elemType, attrs, isSqlFragment),
+                startLine,
+                endLine,
+                startColumn: 0,
+                endColumn: 0,
+                docstring: this.previewSql(elemBody),
+                updatedAt: Date.now(),
+            };
+            this.nodes.push(node);
+            this.edges.push({ source: fileNodeId, target: nodeId, kind: 'contains' });
+            // <include refid="X"/> → reference to the SQL fragment in this mapper
+            // (or in another mapper, when the refid is qualified — `ns.X`).
+            const includeRegex = /<include\b[^>]*\brefid\s*=\s*"([^"]+)"/g;
+            let inc;
+            while ((inc = includeRegex.exec(elemBody)) !== null) {
+                const refid = inc[1];
+                const refQualified = refid.includes('.') ? refid.replace(/\./g, '::') : `${namespace}::${refid}`;
+                const includeOffset = absoluteIndex + (m[0].length - m[3].length - `</${elemType}>`.length) + inc.index;
+                const line = this.getLineNumber(includeOffset);
+                this.unresolvedReferences.push({
+                    fromNodeId: nodeId,
+                    referenceName: refQualified,
+                    referenceKind: 'references',
+                    line,
+                    column: 0,
+                });
+            }
+        }
+    }
+    buildSignature(elemType, attrs, isSqlFragment) {
+        if (isSqlFragment)
+            return '<sql>';
+        const verb = elemType.toUpperCase();
+        const result = /\bresultType\s*=\s*"([^"]+)"/.exec(attrs)?.[1];
+        const param = /\bparameterType\s*=\s*"([^"]+)"/.exec(attrs)?.[1];
+        const parts = [verb];
+        if (param)
+            parts.push(`param=${param}`);
+        if (result)
+            parts.push(`result=${result}`);
+        return parts.join(' ');
+    }
+    previewSql(body) {
+        return body.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 200);
+    }
+    computeLineStarts() {
+        this.lineStarts = [0];
+        for (let i = 0; i < this.source.length; i++) {
+            if (this.source.charCodeAt(i) === 10)
+                this.lineStarts.push(i + 1);
+        }
+    }
+    getLineNumber(offset) {
+        // Binary search
+        let lo = 0;
+        let hi = this.lineStarts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >>> 1;
+            if (this.lineStarts[mid] <= offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo + 1;
+    }
+}
+exports.MyBatisExtractor = MyBatisExtractor;
+//# sourceMappingURL=mybatis-extractor.js.map

package/lib/dist/extraction/mybatis-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mybatis-extractor.js","sourceRoot":"","sources":["../../src/extraction/mybatis-extractor.ts"],"names":[],"mappings":";;;AACA,+DAAuD;AAEvD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAa,gBAAgB;IACnB,QAAQ,CAAS;IACjB,MAAM,CAAS;IACf,KAAK,GAAW,EAAE,CAAC;IACnB,KAAK,GAAW,EAAE,CAAC;IACnB,oBAAoB,GAA0B,EAAE,CAAC;IACjD,MAAM,GAAsB,EAAE,CAAC;IAC/B,UAAU,GAAa,EAAE,CAAC;IAElC,YAAY,QAAgB,EAAE,MAAc;QAC1C,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED,OAAO;QACL,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE7B,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QAEvC,IAAI,CAAC;YACH,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YAC1C,IAAI,WAAW,EAAE,CAAC;gBAChB,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC,SAAS,EAAE,WAAW,CAAC,SAAS,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;YACrG,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;gBACf,OAAO,EAAE,6BAA6B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;gBAC9F,QAAQ,EAAE,OAAO;gBACjB,IAAI,EAAE,aAAa;aACpB,CAAC,CAAC;QACL,CAAC;QAED,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;SACnC,CAAC;IACJ,CAAC;IAEO,cAAc;QACpB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACtC,MAAM,EAAE,GAAG,IAAA,oCAAc,EAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QACnE,MAAM,IAAI,GAAS;YACjB,EAAE;YACF,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,QAAQ;YACrD,aAAa,EAAE,IAAI,CAAC,QAAQ;YAC5B,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,QAAQ,EAAE,KAAK;YACf,SAAS,EAAE,CAAC;YACZ,OAAO,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC;YAC1B,WAAW,EAAE,CAAC;YACd,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC;YAC/C,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;SACtB,CAAC;QACF,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACK,cAAc;QACpB,MAAM,IAAI,GAAG,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACnD,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC5B,MAAM,OAAO,GAAG,6BAA6B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1D,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC;QAC1B,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QAC7D,MAAM,OAAO,GAAG,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;QAC9D,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC,CAAE,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;IACxD,CAAC;IAEO,aAAa,CAAC,UAAkB,EAAE,SAAiB,EAAE,SAAiB,EAAE,OAAe;QAC7F,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QACnD,0EAA0E;QAC1E,wEAAwE;QACxE,2EAA2E;QAC3E,gEAAgE;QAChE,MAAM,SAAS,GAAG,+DAA+D,CAAC;QAClF,IAAI,CAAyB,CAAC;QAC9B,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YAC3C,MAAM,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC;YACvB,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YACzB,MAAM,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YAC5B,MAAM,OAAO,GAAG,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnD,IAAI,CAAC,OAAO;gBAAE,SAAS;YACvB,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAE,CAAC;YACvB,MAAM,aAAa,GAAG,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC;YAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;YACpD,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;YAChE,MAAM,SAAS,GAAG,GAAG,SAAS,KAAK,EAAE,EAAE,CAAC;YACxC,MAAM,aAAa,GAAG,QAAQ,KAAK,KAAK,CAAC;YACzC,MAAM,MAAM,GAAG,IAAA,oCAAc,EAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;YAC7E,MAAM,IAAI,GAAS;gBACjB,EAAE,EAAE,MAAM;gBACV,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,EAAE;gBACR,aAAa,EAAE,SAAS;gBACxB,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,QAAQ,EAAE,KAAK;gBACf,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,KAAK,EAAE,aAAa,CAAC;gBAC9D,SAAS;gBACT,OAAO;gBACP,WAAW,EAAE,CAAC;gBACd,SAAS,EAAE,CAAC;gBACZ,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;gBACpC,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;aACtB,CAAC;YACF,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACtB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;YAE1E,sEAAsE;YACtE,gEAAgE;YAChE,MAAM,YAAY,GAAG,yCAAyC,CAAC;YAC/D,IAAI,GAA2B,CAAC;YAChC,OAAO,CAAC,GAAG,GAAG,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;gBACpD,MAAM,KAAK,GAAG,GAAG,CAAC,CAAC,CAAE,CAAC;gBACtB,MAAM,YAAY,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,KAAK,KAAK,EAAE,CAAC;gBACjG,MAAM,aAAa,GAAG,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC,MAAM,GAAG,KAAK,QAAQ,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC;gBACzG,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;gBAC/C,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC;oBAC7B,UAAU,EAAE,MAAM;oBAClB,aAAa,EAAE,YAAY;oBAC3B,aAAa,EAAE,YAAY;oBAC3B,IAAI;oBACJ,MAAM,EAAE,CAAC;iBACV,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAEO,cAAc,CAAC,QAAgB,EAAE,KAAa,EAAE,aAAsB;QAC5E,IAAI,aAAa;YAAE,OAAO,OAAO,CAAC;QAClC,MAAM,IAAI,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;QACpC,MAAM,MAAM,GAAG,8BAA8B,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/D,MAAM,KAAK,GAAG,iCAAiC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACjE,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,CAAC;QACrB,IAAI,KAAK;YAAE,KAAK,CAAC,IAAI,CAAC,SAAS,KAAK,EAAE,CAAC,CAAC;QACxC,IAAI,MAAM;YAAE,KAAK,CAAC,IAAI,CAAC,UAAU,MAAM,EAAE,CAAC,CAAC;QAC3C,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAEO,UAAU,CAAC,IAAY;QAC7B,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IACjF,CAAC;IAEO,iBAAiB;QACvB,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC;QACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC5C,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,EAAE;gBAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAEO,aAAa,CAAC,MAAc;QAClC,gBAAgB;QAChB,IAAI,EAAE,GAAG,CAAC,CAAC;QACX,IAAI,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;QACpC,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC;YACf,MAAM,GAAG,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAE,IAAI,MAAM;gBAAE,EAAE,GAAG,GAAG,CAAC;;gBACzC,EAAE,GAAG,GAAG,GAAG,CAAC,CAAC;QACpB,CAAC;QACD,OAAO,EAAE,GAAG,CAAC,CAAC;IAChB,CAAC;CACF;AA3KD,4CA2KC"}

package/lib/dist/extraction/tree-sitter.d.ts

@@ -104,6 +104,20 @@ export declare class TreeSitterExtractor {
      * Returns true if children should be skipped (struct/interface handled body visiting).
      */
     private extractTypeAlias;
+    /**
+     * Surface the members of a TypeScript `type X = { ... }` (or intersection
+     * thereof) as `property` / `method` nodes under the type-alias node. Only
+     * walks the immediate object_type / intersection operands so anonymous
+     * nested object types inside generic arguments (`Promise<{ ok: true }>`)
+     * don't produce phantom members.
+     */
+    private extractTsTypeAliasMembers;
+    /**
+     * `foo: () => T` → property_signature whose type_annotation contains a
+     * `function_type`. Treat that as a method-shaped contract member, since
+     * the call site `obj.foo()` has identical semantics to `bar(): T`.
+     */
+    private isTsFunctionTypedProperty;
     /**
      * Extract an import
      *
@@ -178,6 +192,25 @@ export declare class TreeSitterExtractor {
      * Creates 'references' edges for parameter types, return types, and field types.
      */
     private extractTypeAnnotations;
+    /**
+     * Extract C# type references from a node that owns a type position —
+     * a method/constructor declaration, a property declaration, or a
+     * field declaration (which wraps `variable_declaration → type`).
+     *
+     * Walks ONLY into known type fields, so parameter names like
+     * `request` in `Build(UserDto request)` are never mis-emitted as
+     * type references. Once inside a type subtree, `walkCsharpTypePosition`
+     * recognizes C#'s actual type-leaf node kinds (`identifier`,
+     * `qualified_name`, `generic_name`, `array_type`, `nullable_type`,
+     * `tuple_type`, …) — none of which are `type_identifier`. Closes #381.
+     */
+    private extractCsharpTypeRefs;
+    /**
+     * Walk a C# subtree that is KNOWN to be in a type position
+     * (return type, parameter type, property type, field type, generic
+     * argument). Identifiers here are type names, not parameter names.
+     */
+    private walkCsharpTypePosition;
     /**
      * Extract type references from a variable's type annotation.
      */

package/lib/dist/extraction/tree-sitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree-sitter.d.ts","sourceRoot":"","sources":["../../src/extraction/tree-sitter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tree-sitter.d.ts","sourceRoot":"","sources":["../../src/extraction/tree-sitter.ts"],"names":[],"mappings":"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"}

package/lib/dist/extraction/tree-sitter.js

@@ -48,6 +48,7 @@ const liquid_extractor_1 = require("./liquid-extractor");
 const svelte_extractor_1 = require("./svelte-extractor");
 const dfm_extractor_1 = require("./dfm-extractor");
 const vue_extractor_1 = require("./vue-extractor");
+const mybatis_extractor_1 = require("./mybatis-extractor");
 const frameworks_1 = require("../resolution/frameworks");
 // Re-export for backward compatibility
 var tree_sitter_helpers_2 = require("./tree-sitter-helpers");
@@ -395,6 +396,20 @@ class TreeSitterExtractor {
         else if (nodeType === 'impl_item') {
             this.extractRustImplItem(node);
         }
+        // TypeScript interface members: property_signature (`foo: T`, `foo?: T`)
+        // and method_signature (`foo(arg: A): R`) both carry type annotations the
+        // interface walker would otherwise drop. Extract them as `references`
+        // edges from the interface so resolvers can wire callers/impact for
+        // types that only appear in interface members.
+        else if ((nodeType === 'property_signature' || nodeType === 'method_signature') &&
+            this.isInsideClassLikeNode() &&
+            this.TYPE_ANNOTATION_LANGUAGES.has(this.language)) {
+            const parentId = this.nodeStack[this.nodeStack.length - 1];
+            if (parentId) {
+                this.extractTypeAnnotations(node, parentId);
+            }
+            // don't skipChildren — nested signatures still need traversal
+        }
         // Visit children (unless the extract method already visited them)
         if (!skipChildren) {
             for (let i = 0; i < node.namedChildCount; i++) {
@@ -651,6 +666,11 @@ class TreeSitterExtractor {
             // in inline objects). These are ephemeral and create noise (e.g., Svelte context
             // objects: `ctx.set({ get view() { ... } })`).
             if (node.parent?.type === 'object' || node.parent?.type === 'object_expression') {
+                const body = this.extractor.resolveBody?.(node, this.extractor.bodyField)
+                    ?? (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
+                if (body) {
+                    this.visitFunctionBody(body, '');
+                }
                 return;
             }
             // Not inside a class-like node and no receiver type, treat as function
@@ -875,6 +895,10 @@ class TreeSitterExtractor {
         // decorator->target relationship for class properties too.
         if (propNode) {
             this.extractDecoratorsFor(node, propNode.id);
+            // Emit `references` edges from the property to types named in its
+            // type annotation (#381). The generic walker handles TS-style
+            // `type_annotation` children; the C# branch walks the `type` field.
+            this.extractTypeAnnotations(node, propNode.id);
         }
     }
     /**
@@ -947,8 +971,15 @@ class TreeSitterExtractor {
                 });
                 // Java/Kotlin annotations / TS field decorators sit on the
                 // outer field_declaration, not on the individual declarator.
-                if (fieldNode)
+                if (fieldNode) {
                     this.extractDecoratorsFor(node, fieldNode.id);
+                    // Same as properties: emit `references` to the field's annotated
+                    // type. The outer `field_declaration` is the right scope to
+                    // search from — C# carries the `type` inside `variable_declaration`
+                    // and the language-aware path in `extractTypeAnnotations` descends
+                    // into that wrapper (#381).
+                    this.extractTypeAnnotations(node, fieldNode.id);
+                }
             }
         }
         else {
@@ -1016,6 +1047,11 @@ class TreeSitterExtractor {
                         if (varNode) {
                             this.extractVariableTypeAnnotation(child, varNode.id);
                         }
+                        if (valueNode &&
+                            valueNode.type !== 'object' &&
+                            valueNode.type !== 'object_expression') {
+                            this.visitFunctionBody(valueNode, '');
+                        }
                         // Exported const object-of-functions: `export const actions =
                         // { default: async () => {} }` (SvelteKit form actions / handler maps
                         // / route tables). Extract each function-valued property as a function
@@ -1221,10 +1257,89 @@ class TreeSitterExtractor {
             const value = (0, tree_sitter_helpers_1.getChildByField)(node, 'value');
             if (value) {
                 this.extractTypeRefsFromSubtree(value, typeAliasNode.id);
+                // `type X = { foo: T; bar(): T }` — make the members first-class
+                // property/method nodes under the type alias so `recorder.stop()`
+                // can attach the call edge to `RecorderHandle.stop` instead of
+                // an unrelated class method picked by path-proximity (#359).
+                if (this.language === 'typescript' || this.language === 'tsx') {
+                    this.extractTsTypeAliasMembers(value, typeAliasNode);
+                }
             }
         }
         return false;
     }
+    /**
+     * Surface the members of a TypeScript `type X = { ... }` (or intersection
+     * thereof) as `property` / `method` nodes under the type-alias node. Only
+     * walks the immediate object_type / intersection operands so anonymous
+     * nested object types inside generic arguments (`Promise<{ ok: true }>`)
+     * don't produce phantom members.
+     */
+    extractTsTypeAliasMembers(value, typeAliasNode) {
+        const objectTypes = [];
+        if (value.type === 'object_type') {
+            objectTypes.push(value);
+        }
+        else if (value.type === 'intersection_type') {
+            for (let i = 0; i < value.namedChildCount; i++) {
+                const op = value.namedChild(i);
+                if (op && op.type === 'object_type')
+                    objectTypes.push(op);
+            }
+        }
+        else {
+            return;
+        }
+        this.nodeStack.push(typeAliasNode.id);
+        for (const objType of objectTypes) {
+            for (let i = 0; i < objType.namedChildCount; i++) {
+                const child = objType.namedChild(i);
+                if (!child)
+                    continue;
+                if (child.type !== 'property_signature' && child.type !== 'method_signature')
+                    continue;
+                const nameNode = (0, tree_sitter_helpers_1.getChildByField)(child, 'name');
+                const memberName = nameNode ? (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source) : '';
+                if (!memberName)
+                    continue;
+                // `foo: () => T` and `foo(): T` are functionally a method on the
+                // type contract. Treat the property_signature with a function-typed
+                // annotation as a method too so call sites can resolve to it.
+                const memberKind = child.type === 'method_signature'
+                    ? 'method'
+                    : this.isTsFunctionTypedProperty(child) ? 'method' : 'property';
+                const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(child, this.source);
+                const signature = (0, tree_sitter_helpers_1.getNodeText)(child, this.source);
+                this.createNode(memberKind, memberName, child, {
+                    docstring,
+                    signature,
+                    qualifiedName: `${typeAliasNode.name}::${memberName}`,
+                });
+                // Emit `references` edges from the type alias to types named in the
+                // member's signature, matching the interface-member behavior added in
+                // #432. We attach refs to the type-alias parent (consistent with
+                // interface property_signature treatment).
+                this.extractTypeAnnotations(child, typeAliasNode.id);
+            }
+        }
+        this.nodeStack.pop();
+    }
+    /**
+     * `foo: () => T` → property_signature whose type_annotation contains a
+     * `function_type`. Treat that as a method-shaped contract member, since
+     * the call site `obj.foo()` has identical semantics to `bar(): T`.
+     */
+    isTsFunctionTypedProperty(propertySignature) {
+        const typeAnno = (0, tree_sitter_helpers_1.getChildByField)(propertySignature, 'type');
+        if (!typeAnno)
+            return false;
+        for (let i = 0; i < typeAnno.namedChildCount; i++) {
+            const inner = typeAnno.namedChild(i);
+            if (inner && inner.type === 'function_type')
+                return true;
+        }
+        return false;
+    }
     // extractExportedVariables removed — the walker now descends into
     // export_statement children and the inner declaration's dedicated
     // extractor (extractVariable, extractFunction, extractClass, etc.)
@@ -1373,7 +1488,25 @@ class TreeSitterExtractor {
         if (nameField && objectField && (node.type === 'method_invocation' || node.type === 'member_call_expression' || node.type === 'scoped_call_expression')) {
             // Method call with explicit receiver: receiver.method() / $receiver->method() / ClassName::method()
             const methodName = (0, tree_sitter_helpers_1.getNodeText)(nameField, this.source);
-            let receiverName = (0, tree_sitter_helpers_1.getNodeText)(objectField, this.source);
+            // Java `this.userbo.toLogin2()` parses as method_invocation(object=field_access(this, userbo)).
+            // Without unwrapping, receiverName is `this.userbo` and the name-matcher's
+            // single-dot receiver regex fails. Pull out the immediate field after `this.`
+            // so the receiver is the field name (`userbo`), which the resolver can then
+            // look up in the enclosing class's field declarations.
+            let receiverName;
+            if (objectField.type === 'field_access') {
+                const inner = (0, tree_sitter_helpers_1.getChildByField)(objectField, 'object');
+                const fld = (0, tree_sitter_helpers_1.getChildByField)(objectField, 'field');
+                if (inner && fld && (inner.type === 'this' || inner.type === 'this_expression')) {
+                    receiverName = (0, tree_sitter_helpers_1.getNodeText)(fld, this.source);
+                }
+                else {
+                    receiverName = (0, tree_sitter_helpers_1.getNodeText)(objectField, this.source);
+                }
+            }
+            else {
+                receiverName = (0, tree_sitter_helpers_1.getNodeText)(objectField, this.source);
+            }
             // Strip PHP $ prefix from variable names
             receiverName = receiverName.replace(/^\$/, '');
             if (methodName) {
@@ -1427,10 +1560,11 @@ class TreeSitterExtractor {
         else {
             const func = (0, tree_sitter_helpers_1.getChildByField)(node, 'function') || node.namedChild(0);
             if (func) {
-                if (func.type === 'member_expression' || func.type === 'attribute' || func.type === 'selector_expression' || func.type === 'navigation_expression') {
+                if (func.type === 'member_expression' || func.type === 'attribute' || func.type === 'selector_expression' || func.type === 'navigation_expression' || func.type === 'field_expression') {
                     // Method call: obj.method() or obj.field.method()
                     // Go uses selector_expression with 'field', JS/TS uses member_expression with 'property'
                     // Kotlin uses navigation_expression with navigation_suffix > simple_identifier
+                    // C/C++ use field_expression for both `obj.method()` and `ptr->method()`
                     let property = (0, tree_sitter_helpers_1.getChildByField)(func, 'property') || (0, tree_sitter_helpers_1.getChildByField)(func, 'field');
                     if (!property) {
                         const child1 = func.namedChild(1);
@@ -1448,9 +1582,12 @@ class TreeSitterExtractor {
                         // This helps the resolver distinguish method calls from bare function calls
                         // (e.g., Python's console.print() vs builtin print())
                         // Skip self/this/cls as they don't aid resolution
-                        const receiver = (0, tree_sitter_helpers_1.getChildByField)(func, 'object') || (0, tree_sitter_helpers_1.getChildByField)(func, 'operand') || func.namedChild(0);
+                        const receiver = (0, tree_sitter_helpers_1.getChildByField)(func, 'object') ||
+                            (0, tree_sitter_helpers_1.getChildByField)(func, 'operand') ||
+                            (0, tree_sitter_helpers_1.getChildByField)(func, 'argument') ||
+                            func.namedChild(0);
                         const SKIP_RECEIVERS = new Set(['self', 'this', 'cls', 'super']);
-                        if (receiver && (receiver.type === 'identifier' || receiver.type === 'simple_identifier')) {
+                        if (receiver && (receiver.type === 'identifier' || receiver.type === 'simple_identifier' || receiver.type === 'field_identifier')) {
                             const receiverName = (0, tree_sitter_helpers_1.getNodeText)(receiver, this.source);
                             if (!SKIP_RECEIVERS.has(receiverName)) {
                                 calleeName = `${receiverName}.${methodName}`;
@@ -2083,6 +2220,16 @@ class TreeSitterExtractor {
             return;
         if (!this.TYPE_ANNOTATION_LANGUAGES.has(this.language))
             return;
+        // C# tree-sitter doesn't produce `type_identifier` leaves — it uses
+        // `identifier`, `predefined_type`, `qualified_name`, `generic_name`,
+        // etc. — so the generic walker below emits zero references for it.
+        // Dispatch to a C#-aware path that only walks type-position subtrees
+        // (the `type` field of a parameter/method/property/field), so
+        // parameter NAMES never accidentally surface as type refs (#381).
+        if (this.language === 'csharp') {
+            this.extractCsharpTypeRefs(node, nodeId);
+            return;
+        }
         // Extract parameter type annotations
         const params = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.paramsField || 'parameters');
         if (params) {
@@ -2099,6 +2246,112 @@ class TreeSitterExtractor {
             this.extractTypeRefsFromSubtree(typeAnnotation, nodeId);
         }
     }
+    /**
+     * Extract C# type references from a node that owns a type position —
+     * a method/constructor declaration, a property declaration, or a
+     * field declaration (which wraps `variable_declaration → type`).
+     *
+     * Walks ONLY into known type fields, so parameter names like
+     * `request` in `Build(UserDto request)` are never mis-emitted as
+     * type references. Once inside a type subtree, `walkCsharpTypePosition`
+     * recognizes C#'s actual type-leaf node kinds (`identifier`,
+     * `qualified_name`, `generic_name`, `array_type`, `nullable_type`,
+     * `tuple_type`, …) — none of which are `type_identifier`. Closes #381.
+     */
+    extractCsharpTypeRefs(node, nodeId) {
+        // Return type / property type — the field is named `type`.
+        const directType = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
+        if (directType)
+            this.walkCsharpTypePosition(directType, nodeId);
+        // Field declarations wrap declarators in a `variable_declaration`
+        // whose `type` field carries the type. The outer `field_declaration`
+        // has no `type` field of its own, so the call above is a no-op here
+        // and we descend one level.
+        const varDecl = node.namedChildren.find((c) => c.type === 'variable_declaration');
+        if (varDecl) {
+            const vdType = (0, tree_sitter_helpers_1.getChildByField)(varDecl, 'type');
+            if (vdType)
+                this.walkCsharpTypePosition(vdType, nodeId);
+        }
+        // Method / constructor parameters. The field name on
+        // `method_declaration` is `parameters`; it points at a
+        // `parameter_list` whose `parameter` children each have their own
+        // `type` field. Walking ONLY the type field skips parameter NAMES,
+        // which would otherwise mis-emit as type references.
+        const params = (0, tree_sitter_helpers_1.getChildByField)(node, 'parameters');
+        if (params) {
+            for (let i = 0; i < params.namedChildCount; i++) {
+                const child = params.namedChild(i);
+                if (!child || child.type !== 'parameter')
+                    continue;
+                const paramType = (0, tree_sitter_helpers_1.getChildByField)(child, 'type');
+                if (paramType)
+                    this.walkCsharpTypePosition(paramType, nodeId);
+            }
+        }
+    }
+    /**
+     * Walk a C# subtree that is KNOWN to be in a type position
+     * (return type, parameter type, property type, field type, generic
+     * argument). Identifiers here are type names, not parameter names.
+     */
+    walkCsharpTypePosition(node, fromNodeId) {
+        // `predefined_type` is int/string/bool/etc. — never a project ref.
+        if (node.type === 'predefined_type')
+            return;
+        // Bare type name: `Foo` in `Foo bar`, or the `Foo` inside `List<Foo>`.
+        if (node.type === 'identifier') {
+            const name = (0, tree_sitter_helpers_1.getNodeText)(node, this.source);
+            if (name && !this.BUILTIN_TYPES.has(name)) {
+                this.unresolvedReferences.push({
+                    fromNodeId,
+                    referenceName: name,
+                    referenceKind: 'references',
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column,
+                });
+            }
+            return;
+        }
+        // `Namespace.Foo` → the rightmost identifier is the type. Emit the
+        // full qualified name as the reference; the resolver can still match
+        // on the trailing simple name when needed.
+        if (node.type === 'qualified_name') {
+            const text = (0, tree_sitter_helpers_1.getNodeText)(node, this.source);
+            const last = text.split('.').pop() ?? text;
+            if (last && !this.BUILTIN_TYPES.has(last)) {
+                this.unresolvedReferences.push({
+                    fromNodeId,
+                    referenceName: last,
+                    referenceKind: 'references',
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column,
+                });
+            }
+            return;
+        }
+        // `(int Code, Foo Payload)` — tuple element has BOTH a `type` and a
+        // `name` field; descending into all named children would mis-emit
+        // the element name (`Code`, `Payload`) as a type ref. Walk only the
+        // type field.
+        if (node.type === 'tuple_element') {
+            const t = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
+            if (t)
+                this.walkCsharpTypePosition(t, fromNodeId);
+            return;
+        }
+        // Composite type nodes — recurse into named children. Covers
+        // `generic_name` (head identifier + `type_argument_list`),
+        // `nullable_type`, `array_type`, `pointer_type`, `tuple_type`,
+        // `ref_type`, and any newer wrapping shapes the grammar adds.
+        // Identifiers reached here are all type-positional (parameter/field
+        // names are gated out before we descend).
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child)
+                this.walkCsharpTypePosition(child, fromNodeId);
+        }
+    }
     /**
      * Extract type references from a variable's type annotation.
      */
@@ -2535,10 +2788,17 @@ function extractFromSource(filePath, source, language, frameworkNames) {
         const extractor = new liquid_extractor_1.LiquidExtractor(filePath, source);
         result = extractor.extract();
     }
-    else if (detectedLanguage === 'yaml' || detectedLanguage === 'twig') {
-        // No symbol extraction — file is tracked at the file-record level only.
-        // Framework extractors (e.g. Drupal routing resolver) run below and may
-        // add route nodes / references for yaml files such as *.routing.yml.
+    else if (detectedLanguage === 'xml') {
+        // Custom extractor for MyBatis mapper XML. Non-mapper XML returns just a
+        // file node so the watcher tracks it without emitting symbols.
+        const extractor = new mybatis_extractor_1.MyBatisExtractor(filePath, source);
+        result = extractor.extract();
+    }
+    else if (detectedLanguage === 'yaml' || detectedLanguage === 'twig' || detectedLanguage === 'properties') {
+        // No symbol extraction at this stage — files are tracked at the file-record
+        // level only. Framework extractors (Drupal routing yml, Spring `@Value`
+        // resolution against application.yml/application.properties) run later and
+        // add per-file nodes/references when they apply.
         result = { nodes: [], edges: [], unresolvedReferences: [], errors: [], durationMs: 0 };
     }
     else if (detectedLanguage === 'pascal' &&