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

//! Port of `KotlinParsing.java` lines 1972-2076 (blocks, delegation specifiers).

use ktrs_syntax::SyntaxKind::*;

use crate::parsing::Parser;

impl Parser {
    /*
     * block
     *   : "{" (expressions)* "}"
     *   ;
     */
    pub(crate) fn parse_block(&mut self) {
        self.parse_block_1(/*collapse*/ true);
    }

    pub(super) fn parse_block_1(&mut self, collapse: bool) {
        let lazy_block = self.mark();

        self.my_builder.enable_newlines();

        let has_opening_brace = self.expect_2(LBRACE, "Expecting '{' to open a block");
        let can_collapse = collapse && has_opening_brace && self.is_lazy;

        if can_collapse {
            self.advance_balanced_block();
        } else {
            self.parse_statements();
            self.expect_2(RBRACE, "Expecting '}'");
        }

        self.my_builder.restore_newlines_state();

        if can_collapse {
            lazy_block.collapse(self, BLOCK);
        } else {
            lazy_block.done(self, BLOCK);
        }
    }

    pub(crate) fn advance_balanced_block(&mut self) {
        let mut brace_count = 1;
        while !self.eof() {
            // `_at(LBRACE)` / `_at(RBRACE)` on one `tt()`: this loop runs once per nesting level
            // over every token of a lazy block.
            let token = self.tt();
            if token == Some(LBRACE) {
                brace_count += 1;
            } else if token == Some(RBRACE) {
                brace_count -= 1;
            }

            self.advance();

            if brace_count == 0 {
                break;
            }
        }
    }

    /*
     * delegationSpecifier{","}
     */
    pub(super) fn parse_delegation_specifier_list(&mut self) {
        let list = self.mark();

        loop {
            if self.at(COMMA) {
                self.error_and_advance("Expecting a delegation specifier");
                continue;
            }
            self.parse_delegation_specifier();
            if !self.at(COMMA) {
                break;
            }
            self.advance(); // COMMA
        }

        list.done(self, SUPER_TYPE_LIST);
    }

    /*
     * delegationSpecifier
     *   : constructorInvocation // type and constructor arguments
     *   : userType
     *   : explicitDelegation
     *   ;
     *
     * explicitDelegation
     *   : userType "by" element
     *   ;
     */
    fn parse_delegation_specifier(&mut self) {
        let delegator = self.mark();
        let reference = self.mark();
        self.parse_type_ref();

        if self.at(BY_KEYWORD) {
            reference.drop(self);
            self.advance(); // BY_KEYWORD
            self.create_for_by_clause(self.is_lazy, |p| p.parse_expression());
            delegator.done(self, DELEGATED_SUPER_TYPE_ENTRY);
        } else if self.at(LPAR) {
            reference.done(self, CONSTRUCTOR_CALLEE);
            self.parse_value_argument_list();
            delegator.done(self, SUPER_TYPE_CALL_ENTRY);
        } else {
            reference.drop(self);
            delegator.done(self, SUPER_TYPE_ENTRY);
        }
    }
}