Skip to main content

code_analyze_mcp/languages/
mod.rs

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