fix: remove all parent() calls and fix PHP method call detection

Author: fsender

native/queries/php-calls.scm

@@ -3,6 +3,7 @@
 ; =============================================================
 
 ; Direct function calls: foo(), strlen($s)
+; Must be checked first to avoid being captured by method call patterns
 (function_call_expression
   function: (name) @callee.name) @call
 
@@ -11,17 +12,17 @@
   function: (qualified_name
     (name) @callee.name)) @call
 
+; Static method calls: Foo::bar(), self::method()
+(scoped_call_expression
+  name: (name) @callee.name) @static.call
+
 ; Method calls: $obj->method()
 (member_call_expression
-  name: (name) @callee.name) @call
+  name: (name) @callee.name) @method.call
 
 ; Nullsafe method calls: $obj?->method()
 (nullsafe_member_call_expression
-  name: (name) @callee.name) @call
-
-; Static method calls: Foo::bar(), self::method()
-(scoped_call_expression
-  name: (name) @callee.name) @call
+  name: (name) @callee.name) @method.call
 
 ; Constructor calls: new Foo()
 (object_creation_expression

native/src/call_extractor.rs

@@ -38,9 +38,6 @@ pub fn extract_calls(content: &str, language_name: &str) -> Result<Vec<CallSite>
         .set_language(&ts_language)
         .map_err(|e| anyhow!("Failed to set language: {}", e))?;
 
-    // Set a timeout to prevent infinite parsing loops
-    parser.set_timeout_micros(5_000_000); // 5 seconds timeout
-
     let tree = parser
         .parse(content, None)
         .ok_or_else(|| anyhow!("Parse failed"))?;
@@ -63,31 +60,15 @@ pub fn extract_calls(content: &str, language_name: &str) -> Result<Vec<CallSite>
     let query = Query::new(&ts_language, query_source)
         .map_err(|e| anyhow!("Failed to compile query: {}", e))?;
 
-    // Disable query analysis that causes the crash (tree-sitter bug with analysis_state__compare_position)
     let callee_name_idx = query.capture_index_for_name("callee.name");
     let call_idx = query.capture_index_for_name("call");
+    let method_call_idx = query.capture_index_for_name("method.call");
+    let static_call_idx = query.capture_index_for_name("static.call");
     let constructor_idx = query.capture_index_for_name("constructor");
     let import_name_idx = query.capture_index_for_name("import.name");
     let import_default_idx = query.capture_index_for_name("import.default");
     let import_namespace_idx = query.capture_index_for_name("import.namespace");
 
-    let method_parent_kinds: &[&str] = match language {
-        Language::TypeScript
-        | Language::TypeScriptTsx
-        | Language::JavaScript
-        | Language::JavaScriptJsx => &["member_expression"],
-        Language::Python => &["attribute"],
-        Language::Rust => &["field_expression"],
-        Language::Go => &["selector_expression"],
-        Language::Php => &[
-            "member_call_expression",
-            "scoped_call_expression",
-            "nullsafe_member_call_expression",
-        ],
-        _ => &[],
-    };
-    let _method_parent_kinds = method_parent_kinds;
-
     let mut cursor = QueryCursor::new();
     let mut calls = Vec::new();
     let text_bytes = content.as_bytes();
@@ -114,8 +95,31 @@ pub fn extract_calls(content: &str, language_name: &str) -> Result<Vec<CallSite>
             }
 
             if let Some(idx) = call_idx {
+                if capture.index == idx {
+                    // Check if this is actually a method call by looking at other captures
+                    // If method_call_idx or static_call_idx also matches, it's a method call
+                    let is_method_call = match_.captures.iter().any(|c| {
+                        method_call_idx.map(|idx| c.index == idx).unwrap_or(false)
+                            || static_call_idx.map(|idx| c.index == idx).unwrap_or(false)
+                    });
+
+                    if is_method_call {
+                        call_type = Some(CallType::MethodCall);
+                    } else {
+                        call_type = Some(CallType::Call);
+                    }
+                }
+            }
+
+            if let Some(idx) = method_call_idx {
                 if capture.index == idx && call_type.is_none() {
-                    call_type = Some(CallType::Call);
+                    call_type = Some(CallType::MethodCall);
+                }
+            }
+
+            if let Some(idx) = static_call_idx {
+                if capture.index == idx && call_type.is_none() {
+                    call_type = Some(CallType::MethodCall);
                 }
             }
 
@@ -153,49 +157,35 @@ pub fn extract_calls(content: &str, language_name: &str) -> Result<Vec<CallSite>
             }
         }
 
