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
|
use crate::{LexedStr, PrefixEntryPoint, Step};
#[test]
fn vis() {
check(PrefixEntryPoint::Vis, "pub(crate) fn foo() {}", "pub(crate)");
check(PrefixEntryPoint::Vis, "fn foo() {}", "");
check(PrefixEntryPoint::Vis, "pub(fn foo() {}", "pub");
check(PrefixEntryPoint::Vis, "pub(crate fn foo() {}", "pub(crate");
check(PrefixEntryPoint::Vis, "crate fn foo() {}", "crate");
}
#[test]
fn block() {
check(PrefixEntryPoint::Block, "{}, 92", "{}");
check(PrefixEntryPoint::Block, "{, 92)", "{, 92)");
check(PrefixEntryPoint::Block, "()", "");
}
#[test]
fn stmt() {
check(PrefixEntryPoint::Stmt, "92; fn", "92");
check(PrefixEntryPoint::Stmt, "let _ = 92; 1", "let _ = 92");
check(PrefixEntryPoint::Stmt, "pub fn f() {} = 92", "pub fn f() {}");
check(PrefixEntryPoint::Stmt, "struct S;;", "struct S;");
check(PrefixEntryPoint::Stmt, "fn f() {};", "fn f() {}");
check(PrefixEntryPoint::Stmt, ";;;", ";");
check(PrefixEntryPoint::Stmt, "+", "+");
check(PrefixEntryPoint::Stmt, "@", "@");
check(PrefixEntryPoint::Stmt, "loop {} - 1", "loop {}");
}
#[test]
fn pat() {
check(PrefixEntryPoint::Pat, "x y", "x");
check(PrefixEntryPoint::Pat, "fn f() {}", "fn");
// FIXME: This one is wrong, we should consume only one pattern.
check(PrefixEntryPoint::Pat, ".. ..", ".. ..");
}
#[test]
fn ty() {
check(PrefixEntryPoint::Ty, "fn() foo", "fn()");
check(PrefixEntryPoint::Ty, "Clone + Copy + fn", "Clone + Copy +");
check(PrefixEntryPoint::Ty, "struct f", "struct");
}
#[test]
fn expr() {
check(PrefixEntryPoint::Expr, "92 92", "92");
check(PrefixEntryPoint::Expr, "+1", "+");
check(PrefixEntryPoint::Expr, "-1", "-1");
check(PrefixEntryPoint::Expr, "fn foo() {}", "fn");
check(PrefixEntryPoint::Expr, "#[attr] ()", "#[attr] ()");
}
#[test]
fn path() {
check(PrefixEntryPoint::Path, "foo::bar baz", "foo::bar");
check(PrefixEntryPoint::Path, "foo::<> baz", "foo::<>");
check(PrefixEntryPoint::Path, "foo<> baz", "foo<>");
check(PrefixEntryPoint::Path, "Fn() -> i32?", "Fn() -> i32");
// FIXME: This shouldn't be accepted as path actually.
check(PrefixEntryPoint::Path, "<_>::foo", "<_>::foo");
}
#[test]
fn item() {
// FIXME: This shouldn't consume the semicolon.
check(PrefixEntryPoint::Item, "fn foo() {};", "fn foo() {};");
check(PrefixEntryPoint::Item, "#[attr] pub struct S {} 92", "#[attr] pub struct S {}");
check(PrefixEntryPoint::Item, "item!{}?", "item!{}");
check(PrefixEntryPoint::Item, "????", "?");
}
#[test]
fn meta_item() {
check(PrefixEntryPoint::MetaItem, "attr, ", "attr");
check(PrefixEntryPoint::MetaItem, "attr(some token {stream});", "attr(some token {stream})");
check(PrefixEntryPoint::MetaItem, "path::attr = 2 * 2!", "path::attr = 2 * 2");
}
#[track_caller]
fn check(entry: PrefixEntryPoint, input: &str, prefix: &str) {
let lexed = LexedStr::new(input);
let input = lexed.to_input();
let mut n_tokens = 0;
for step in entry.parse(&input).iter() {
match step {
Step::Token { n_input_tokens, .. } => n_tokens += n_input_tokens as usize,
Step::Enter { .. } | Step::Exit | Step::Error { .. } => (),
}
}
let mut i = 0;
loop {
if n_tokens == 0 {
break;
}
if !lexed.kind(i).is_trivia() {
n_tokens -= 1;
}
i += 1;
}
let buf = &lexed.as_str()[..lexed.text_start(i)];
assert_eq!(buf, prefix);
}
|
