ktrs-parser 0.5.0

Kotlin parser producing PSI-identical lossless trees, ported from the Kotlin compiler
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! `KotlinExpressionParsing.java` lines 1366-1487: `do`/`while`/`for` loops and control-structure bodies.

use ktrs_syntax::SyntaxKind::*;

use super::{
    COLON_IN_KEYWORD_SET, IN_KEYWORD_L_BRACE_RECOVERY_SET, IN_KEYWORD_L_BRACE_SET, IN_KEYWORD_R_PAR_COLON_SET,
    IN_KEYWORD_SET, L_PAR_L_BRACE_R_PAR_SET,
};
use crate::parsing::Parser;
use crate::parsing::declarations::{EXPRESSION_FIRST, MultiDeclarationMode};

impl Parser {
    /*
     * doWhile
     *   : "do" element "while" "(" element ")"
     *   ;
     */
    pub(crate) fn parse_do_while(&mut self) {
        debug_assert!(self._at(DO_KEYWORD));

        let r#loop = self.mark();

        self.advance(); // DO_KEYWORD

        if !self.at(WHILE_KEYWORD) {
            self.parse_loop_body();
        }

        if self.expect_2(WHILE_KEYWORD, "Expecting 'while' followed by a post-condition") {
            self.parse_condition();
        }

        r#loop.done(self, DO_WHILE);
    }

    /*
     * while
     *   : "while" "(" element ")" element
     *   ;
     */
    pub(crate) fn parse_while(&mut self) {
        debug_assert!(self._at(WHILE_KEYWORD));

        let r#loop = self.mark();

        self.advance(); // WHILE_KEYWORD

        self.parse_condition();

        self.parse_loop_body();

        r#loop.done(self, WHILE);
    }

    /*
     * for
     *   : "for" "(" annotations ("val" | "var")? (multipleVariableDeclarations | variableDeclarationEntry) "in" expression ")" expression
     *   ;
     *
     *   TODO: empty loop body (at the end of the block)?
     */
    pub(crate) fn parse_for(&mut self) {
        debug_assert!(self._at(FOR_KEYWORD));

        let r#loop = self.mark();

        self.advance(); // FOR_KEYWORD

        if self.expect_3(LPAR, "Expecting '(' to open a loop range", Some(EXPRESSION_FIRST)) {
            self.my_builder.disable_newlines();

            if !self.at(RPAR) {
                let parameter = self.mark();

                if !self.at(IN_KEYWORD) {
                    self.parse_modifier_list(IN_KEYWORD_R_PAR_COLON_SET);
                }

                if self.at(VAL_KEYWORD) || self.at(VAR_KEYWORD) {
                    self.advance(); // VAL_KEYWORD or VAR_KEYWORD
                }

                if self.at(LPAR) || self.at(LBRACKET) {
                    let destructuring_declaration = self.mark();
                    // No var in destructured loop parameter
                    let mode = if self.lookahead(1) == Some(VAL_KEYWORD) {
                        MultiDeclarationMode::FullValOnly
                    } else {
                        MultiDeclarationMode::Short
                    };
                    self.parse_multi_declaration_entry(IN_KEYWORD_L_BRACE_SET, IN_KEYWORD_L_BRACE_RECOVERY_SET, mode);
                    destructuring_declaration.done(self, DESTRUCTURING_DECLARATION);
                } else {
                    self.expect_3(IDENTIFIER, "Expecting a variable name", Some(COLON_IN_KEYWORD_SET));

                    if self.at(COLON) {
                        self.advance(); // COLON
                        self.parse_type_ref_1(IN_KEYWORD_SET);
                    }
                }
                parameter.done(self, VALUE_PARAMETER);

                if self.expect_3(IN_KEYWORD, "Expecting 'in'", Some(L_PAR_L_BRACE_R_PAR_SET)) {
                    let range = self.mark();
                    self.parse_expression();
                    range.done(self, LOOP_RANGE);
                }
            } else {
                self.error("Expecting a variable name");
            }

            self.expect_no_advance(RPAR, "Expecting ')'");
            self.my_builder.restore_newlines_state();
        }

        self.parse_loop_body();

        r#loop.done(self, FOR);
    }

    pub(crate) fn parse_control_structure_body(&mut self) {
        if !self.parse_annotated_lambda(/* preferBlock = */ true) {
            self.parse_block_level_expression();
        }
    }

    /*
     * element
     */
    pub(crate) fn parse_loop_body(&mut self) {
        let body = self.mark();
        if !self.at(SEMICOLON) {
            self.parse_control_structure_body();
        }
        body.done(self, BODY);
    }
}