homegraph 1.1.3 → 1.2.0

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");
@@ -81,20 +82,43 @@ const VUE_STORE_FILE_SIGNAL = /\bdefineStore\b|\bcreateStore\b|\bVuex\b|\bmutati
  * 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);
@@ -980,29 +1004,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 +1067,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,
@@ -1455,6 +1508,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 +1536,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);
@@ -3391,6 +3450,63 @@ class TreeSitterExtractor {
         const callerId = this.nodeStack[this.nodeStack.length - 1];
         if (!callerId)
             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;
+        }
         // Get the function/method being called
         let calleeName = '';
         // Java/Kotlin method_invocation has 'object' + 'name' fields instead of 'function'
@@ -3822,6 +3938,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
@@ -4202,6 +4357,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[] = []`,
@@ -4396,7 +4563,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 +4575,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,