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

mod fn_;
mod struct_;
mod trait_;

use crate::Parser;
use dialect::HighlightGroup;
use fn_::parse_fn;
use struct_::parse_struct;
use trait_::parse_trait;

pub(crate) fn parse_item(p: &mut Parser) {
    while let Some(token) = p.peek() {
        match token.kind {
            crate::TokenKind::Fn => {
                parse_fn(p);
                break;
            }
            crate::TokenKind::Struct => {
                parse_struct(p);
                break;
            }
            crate::TokenKind::Trait => {
                parse_trait(p);
                break;
            }

            crate::TokenKind::CloseBrace => {
                break;
            }
            _ => p.eat(HighlightGroup::Error),
        }
    }
}

// Most of these tests just check if each item’s parser has been hooked in correctly by looking at
// the first HighlightedSpan found, rather than checking the entire parser output.
#[cfg(test)]
mod tests {
    use super::*;
    use dialect::HighlightedSpan;
    use pretty_assertions::assert_eq;

    fn test(input: &str, expected_group: HighlightGroup) {
        let mut parser = Parser::new(input);
        parse_item(&mut parser);

        assert_eq!(parser.output[0].group, expected_group);
    }

    #[test]
    fn parses_function() {
        test("fn a() {}", HighlightGroup::OtherKeyword);
    }

    #[test]
    fn parses_struct() {
        test("struct Parser;", HighlightGroup::OtherKeyword);
    }

    #[test]
    fn parses_trait() {
        test("trait Marker {}", HighlightGroup::OtherKeyword);
    }

    #[test]
    fn eats_errors_until_finds_valid_keyword() {
        let mut parser = Parser::new("error blah fn");
        parse_item(&mut parser);

        assert_eq!(
            parser.output,
            vec![
                HighlightedSpan {
                    range: 0..5,
                    group: HighlightGroup::Error,
                },
                HighlightedSpan {
                    range: 6..10,
                    group: HighlightGroup::Error,
                },
                HighlightedSpan {
                    range: 11..13,
                    group: HighlightGroup::OtherKeyword,
                },
            ],
        );
    }

    #[test]
    fn eats_errors_until_close_brace() {
        let mut parser = Parser::new("invalid item }");
        parse_item(&mut parser);

        assert_eq!(
            parser.output,
            vec![
                HighlightedSpan {
                    range: 0..7,
                    group: HighlightGroup::Error,
                },
                HighlightedSpan {
                    range: 8..12,
                    group: HighlightGroup::Error,
                },
            ],
        );
    }
}