Skip to main content

code_analyze_mcp/languages/
mod.rs

1pub mod go;
2pub mod java;
3pub mod python;
4pub mod rust;
5pub mod typescript;
6
7use tree_sitter::{Language, Node};
8
9/// Handler to extract function name from a node.
10pub type ExtractFunctionNameHandler = fn(&Node, &str, &str) -> Option<String>;
11
12/// Handler to find method name for a receiver type.
13pub type FindMethodForReceiverHandler = fn(&Node, &str, Option<usize>) -> Option<String>;
14
15/// Handler to find receiver type for a method.
16pub type FindReceiverTypeHandler = fn(&Node, &str) -> Option<String>;
17
18/// Handler to extract inheritance information from a class node.
19pub type ExtractInheritanceHandler = fn(&Node, &str) -> Vec<String>;
20
21/// Information about a supported language for code analysis.
22pub struct LanguageInfo {
23    pub name: &'static str,
24    pub language: Language,
25    pub element_query: &'static str,
26    pub call_query: &'static str,
27    pub reference_query: Option<&'static str>,
28    pub import_query: Option<&'static str>,
29    pub impl_query: Option<&'static str>,
30    pub assignment_query: Option<&'static str>,
31    pub field_query: Option<&'static str>,
32    pub extract_function_name: Option<ExtractFunctionNameHandler>,
33    pub find_method_for_receiver: Option<FindMethodForReceiverHandler>,
34    pub find_receiver_type: Option<FindReceiverTypeHandler>,
35    pub extract_inheritance: Option<ExtractInheritanceHandler>,
36}
37
38/// Get language information by language name.
39pub fn get_language_info(lang_name: &str) -> Option<LanguageInfo> {
40    match lang_name {
41        "rust" => Some(LanguageInfo {
42            name: "rust",
43            language: tree_sitter_rust::LANGUAGE.into(),
44            element_query: rust::ELEMENT_QUERY,
45            call_query: rust::CALL_QUERY,
46            reference_query: Some(rust::REFERENCE_QUERY),
47            import_query: Some(rust::IMPORT_QUERY),
48            impl_query: Some(rust::IMPL_QUERY),
49            assignment_query: Some(rust::ASSIGNMENT_QUERY),
50            field_query: Some(rust::FIELD_QUERY),
51            extract_function_name: Some(rust::extract_function_name),
52            find_method_for_receiver: Some(rust::find_method_for_receiver),
53            find_receiver_type: Some(rust::find_receiver_type),
54            extract_inheritance: Some(rust::extract_inheritance),
55        }),
56        "python" => Some(LanguageInfo {
57            name: "python",
58            language: tree_sitter_python::LANGUAGE.into(),
59            element_query: python::ELEMENT_QUERY,
60            call_query: python::CALL_QUERY,
61            reference_query: Some(python::REFERENCE_QUERY),
62            import_query: Some(python::IMPORT_QUERY),
63            impl_query: None,
64            assignment_query: None,
65            field_query: None,
66            extract_function_name: None,
67            find_method_for_receiver: None,
68            find_receiver_type: None,
69            extract_inheritance: Some(python::extract_inheritance),
70        }),
71        "typescript" => Some(LanguageInfo {
72            name: "typescript",
73            language: tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into(),
74            element_query: typescript::ELEMENT_QUERY,
75            call_query: typescript::CALL_QUERY,
76            reference_query: Some(typescript::REFERENCE_QUERY),
77            import_query: Some(typescript::IMPORT_QUERY),
78            impl_query: None,
79            assignment_query: None,
80            field_query: None,
81            extract_function_name: None,
82            find_method_for_receiver: None,
83            find_receiver_type: None,
84            extract_inheritance: Some(typescript::extract_inheritance),
85        }),
86        "tsx" => Some(LanguageInfo {
87            name: "tsx",
88            language: tree_sitter_typescript::LANGUAGE_TSX.into(),
89            element_query: typescript::ELEMENT_QUERY,
90            call_query: typescript::CALL_QUERY,
91            reference_query: Some(typescript::REFERENCE_QUERY),
92            import_query: Some(typescript::IMPORT_QUERY),
93            impl_query: None,
94            assignment_query: None,
95            field_query: None,
96            extract_function_name: None,
97            find_method_for_receiver: None,
98            find_receiver_type: None,
99            extract_inheritance: Some(typescript::extract_inheritance),
100        }),
101        "go" => Some(LanguageInfo {
102            name: "go",
103            language: tree_sitter_go::LANGUAGE.into(),
104            element_query: go::ELEMENT_QUERY,
105            call_query: go::CALL_QUERY,
106            reference_query: Some(go::REFERENCE_QUERY),
107            import_query: Some(go::IMPORT_QUERY),
108            impl_query: None,
109            assignment_query: None,
110            field_query: None,
111            extract_function_name: None,
112            find_method_for_receiver: Some(go::find_method_for_receiver),
113            find_receiver_type: None,
114            extract_inheritance: Some(go::extract_inheritance),
115        }),
116        "java" => Some(LanguageInfo {
117            name: "java",
118            language: tree_sitter_java::LANGUAGE.into(),
119            element_query: java::ELEMENT_QUERY,
120            call_query: java::CALL_QUERY,
121            reference_query: Some(java::REFERENCE_QUERY),
122            import_query: Some(java::IMPORT_QUERY),
123            impl_query: None,
124            assignment_query: None,
125            field_query: None,
126            extract_function_name: None,
127            find_method_for_receiver: None,
128            find_receiver_type: None,
129            extract_inheritance: Some(java::extract_inheritance),
130        }),
131        _ => None,
132    }
133}