diff options
author | Aleksey Kladov <[email protected]> | 2018-08-10 20:33:29 +0100 |
---|---|---|
committer | Aleksey Kladov <[email protected]> | 2018-08-10 20:33:29 +0100 |
commit | 7c67612b8a894187fa3b64725531a5459f9211bf (patch) | |
tree | 9e2a536efa0c880d921fd8d4d74423afc9451fd4 /crates/libsyntax2/src/grammar/expressions/mod.rs | |
parent | 26262aaf05983c5b7f41cc438e287523268fe1eb (diff) |
organizize
Diffstat (limited to 'crates/libsyntax2/src/grammar/expressions/mod.rs')
-rw-r--r-- | crates/libsyntax2/src/grammar/expressions/mod.rs | 379 |
1 files changed, 379 insertions, 0 deletions
diff --git a/crates/libsyntax2/src/grammar/expressions/mod.rs b/crates/libsyntax2/src/grammar/expressions/mod.rs new file mode 100644 index 000000000..dcbb1e2a8 --- /dev/null +++ b/crates/libsyntax2/src/grammar/expressions/mod.rs | |||
@@ -0,0 +1,379 @@ | |||
1 | mod atom; | ||
2 | |||
3 | use super::*; | ||
4 | pub(super) use self::atom::literal; | ||
5 | |||
6 | const EXPR_FIRST: TokenSet = LHS_FIRST; | ||
7 | |||
8 | pub(super) fn expr(p: &mut Parser) -> BlockLike { | ||
9 | let r = Restrictions { forbid_structs: false, prefer_stmt: false }; | ||
10 | expr_bp(p, r, 1) | ||
11 | } | ||
12 | |||
13 | pub(super) fn expr_stmt(p: &mut Parser) -> BlockLike { | ||
14 | let r = Restrictions { forbid_structs: false, prefer_stmt: true }; | ||
15 | expr_bp(p, r, 1) | ||
16 | } | ||
17 | |||
18 | fn expr_no_struct(p: &mut Parser) { | ||
19 | let r = Restrictions { forbid_structs: true, prefer_stmt: false }; | ||
20 | expr_bp(p, r, 1); | ||
21 | } | ||
22 | |||
23 | // test block | ||
24 | // fn a() {} | ||
25 | // fn b() { let _ = 1; } | ||
26 | // fn c() { 1; 2; } | ||
27 | // fn d() { 1; 2 } | ||
28 | pub(super) fn block(p: &mut Parser) { | ||
29 | if !p.at(L_CURLY) { | ||
30 | p.error("expected block"); | ||
31 | return; | ||
32 | } | ||
33 | atom::block_expr(p); | ||
34 | } | ||
35 | |||
36 | #[derive(Clone, Copy)] | ||
37 | struct Restrictions { | ||
38 | forbid_structs: bool, | ||
39 | prefer_stmt: bool, | ||
40 | } | ||
41 | |||
42 | enum Op { | ||
43 | Simple, | ||
44 | Composite(SyntaxKind, u8), | ||
45 | } | ||
46 | |||
47 | fn current_op(p: &Parser) -> (u8, Op) { | ||
48 | if p.at_compound2(PLUS, EQ) { | ||
49 | return (1, Op::Composite(PLUSEQ, 2)); | ||
50 | } | ||
51 | if p.at_compound2(MINUS, EQ) { | ||
52 | return (1, Op::Composite(MINUSEQ, 2)); | ||
53 | } | ||
54 | if p.at_compound3(L_ANGLE, L_ANGLE, EQ) { | ||
55 | return (1, Op::Composite(SHLEQ, 3)); | ||
56 | } | ||
57 | if p.at_compound3(R_ANGLE, R_ANGLE, EQ) { | ||
58 | return (1, Op::Composite(SHREQ, 3)); | ||
59 | } | ||
60 | if p.at_compound2(PIPE, PIPE) { | ||
61 | return (3, Op::Composite(PIPEPIPE, 2)); | ||
62 | } | ||
63 | if p.at_compound2(AMP, AMP) { | ||
64 | return (4, Op::Composite(AMPAMP, 2)); | ||
65 | } | ||
66 | if p.at_compound2(L_ANGLE, EQ) { | ||
67 | return (5, Op::Composite(LTEQ, 2)); | ||
68 | } | ||
69 | if p.at_compound2(R_ANGLE, EQ) { | ||
70 | return (5, Op::Composite(GTEQ, 2)); | ||
71 | } | ||
72 | if p.at_compound2(L_ANGLE, L_ANGLE) { | ||
73 | return (9, Op::Composite(SHL, 2)); | ||
74 | } | ||
75 | if p.at_compound2(R_ANGLE, R_ANGLE) { | ||
76 | return (9, Op::Composite(SHR, 2)); | ||
77 | } | ||
78 | |||
79 | let bp = match p.current() { | ||
80 | EQ => 1, | ||
81 | DOTDOT => 2, | ||
82 | EQEQ | NEQ | L_ANGLE | R_ANGLE => 5, | ||
83 | PIPE => 6, | ||
84 | CARET => 7, | ||
85 | AMP => 8, | ||
86 | MINUS | PLUS => 10, | ||
87 | STAR | SLASH | PERCENT => 11, | ||
88 | _ => 0, | ||
89 | }; | ||
90 | (bp, Op::Simple) | ||
91 | } | ||
92 | |||
93 | // Parses expression with binding power of at least bp. | ||
94 | fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike { | ||
95 | let mut lhs = match lhs(p, r) { | ||
96 | Some(lhs) => { | ||
97 | // test stmt_bin_expr_ambiguity | ||
98 | // fn foo() { | ||
99 | // let _ = {1} & 2; | ||
100 | // {1} &2; | ||
101 | // } | ||
102 | if r.prefer_stmt && is_block(lhs.kind()) { | ||
103 | return BlockLike::Block; | ||
104 | } | ||
105 | lhs | ||
106 | } | ||
107 | None => return BlockLike::NotBlock, | ||
108 | }; | ||
109 | |||
110 | loop { | ||
111 | let is_range = p.current() == DOTDOT; | ||
112 | let (op_bp, op) = current_op(p); | ||
113 | if op_bp < bp { | ||
114 | break; | ||
115 | } | ||
116 | let m = lhs.precede(p); | ||
117 | match op { | ||
118 | Op::Simple => p.bump(), | ||
119 | Op::Composite(kind, n) => { | ||
120 | p.bump_compound(kind, n); | ||
121 | } | ||
122 | } | ||
123 | expr_bp(p, r, op_bp + 1); | ||
124 | lhs = m.complete(p, if is_range { RANGE_EXPR } else { BIN_EXPR }); | ||
125 | } | ||
126 | BlockLike::NotBlock | ||
127 | } | ||
128 | |||
129 | // test no_semi_after_block | ||
130 | // fn foo() { | ||
131 | // if true {} | ||
132 | // loop {} | ||
133 | // match () {} | ||
134 | // while true {} | ||
135 | // for _ in () {} | ||
136 | // {} | ||
137 | // {} | ||
138 | // } | ||
139 | fn is_block(kind: SyntaxKind) -> bool { | ||
140 | match kind { | ||
141 | IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR | BLOCK_EXPR => true, | ||
142 | _ => false, | ||
143 | } | ||
144 | } | ||
145 | |||
146 | const LHS_FIRST: TokenSet = | ||
147 | token_set_union![ | ||
148 | token_set![AMP, STAR, EXCL, DOTDOT, MINUS], | ||
149 | atom::ATOM_EXPR_FIRST, | ||
150 | ]; | ||
151 | |||
152 | fn lhs(p: &mut Parser, r: Restrictions) -> Option<CompletedMarker> { | ||
153 | let m; | ||
154 | let kind = match p.current() { | ||
155 | // test ref_expr | ||
156 | // fn foo() { | ||
157 | // let _ = &1; | ||
158 | // let _ = &mut &f(); | ||
159 | // } | ||
160 | AMP => { | ||
161 | m = p.start(); | ||
162 | p.bump(); | ||
163 | p.eat(MUT_KW); | ||
164 | REF_EXPR | ||
165 | } | ||
166 | // test unary_expr | ||
167 | // fn foo() { | ||
168 | // **&1; | ||
169 | // !!true; | ||
170 | // --1; | ||
171 | // } | ||
172 | STAR | EXCL | MINUS => { | ||
173 | m = p.start(); | ||
174 | p.bump(); | ||
175 | PREFIX_EXPR | ||
176 | } | ||
177 | DOTDOT => { | ||
178 | m = p.start(); | ||
179 | p.bump(); | ||
180 | expr_bp(p, r, 2); | ||
181 | return Some(m.complete(p, RANGE_EXPR)); | ||
182 | } | ||
183 | _ => { | ||
184 | let lhs = atom::atom_expr(p, r)?; | ||
185 | return Some(postfix_expr(p, r, lhs)); | ||
186 | } | ||
187 | }; | ||
188 | expr_bp(p, r, 255); | ||
189 | Some(m.complete(p, kind)) | ||
190 | } | ||
191 | |||
192 | fn postfix_expr(p: &mut Parser, r: Restrictions, mut lhs: CompletedMarker) -> CompletedMarker { | ||
193 | let mut allow_calls = !r.prefer_stmt || !is_block(lhs.kind()); | ||
194 | loop { | ||
195 | lhs = match p.current() { | ||
196 | // test stmt_postfix_expr_ambiguity | ||
197 | // fn foo() { | ||
198 | // match () { | ||
199 | // _ => {} | ||
200 | // () => {} | ||
201 | // [] => {} | ||
202 | // } | ||
203 | // } | ||
204 | L_PAREN if allow_calls => call_expr(p, lhs), | ||
205 | L_BRACK if allow_calls => index_expr(p, lhs), | ||
206 | DOT if p.nth(1) == IDENT => if p.nth(2) == L_PAREN || p.nth(2) == COLONCOLON { | ||
207 | method_call_expr(p, lhs) | ||
208 | } else { | ||
209 | field_expr(p, lhs) | ||
210 | }, | ||
211 | DOT if p.nth(1) == INT_NUMBER => field_expr(p, lhs), | ||
212 | // test postfix_range | ||
213 | // fn foo() { let x = 1..; } | ||
214 | DOTDOT if !EXPR_FIRST.contains(p.nth(1)) => { | ||
215 | let m = lhs.precede(p); | ||
216 | p.bump(); | ||
217 | m.complete(p, RANGE_EXPR) | ||
218 | } | ||
219 | QUESTION => try_expr(p, lhs), | ||
220 | AS_KW => cast_expr(p, lhs), | ||
221 | _ => break, | ||
222 | }; | ||
223 | allow_calls = true | ||
224 | } | ||
225 | lhs | ||
226 | } | ||
227 | |||
228 | // test call_expr | ||
229 | // fn foo() { | ||
230 | // let _ = f(); | ||
231 | // let _ = f()(1)(1, 2,); | ||
232 | // } | ||
233 | fn call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker { | ||
234 | assert!(p.at(L_PAREN)); | ||
235 | let m = lhs.precede(p); | ||
236 | arg_list(p); | ||
237 | m.complete(p, CALL_EXPR) | ||
238 | } | ||
239 | |||
240 | // test index_expr | ||
241 | // fn foo() { | ||
242 | // x[1][2]; | ||
243 | // } | ||
244 | fn index_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker { | ||
245 | assert!(p.at(L_BRACK)); | ||
246 | let m = lhs.precede(p); | ||
247 | p.bump(); | ||
248 | expr(p); | ||
249 | p.expect(R_BRACK); | ||
250 | m.complete(p, INDEX_EXPR) | ||
251 | } | ||
252 | |||
253 | // test method_call_expr | ||
254 | // fn foo() { | ||
255 | // x.foo(); | ||
256 | // y.bar::<T>(1, 2,); | ||
257 | // } | ||
258 | fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker { | ||
259 | assert!( | ||
260 | p.at(DOT) && p.nth(1) == IDENT | ||
261 | && (p.nth(2) == L_PAREN || p.nth(2) == COLONCOLON) | ||
262 | ); | ||
263 | let m = lhs.precede(p); | ||
264 | p.bump(); | ||
265 | name_ref(p); | ||
266 | type_args::type_arg_list(p, true); | ||
267 | arg_list(p); | ||
268 | m.complete(p, METHOD_CALL_EXPR) | ||
269 | } | ||
270 | |||
271 | // test field_expr | ||
272 | // fn foo() { | ||
273 | // x.foo; | ||
274 | // x.0.bar; | ||
275 | // } | ||
276 | fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker { | ||
277 | assert!(p.at(DOT) && (p.nth(1) == IDENT || p.nth(1) == INT_NUMBER)); | ||
278 | let m = lhs.precede(p); | ||
279 | p.bump(); | ||
280 | if p.at(IDENT) { | ||
281 | name_ref(p) | ||
282 | } else { | ||
283 | p.bump() | ||
284 | } | ||
285 | m.complete(p, FIELD_EXPR) | ||
286 | } | ||
287 | |||
288 | // test try_expr | ||
289 | // fn foo() { | ||
290 | // x?; | ||
291 | // } | ||
292 | fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker { | ||
293 | assert!(p.at(QUESTION)); | ||
294 | let m = lhs.precede(p); | ||
295 | p.bump(); | ||
296 | m.complete(p, TRY_EXPR) | ||
297 | } | ||
298 | |||
299 | // test cast_expr | ||
300 | // fn foo() { | ||
301 | // 82 as i32; | ||
302 | // } | ||
303 | fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker { | ||
304 | assert!(p.at(AS_KW)); | ||
305 | let m = lhs.precede(p); | ||
306 | p.bump(); | ||
307 | types::type_(p); | ||
308 | m.complete(p, CAST_EXPR) | ||
309 | } | ||
310 | |||
311 | fn arg_list(p: &mut Parser) { | ||
312 | assert!(p.at(L_PAREN)); | ||
313 | let m = p.start(); | ||
314 | p.bump(); | ||
315 | while !p.at(R_PAREN) && !p.at(EOF) { | ||
316 | expr(p); | ||
317 | if !p.at(R_PAREN) && !p.expect(COMMA) { | ||
318 | break; | ||
319 | } | ||
320 | } | ||
321 | p.eat(R_PAREN); | ||
322 | m.complete(p, ARG_LIST); | ||
323 | } | ||
324 | |||
325 | // test path_expr | ||
326 | // fn foo() { | ||
327 | // let _ = a; | ||
328 | // let _ = a::b; | ||
329 | // let _ = ::a::<b>; | ||
330 | // let _ = format!(); | ||
331 | // } | ||
332 | fn path_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker { | ||
333 | assert!(paths::is_path_start(p)); | ||
334 | let m = p.start(); | ||
335 | paths::expr_path(p); | ||
336 | match p.current() { | ||
337 | L_CURLY if !r.forbid_structs => { | ||
338 | struct_lit(p); | ||
339 | m.complete(p, STRUCT_LIT) | ||
340 | } | ||
341 | EXCL => { | ||
342 | items::macro_call_after_excl(p); | ||
343 | m.complete(p, MACRO_CALL) | ||
344 | } | ||
345 | _ => m.complete(p, PATH_EXPR) | ||
346 | } | ||
347 | } | ||
348 | |||
349 | // test struct_lit | ||
350 | // fn foo() { | ||
351 | // S {}; | ||
352 | // S { x, y: 32, }; | ||
353 | // S { x, y: 32, ..Default::default() }; | ||
354 | // } | ||
355 | fn struct_lit(p: &mut Parser) { | ||
356 | assert!(p.at(L_CURLY)); | ||
357 | p.bump(); | ||
358 | while !p.at(EOF) && !p.at(R_CURLY) { | ||
359 | match p.current() { | ||
360 | IDENT => { | ||
361 | let m = p.start(); | ||
362 | name_ref(p); | ||
363 | if p.eat(COLON) { | ||
364 | expr(p); | ||
365 | } | ||
366 | m.complete(p, STRUCT_LIT_FIELD); | ||
367 | } | ||
368 | DOTDOT => { | ||
369 | p.bump(); | ||
370 | expr(p); | ||
371 | } | ||
372 | _ => p.err_and_bump("expected identifier"), | ||
373 | } | ||
374 | if !p.at(R_CURLY) { | ||
375 | p.expect(COMMA); | ||
376 | } | ||
377 | } | ||
378 | p.expect(R_CURLY); | ||
379 | } | ||