Merge branch 'main' into fix/version-aware-strip-types

carlos-alm · web-flow · commit a7f4e6df8d40 · 2026-03-25T15:12:41.000-06:00
diff --git a/crates/codegraph-core/src/extractors/helpers.rs b/crates/codegraph-core/src/extractors/helpers.rs
@@ -100,6 +100,8 @@ pub const AST_TEXT_MAX: usize = 200;
 
 /// Language-specific AST node type configuration.
 pub struct LangAstConfig {
+    /// Node types mapping to `"call"` kind (e.g. `call_expression`, `method_invocation`)
+    pub call_types: &'static [&'static str],
     /// Node types mapping to `"new"` kind (e.g. `new_expression`, `object_creation_expression`)
     pub new_types: &'static [&'static str],
     /// Node types mapping to `"throw"` kind (e.g. `throw_statement`, `raise_statement`)
@@ -120,6 +122,7 @@ pub struct LangAstConfig {
 // ── Per-language configs ─────────────────────────────────────────────────────
 
 pub const PYTHON_AST_CONFIG: LangAstConfig = LangAstConfig {
+    call_types: &["call"],
     new_types: &[],
     throw_types: &["raise_statement"],
     await_types: &["await"],
@@ -130,6 +133,7 @@ pub const PYTHON_AST_CONFIG: LangAstConfig = LangAstConfig {
 };
 
 pub const GO_AST_CONFIG: LangAstConfig = LangAstConfig {
+    call_types: &["call_expression"],
     new_types: &[],
     throw_types: &[],
     await_types: &[],
@@ -140,6 +144,7 @@ pub const GO_AST_CONFIG: LangAstConfig = LangAstConfig {
 };
 
 pub const RUST_AST_CONFIG: LangAstConfig = LangAstConfig {
+    call_types: &["call_expression", "method_call_expression"],
     new_types: &[],
     throw_types: &[],
     await_types: &["await_expression"],
@@ -150,6 +155,7 @@ pub const RUST_AST_CONFIG: LangAstConfig = LangAstConfig {
 };
 
 pub const JAVA_AST_CONFIG: LangAstConfig = LangAstConfig {
+    call_types: &["method_invocation"],
     new_types: &["object_creation_expression"],
     throw_types: &["throw_statement"],
     await_types: &[],
@@ -160,6 +166,7 @@ pub const JAVA_AST_CONFIG: LangAstConfig = LangAstConfig {
 };
 
 pub const CSHARP_AST_CONFIG: LangAstConfig = LangAstConfig {
+    call_types: &["invocation_expression"],
     new_types: &["object_creation_expression"],
     throw_types: &["throw_statement", "throw_expression"],
     await_types: &["await_expression"],
@@ -170,6 +177,7 @@ pub const CSHARP_AST_CONFIG: LangAstConfig = LangAstConfig {
 };
 
 pub const RUBY_AST_CONFIG: LangAstConfig = LangAstConfig {
+    call_types: &["call", "method_call"],
     new_types: &[],
     throw_types: &[],
     await_types: &[],
@@ -180,6 +188,7 @@ pub const RUBY_AST_CONFIG: LangAstConfig = LangAstConfig {
 };
 
 pub const PHP_AST_CONFIG: LangAstConfig = LangAstConfig {
+    call_types: &["function_call_expression", "member_call_expression", "scoped_call_expression"],
     new_types: &["object_creation_expression"],
     throw_types: &["throw_expression"],
     await_types: &[],
@@ -229,6 +238,43 @@ fn walk_ast_nodes_with_config_depth(
     }
     let kind = node.kind();
 
+    // Call extraction — checked first since calls are the most common AST node kind.
+    // Do NOT recurse children: prevents double-counting nested calls like `a(b())`.
+    if config.call_types.contains(&kind) {
+        let name = extract_call_name(node, source);
+        let receiver = extract_call_receiver(node, source);
+        let text = truncate(node_text(node, source), AST_TEXT_MAX);
+        ast_nodes.push(AstNode {
+            kind: "call".to_string(),
+            name,
+            line: start_line(node),
+            text: Some(text),
+            receiver,
+        });
+        // Recurse into arguments only — nested calls in args should be captured.
+        // Use child_by_field_name("arguments") — immune to kind-name variation across grammars.
+        // Falls back to kind-based matching for grammars that don't expose a field name.
+        let args_node = node.child_by_field_name("arguments").or_else(|| {
+            for i in 0..node.child_count() {
+                if let Some(child) = node.child(i) {
+                    let ck = child.kind();
+                    if ck == "arguments" || ck == "argument_list" || ck == "method_arguments" {
+                        return Some(child);
+                    }
+                }
+            }
+            None
+        });
+        if let Some(args) = args_node {
+            for j in 0..args.child_count() {
+                if let Some(arg) = args.child(j) {
+                    walk_ast_nodes_with_config_depth(&arg, source, ast_nodes, config, depth + 1);
+                }
+            }
+        }
+        return;
+    }
+
     if config.new_types.contains(&kind) {
         let name = extract_constructor_name(node, source);
         let text = truncate(node_text(node, source), AST_TEXT_MAX);
@@ -261,7 +307,9 @@ fn walk_ast_nodes_with_config_depth(
             text,
             receiver: None,
         });
-        // Fall through to recurse children
+        // Fall through to recurse children — captures strings, calls, etc. inside await expr.
+        // The call_types guard at the top of the function already handles `call_expression`
+        // nodes correctly (recurse-into-args-only), so there is no double-counting risk here.
     } else if config.string_types.contains(&kind) {
         let raw = node_text(node, source);
         let is_raw_string = kind.contains("raw_string");
@@ -400,6 +448,42 @@ fn extract_call_name(node: &Node, source: &[u8]) -> String {
     text.split('(').next().unwrap_or("?").to_string()
 }
 
+/// Extract receiver from a call node (e.g. `obj` from `obj.method()`).
+/// Looks for a member-expression-like function child and extracts the object part.
+fn extract_call_receiver(node: &Node, source: &[u8]) -> Option<String> {
+    // PHP: scoped_call_expression — receiver is the "scope" field (e.g. MyClass in MyClass::method())
+    if let Some(scope) = node.child_by_field_name("scope") {
+        return Some(node_text(&scope, source).to_string());
+    }
+    // Try "function" field first (JS/TS: call_expression -> member_expression)
+    // Then "object" (Go, Python), then "receiver" (Ruby)
+    for field in &["function", "object", "receiver"] {
+        if let Some(fn_node) = node.child_by_field_name(field) {
+            // JS/TS/Python: member_expression / attribute with "object" field
+            if let Some(obj) = fn_node.child_by_field_name("object") {
+                return Some(node_text(&obj, source).to_string());
+            }
+            // Go: selector_expression uses "operand" not "object"
+            if fn_node.kind() == "selector_expression" {
+                if let Some(operand) = fn_node.child_by_field_name("operand") {
+                    return Some(node_text(&operand, source).to_string());
+                }
+            }
+            // C#: member_access_expression uses "expression" not "object"
+            if fn_node.kind() == "member_access_expression" {
+                if let Some(expr) = fn_node.child_by_field_name("expression") {
+                    return Some(node_text(&expr, source).to_string());
+                }
+            }
+            // For Ruby/Go where the receiver is directly a field
+            if *field == "object" || *field == "receiver" {
+                return Some(node_text(&fn_node, source).to_string());
+            }
+        }
+    }
+    None
+}
+
 /// Extract expression text from throw/await — skip the keyword child.
 fn extract_child_expression_text(node: &Node, source: &[u8]) -> Option<String> {
     const KEYWORDS: &[&str] = &["throw", "raise", "await", "new"];
diff --git a/crates/codegraph-core/src/extractors/javascript.rs b/crates/codegraph-core/src/extractors/javascript.rs
@@ -518,7 +518,7 @@ fn walk_node_depth(node: &Node, source: &[u8], symbols: &mut FileSymbols, depth:
 
 const TEXT_MAX: usize = 200;
 
-/// Walk the tree collecting new/throw/await/string/regex AST nodes.
+/// Walk the tree collecting call/new/throw/await/string/regex AST nodes.
 /// Mirrors `walkAst()` in `ast.js:216-276`.
 fn walk_ast_nodes(node: &Node, source: &[u8], ast_nodes: &mut Vec<AstNode>) {
     walk_ast_nodes_depth(node, source, ast_nodes, 0);
@@ -529,6 +529,28 @@ fn walk_ast_nodes_depth(node: &Node, source: &[u8], ast_nodes: &mut Vec<AstNode>
         return;
     }
     match node.kind() {
+        "call_expression" => {
+            let (name, receiver) = extract_js_call_ast(node, source);
+            let text = truncate(node_text(node, source), TEXT_MAX);
+            ast_nodes.push(AstNode {
+                kind: "call".to_string(),
+                name,
+                line: start_line(node),
+                text: Some(text),
+                receiver,
+            });
+            // Recurse into arguments only — nested calls in args should be captured.
+            if let Some(args) = node.child_by_field_name("arguments")
+                .or_else(|| find_child(node, "arguments"))
+            {
+                for i in 0..args.child_count() {
+                    if let Some(arg) = args.child(i) {
+                        walk_ast_nodes_depth(&arg, source, ast_nodes, depth + 1);
+                    }
+                }
+            }
+            return;
+        }
         "new_expression" => {
             let name = extract_new_name(node, source);
             let text = truncate(node_text(node, source), TEXT_MAX);
@@ -698,6 +720,34 @@ fn extract_expression_text(node: &Node, source: &[u8]) -> Option<String> {
     Some(truncate(node_text(node, source), TEXT_MAX))
 }
 
+/// Extract call name and optional receiver from a JS/TS `call_expression`.
+/// `fetch()` → ("fetch", None); `obj.method()` → ("obj.method", Some("obj"))
+fn extract_js_call_ast(node: &Node, source: &[u8]) -> (String, Option<String>) {
+    if let Some(fn_node) = node.child_by_field_name("function") {
+        match fn_node.kind() {
+            "member_expression" => {
+                let name = node_text(&fn_node, source).to_string();
+                let receiver = fn_node.child_by_field_name("object")
+                    .map(|obj| node_text(&obj, source).to_string());
+                (name, receiver)
+            }
+            "identifier" => {
+                (node_text(&fn_node, source).to_string(), None)
+            }
+            _ => {
+                // Computed call like `fn[key]()` — use full text before `(`
+                let text = node_text(node, source);
+                let name = text.split('(').next().unwrap_or("?").to_string();
+                (name, None)
+            }
+        }
+    } else {
+        let text = node_text(node, source);
+        let name = text.split('(').next().unwrap_or("?").to_string();
+        (name, None)
+    }
+}
+
 // ── Extended kinds helpers ──────────────────────────────────────────────────
 
 fn extract_js_parameters(node: &Node, source: &[u8]) -> Vec<Definition> {
diff --git a/src/ast-analysis/engine.ts b/src/ast-analysis/engine.ts
@@ -172,7 +172,7 @@ function setupVisitors(
   // AST-store visitor
   let astVisitor: Visitor | null = null;
   const astTypeMap = AST_TYPE_MAPS.get(langId);
-  if (doAst && astTypeMap && WALK_EXTENSIONS.has(ext) && !symbols.astNodes?.length) {
+  if (doAst && astTypeMap && WALK_EXTENSIONS.has(ext) && !Array.isArray(symbols.astNodes)) {
     const nodeIdMap = new Map<string, number>();
     for (const row of bulkNodeIdsByFile(db, relPath)) {
       nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
diff --git a/src/features/ast.ts b/src/features/ast.ts
@@ -93,7 +93,10 @@ export async function buildAstNodes(
       nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
     }
 
-    if (symbols.calls) {
+    // When native astNodes includes call entries, skip separate symbols.calls processing
+    // to avoid duplication. Fall back to symbols.calls for WASM or older native binaries.
+    const nativeProvidedAstNodes = Array.isArray(symbols.astNodes);
+    if (symbols.calls && !nativeProvidedAstNodes) {
       for (const call of symbols.calls) {
         const parentDef = findParentDef(defs, call.line);
         let parentNodeId: number | null = null;
@@ -113,7 +116,8 @@ export async function buildAstNodes(
       }
     }
 
-    if (symbols.astNodes?.length) {
+    if (Array.isArray(symbols.astNodes)) {
+      // Native engine provided AST nodes (may be empty for files with no AST content)
       for (const n of symbols.astNodes) {
         const parentDef = findParentDef(defs, n.line);
         let parentNodeId: number | null = null;
@@ -132,6 +136,7 @@ export async function buildAstNodes(
         });
       }
     } else {
+      // WASM fallback — walk tree if available
       const ext = path.extname(relPath).toLowerCase();
       if (WALK_EXTENSIONS.has(ext) && symbols._tree) {
         const astRows: AstRow[] = [];
diff --git a/tests/engines/ast-parity.test.ts b/tests/engines/ast-parity.test.ts
