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         match_arm(p);
 404     }
 405     p.expect(T!['}']);
 406     m.complete(p, MATCH_ARM_LIST);
 407 }
 408
 409 // test match_arm
 410 // fn foo() {
 411 //     match () {
 412 //         _ => (),
 413 //         _ if Test > Test{field: 0} => (),
 414 //         X | Y if Z => (),
 415 //         | X | Y if Z => (),
 416 //         | X => (),
 417 //     };
 418 // }
 419 fn match_arm(p: &mut Parser) {
 420     let m = p.start();
 421     // test match_arms_outer_attributes
 422     // fn foo() {
 423     //     match () {
 424     //         #[cfg(feature = "some")]
 425     //         _ => (),
 426     //         #[cfg(feature = "other")]
 427     //         _ => (),
 428     //         #[cfg(feature = "many")]
 429     //         #[cfg(feature = "attributes")]
 430     //         #[cfg(feature = "before")]
 431     //         _ => (),
 432     //     }
 433     // }
 434     attributes::outer_attrs(p);
 435
 436     patterns::pattern_top_r(p, TokenSet::EMPTY);
 437     if p.at(T![if]) {
 438         match_guard(p);
 439     }
 440     p.expect(T![=>]);
 441     let blocklike = expr_stmt(p).1;
 442
 443     // test match_arms_commas
 444     // fn foo() {
 445     //     match () {
 446     //         _ => (),
 447     //         _ => {}
 448     //         _ => ()
 449     //     }
 450     // }
 451     if !p.eat(T![,]) && !blocklike.is_block() && !p.at(T!['}']) {
 452         p.error("expected `,`");
 453     }
 454     m.complete(p, MATCH_ARM);
 455 }
 456
 457 // test match_guard
 458 // fn foo() {
 459 //     match () {
 460 //         _ if foo => (),
 461 //         _ if let foo = bar => (),
 462 //     }
 463 // }
 464 fn match_guard(p: &mut Parser) -> CompletedMarker {
 465     assert!(p.at(T![if]));
 466     let m = p.start();
 467     p.bump(T![if]);
 468     if p.eat(T![let]) {
 469         patterns::pattern_top(p);
 470         p.expect(T![=]);
 471     }
 472     expr(p);
 473     m.complete(p, MATCH_GUARD)
 474 }
 475
 476 // test block
 477 // fn a() {}
 478 // fn b() { let _ = 1; }
 479 // fn c() { 1; 2; }
 480 // fn d() { 1; 2 }
 481 pub(crate) fn block_expr(p: &mut Parser) {
 482     if !p.at(T!['{']) {
 483         p.error("expected a block");
 484         return;
 485     }
 486     block_expr_unchecked(p);
 487 }
 488
 489 fn block_expr_unchecked(p: &mut Parser) -> CompletedMarker {
 490     assert!(p.at(T!['{']));
 491     let m = p.start();
 492     p.bump(T!['{']);
 493     expr_block_contents(p);
 494     p.expect(T!['}']);
 495     m.complete(p, BLOCK_EXPR)
 496 }
 497
 498 // test return_expr
 499 // fn foo() {
 500 //     return;
 501 //     return 92;
 502 // }
 503 fn return_expr(p: &mut Parser) -> CompletedMarker {
 504     assert!(p.at(T![return]));
 505     let m = p.start();
 506     p.bump(T![return]);
 507     if p.at_ts(EXPR_FIRST) {
 508         expr(p);
 509     }
 510     m.complete(p, RETURN_EXPR)
 511 }
 512 // test yield_expr
 513 // fn foo() {
 514 //     yield;
 515 //     yield 1;
 516 // }
 517 fn yield_expr(p: &mut Parser) -> CompletedMarker {
 518     assert!(p.at(T![yield]));
 519     let m = p.start();
 520     p.bump(T![yield]);
 521     if p.at_ts(EXPR_FIRST) {
 522         expr(p);
 523     }
 524     m.complete(p, YIELD_EXPR)
 525 }
 526
 527 // test continue_expr
 528 // fn foo() {
 529 //     loop {
 530 //         continue;
 531 //         continue 'l;
 532 //     }
 533 // }
 534 fn continue_expr(p: &mut Parser) -> CompletedMarker {
 535     assert!(p.at(T![continue]));
 536     let m = p.start();
 537     p.bump(T![continue]);
 538     if p.at(LIFETIME_IDENT) {
 539         lifetime(p);
 540     }
 541     m.complete(p, CONTINUE_EXPR)
 542 }
 543
 544 // test break_expr
 545 // fn foo() {
 546 //     loop {
 547 //         break;
 548 //         break 'l;
 549 //         break 92;
 550 //         break 'l 92;
 551 //     }
 552 // }
 553 fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
 554     assert!(p.at(T![break]));
 555     let m = p.start();
 556     p.bump(T![break]);
 557     if p.at(LIFETIME_IDENT) {
 558         lifetime(p);
 559     }
 560     // test break_ambiguity
 561     // fn foo(){
 562     //     if break {}
 563     //     while break {}
 564     //     for i in break {}
 565     //     match break {}
 566     // }
 567     if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(T!['{'])) {
 568         expr(p);
 569     }
 570     m.complete(p, BREAK_EXPR)
 571 }
 572
 573 // test try_block_expr
 574 // fn foo() {
 575 //     let _ = try {};
 576 // }
 577 fn try_block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 578     assert!(p.at(T![try]));
 579     let m = m.unwrap_or_else(|| p.start());
 580     // Special-case `try!` as macro.
 581     // This is a hack until we do proper edition support
 582     if p.nth_at(1, T![!]) {
 583         // test try_macro_fallback
 584         // fn foo() { try!(Ok(())); }
 585         let path = p.start();
 586         let path_segment = p.start();
 587         let name_ref = p.start();
 588         p.bump_remap(IDENT);
 589         name_ref.complete(p, NAME_REF);
 590         path_segment.complete(p, PATH_SEGMENT);
 591         path.complete(p, PATH);
 592         let _block_like = items::macro_call_after_excl(p);
 593         return m.complete(p, MACRO_CALL);
 594     }
 595
 596     p.bump(T![try]);
 597     block_expr(p);
 598     m.complete(p, EFFECT_EXPR)
 599 }
 600
 601 // test box_expr
 602 // fn foo() {
 603 //     let x = box 1i32;
 604 //     let y = (box 1i32, box 2i32);
 605 //     let z = Foo(box 1i32, box 2i32);
 606 // }
 607 fn box_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 608     assert!(p.at(T![box]));
 609     let m = m.unwrap_or_else(|| p.start());
 610     p.bump(T![box]);
 611     if p.at_ts(EXPR_FIRST) {
 612         expr(p);
 613     }
 614     m.complete(p, BOX_EXPR)
 615 }
 616
 617 /// Expression from `$var` macro expansion, wrapped in dollars
 618 fn meta_var_expr(p: &mut Parser) -> CompletedMarker {
 619     assert!(p.at(L_DOLLAR));
 620     let m = p.start();
 621     p.bump(L_DOLLAR);
 622     let (completed, _is_block) =
 623         expr_bp(p, Restrictions { forbid_structs: false, prefer_stmt: false }, 1);
 624
 625     match (completed, p.current()) {
 626         (Some(it), R_DOLLAR) => {
 627             p.bump(R_DOLLAR);
 628             m.abandon(p);
 629             it
 630         }
 631         _ => {
 632             while !p.at(R_DOLLAR) {
 633                 p.bump_any()
 634             }
 635             p.bump(R_DOLLAR);
 636             m.complete(p, ERROR)
 637         }
 638     }
 639 }