oak_java/parser/
mod.rs

1use crate::{kind::JavaSyntaxKind, language::JavaLanguage, lexer::JavaLexer};
2use oak_core::{
3    GreenNode, OakError, TextEdit, TokenType,
4    parser::{
5        ParseCache, Parser, ParserState,
6        pratt::{Associativity, Pratt, PrattParser, binary},
7    },
8    source::Source,
9};
10
11pub(crate) type State<'a, S> = ParserState<'a, JavaLanguage, S>;
12
13pub struct JavaParser<'config> {
14    pub(crate) config: &'config JavaLanguage,
15}
16
17impl<'config> Pratt<JavaLanguage> for JavaParser<'config> {
18    fn primary<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> &'a GreenNode<'a, JavaLanguage> {
19        use crate::kind::JavaSyntaxKind::*;
20        self.skip_trivia(state);
21        let cp = state.checkpoint();
22        match state.peek_kind() {
23            Some(Identifier) => {
24                state.bump();
25                state.finish_at(cp, Identifier.into())
26            }
27            Some(IntegerLiteral) | Some(FloatingPointLiteral) | Some(BooleanLiteral) | Some(CharacterLiteral) | Some(StringLiteral) | Some(NullLiteral) => {
28                state.bump();
29                state.finish_at(cp, LiteralExpression.into())
30            }
31            Some(LeftParen) => {
32                state.bump();
33                PrattParser::parse(state, 0, self);
34                state.expect(RightParen).ok();
35                state.finish_at(cp, CompilationUnit.into()) // 括号表达式暂且如此
36            }
37            _ => {
38                state.bump();
39                state.finish_at(cp, Error.into())
40            }
41        }
42    }
43
44    fn prefix<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> &'a GreenNode<'a, JavaLanguage> {
45        self.primary(state)
46    }
47
48    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>> {
49        use crate::kind::JavaSyntaxKind::*;
50        self.skip_trivia(state);
51        let kind = state.peek_kind()?;
52        eprintln!("DEBUG: Parser infix peeking {:?}", kind);
53
54        let (prec, assoc) = match kind {
55            Assign | PlusEquals | MinusEquals | AsteriskEquals | SlashEquals | PercentEquals | LeftShiftEquals | RightShiftEquals | UnsignedRightShiftEquals | AmpersandEquals | PipeEquals | CaretEquals => (1, Associativity::Right),
56            PipePipe => (2, Associativity::Left),
57            AmpersandAmpersand => (3, Associativity::Left),
58            Equals | BangEquals | LessThan | GreaterThan | LessThanEquals | GreaterThanEquals => (4, Associativity::Left),
59            Plus | Minus => (10, Associativity::Left),
60            Asterisk | Slash | Percent => (11, Associativity::Left),
61            LeftParen | Dot => (15, Associativity::Left),
62            _ => return None,
63        };
64
65        if prec < min_precedence {
66            return None;
67        }
68
69        match kind {
70            LeftParen => {
71                let cp = state.checkpoint();
72                state.push_child(left);
73                state.expect(LeftParen).ok();
74                self.skip_trivia(state);
75                while state.not_at_end() && !state.at(RightParen) {
76                    PrattParser::parse(state, 0, self);
77                    self.skip_trivia(state);
78                    if state.eat(Comma) {
79                        self.skip_trivia(state);
80                        continue;
81                    }
82                }
83                state.expect(RightParen).ok();
84                Some(state.finish_at(cp, MethodCall.into()))
85            }
86            Dot => {
87                let cp = state.checkpoint();
88                state.push_child(left);
89                state.expect(Dot).ok();
90                self.skip_trivia(state);
91                state.expect(Identifier).ok();
92                Some(state.finish_at(cp, MemberSelect.into()))
93            }
94            _ => Some(binary(state, left, kind, prec, assoc, BinaryExpression.into(), |s, p| PrattParser::parse(s, p, self))),
95        }
96    }
97}
98
99impl<'config> JavaParser<'config> {
100    pub fn new(config: &'config JavaLanguage) -> Self {
101        Self { config }
102    }
103
104    fn parse_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
105        use crate::kind::JavaSyntaxKind::*;
106        self.skip_trivia(state);
107        let cp = state.checkpoint();
108        let pk = state.peek_kind();
109        match pk {
110            Some(Public) | Some(Private) | Some(Protected) | Some(Static) | Some(Final) | Some(Class) | Some(Interface) | Some(Enum) => {
111                self.parse_declaration(state)?;
112            }
113            Some(If) => {
114                self.parse_if_statement(state)?;
115                state.finish_at(cp, IfStatement.into());
116            }
117            Some(While) => {
118                self.parse_while_statement(state)?;
119                state.finish_at(cp, WhileStatement.into());
120            }
121            Some(For) => {
122                self.parse_for_statement(state)?;
123                state.finish_at(cp, ForStatement.into());
124            }
125            Some(Return) => {
126                self.parse_return_statement(state)?;
127                state.finish_at(cp, ReturnStatement.into());
128            }
129            Some(LeftBrace) => {
130                self.parse_block_statement(state)?;
131            }
132            Some(Package) => self.parse_package_declaration(state)?,
133            Some(Import) => self.parse_import_declaration(state)?,
134            _ => {
135                PrattParser::parse(state, 0, self);
136                self.skip_trivia(state);
137                state.eat(Semicolon);
138                state.finish_at(cp, ExpressionStatement.into());
139            }
140        }
141        Ok(())
142    }
143
144    fn skip_trivia<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) {
145        while let Some(kind) = state.peek_kind() {
146            if kind.is_ignored() {
147                state.bump();
148            }
149            else {
150                break;
151            }
152        }
153    }
154
155    fn parse_type<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
156        use crate::kind::JavaSyntaxKind::*;
157        self.skip_trivia(state);
158        match state.peek_kind() {
159            Some(Identifier) | Some(Int) | Some(Boolean) | Some(Void) | Some(Long) | Some(Float) | Some(Double) | Some(Char) | Some(Byte) | Some(Short) => {
160                state.bump();
161            }
162            _ => {
163                // Return error?
164            }
165        }
166        self.skip_trivia(state);
167        while state.at(Dot) {
168            state.bump();
169            self.skip_trivia(state);
170            state.expect(Identifier).ok();
171            self.skip_trivia(state);
172        }
173        while state.at(LeftBracket) {
174            state.bump();
175            self.skip_trivia(state);
176            state.expect(RightBracket).ok();
177            self.skip_trivia(state);
178        }
179        Ok(())
180    }
181
182    fn parse_package_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
183        use crate::kind::JavaSyntaxKind::*;
184        state.expect(Package).ok();
185        self.skip_trivia(state);
186        state.advance_until(Semicolon);
187        state.eat(Semicolon);
188        Ok(())
189    }
190
191    fn parse_import_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
192        use crate::kind::JavaSyntaxKind::*;
193        state.expect(Import).ok();
194        self.skip_trivia(state);
195        state.advance_until(Semicolon);
196        state.eat(Semicolon);
197        Ok(())
198    }
199
200    fn parse_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
201        use crate::kind::JavaSyntaxKind::*;
202        let cp = state.checkpoint();
203        self.skip_trivia(state);
204        // 处理修饰符
205        while state.not_at_end() && matches!(state.peek_kind(), Some(Public) | Some(Private) | Some(Protected) | Some(Static) | Some(Final) | Some(Abstract)) {
206            state.bump();
207            self.skip_trivia(state);
208        }
209
210        match state.peek_kind() {
211            Some(Class) => {
212                state.expect(Class).ok();
213                self.skip_trivia(state);
214                state.expect(Identifier).ok();
215                self.skip_trivia(state);
216                if state.eat(Extends) {
217                    self.skip_trivia(state);
218                    state.expect(Identifier).ok();
219                    self.skip_trivia(state);
220                }
221                if state.eat(Implements) {
222                    self.skip_trivia(state);
223                    while state.not_at_end() && !state.at(LeftBrace) {
224                        state.bump();
225                        self.skip_trivia(state);
226                    }
227                }
228                self.parse_block_statement(state)?;
229                state.finish_at(cp, ClassDeclaration.into());
230            }
231            Some(Interface) => {
232                state.expect(Interface).ok();
233                self.skip_trivia(state);
234                state.expect(Identifier).ok();
235                self.skip_trivia(state);
236                self.parse_block_statement(state)?;
237                state.finish_at(cp, InterfaceDeclaration.into());
238            }
239            Some(Enum) => {
240                state.expect(Enum).ok();
241                self.skip_trivia(state);
242                state.expect(Identifier).ok();
243                self.skip_trivia(state);
244                self.parse_block_statement(state)?;
245                state.finish_at(cp, ClassDeclaration.into()); // 暂且用 ClassDeclaration
246            }
247            _ => {
248                // 可能是方法或字段
249                // 此时已经消耗了修饰符，当前应该是类型
250                self.parse_type(state).ok();
251                self.skip_trivia(state);
252                state.expect(Identifier).ok(); // 消耗名称
253                self.skip_trivia(state);
254
255                if state.at(LeftParen) {
256                    // 方法声明
257                    state.bump(); // (
258                    self.skip_trivia(state);
259                    while state.not_at_end() && !state.at(RightParen) {
260                        // 简单的参数解析：Type Name
261                        let p_cp = state.checkpoint();
262                        self.parse_type(state).ok();
263                        self.skip_trivia(state);
264                        state.expect(Identifier).ok(); // Name
265                        self.skip_trivia(state);
266                        // 处理数组类型 []
267                        while state.at(LeftBracket) {
268                            state.bump();
269                            self.skip_trivia(state);
270                            state.expect(RightBracket).ok();
271                            self.skip_trivia(state);
272                        }
273                        state.finish_at(p_cp, Parameter.into());
274                        if !state.eat(Comma) {
275                            break;
276                        }
277                        self.skip_trivia(state);
278                    }
279                    state.expect(RightParen).ok();
280                    self.skip_trivia(state);
281                    if state.at(LeftBrace) {
282                        self.parse_block_statement(state)?;
283                    }
284                    else {
285                        state.eat(Semicolon);
286                    }
287                    state.finish_at(cp, MethodDeclaration.into());
288                }
289                else {
290                    // 字段声明
291                    if state.eat(Assign) {
292                        self.skip_trivia(state);
293                        PrattParser::parse(state, 0, self);
294                    }
295                    self.skip_trivia(state);
296                    state.eat(Semicolon);
297                    state.finish_at(cp, FieldDeclaration.into());
298                }
299            }
300        }
301        Ok(())
302    }
303
304    fn _parse_class_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
305        use crate::kind::JavaSyntaxKind::*;
306        let cp = state.checkpoint();
307        state.expect(Class).ok();
308        state.expect(Identifier).ok();
309        if state.eat(Extends) {
310            state.expect(Identifier).ok();
311        }
312        if state.eat(Implements) {
313            while state.not_at_end() && !state.at(LeftBrace) {
314                state.bump();
315            }
316        }
317        self.parse_block_statement(state)?;
318        state.finish_at(cp, ClassDeclaration.into());
319        Ok(())
320    }
321
322    fn _parse_interface_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
323        use crate::kind::JavaSyntaxKind::*;
324        state.expect(Interface).ok();
325        state.expect(Identifier).ok();
326        self.parse_block_statement(state)?;
327        Ok(())
328    }
329
330    fn _parse_enum_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
331        use crate::kind::JavaSyntaxKind::*;
332        state.expect(Enum).ok();
333        state.expect(Identifier).ok();
334        self.parse_block_statement(state)?;
335        Ok(())
336    }
337
338    fn parse_if_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
339        state.bump(); // if
340        state.expect(crate::kind::JavaSyntaxKind::LeftParen).ok();
341        PrattParser::parse(state, 0, self);
342        state.expect(crate::kind::JavaSyntaxKind::RightParen).ok();
343        self.parse_statement(state)?;
344        if state.eat(crate::kind::JavaSyntaxKind::Else) {
345            self.parse_statement(state)?;
346        }
347        Ok(())
348    }
349
350    fn parse_while_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
351        state.bump(); // while
352        state.expect(crate::kind::JavaSyntaxKind::LeftParen).ok();
353        PrattParser::parse(state, 0, self);
354        state.expect(crate::kind::JavaSyntaxKind::RightParen).ok();
355        self.parse_statement(state)?;
356        Ok(())
357    }
358
359    fn parse_for_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
360        state.bump(); // for
361        state.expect(crate::kind::JavaSyntaxKind::LeftParen).ok();
362        PrattParser::parse(state, 0, self);
363        state.expect(crate::kind::JavaSyntaxKind::RightParen).ok();
364        self.parse_statement(state)?;
365        Ok(())
366    }
367
368    fn parse_block_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
369        let cp = state.checkpoint();
370        state.expect(crate::kind::JavaSyntaxKind::LeftBrace).ok();
371        while state.not_at_end() && !state.at(crate::kind::JavaSyntaxKind::RightBrace) {
372            self.skip_trivia(state);
373            if state.at(crate::kind::JavaSyntaxKind::RightBrace) {
374                break;
375            }
376            self.parse_statement(state).ok();
377            self.skip_trivia(state);
378        }
379        state.expect(crate::kind::JavaSyntaxKind::RightBrace).ok();
380        state.finish_at(cp, crate::kind::JavaSyntaxKind::BlockStatement.into());
381        Ok(())
382    }
383
384    fn parse_return_statement<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
385        state.bump(); // return
386        if !state.at(crate::kind::JavaSyntaxKind::Semicolon) && !state.at(crate::kind::JavaSyntaxKind::RightBrace) {
387            PrattParser::parse(state, 0, self);
388        }
389        state.eat(crate::kind::JavaSyntaxKind::Semicolon);
390        Ok(())
391    }
392
393    fn parse_item<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
394        self.parse_statement(state)
395    }
396}
397
398impl<'config> JavaParser<'config> {
399    fn parse_root<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<&'a GreenNode<'a, JavaLanguage>, OakError> {
400        let checkpoint = state.checkpoint();
401        while state.not_at_end() {
402            self.parse_item(state).ok();
403        }
404        Ok(state.finish_at(checkpoint, JavaSyntaxKind::CompilationUnit.into()))
405    }
406}
407
408impl<'config> Parser<JavaLanguage> for JavaParser<'config> {
409    fn parse<'a, S: Source + ?Sized>(&self, text: &'a S, edits: &[TextEdit], cache: &'a mut impl ParseCache<JavaLanguage>) -> oak_core::parser::ParseOutput<'a, JavaLanguage> {
410        let lexer = JavaLexer::new(self.config);
411        oak_core::parser::parse_with_lexer(&lexer, text, edits, cache, |state| self.parse_root(state))
412    }
413}
oak_java/parser/mod.rs

oak_java/parser/
mod.rs
