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
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use super::super::comments::Comments;
use super::super::context::{FormatterContext, context_for_declaration, declaration_delimiter};
use super::helpers::{
    comment_opts_left, comment_opts_left_force_remove, format_comments_before_token,
    format_trailing_comment,
};
use super::last_token::LastToken;
use super::scanner_fmt::format_scanner_directives_with_context;
use super::traits::Fmt;
use crate::parol_ls_grammar_trait::Declaration;

pub(super) fn format_declaration_with_context(
    declaration: &Declaration,
    context: &FormatterContext<'_>,
    comments: Comments,
) -> (String, Comments) {
    match declaration {
        Declaration::PercentTitleString(title) => {
            let (comments_before_token, comments) = format_comments_before_token(
                comments,
                &title.percent_title,
                &comment_opts_left(context.policy()),
            );
            let context = context_for_declaration(context, &comments_before_token);
            let delim = declaration_delimiter(&context);
            let (str, comments) = title.string.txt(context.policy(), comments);
            (
                format!(
                    "{}{}{} {}",
                    comments_before_token, delim, title.percent_title, str
                ),
                comments,
            )
        }
        Declaration::PercentCommentString(comment) => {
            let (comments_before_token, comments) = format_comments_before_token(
                comments,
                &comment.percent_comment,
                &comment_opts_left(context.policy()),
            );
            let context = context_for_declaration(context, &comments_before_token);
            let delim = declaration_delimiter(&context);
            let (str, comments) = comment.string.txt(context.policy(), comments);
            (
                format!(
                    "{}{}{} {}",
                    comments_before_token, delim, comment.percent_comment, str
                ),
                comments,
            )
        }
        Declaration::PercentUserUnderscoreTypeIdentifierEquUserTypeName(user_type) => {
            let (comments_before_token, comments) = format_comments_before_token(
                comments,
                &user_type.percent_user_underscore_type,
                &comment_opts_left_force_remove(context.policy()),
            );
            let context = context_for_declaration(context, &comments_before_token);
            let delim = declaration_delimiter(&context);
            let (alias_name, comments) = user_type.identifier.txt(context.policy(), comments);
            let (orig_type_name, comments) =
                user_type.user_type_name.txt(context.policy(), comments);
            let (following_comment, comments) = format_trailing_comment(
                comments,
                user_type.user_type_name.get_last_token(),
                &comment_opts_left_force_remove(context.policy()),
            );
            (
                format!(
                    "{}{}{} {} {} {}{}",
                    comments_before_token,
                    delim,
                    user_type.percent_user_underscore_type,
                    alias_name,
                    user_type.equ,
                    orig_type_name,
                    following_comment,
                ),
                comments,
            )
        }
        Declaration::ScannerDirectives(scanner_directives) => {
            format_scanner_directives_with_context(
                &scanner_directives.scanner_directives,
                context,
                comments,
            )
        }
        Declaration::PercentGrammarUnderscoreTypeLiteralString(grammar_type) => {
            let (comments_before_token, comments) = format_comments_before_token(
                comments,
                &grammar_type.percent_grammar_underscore_type,
                &comment_opts_left(context.policy()),
            );
            let context = context_for_declaration(context, &comments_before_token);
            let delim = declaration_delimiter(&context);
            let (str, comments) = grammar_type.literal_string.txt(context.policy(), comments);
            (
                format!(
                    "{}{}{} {}",
                    comments_before_token, delim, grammar_type.percent_grammar_underscore_type, str
                ),
                comments,
            )
        }
        Declaration::PercentNtUnderscoreTypeNtNameEquNtType(nt_type) => {
            let (comments_before_token, comments) = format_comments_before_token(
                comments,
                &nt_type.percent_nt_underscore_type,
                &comment_opts_left_force_remove(context.policy()),
            );
            let context = context_for_declaration(context, &comments_before_token);
            let delim = declaration_delimiter(&context);
            let (prod_name, comments) = nt_type.nt_name.txt(context.policy(), comments);
            let (orig_type_name, comments) = nt_type.nt_type.txt(context.policy(), comments);
            let (following_comment, comments) = format_trailing_comment(
                comments,
                nt_type.nt_type.get_last_token(),
                &comment_opts_left_force_remove(context.policy()),
            );
            (
                format!(
                    "{}{}{} {} {} {}{}",
                    comments_before_token,
                    delim,
                    nt_type.percent_nt_underscore_type,
                    prod_name,
                    nt_type.equ,
                    orig_type_name,
                    following_comment,
                ),
                comments,
            )
        }
        Declaration::PercentTUnderscoreTypeTType(t_type) => {
            let (comments_before_token, comments) = format_comments_before_token(
                comments,
                &t_type.percent_t_underscore_type,
                &comment_opts_left_force_remove(context.policy()),
            );
            let context = context_for_declaration(context, &comments_before_token);
            let delim = declaration_delimiter(&context);
            let (user_type_name, comments) = t_type.t_type.txt(context.policy(), comments);
            let (following_comment, comments) = format_trailing_comment(
                comments,
                t_type.t_type.get_last_token(),
                &comment_opts_left_force_remove(context.policy()),
            );
            (
                format!(
                    "{}{}{} {}{}",
                    comments_before_token,
                    delim,
                    t_type.percent_t_underscore_type,
                    user_type_name,
                    following_comment,
                ),
                comments,
            )
        }
    }
}