fix: remove parent() calls, upgrade tree-sitter, fix PHP method call detection

Author: fsender

native/Cargo.lock

@@ -16,7 +16,7 @@ crate-type = ["cdylib"]
 napi = { version = "2.16", default-features = false, features = ["napi9", "async", "serde-json"] }
 napi-derive = "2.16"
 
-tree-sitter = "0.24"
+tree-sitter = "0.26.8"
 tree-sitter-typescript = "0.23"
 tree-sitter-javascript = "0.23"
 tree-sitter-python = "0.23"

native/Cargo.toml

@@ -16,7 +16,7 @@
 ; -------------------------------------------------------------
 (call_expression
   function: (member_expression
-    property: (property_identifier) @callee.name)) @call
+    property: (property_identifier) @callee.name)) @method.call
 
 ; -------------------------------------------------------------
 ; Constructor calls: new Foo(), new Bar(args)

native/queries/typescript-calls.scm

@@ -56,7 +56,6 @@ pub fn extract_calls(content: &str, language_name: &str) -> Result<Vec<CallSite>
         _ => return Ok(vec![]),
     };
 
-    // Limit query analysis to prevent tree-sitter internal bugs
     let query = Query::new(&ts_language, query_source)
         .map_err(|e| anyhow!("Failed to compile query: {}", e))?;
 
@@ -157,47 +156,17 @@ pub fn extract_calls(content: &str, language_name: &str) -> Result<Vec<CallSite>
             }
         }
 
-        // 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) {
-            let is_method_call = match language {
-                Language::TypeScript
-                | Language::TypeScriptTsx
-                | Language::JavaScript
-                | 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,
-            };
-
-            let final_call_type = if is_method_call {
-                CallType::MethodCall
-            } else {
-                CallType::Call
-            };
-
+        // PHP method calls are already marked in query (@method.call, @static.call)
+        // @call is only for direct function calls
+        // So we need to check if the call was already classified as a method call
+        if let (Some(name), Some(ct), Some(pos)) = (callee_name, call_type, position) {
             // PHP function/method names are case-insensitive; normalize to lowercase
             // so that HELPER() matches symbol helper during resolution and lookup.
-            let normalized_name = if language == Language::Php {
+            // Import names and constructor names should keep their original case for proper symbol resolution
+            let normalized_name = if language == Language::Php
+                && ct != CallType::Import
+                && ct != CallType::Constructor
+            {
                 name.to_lowercase()
             } else {
                 name.clone()
@@ -207,13 +176,6 @@ pub fn extract_calls(content: &str, language_name: &str) -> Result<Vec<CallSite>
                 callee_name: normalized_name,
                 line: pos.0,
                 column: pos.1,
-                call_type: final_call_type,
-            });
-        } else if let (Some(name), Some(ct), Some(pos)) = (callee_name, call_type, position) {
-            calls.push(CallSite {
-                callee_name: name,
-                line: pos.0,
-                column: pos.1,
                 call_type: ct,
             });
         }

native/src/call_extractor.rs

@@ -497,7 +497,7 @@ fn extract_name(cursor: &tree_sitter::TreeCursor, source: &str) -> Option<String
     };
 
     for i in 0..node.child_count() {
-        if let Some(child) = node.child(i) {
+        if let Some(child) = node.child(i.try_into().unwrap()) {
             if let Some(name) = extract_identifier(child) {
                 #[cfg(debug_assertions)]
                 {
@@ -511,7 +511,7 @@ fn extract_name(cursor: &tree_sitter::TreeCursor, source: &str) -> Option<String
 
     if node.kind() == "export_statement" {
         for i in 0..node.child_count() {
-            if let Some(child) = node.child(i) {
+            if let Some(child) = node.child(i.try_into().unwrap()) {
                 let child_kind = child.kind();
                 if matches!(
                     child_kind,
@@ -524,7 +524,7 @@ fn extract_name(cursor: &tree_sitter::TreeCursor, source: &str) -> Option<String
                         | "abstract_class_declaration"
                 ) {
                     for j in 0..child.child_count() {
-                        if let Some(grandchild) = child.child(j) {
+                        if let Some(grandchild) = child.child(j.try_into().unwrap()) {
                             if let Some(name) = extract_identifier(grandchild) {
                                 #[cfg(debug_assertions)]
                                 {
@@ -538,10 +538,12 @@ fn extract_name(cursor: &tree_sitter::TreeCursor, source: &str) -> Option<String
 
                     if child_kind == "lexical_declaration" {
                         for j in 0..child.child_count() {
-                            if let Some(declarator) = child.child(j) {
+                            if let Some(declarator) = child.child(j.try_into().unwrap()) {
                                 if declarator.kind() == "variable_declarator" {
                                     for k in 0..declarator.child_count() {
-                                        if let Some(name_node) = declarator.child(k) {
+                                        if let Some(name_node) =
+                                            declarator.child(k.try_into().unwrap())
+                                        {
                                             if name_node.kind() == "identifier" {
                                                 #[cfg(debug_assertions)]
                                                 {