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

use super::{FmtOptions, Line};

#[derive(Debug, Clone, Copy, Default)]
struct FormatterState {
    semicolon_starts_on_new_line: bool,
    directive_starts_on_new_line: bool,
    declaration_starts_on_new_line: bool,
}

#[derive(Debug, Clone, Copy)]
pub(crate) struct FormatterContext<'a> {
    policy: &'a FmtOptions,
    state: FormatterState,
}

impl<'a> FormatterContext<'a> {
    pub(crate) fn new(policy: &'a FmtOptions) -> Self {
        Self {
            policy,
            state: FormatterState::default(),
        }
    }

    pub(crate) fn with_semicolon_starts_on_new_line(
        mut self,
        semicolon_starts_on_new_line: bool,
    ) -> Self {
        self.state.semicolon_starts_on_new_line = semicolon_starts_on_new_line;
        self
    }

    pub(crate) fn with_directive_starts_on_new_line(
        mut self,
        directive_starts_on_new_line: bool,
    ) -> Self {
        self.state.directive_starts_on_new_line = directive_starts_on_new_line;
        self
    }

    pub(crate) fn with_declaration_starts_on_new_line(
        mut self,
        declaration_starts_on_new_line: bool,
    ) -> Self {
        self.state.declaration_starts_on_new_line = declaration_starts_on_new_line;
        self
    }

    pub(crate) fn policy(&self) -> &FmtOptions {
        self.policy
    }

    pub(crate) fn semicolon_starts_on_new_line(&self) -> bool {
        self.state.semicolon_starts_on_new_line
    }

    pub(crate) fn directive_starts_on_new_line(&self) -> bool {
        self.state.directive_starts_on_new_line
    }

    pub(crate) fn declaration_starts_on_new_line(&self) -> bool {
        self.state.declaration_starts_on_new_line
    }

    pub(crate) fn empty_line_after_prod(&self) -> bool {
        self.policy.empty_line_after_prod
    }
}

pub(crate) fn context_for_scanner_directive<'a>(
    context: &FormatterContext<'a>,
    comments_before_token: &str,
) -> FormatterContext<'a> {
    context
        .with_directive_starts_on_new_line(leading_token_delimiter(comments_before_token) == "\n")
}

pub(crate) fn scanner_directive_indent(
    base_indent: &str,
    context: &FormatterContext<'_>,
) -> String {
    if context.directive_starts_on_new_line() {
        format!("\n{base_indent}")
    } else {
        base_indent.to_string()
    }
}

pub(crate) fn context_for_declaration<'a>(
    context: &FormatterContext<'a>,
    comments_before_token: &str,
) -> FormatterContext<'a> {
    context
        .with_declaration_starts_on_new_line(leading_token_delimiter(comments_before_token) == "\n")
}

pub(crate) fn declaration_delimiter(context: &FormatterContext<'_>) -> &'static str {
    if context.declaration_starts_on_new_line() {
        "\n"
    } else {
        ""
    }
}

pub(crate) fn semicolon_starts_on_new_line(
    options: &FmtOptions,
    comments_before_semicolon: &str,
) -> bool {
    options.prod_semicolon_on_nl || Line::ends_with_nl(comments_before_semicolon)
}

fn leading_token_delimiter(comments_before_token: &str) -> &'static str {
    if comments_before_token.is_empty() || !Line::ends_with_nl(comments_before_token) {
        "\n"
    } else {
        ""
    }
}