feat(repo-map): add swift, java and php support (#1446)

.pre-commit-config.yaml

@@ -13,7 +13,7 @@ repos:
     - id: stylua-system # or stylua-system / stylua-github
       files: \.lua$
 - repo: https://github.com/doublify/pre-commit-rust
-  rev: master
+  rev: v1.0
   hooks:
   - id: fmt
     files: \.rs$
@@ -21,7 +21,7 @@ repos:
     args: ['--features', 'luajit']
     files: \.rs$
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.9.5
+  rev: v0.9.9
   hooks:
     # 运行 Ruff linter
     - id: ruff
@@ -29,7 +29,7 @@ repos:
     # 运行 Ruff formatter
     - id: ruff-format
 - repo: https://github.com/RobertCraigie/pyright-python
-  rev: v1.1.393
+  rev: v1.1.395
   hooks:
     - id: pyright
       additional_dependencies:

Cargo.lock

@@ -68,13 +68,16 @@ dependencies = [
  "tree-sitter-cpp",
  "tree-sitter-elixir",
  "tree-sitter-go",
+ "tree-sitter-java",
  "tree-sitter-javascript",
  "tree-sitter-language",
  "tree-sitter-lua",
+ "tree-sitter-php",
  "tree-sitter-python",
  "tree-sitter-ruby",
  "tree-sitter-rust",
  "tree-sitter-scala",
+ "tree-sitter-swift",
  "tree-sitter-typescript",
  "tree-sitter-zig",
 ]
@@ -2235,6 +2238,16 @@ dependencies = [
  "tree-sitter-language",
 ]
 
+[[package]]
+name = "tree-sitter-java"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0aa6cbcdc8c679b214e616fd3300da67da0e492e066df01bcf5a5921a71e90d6"
+dependencies = [
+ "cc",
+ "tree-sitter-language",
+]
+
 [[package]]
 name = "tree-sitter-javascript"
 version = "0.23.0"
@@ -2261,6 +2274,16 @@ dependencies = [
  "tree-sitter-language",
 ]
 
+[[package]]
+name = "tree-sitter-php"
+version = "0.23.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f066e94e9272cfe4f1dcb07a1c50c66097eca648f2d7233d299c8ae9ed8c130c"
+dependencies = [
+ "cc",
+ "tree-sitter-language",
+]
+
 [[package]]
 name = "tree-sitter-python"
 version = "0.23.2"
@@ -2301,6 +2324,16 @@ dependencies = [
  "tree-sitter-language",
 ]
 
+[[package]]
+name = "tree-sitter-swift"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdc72ea9c62a6d188c9f7d64109a9b14b09231852b87229c68c44e8738b9e6b9"
+dependencies = [
+ "cc",
+ "tree-sitter-language",
+]
+
 [[package]]
 name = "tree-sitter-typescript"
 version = "0.23.0"

crates/avante-repo-map/Cargo.toml

@@ -18,7 +18,9 @@ serde = { workspace = true, features = ["derive"] }
 tree-sitter = "0.23"
 tree-sitter-language = "0.1"
 tree-sitter-rust = "0.23"
+tree-sitter-php = "0.23.11"
 tree-sitter-python = "0.23"
+tree-sitter-java = "0.23.5"
 tree-sitter-javascript = "0.23"
 tree-sitter-typescript = "0.23"
 tree-sitter-go = "0.23"
@@ -28,6 +30,7 @@ tree-sitter-lua = "0.2"
 tree-sitter-ruby = "0.23"
 tree-sitter-zig = "1.0.2"
 tree-sitter-scala = "0.23"
+tree-sitter-swift = "0.7.0"
 tree-sitter-elixir = "0.3.1"
 tree-sitter-c-sharp = "0.23"
 

crates/avante-repo-map/queries/tree-sitter-java-defs.scm

@@ -0,0 +1,25 @@
+;; Capture exported functions, arrow functions, variables, classes, and method definitions
+
+(class_declaration
+  name: (identifier) @class)
+
+(interface_declaration
+  name: (identifier) @class)
+
+(enum_declaration
+  name: (identifier) @enum)
+
+(enum_constant
+  name: (identifier) @enum_item)
+
+(class_body
+  (field_declaration) @class_variable)
+
+(class_body
+  (constructor_declaration) @method)
+
+(class_body
+  (method_declaration) @method)
+
+(interface_body
+  (method_declaration) @method)

crates/avante-repo-map/queries/tree-sitter-php-defs.scm

@@ -0,0 +1,20 @@
+;; Capture exported functions, arrow functions, variables, classes, and method definitions
+
+(class_declaration) @class
+(interface_declaration) @class
+
+(function_definition) @function
+
+(assignment_expression) @assignment
+
+(const_declaration
+  (const_element
+    (name) @variable))
+
+(_
+    body: (declaration_list
+      (property_declaration) @class_variable))
+
+(_
+  body: (declaration_list
+    (method_declaration) @method))

crates/avante-repo-map/queries/tree-sitter-swift-defs.scm

@@ -0,0 +1,37 @@
+(property_declaration) @variable
+
+(function_declaration) @function
+
+
+(class_declaration
+	_?
+	[
+	 "struct"
+	 "class"
+	]) @class
+
+(class_declaration
+	_?
+	 "enum"
+	) @enum
+
+(class_body
+    (property_declaration) @class_variable)
+
+(class_body
+    (function_declaration) @method)
+
+(class_body
+    (init_declaration) @method)
+
+(protocol_declaration
+    body: (protocol_body
+        (protocol_function_declaration) @function))
+
+(protocol_declaration
+    body: (protocol_body
+        (protocol_property_declaration) @class_variable))
+
+(class_declaration
+	body: (enum_class_body
+            (enum_entry) @enum_item))

crates/avante-repo-map/src/lib.rs

@@ -56,6 +56,8 @@ fn get_ts_language(language: &str) -> Option<LanguageFn> {
     match language {
         "rust" => Some(tree_sitter_rust::LANGUAGE),
         "python" => Some(tree_sitter_python::LANGUAGE),
+        "php" => Some(tree_sitter_php::LANGUAGE_PHP),
+        "java" => Some(tree_sitter_java::LANGUAGE),
         "javascript" => Some(tree_sitter_javascript::LANGUAGE),
         "typescript" => Some(tree_sitter_typescript::LANGUAGE_TSX),
         "go" => Some(tree_sitter_go::LANGUAGE),
@@ -65,6 +67,7 @@ fn get_ts_language(language: &str) -> Option<LanguageFn> {
         "ruby" => Some(tree_sitter_ruby::LANGUAGE),
         "zig" => Some(tree_sitter_zig::LANGUAGE),
         "scala" => Some(tree_sitter_scala::LANGUAGE),
+        "swift" => Some(tree_sitter_swift::LANGUAGE),
         "elixir" => Some(tree_sitter_elixir::LANGUAGE),
         "csharp" => Some(tree_sitter_c_sharp::LANGUAGE),
         _ => None,
@@ -74,14 +77,17 @@ fn get_ts_language(language: &str) -> Option<LanguageFn> {
 const C_QUERY: &str = include_str!("../queries/tree-sitter-c-defs.scm");
 const CPP_QUERY: &str = include_str!("../queries/tree-sitter-cpp-defs.scm");
 const GO_QUERY: &str = include_str!("../queries/tree-sitter-go-defs.scm");
+const JAVA_QUERY: &str = include_str!("../queries/tree-sitter-java-defs.scm");
 const JAVASCRIPT_QUERY: &str = include_str!("../queries/tree-sitter-javascript-defs.scm");
 const LUA_QUERY: &str = include_str!("../queries/tree-sitter-lua-defs.scm");
 const PYTHON_QUERY: &str = include_str!("../queries/tree-sitter-python-defs.scm");
+const PHP_QUERY: &str = include_str!("../queries/tree-sitter-php-defs.scm");
 const RUST_QUERY: &str = include_str!("../queries/tree-sitter-rust-defs.scm");
 const ZIG_QUERY: &str = include_str!("../queries/tree-sitter-zig-defs.scm");
 const TYPESCRIPT_QUERY: &str = include_str!("../queries/tree-sitter-typescript-defs.scm");
 const RUBY_QUERY: &str = include_str!("../queries/tree-sitter-ruby-defs.scm");
 const SCALA_QUERY: &str = include_str!("../queries/tree-sitter-scala-defs.scm");
+const SWIFT_QUERY: &str = include_str!("../queries/tree-sitter-swift-defs.scm");
 const ELIXIR_QUERY: &str = include_str!("../queries/tree-sitter-elixir-defs.scm");
 const CSHARP_QUERY: &str = include_str!("../queries/tree-sitter-c-sharp-defs.scm");
 
@@ -95,14 +101,17 @@ fn get_definitions_query(language: &str) -> Result<Query, String> {
         "c" => C_QUERY,
         "cpp" => CPP_QUERY,
         "go" => GO_QUERY,
+        "java" => JAVA_QUERY,
         "javascript" => JAVASCRIPT_QUERY,
         "lua" => LUA_QUERY,
+        "php" => PHP_QUERY,
         "python" => PYTHON_QUERY,
         "rust" => RUST_QUERY,
         "zig" => ZIG_QUERY,
         "typescript" => TYPESCRIPT_QUERY,
         "ruby" => RUBY_QUERY,
         "scala" => SCALA_QUERY,
+        "swift" => SWIFT_QUERY,
         "elixir" => ELIXIR_QUERY,
         "csharp" => CSHARP_QUERY,
         _ => return Err(format!("Unsupported language: {language}")),
@@ -573,6 +582,21 @@ fn extract_definitions(language: &str, source: &str) -> Result<Vec<Definition>,
                     let visibility_modifier = visibility_modifier_node
                         .map(|n| n.utf8_text(source.as_bytes()).unwrap())
                         .unwrap_or("");
+                    if language == "swift" {
+                        if visibility_modifier.contains("private") {
+                            continue;
+                        }
+                    }
+                    if language == "java" {
+                        let modifier_node = find_descendant_by_type(&node, "modifiers");
+                        if modifier_node.is_some() {
+                            let modifier_text =
+                                modifier_node.unwrap().utf8_text(source.as_bytes()).unwrap();
+                            if modifier_text.contains("private") {
+                                continue;
+                            }
+                        }
+                    }
                     if language == "rust" && !visibility_modifier.contains("pub") {
                         continue;
                     }
@@ -757,6 +781,21 @@ fn extract_definitions(language: &str, source: &str) -> Result<Vec<Definition>,
                     let visibility_modifier = visibility_modifier_node
                         .map(|n| n.utf8_text(source.as_bytes()).unwrap())
                         .unwrap_or("");
+                    if language == "swift" || language == "java" {
+                        if visibility_modifier.contains("private") {
+                            continue;
+                        }
+                    }
+                    if language == "java" {
+                        let modifier_node = find_descendant_by_type(&node, "modifiers");
+                        if modifier_node.is_some() {
+                            let modifier_text =
+                                modifier_node.unwrap().utf8_text(source.as_bytes()).unwrap();
+                            if modifier_text.contains("private") {
+                                continue;
+                            }
+                        }
+                    }
                     if language == "rust" && !visibility_modifier.contains("pub") {
                         continue;
                     }
@@ -799,6 +838,23 @@ fn extract_definitions(language: &str, source: &str) -> Result<Vec<Definition>,
                         continue;
                     }
 
+                    if language == "swift" || language == "java" {
+                        if visibility_modifier.contains("private") {
+                            continue;
+                        }
+                    }
+
+                    if language == "java" {
+                        let modifier_node = find_descendant_by_type(&node, "modifiers");
+                        if modifier_node.is_some() {
+                            let modifier_text =
+                                modifier_node.unwrap().utf8_text(source.as_bytes()).unwrap();
+                            if modifier_text.contains("private") {
+                                continue;
+                            }
+                        }
+                    }
+
                     let value_type = get_node_type(&node, source.as_bytes());
 
                     if language == "zig" {
@@ -864,6 +920,27 @@ fn extract_definitions(language: &str, source: &str) -> Result<Vec<Definition>,
                         .map(|n| n.utf8_text(source.as_bytes()).unwrap())
                         .unwrap_or("");
 
+                    if language == "swift" || language == "java" {
+                        if visibility_modifier.contains("private") {
+                            continue;
+                        }
+
+                        if node.parent().is_some() {
+                            continue;
+                        }
+                    }
+
+                    if language == "java" {
+                        let modifier_node = find_descendant_by_type(&node, "modifiers");
+                        if modifier_node.is_some() {
+                            let modifier_text =
+                                modifier_node.unwrap().utf8_text(source.as_bytes()).unwrap();
+                            if modifier_text.contains("private") {
+                                continue;
+                            }
+                        }
+                    }
+
                     if language == "rust" && !visibility_modifier.contains("pub") {
                         continue;
                     }
@@ -945,6 +1022,21 @@ fn extract_definitions(language: &str, source: &str) -> Result<Vec<Definition>,
                     let visibility_modifier = visibility_modifier_node
                         .map(|n| n.utf8_text(source.as_bytes()).unwrap())
                         .unwrap_or("");
+                    if language == "swift" || language == "java" {
+                        if visibility_modifier.contains("private") {
+                            continue;
+                        }
+                    }
+                    if language == "java" {
+                        let modifier_node = find_descendant_by_type(&node, "modifiers");
+                        if modifier_node.is_some() {
+                            let modifier_text =
+                                modifier_node.unwrap().utf8_text(source.as_bytes()).unwrap();
+                            if modifier_text.contains("private") {
+                                continue;
+                            }
+                        }
+                    }
                     if language == "rust" && !visibility_modifier.contains("pub") {
                         continue;
                     }
@@ -981,6 +1073,23 @@ fn extract_definitions(language: &str, source: &str) -> Result<Vec<Definition>,
                         .map(|n| n.utf8_text(source.as_bytes()).unwrap())
                         .unwrap_or("");
 
+                    if language == "swift" {
+                        if visibility_modifier.contains("private") {
+                            continue;
+                        }
+                    }
+
+                    if language == "java" {
+                        let modifier_node = find_descendant_by_type(&node, "modifiers");
+                        if modifier_node.is_some() {
+                            let modifier_text =
+                                modifier_node.unwrap().utf8_text(source.as_bytes()).unwrap();
+                            if modifier_text.contains("private") {
+                                continue;
+                            }
+                        }
+                    }
+
                     if language == "rust" && !visibility_modifier.contains("pub") {
                         continue;
                     }
@@ -1804,6 +1913,105 @@ mod tests {
         assert_eq!(stringified, expected);
     }
 
+    #[test]
+    fn test_swift() {
+        let source = r#"
+            import Foundation
+
+            private var myVariable = 0
+            public var myPublicVariable = 0
+
+            struct MyStruct {
+              public var myPublicVariable = 0
+              private var myPrivateVariable = 0
+
+              func myPublicMethod(with parameter: Int) -> {
+              }
+
+              private func myPrivateMethod(with parameter: Int) -> {
+              }
+            }
+
+            class MyClass {
+                public var myPublicVariable = 0
+                private var myPrivateVariable = 0
+
+                init(myParameter: Int, myOtherParameter: Int) {
+                }
+
+                func myPublicMethod(with parameter: Int) -> {
+                }
+
+                private func myPrivateMethod(with parameter: Int) -> {
+                }
+
+                func myMethod() {
+                    print("Hello, world!")
+                }
+            }
+        "#;
+
+        let definitions = extract_definitions("swift", source).unwrap();
+        let stringified = stringify_definitions(&definitions);
+        println!("{stringified}");
+        let expected = "var myPublicVariable;class MyClass{func init() -> void;func myPublicMethod() -> void;func myMethod() -> void;var myPublicVariable;};class MyStruct{func myPublicMethod() -> void;var myPublicVariable;};";
+        assert_eq!(stringified, expected);
+    }
+
+    #[test]
+    fn test_php() {
+        let source = r#"
+        <?php
+        class MyClass {
+            public $myPublicVariable = 0;
+            private $myPrivateVariable = 0;
+
+            public function myPublicMethod($parameter) {
+            }
+
+            private function myPrivateMethod($parameter) {
+            }
+
+            function myMethod() {
+                echo "Hello, world!";
+            }
+        }
+        ?>
+        "#;
+
+        let definitions = extract_definitions("php", source).unwrap();
+        let stringified = stringify_definitions(&definitions);
+        println!("{stringified}");
+        let expected = "class MyClass{func myPublicMethod($parameter) -> void;func myPrivateMethod($parameter) -> void;func myMethod() -> void;var public $myPublicVariable = 0;;var private $myPrivateVariable = 0;;};";
+        assert_eq!(stringified, expected);
+    }
+
+    #[test]
+    fn test_java() {
+        let source = r#"
+        public class MyClass {
+            public void myPublicMethod(String parameter) {
+                System.out.println("Hello, world!");
+            }
+
+            private void myPrivateMethod(String parameter) {
+                System.out.println("Hello, world!");
+            }
+
+            void myMethod() {
+                System.out.println("Hello, world!");
+            }
+        }
+        "#;
+
+        let definitions = extract_definitions("java", source).unwrap();
+        let stringified = stringify_definitions(&definitions);
+        println!("{stringified}");
+        let expected =
+            "class MyClass{func myPublicMethod(String parameter) -> void;func myMethod() -> void;};";
+        assert_eq!(stringified, expected);
+    }
+
     #[test]
     fn test_unsupported_language() {
         let source = "print('Hello, world!')";