syntax-rust 0.4.1

Provides highlighting for Rust code.
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
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
163
164
165
166
167
168

use crate::grammar::parse_item;
use crate::Parser;
use dialect::HighlightGroup;

pub(super) fn parse_trait(p: &mut Parser) {
    assert!(p.at(&[crate::TokenKind::Trait]));
    p.eat(HighlightGroup::OtherKeyword);

    p.push(crate::TokenKind::TypeIdent, HighlightGroup::InterfaceDef);

    p.push(crate::TokenKind::OpenBrace, HighlightGroup::Delimiter);

    loop {
        if p.at_end() {
            break;
        }

        if p.at(&[crate::TokenKind::CloseBrace]) {
            p.eat(HighlightGroup::Delimiter);
            break;
        }

        parse_item(p);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use dialect::HighlightedSpan;
    use pretty_assertions::assert_eq;

    #[test]
    fn parses_trait_with_no_items() {
        let mut parser = Parser::new("trait A {}");
        parse_trait(&mut parser);

        assert_eq!(
            parser.output,
            vec![
                HighlightedSpan {
                    range: 0..5,
                    group: HighlightGroup::OtherKeyword,
                },
                HighlightedSpan {
                    range: 6..7,
                    group: HighlightGroup::InterfaceDef,
                },
                HighlightedSpan {
                    range: 8..9,
                    group: HighlightGroup::Delimiter,
                },
                HighlightedSpan {
                    range: 9..10,
                    group: HighlightGroup::Delimiter,
                },
            ],
        );
    }

    #[test]
    fn parses_trait_with_several_items() {
        let mut parser = Parser::new("trait A { fn a(); }");
        parse_trait(&mut parser);

        assert_eq!(
            parser.output,
            vec![
                HighlightedSpan {
                    range: 0..5,
                    group: HighlightGroup::OtherKeyword,
                },
                HighlightedSpan {
                    range: 6..7,
                    group: HighlightGroup::InterfaceDef,
                },
                HighlightedSpan {
                    range: 8..9,
                    group: HighlightGroup::Delimiter,
                },
                HighlightedSpan {
                    range: 10..12,
                    group: HighlightGroup::OtherKeyword,
                },
                HighlightedSpan {
                    range: 13..14,
                    group: HighlightGroup::FunctionDef,
                },
                HighlightedSpan {
                    range: 14..15,
                    group: HighlightGroup::Delimiter,
                },
                HighlightedSpan {
                    range: 15..16,
                    group: HighlightGroup::Delimiter,
                },
                HighlightedSpan {
                    range: 16..17,
                    group: HighlightGroup::Terminator,
                },
                HighlightedSpan {
                    range: 18..19,
                    group: HighlightGroup::Delimiter,
                },
            ],
        );
    }

    #[test]
    fn parses_trait_with_erroneous_contents() {
        let mut parser = Parser::new("trait A { not valid }");
        parse_trait(&mut parser);

        assert_eq!(
            parser.output,
            vec![
                HighlightedSpan {
                    range: 0..5,
                    group: HighlightGroup::OtherKeyword,
                },
                HighlightedSpan {
                    range: 6..7,
                    group: HighlightGroup::InterfaceDef,
                },
                HighlightedSpan {
                    range: 8..9,
                    group: HighlightGroup::Delimiter,
                },
                HighlightedSpan {
                    range: 10..13,
                    group: HighlightGroup::Error,
                },
                HighlightedSpan {
                    range: 14..19,
                    group: HighlightGroup::Error,
                },
                HighlightedSpan {
                    range: 20..21,
                    group: HighlightGroup::Delimiter,
                },
            ],
        );
    }

    #[test]
    fn parses_trait_with_unclosed_brace() {
        let mut parser = Parser::new("trait A {");
        parse_trait(&mut parser);

        assert_eq!(
            parser.output,
            vec![
                HighlightedSpan {
                    range: 0..5,
                    group: HighlightGroup::OtherKeyword,
                },
                HighlightedSpan {
                    range: 6..7,
                    group: HighlightGroup::InterfaceDef,
                },
                HighlightedSpan {
                    range: 8..9,
                    group: HighlightGroup::Delimiter,
                },
            ],
        );
    }
}