oak_rust/parser/
parse.rs

1use super::*;
2use crate::kind::RustSyntaxKind::*;
3use oak_core::{GreenBuilder, SourceLocation};
4
5type State<'a, S> = ParserState<'a, S, RustLanguage>;
6
7impl<'config> Parser<RustLanguage> for RustParser<'config> {
8    fn parse_incremental(
9        &self,
10        text: impl Source,
11        changed: usize,
12        cache: IncrementalCache<RustLanguage>,
13    ) -> OakDiagnostics<Arc<GreenNode<RustSyntaxKind>>> {
14        let mut state = ParserState::new_with_cache(text, changed, cache);
15        let result = self.run(&mut state);
16        state.finish(result)
17    }
18}
19
20impl<'config> RustParser<'config> {
21    fn run<S: Source>(&self, state: &mut State<S>) -> Result<(), OakError> {
22        let root = self.parse_source_file(state)?;
23        state.cache.last_parse = Some(root);
24        Ok(())
25    }
26
27    fn parse_source_file<S: Source>(&self, state: &mut State<S>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
28        // 跳过开头的空白和注释
29        self.skip_trivia(state);
30
31        while state.not_at_end() {
32            // 每轮都跳过空白/注释
33            self.skip_trivia(state);
34
35            match state.peek_kind() {
36                Some(Fn) => {
37                    let function = self.parse_function(state)?;
38                    // 直接在缓存构建器上添加函数节点
39                    let old_builder = std::mem::replace(state.cache.pool, oak_core::GreenBuilder::<RustLanguage>::new(128));
40                    let new_builder = old_builder.push(GreenTree::Node(function));
41                    *state.cache.pool = new_builder;
42                }
43                Some(Use) => {
44                    let use_item = Self::parse_use_item(state)?;
45                    let old_builder = std::mem::replace(state.cache.pool, oak_core::GreenBuilder::<RustLanguage>::new(128));
46                    let new_builder = old_builder.push(GreenTree::Node(use_item));
47                    *state.cache.pool = new_builder;
48                }
49                Some(Const) => {
50                    let const_item = Self::parse_const_item(state)?;
51                    let old_builder = std::mem::replace(state.cache.pool, oak_core::GreenBuilder::<RustLanguage>::new(128));
52                    let new_builder = old_builder.push(GreenTree::Node(const_item));
53                    *state.cache.pool = new_builder;
54                }
55                Some(Mod) => {
56                    let mod_item = Self::parse_mod_item(state)?;
57                    let old_builder = std::mem::replace(state.cache.pool, oak_core::GreenBuilder::<RustLanguage>::new(128));
58                    let new_builder = old_builder.push(GreenTree::Node(mod_item));
59                    *state.cache.pool = new_builder;
60                }
61                Some(Pub) => {
62                    let pub_item = Self::parse_pub_item(state)?;
63                    let old_builder = std::mem::replace(state.cache.pool, oak_core::GreenBuilder::<RustLanguage>::new(128));
64                    let new_builder = old_builder.push(GreenTree::Node(pub_item));
65                    *state.cache.pool = new_builder;
66                }
67                Some(_) => {
68                    // 其它未知 token：消费并作为叶子保留
69                    let (k, len) = match state.advance() {
70                        Some(t) => (t.kind, t.length()),
71                        None => break,
72                    };
73                    let old_builder = std::mem::replace(state.cache.pool, oak_core::GreenBuilder::<RustLanguage>::new(128));
74                    let new_builder = old_builder.token(k, len);
75                    *state.cache.pool = new_builder;
76                }
77                None => break,
78            }
79        }
80
81        let builder = std::mem::replace(state.cache.pool, oak_core::GreenBuilder::<RustLanguage>::new(128));
82        let result = builder.finish(RustSyntaxKind::SourceFile);
83        Ok(result)
84    }
85
86    fn parse_function<S: Source>(&self, state: &mut State<S>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
87        let mut builder = GreenBuilder::<RustLanguage>::new(32);
88
89        // 'fn'
90        if let Some(t) = state.current() {
91            if t.kind == Fn {
92                let (k, len) = (t.kind, t.length());
93                state.advance();
94                builder = builder.token(k, len);
95            }
96        }
97
98        // 标识符（函数名）
99        if let Some(t) = state.current() {
100            if t.kind == Identifier {
101                let (k, len) = (t.kind, t.length());
102                state.advance();
103                builder = builder.token(k, len);
104            }
105        }
106
107        // 参数列表
108        if let Some(t) = state.current() {
109            if t.kind == LeftParen {
110                let params = self.parse_param_list(state)?;
111                builder = builder.push(GreenTree::Node(params));
112            }
113        }
114
115        // 函数体
116        if let Some(t) = state.current() {
117            if t.kind == LeftBrace {
118                let body = Self::parse_block(state)?;
119                builder = builder.push(GreenTree::Node(body));
120            }
121        }
122
123        Ok(builder.finish(RustSyntaxKind::Function))
124    }
125
126    fn parse_function_with_builder<S: Source>(&self, state: &mut State<S>, builder: &mut GreenBuilder<RustLanguage>) -> Result<GreenBuilder<RustLanguage>, OakError> {
127        let mut function_builder = GreenBuilder::<RustLanguage>::new(32);
128
129        // 'fn'
130        if let Some(t) = state.current() {
131            if t.kind == Fn {
132                let (k, len) = (t.kind, t.length());
133                state.advance();
134                function_builder = function_builder.token(k, len);
135            }
136        }
137
138        // 标识符（函数名）
139        if let Some(t) = state.current() {
140            if t.kind == Identifier {
141                let (k, len) = (t.kind, t.length());
142                state.advance();
143                function_builder = function_builder.token(k, len);
144            }
145        }
146
147        // 参数列表
148        if let Some(t) = state.current() {
149            if t.kind == LeftParen {
150                let params = self.parse_param_list_with_builder(state)?;
151                function_builder = function_builder.push(GreenTree::Node(params));
152            }
153        }
154
155        // 函数体
156        if let Some(t) = state.current() {
157            if t.kind == LeftBrace {
158                let body = Self::parse_block(state)?;
159                function_builder = function_builder.push(GreenTree::Node(body));
160            }
161        }
162
163        let function_node = function_builder.finish(RustSyntaxKind::Function);
164        Ok(std::mem::replace(builder, GreenBuilder::<RustLanguage>::new(128)).push(GreenTree::Node(function_node)))
165    }
166
167    fn parse_param_list_with_builder<S: Source>(&self, state: &mut State<S>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
168        let mut builder = GreenBuilder::<RustLanguage>::new(16);
169
170        // '('
171        if let Some(t) = state.current() {
172            if t.kind == RustSyntaxKind::LeftParen {
173                let (k, len) = (t.kind, t.length());
174                state.advance();
175                builder = builder.token(k, len);
176            }
177        }
178
179        // 参数们
180        while state.current().map(|t| t.kind) != Some(RustSyntaxKind::RightParen) && state.current().is_some() {
181            let param = Self::parse_param(state)?;
182            builder = builder.push(GreenTree::Node(param));
183
184            if let Some(t) = state.current() {
185                if t.kind == RustSyntaxKind::Comma {
186                    let (k, len) = (t.kind, t.length());
187                    state.advance();
188                    builder = builder.token(k, len);
189                }
190            }
191        }
192
193        // ')'
194        if let Some(t) = state.current() {
195            if t.kind == RustSyntaxKind::RightParen {
196                let (k, len) = (t.kind, t.length());
197                state.advance();
198                builder = builder.token(k, len);
199            }
200        }
201
202        Ok(builder.finish(RustSyntaxKind::ParameterList))
203    }
204
205    fn parse_param_list<S: Source>(&self, state: &mut State<S>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
206        let mut builder = GreenBuilder::<RustLanguage>::new(16);
207
208        // '('
209        if let Some(t) = state.current() {
210            if t.kind == RustSyntaxKind::LeftParen {
211                let (k, len) = (t.kind, t.length());
212                state.advance();
213                builder = builder.token(k, len);
214            }
215        }
216
217        // 参数们
218        while state.current().map(|t| t.kind) != Some(RustSyntaxKind::RightParen) && state.current().is_some() {
219            let param = Self::parse_param(state)?;
220            builder = builder.push(GreenTree::Node(param));
221
222            if let Some(t) = state.current() {
223                if t.kind == RustSyntaxKind::Comma {
224                    let (k, len) = (t.kind, t.length());
225                    state.advance();
226                    builder = builder.token(k, len);
227                }
228            }
229        }
230
231        // ')'
232        if let Some(t) = state.current() {
233            if t.kind == RustSyntaxKind::RightParen {
234                let (k, len) = (t.kind, t.length());
235                state.advance();
236                builder = builder.token(k, len);
237            }
238        }
239
240        Ok(builder.finish(RustSyntaxKind::ParameterList))
241    }
242
243    pub fn parse_param(state: &mut ParserState<impl Source, RustLanguage>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
244        let mut builder = GreenBuilder::<RustLanguage>::new(8);
245
246        // name
247        if let Some(t) = state.current() {
248            if t.kind == RustSyntaxKind::Identifier {
249                let (k, len) = (t.kind, t.length());
250                state.advance();
251                builder = builder.token(k, len);
252            }
253        }
254
255        // ':'
256        if let Some(t) = state.current() {
257            if t.kind == RustSyntaxKind::Colon {
258                let (k, len) = (t.kind, t.length());
259                state.advance();
260                builder = builder.token(k, len);
261            }
262        }
263
264        // type
265        if let Some(t) = state.current() {
266            if t.kind == RustSyntaxKind::Identifier {
267                let (k, len) = (t.kind, t.length());
268                state.advance();
269                builder = builder.token(k, len);
270            }
271        }
272
273        Ok(builder.finish(RustSyntaxKind::Parameter))
274    }
275
276    pub fn parse_block(state: &mut ParserState<impl Source, RustLanguage>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
277        let mut builder = GreenBuilder::<RustLanguage>::new(32);
278
279        // '{'
280        if let Some(t) = state.current() {
281            if t.kind == RustSyntaxKind::LeftBrace {
282                let (k, len) = (t.kind, t.length());
283                state.advance();
284                builder = builder.token(k, len);
285            }
286        }
287
288        // stmts
289        while state.current().map(|t| t.kind) != Some(RustSyntaxKind::RightBrace) && state.current().is_some() {
290            let stmt = Self::parse_stmt(state)?;
291            builder = builder.push(GreenTree::Node(stmt));
292        }
293
294        // '}'
295        if let Some(t) = state.current() {
296            if t.kind == RustSyntaxKind::RightBrace {
297                let (k, len) = (t.kind, t.length());
298                state.advance();
299                builder = builder.token(k, len);
300            }
301        }
302
303        Ok(builder.finish(RustSyntaxKind::BlockExpression))
304    }
305
306    pub fn parse_stmt(state: &mut ParserState<impl Source, RustLanguage>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
307        match state.current().map(|t| t.kind) {
308            Some(RustSyntaxKind::Let) => Self::parse_let_stmt(state),
309            _ => Self::parse_expr_stmt(state),
310        }
311    }
312
313    pub fn parse_let_stmt(state: &mut ParserState<impl Source, RustLanguage>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
314        let mut builder = GreenBuilder::<RustLanguage>::new(16);
315
316        // 'let'
317        if let Some(t) = state.current() {
318            if t.kind == RustSyntaxKind::Let {
319                let (k, len) = (t.kind, t.length());
320                state.advance();
321                builder = builder.token(k, len);
322            }
323        }
324
325        // name
326        if let Some(t) = state.current() {
327            if t.kind == RustSyntaxKind::Identifier {
328                let (k, len) = (t.kind, t.length());
329                state.advance();
330                builder = builder.token(k, len);
331            }
332        }
333
334        // '='
335        if let Some(t) = state.current() {
336            if t.kind == RustSyntaxKind::Eq {
337                let (k, len) = (t.kind, t.length());
338                state.advance();
339                builder = builder.token(k, len);
340            }
341        }
342
343        // expr
344        let expr = Self::parse_expr(state)?;
345        builder = builder.push(GreenTree::Node(expr));
346
347        // ';'
348        if let Some(t) = state.current() {
349            if t.kind == RustSyntaxKind::Semicolon {
350                let (k, len) = (t.kind, t.length());
351                state.advance();
352                builder = builder.token(k, len);
353            }
354        }
355
356        Ok(builder.finish(RustSyntaxKind::LetStatement))
357    }
358
359    pub fn parse_expr_stmt(state: &mut ParserState<impl Source, RustLanguage>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
360        let mut builder = GreenBuilder::<RustLanguage>::new(8);
361
362        let expr = Self::parse_expr(state)?;
363        builder = builder.push(GreenTree::Node(expr));
364
365        // ';'
366        if let Some(t) = state.current() {
367            if t.kind == RustSyntaxKind::Semicolon {
368                let (k, len) = (t.kind, t.length());
369                state.advance();
370                builder = builder.token(k, len);
371            }
372        }
373
374        Ok(builder.finish(RustSyntaxKind::ExpressionStatement))
375    }
376
377    pub fn parse_expr(state: &mut ParserState<impl Source, RustLanguage>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
378        let mut builder = GreenBuilder::<RustLanguage>::new(4);
379
380        match state.current().map(|t| t.kind) {
381            Some(RustSyntaxKind::Identifier) => {
382                let (k, len) = match state.advance() { Some(t) => (t.kind, t.length()), None => (RustSyntaxKind::Identifier, 0) };
383                builder = builder.token(k, len);
384            }
385            Some(RustSyntaxKind::IntegerLiteral) => {
386                let (k, len) = match state.advance() { Some(t) => (t.kind, t.length()), None => (RustSyntaxKind::IntegerLiteral, 0) };
387                builder = builder.token(k, len);
388            }
389            _ => {
390                let pos = state.current().map(|t| t.span.start).unwrap_or(state.source.length());
391                return Err(state.source.syntax_error("Expected expression".to_string(), pos));
392            }
393        }
394
395        Ok(builder.finish(RustSyntaxKind::IdentifierExpression))
396    }
397
398    pub fn parse_use_item(state: &mut ParserState<impl Source, RustLanguage>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
399        let mut builder = GreenBuilder::<RustLanguage>::new(8);
400
401        // 'use'
402        if let Some(t) = state.current() {
403            if t.kind == RustSyntaxKind::Use {
404                let (k, len) = (t.kind, t.length());
405                state.advance();
406                builder = builder.token(k, len);
407            }
408        }
409
410        // path
411        if let Some(t) = state.current() {
412            if t.kind == RustSyntaxKind::Identifier {
413                let (k, len) = (t.kind, t.length());
414                state.advance();
415                builder = builder.token(k, len);
416            }
417        }
418
419        // ';'
420        if let Some(t) = state.current() {
421            if t.kind == RustSyntaxKind::Semicolon {
422                let (k, len) = (t.kind, t.length());
423                state.advance();
424                builder = builder.token(k, len);
425            }
426        }
427
428        Ok(builder.finish(RustSyntaxKind::UseDeclaration))
429    }
430
431    pub fn parse_const_item(state: &mut ParserState<impl Source, RustLanguage>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
432        let mut builder = GreenBuilder::<RustLanguage>::new(12);
433
434        // 'const'
435        if let Some(t) = state.current() {
436            if t.kind == RustSyntaxKind::Const {
437                let (k, len) = (t.kind, t.length());
438                state.advance();
439                builder = builder.token(k, len);
440            }
441        }
442
443        // name
444        if let Some(t) = state.current() {
445            if t.kind == RustSyntaxKind::Identifier {
446                let (k, len) = (t.kind, t.length());
447                state.advance();
448                builder = builder.token(k, len);
449            }
450        }
451
452        // ':'
453        if let Some(t) = state.current() {
454            if t.kind == RustSyntaxKind::Colon {
455                let (k, len) = (t.kind, t.length());
456                state.advance();
457                builder = builder.token(k, len);
458            }
459        }
460
461        // type
462        if let Some(t) = state.current() {
463            if t.kind == RustSyntaxKind::Identifier {
464                let (k, len) = (t.kind, t.length());
465                state.advance();
466                builder = builder.token(k, len);
467            }
468        }
469
470        // '='
471        if let Some(t) = state.current() {
472            if t.kind == RustSyntaxKind::Eq {
473                let (k, len) = (t.kind, t.length());
474                state.advance();
475                builder = builder.token(k, len);
476            }
477        }
478
479        // expr
480        let expr = Self::parse_expr(state)?;
481        builder = builder.push(GreenTree::Node(expr));
482
483        // ';'
484        if let Some(t) = state.current() {
485            if t.kind == RustSyntaxKind::Semicolon {
486                let (k, len) = (t.kind, t.length());
487                state.advance();
488                builder = builder.token(k, len);
489            }
490        }
491
492        Ok(builder.finish(RustSyntaxKind::ConstDeclaration))
493    }
494
495    pub fn parse_mod_item(state: &mut ParserState<impl Source, RustLanguage>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
496        let mut builder = GreenBuilder::<RustLanguage>::new(8);
497
498        // 'mod'
499        if let Some(t) = state.current() {
500            if t.kind == RustSyntaxKind::Mod {
501                let (k, len) = (t.kind, t.length());
502                state.advance();
503                builder = builder.token(k, len);
504            }
505        }
506
507        // name
508        if let Some(t) = state.current() {
509            if t.kind == RustSyntaxKind::Identifier {
510                let (k, len) = (t.kind, t.length());
511                state.advance();
512                builder = builder.token(k, len);
513            }
514        }
515
516        // ';'
517        if let Some(t) = state.current() {
518            if t.kind == RustSyntaxKind::Semicolon {
519                let (k, len) = (t.kind, t.length());
520                state.advance();
521                builder = builder.token(k, len);
522            }
523        }
524
525        Ok(builder.finish(RustSyntaxKind::ModuleDeclaration))
526    }
527
528    pub fn parse_pub_item(state: &mut ParserState<impl Source, RustLanguage>) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError> {
529        let mut builder = GreenBuilder::<RustLanguage>::new(4);
530
531        // 'pub'
532        if let Some(t) = state.current() {
533            if t.kind == RustSyntaxKind::Pub {
534                let (k, len) = (t.kind, t.length());
535                state.advance();
536                builder = builder.token(k, len);
537            }
538        }
539
540        Ok(builder.finish(RustSyntaxKind::Visibility))
541    }
542
543    fn skip_trivia<S: Source>(&self, state: &mut State<S>) {
544        while let Some(kind) = state.current() {
545            match kind.kind {
546                RustSyntaxKind::Whitespace | RustSyntaxKind::Comment => {
547                    state.advance();
548                }
549                _ => break,
550            }
551        }
552    }
553}
oak_rust/parser/parse.rs

oak_rust/parser/
parse.rs
