infiniloom_engine/parser/
init.rs

1//! Language-specific parser initializers
2//!
3//! This module contains functions to initialize tree-sitter parsers for each
4//! supported programming language.
5
6use super::core::ParserError;
7use tree_sitter::Parser as TSParser;
8
9/// Initialize Python parser
10pub fn python() -> Result<TSParser, ParserError> {
11    let mut parser = TSParser::new();
12    parser
13        .set_language(&tree_sitter_python::LANGUAGE.into())
14        .map_err(|e| ParserError::ParseError(e.to_string()))?;
15    Ok(parser)
16}
17
18/// Initialize JavaScript parser
19pub fn javascript() -> Result<TSParser, ParserError> {
20    let mut parser = TSParser::new();
21    parser
22        .set_language(&tree_sitter_javascript::LANGUAGE.into())
23        .map_err(|e| ParserError::ParseError(e.to_string()))?;
24    Ok(parser)
25}
26
27/// Initialize TypeScript parser
28pub fn typescript() -> Result<TSParser, ParserError> {
29    let mut parser = TSParser::new();
30    parser
31        .set_language(&tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into())
32        .map_err(|e| ParserError::ParseError(e.to_string()))?;
33    Ok(parser)
34}
35
36/// Initialize Rust parser
37pub fn rust() -> Result<TSParser, ParserError> {
38    let mut parser = TSParser::new();
39    parser
40        .set_language(&tree_sitter_rust::LANGUAGE.into())
41        .map_err(|e| ParserError::ParseError(e.to_string()))?;
42    Ok(parser)
43}
44
45/// Initialize Go parser
46pub fn go() -> Result<TSParser, ParserError> {
47    let mut parser = TSParser::new();
48    parser
49        .set_language(&tree_sitter_go::LANGUAGE.into())
50        .map_err(|e| ParserError::ParseError(e.to_string()))?;
51    Ok(parser)
52}
53
54/// Initialize Java parser
55pub fn java() -> Result<TSParser, ParserError> {
56    let mut parser = TSParser::new();
57    parser
58        .set_language(&tree_sitter_java::LANGUAGE.into())
59        .map_err(|e| ParserError::ParseError(e.to_string()))?;
60    Ok(parser)
61}
62
63/// Initialize C parser
64pub fn c() -> Result<TSParser, ParserError> {
65    let mut parser = TSParser::new();
66    parser
67        .set_language(&tree_sitter_c::LANGUAGE.into())
68        .map_err(|e| ParserError::ParseError(e.to_string()))?;
69    Ok(parser)
70}
71
72/// Initialize C++ parser
73pub fn cpp() -> Result<TSParser, ParserError> {
74    let mut parser = TSParser::new();
75    parser
76        .set_language(&tree_sitter_cpp::LANGUAGE.into())
77        .map_err(|e| ParserError::ParseError(e.to_string()))?;
78    Ok(parser)
79}
80
81/// Initialize C# parser
82pub fn csharp() -> Result<TSParser, ParserError> {
83    let mut parser = TSParser::new();
84    parser
85        .set_language(&tree_sitter_c_sharp::LANGUAGE.into())
86        .map_err(|e| ParserError::ParseError(e.to_string()))?;
87    Ok(parser)
88}
89
90/// Initialize Ruby parser
91pub fn ruby() -> Result<TSParser, ParserError> {
92    let mut parser = TSParser::new();
93    parser
94        .set_language(&tree_sitter_ruby::LANGUAGE.into())
95        .map_err(|e| ParserError::ParseError(e.to_string()))?;
96    Ok(parser)
97}
98
99/// Initialize Bash parser
100pub fn bash() -> Result<TSParser, ParserError> {
101    let mut parser = TSParser::new();
102    parser
103        .set_language(&tree_sitter_bash::LANGUAGE.into())
104        .map_err(|e| ParserError::ParseError(e.to_string()))?;
105    Ok(parser)
106}
107
108/// Initialize PHP parser
109pub fn php() -> Result<TSParser, ParserError> {
110    let mut parser = TSParser::new();
111    parser
112        .set_language(&tree_sitter_php::LANGUAGE_PHP.into())
113        .map_err(|e| ParserError::ParseError(e.to_string()))?;
114    Ok(parser)
115}
116
117/// Initialize Kotlin parser
118pub fn kotlin() -> Result<TSParser, ParserError> {
119    let mut parser = TSParser::new();
120    parser
121        .set_language(&tree_sitter_kotlin_ng::LANGUAGE.into())
122        .map_err(|e| ParserError::ParseError(e.to_string()))?;
123    Ok(parser)
124}
125
126/// Initialize Swift parser
127pub fn swift() -> Result<TSParser, ParserError> {
128    let mut parser = TSParser::new();
129    parser
130        .set_language(&tree_sitter_swift::LANGUAGE.into())
131        .map_err(|e| ParserError::ParseError(e.to_string()))?;
132    Ok(parser)
133}
134
135/// Initialize Scala parser
136pub fn scala() -> Result<TSParser, ParserError> {
137    let mut parser = TSParser::new();
138    parser
139        .set_language(&tree_sitter_scala::LANGUAGE.into())
140        .map_err(|e| ParserError::ParseError(e.to_string()))?;
141    Ok(parser)
142}
143
144/// Initialize Haskell parser
145pub fn haskell() -> Result<TSParser, ParserError> {
146    let mut parser = TSParser::new();
147    parser
148        .set_language(&tree_sitter_haskell::LANGUAGE.into())
149        .map_err(|e| ParserError::ParseError(e.to_string()))?;
150    Ok(parser)
151}
152
153/// Initialize Elixir parser
154pub fn elixir() -> Result<TSParser, ParserError> {
155    let mut parser = TSParser::new();
156    parser
157        .set_language(&tree_sitter_elixir::LANGUAGE.into())
158        .map_err(|e| ParserError::ParseError(e.to_string()))?;
159    Ok(parser)
160}
161
162/// Initialize Clojure parser
163///
164/// NOTE: Clojure support is unavailable because tree-sitter-clojure 0.1.0
165/// depends on tree-sitter ^0.25 (normal dep), which conflicts with tree-sitter 0.26.
166/// No compatible version exists on crates.io as of 2026-03-08.
167pub fn clojure() -> Result<TSParser, ParserError> {
168    Err(ParserError::UnsupportedLanguage(
169        "Clojure (tree-sitter-clojure incompatible with tree-sitter 0.26)".to_owned(),
170    ))
171}
172
173/// Initialize OCaml parser
174pub fn ocaml() -> Result<TSParser, ParserError> {
175    let mut parser = TSParser::new();
176    parser
177        .set_language(&tree_sitter_ocaml::LANGUAGE_OCAML.into())
178        .map_err(|e| ParserError::ParseError(e.to_string()))?;
179    Ok(parser)
180}
181
182/// Initialize Lua parser
183pub fn lua() -> Result<TSParser, ParserError> {
184    let mut parser = TSParser::new();
185    parser
186        .set_language(&tree_sitter_lua::LANGUAGE.into())
187        .map_err(|e| ParserError::ParseError(e.to_string()))?;
188    Ok(parser)
189}
190
191/// Initialize R parser
192pub fn r() -> Result<TSParser, ParserError> {
193    let mut parser = TSParser::new();
194    parser
195        .set_language(&tree_sitter_r::LANGUAGE.into())
196        .map_err(|e| ParserError::ParseError(e.to_string()))?;
197    Ok(parser)
198}
199
200/// Initialize HCL parser
201pub fn hcl() -> Result<TSParser, ParserError> {
202    let mut parser = TSParser::new();
203    parser
204        .set_language(&tree_sitter_hcl::LANGUAGE.into())
205        .map_err(|e| ParserError::ParseError(e.to_string()))?;
206    Ok(parser)
207}
208
209/// Initialize Zig parser
210pub fn zig() -> Result<TSParser, ParserError> {
211    let mut parser = TSParser::new();
212    parser
213        .set_language(&tree_sitter_zig::LANGUAGE.into())
214        .map_err(|e| ParserError::ParseError(e.to_string()))?;
215    Ok(parser)
216}
217
218/// Initialize Dart parser
219pub fn dart() -> Result<TSParser, ParserError> {
220    let mut parser = TSParser::new();
221    parser
222        .set_language(&tree_sitter_dart_orchard::LANGUAGE.into())
223        .map_err(|e| ParserError::ParseError(e.to_string()))?;
224    Ok(parser)
225}
226
227#[cfg(test)]
228mod tests {
229    use super::*;
230
231    #[test]
232    fn test_python_init() {
233        assert!(python().is_ok());
234    }
235
236    #[test]
237    fn test_javascript_init() {
238        assert!(javascript().is_ok());
239    }
240
241    #[test]
242    fn test_typescript_init() {
243        assert!(typescript().is_ok());
244    }
245
246    #[test]
247    fn test_rust_init() {
248        assert!(rust().is_ok());
249    }
250
251    #[test]
252    fn test_go_init() {
253        assert!(go().is_ok());
254    }
255
256    #[test]
257    fn test_java_init() {
258        assert!(java().is_ok());
259    }
260
261    #[test]
262    fn test_c_init() {
263        assert!(c().is_ok());
264    }
265
266    #[test]
267    fn test_cpp_init() {
268        assert!(cpp().is_ok());
269    }
270
271    #[test]
272    fn test_csharp_init() {
273        assert!(csharp().is_ok());
274    }
275
276    #[test]
277    fn test_ruby_init() {
278        assert!(ruby().is_ok());
279    }
280
281    #[test]
282    fn test_bash_init() {
283        assert!(bash().is_ok());
284    }
285
286    #[test]
287    fn test_php_init() {
288        assert!(php().is_ok());
289    }
290
291    #[test]
292    fn test_kotlin_init() {
293        assert!(kotlin().is_ok());
294    }
295
296    #[test]
297    fn test_swift_init() {
298        assert!(swift().is_ok());
299    }
300
301    #[test]
302    fn test_scala_init() {
303        assert!(scala().is_ok());
304    }
305
306    #[test]
307    fn test_haskell_init() {
308        assert!(haskell().is_ok());
309    }
310
311    #[test]
312    fn test_elixir_init() {
313        assert!(elixir().is_ok());
314    }
315
316    #[test]
317    fn test_clojure_init() {
318        // Clojure is expected to return an error since tree-sitter-clojure
319        // is incompatible with tree-sitter 0.26
320        assert!(clojure().is_err());
321    }
322
323    #[test]
324    fn test_ocaml_init() {
325        assert!(ocaml().is_ok());
326    }
327
328    #[test]
329    fn test_lua_init() {
330        assert!(lua().is_ok());
331    }
332
333    #[test]
334    fn test_r_init() {
335        assert!(r().is_ok());
336    }
337
338    #[test]
339    fn test_hcl_init() {
340        assert!(hcl().is_ok());
341    }
342
343    #[test]
344    fn test_zig_init() {
345        assert!(zig().is_ok());
346    }
347
348    #[test]
349    fn test_dart_init() {
350        assert!(dart().is_ok());
351    }
352}
infiniloom_engine/parser/init.rs

infiniloom_engine/parser/
init.rs
