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, TSX, 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 impl_trait_query: Option<&'static str>,
37    pub extract_function_name: Option<ExtractFunctionNameHandler>,
38    pub find_method_for_receiver: Option<FindMethodForReceiverHandler>,
39    pub find_receiver_type: Option<FindReceiverTypeHandler>,
40    pub extract_inheritance: Option<ExtractInheritanceHandler>,
41}
42
43/// Get language information by language name.
44pub fn get_language_info(lang_name: &str) -> Option<LanguageInfo> {
45    match lang_name {
46        "rust" => Some(LanguageInfo {
47            name: "rust",
48            language: tree_sitter_rust::LANGUAGE.into(),
49            element_query: rust::ELEMENT_QUERY,
50            call_query: rust::CALL_QUERY,
51            reference_query: Some(rust::REFERENCE_QUERY),
52            import_query: Some(rust::IMPORT_QUERY),
53            impl_query: Some(rust::IMPL_QUERY),
54            impl_trait_query: Some(rust::IMPL_TRAIT_QUERY),
55            extract_function_name: Some(rust::extract_function_name),
56            find_method_for_receiver: Some(rust::find_method_for_receiver),
57            find_receiver_type: Some(rust::find_receiver_type),
58            extract_inheritance: Some(rust::extract_inheritance),
59        }),
60        "python" => Some(LanguageInfo {
61            name: "python",
62            language: tree_sitter_python::LANGUAGE.into(),
63            element_query: python::ELEMENT_QUERY,
64            call_query: python::CALL_QUERY,
65            reference_query: Some(python::REFERENCE_QUERY),
66            import_query: Some(python::IMPORT_QUERY),
67            impl_query: None,
68            impl_trait_query: None,
69            extract_function_name: None,
70            find_method_for_receiver: None,
71            find_receiver_type: None,
72            extract_inheritance: Some(python::extract_inheritance),
73        }),
74        "typescript" => Some(LanguageInfo {
75            name: "typescript",
76            language: tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into(),
77            element_query: typescript::ELEMENT_QUERY,
78            call_query: typescript::CALL_QUERY,
79            reference_query: Some(typescript::REFERENCE_QUERY),
80            import_query: Some(typescript::IMPORT_QUERY),
81            impl_query: None,
82            impl_trait_query: None,
83            extract_function_name: None,
84            find_method_for_receiver: None,
85            find_receiver_type: None,
86            extract_inheritance: Some(typescript::extract_inheritance),
87        }),
88        "tsx" => Some(LanguageInfo {
89            name: "tsx",
90            language: tree_sitter_typescript::LANGUAGE_TSX.into(),
91            element_query: typescript::ELEMENT_QUERY,
92            call_query: typescript::CALL_QUERY,
93            reference_query: Some(typescript::REFERENCE_QUERY),
94            import_query: Some(typescript::IMPORT_QUERY),
95            impl_query: None,
96            impl_trait_query: None,
97            extract_function_name: None,
98            find_method_for_receiver: None,
99            find_receiver_type: None,
100            extract_inheritance: Some(typescript::extract_inheritance),
101        }),
102        "go" => Some(LanguageInfo {
103            name: "go",
104            language: tree_sitter_go::LANGUAGE.into(),
105            element_query: go::ELEMENT_QUERY,
106            call_query: go::CALL_QUERY,
107            reference_query: Some(go::REFERENCE_QUERY),
108            import_query: Some(go::IMPORT_QUERY),
109            impl_query: None,
110            impl_trait_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            impl_trait_query: None,
125            extract_function_name: None,
126            find_method_for_receiver: None,
127            find_receiver_type: None,
128            extract_inheritance: Some(java::extract_inheritance),
129        }),
130        "fortran" => Some(LanguageInfo {
131            name: "fortran",
132            language: tree_sitter_fortran::LANGUAGE.into(),
133            element_query: fortran::ELEMENT_QUERY,
134            call_query: fortran::CALL_QUERY,
135            reference_query: Some(fortran::REFERENCE_QUERY),
136            import_query: Some(fortran::IMPORT_QUERY),
137            impl_query: None,
138            impl_trait_query: None,
139            extract_function_name: None,
140            find_method_for_receiver: None,
141            find_receiver_type: None,
142            extract_inheritance: Some(fortran::extract_inheritance),
143        }),
144        _ => None,
145    }
146}