crates/parser/src/grammar/expressions/atom.rs

   1 use super::*;
   2
   3 // test expr_literals
   4 // fn foo() {
   5 //     let _ = true;
   6 //     let _ = false;
   7 //     let _ = 1;
   8 //     let _ = 2.0;
   9 //     let _ = b'a';
  10 //     let _ = 'b';
  11 //     let _ = "c";
  12 //     let _ = r"d";
  13 //     let _ = b"e";
  14 //     let _ = br"f";
  15 // }
  16 pub(crate) const LITERAL_FIRST: TokenSet = TokenSet::new(&[
  17     T![true],
  18     T![false],
  19     INT_NUMBER,
  20     FLOAT_NUMBER,
  21     BYTE,
  22     CHAR,
  23     STRING,
  24     BYTE_STRING,
  25 ]);
  26
  27 pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> {
  28     if !p.at_ts(LITERAL_FIRST) {
  29         return None;
  30     }
  31     let m = p.start();
  32     p.bump_any();
  33     Some(m.complete(p, LITERAL))
  34 }
  35
  36 // E.g. for after the break in `if break {}`, this should not match
  37 pub(super) const ATOM_EXPR_FIRST: TokenSet =
  38     LITERAL_FIRST.union(paths::PATH_FIRST).union(TokenSet::new(&[
  39         T!['('],
  40         T!['{'],
  41         T!['['],
  42         L_DOLLAR,
  43         T![|],
  44         T![move],
  45         T![box],
  46         T![if],
  47         T![while],
  48         T![match],
  49         T![unsafe],
  50         T![return],
  51         T![yield],
  52         T![break],
  53         T![continue],
  54         T![async],
  55         T![try],
  56         T![const],
  57         T![loop],
  58         T![for],
  59         LIFETIME_IDENT,
  60     ]));
  61
  62 const EXPR_RECOVERY_SET: TokenSet = TokenSet::new(&[LET_KW, R_DOLLAR]);
  63
  64 pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
  65     if let Some(m) = literal(p) {
  66         return Some((m, BlockLike::NotBlock));
  67     }
  68     if paths::is_path_start(p) {
  69         return Some(path_expr(p, r));
  70     }
  71     let la = p.nth(1);
  72     let done = match p.current() {
  73         T!['('] => tuple_expr(p),
  74         T!['['] => array_expr(p),
  75         L_DOLLAR => meta_var_expr(p),
  76         T![|] => closure_expr(p),
  77         T![move] if la == T![|] => closure_expr(p),
  78         T![async] if la == T![|] || (la == T![move] && p.nth(2) == T![|]) => closure_expr(p),
  79         T![if] => if_expr(p),
  80
  81         T![loop] => loop_expr(p, None),
  82         T![box] => box_expr(p, None),
  83         T![for] => for_expr(p, None),
  84         T![while] => while_expr(p, None),
  85         T![try] => try_block_expr(p, None),
  86         LIFETIME_IDENT if la == T![:] => {
  87             let m = p.start();
  88             label(p);
  89             match p.current() {
  90                 T![loop] => loop_expr(p, Some(m)),
  91                 T![for] => for_expr(p, Some(m)),
  92                 T![while] => while_expr(p, Some(m)),
  93                 // test labeled_block
  94                 // fn f() { 'label: {}; }
  95                 T!['{'] => {
  96                     block_expr(p);
  97                     m.complete(p, EFFECT_EXPR)
  98                 }
  99                 _ => {
 100                     // test_err misplaced_label_err
 101                     // fn main() {
 102                     //     'loop: impl
 103                     // }
 104                     p.error("expected a loop");
 105                     m.complete(p, ERROR);
 106                     return None;
 107                 }
 108             }
 109         }
 110         T![async] if la == T!['{'] || (la == T![move] && p.nth(2) == T!['{']) => {
 111             let m = p.start();
 112             p.bump(T![async]);
 113             p.eat(T![move]);
 114             block_expr(p);
 115             m.complete(p, EFFECT_EXPR)
 116         }
 117         T![match] => match_expr(p),
 118         // test unsafe_block
 119         // fn f() { unsafe { } }
 120         T![unsafe] if la == T!['{'] => {
 121             let m = p.start();
 122             p.bump(T![unsafe]);
 123             block_expr(p);
 124             m.complete(p, EFFECT_EXPR)
 125         }
 126         // test const_block
 127         // fn f() { const { } }
 128         T![const] if la == T!['{'] => {
 129             let m = p.start();
 130             p.bump(T![const]);
 131             block_expr(p);
 132             m.complete(p, EFFECT_EXPR)
 133         }
 134         T!['{'] => {
 135             // test for_range_from
 136             // fn foo() {
 137             //    for x in 0 .. {
 138             //        break;
 139             //    }
 140             // }
 141             block_expr_unchecked(p)
 142         }
 143         T![return] => return_expr(p),
 144         T![yield] => yield_expr(p),
 145         T![continue] => continue_expr(p),
 146         T![break] => break_expr(p, r),
 147         _ => {
 148             p.err_recover("expected expression", EXPR_RECOVERY_SET);
 149             return None;
 150         }
 151     };
 152     let blocklike = match done.kind() {
 153         IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR | BLOCK_EXPR | EFFECT_EXPR => {
 154             BlockLike::Block
 155         }
 156         _ => BlockLike::NotBlock,
 157     };
 158     Some((done, blocklike))
 159 }
 160
 161 // test tuple_expr
 162 // fn foo() {
 163 //     ();
 164 //     (1);
 165 //     (1,);
 166 // }
 167 fn tuple_expr(p: &mut Parser) -> CompletedMarker {
 168     assert!(p.at(T!['(']));
 169     let m = p.start();
 170     p.expect(T!['(']);
 171
 172     let mut saw_comma = false;
 173     let mut saw_expr = false;
 174     while !p.at(EOF) && !p.at(T![')']) {
 175         saw_expr = true;
 176
 177         // test tuple_attrs
 178         // const A: (i64, i64) = (1, #[cfg(test)] 2);
 179         if !expr_with_attrs(p) {
 180             break;
 181         }
 182
 183         if !p.at(T![')']) {
 184             saw_comma = true;
 185             p.expect(T![,]);
 186         }
 187     }
 188     p.expect(T![')']);
 189     m.complete(p, if saw_expr && !saw_comma { PAREN_EXPR } else { TUPLE_EXPR })
 190 }
 191
 192 // test array_expr
 193 // fn foo() {
 194 //     [];
 195 //     [1];
 196 //     [1, 2,];
 197 //     [1; 2];
 198 // }
 199 fn array_expr(p: &mut Parser) -> CompletedMarker {
 200     assert!(p.at(T!['[']));
 201     let m = p.start();
 202
 203     let mut n_exprs = 0u32;
 204     let mut has_semi = false;
 205
 206     p.bump(T!['[']);
 207     while !p.at(EOF) && !p.at(T![']']) {
 208         n_exprs += 1;
 209
 210         // test array_attrs
 211         // const A: &[i64] = &[1, #[cfg(test)] 2];
 212         if !expr_with_attrs(p) {
 213             break;
 214         }
 215
 216         if n_exprs == 1 && p.eat(T![;]) {
 217             has_semi = true;
 218             continue;
 219         }
 220
 221         if has_semi || !p.at(T![']']) && !p.expect(T![,]) {
 222             break;
 223         }
 224     }
 225     p.expect(T![']']);
 226
 227     m.complete(p, ARRAY_EXPR)
 228 }
 229
 230 // test lambda_expr
 231 // fn foo() {
 232 //     || ();
 233 //     || -> i32 { 92 };
 234 //     |x| x;
 235 //     move |x: i32,| x;
 236 //     async || {};
 237 //     move || {};
 238 //     async move || {};
 239 // }
 240 fn closure_expr(p: &mut Parser) -> CompletedMarker {
 241     assert!(
 242         p.at(T![|])
 243             || (p.at(T![move]) && p.nth(1) == T![|])
 244             || (p.at(T![async]) && p.nth(1) == T![|])
 245             || (p.at(T![async]) && p.nth(1) == T![move] && p.nth(2) == T![|])
 246     );
 247     let m = p.start();
 248     p.eat(T![async]);
 249     p.eat(T![move]);
 250     params::param_list_closure(p);
 251     if opt_ret_type(p) {
 252         // test lambda_ret_block
 253         // fn main() { || -> i32 { 92 }(); }
 254         block_expr(p);
 255     } else if p.at_ts(EXPR_FIRST) {
 256         expr(p);
 257     } else {
 258         p.error("expected expression");
 259     }
 260     m.complete(p, CLOSURE_EXPR)
 261 }
 262
 263 // test if_expr
 264 // fn foo() {
 265 //     if true {};
 266 //     if true {} else {};
 267 //     if true {} else if false {} else {};
 268 //     if S {};
 269 //     if { true } { } else { };
 270 // }
 271 fn if_expr(p: &mut Parser) -> CompletedMarker {
 272     assert!(p.at(T![if]));
 273     let m = p.start();
 274     p.bump(T![if]);
 275     condition(p);
 276     block_expr(p);
 277     if p.at(T![else]) {
 278         p.bump(T![else]);
 279         if p.at(T![if]) {
 280             if_expr(p);
 281         } else {
 282             block_expr(p);
 283         }
 284     }
 285     m.complete(p, IF_EXPR)
 286 }
 287
 288 // test label
 289 // fn foo() {
 290 //     'a: loop {}
 291 //     'b: while true {}
 292 //     'c: for x in () {}
 293 // }
 294 fn label(p: &mut Parser) {
 295     assert!(p.at(LIFETIME_IDENT) && p.nth(1) == T![:]);
 296     let m = p.start();
 297     lifetime(p);
 298     p.bump_any();
 299     m.complete(p, LABEL);
 300 }
 301
 302 // test loop_expr
 303 // fn foo() {
 304 //     loop {};
 305 // }
 306 fn loop_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 307     assert!(p.at(T![loop]));
 308     let m = m.unwrap_or_else(|| p.start());
 309     p.bump(T![loop]);
 310     block_expr(p);
 311     m.complete(p, LOOP_EXPR)
 312 }
 313
 314 // test while_expr
 315 // fn foo() {
 316 //     while true {};
 317 //     while let Some(x) = it.next() {};
 318 //     while { true } {};
 319 // }
 320 fn while_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 321     assert!(p.at(T![while]));
 322     let m = m.unwrap_or_else(|| p.start());
 323     p.bump(T![while]);
 324     condition(p);
 325     block_expr(p);
 326     m.complete(p, WHILE_EXPR)
 327 }
 328
 329 // test for_expr
 330 // fn foo() {
 331 //     for x in [] {};
 332 // }
 333 fn for_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 334     assert!(p.at(T![for]));
 335     let m = m.unwrap_or_else(|| p.start());
 336     p.bump(T![for]);
 337     patterns::pattern(p);
 338     p.expect(T![in]);
 339     expr_no_struct(p);
 340     block_expr(p);
 341     m.complete(p, FOR_EXPR)
 342 }
 343
 344 // test cond
 345 // fn foo() { if let Some(_) = None {} }
 346 // fn bar() {
 347 //     if let Some(_) | Some(_) = None {}
 348 //     if let | Some(_) = None {}
 349 //     while let Some(_) | Some(_) = None {}
 350 //     while let | Some(_) = None {}
 351 // }
 352 fn condition(p: &mut Parser) {
 353     let m = p.start();
 354     if p.eat(T![let]) {
 355         patterns::pattern_top(p);
 356         p.expect(T![=]);
 357     }
 358     expr_no_struct(p);
 359     m.complete(p, CONDITION);
 360 }
 361
 362 // test match_expr
 363 // fn foo() {
 364 //     match () { };
 365 //     match S {};
 366 //     match { } { _ => () };
 367 //     match { S {} } {};
 368 // }
 369 fn match_expr(p: &mut Parser) -> CompletedMarker {
 370     assert!(p.at(T![match]));
 371     let m = p.start();
 372     p.bump(T![match]);
 373     expr_no_struct(p);
 374     if p.at(T!['{']) {
 375         match_arm_list(p);
 376     } else {
 377         p.error("expected `{`")
 378     }
 379     m.complete(p, MATCH_EXPR)
 380 }
 381
 382 pub(crate) fn match_arm_list(p: &mut Parser) {
 383     assert!(p.at(T!['{']));
 384     let m = p.start();
 385     p.eat(T!['{']);
 386
 387     // test match_arms_inner_attribute
 388     // fn foo() {
 389     //     match () {
 390     //         #![doc("Inner attribute")]
 391     //         #![doc("Can be")]
 392     //         #![doc("Stacked")]
 393     //         _ => (),
 394     //     }
 395     // }
 396     attributes::inner_attrs(p);
 397
 398     while !p.at(EOF) && !p.at(T!['}']) {
 399         if p.at(T!['{']) {
 400             error_block(p, "expected match arm");
 401             continue;
 402         }
 403
 404         // test match_arms_commas
 405         // fn foo() {
 406         //     match () {
 407         //         _ => (),
 408         //         _ => {}
 409         //         _ => ()
 410         //     }
 411         // }
 412         if match_arm(p).is_block() {
 413             p.eat(T![,]);
 414         } else if !p.at(T!['}']) {
 415             p.expect(T![,]);
 416         }
 417     }
 418     p.expect(T!['}']);
 419     m.complete(p, MATCH_ARM_LIST);
 420 }
 421
 422 // test match_arm
 423 // fn foo() {
 424 //     match () {
 425 //         _ => (),
 426 //         _ if Test > Test{field: 0} => (),
 427 //         X | Y if Z => (),
 428 //         | X | Y if Z => (),
 429 //         | X => (),
 430 //     };
 431 // }
 432 fn match_arm(p: &mut Parser) -> BlockLike {
 433     let m = p.start();
 434     // test match_arms_outer_attributes
 435     // fn foo() {
 436     //     match () {
 437     //         #[cfg(feature = "some")]
 438     //         _ => (),
 439     //         #[cfg(feature = "other")]
 440     //         _ => (),
 441     //         #[cfg(feature = "many")]
 442     //         #[cfg(feature = "attributes")]
 443     //         #[cfg(feature = "before")]
 444     //         _ => (),
 445     //     }
 446     // }
 447     attributes::outer_attrs(p);
 448
 449     patterns::pattern_top_r(p, TokenSet::EMPTY);
 450     if p.at(T![if]) {
 451         match_guard(p);
 452     }
 453     p.expect(T![=>]);
 454     let blocklike = expr_stmt(p).1;
 455     m.complete(p, MATCH_ARM);
 456     blocklike
 457 }
 458
 459 // test match_guard
 460 // fn foo() {
 461 //     match () {
 462 //         _ if foo => (),
 463 //     }
 464 // }
 465 fn match_guard(p: &mut Parser) -> CompletedMarker {
 466     assert!(p.at(T![if]));
 467     let m = p.start();
 468     p.bump(T![if]);
 469     expr(p);
 470     m.complete(p, MATCH_GUARD)
 471 }
 472
 473 // test block
 474 // fn a() {}
 475 // fn b() { let _ = 1; }
 476 // fn c() { 1; 2; }
 477 // fn d() { 1; 2 }
 478 pub(crate) fn block_expr(p: &mut Parser) {
 479     if !p.at(T!['{']) {
 480         p.error("expected a block");
 481         return;
 482     }
 483     block_expr_unchecked(p);
 484 }
 485
 486 fn block_expr_unchecked(p: &mut Parser) -> CompletedMarker {
 487     assert!(p.at(T!['{']));
 488     let m = p.start();
 489     p.bump(T!['{']);
 490     expr_block_contents(p);
 491     p.expect(T!['}']);
 492     m.complete(p, BLOCK_EXPR)
 493 }
 494
 495 // test return_expr
 496 // fn foo() {
 497 //     return;
 498 //     return 92;
 499 // }
 500 fn return_expr(p: &mut Parser) -> CompletedMarker {
 501     assert!(p.at(T![return]));
 502     let m = p.start();
 503     p.bump(T![return]);
 504     if p.at_ts(EXPR_FIRST) {
 505         expr(p);
 506     }
 507     m.complete(p, RETURN_EXPR)
 508 }
 509 // test yield_expr
 510 // fn foo() {
 511 //     yield;
 512 //     yield 1;
 513 // }
 514 fn yield_expr(p: &mut Parser) -> CompletedMarker {
 515     assert!(p.at(T![yield]));
 516     let m = p.start();
 517     p.bump(T![yield]);
 518     if p.at_ts(EXPR_FIRST) {
 519         expr(p);
 520     }
 521     m.complete(p, YIELD_EXPR)
 522 }
 523
 524 // test continue_expr
 525 // fn foo() {
 526 //     loop {
 527 //         continue;
 528 //         continue 'l;
 529 //     }
 530 // }
 531 fn continue_expr(p: &mut Parser) -> CompletedMarker {
 532     assert!(p.at(T![continue]));
 533     let m = p.start();
 534     p.bump(T![continue]);
 535     if p.at(LIFETIME_IDENT) {
 536         lifetime(p);
 537     }
 538     m.complete(p, CONTINUE_EXPR)
 539 }
 540
 541 // test break_expr
 542 // fn foo() {
 543 //     loop {
 544 //         break;
 545 //         break 'l;
 546 //         break 92;
 547 //         break 'l 92;
 548 //     }
 549 // }
 550 fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
 551     assert!(p.at(T![break]));
 552     let m = p.start();
 553     p.bump(T![break]);
 554     if p.at(LIFETIME_IDENT) {
 555         lifetime(p);
 556     }
 557     // test break_ambiguity
 558     // fn foo(){
 559     //     if break {}
 560     //     while break {}
 561     //     for i in break {}
 562     //     match break {}
 563     // }
 564     if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(T!['{'])) {
 565         expr(p);
 566     }
 567     m.complete(p, BREAK_EXPR)
 568 }
 569
 570 // test try_block_expr
 571 // fn foo() {
 572 //     let _ = try {};
 573 // }
 574 fn try_block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 575     assert!(p.at(T![try]));
 576     let m = m.unwrap_or_else(|| p.start());
 577     // Special-case `try!` as macro.
 578     // This is a hack until we do proper edition support
 579     if p.nth_at(1, T![!]) {
 580         // test try_macro_fallback
 581         // fn foo() { try!(Ok(())); }
 582         let path = p.start();
 583         let path_segment = p.start();
 584         let name_ref = p.start();
 585         p.bump_remap(IDENT);
 586         name_ref.complete(p, NAME_REF);
 587         path_segment.complete(p, PATH_SEGMENT);
 588         path.complete(p, PATH);
 589         let _block_like = items::macro_call_after_excl(p);
 590         return m.complete(p, MACRO_CALL);
 591     }
 592
 593     p.bump(T![try]);
 594     block_expr(p);
 595     m.complete(p, EFFECT_EXPR)
 596 }
 597
 598 // test box_expr
 599 // fn foo() {
 600 //     let x = box 1i32;
 601 //     let y = (box 1i32, box 2i32);
 602 //     let z = Foo(box 1i32, box 2i32);
 603 // }
 604 fn box_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 605     assert!(p.at(T![box]));
 606     let m = m.unwrap_or_else(|| p.start());
 607     p.bump(T![box]);
 608     if p.at_ts(EXPR_FIRST) {
 609         expr(p);
 610     }
 611     m.complete(p, BOX_EXPR)
 612 }
 613
 614 /// Expression from `$var` macro expansion, wrapped in dollars
 615 fn meta_var_expr(p: &mut Parser) -> CompletedMarker {
 616     assert!(p.at(L_DOLLAR));
 617     let m = p.start();
 618     p.bump(L_DOLLAR);
 619     let (completed, _is_block) =
 620         expr_bp(p, Restrictions { forbid_structs: false, prefer_stmt: false }, 1);
 621
 622     match (completed, p.current()) {
 623         (Some(it), R_DOLLAR) => {
 624             p.bump(R_DOLLAR);
 625             m.abandon(p);
 626             it
 627         }
 628         _ => {
 629             while !p.at(R_DOLLAR) {
 630                 p.bump_any()
 631             }
 632             p.bump(R_DOLLAR);
 633             m.complete(p, ERROR)
 634         }
 635     }
 636 }