homegraph 1.1.3 → 1.4.1

package/dist/extraction/tree-sitter.js

@@ -46,6 +46,7 @@ const tree_sitter_helpers_1 = require("./tree-sitter-helpers");
 const function_ref_1 = require("./function-ref");
 const generated_detection_1 = require("./generated-detection");
 const languages_1 = require("./languages");
+const c_cpp_1 = require("./languages/c-cpp");
 const liquid_extractor_1 = require("./liquid-extractor");
 const razor_extractor_1 = require("./razor-extractor");
 const svelte_extractor_1 = require("./svelte-extractor");
@@ -53,6 +54,7 @@ const astro_extractor_1 = require("./astro-extractor");
 const dfm_extractor_1 = require("./dfm-extractor");
 const vue_extractor_1 = require("./vue-extractor");
 const mybatis_extractor_1 = require("./mybatis-extractor");
+const cfml_extractor_1 = require("./cfml-extractor");
 const arkts_1 = require("./languages/arkts");
 const frameworks_1 = require("../resolution/frameworks");
 // Re-export for backward compatibility
@@ -77,24 +79,68 @@ const VUE_STORE_FACTORY_CALLEES = new Set(['defineStore', 'createStore']);
 /** Distinct signals that a file is a Vuex/Pinia store (≥2 ⇒ treat a bare
  *  `const actions = {…}` as a store collection — see looksLikeVueStoreFile). */
 const VUE_STORE_FILE_SIGNAL = /\bdefineStore\b|\bcreateStore\b|\bVuex\b|\bmutations\b|\bactions\b|\bgetters\b|\bnamespaced\b/g;
