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
use proc_macro2::{Ident, TokenStream, TokenTree};
use crate::parser::Parser;
use crate::util::is_punct;
#[derive(Clone, Copy, PartialEq, Eq, Default)]
pub struct IgnoreFlags {
pub ignore_case: bool,
}
impl IgnoreFlags {
/// Parses an identifier and enables it for `self`.
///
/// Valid inputs are (that produces `true`):
/// * `"case"`
///
/// An error causes this function to return `false` and emits an error to
/// the given `Parser`.
fn parse_ident(&mut self, ident: Ident, parser: &mut Parser) -> bool {
match ident.to_string().as_str() {
"case" => {
self.ignore_case = true;
true
}
"ascii_case" => {
parser.err(
"\
The flag \"ascii_case\" is no longer supported\
",
ident.span(),
);
false
}
unknown => {
parser.err(
format!(
"\
Unknown flag: {unknown}\n\
\n\
Expected one of: case\
"
),
ident.span(),
);
false
}
}
}
pub fn parse_group(&mut self, name: Ident, tokens: TokenStream, parser: &mut Parser) {
let mut tokens = tokens.into_iter();
let mut found_flag = false;
loop {
match tokens.next() {
Some(TokenTree::Ident(ident)) => {
if self.parse_ident(ident, parser) {
found_flag = true;
} else {
return;
}
}
None if found_flag => return,
_ => {
parser.err(
"\
Invalid ignore flag\n\
\n\
Expected one of: case\
",
name.span(),
);
return;
}
}
match tokens.next() {
Some(tt) if is_punct(&tt, ',') => {}
None => return,
Some(unexpected_tt) => {
parser.err(
format!(
"\
Unexpected token: {:?}\
",
unexpected_tt.to_string(),
),
unexpected_tt.span(),
);
return;
}
};
}
}
}