diff options
Diffstat (limited to 'crates/ra_parser/src/grammar/patterns.rs')
-rw-r--r-- | crates/ra_parser/src/grammar/patterns.rs | 78 |
1 files changed, 39 insertions, 39 deletions
diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs index 12dd22bde..16ae9da63 100644 --- a/crates/ra_parser/src/grammar/patterns.rs +++ b/crates/ra_parser/src/grammar/patterns.rs | |||
@@ -16,10 +16,10 @@ pub(super) fn pattern_list(p: &mut Parser) { | |||
16 | /// Parses a pattern list separated by pipes `|` | 16 | /// Parses a pattern list separated by pipes `|` |
17 | /// using the given `recovery_set` | 17 | /// using the given `recovery_set` |
18 | pub(super) fn pattern_list_r(p: &mut Parser, recovery_set: TokenSet) { | 18 | pub(super) fn pattern_list_r(p: &mut Parser, recovery_set: TokenSet) { |
19 | p.eat(PIPE); | 19 | p.eat(T![|]); |
20 | pattern_r(p, recovery_set); | 20 | pattern_r(p, recovery_set); |
21 | 21 | ||
22 | while p.eat(PIPE) { | 22 | while p.eat(T![|]) { |
23 | pattern_r(p, recovery_set); | 23 | pattern_r(p, recovery_set); |
24 | } | 24 | } |
25 | } | 25 | } |
@@ -34,7 +34,7 @@ pub(super) fn pattern_r(p: &mut Parser, recovery_set: TokenSet) { | |||
34 | // 200 .. 301=> (), | 34 | // 200 .. 301=> (), |
35 | // } | 35 | // } |
36 | // } | 36 | // } |
37 | if p.at(DOTDOTDOT) || p.at(DOTDOTEQ) || p.at(DOTDOT) { | 37 | if p.at(T![...]) || p.at(T![..=]) || p.at(T![..]) { |
38 | let m = lhs.precede(p); | 38 | let m = lhs.precede(p); |
39 | p.bump(); | 39 | p.bump(); |
40 | atom_pat(p, recovery_set); | 40 | atom_pat(p, recovery_set); |
@@ -44,7 +44,7 @@ pub(super) fn pattern_r(p: &mut Parser, recovery_set: TokenSet) { | |||
44 | // fn main() { | 44 | // fn main() { |
45 | // let m!(x) = 0; | 45 | // let m!(x) = 0; |
46 | // } | 46 | // } |
47 | else if lhs.kind() == PATH_PAT && p.at(EXCL) { | 47 | else if lhs.kind() == PATH_PAT && p.at(T![!]) { |
48 | let m = lhs.precede(p); | 48 | let m = lhs.precede(p); |
49 | items::macro_call_after_excl(p); | 49 | items::macro_call_after_excl(p); |
50 | m.complete(p, MACRO_CALL); | 50 | m.complete(p, MACRO_CALL); |
@@ -58,9 +58,9 @@ const PAT_RECOVERY_SET: TokenSet = | |||
58 | fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> { | 58 | fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> { |
59 | let la0 = p.nth(0); | 59 | let la0 = p.nth(0); |
60 | let la1 = p.nth(1); | 60 | let la1 = p.nth(1); |
61 | if la0 == REF_KW | 61 | if la0 == T![ref] |
62 | || la0 == MUT_KW | 62 | || la0 == T![mut] |
63 | || (la0 == IDENT && !(la1 == COLONCOLON || la1 == L_PAREN || la1 == L_CURLY || la1 == EXCL)) | 63 | || (la0 == IDENT && !(la1 == T![::] || la1 == T!['('] || la1 == T!['{'] || la1 == T![!])) |
64 | { | 64 | { |
65 | return Some(bind_pat(p, true)); | 65 | return Some(bind_pat(p, true)); |
66 | } | 66 | } |
@@ -73,10 +73,10 @@ fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> { | |||
73 | } | 73 | } |
74 | 74 | ||
75 | let m = match la0 { | 75 | let m = match la0 { |
76 | UNDERSCORE => placeholder_pat(p), | 76 | T![_] => placeholder_pat(p), |
77 | AMP => ref_pat(p), | 77 | T![&] => ref_pat(p), |
78 | L_PAREN => tuple_pat(p), | 78 | T!['('] => tuple_pat(p), |
79 | L_BRACK => slice_pat(p), | 79 | T!['['] => slice_pat(p), |
80 | _ => { | 80 | _ => { |
81 | p.err_recover("expected pattern", recovery_set); | 81 | p.err_recover("expected pattern", recovery_set); |
82 | return None; | 82 | return None; |
@@ -86,7 +86,7 @@ fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> { | |||
86 | } | 86 | } |
87 | 87 | ||
88 | fn is_literal_pat_start(p: &mut Parser) -> bool { | 88 | fn is_literal_pat_start(p: &mut Parser) -> bool { |
89 | p.at(MINUS) && (p.nth(1) == INT_NUMBER || p.nth(1) == FLOAT_NUMBER) | 89 | p.at(T![-]) && (p.nth(1) == INT_NUMBER || p.nth(1) == FLOAT_NUMBER) |
90 | || p.at_ts(expressions::LITERAL_FIRST) | 90 | || p.at_ts(expressions::LITERAL_FIRST) |
91 | } | 91 | } |
92 | 92 | ||
@@ -102,7 +102,7 @@ fn is_literal_pat_start(p: &mut Parser) -> bool { | |||
102 | fn literal_pat(p: &mut Parser) -> CompletedMarker { | 102 | fn literal_pat(p: &mut Parser) -> CompletedMarker { |
103 | assert!(is_literal_pat_start(p)); | 103 | assert!(is_literal_pat_start(p)); |
104 | let m = p.start(); | 104 | let m = p.start(); |
105 | if p.at(MINUS) { | 105 | if p.at(T![-]) { |
106 | p.bump(); | 106 | p.bump(); |
107 | } | 107 | } |
108 | expressions::literal(p); | 108 | expressions::literal(p); |
@@ -121,11 +121,11 @@ fn path_pat(p: &mut Parser) -> CompletedMarker { | |||
121 | let m = p.start(); | 121 | let m = p.start(); |
122 | paths::expr_path(p); | 122 | paths::expr_path(p); |
123 | let kind = match p.current() { | 123 | let kind = match p.current() { |
124 | L_PAREN => { | 124 | T!['('] => { |
125 | tuple_pat_fields(p); | 125 | tuple_pat_fields(p); |
126 | TUPLE_STRUCT_PAT | 126 | TUPLE_STRUCT_PAT |
127 | } | 127 | } |
128 | L_CURLY => { | 128 | T!['{'] => { |
129 | field_pat_list(p); | 129 | field_pat_list(p); |
130 | STRUCT_PAT | 130 | STRUCT_PAT |
131 | } | 131 | } |
@@ -142,10 +142,10 @@ fn path_pat(p: &mut Parser) -> CompletedMarker { | |||
142 | // let S(_, .. , x) = (); | 142 | // let S(_, .. , x) = (); |
143 | // } | 143 | // } |
144 | fn tuple_pat_fields(p: &mut Parser) { | 144 | fn tuple_pat_fields(p: &mut Parser) { |
145 | assert!(p.at(L_PAREN)); | 145 | assert!(p.at(T!['('])); |
146 | p.bump(); | 146 | p.bump(); |
147 | pat_list(p, R_PAREN); | 147 | pat_list(p, T![')']); |
148 | p.expect(R_PAREN); | 148 | p.expect(T![')']); |
149 | } | 149 | } |
150 | 150 | ||
151 | // test field_pat_list | 151 | // test field_pat_list |
@@ -156,29 +156,29 @@ fn tuple_pat_fields(p: &mut Parser) { | |||
156 | // let S { h: _, } = (); | 156 | // let S { h: _, } = (); |
157 | // } | 157 | // } |
158 | fn field_pat_list(p: &mut Parser) { | 158 | fn field_pat_list(p: &mut Parser) { |
159 | assert!(p.at(L_CURLY)); | 159 | assert!(p.at(T!['{'])); |
160 | let m = p.start(); | 160 | let m = p.start(); |
161 | p.bump(); | 161 | p.bump(); |
162 | while !p.at(EOF) && !p.at(R_CURLY) { | 162 | while !p.at(EOF) && !p.at(T!['}']) { |
163 | match p.current() { | 163 | match p.current() { |
164 | DOTDOT => p.bump(), | 164 | T![..] => p.bump(), |
165 | IDENT if p.nth(1) == COLON => field_pat(p), | 165 | IDENT if p.nth(1) == T![:] => field_pat(p), |
166 | L_CURLY => error_block(p, "expected ident"), | 166 | T!['{'] => error_block(p, "expected ident"), |
167 | _ => { | 167 | _ => { |
168 | bind_pat(p, false); | 168 | bind_pat(p, false); |
169 | } | 169 | } |
170 | } | 170 | } |
171 | if !p.at(R_CURLY) { | 171 | if !p.at(T!['}']) { |
172 | p.expect(COMMA); | 172 | p.expect(T![,]); |
173 | } | 173 | } |
174 | } | 174 | } |
175 | p.expect(R_CURLY); | 175 | p.expect(T!['}']); |
176 | m.complete(p, FIELD_PAT_LIST); | 176 | m.complete(p, FIELD_PAT_LIST); |
177 | } | 177 | } |
178 | 178 | ||
179 | fn field_pat(p: &mut Parser) { | 179 | fn field_pat(p: &mut Parser) { |
180 | assert!(p.at(IDENT)); | 180 | assert!(p.at(IDENT)); |
181 | assert!(p.nth(1) == COLON); | 181 | assert!(p.nth(1) == T![:]); |
182 | 182 | ||
183 | let m = p.start(); | 183 | let m = p.start(); |
184 | name(p); | 184 | name(p); |
@@ -190,7 +190,7 @@ fn field_pat(p: &mut Parser) { | |||
190 | // test placeholder_pat | 190 | // test placeholder_pat |
191 | // fn main() { let _ = (); } | 191 | // fn main() { let _ = (); } |
192 | fn placeholder_pat(p: &mut Parser) -> CompletedMarker { | 192 | fn placeholder_pat(p: &mut Parser) -> CompletedMarker { |
193 | assert!(p.at(UNDERSCORE)); | 193 | assert!(p.at(T![_])); |
194 | let m = p.start(); | 194 | let m = p.start(); |
195 | p.bump(); | 195 | p.bump(); |
196 | m.complete(p, PLACEHOLDER_PAT) | 196 | m.complete(p, PLACEHOLDER_PAT) |
@@ -202,10 +202,10 @@ fn placeholder_pat(p: &mut Parser) -> CompletedMarker { | |||
202 | // let &mut b = (); | 202 | // let &mut b = (); |
203 | // } | 203 | // } |
204 | fn ref_pat(p: &mut Parser) -> CompletedMarker { | 204 | fn ref_pat(p: &mut Parser) -> CompletedMarker { |
205 | assert!(p.at(AMP)); | 205 | assert!(p.at(T![&])); |
206 | let m = p.start(); | 206 | let m = p.start(); |
207 | p.bump(); | 207 | p.bump(); |
208 | p.eat(MUT_KW); | 208 | p.eat(T![mut]); |
209 | pattern(p); | 209 | pattern(p); |
210 | m.complete(p, REF_PAT) | 210 | m.complete(p, REF_PAT) |
211 | } | 211 | } |
@@ -215,7 +215,7 @@ fn ref_pat(p: &mut Parser) -> CompletedMarker { | |||
215 | // let (a, b, ..) = (); | 215 | // let (a, b, ..) = (); |
216 | // } | 216 | // } |
217 | fn tuple_pat(p: &mut Parser) -> CompletedMarker { | 217 | fn tuple_pat(p: &mut Parser) -> CompletedMarker { |
218 | assert!(p.at(L_PAREN)); | 218 | assert!(p.at(T!['('])); |
219 | let m = p.start(); | 219 | let m = p.start(); |
220 | tuple_pat_fields(p); | 220 | tuple_pat_fields(p); |
221 | m.complete(p, TUPLE_PAT) | 221 | m.complete(p, TUPLE_PAT) |
@@ -226,18 +226,18 @@ fn tuple_pat(p: &mut Parser) -> CompletedMarker { | |||
226 | // let [a, b, ..] = []; | 226 | // let [a, b, ..] = []; |
227 | // } | 227 | // } |
228 | fn slice_pat(p: &mut Parser) -> CompletedMarker { | 228 | fn slice_pat(p: &mut Parser) -> CompletedMarker { |
229 | assert!(p.at(L_BRACK)); | 229 | assert!(p.at(T!['['])); |
230 | let m = p.start(); | 230 | let m = p.start(); |
231 | p.bump(); | 231 | p.bump(); |
232 | pat_list(p, R_BRACK); | 232 | pat_list(p, T![']']); |
233 | p.expect(R_BRACK); | 233 | p.expect(T![']']); |
234 | m.complete(p, SLICE_PAT) | 234 | m.complete(p, SLICE_PAT) |
235 | } | 235 | } |
236 | 236 | ||
237 | fn pat_list(p: &mut Parser, ket: SyntaxKind) { | 237 | fn pat_list(p: &mut Parser, ket: SyntaxKind) { |
238 | while !p.at(EOF) && !p.at(ket) { | 238 | while !p.at(EOF) && !p.at(ket) { |
239 | match p.current() { | 239 | match p.current() { |
240 | DOTDOT => p.bump(), | 240 | T![..] => p.bump(), |
241 | _ => { | 241 | _ => { |
242 | if !p.at_ts(PATTERN_FIRST) { | 242 | if !p.at_ts(PATTERN_FIRST) { |
243 | p.error("expected a pattern"); | 243 | p.error("expected a pattern"); |
@@ -247,7 +247,7 @@ fn pat_list(p: &mut Parser, ket: SyntaxKind) { | |||
247 | } | 247 | } |
248 | } | 248 | } |
249 | if !p.at(ket) { | 249 | if !p.at(ket) { |
250 | p.expect(COMMA); | 250 | p.expect(T![,]); |
251 | } | 251 | } |
252 | } | 252 | } |
253 | } | 253 | } |
@@ -263,10 +263,10 @@ fn pat_list(p: &mut Parser, ket: SyntaxKind) { | |||
263 | // } | 263 | // } |
264 | fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker { | 264 | fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker { |
265 | let m = p.start(); | 265 | let m = p.start(); |
266 | p.eat(REF_KW); | 266 | p.eat(T![ref]); |
267 | p.eat(MUT_KW); | 267 | p.eat(T![mut]); |
268 | name(p); | 268 | name(p); |
269 | if with_at && p.eat(AT) { | 269 | if with_at && p.eat(T![@]) { |
270 | pattern(p); | 270 | pattern(p); |
271 | } | 271 | } |
272 | m.complete(p, BIND_PAT) | 272 | m.complete(p, BIND_PAT) |