@stupidloud/codegraph 0.8.1 → 0.9.9

package/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");
@@ -56,6 +57,9 @@ Object.defineProperty(exports, "generateNodeId", { enumerable: true, get: functi
  * Extract the name from a node based on language
  */
 function extractName(node, source, extractor) {
+    const hookName = extractor.resolveName?.(node, source);
+    if (hookName)
+        return hookName;
     // Try field name first
     const nameNode = (0, tree_sitter_helpers_1.getChildByField)(node, extractor.nameField);
     if (nameNode) {
@@ -72,6 +76,19 @@ function extractName(node, source, extractor) {
             const innerName = (0, tree_sitter_helpers_1.getChildByField)(resolved, 'declarator') || resolved.namedChild(0);
             return innerName ? (0, tree_sitter_helpers_1.getNodeText)(innerName, source) : (0, tree_sitter_helpers_1.getNodeText)(resolved, source);
         }
+        // Lua: `function t.f()` / `function t:m()` — the name node is a dot/method
+        // index expression; the simple name is the trailing field/method (the table
+        // receiver is captured separately via getReceiverType).
+        if (resolved.type === 'dot_index_expression') {
+            const field = (0, tree_sitter_helpers_1.getChildByField)(resolved, 'field');
+            if (field)
+                return (0, tree_sitter_helpers_1.getNodeText)(field, source);
+        }
+        if (resolved.type === 'method_index_expression') {
+            const method = (0, tree_sitter_helpers_1.getChildByField)(resolved, 'method');
+            if (method)
+                return (0, tree_sitter_helpers_1.getNodeText)(method, source);
+        }
         return (0, tree_sitter_helpers_1.getNodeText)(resolved, source);
     }
     // For Dart method_signature, look inside inner signature types
@@ -205,7 +222,16 @@ class TreeSitterExtractor {
             this.nodes.push(fileNode);
             // Push file node onto stack so top-level declarations get contains edges
             this.nodeStack.push(fileNode.id);
+            // File-level package declaration (Kotlin/Java). Creates an implicit
+            // `namespace` node wrapping every top-level declaration so their
+            // qualifiedName carries the FQN — required for cross-file import
+            // resolution on JVM languages where filename ≠ class name.
+            const packageNodeId = this.extractFilePackage(this.tree.rootNode);
+            if (packageNodeId)
+                this.nodeStack.push(packageNodeId);
             this.visitNode(this.tree.rootNode);
+            if (packageNodeId)
+                this.nodeStack.pop();
             this.nodeStack.pop();
         }
         catch (error) {
@@ -370,6 +396,17 @@ class TreeSitterExtractor {
         // their own `calls` refs.
         else if (INSTANTIATION_KINDS.has(nodeType)) {
             this.extractInstantiation(node);
+            // Java/C# `new T(...) { ... }` — anonymous class with body. Without
+            // extracting it as a class node + its methods, the interface→impl
+            // synthesizer (Phase 5.5) can't bridge T's abstract methods to the
+            // anonymous overrides, and an agent investigating a call through T
+            // (`strategy.iterator(...)` where strategy is a Strategy lambda body)
+            // has to Read the file to find the actual implementation.
+            const anonBody = this.findAnonymousClassBody(node);
+            if (anonBody) {
+                this.extractAnonymousClass(node, anonBody);
+                skipChildren = true;
+            }
         }
         // (Decorator handling lives inside the symbol-creating extractors
         // — extractClass / extractFunction / extractProperty — because the
@@ -379,6 +416,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++) {
@@ -399,6 +450,19 @@ class TreeSitterExtractor {
             return null;
         }
         const id = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, kind, name, node.startPosition.row + 1);
+        // Some grammars (e.g. Dart) model a function/method body as a *sibling* of
+        // the signature node, so the declaration node's own range is just the
+        // signature line. Extend endLine to the resolved body when it sits beyond
+        // the node so the node spans its body — required for any body-level analysis
+        // (callees, the callback synthesizer's body scan, context slices). Guarded to
+        // only ever extend: for child-body grammars the body is within range (no-op).
+        let endLine = node.endPosition.row + 1;
+        if (kind === 'function' || kind === 'method') {
+            const body = this.extractor?.resolveBody?.(node, this.extractor.bodyField);
+            if (body && body.endPosition.row + 1 > endLine) {
+                endLine = body.endPosition.row + 1;
+            }
+        }
         const newNode = {
             id,
             kind,
@@ -407,7 +471,7 @@ class TreeSitterExtractor {
             filePath: this.filePath,
             language: this.language,
             startLine: node.startPosition.row + 1,
-            endLine: node.endPosition.row + 1,
+            endLine,
             startColumn: node.startPosition.column,
             endColumn: node.endPosition.column,
             updatedAt: Date.now(),
@@ -439,6 +503,32 @@ class TreeSitterExtractor {
         }
         return null;
     }
+    /**
+     * Find a `packageTypes` child under the root, create a `namespace` node
+     * for it, and return its id so the caller can scope top-level
+     * declarations underneath. Returns null when no package header is
+     * present (script files, .kts without a package).
+     */
+    extractFilePackage(rootNode) {
+        const types = this.extractor?.packageTypes;
+        if (!types || types.length === 0 || !this.extractor?.extractPackage)
+            return null;
+        let pkgNode = null;
+        for (let i = 0; i < rootNode.namedChildCount; i++) {
+            const child = rootNode.namedChild(i);
+            if (child && types.includes(child.type)) {
+                pkgNode = child;
+                break;
+            }
+        }
+        if (!pkgNode)
+            return null;
+        const pkgName = this.extractor.extractPackage(pkgNode, this.source);
+        if (!pkgName)
+            return null;
+        const ns = this.createNode('namespace', pkgName, pkgNode);
+        return ns?.id ?? null;
+    }
     /**
      * Build qualified name from node stack
      */
@@ -497,7 +587,7 @@ class TreeSitterExtractor {
     /**
      * Extract a function
      */
-    extractFunction(node) {
+    extractFunction(node, nameOverride) {
         if (!this.extractor)
             return;
         // If the language provides getReceiverType and this function has a receiver
@@ -506,12 +596,17 @@ class TreeSitterExtractor {
             this.extractMethod(node);
             return;
         }
-        let name = extractName(node, this.source, this.extractor);
+        // nameOverride is supplied only for explicitly-named anonymous functions the
+        // caller resolved itself (e.g. arrow values of exported-const object members
+        // — SvelteKit actions). Inline-object arrows reached by the general walker
+        // get no override, so they still fall through to the <anonymous> skip below.
+        let name = nameOverride ?? extractName(node, this.source, this.extractor);
         // For arrow functions and function expressions assigned to variables,
         // resolve the name from the parent variable_declarator.
         // e.g. `export const useAuth = () => { ... }` — the arrow_function node
         // has no `name` field; the name lives on the variable_declarator.
-        if (name === '<anonymous>' &&
+        if (!nameOverride &&
+            name === '<anonymous>' &&
             (node.type === 'arrow_function' || node.type === 'function_expression')) {
             const parent = node.parent;
             if (parent?.type === 'variable_declarator') {
@@ -521,8 +616,19 @@ class TreeSitterExtractor {
                 }
             }
         }
-        if (name === '<anonymous>')
-            return; // Skip anonymous functions
+        if (name === '<anonymous>') {
+            // Don't emit a node for the anonymous wrapper itself, but still visit its
+            // body: AMD/RequireJS and CommonJS module wrappers (`define([], function(){…})`,
+            // `(function(){…})()`) hold named inner functions and calls that would
+            // otherwise be lost — the dispatcher set skipChildren, so nothing else
+            // descends into this subtree. (#528)
+            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;
+        }
         // Check for misparse artifacts (e.g. C++ macros causing "namespace detail" functions)
         // Skip the node but still visit the body for calls and structural nodes
         if (this.extractor.isMisparsedFunction?.(name, node)) {
@@ -617,6 +723,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
@@ -818,12 +929,13 @@ class TreeSitterExtractor {
         const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         const visibility = this.extractor.getVisibility?.(node);
         const isStatic = this.extractor.isStatic?.(node) ?? false;
-        // Property name is a direct identifier child
-        const nameNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'name')
-            || node.namedChildren.find(c => c.type === 'identifier');
-        if (!nameNode)
+        const hookName = this.extractor.extractPropertyName?.(node, this.source);
+        const nameNode = hookName
+            ? null
+            : (0, tree_sitter_helpers_1.getChildByField)(node, 'name') || node.namedChildren.find(c => c.type === 'identifier');
+        const name = hookName ?? (nameNode ? (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source) : null);
+        if (!name)
             return;
-        const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
         // Get property type from the type child (first named child that isn't modifier or identifier)
         const typeNode = node.namedChildren.find(c => c.type !== 'modifier' && c.type !== 'modifiers'
             && c.type !== 'identifier' && c.type !== 'accessor_list'
@@ -840,6 +952,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);
         }
     }
     /**
@@ -912,8 +1028,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 {
@@ -930,6 +1053,114 @@ class TreeSitterExtractor {
             }
         }
     }
+    /**
+     * Extract function-valued properties of an object literal as named function
+     * nodes (named by their property key). Shared by the two object-of-functions
+     * shapes in extractVariable: the object as a direct const value, and the
+     * object returned by a store-initializer call. Handles both `key: () => {}` /
+     * `key: function() {}` pairs and method shorthand `key() {}`.
+     */
+    extractObjectLiteralFunctions(obj) {
+        for (let i = 0; i < obj.namedChildCount; i++) {
+            const member = obj.namedChild(i);
+            if (!member)
+                continue;
+            if (member.type === 'pair') {
+                const key = (0, tree_sitter_helpers_1.getChildByField)(member, 'key');
+                const value = (0, tree_sitter_helpers_1.getChildByField)(member, 'value');
+                if (key && value && (value.type === 'arrow_function' || value.type === 'function_expression')) {
+                    this.extractFunction(value, this.objectKeyName(key));
+                }
+            }
+            else if (member.type === 'method_definition') {
+                // Method shorthand: `{ fetchUser() {...} }`. extractMethod deliberately
+                // skips object-literal methods, so route through extractFunction with an
+                // explicit name (method_definition exposes a `body` field, so resolveBody
+                // falls through to it and the node spans the full method).
+                const key = (0, tree_sitter_helpers_1.getChildByField)(member, 'name');
+                if (key)
+                    this.extractFunction(member, this.objectKeyName(key));
+            }
+        }
+    }
+    /** Property-key text with surrounding quotes stripped (`'foo'` → `foo`). */
+    objectKeyName(key) {
+        return (0, tree_sitter_helpers_1.getNodeText)(key, this.source).replace(/^['"`]|['"`]$/g, '');
+    }
+    /**
+     * Given a `call_expression` initializer (`create((set, get) => ({...}))`),
+     * find the object literal RETURNED by a function argument — descending through
+     * nested call_expression arguments so middleware wrappers are unwrapped
+     * (`create(persist((set, get) => ({...}), {...}))`, devtools, immer,
+     * subscribeWithSelector). Returns null when no such object is found — the
+     * common case for ordinary call initializers — so this stays cheap and silent
+     * rather than guessing. Keyed purely on AST shape; no library names.
+     */
+    findInitializerReturnedObject(callNode, depth = 0) {
+        if (depth > 4)
+            return null;
+        const args = (0, tree_sitter_helpers_1.getChildByField)(callNode, 'arguments');
+        if (!args)
+            return null;
+        for (let i = 0; i < args.namedChildCount; i++) {
+            const arg = args.namedChild(i);
+            if (!arg)
+                continue;
+            if (arg.type === 'arrow_function' || arg.type === 'function_expression') {
+                const obj = this.functionReturnedObject(arg);
+                if (obj)
+                    return obj;
+            }
+            else if (arg.type === 'call_expression') {
+                const obj = this.findInitializerReturnedObject(arg, depth + 1);
+                if (obj)
+                    return obj;
+            }
+        }
+        return null;
+    }
+    /**
+     * The object literal a function expression returns — either the `=> ({...})`
+     * arrow form (a parenthesized_expression wrapping an object) or a
+     * `=> { return {...} }` block. Returns null for any other body shape.
+     */
+    functionReturnedObject(fnNode) {
+        const body = (0, tree_sitter_helpers_1.getChildByField)(fnNode, 'body');
+        if (!body)
+            return null;
+        const asObject = (n) => {
+            if (!n)
+                return null;
+            if (n.type === 'object' || n.type === 'object_expression')
+                return n;
+            if (n.type === 'parenthesized_expression') {
+                for (let i = 0; i < n.namedChildCount; i++) {
+                    const inner = asObject(n.namedChild(i));
+                    if (inner)
+                        return inner;
+                }
+            }
+            return null;
+        };
+        // `(set, get) => ({...})` — body is the (parenthesized) object directly.
+        const direct = asObject(body);
+        if (direct)
+            return direct;
+        // `(set, get) => { return {...} }` — scan top-level return statements.
+        if (body.type === 'statement_block') {
+            for (let i = 0; i < body.namedChildCount; i++) {
+                const stmt = body.namedChild(i);
+                if (stmt?.type !== 'return_statement')
+                    continue;
+                for (let j = 0; j < stmt.namedChildCount; j++) {
+                    const obj = asObject(stmt.namedChild(j));
+                    if (obj)
+                        return obj;
+                }
+            }
+        }
+        return null;
+    }
     /**
      * Extract a variable declaration (const, let, var, etc.)
      *
@@ -981,6 +1212,42 @@ class TreeSitterExtractor {
                         if (varNode) {
                             this.extractVariableTypeAnnotation(child, varNode.id);
                         }
+                        // Exported const object-of-functions — extract each function-valued
+                        // property as a function named by its key + walk its body so its
+                        // calls are captured. Two shapes, both keyed on AST shape (not on any
+                        // library name):
+                        //   `export const actions = { default: async () => {} }` — object is
+                        //     the DIRECT value (SvelteKit form actions / handler maps / route
+                        //     tables).
+                        //   `export const useStore = create((set, get) => ({ fetchUser:
+                        //     async () => {} }))` — object is RETURNED by an initializer call,
+                        //     possibly through middleware wrappers (persist/devtools/immer).
+                        //     Covers Zustand/Redux/Pinia/MobX stores generically. Without
+                        //     this, store actions exist only as object-literal properties —
+                        //     never nodes — so `node`/`callers` on `fetchUser` return "not
+                        //     found" and the agent Reads the store to reconstruct the flow.
+                        // Scoped to EXPORTED consts to exclude inline-object noise
+                        // (`ctx.set({...})`) the object-method skip deliberately avoids.
+                        const objectOfFns = valueNode && (valueNode.type === 'object' || valueNode.type === 'object_expression')
+                            ? valueNode
+                            : valueNode?.type === 'call_expression'
+                                ? this.findInitializerReturnedObject(valueNode)
+                                : null;
+                        const extractObjectMethods = isExported && !!objectOfFns;
+                        // Visit the initializer body for calls — EXCEPT object literals (their
+                        // function-valued properties are extracted below) and the store-factory
+                        // call whose returned object we extract method-by-method below (walking
+                        // the whole call would re-visit those method arrows and mis-attribute
+                        // their inner calls to the file/module scope).
+                        if (valueNode &&
+                            valueNode.type !== 'object' &&
+                            valueNode.type !== 'object_expression' &&
+                            !(extractObjectMethods && valueNode.type === 'call_expression')) {
+                            this.visitFunctionBody(valueNode, '');
+                        }
+                        if (extractObjectMethods && objectOfFns) {
+                            this.extractObjectLiteralFunctions(objectOfFns);
+                        }
                     }
                 }
             }
@@ -1039,6 +1306,25 @@ class TreeSitterExtractor {
                 }
             }
         }
+        else if (this.language === 'lua' || this.language === 'luau') {
+            // Lua/Luau: variable_declaration → assignment_statement → variable_list
+            //      (name: identifier...) = expression_list. `local x, y = 1, 2`
+            //      declares multiple names; only plain identifiers are locals.
+            const assign = node.namedChildren.find((c) => c.type === 'assignment_statement') ?? node;
+            const varList = assign.namedChildren.find((c) => c.type === 'variable_list');
+            const exprList = assign.namedChildren.find((c) => c.type === 'expression_list');
+            const values = exprList ? exprList.namedChildren : [];
+            const names = varList ? varList.namedChildren.filter((c) => c.type === 'identifier') : [];
+            names.forEach((nameNode, i) => {
+                const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+                if (!name)
+                    return;
+                const valueNode = values[i];
+                const initValue = valueNode ? (0, tree_sitter_helpers_1.getNodeText)(valueNode, this.source).slice(0, 100) : undefined;
+                const initSignature = initValue ? `= ${initValue}${initValue.length >= 100 ? '...' : ''}` : undefined;
+                this.createNode(kind, name, nameNode, { docstring, signature: initSignature, isExported });
+            });
+        }
         else {
             // Generic fallback for other languages
             // Try to find identifier children
@@ -1148,10 +1434,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.)
@@ -1300,7 +1665,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) {
@@ -1314,13 +1697,51 @@ class TreeSitterExtractor {
                 }
             }
         }
+        else if (node.type === 'message_expression') {
+            // ObjC message expressions emit one `method` field child per selector
+            // keyword: `[obj a:1 b:2 c:3]` has three `method=identifier` siblings.
+            // Joining them with `:` reconstructs the full selector and matches the
+            // multi-part selector names produced by the ObjC method_definition
+            // extractor (`extractObjcMethodName` in languages/objc.ts). Without this
+            // join, multi-keyword call sites only emitted the first keyword and never
+            // resolved to their target methods (e.g. `GET:parameters:headers:...` had
+            // zero callers despite obviously being called).
+            const methodKeywords = [];
+            for (let i = 0; i < node.namedChildCount; i++) {
+                if (node.fieldNameForNamedChild(i) === 'method') {
+                    const kw = node.namedChild(i);
+                    if (kw)
+                        methodKeywords.push((0, tree_sitter_helpers_1.getNodeText)(kw, this.source));
+                }
+            }
+            if (methodKeywords.length > 0) {
+                const methodName = methodKeywords.length === 1
+                    ? methodKeywords[0]
+                    : methodKeywords.map((k) => `${k}:`).join('');
+                const receiverField = (0, tree_sitter_helpers_1.getChildByField)(node, 'receiver');
+                const SKIP_RECEIVERS = new Set(['self', 'super']);
+                if (receiverField && receiverField.type !== 'message_expression') {
+                    const receiverName = (0, tree_sitter_helpers_1.getNodeText)(receiverField, this.source);
+                    if (receiverName && !SKIP_RECEIVERS.has(receiverName)) {
+                        calleeName = `${receiverName}.${methodName}`;
+                    }
+                    else {
+                        calleeName = methodName;
+                    }
+                }
+                else {
+                    calleeName = methodName;
+                }
+            }
+        }
         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);
@@ -1338,9 +1759,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}`;
@@ -1421,6 +1845,76 @@ class TreeSitterExtractor {
             });
         }
     }
+    /**
+     * Find a `class_body` child of an `object_creation_expression` — the
+     * marker for an anonymous class (`new T() { ... }`). Returns the body
+     * node so the caller can walk it as the anon class's members.
+     */
+    findAnonymousClassBody(node) {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            // Java: `class_body`. C# uses the same node kind.
+            if (child && (child.type === 'class_body' || child.type === 'declaration_list')) {
+                return child;
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract a Java/C# anonymous class — `new T() { ...members }`. Emits a
+     * `class` node named `<T$anon@line>`, an `extends` reference to T (so
+     * Phase 5.5 interface-impl can bridge), and walks the body so its
+     * `method_declaration` members become method nodes under the anon class.
+     *
+     * Why this matters: without anon-class extraction, the overrides inside
+     * a lambda-returned `new T() { @Override int foo(){...} }` are not nodes,
+     * so a call through T.foo (the abstract parent method) has no static
+     * target — the agent has to Read the file to find the implementation.
+     */
+    extractAnonymousClass(node, body) {
+        if (!this.extractor)
+            return;
+        // The instantiated type sits in the same field/position that
+        // extractInstantiation reads from. Use the same lookup so the anon
+        // class's `extends` target matches the `instantiates` edge.
+        const typeNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'constructor') ||
+            (0, tree_sitter_helpers_1.getChildByField)(node, 'type') ||
+            (0, tree_sitter_helpers_1.getChildByField)(node, 'name') ||
+            node.namedChild(0);
+        let typeName = typeNode ? (0, tree_sitter_helpers_1.getNodeText)(typeNode, this.source) : 'Object';
+        const ltIdx = typeName.indexOf('<');
+        if (ltIdx > 0)
+            typeName = typeName.slice(0, ltIdx);
+        const lastDot = Math.max(typeName.lastIndexOf('.'), typeName.lastIndexOf('::'));
+        if (lastDot >= 0)
+            typeName = typeName.slice(lastDot + 1).replace(/^[:.]/, '');
+        typeName = typeName.trim() || 'Object';
+        const anonName = `<${typeName}$anon@${node.startPosition.row + 1}>`;
+        const classNode = this.createNode('class', anonName, node, {});
+        if (!classNode)
+            return;
+        // The anonymous class implicitly extends/implements the named type.
+        // We can't tell at extraction time whether T is a class or an interface,
+        // so emit `extends`. Resolution will still bind T to whatever it is, and
+        // Phase 5.5 (which already handles both `extends` and `implements`) will
+        // bridge T's methods to the override names found in the anon body.
+        this.unresolvedReferences.push({
+            fromNodeId: classNode.id,
+            referenceName: typeName,
+            referenceKind: 'extends',
+            line: typeNode?.startPosition.row ?? node.startPosition.row,
+            column: typeNode?.startPosition.column ?? node.startPosition.column,
+        });
+        // Walk the body's children so method_declaration nodes inside become
+        // method nodes scoped to the anon class.
+        this.nodeStack.push(classNode.id);
+        for (let i = 0; i < body.namedChildCount; i++) {
+            const child = body.namedChild(i);
+            if (child)
+                this.visitNode(child);
+        }
+        this.nodeStack.pop();
+    }
     /**
      * Scan `declNode` and its preceding siblings (within the parent's
      * named children) for decorator nodes, emitting a `decorates`
@@ -1551,6 +2045,14 @@ class TreeSitterExtractor {
                 // about `call_expression`, so constructor invocations
                 // produced no graph edges at all.
                 this.extractInstantiation(node);
+                // Anonymous class with body: `new T() { ... }` (Java/C#). Extract as
+                // a class so interface-impl synthesis (Phase 5.5) can bridge T's
+                // methods to the overrides — same rationale as in visitNode.
+                const anonBody = this.findAnonymousClassBody(node);
+                if (anonBody) {
+                    this.extractAnonymousClass(node, anonBody);
+                    return;
+                }
             }
             else if (this.extractor.extractBareCall) {
                 const calleeName = this.extractor.extractBareCall(node, this.source);
@@ -1567,6 +2069,20 @@ class TreeSitterExtractor {
                     }
                 }
             }
+            // Nested NAMED functions inside a body — function declarations and named
+            // function expressions like `.on('mount', function onmount(){})` — become
+            // their own nodes so the graph can link to them (callback handlers, local
+            // helpers). Anonymous arrows/expressions fall through to the default
+            // recursion below, keeping their inner calls attributed to the enclosing
+            // function: this bounds the new nodes to NAMED functions only (no explosion,
+            // no lost edges). extractFunction walks the nested body itself, so we return.
+            if (this.extractor.functionTypes.includes(nodeType)) {
+                const nestedName = extractName(node, this.source, this.extractor);
+                if (nestedName && nestedName !== '<anonymous>') {
+                    this.extractFunction(node);
+                    return;
+                }
+            }
             // Extract structural nodes found inside function bodies.
             // Each extract method visits its own children, so we return after extracting.
             if (this.extractor.classTypes.includes(nodeType)) {
@@ -1608,6 +2124,42 @@ class TreeSitterExtractor {
      * Extract inheritance relationships
      */
     extractInheritance(node, classId) {
+        // Objective-C @interface MyClass : NSObject <ProtoA, ProtoB>
+        if (node.type === 'class_interface') {
+            const superclass = (0, tree_sitter_helpers_1.getChildByField)(node, 'superclass');
+            if (superclass) {
+                const name = (0, tree_sitter_helpers_1.getNodeText)(superclass, this.source);
+                this.unresolvedReferences.push({
+                    fromNodeId: classId,
+                    referenceName: name,
+                    referenceKind: 'extends',
+                    line: superclass.startPosition.row + 1,
+                    column: superclass.startPosition.column,
+                });
+            }
+            for (let j = 0; j < node.namedChildCount; j++) {
+                const argList = node.namedChild(j);
+                if (argList?.type !== 'parameterized_arguments')
+                    continue;
+                for (let k = 0; k < argList.namedChildCount; k++) {
+                    const typeName = argList.namedChild(k);
+                    if (!typeName)
+                        continue;
+                    const typeId = typeName.namedChildren.find((c) => c.type === 'type_identifier' || c.type === 'identifier');
+                    if (!typeId)
+                        continue;
+                    const protocolName = (0, tree_sitter_helpers_1.getNodeText)(typeId, this.source);
+                    this.unresolvedReferences.push({
+                        fromNodeId: classId,
+                        referenceName: protocolName,
+                        referenceKind: 'implements',
+                        line: typeId.startPosition.row + 1,
+                        column: typeId.startPosition.column,
+                    });
+                }
+            }
+            return;
+        }
         // Look for extends/implements clauses
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
@@ -1635,6 +2187,24 @@ class TreeSitterExtractor {
                     }
                 }
             }
+            // C++ base classes: `class Derived : public Base, private Other` →
+            // base_class_clause holds access specifiers + base type(s). Emit an extends
+            // ref per base type (skip the public/private/protected keywords).
+            if (child.type === 'base_class_clause') {
+                for (const t of child.namedChildren) {
+                    if (t.type === 'type_identifier' ||
+                        t.type === 'qualified_identifier' ||
+                        t.type === 'template_type') {
+                        this.unresolvedReferences.push({
+                            fromNodeId: classId,
+                            referenceName: (0, tree_sitter_helpers_1.getNodeText)(t, this.source),
+                            referenceKind: 'extends',
+                            line: t.startPosition.row + 1,
+                            column: t.startPosition.column,
+                        });
+                    }
+                }
+            }
             if (child.type === 'implements_clause' ||
                 child.type === 'class_interface_clause' ||
                 child.type === 'super_interfaces' || // Java class implements
@@ -1905,6 +2475,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) {
@@ -1921,6 +2501,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.
      */
@@ -2357,6 +3043,19 @@ function extractFromSource(filePath, source, language, frameworkNames) {
         const extractor = new liquid_extractor_1.LiquidExtractor(filePath, source);
         result = extractor.extract();
     }
+    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 ((0, grammars_1.isFileLevelOnlyLanguage)(detectedLanguage)) {
+        // 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' &&
         (fileExtension === '.dfm' || fileExtension === '.fmx')) {
         // Use custom extractor for DFM/FMX form files