parol-ls 4.4.0

Language server for parol parser generator
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

use crate::parol_ls_grammar_trait::{
    DoubleColon, Identifier, LiteralString, LookAheadGroup, Regex, TokenLiteral, UserTypeNameList,
};

use super::super::comments::Comments;
use super::super::fmt_options::FmtOptions;
use super::traits::Fmt;

impl Fmt for DoubleColon {
    fn txt(&self, _options: &FmtOptions, comments: Comments) -> (String, Comments) {
        (self.double_colon.text().to_string(), comments)
    }
}

impl Fmt for Identifier {
    fn txt(&self, _options: &FmtOptions, comments: Comments) -> (String, Comments) {
        (self.identifier.text().to_string(), comments)
    }
}

impl Fmt for LiteralString {
    fn txt(&self, _options: &FmtOptions, comments: Comments) -> (String, Comments) {
        (self.literal_string.text().to_string(), comments)
    }
}

impl Fmt for LookAheadGroup {
    fn txt(&self, _options: &FmtOptions, comments: Comments) -> (String, Comments) {
        let lookahead_group_str = match self {
            LookAheadGroup::PositiveLookahead(look_ahead_group_positive_lookahead) => {
                look_ahead_group_positive_lookahead
                    .positive_lookahead
                    .positive_lookahead
                    .text()
            }
            LookAheadGroup::NegativeLookahead(look_ahead_group_negative_lookahead) => {
                look_ahead_group_negative_lookahead
                    .negative_lookahead
                    .negative_lookahead
                    .text()
            }
        };
        (lookahead_group_str.to_string(), comments)
    }
}

impl Fmt for Regex {
    fn txt(&self, _options: &FmtOptions, comments: Comments) -> (String, Comments) {
        (self.regex.text().to_string(), comments)
    }
}

impl Fmt for TokenLiteral {
    fn txt(&self, options: &FmtOptions, comments: Comments) -> (String, Comments) {
        match self {
            TokenLiteral::String(s) => s.string.txt(options, comments),
            TokenLiteral::LiteralString(l) => l.literal_string.txt(options, comments),
            TokenLiteral::Regex(r) => r.regex.txt(options, comments),
        }
    }
}

impl Fmt for UserTypeNameList {
    fn txt(&self, options: &FmtOptions, comments: Comments) -> (String, Comments) {
        let (identifier, comments) = self.identifier.txt(options, comments);
        (
            format!("{}{}", self.double_colon.double_colon, identifier),
            comments,
        )
    }
}