oak_java/parser/
mod.rs

1use oak_core::TokenType;
2pub mod element_type;
3
4use crate::{
5    language::JavaLanguage,
6    lexer::{JavaLexer, token_type::JavaTokenType},
7    parser::element_type::JavaElementType,
8};
9use oak_core::{
10    GreenNode, OakError, TextEdit,
11    parser::{
12        ParseCache, Parser, ParserState,
13        pratt::{Associativity, Pratt, PrattParser, binary},
14    },
15    source::Source,
16};
17
18pub(crate) type State<'a, S> = ParserState<'a, JavaLanguage, S>;
19
20pub struct JavaParser<'config> {
21    pub(crate) config: &'config JavaLanguage,
22}
23
24impl<'config> Pratt<JavaLanguage> for JavaParser<'config> {
25    fn primary<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> &'a GreenNode<'a, JavaLanguage> {
26        use crate::lexer::token_type::JavaTokenType::*;
27        self.skip_trivia(state);
28        let cp = state.checkpoint();
29        match state.peek_kind() {
30            Some(Identifier) => {
31                state.bump();
32                state.finish_at(cp, JavaElementType::Identifier)
33            }
34            Some(IntegerLiteral) | Some(FloatingPointLiteral) | Some(BooleanLiteral) | Some(CharacterLiteral) | Some(StringLiteral) | Some(NullLiteral) => {
35                state.bump();
36                state.finish_at(cp, JavaElementType::LiteralExpression)
37            }
38            Some(LeftParen) => {
39                state.bump();
40                PrattParser::parse(state, 0, self);
41                state.expect(RightParen).ok();
42                state.finish_at(cp, JavaElementType::ParenthesizedExpression)
43            }
44            Some(New) => {
45                state.bump(); // new
46                self.skip_trivia(state);
47                self.parse_type(state).ok();
48                self.skip_trivia(state);
49                if state.at(LeftBracket) {
50                    // Array creation
51                    while state.at(LeftBracket) {
52                        state.bump();
53                        self.skip_trivia(state);
54                        if !state.at(RightBracket) {
55                            PrattParser::parse(state, 0, self);
56                        }
57                        self.skip_trivia(state);
58                        state.expect(RightBracket).ok();
59                        self.skip_trivia(state)
60                    }
61                    state.finish_at(cp, JavaElementType::ArrayCreation)
62                }
63                else if state.at(LeftParen) {
64                    // Object creation
65                    state.bump();
66                    self.skip_trivia(state);
67                    while state.not_at_end() && !state.at(RightParen) {
68                        PrattParser::parse(state, 0, self);
69                        self.skip_trivia(state);
70                        if !state.eat(Comma) {
71                            break;
72                        }
73                        self.skip_trivia(state)
74                    }
75                    state.expect(RightParen).ok();
76                    state.finish_at(cp, JavaElementType::MethodCall) // Reuse MethodCall for constructor for now
77                }
78                else {
79                    state.finish_at(cp, JavaElementType::Error)
80                }
81            }
82            _ => {
83                state.bump();
84                state.finish_at(cp, JavaElementType::Error)
85            }
86        }
87    }
88
89    fn prefix<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> &'a GreenNode<'a, JavaLanguage> {
90        use crate::lexer::token_type::JavaTokenType::*;
91        self.skip_trivia(state);
92        let cp = state.checkpoint();
93        match state.peek_kind() {
94            Some(Bang) | Some(Tilde) | Some(Plus) | Some(Minus) | Some(PlusPlus) | Some(MinusMinus) => {
95                state.bump();
96                PrattParser::parse(state, 14, self); // Prefix operators have high precedence
97                state.finish_at(cp, JavaElementType::UnaryExpression)
98            }
99            Some(LeftParen) => {
100                // Try to parse as Cast: (Type) Expr
101                // For now, a simple heuristic: if it looks like (Identifier), it might be a cast
102                // But this is ambiguous with parenthesized expressions.
103                // Standard Java parser looks ahead.
104                // We'll try to parse a type inside.
105                let snapshot = state.checkpoint();
106                state.bump(); // (
107                self.skip_trivia(state);
108                if self.parse_type(state).is_ok() {
109                    self.skip_trivia(state);
110                    if state.eat(RightParen) {
111                        self.skip_trivia(state);
112                        // It's a cast if we have an expression following it
113                        PrattParser::parse(state, 13, self); // Precedence for cast
114                        state.finish_at(cp, JavaElementType::CastExpression)
115                    }
116                    else {
117                        state.restore(snapshot);
118                        self.primary(state)
119                    }
120                }
121                else {
122                    state.restore(snapshot);
123                    self.primary(state)
124                }
125            }
126            _ => self.primary(state),
127        }
128    }
129
130    fn infix<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>, left: &'a GreenNode<'a, JavaLanguage>, min_precedence: u8) -> Option<&'a GreenNode<'a, JavaLanguage>> {
131        use crate::lexer::token_type::JavaTokenType::*;
132        self.skip_trivia(state);
133        let kind = state.peek_kind()?;
134        eprintln!("DEBUG: Parser infix peeking {:?}", kind);
135
136        let (prec, assoc) = match kind {
137            Assign | PlusEquals | MinusEquals | AsteriskEquals | SlashEquals | PercentEquals | LeftShiftEquals | RightShiftEquals | UnsignedRightShiftEquals | AmpersandEquals | PipeEquals | CaretEquals => (1, Associativity::Right),
138            Question => (2, Associativity::Right),
139            PipePipe => (3, Associativity::Left),
140            AmpersandAmpersand => (4, Associativity::Left),
141            Pipe => (5, Associativity::Left),
142            Caret => (6, Associativity::Left),
143            Ampersand => (7, Associativity::Left),
144            Equals | BangEquals => (8, Associativity::Left),
145            LessThan | GreaterThan | LessThanEquals | GreaterThanEquals | Instanceof => (9, Associativity::Left),
146            LeftShift | RightShift | UnsignedRightShift => (10, Associativity::Left),
147            Plus | Minus => (11, Associativity::Left),
148            Asterisk | Slash | Percent => (12, Associativity::Left),
149            PlusPlus | MinusMinus => (15, Associativity::Left), // Postfix
150            LeftParen | Dot | LeftBracket => (16, Associativity::Left),
151            _ => return None,
152        };
153
154        if prec < min_precedence {
155            return None;
156        }
157
158        match kind {
159            PlusPlus | MinusMinus => {
160                let cp = state.checkpoint_before(left);
161                state.bump();
162                Some(state.finish_at(cp, JavaElementType::PostfixExpression))
163            }
164            Assign | PlusEquals | MinusEquals | AsteriskEquals | SlashEquals | PercentEquals | LeftShiftEquals | RightShiftEquals | UnsignedRightShiftEquals | AmpersandEquals | PipeEquals | CaretEquals => {
165                Some(binary(state, left, kind, prec, assoc, JavaElementType::AssignmentExpression.into(), |s, p| PrattParser::parse(s, p, self)))
166            }
167            Question => {
168                let cp = state.checkpoint_before(left);
169                state.bump(); // ?
170                self.skip_trivia(state);
171                PrattParser::parse(state, 0, self); // then branch
172                self.skip_trivia(state);
173                state.expect(Colon).ok(); // :
174                self.skip_trivia(state);
175                PrattParser::parse(state, prec, self); // else branch (right assoc)
176                Some(state.finish_at(cp, JavaElementType::TernaryExpression))
177            }
178            LeftParen => {
179                let cp = state.checkpoint_before(left);
180                state.expect(LeftParen).ok();
181                self.skip_trivia(state);
182                while state.not_at_end() && !state.at(RightParen) {
183                    PrattParser::parse(state, 0, self);
184                    self.skip_trivia(state);
185                    if state.eat(Comma) {
186                        self.skip_trivia(state);
187                        continue;
188                    }
189                }
190                state.expect(RightParen).ok();
191                Some(state.finish_at(cp, JavaElementType::MethodCall))
192            }
193            Dot => {
194                let cp = state.checkpoint_before(left);
195                state.expect(Dot).ok();
196                self.skip_trivia(state);
197                state.expect(Identifier).ok();
198                Some(state.finish_at(cp, JavaElementType::MemberSelect))
199            }
200            LeftBracket => {
201                let cp = state.checkpoint_before(left);
202                state.expect(LeftBracket).ok();
203                self.skip_trivia(state);
204                PrattParser::parse(state, 0, self);
205                self.skip_trivia(state);
206                state.expect(RightBracket).ok();
207                Some(state.finish_at(cp, JavaElementType::ArrayAccess))
208            }
209            _ => Some(binary(state, left, kind, prec, assoc, JavaElementType::BinaryExpression.into(), |s, p| PrattParser::parse(s, p, self))),
210        }
211    }
212}
213
214impl<'config> JavaParser<'config> {
215    pub fn new(config: &'config JavaLanguage) -> Self {
216        Self { config }
217    }
218
219    fn parse_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
220        use crate::lexer::token_type::JavaTokenType::*;
221        self.skip_trivia(state);
222        let cp = state.checkpoint();
223        let pk = state.peek_kind();
224        match pk {
225            Some(Public) | Some(Private) | Some(Protected) | Some(Static) | Some(Final) | Some(Abstract) | Some(Class) | Some(Interface) | Some(Enum) | Some(Struct) | Some(Record) => self.parse_declaration(state)?,
226            Some(Int) | Some(Boolean) | Some(Void) | Some(Long) | Some(Float) | Some(Double) | Some(Char) | Some(Byte) | Some(Short) => {
227                self.parse_variable_declaration(state)?;
228                state.finish_at(cp, JavaElementType::VariableDeclaration);
229            }
230            Some(Identifier) => {
231                // Could be a type name for a variable declaration, or an expression
232                let snapshot = state.checkpoint();
233                if self.parse_type(state).is_ok() {
234                    self.skip_trivia(state);
235                    if state.at(Identifier) {
236                        state.restore(snapshot);
237                        self.parse_variable_declaration(state)?;
238                        state.finish_at(cp, JavaElementType::VariableDeclaration);
239                    }
240                    else {
241                        state.restore(snapshot);
242                        PrattParser::parse(state, 0, self);
243                        self.skip_trivia(state);
244                        state.eat(Semicolon);
245                        state.finish_at(cp, JavaElementType::ExpressionStatement);
246                    }
247                }
248                else {
249                    state.restore(snapshot);
250                    PrattParser::parse(state, 0, self);
251                    self.skip_trivia(state);
252                    state.eat(Semicolon);
253                    state.finish_at(cp, JavaElementType::ExpressionStatement);
254                }
255            }
256            Some(If) => {
257                self.parse_if_statement(state)?;
258                state.finish_at(cp, JavaElementType::IfStatement);
259            }
260            Some(While) => {
261                self.parse_while_statement(state)?;
262                state.finish_at(cp, JavaElementType::WhileStatement);
263            }
264            Some(Do) => {
265                self.parse_do_while_statement(state)?;
266                state.finish_at(cp, JavaElementType::DoWhileStatement);
267            }
268            Some(For) => {
269                self.parse_for_statement(state)?;
270                state.finish_at(cp, JavaElementType::ForStatement);
271            }
272            Some(Switch) => {
273                self.parse_switch_statement(state)?;
274                state.finish_at(cp, JavaElementType::SwitchStatement);
275            }
276            Some(Return) => {
277                self.parse_return_statement(state)?;
278                state.finish_at(cp, JavaElementType::ReturnStatement);
279            }
280            Some(Break) => {
281                state.bump(); // break
282                state.eat(Semicolon);
283                state.finish_at(cp, JavaElementType::Break);
284            }
285            Some(Continue) => {
286                state.bump(); // continue
287                state.eat(Semicolon);
288                state.finish_at(cp, JavaElementType::Continue);
289            }
290            Some(LeftBrace) => {
291                self.parse_block_statement(state)?;
292            }
293            Some(Try) => {
294                state.bump(); // try
295                self.parse_block_statement(state)?;
296                self.skip_trivia(state);
297                while state.at(Catch) {
298                    let c_cp = state.checkpoint();
299                    state.bump(); // catch
300                    self.skip_trivia(state);
301                    state.expect(LeftParen).ok();
302                    self.skip_trivia(state);
303                    // Catch parameter: Type Name
304                    let p_cp = state.checkpoint();
305                    self.parse_type(state).ok();
306                    self.skip_trivia(state);
307                    state.expect(Identifier).ok();
308                    state.finish_at(p_cp, JavaElementType::Parameter);
309                    self.skip_trivia(state);
310                    state.expect(RightParen).ok();
311                    self.skip_trivia(state);
312                    self.parse_block_statement(state)?;
313                    state.finish_at(c_cp, JavaElementType::CatchClause);
314                    self.skip_trivia(state);
315                }
316                if state.eat(Finally) {
317                    self.skip_trivia(state);
318                    self.parse_block_statement(state)?;
319                }
320                state.finish_at(cp, JavaElementType::TryStatement);
321            }
322            Some(Throw) => {
323                state.bump(); // throw
324                self.skip_trivia(state);
325                PrattParser::parse(state, 0, self);
326                self.skip_trivia(state);
327                state.eat(Semicolon);
328                state.finish_at(cp, JavaElementType::ThrowStatement);
329            }
330            Some(Package) => {
331                self.parse_package_declaration(state)?;
332            }
333            Some(Import) => {
334                self.parse_import_declaration(state)?;
335            }
336            _ => {
337                PrattParser::parse(state, 0, self);
338                self.skip_trivia(state);
339                state.eat(Semicolon);
340                state.finish_at(cp, JavaElementType::ExpressionStatement);
341            }
342        }
343        Ok(())
344    }
345
346    fn skip_trivia<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) {
347        while let Some(kind) = state.peek_kind() {
348            if kind.is_ignored() { state.bump() } else { break }
349        }
350    }
351
352    fn parse_type<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
353        use crate::lexer::token_type::JavaTokenType::*;
354        self.skip_trivia(state);
355        let cp = state.checkpoint();
356        match state.peek_kind() {
357            Some(Identifier) | Some(Int) | Some(Boolean) | Some(Void) | Some(Long) | Some(Float) | Some(Double) | Some(Char) | Some(Byte) | Some(Short) => state.bump(),
358            _ => {
359                // Return error?
360            }
361        }
362        self.skip_trivia(state);
363        while state.at(Dot) {
364            state.bump();
365            self.skip_trivia(state);
366            state.expect(Identifier).ok();
367            self.skip_trivia(state)
368        }
369        while state.at(LeftBracket) {
370            state.bump();
371            self.skip_trivia(state);
372            state.expect(RightBracket).ok();
373            self.skip_trivia(state)
374        }
375        state.finish_at(cp, JavaElementType::Identifier);
376        Ok(())
377    }
378
379    fn parse_package_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
380        use crate::lexer::token_type::JavaTokenType::*;
381        let cp = state.checkpoint();
382        state.expect(Package).ok();
383        self.skip_trivia(state);
384        while state.not_at_end() && !state.at(Semicolon) {
385            if state.at(Identifier) || state.at(Dot) {
386                state.bump()
387            }
388            else {
389                break;
390            }
391            self.skip_trivia(state)
392        }
393        state.eat(Semicolon);
394        state.finish_at(cp, JavaElementType::Package);
395        Ok(())
396    }
397
398    fn parse_import_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
399        use crate::lexer::token_type::JavaTokenType::*;
400        let cp = state.checkpoint();
401        state.expect(Import).ok();
402        self.skip_trivia(state);
403        if state.eat(Static) {
404            self.skip_trivia(state)
405        }
406        while state.not_at_end() && !state.at(Semicolon) {
407            if state.at(Identifier) || state.at(Dot) || state.at(Asterisk) {
408                state.bump()
409            }
410            else {
411                break;
412            }
413            self.skip_trivia(state)
414        }
415        state.eat(Semicolon);
416        state.finish_at(cp, JavaElementType::Import);
417        Ok(())
418    }
419
420    fn parse_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
421        use crate::lexer::token_type::JavaTokenType::*;
422        let cp = state.checkpoint();
423        self.skip_trivia(state);
424        // 处理修饰符
425        while state.not_at_end() && matches!(state.peek_kind(), Some(Public) | Some(Private) | Some(Protected) | Some(Static) | Some(Final) | Some(Abstract)) {
426            state.bump();
427            self.skip_trivia(state)
428        }
429
430        match state.peek_kind() {
431            Some(Class) => {
432                state.expect(Class).ok();
433                self.skip_trivia(state);
434                state.expect(Identifier).ok();
435                self.skip_trivia(state);
436                if state.eat(Extends) {
437                    self.skip_trivia(state);
438                    state.expect(Identifier).ok();
439                    self.skip_trivia(state)
440                }
441                if state.eat(Implements) {
442                    self.skip_trivia(state);
443                    while state.not_at_end() && !state.at(LeftBrace) {
444                        state.bump();
445                        self.skip_trivia(state)
446                    }
447                }
448                self.parse_block_statement(state)?;
449                state.finish_at(cp, JavaElementType::ClassDeclaration);
450            }
451            Some(Interface) => {
452                state.expect(Interface).ok();
453                self.skip_trivia(state);
454                state.expect(Identifier).ok();
455                self.skip_trivia(state);
456                self.parse_block_statement(state)?;
457                state.finish_at(cp, JavaElementType::InterfaceDeclaration);
458            }
459            Some(Enum) => {
460                state.expect(Enum).ok();
461                self.skip_trivia(state);
462                state.expect(Identifier).ok();
463                self.skip_trivia(state);
464                self.parse_block_statement(state)?;
465                state.finish_at(cp, JavaElementType::EnumDeclaration);
466            }
467            Some(Struct) => {
468                state.expect(Struct).ok();
469                self.skip_trivia(state);
470                state.expect(Identifier).ok();
471                self.skip_trivia(state);
472                self.parse_block_statement(state)?;
473                state.finish_at(cp, JavaElementType::StructDeclaration);
474            }
475            Some(Record) => {
476                state.expect(Record).ok();
477                self.skip_trivia(state);
478                state.expect(Identifier).ok();
479                self.skip_trivia(state);
480                self.parse_block_statement(state)?;
481                state.finish_at(cp, JavaElementType::RecordDeclaration);
482            }
483            _ => {
484                // 可能是方法或字段
485                // 此时已经消耗了修饰符，当前应该是类型
486                self.parse_type(state).ok();
487                self.skip_trivia(state);
488                // 消耗名称并包装为 Identifier 节点
489                let name_cp = state.checkpoint();
490                state.expect(Identifier).ok();
491                state.finish_at(name_cp, JavaElementType::Identifier);
492                self.skip_trivia(state);
493
494                if state.at(LeftParen) {
495                    // 方法声明
496                    state.bump(); // (
497                    self.skip_trivia(state);
498                    while state.not_at_end() && !state.at(RightParen) {
499                        // 简单的参数解析：Type Name
500                        let p_cp = state.checkpoint();
501                        self.parse_type(state).ok();
502                        self.skip_trivia(state);
503                        let pn_cp = state.checkpoint();
504                        state.expect(Identifier).ok(); // Name
505                        state.finish_at(pn_cp, JavaElementType::Identifier);
506                        self.skip_trivia(state);
507                        // 处理数组类型 []
508                        while state.at(LeftBracket) {
509                            state.bump();
510                            self.skip_trivia(state);
511                            state.expect(RightBracket).ok();
512                            self.skip_trivia(state)
513                        }
514                        state.finish_at(p_cp, JavaElementType::Parameter);
515                        if !state.eat(Comma) {
516                            break;
517                        }
518                        self.skip_trivia(state)
519                    }
520                    state.expect(RightParen).ok();
521                    self.skip_trivia(state);
522                    if state.eat(Throws) {
523                        self.skip_trivia(state);
524                        while state.not_at_end() && !state.at(LeftBrace) && !state.at(Semicolon) {
525                            let t_cp = state.checkpoint();
526                            state.expect(Identifier).ok();
527                            state.finish_at(t_cp, JavaElementType::Identifier);
528                            self.skip_trivia(state);
529                            if !state.eat(Comma) {
530                                break;
531                            }
532                            self.skip_trivia(state)
533                        }
534                    }
535                    self.skip_trivia(state);
536                    if state.at(LeftBrace) {
537                        self.parse_block_statement(state)?
538                    }
539                    else {
540                        state.eat(Semicolon);
541                    }
542                    state.finish_at(cp, JavaElementType::MethodDeclaration);
543                }
544                else {
545                    // 字段声明
546                    if state.eat(Assign) {
547                        self.skip_trivia(state);
548                        PrattParser::parse(state, 0, self);
549                    }
550                    self.skip_trivia(state);
551                    state.eat(Semicolon);
552                    state.finish_at(cp, JavaElementType::FieldDeclaration);
553                }
554            }
555        }
556        Ok(())
557    }
558
559    fn _parse_class_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
560        use crate::lexer::token_type::JavaTokenType::*;
561        let cp = state.checkpoint();
562        state.expect(Class).ok();
563        state.expect(Identifier).ok();
564        if state.eat(Extends) {
565            state.expect(Identifier).ok();
566        }
567        if state.eat(Implements) {
568            while state.not_at_end() && !state.at(LeftBrace) {
569                state.bump()
570            }
571        }
572        self.parse_block_statement(state)?;
573        state.finish_at(cp, JavaElementType::ClassDeclaration);
574        Ok(())
575    }
576
577    fn _parse_interface_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
578        use crate::lexer::token_type::JavaTokenType::*;
579        state.expect(Interface).ok();
580        state.expect(Identifier).ok();
581        self.parse_block_statement(state)?;
582        Ok(())
583    }
584
585    fn _parse_enum_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
586        use crate::lexer::token_type::JavaTokenType::*;
587        state.expect(Enum).ok();
588        state.expect(Identifier).ok();
589        self.parse_block_statement(state)?;
590        Ok(())
591    }
592
593    fn parse_if_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
594        use crate::lexer::token_type::JavaTokenType::*;
595        state.bump(); // if
596        self.skip_trivia(state);
597        state.expect(LeftParen).ok();
598        self.skip_trivia(state);
599        PrattParser::parse(state, 0, self);
600        self.skip_trivia(state);
601        state.expect(RightParen).ok();
602        self.skip_trivia(state);
603        self.parse_statement(state)?;
604        self.skip_trivia(state);
605        if state.eat(Else) {
606            self.skip_trivia(state);
607            self.parse_statement(state)?;
608        }
609        Ok(())
610    }
611
612    fn parse_while_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
613        use crate::lexer::token_type::JavaTokenType::*;
614        state.bump(); // while
615        self.skip_trivia(state);
616        state.expect(LeftParen).ok();
617        self.skip_trivia(state);
618        PrattParser::parse(state, 0, self);
619        self.skip_trivia(state);
620        state.expect(RightParen).ok();
621        self.skip_trivia(state);
622        self.parse_statement(state)?;
623        Ok(())
624    }
625
626    fn parse_do_while_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
627        use crate::lexer::token_type::JavaTokenType::*;
628        state.bump(); // do
629        self.skip_trivia(state);
630        self.parse_statement(state)?;
631        self.skip_trivia(state);
632        state.expect(While).ok();
633        self.skip_trivia(state);
634        state.expect(LeftParen).ok();
635        self.skip_trivia(state);
636        PrattParser::parse(state, 0, self);
637        self.skip_trivia(state);
638        state.expect(RightParen).ok();
639        self.skip_trivia(state);
640        state.eat(Semicolon);
641        Ok(())
642    }
643
644    fn parse_for_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
645        use crate::lexer::token_type::JavaTokenType::*;
646        state.bump(); // for
647        state.expect(LeftParen).ok();
648        self.skip_trivia(state);
649
650        // 1. Init
651        if !state.at(Semicolon) {
652            let cp = state.checkpoint();
653            let pk = state.peek_kind();
654            match pk {
655                Some(Int) | Some(Boolean) | Some(Void) | Some(Long) | Some(Float) | Some(Double) | Some(Char) | Some(Byte) | Some(Short) => {
656                    self.parse_variable_declaration(state)?;
657                    state.finish_at(cp, JavaElementType::VariableDeclaration);
658                }
659                Some(Identifier) => {
660                    let snapshot = state.checkpoint();
661                    if self.parse_type(state).is_ok() && state.at(Identifier) {
662                        state.restore(snapshot);
663                        self.parse_variable_declaration(state)?;
664                        state.finish_at(cp, JavaElementType::VariableDeclaration);
665                    }
666                    else {
667                        state.restore(snapshot);
668                        PrattParser::parse(state, 0, self);
669                    }
670                }
671                _ => {
672                    PrattParser::parse(state, 0, self);
673                }
674            }
675        }
676        state.expect(Semicolon).ok();
677        self.skip_trivia(state);
678
679        // 2. Condition
680        if !state.at(Semicolon) {
681            PrattParser::parse(state, 0, self);
682        }
683        state.expect(Semicolon).ok();
684        self.skip_trivia(state);
685
686        // 3. Update
687        if !state.at(RightParen) {
688            PrattParser::parse(state, 0, self);
689        }
690        state.expect(RightParen).ok();
691        self.skip_trivia(state);
692
693        // 4. Body
694        self.parse_statement(state)?;
695        Ok(())
696    }
697
698    fn parse_variable_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
699        use crate::lexer::token_type::JavaTokenType::*;
700        self.parse_type(state)?;
701        self.skip_trivia(state);
702        let cp = state.checkpoint();
703        state.expect(Identifier).ok();
704        state.finish_at(cp, JavaElementType::Identifier);
705        self.skip_trivia(state);
706        if state.eat(Assign) {
707            self.skip_trivia(state);
708            PrattParser::parse(state, 0, self);
709        }
710        self.skip_trivia(state);
711        state.eat(Semicolon);
712        Ok(())
713    }
714
715    fn parse_switch_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
716        use crate::lexer::token_type::JavaTokenType::*;
717        state.bump(); // switch
718        self.skip_trivia(state);
719        state.expect(LeftParen).ok();
720        self.skip_trivia(state);
721        PrattParser::parse(state, 0, self);
722        self.skip_trivia(state);
723        state.expect(RightParen).ok();
724        self.skip_trivia(state);
725        state.expect(LeftBrace).ok();
726        self.skip_trivia(state);
727        while state.not_at_end() && !state.at(RightBrace) {
728            self.skip_trivia(state);
729            let cp = state.checkpoint();
730            if state.eat(Case) {
731                self.skip_trivia(state);
732                PrattParser::parse(state, 0, self);
733                self.skip_trivia(state);
734                state.expect(Colon).ok();
735                self.skip_trivia(state);
736                while state.not_at_end() && !state.at(Case) && !state.at(Default) && !state.at(RightBrace) {
737                    self.parse_statement(state).ok();
738                    self.skip_trivia(state);
739                }
740                state.finish_at(cp, JavaElementType::SwitchCase);
741            }
742            else if state.eat(Default) {
743                self.skip_trivia(state);
744                state.expect(Colon).ok();
745                self.skip_trivia(state);
746                while state.not_at_end() && !state.at(Case) && !state.at(Default) && !state.at(RightBrace) {
747                    self.parse_statement(state).ok();
748                    self.skip_trivia(state)
749                }
750                state.finish_at(cp, JavaElementType::DefaultCase);
751            }
752            else {
753                state.bump(); // error recovery
754                self.skip_trivia(state)
755            }
756        }
757        state.expect(RightBrace).ok();
758        Ok(())
759    }
760
761    fn parse_block_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
762        let cp = state.checkpoint();
763        state.expect(JavaTokenType::LeftBrace).ok();
764        while state.not_at_end() && !state.at(JavaTokenType::RightBrace) {
765            self.skip_trivia(state);
766            if state.at(JavaTokenType::RightBrace) {
767                break;
768            }
769            self.parse_statement(state).ok();
770            self.skip_trivia(state)
771        }
772        state.expect(JavaTokenType::RightBrace).ok();
773        state.finish_at(cp, JavaElementType::BlockStatement);
774        Ok(())
775    }
776
777    fn parse_return_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
778        state.bump(); // return
779        if !state.at(JavaTokenType::Semicolon) && !state.at(JavaTokenType::RightBrace) {
780            PrattParser::parse(state, 0, self);
781        }
782        state.eat(JavaTokenType::Semicolon);
783        Ok(())
784    }
785
786    fn parse_item<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
787        self.parse_statement(state)
788    }
789}
790
791impl<'config> JavaParser<'config> {
792    fn parse_root<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<&'a GreenNode<'a, JavaLanguage>, OakError> {
793        let checkpoint = state.checkpoint();
794        while state.not_at_end() {
795            self.parse_item(state).ok();
796        }
797        Ok(state.finish_at(checkpoint, JavaElementType::CompilationUnit))
798    }
799}
800
801impl<'config> Parser<JavaLanguage> for JavaParser<'config> {
802    fn parse<'a, S: Source + ?Sized>(&self, text: &'a S, edits: &[TextEdit], cache: &'a mut impl ParseCache<JavaLanguage>) -> oak_core::parser::ParseOutput<'a, JavaLanguage> {
803        let lexer = JavaLexer::new(self.config);
804        oak_core::parser::parse_with_lexer(&lexer, text, edits, cache, |state| self.parse_root(state))
805    }
806}
oak_java/parser/mod.rs

oak_java/parser/
mod.rs
