@colbymchenry/codegraph-darwin-x64 1.1.2 → 1.1.4

package/lib/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");
@@ -3850,6 +3851,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
@@ -4230,6 +4270,18 @@ 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);
+            }
             // Static-member / value-read: `Enum.value`, `Type.CONST`, `Foo::BAR`.
             this.extractStaticMemberRef(node);
             // Local variable type annotations inside a body — `const items: Foo[] = []`,
@@ -4424,7 +4476,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' ||
@@ -4432,7 +4488,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,