lalrpop 0.4.0

convenient LR(1) 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

use super::{Tok, Tokenizer};
use super::Tok::*;

fn test(input: &str,
        expected: Vec<(&str, Tok)>)
{
    // use $ to signal EOL because it can be replaced with a single space
    // for spans, and because it applies also to r#XXX# style strings:
    let input = input.replace("$", "\n");

    let tokenizer = Tokenizer::new(&input, 0);
    let len = expected.len();
    for (token, (expected_span, expected_tok)) in tokenizer.zip(expected.into_iter()) {
        println!("token: {:?}", token);
        let expected_start = expected_span.find("~").unwrap();
        let expected_end = expected_span.rfind("~").unwrap() + 1;
        assert_eq!(Ok((expected_start, expected_tok, expected_end)), token);
    }

    let tokenizer = Tokenizer::new(&input, 0);
    assert_eq!(None, tokenizer.skip(len).next());
}

#[test]
fn basic() {
    test("extern foo", vec![
        ("~~~~~~    ", Extern),
        ("       ~~~", Id("foo")),
    ]);
}

#[test]
fn eol_comment() {
    test("extern // This is a comment$ foo", vec![
        ("~~~~~~                          ", Extern),
        ("                             ~~~", Id("foo")),
    ]);
}

#[test]
fn code1() {
    test("=> a(b, c),", vec![
        ("~~~~~~~~~~ ", EqualsGreaterThanCode(" a(b, c)")),
        ("          ~", Comma),
    ]);
}

#[test]
fn code2() {
    test("=>? a(b, c),", vec![
        ("~~~~~~~~~~~ ", EqualsGreaterThanQuestionCode(" a(b, c)")),
        ("           ~", Comma),
    ]);
}

#[test]
#[should_panic]
fn code_forgot_comma() {
    test("=> a(b, c),", vec![
        ("~~~~~~~~~~ ", EqualsGreaterThanCode(" a(b, c)")),
        // intentionally forget the comma token; this is more of a test of `test`
    ]);
}

#[test]
fn various_kinds_of_ids() {
    test("foo<T<'a,U,`Z*{}`>>", vec![
        ("~~~                ", MacroId("foo")),
        ("   ~               ", LessThan),
        ("    ~              ", MacroId("T")),
        ("     ~             ", LessThan),
        ("      ~~           ", Lifetime("'a")),
        ("        ~          ", Comma),
        ("         ~         ", Id("U")),
        ("          ~        ", Comma),
        ("           ~~~~~~  ", Escape("Z*{}")),
        ("                 ~ ", GreaterThan),
        ("                  ~", GreaterThan),
    ]);
}

#[test]
fn string_literals() {
    test(r#"foo "bar\"\n" baz"#, vec![
        (r#"~~~              "#, Id("foo")),
        (r#"    ~~~~~~~~~    "#, StringLiteral(r#"bar\"\n"#)),
        (r#"              ~~~"#, Id("baz")),
    ]);
}

#[test]
fn use1() {
    test(r#"use foo::bar; baz"#, vec![
        (r#"~~~~~~~~~~~~     "#, Use(" foo::bar")),
        (r#"            ~    "#, Semi),
        (r#"              ~~~"#, Id("baz")),
    ]);
}

#[test]
fn use2() {
    test(r#"use {foo,bar}; baz"#, vec![
        (r#"~~~~~~~~~~~~~     "#, Use(" {foo,bar}")),
        (r#"             ~    "#, Semi),
        (r#"               ~~~"#, Id("baz")),
    ]);
}

#[test]
fn where1() {
    test(r#"where <foo,bar>,baz;"#, vec![
        (r#"~~~~~~~~~~~~~~~~~~~ "#, Where(vec![" <foo,bar>", "baz"])),
        (r#"                   ~"#, Semi),
    ]);
}