-        // Safely detect method calls by checking the callee node's parent
-        // instead of using query analysis which triggers tree-sitter bug
-        // The callee.name node is a property_identifier for method calls,
-        // and its parent is member_expression/attribute/etc.
+        // Safely detect method calls using query context analysis
+        // For PHP: check if the call is wrapped in a method call pattern
         if let (Some(name), Some(CallType::Call), Some(pos)) = (&callee_name, call_type, position) {
-            // Find the callee.name capture node
-            let callee_name_node = match_
-                .captures
-                .iter()
-                .find(|c| callee_name_idx.map(|idx| c.index == idx).unwrap_or(false))
-                .map(|c| c.node);
-
             let is_method_call = match language {
                 Language::TypeScript
                 | Language::TypeScriptTsx
                 | Language::JavaScript
-                | Language::JavaScriptJsx => callee_name_node
-                    .and_then(|n| n.parent())
-                    .map(|p| p.kind() == "member_expression")
-                    .unwrap_or(false),
-                Language::Python => callee_name_node
-                    .and_then(|n| n.parent())
-                    .map(|p| p.kind() == "attribute")
-                    .unwrap_or(false),
-                Language::Rust => callee_name_node
-                    .and_then(|n| n.parent())
-                    .map(|p| p.kind() == "field_expression")
-                    .unwrap_or(false),
-                Language::Go => callee_name_node
-                    .and_then(|n| n.parent())
-                    .map(|p| p.kind() == "selector_expression")
-                    .unwrap_or(false),
-                Language::Php => callee_name_node
-                    .and_then(|n| n.parent())
-                    .map(|p| {
-                        matches!(
-                            p.kind(),
-                            "member_call_expression"
-                                | "scoped_call_expression"
-                                | "nullsafe_member_call_expression"
-                        )
-                    })
-                    .unwrap_or(false),
+                | Language::JavaScriptJsx => match_.captures.iter().any(|c| {
+                    callee_name_idx.map(|idx| c.index == idx).unwrap_or(false)
+                        && (c.node.kind() == "property_identifier" || c.node.kind() == "identifier")
+                }),
+                Language::Python => match_.captures.iter().any(|c| {
+                    callee_name_idx.map(|idx| c.index == idx).unwrap_or(false)
+                        && c.node.kind() == "identifier"
+                }),
+                Language::Rust => match_.captures.iter().any(|c| {
+                    callee_name_idx.map(|idx| c.index == idx).unwrap_or(false)
+                        && c.node.kind() == "field_identifier"
+                }),
+                Language::Go => match_.captures.iter().any(|c| {
+                    callee_name_idx.map(|idx| c.index == idx).unwrap_or(false)
+                        && c.node.kind() == "field_identifier"
+                }),
+                Language::Php => {
+                    // PHP method calls are already marked in query (@method.call, @static.call)
+                    // @call is only for direct function calls
+                    // So if we reach here with CallType::Call, it's definitely not a method call
+                    false
+                }
                 _ => false,
             };
 

tests/call-graph.test.ts

@@ -48,6 +48,19 @@ describe("call-graph", () => {
           expect(createCall!.callType).toBe("MethodCall");
         });
 
+        it("should detect method calls using zero-allocation approach", () => {
+          const content = fs.readFileSync(path.join(fixturesDir, "php-method-zeroalloc.php"), "utf-8");
+          const calls = extractCalls(content, "php");
+
+          // Check that method calls are correctly identified without using parent() on callee.name
+          const methodCalls = calls.filter((c) => c.callType === "MethodCall");
+          expect(methodCalls.length).toBeGreaterThan(0);
+
+          // Verify specific method call patterns
+          expect(methodCalls.some(c => c.calleeName === "process")).toBe(true);
+          expect(methodCalls.some(c => c.calleeName === "validate")).toBe(true);
+        });
+
     it("should extract method calls", () => {
       const content = fs.readFileSync(path.join(fixturesDir, "method-calls.ts"), "utf-8");
       const calls = extractCalls(content, "typescript");

tests/fixtures/call-graph/php-method-zeroalloc.php

@@ -0,0 +1,29 @@
+<?php
+
+// Test zero-allocation method call detection
+// Uses method_call_expression patterns
+
+class Service {
+    public function process($data) {
+        return $this->validate($data);
+    }
+
+    public function validate($data) {
+        return $data !== null;
+    }
+
+    public static function create() {
+        return new self();
+    }
+}
+
+// Direct method calls
+$service = new Service();
+$service->process("data");
+$service->validate("data");
+
+// Static method calls
+Service::create();
+
+// Chain calls
+$service->process("data")->validate("data");