+/**
+ * Erlang calls that take their real callee as (Module, Function, Args)
+ * ARGUMENTS — the spawn/apply family. Keys are the callee as the call site
+ * spells it: bare for auto-imported BIFs, `module:function` for remote calls.
+ * Used by the erlang branch of extractCall to lift a static MFA pair into a
+ * call edge (the spawned/applied function is otherwise invisible to the graph).
+ */
+/** Compiler-predefined Erlang macros — no `-define` exists to link a use to. */
+const ERLANG_PREDEFINED_MACROS = new Set([
+    'MODULE', 'MODULE_STRING', 'FILE', 'LINE', 'MACHINE',
+    'FUNCTION_NAME', 'FUNCTION_ARITY', 'OTP_RELEASE',
+    'FEATURE_AVAILABLE', 'FEATURE_ENABLED',
+]);
+const ERLANG_MFA_CALLS = new Set([
+    'spawn', 'spawn_link', 'spawn_monitor', 'spawn_opt', 'apply',
+    'erlang:spawn', 'erlang:spawn_link', 'erlang:spawn_monitor', 'erlang:spawn_opt', 'erlang:apply',
+    'proc_lib:spawn', 'proc_lib:spawn_link', 'proc_lib:spawn_opt', 'proc_lib:start', 'proc_lib:start_link',
+    'timer:apply_after', 'timer:apply_interval',
+    'rpc:call', 'rpc:cast', 'rpc:async_call',
+    'erpc:call', 'erpc:cast',
+]);
 /**
  * Extract the name from a node based on language
  */
 function extractName(node, source, extractor) {
+    const name = extractNameRaw(node, source, extractor);
+    // Universal fallback: recover a real identifier from a name still mangled by a
+    // macro the pre-parse didn't blank (C/C++ only — see recoverMangledName). A
+    // no-op on well-formed names, so a clean name is never altered.
+    return extractor.recoverMangledName ? extractor.recoverMangledName(name) : name;
+}
+function extractNameRaw(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) {
-        // Unwrap pointer_declarator(s) for C/C++ pointer return types
+        // Unwrap pointer_declarator / reference_declarator for C/C++ pointer and
+        // reference return types (`int* f()`, `int& f()`, `int&& f()`). Without
+        // unwrapping the reference wrapper an inline reference-returning method is
+        // named "& f() const" instead of "f" — common in Unreal Engine gameplay
+        // headers (`const FGameplayTagContainer& GetActiveTags() const`). Out-of-line
+        // defs (`T& C::f()`) already resolve via the qualified-name hook. A
+        // pointer_declarator exposes its inner through a `declarator` field; a
+        // reference_declarator has none, so it's reached via namedChild(0).
         let resolved = nameNode;
-        while (resolved.type === 'pointer_declarator') {
+        while (resolved.type === 'pointer_declarator' || resolved.type === 'reference_declarator') {
             const inner = (0, tree_sitter_helpers_1.getChildByField)(resolved, 'declarator') || resolved.namedChild(0);
             if (!inner)
                 break;
             resolved = inner;
         }
+        // C++ user-defined conversion operator: the declarator is an `operator_cast`
+        // whose first child is the target type and second is the `() const` tail. Name
+        // it `operator <type>` (the conventional spelling) rather than the whole
+        // `operator EALSMovementState() const` declarator, so it matches symbolic
+        // overloads (`operator+`) and is findable by the type name.
+        if (resolved.type === 'operator_cast') {
+            const typeNode = resolved.namedChild(0);
+            return typeNode ? `operator ${(0, tree_sitter_helpers_1.getNodeText)(typeNode, source).trim()}` : (0, tree_sitter_helpers_1.getNodeText)(resolved, source);
+        }
         // Handle complex declarators (C/C++)
         if (resolved.type === 'function_declarator' || resolved.type === 'declarator') {
             const innerName = (0, tree_sitter_helpers_1.getChildByField)(resolved, 'declarator') || resolved.namedChild(0);
@@ -324,7 +370,7 @@ class TreeSitterExtractor {
     // Value-reference edges (default ON; set HOMEGRAPH_VALUE_REFS=0 to disable; see flushValueRefs).
     // Same-file reads of file-scope const/var symbols → `references` edges so impact analysis catches
     // value consumers ("change this constant/table, affect its readers").
-    static VALUE_REF_LANGS = new Set(['typescript', 'javascript', 'tsx', 'go', 'python', 'rust', 'ruby', 'c', 'java', 'csharp', 'php', 'scala', 'kotlin', 'swift', 'dart', 'pascal']);
+    static VALUE_REF_LANGS = new Set(['typescript', 'javascript', 'tsx', 'arkts', 'go', 'python', 'rust', 'ruby', 'c', 'java', 'csharp', 'php', 'scala', 'kotlin', 'swift', 'dart', 'pascal']);
     static MAX_VALUE_REF_NODES = 20_000;
     valueRefsEnabled = process.env.HOMEGRAPH_VALUE_REFS !== '0';
     fileScopeValues = new Map();
@@ -333,6 +379,20 @@ class TreeSitterExtractor {
     errors = [];
     extractor = null;
     nodeStack = []; // Stack of parent node IDs
+    // C/C++ enclosing `namespace ns { … }` names, prepended to every contained
+    // symbol's qualifiedName (see visitNode). Prefix-only by design — no
+    // namespace NODE is created: `namespace cutlass {` opens in thousands of
+    // files, and a node per block would flood search with same-named symbols
+    // (the #1093 crowd-out failure mode). Always empty outside C/C++.
+    namespacePrefix = [];
+    // C++ local function-pointer bindings, per enclosing symbol:
+    // `auto kernel = &flash_fwd_kernel<…>;` recorded as callerId → kernel →
+    // {flash_fwd_kernel}, so a later `kernel<<<grid, block>>>(params)` (or plain
+    // `kernel(args)`) in the same body emits calls refs to the real target(s)
+    // instead of an unresolvable local name. Branch reassignments accumulate —
+    // each assigned target is a genuine possible callee. Same-body locality is
+    // the precision guard (the #932 table-dispatch philosophy scoped to locals).
+    cppLocalFnPtrs = new Map();
     methodIndex = null; // lookup key → node ID for Pascal defProc lookup
     // Function-as-value capture (#756): per-language spec + candidates collected
     // during the walk, gated & flushed into unresolvedReferences at end-of-file
@@ -393,7 +453,7 @@ class TreeSitterExtractor {
             // this.source so downstream getNodeText reads the same bytes the parser
             // saw (identical outside the blanked directive lines).
             if (this.extractor?.preParse) {
-                this.source = this.extractor.preParse(this.source);
+                this.source = this.extractor.preParse(this.source, this.filePath);
             }
             this.tree = parser.parse(this.source) ?? null;
             if (!this.tree) {
@@ -851,6 +911,31 @@ class TreeSitterExtractor {
             if (skipChildren)
                 return;
         }
+        // C++ namespace blocks: carry the namespace name as a qualifiedName prefix
+        // while walking the body, so `namespace flash { void compute_attn(); }`
+        // indexes compute_attn with qualifiedName `flash::compute_attn` and a
+        // namespace-qualified call (`flash::compute_attn(...)`) resolves by exact
+        // qualified match instead of never resolving — C++ namespaces previously
+        // left no trace in qualifiedNames at all, so every `ns::fn()` call site
+        // was a permanently dead edge (surfaced by #387 flow validation on
+        // flash-attention/cutlass, whose kernel dispatch is namespace-qualified).
+        // C++17 nested forms (`namespace a::b {`) prefix as written. An anonymous
+        // namespace falls through to the generic walk — its contents stay bare,
+        // matching how call sites spell them.
+        if (this.language === 'cpp' && nodeType === 'namespace_definition') {
+            const nameNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
+            const nsName = nameNode ? (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source) : '';
+            if (nsName) {
+                this.namespacePrefix.push(nsName);
+                for (let i = 0; i < node.namedChildCount; i++) {
+                    const child = node.namedChild(i);
+                    if (child)
+                        this.visitNode(child);
+                }
+                this.namespacePrefix.pop();
+                return;
+            }
+        }
         // Function-as-value capture (#756) — independent of the dispatch ladder
         // below (the captured container types have no other handler there), so it
         // can never shadow or be shadowed by an extraction branch.
@@ -980,29 +1065,44 @@ class TreeSitterExtractor {
             this.scanFnRefSubtree(node, 0);
             skipChildren = true; // extractVariable handles children
         }
-        // Swift stored properties inside a type. Swift instance properties aren't
-        // extracted as their own nodes, but a property's PROPERTY WRAPPER
-        // (`@Argument`/`@Published`/`@State`/custom) and declared type ARE
-        // dependencies — attribute them to the enclosing type so the wrapper/type
-        // files get dependents. Don't skipChildren: an initializer's calls still
-        // matter. (Other languages extract properties via property/field types.)
+        // Swift properties inside a type. A stored instance property becomes a `field`
+        // node; a `static let`/`static var` member becomes `constant`/`variable`
+        // (Swift's `static`-namespacing idiom — value-reference edges can then target
+        // it); a COMPUTED property (getter block, no stored value) becomes a `property`
+        // node whose getter is walked below so its calls attribute to it. A property's
+        // PROPERTY WRAPPER (`@Argument`/`@Published`/`@State`/custom) and declared type
+        // are dependencies attributed to the enclosing type. (Other languages extract
+        // properties via property/field types.)
         else if (this.language === 'swift' &&
-            nodeType === 'property_declaration' &&
+            (nodeType === 'property_declaration' || nodeType === 'protocol_property_declaration') &&
             this.isInsideClassLikeNode()) {
             const ownerId = this.nodeStack[this.nodeStack.length - 1];
-            // A `static let`/`static var` member is a SHARED constant of the type
-            // (Swift's `static`-namespacing idiom, esp. in `enum`/`struct`) — extract
-            // it as `constant`/`variable` so value-reference edges can target it. An
-            // instance stored property stays a `field` (per-instance; Swift instance
-            // properties otherwise aren't own nodes — that's unchanged). A *computed*
-            // property (getter, no stored value) is never a constant — skip the node.
             const { nameNode, isLet, isComputed } = swiftPropertyInfo(node, this.source);
-            if (nameNode && !isComputed) {
-                const isStatic = this.extractor.isStatic?.(node) ?? false;
-                this.createNode(isStatic ? (isLet ? 'constant' : 'variable') : 'field', (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source), node, {
-                    visibility: this.extractor.getVisibility?.(node),
-                    isStatic,
-                });
+            let computedPropId;
+            if (nameNode) {
+                if (isComputed) {
+                    // Computed property — accessed like a property but its getter holds real
+                    // logic. Index as `property` so search/explore find it (#1020: computed
+                    // props such as a heavily-read `var isCloudProxy: Bool` returned "No
+                    // results found"); pushed below so the getter's calls attribute to it
+                    // rather than flattening onto the owning type (SwiftUI `var body: some
+                    // View { … }` — the whole subview tree — is the canonical case).
+                    const prop = this.createNode('property', (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source), node, {
+                        visibility: this.extractor.getVisibility?.(node),
+                        isStatic: this.extractor.isStatic?.(node) ?? false,
+                    });
+                    computedPropId = prop?.id;
+                }
+                else {
+                    // A `static let`/`static var` member is a SHARED constant of the type
+                    // (esp. in `enum`/`struct`); an instance stored property stays a `field`
+                    // (per-instance — Swift instance properties otherwise aren't own nodes).
+                    const isStatic = this.extractor.isStatic?.(node) ?? false;
+                    this.createNode(isStatic ? (isLet ? 'constant' : 'variable') : 'field', (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source), node, {
+                        visibility: this.extractor.getVisibility?.(node),
+                        isStatic,
+                    });
+                }
             }
             if (ownerId) {
                 this.extractDecoratorsFor(node, ownerId);
@@ -1028,6 +1128,20 @@ class TreeSitterExtractor {
                     walkAttrArgs(modifiers);
                 }
             }
+            // A computed property's getter holds real logic — walk it with the property
+            // node pushed so its calls/instantiations attribute to the property (a
+            // SwiftUI `body`'s subview tree becomes the property's callees). skipChildren
+            // then stops the generic walker from re-walking the getter (and the
+            // modifiers/type annotation already handled above).
+            if (computedPropId) {
+                const getter = node.namedChildren.find((c) => c.type === 'computed_property' || c.type === 'protocol_property_requirements');
+                if (getter) {
+                    this.nodeStack.push(computedPropId);
+                    this.visitFunctionBody(getter, '');
+                    this.nodeStack.pop();
+                }
+                skipChildren = true;
+            }
         }
         // `export_statement` itself is not extracted — the walker descends
         // into children, where the inner declaration (lexical_declaration,
@@ -1055,7 +1169,8 @@ class TreeSitterExtractor {
         // falls through to its normal declaration extraction).
         else if (nodeType === 'export_statement' &&
             (this.language === 'typescript' || this.language === 'tsx' ||
-                this.language === 'javascript' || this.language === 'jsx') &&
+                this.language === 'javascript' || this.language === 'jsx' ||
+                this.language === 'arkts') &&
             (0, tree_sitter_helpers_1.getChildByField)(node, 'source')) {
             const parentId = this.nodeStack[this.nodeStack.length - 1];
             if (parentId)
@@ -1085,7 +1200,7 @@ class TreeSitterExtractor {
         // produce an `instantiates` reference. Children still walked so
         // nested calls inside the constructor args (`new Foo(bar())`) get
         // their own `calls` refs.
-        else if (INSTANTIATION_KINDS.has(nodeType)) {
+        else if (INSTANTIATION_KINDS.has(nodeType) || this.isVbnetConstructorShapedArrayCreation(node)) {
             this.extractInstantiation(node);
             // Java/C# `new T(...) { ... }` — anonymous class with body. Without
             // extracting it as a class node + its methods, the interface→impl
@@ -1236,7 +1351,8 @@ class TreeSitterExtractor {
     buildQualifiedName(name) {
         // Build a qualified name from the semantic hierarchy only (no file path).
         // The file path is stored separately in filePath and pollutes FTS if included here.
-        const parts = [];
+        // C/C++ enclosing namespaces prefix first (empty for every other language).
+        const parts = [...this.namespacePrefix];
         for (const nodeId of this.nodeStack) {
             const node = this.nodes.find((n) => n.id === nodeId);
             if (node && node.kind !== 'file') {
@@ -1455,6 +1571,15 @@ class TreeSitterExtractor {
     extractClass(node, kind = 'class') {
         if (!this.extractor)
             return;
+        // Skip forward declarations / elaborated type references (`class Foo;`) in
+        // languages that opt in — bodiless there means "not a definition", so it
+        // would otherwise mint a phantom node competing with the real definition
+        // (#1093). Languages where a bodiless class is complete (Kotlin, Scala)
+        // leave the flag unset. Resolved once here and reused for the body walk.
+        const resolvedBody = this.extractor.resolveBody?.(node, this.extractor.bodyField)
+            ?? (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
+        if (this.extractor.skipBodilessClass && !resolvedBody)
+            return;
         const name = extractName(node, this.source, this.extractor);
         const docstring = (0, tree_sitter_helpers_1.getPrecedingDocstring)(node, this.source);
         const visibility = this.extractor.getVisibility?.(node);
@@ -1474,10 +1599,7 @@ class TreeSitterExtractor {
         this.extractDecoratorsFor(node, classNode.id);
         // Push to stack and visit body
         this.nodeStack.push(classNode.id);
-        let body = this.extractor.resolveBody?.(node, this.extractor.bodyField)
-            ?? (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.bodyField);
-        if (!body)
-            body = node;
+        const body = resolvedBody ?? node;
         // Visit all children for methods and properties
         for (let i = 0; i < body.namedChildCount; i++) {
             const child = body.namedChild(i);
@@ -2311,7 +2433,8 @@ class TreeSitterExtractor {
         const isExported = this.extractor.isExported?.(node, this.source) ?? false;
         // Extract variable declarators based on language
         if (this.language === 'typescript' || this.language === 'javascript' ||
-            this.language === 'tsx' || this.language === 'jsx') {
+            this.language === 'tsx' || this.language === 'jsx' || this.language === 'cfscript' ||
+            this.language === 'arkts') {
             // Handle lexical_declaration and variable_declaration
             // These contain one or more variable_declarator children
             for (let i = 0; i < node.namedChildCount; i++) {
@@ -2725,7 +2848,7 @@ class TreeSitterExtractor {
                 // 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') {
+                if (this.language === 'typescript' || this.language === 'tsx' || this.language === 'arkts') {
                     this.extractTsTypeAliasMembers(value, typeAliasNode);
                     // `type List = [ Service<'name', Req, Resp>, … ]` — surface each
                     // entry's string-literal name as a searchable member (issue #634).
@@ -2946,7 +3069,8 @@ class TreeSitterExtractor {
                 // Link each imported binding to its definition so imported-but-not-
                 // called/typed symbols still record a cross-file dependency (TS/JS only).
                 if (this.language === 'typescript' || this.language === 'tsx' ||
-                    this.language === 'javascript' || this.language === 'jsx') {
+                    this.language === 'javascript' || this.language === 'jsx' ||
+                    this.language === 'arkts') {
                     const parentId = this.nodeStack[this.nodeStack.length - 1];
                     if (parentId)
                         this.emitImportBindingRefs(node, parentId);
@@ -3385,12 +3509,522 @@ class TreeSitterExtractor {
     /**
      * Extract a function call
      */
+    /**
+     * The module an Erlang gen_server target expression statically names, or
+     * null when it's dynamic (pid/var/tuple form). Static shapes:
+     *   - a bare atom — either this module or another one; OTP's dominant
+     *     registration convention (`{local, ?MODULE}`) names a server process
+     *     after its module, so `gen_server:call(other_mod, …)` reaches
+     *     `other_mod`'s handlers. A registered name that matches no module
+     *     resolves to nothing downstream (the qualified ref just drops).
+     *   - `?MODULE`, or a macro the file defines as `?MODULE`
+     *     (`-define(SERVER, ?MODULE)` — the standard self idiom)
+     *   - a macro the file defines as a bare atom
+     *     (`-define(STORE, kv_store)` — the cross-module variant)
+     * The macro tables are memoized per file (single entry — extraction is
+     * file-sequential).
+     */
+    erlangServerMacroFile = '';
+    erlangSelfMacros = new Set();
+    erlangAtomMacros = new Map();
+    resolveErlangGenServerTarget(target) {
+        const ownModule = (this.filePath.split('/').pop() ?? '').replace(/\.erl$/, '');
+        if (target.type === 'atom') {
+            const name = (0, tree_sitter_helpers_1.getNodeText)(target, this.source).replace(/^'([\s\S]*)'$/, '$1');
+            return name || null;
+        }
+        if (target.type !== 'macro_call_expr')
+            return null;
+        const nameNode = (0, tree_sitter_helpers_1.getChildByField)(target, 'name');
+        if (!nameNode)
+            return null;
+        const macroName = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+        if (macroName === 'MODULE')
+            return ownModule || null;
+        if (this.erlangServerMacroFile !== this.filePath) {
+            this.erlangServerMacroFile = this.filePath;
+            this.erlangSelfMacros = new Set();
+            this.erlangAtomMacros = new Map();
+            let root = target;
+            while (root.parent)
+                root = root.parent;
+            for (let i = 0; i < root.namedChildCount; i++) {
+                const form = root.namedChild(i);
+                if (form?.type !== 'pp_define')
+                    continue;
+                const lhs = (0, tree_sitter_helpers_1.getChildByField)(form, 'lhs');
+                const defName = lhs ? (0, tree_sitter_helpers_1.getChildByField)(lhs, 'name') : null;
+                const replacement = (0, tree_sitter_helpers_1.getChildByField)(form, 'replacement');
+                if (!defName || !replacement)
+                    continue;
+                if (replacement.type === 'macro_call_expr' &&
+                    (0, tree_sitter_helpers_1.getChildByField)(replacement, 'name') &&
+                    (0, tree_sitter_helpers_1.getNodeText)((0, tree_sitter_helpers_1.getChildByField)(replacement, 'name'), this.source) === 'MODULE') {
+                    this.erlangSelfMacros.add((0, tree_sitter_helpers_1.getNodeText)(defName, this.source));
+                }
+                else if (replacement.type === 'atom') {
+                    this.erlangAtomMacros.set((0, tree_sitter_helpers_1.getNodeText)(defName, this.source), (0, tree_sitter_helpers_1.getNodeText)(replacement, this.source).replace(/^'([\s\S]*)'$/, '$1'));
+                }
+            }
+        }
+        if (this.erlangSelfMacros.has(macroName))
+            return ownModule || null;
+        return this.erlangAtomMacros.get(macroName) ?? null;
+    }
     extractCall(node) {
         if (this.nodeStack.length === 0)
             return;
         const callerId = this.nodeStack[this.nodeStack.length - 1];
         if (!callerId)
             return;
+        // VB.NET: `foo(args)` is syntactically ambiguous between a call and an
+        // index read, so the grammar parses non-empty parens as
+        // array_access_expression (field `array`, not `function`) — even Roslyn
+        // parses both as InvocationExpression and resolves during binding. Treat
+        // all three shapes as call sites: the callee is the member/identifier
+        // under the array/function field, qualified with a simple-identifier
+        // receiver for resolution. Index reads on collections simply never
+        // resolve to a callable, so they cost nothing.
+        if (this.language === 'vbnet' &&
+            (node.type === 'array_access_expression' ||
+                node.type === 'invocation_expression' ||
+                node.type === 'generic_invocation_expression')) {
+            const fn = (0, tree_sitter_helpers_1.getChildByField)(node, 'function') || (0, tree_sitter_helpers_1.getChildByField)(node, 'array');
+            if (!fn)
+                return;
+            let calleeName = '';
+            if (fn.type === 'member_access_expression') {
+                const member = (0, tree_sitter_helpers_1.getChildByField)(fn, 'member');
+                const memberName = member ? (0, tree_sitter_helpers_1.getNodeText)(member, this.source) : '';
+                if (!memberName)
+                    return;
+                const receiver = (0, tree_sitter_helpers_1.getChildByField)(fn, 'object');
+                const SKIP = new Set(['me', 'mybase', 'myclass']);
+                if (receiver && receiver.type === 'identifier' && !SKIP.has((0, tree_sitter_helpers_1.getNodeText)(receiver, this.source).toLowerCase())) {
+                    calleeName = `${(0, tree_sitter_helpers_1.getNodeText)(receiver, this.source)}.${memberName}`;
+                }
+                else {
+                    calleeName = memberName;
+                }
+            }
+            else if (fn.type === 'identifier') {
+                calleeName = (0, tree_sitter_helpers_1.getNodeText)(fn, this.source);
+            }
+            else {
+                return; // parenthesized/chained receivers: no static name to link
+            }
+            if (calleeName) {
+                this.unresolvedReferences.push({
+                    fromNodeId: callerId,
+                    referenceName: calleeName,
+                    referenceKind: 'calls',
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column,
+                });
+            }
+            return;
+        }
+        // Erlang: a local call is `call(expr: atom, args)`; a remote call nests it
+        // under `remote(module: remote_module, fun: call)` — the module qualifier
+        // lives on the PARENT. Remote calls are emitted as `mod::fn`, which is
+        // byte-identical to the qualifiedName the module namespace gives every
+        // function (see packageTypes in languages/erlang.ts), so they resolve via
+        // matchByQualifiedName. A var/macro callee or module (`F(X)`, `?M(X)`,
+        // `Mod:handle(X)`) has no static target — except `?MODULE:fn(X)`, which the
+        // bare name + same-file preference resolves correctly. `fun name/1` /
+        // `fun mod:name/1` values are function REFERENCES (callback registration),
+        // and record construction/update/index/field-access are `references` to the
+        // record's struct node.
+        if (this.language === 'erlang') {
+            const line = node.startPosition.row + 1;
+            const column = node.startPosition.column;
+            const erlAtom = (n) => (0, tree_sitter_helpers_1.getNodeText)(n, this.source).replace(/^'([\s\S]*)'$/, '$1');
+            if (node.type === 'call') {
+                let callee = (0, tree_sitter_helpers_1.getChildByField)(node, 'expr');
+                let moduleNode = null;
+                // remote(module, fun: call) — the shape the grammar produces today; the
+                // node-types also permit call(expr: remote), so handle both nestings.
+                if (node.parent?.type === 'remote') {
+                    moduleNode = (0, tree_sitter_helpers_1.getChildByField)(node.parent, 'module');
+                }
+                else if (callee?.type === 'remote') {
+                    moduleNode = (0, tree_sitter_helpers_1.getChildByField)(callee, 'module');
+                    callee = (0, tree_sitter_helpers_1.getChildByField)(callee, 'fun');
+                }
+                if (callee?.type === 'atom') {
+                    const fnBare = erlAtom(callee);
+                    let calleeName = fnBare;
+                    const moduleExpr = moduleNode ? (0, tree_sitter_helpers_1.getChildByField)(moduleNode, 'module') : null;
+                    if (moduleExpr?.type === 'atom') {
+                        calleeName = `${erlAtom(moduleExpr)}::${calleeName}`;
+                    }
+                    else if (moduleExpr) {
+                        // Non-atom module qualifier. `?MODULE:f(X)` targets THIS module —
+                        // keep the bare name so same-file preference resolves it. Anything
+                        // else (`Mod:f(X)`) is behaviour-style dynamic dispatch with no
+                        // static target: emitting the bare name would link an arbitrary
+                        // same-named function, so stay silent instead.
+                        const macroName = moduleExpr.type === 'macro_call_expr' ? (0, tree_sitter_helpers_1.getChildByField)(moduleExpr, 'name') : null;
+                        if (!macroName || (0, tree_sitter_helpers_1.getNodeText)(macroName, this.source) !== 'MODULE')
+                            return;
+                    }
+                    this.unresolvedReferences.push({
+                        fromNodeId: callerId,
+                        referenceName: calleeName,
+                        referenceKind: 'calls',
+                        line,
+                        column,
+                    });
+                    // gen_server dispatch: `gen_server:call(?SERVER, Msg)` /
+                    // `gen_server:cast(other_mod, Msg)` — a request routes to the TARGET
+                    // module's handle_call/handle_cast. The target is static when the
+                    // first argument names a module: ?MODULE or a ?MODULE-defined macro
+                    // (the self API-wrapper idiom), a bare atom (OTP's `{local, ?MODULE}`
+                    // convention names a server after its module, so a cross-module
+                    // registered name reaches that module's handlers — and a registered
+                    // name matching no module resolves to nothing), or a macro defined
+                    // as a bare atom. Pid/var/tuple targets stay silent.
+                    if (moduleExpr?.type === 'atom' &&
+                        erlAtom(moduleExpr) === 'gen_server' &&
+                        (fnBare === 'call' || fnBare === 'cast' || fnBare === 'send_request')) {
+                        const argsNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'args');
+                        const target = argsNode?.namedChild(0) ?? null;
+                        const targetModule = target ? this.resolveErlangGenServerTarget(target) : null;
+                        if (targetModule) {
+                            this.unresolvedReferences.push({
+                                fromNodeId: callerId,
+                                referenceName: `${targetModule}::${fnBare === 'cast' ? 'handle_cast' : 'handle_call'}`,
+                                referenceKind: 'calls',
+                                line,
+                                column,
+                            });
+                        }
+                    }
+                    // MFA-in-argument dispatch: the spawn/apply family names its real
+                    // callee in ARGUMENT position — `proc_lib:spawn_link(?MODULE,
+                    // request_process, [Req, Env, Middlewares])` — so the walker above
+                    // sees only the spawn itself and the spawned function ends up with
+                    // zero callers (measured on cowboy: request_process had no incoming
+                    // edges and the agent Read the file to find it). When the (Module,
+                    // Function) pair is static, lift it as a call edge. The pair is
+                    // found positionally-agnostically (first adjacent module-atom/
+                    // ?MODULE + atom pair) so every arity variant works: spawn/3,
+                    // spawn(Node,M,F,A)/4, timer:apply_after(Time,M,F,A),
+                    // rpc:call(Node,M,F,A). A var module or fun stays silent.
+                    const familyKey = moduleExpr?.type === 'atom' ? `${erlAtom(moduleExpr)}:${fnBare}` : fnBare;
+                    if (ERLANG_MFA_CALLS.has(familyKey)) {
+                        const argsNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'args');
+                        const argExprs = argsNode ? argsNode.namedChildren : [];
+                        for (let i = 0; i + 1 < argExprs.length; i++) {
+                            const m = argExprs[i];
+                            const f = argExprs[i + 1];
+                            if (f.type !== 'atom')
+                                continue;
+                            const isLocalModule = m.type === 'macro_call_expr' &&
+                                (0, tree_sitter_helpers_1.getChildByField)(m, 'name') !== null &&
+                                (0, tree_sitter_helpers_1.getNodeText)((0, tree_sitter_helpers_1.getChildByField)(m, 'name'), this.source) === 'MODULE';
+                            if (m.type !== 'atom' && !isLocalModule)
+                                continue;
+                            this.unresolvedReferences.push({
+                                fromNodeId: callerId,
+                                referenceName: isLocalModule ? erlAtom(f) : `${erlAtom(m)}::${erlAtom(f)}`,
+                                referenceKind: 'calls',
+                                line: f.startPosition.row + 1,
+                                column: f.startPosition.column,
+                            });
+                            break;
+                        }
+                    }
+                }
+                return;
+            }
+            if (node.type === 'internal_fun' || node.type === 'external_fun') {
+                const funNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'fun');
+                if (funNode?.type !== 'atom')
+                    return; // fun Mod:F/A with var parts — dynamic
+                let refName = erlAtom(funNode);
+                if (node.type === 'external_fun') {
+                    const moduleWrapper = (0, tree_sitter_helpers_1.getChildByField)(node, 'module');
+                    const moduleAtom = moduleWrapper ? (0, tree_sitter_helpers_1.getChildByField)(moduleWrapper, 'name') : null;
+                    if (moduleAtom?.type !== 'atom')
+                        return;
+                    refName = `${erlAtom(moduleAtom)}::${refName}`;
+                }
+                this.unresolvedReferences.push({
+                    fromNodeId: callerId,
+                    referenceName: refName,
+                    referenceKind: 'references',
+                    line,
+                    column,
+                });
+                return;
+            }
+            if (node.type === 'macro_call_expr') {
+                // Macro use site → the `-define` constant node. Function-like uses
+                // (`?LOG_AUDIT(X)` — args present) are inlined code, so they join the
+                // call chain and connect through the macro node to the body's calls
+                // (attributed there by handlePpDefine); bare reads (`?TIMEOUT`) are
+                // `references`, answering "where is this macro used" without
+                // polluting call paths. Compiler-predefined macros carry no
+                // definition to link. The use site's ARGUMENTS are children and keep
+                // walking, so a call nested in `?assertEqual(ok, do_thing())` still
+                // attributes to the enclosing function.
+                const macroName = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
+                if (!macroName)
+                    return;
+                const name = (0, tree_sitter_helpers_1.getNodeText)(macroName, this.source);
+                if (ERLANG_PREDEFINED_MACROS.has(name))
+                    return;
+                this.unresolvedReferences.push({
+                    fromNodeId: callerId,
+                    referenceName: name,
+                    referenceKind: (0, tree_sitter_helpers_1.getChildByField)(node, 'args') ? 'calls' : 'references',
+                    line,
+                    column,
+                });
+                return;
+            }
+            // record_expr / record_update_expr / record_index_expr / record_field_expr
+            const recordName = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
+            const recordAtom = recordName?.type === 'record_name' ? (0, tree_sitter_helpers_1.getChildByField)(recordName, 'name') : null;
+            if (recordAtom?.type === 'atom') {
+                this.unresolvedReferences.push({
+                    fromNodeId: callerId,
+                    referenceName: erlAtom(recordAtom),
+                    referenceKind: 'references',
+                    line,
+                    column,
+                });
+            }
+            return;
+        }
+        // Ruby `call` nodes use `receiver` + `method` fields (tree-sitter-ruby), not
+        // the `object`/`name`/`function` fields the branches below expect — so
+        // without this they fell through to the generic path, which took the
+        // receiver as the callee and DROPPED the method name: `lg.log()` produced a
+        // `calls` ref to `lg` (unresolvable) and no method edge was ever recorded,
+        // so a Ruby method's callers/impact were invisible (#1108 follow-up). Build
+        // `receiver.method` so the resolver — and local-variable type inference —
+        // can link it; `Foo.new` stays an instantiation.
+        if (this.language === 'ruby' && (node.type === 'call' || node.type === 'method_call')) {
+            const methodNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'method');
+            const methodName = methodNode ? (0, tree_sitter_helpers_1.getNodeText)(methodNode, this.source) : '';
+            if (!methodName)
+                return; // operator/element-reference call with no method name
+            const receiverNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'receiver');
+            const line = node.startPosition.row + 1;
+            const column = node.startPosition.column;
+            if (!receiverNode) {
+                // Bare `foo(...)` — just the method name (unchanged behavior).
+                this.unresolvedReferences.push({ fromNodeId: callerId, referenceName: methodName, referenceKind: 'calls', line, column });
+                return;
+            }
+            const receiverName = (0, tree_sitter_helpers_1.getNodeText)(receiverNode, this.source);
+            // `Foo.new` / `Foo::Bar.new` is construction — emit an `instantiates` ref to
+            // the class (last `::` segment), preserving the "what creates X" edge.
+            if (methodName === 'new') {
+                const className = receiverName.includes('::')
+                    ? receiverName.slice(receiverName.lastIndexOf('::') + 2)
+                    : receiverName;
+                if (/^[A-Z]/.test(className)) {
+                    this.unresolvedReferences.push({ fromNodeId: callerId, referenceName: className, referenceKind: 'instantiates', line, column });
+                    return;
+                }
+            }
+            const SKIP_RECEIVERS = new Set(['self', 'super']);
+            const skip = SKIP_RECEIVERS.has(receiverName);
+            this.unresolvedReferences.push({
+                fromNodeId: callerId,
+                referenceName: skip ? methodName : `${receiverName}.${methodName}`,
+                referenceKind: 'calls',
+                line,
+                column,
+            });
+            // A capitalized (constant) receiver — `Foo.bar`, a class/module method call
+            // — is itself a dependency on that constant; emit a `references` ref so a
+            // class used only via its class methods still records a dependent (the edge
+            // the old receiver-only callee happened to provide, now made explicit).
+            if (!skip && receiverNode.type === 'constant') {
+                this.unresolvedReferences.push({
+                    fromNodeId: callerId,
+                    referenceName: receiverName,
+                    referenceKind: 'references',
+                    line: receiverNode.startPosition.row + 1,
+                    column: receiverNode.startPosition.column,
+                });
+            }
+            return;
+        }
+        // ArkTS build()-DSL handling. Three shapes carry UI-attribute chains, and
+        // all of their attribute names are emitted with a LEADING DOT
+        // (`.titleStyle`, `.width`) — an impossible identifier that routes them to
+        // a dedicated matcher strategy resolving ONLY to decorator-marked
+        // attribute helpers (`@Extend`/`@Styles`/`@AnimatableExtend`/`@Builder`
+        // functions). Bare names would go through global name matching, where
+        // framework attributes (`.width`, `.fontSize`, appearing on nearly every
+        // UI line) hit arbitrary same-named symbols — measured on the OpenHarmony
+        // samples monorepo, that produced 36k wrong edges (17% of all calls),
+        // including single properties with 3,400+ false callers.
+        //
+        //   1. `Column({space:8}) { … }.height('100%')` — ONE
+        //      arkui_component_expression: `function:` = the component, chained
+        //      attributes as repeated `property:`/`arguments:` field pairs.
+        //      The component ref (`Column`, `TodoRow`) stays a PLAIN name — it
+        //      resolves to the child `@Component struct`, giving the parent→child
+        //      component-tree edge the way JSX children do for React.
+        //   2. `Image(x).width(10).onClick(this.f)` — ordinary nested
+        //      call_expressions whose `function:` is a member_expression chained
+        //      on a CALL RESULT (never a named receiver, so `svc.save()` /
+        //      `this.vm.load()` are untouched and fall through to the generic
+        //      paths below).
+        //   3. A nested component whose chain starts on the line AFTER its
+        //      closing `}` inside arkui_children — the grammar detaches the chain
+        //      into sibling `leading_dot_expression(identifier)` +
+        //      `parenthesized_expression(args)` statement pairs; reassemble from
+        //      the siblings.
+        //
+        // `.onXxx(this.handler)` METHOD-REFERENCE bindings (no call parens, so
+        // nothing else records them) additionally emit a call ref to the bare
+        // handler name — same-class resolution links the tap→handler hop.
+        // Arrow-function handlers need nothing: their bodies' calls already
+        // attribute to the enclosing build(). Children/argument subtrees are
+        // still walked by the caller, so nested components extract normally.
+        if (this.language === 'arkts') {
+            const emitAttr = (nameNode) => {
+                const attrName = (0, tree_sitter_helpers_1.getNodeText)(nameNode, this.source);
+                if (!attrName)
+                    return;
+                this.unresolvedReferences.push({
+                    fromNodeId: callerId,
+                    referenceName: '.' + attrName,
+                    referenceKind: 'calls',
+                    line: nameNode.startPosition.row + 1,
+                    column: nameNode.startPosition.column,
+                });
+            };
+            // Emit `handler` for each bare `this.handler` among an on-attribute's
+            // arguments.
+            const emitThisHandlers = (args) => {
+                if (!args)
+                    return;
+                for (let j = 0; j < args.namedChildCount; j++) {
+                    const arg = args.namedChild(j);
+                    if (arg?.type !== 'member_expression')
+                        continue;
+                    const obj = (0, tree_sitter_helpers_1.getChildByField)(arg, 'object');
+                    const prop = (0, tree_sitter_helpers_1.getChildByField)(arg, 'property');
+                    if (obj?.type === 'this' && prop) {
+                        this.unresolvedReferences.push({
+                            fromNodeId: callerId,
+                            referenceName: (0, tree_sitter_helpers_1.getNodeText)(prop, this.source),
+                            referenceKind: 'calls',
+                            line: arg.startPosition.row + 1,
+                            column: arg.startPosition.column,
+                        });
+                    }
+                }
+            };
+            // Shape 1: arkui_component_expression with property/arguments pairs.
+            if (node.type === 'arkui_component_expression') {
+                const componentField = (0, tree_sitter_helpers_1.getChildByField)(node, 'function');
+                if (componentField && componentField.type === 'identifier') {
+                    this.unresolvedReferences.push({
+                        fromNodeId: callerId,
+                        referenceName: (0, tree_sitter_helpers_1.getNodeText)(componentField, this.source),
+                        referenceKind: 'calls',
+                        line: node.startPosition.row + 1,
+                        column: node.startPosition.column,
+                    });
+                }
+                for (let i = 0; i < node.childCount; i++) {
+                    const child = node.child(i);
+                    if (!child || child.type !== 'property_identifier')
+                        continue;
+                    emitAttr(child);
+                    if (/^on[A-Z]/.test((0, tree_sitter_helpers_1.getNodeText)(child, this.source))) {
+                        // The attribute's arguments node is the next `arguments`-typed
+                        // child before the following attribute name.
+                        let args = null;
+                        for (let k = i + 1; k < node.childCount; k++) {
+                            const next = node.child(k);
+                            if (!next)
+                                continue;
+                            if (next.type === 'property_identifier')
+                                break;
+                            if (next.type === 'arguments') {
+                                args = next;
+                                break;
+                            }
+                        }
+                        emitThisHandlers(args);
+                    }
+                }
+                return;
+            }
+            // Shape 2: fluent chain on a call result —
+            // call_expression(function: member_expression(object: <call>)), or the
+            // grammar's DSL-specific arkui_dsl_decorator_member_expression (same
+            // object/property fields; produced e.g. by `Column() { … }.alignItems(x)`
+            // in some chain positions — it ONLY occurs in attribute chains).
+            if (node.type === 'call_expression') {
+                const fn = (0, tree_sitter_helpers_1.getChildByField)(node, 'function');
+                if (fn?.type === 'member_expression' || fn?.type === 'arkui_dsl_decorator_member_expression') {
+                    const obj = (0, tree_sitter_helpers_1.getChildByField)(fn, 'object');
+                    const prop = (0, tree_sitter_helpers_1.getChildByField)(fn, 'property');
+                    if (prop &&
+                        (fn.type === 'arkui_dsl_decorator_member_expression' ||
+                            obj?.type === 'call_expression' ||
+                            obj?.type === 'arkui_component_expression')) {
+                        emitAttr(prop);
+                        if (/^on[A-Z]/.test((0, tree_sitter_helpers_1.getNodeText)(prop, this.source))) {
+                            emitThisHandlers((0, tree_sitter_helpers_1.getChildByField)(node, 'arguments'));
+                        }
+                        return;
+                    }
+                }
+                // The INNERMOST call of a proper-form detached chain
+                // (`.alignItems(x).layoutWeight(1)…` under a leading_dot_expression)
+                // has a BARE IDENTIFIER function — the leading dot was consumed by
+                // the wrapper, so it masquerades as a plain `alignItems(...)` call.
+                // Walk up the member/call alternation; topping out at
+                // leading_dot_expression means the dot belongs to this chain.
+                if (fn?.type === 'identifier') {
+                    let p = node.parent;
+                    while (p && (p.type === 'member_expression' || p.type === 'call_expression')) {
+                        p = p.parent;
+                    }
+                    if (p?.type === 'leading_dot_expression') {
+                        emitAttr(fn);
+                        if (/^on[A-Z]/.test((0, tree_sitter_helpers_1.getNodeText)(fn, this.source))) {
+                            emitThisHandlers((0, tree_sitter_helpers_1.getChildByField)(node, 'arguments'));
+                        }
+                        return;
+                    }
+                }
+                // Not a chained attribute — fall through to the generic call paths.
+            }
+            // Shape 3: detached chain segment — leading_dot_expression whose only
+            // named child is a bare identifier; its arguments sit in the NEXT
+            // sibling statement as a parenthesized_expression.
+            if (node.type === 'leading_dot_expression') {
+                const only = node.namedChildCount === 1 ? node.namedChild(0) : null;
+                if (only && only.type === 'identifier') {
+                    emitAttr(only);
+                    if (/^on[A-Z]/.test((0, tree_sitter_helpers_1.getNodeText)(only, this.source))) {
+                        const stmt = node.parent; // expression_statement
+                        const nextStmt = stmt?.nextNamedSibling;
+                        const paren = nextStmt?.namedChild(0);
+                        if (paren?.type === 'parenthesized_expression') {
+                            emitThisHandlers(paren);
+                        }
+                    }
+                }
+                // The proper form (child is a call_expression chain, as inside
+                // `@Extend` bodies) needs nothing here — the walker descends into it
+                // and the inner call_expressions take the paths above.
+                return;
+            }
+        }
         // Get the function/method being called
         let calleeName = '';
         // Java/Kotlin method_invocation has 'object' + 'name' fields instead of 'function'
@@ -3682,6 +4316,20 @@ class TreeSitterExtractor {
                             }
                             calleeName = reencode ? `${innerCallee}().${methodName}` : methodName;
                         }
+                        else if (this.language === 'cfscript' &&
+                            receiver &&
+                            receiver.type === 'member_expression' &&
+                            /^(variables|this|local|arguments)\.[A-Za-z_][\w]*$/i.test((0, tree_sitter_helpers_1.getNodeText)(receiver, this.source))) {
+                            // CFML scope-prefixed member call — `variables.svc.save()` /
+                            // `arguments.svc.save()`: the receiver is a component field,
+                            // injected property, or typed argument reached through one of
+                            // CFML's file-local scopes. Keep the full receiver chain so
+                            // resolution can strip the scope prefix and infer the field's
+                            // component type from its declaration (#1108). Gated to these
+                            // scope keywords: such calls previously emitted a bare method
+                            // name, which either failed to resolve or resolved ambiguously.
+                            calleeName = `${(0, tree_sitter_helpers_1.getNodeText)(receiver, this.source)}.${methodName}`;
+                        }
                         else {
                             calleeName = methodName;
                         }
@@ -3724,6 +4372,40 @@ class TreeSitterExtractor {
             if (conv && conv[1])
                 calleeName = conv[1];
         }
+        // C/C++ templated callees — a direct templated call (`fn<T, 256>(args)`,
+        // the shape every CUDA kernel-launch site takes once its `<<<…>>>` config
+        // is blanked) or a qualified one (`ns::fn<T>(args)`) — carry template
+        // arguments in the callee text, which can never match the bare name the
+        // function was DEFINED as, so the call edge silently never resolves. Strip
+        // them: the same normalization base-class `extends` refs already get
+        // (#1043). `operator<`/`operator<<` callees are excluded — their `<` is the
+        // operator itself, not a template-argument list.
+        if (calleeName &&
+            calleeName.includes('<') &&
+            (this.language === 'cpp' || this.language === 'c') &&
+            !calleeName.includes('operator')) {
+            calleeName = (0, c_cpp_1.stripCppTemplateArgs)(calleeName);
+        }
+        // C++ call/launch through a local function pointer: `auto kernel =
+        // &flash_fwd_kernel<…>; … kernel<<<grid, block>>>(params);` — the callee
+        // is an unresolvable local name. When the same enclosing symbol bound the
+        // local from `&fn` (each branch assignment counts), emit the call against
+        // every recorded target instead of the local.
+        if (calleeName && this.language === 'cpp' && /^[A-Za-z_]\w*$/.test(calleeName)) {
+            const targets = this.cppLocalFnPtrs.get(callerId)?.get(calleeName);
+            if (targets && targets.size > 0) {
+                for (const target of targets) {
+                    this.unresolvedReferences.push({
+                        fromNodeId: callerId,
+                        referenceName: target,
+                        referenceKind: 'calls',
+                        line: node.startPosition.row + 1,
+                        column: node.startPosition.column,
+                    });
+                }
+                return;
+            }
+        }
         if (calleeName) {
             this.unresolvedReferences.push({
                 fromNodeId: callerId,
@@ -3743,6 +4425,26 @@ class TreeSitterExtractor {
      * Children are still walked so nested calls inside the constructor
      * arguments (`new Foo(bar())`) get their own `calls` references.
      */
+    /**
+     * VB.NET `New Invoice(1)` is syntactically ambiguous between constructing
+     * Invoice with an argument and allocating an Invoice array of bound 1; the
+     * grammar parses the parenthesized form as array_creation_expression. A
+     * user-defined type with no `{...}` array initializer is overwhelmingly a
+     * constructor call, so treat it as an instantiation. Predefined element
+     * types (`New Byte(1023)`) and brace-initialized forms stay arrays.
+     */
+    isVbnetConstructorShapedArrayCreation(node) {
+        if (this.language !== 'vbnet' || node.type !== 'array_creation_expression')
+            return false;
+        const typeNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
+        if (!typeNode || typeNode.type === 'predefined_type' || typeNode.type === 'array_type')
+            return false;
+        for (const child of node.namedChildren) {
+            if (child?.type === 'array_initializer')
+                return false;
+        }
+        return true;
+    }
     extractInstantiation(node) {
         if (this.nodeStack.length === 0)
             return;
@@ -3805,6 +4507,14 @@ class TreeSitterExtractor {
         const ltIdx = className.indexOf('<');
         if (ltIdx > 0)
             className = className.slice(0, ltIdx);
+        // VB.NET spells generics with parentheses: `New List(Of String)` /
+        // `New Dictionary(Of K, V)(cap)` — strip from the `(` so the bare
+        // type name is what resolution matches.
+        if (this.language === 'vbnet') {
+            const parenIdx = className.indexOf('(');
+            if (parenIdx > 0)
+                className = className.slice(0, parenIdx);
+        }
         // For namespaced/qualified constructors (`new ns.Foo()`,
         // `new ns::Foo()`) keep the trailing identifier — that's what
         // matches a class node in the index.
@@ -3822,6 +4532,45 @@ class TreeSitterExtractor {
             });
         }
     }
+    /**
+     * Is this C++ `declaration` a stack/direct-initialization object construction
+     * that invokes a constructor — `Calculator calc(0)` (direct-init) or
+     * `Widget w{1, 2}` (brace-init) — as opposed to a plain variable or a
+     * function declaration? Used to emit an `instantiates` edge for the
+     * call-less construction syntax (#1035); heap `new T(...)` is handled
+     * separately by INSTANTIATION_KINDS.
+     *
+     * Two signals, both required:
+     *  - the `type` field is a class-like NAMED type (`type_identifier`,
+     *    `template_type`, or `qualified_identifier`). Primitives (`int x(0)`),
+     *    `auto` (`placeholder_type_specifier` — that form always carries a real
+     *    `call_expression`, already handled), and sized specifiers are excluded —
+     *    they construct no class; and
+     *  - a declarator carries constructor arguments: an `init_declarator` whose
+     *    `value` is an `argument_list` (`(args)`) or `initializer_list` (`{args}`).
+     *    This skips default construction `Calculator c;` (no value) and the
+     *    most-vexing-parse `Calculator c();` (a bodyless `function_declarator`,
+     *    a function decl — not a construction).
+     */
+    isCppStackConstruction(node) {
+        const typeNode = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
+        if (!typeNode ||
+            (typeNode.type !== 'type_identifier' &&
+                typeNode.type !== 'template_type' &&
+                typeNode.type !== 'qualified_identifier')) {
+            return false;
+        }
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type !== 'init_declarator')
+                continue;
+            const value = (0, tree_sitter_helpers_1.getChildByField)(child, 'value');
+            if (value && (value.type === 'argument_list' || value.type === 'initializer_list')) {
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * Static-member / value-read pass. A type/enum/class used only via a member
      * VALUE — `Enum.value`, `Type.CONST`, `Colors.red`, `Foo::BAR` — recorded no
@@ -3980,6 +4729,28 @@ class TreeSitterExtractor {
         const consider = (n) => {
             if (!n)
                 return;
+            // Solidity `modifier_invocation` (unique to that grammar) sits
+            // decorator-position in the function header — OUTSIDE the `body:` field
+            // the call walker descends — but its body executes around the function
+            // via `_;`, so it is a real call-flow hop (`withdraw → onlyOwner →
+            // _checkRole` is the canonical audit trace). The same node type carries
+            // base-constructor invocations (`constructor() ERC20("T","TOK")`), the
+            // constructor-chain hop. Emit `calls`, not `decorates`, so flow
+            // traversal rides it.
+            if (n.type === 'modifier_invocation') {
+                const target = n.namedChild(0);
+                const name = target?.type === 'identifier' ? (0, tree_sitter_helpers_1.getNodeText)(target, this.source) : undefined;
+                if (name) {
+                    this.unresolvedReferences.push({
+                        fromNodeId: decoratedId,
+                        referenceName: name,
+                        referenceKind: 'calls',
+                        line: n.startPosition.row + 1,
+                        column: n.startPosition.column,
+                    });
+                }
+                return;
+            }
             // `marker_annotation` is Java's grammar for arg-less annotations
             // (`@Override`, `@Deprecated`); `attribute` is Swift's grammar for
             // attributes and PROPERTY WRAPPERS (`@objc`, `@Argument`, `@Published`,
@@ -4157,6 +4928,43 @@ class TreeSitterExtractor {
         }
         flush();
     }
+    /**
+     * Record a C++ local function-pointer binding (`local = &fn` / `&fn<…>` /
+     * `&ns::fn<…>`) for the CURRENT enclosing symbol, so calls through the local
+     * resolve to the real target (see cppLocalFnPtrs). Only the address-of shape
+     * is accepted — a bare-identifier RHS (`auto x = y;`) is any value copy, and
+     * linking through it would guess.
+     */
+    recordCppFnPtrBinding(localName, value) {
+        if (!value || value.type !== 'pointer_expression')
+            return;
+        if (value.child(0)?.type !== '&')
+            return; // `*p` dereference, not address-of
+        const arg = (0, tree_sitter_helpers_1.getChildByField)(value, 'argument') ?? value.namedChild(0);
+        if (!arg ||
+            (arg.type !== 'identifier' &&
+                arg.type !== 'template_function' &&
+                arg.type !== 'qualified_identifier')) {
+            return;
+        }
+        const callerId = this.nodeStack[this.nodeStack.length - 1];
+        if (!callerId)
+            return;
+        const target = (0, c_cpp_1.stripCppTemplateArgs)((0, tree_sitter_helpers_1.getNodeText)(arg, this.source));
+        if (!target || target === localName)
+            return;
+        let locals = this.cppLocalFnPtrs.get(callerId);
+        if (!locals) {
+            locals = new Map();
+            this.cppLocalFnPtrs.set(callerId, locals);
+        }
+        let targets = locals.get(localName);
+        if (!targets) {
+            targets = new Set();
+            locals.set(localName, targets);
+        }
+        targets.add(target);
+    }
     visitFunctionBody(body, _functionId) {
         if (!this.extractor)
             return;
@@ -4172,7 +4980,7 @@ class TreeSitterExtractor {
             if (this.extractor.callTypes.includes(nodeType)) {
                 this.extractCall(node);
             }
-            else if (INSTANTIATION_KINDS.has(nodeType)) {
+            else if (INSTANTIATION_KINDS.has(nodeType) || this.isVbnetConstructorShapedArrayCreation(node)) {
                 // `new Foo()` inside a function body — emit an `instantiates`
                 // reference. Without this branch the body walker only knew
                 // about `call_expression`, so constructor invocations
@@ -4202,6 +5010,43 @@ class TreeSitterExtractor {
                     }
                 }
             }
+            // C++ stack / direct-initialization construction — `Calculator calc(0)`
+            // and `Widget w{1, 2}`. Unlike heap `new Calculator(0)` (a new_expression
+            // handled above), these carry the constructor arguments directly on the
+            // declarator with NO call/new node, so the body walker saw no constructor
+            // invocation and recorded no `instantiates` edge (#1035). A declaration's
+            // `type` field IS the constructed class name, so reuse extractInstantiation
+            // (which strips template args / namespace and emits the `instantiates`
+            // ref). Children still recurse below, so a nested ctor-arg call
+            // (`Calculator calc(make())`) keeps its own `calls` ref.
+            if (nodeType === 'declaration' && this.language === 'cpp' && this.isCppStackConstruction(node)) {
+                this.extractInstantiation(node);
+            }
+            // C++ local function-pointer bindings (see cppLocalFnPtrs): record
+            // `auto kernel = &fn<…>;` declarations and `kernel = &other_fn<…>;`
+            // branch reassignments so a call/launch through the local links to the
+            // real target(s). The body walker sees these in source order, and C++
+            // requires declaration-before-use, so the map is always populated before
+            // the call that consumes it.
+            if (this.language === 'cpp' && this.nodeStack.length > 0) {
+                if (nodeType === 'declaration') {
+                    for (let i = 0; i < node.namedChildCount; i++) {
+                        const child = node.namedChild(i);
+                        if (child?.type !== 'init_declarator')
+                            continue;
+                        const decl = (0, tree_sitter_helpers_1.getChildByField)(child, 'declarator');
+                        if (decl?.type !== 'identifier')
+                            continue;
+                        this.recordCppFnPtrBinding((0, tree_sitter_helpers_1.getNodeText)(decl, this.source), (0, tree_sitter_helpers_1.getChildByField)(child, 'value'));
+                    }
+                }
+                else if (nodeType === 'assignment_expression') {
+                    const left = (0, tree_sitter_helpers_1.getChildByField)(node, 'left');
+                    if (left?.type === 'identifier') {
+                        this.recordCppFnPtrBinding((0, tree_sitter_helpers_1.getNodeText)(left, this.source), (0, tree_sitter_helpers_1.getChildByField)(node, 'right'));
+                    }
+                }
+            }
             // Static-member / value-read: `Enum.value`, `Type.CONST`, `Foo::BAR`.
             this.extractStaticMemberRef(node);
             // Local variable type annotations inside a body — `const items: Foo[] = []`,
@@ -4396,7 +5241,11 @@ 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).
+            // ref per base type (skip the public/private/protected keywords). A
+            // templated base (`Base<int>`, `ns::Tpl<int>`) arrives as a `template_type`
+            // or a `qualified_identifier` wrapping one; strip the `<…>` args so the ref
+            // matches the bare class the template was defined as — `Base`, `ns::Tpl` —
+            // instead of never resolving (#1043).
             if (child.type === 'base_class_clause') {
                 for (const t of child.namedChildren) {
                     if (t.type === 'type_identifier' ||
@@ -4404,7 +5253,7 @@ class TreeSitterExtractor {
                         t.type === 'template_type') {
                         this.unresolvedReferences.push({
                             fromNodeId: classId,
-                            referenceName: (0, tree_sitter_helpers_1.getNodeText)(t, this.source),
+                            referenceName: (0, c_cpp_1.stripCppTemplateArgs)((0, tree_sitter_helpers_1.getNodeText)(t, this.source)),
                             referenceKind: 'extends',
                             line: t.startPosition.row + 1,
                             column: t.startPosition.column,
@@ -4522,6 +5371,33 @@ class TreeSitterExtractor {
                     }
                 }
             }
+            // VB.NET: `Inherits Base` / `Implements IFoo, IBar(Of T)` are STATEMENTS
+            // inside the class body (children of the class node), not header clauses.
+            // Each name is a simple/qualified/generic reference; generics unwrap to
+            // the base identifier and dotted paths keep the trailing segment.
+            if (this.language === 'vbnet' &&
+                (child.type === 'inherits_statement' || child.type === 'implements_statement')) {
+                const kind = child.type === 'inherits_statement' ? 'extends' : 'implements';
+                for (const ref of child.namedChildren) {
+                    if (!ref || (ref.type !== 'simple_name' && ref.type !== 'qualified_name' && ref.type !== 'generic_name' && ref.type !== 'global_qualified_name'))
+                        continue;
+                    let name = (0, tree_sitter_helpers_1.getNodeText)(ref, this.source);
+                    name = name.replace(/\(\s*Of\b[^)]*\)/gi, '');
+                    const lastDot = name.lastIndexOf('.');
+                    if (lastDot >= 0)
+                        name = name.slice(lastDot + 1);
+                    name = name.trim();
+                    if (!name)
+                        continue;
+                    this.unresolvedReferences.push({
+                        fromNodeId: classId,
+                        referenceName: name,
+                        referenceKind: kind,
+                        line: ref.startPosition.row + 1,
+                        column: ref.startPosition.column,
+                    });
+                }
+            }
             // C#: `class Movie : BaseItem, IPlugin` → base_list with identifier children
             // base_list combines both base class and interfaces in a single colon-separated list.
             // We emit all as 'extends' since the syntax doesn't distinguish them.
@@ -4597,6 +5473,33 @@ class TreeSitterExtractor {
             if (child.type === 'field_declaration_list' || child.type === 'class_heritage') {
                 this.extractInheritance(child, classId);
             }
+            // CFML cfscript `component extends="Base" implements="IFoo,IBar" { ... }`
+            // (also covers `interface extends="IBase" { ... }`, which reuses the same
+            // component_attribute shape). Attributes are generic name=value pairs —
+            // (identifier label, expression value) — not a dedicated extends_clause,
+            // so filter by the label text. `implements` is a comma-separated list.
+            if (child.type === 'component_attribute' && node.type === 'component') {
+                const label = child.namedChildren.find((c) => c.type === 'identifier');
+                const value = child.namedChildren.find((c) => c.type !== 'identifier');
+                if (label && value) {
+                    const labelText = (0, tree_sitter_helpers_1.getNodeText)(label, this.source).toLowerCase();
+                    if (labelText === 'extends' || labelText === 'implements') {
+                        const valueText = (0, tree_sitter_helpers_1.getNodeText)(value, this.source).replace(/^["']|["']$/g, '');
+                        const names = labelText === 'implements'
+                            ? valueText.split(',').map((s) => s.trim()).filter(Boolean)
+                            : [valueText.trim()].filter(Boolean);
+                        for (const name of names) {
+                            this.unresolvedReferences.push({
+                                fromNodeId: classId,
+                                referenceName: name,
+                                referenceKind: labelText === 'implements' ? 'implements' : 'extends',
+                                line: value.startPosition.row + 1,
+                                column: value.startPosition.column,
+                            });
+                        }
+                    }
+                }
+            }
         }
     }
     /**
@@ -4656,7 +5559,7 @@ class TreeSitterExtractor {
      * Languages that support type annotations (TypeScript, etc.)
      */
     TYPE_ANNOTATION_LANGUAGES = new Set([
-        'typescript', 'tsx', 'dart', 'kotlin', 'swift', 'rust', 'go', 'java', 'csharp', 'scala', 'php',
+        'typescript', 'tsx', 'arkts', 'dart', 'kotlin', 'swift', 'rust', 'go', 'java', 'csharp', 'scala', 'php',
     ]);
     /**
      * PHP pseudo-types and `self`/`static`/`parent` that aren't project symbols.
@@ -5550,7 +6453,19 @@ function extractFromSource(filePath, source, language, frameworkNames) {
         const extractor = new mybatis_extractor_1.MyBatisExtractor(filePath, source);
         result = extractor.extract();
     }
+    else if (detectedLanguage === 'cfml' || detectedLanguage === 'cfscript') {
+        // Custom extractor for CFML (.cfc/.cfm) — dialect-switches between the
+        // tag-based cfml grammar and the bare-script cfscript grammar. Standalone
+        // `.cfs` files (language 'cfscript') are always pure script (never `<`-led),
+        // so routing them through here too gets them the same anonymous-component
+        // filename fallback as a bare-script `.cfc` — without it a `.cfs` whose
+        // `component { ... }` declares no name (the grammar has no `name` field;
+        // CFML never spells one in source) stays `<anonymous>`.
+        const extractor = new cfml_extractor_1.CfmlExtractor(filePath, source, detectedLanguage);
+        result = extractor.extract();
+    }
     else if (detectedLanguage === 'arkts') {
+        // HomeGraph uses the arkanalyzer-backed ArkTS extractor (not tree-sitter).
         const extractor = new arkts_1.ArkTSExtractor(filePath, source);
         result = extractor.extract();
     }