rust/crates/ra_parser/src/grammar/expressions.rs

634 lines
17 KiB
Rust
Raw Normal View History

2018-08-04 08:58:22 -05:00
mod atom;
pub(crate) use self::atom::match_arm_list;
pub(super) use self::atom::{literal, LITERAL_FIRST};
use super::*;
2018-08-04 08:58:22 -05:00
2019-04-18 14:49:56 -05:00
pub(super) enum StmtWithSemi {
Yes,
No,
Optional,
}
2018-08-07 06:24:03 -05:00
const EXPR_FIRST: TokenSet = LHS_FIRST;
2018-08-04 08:58:22 -05:00
2018-08-07 08:32:09 -05:00
pub(super) fn expr(p: &mut Parser) -> BlockLike {
2019-02-08 05:49:43 -06:00
let r = Restrictions { forbid_structs: false, prefer_stmt: false };
let mut dollar_lvl = 0;
expr_bp(p, r, 1, &mut dollar_lvl).1
2018-08-07 09:00:45 -05:00
}
pub(super) fn expr_stmt(p: &mut Parser) -> (Option<CompletedMarker>, BlockLike) {
2019-02-08 05:49:43 -06:00
let r = Restrictions { forbid_structs: false, prefer_stmt: true };
let mut dollar_lvl = 0;
expr_bp(p, r, 1, &mut dollar_lvl)
2018-08-04 09:12:00 -05:00
}
fn expr_no_struct(p: &mut Parser) {
2019-02-08 05:49:43 -06:00
let r = Restrictions { forbid_structs: true, prefer_stmt: false };
let mut dollar_lvl = 0;
expr_bp(p, r, 1, &mut dollar_lvl);
2018-08-04 08:58:22 -05:00
}
// test block
// fn a() {}
// fn b() { let _ = 1; }
// fn c() { 1; 2; }
// fn d() { 1; 2 }
2018-08-25 05:17:54 -05:00
pub(crate) fn block(p: &mut Parser) {
2019-05-15 07:35:47 -05:00
if !p.at(T!['{']) {
2018-08-25 05:21:43 -05:00
p.error("expected a block");
return;
}
2019-09-02 11:33:02 -05:00
atom::block_expr(p, None);
}
pub(crate) fn naked_block(p: &mut Parser) {
assert!(p.at(T!['{']));
2018-08-24 11:27:30 -05:00
let m = p.start();
2019-09-09 16:59:29 -05:00
p.bump_any();
2019-03-04 05:17:31 -06:00
expr_block_contents(p);
2019-05-15 07:35:47 -05:00
p.expect(T!['}']);
2019-03-04 05:17:31 -06:00
m.complete(p, BLOCK);
}
fn is_expr_stmt_attr_allowed(kind: SyntaxKind) -> bool {
match kind {
BIN_EXPR | RANGE_EXPR | IF_EXPR => false,
_ => true,
}
}
2019-04-18 14:49:56 -05:00
pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
2019-04-16 23:34:43 -05:00
// test block_items
// fn a() { fn b() {} }
let m = p.start();
// test attr_on_expr_stmt
// fn foo() {
// #[A] foo();
// #[B] bar!{}
// #[C] #[D] {}
// #[D] return ();
// }
2019-05-15 07:35:47 -05:00
let has_attrs = p.at(T![#]);
2019-04-16 23:34:43 -05:00
attributes::outer_attributes(p);
2018-12-20 12:39:38 -06:00
2019-05-15 07:35:47 -05:00
if p.at(T![let]) {
2019-04-16 23:34:43 -05:00
let_stmt(p, m, with_semi);
return;
}
let m = match items::maybe_item(p, m, items::ItemFlavor::Mod) {
Ok(()) => return,
Err(m) => m,
};
let (cm, blocklike) = expr_stmt(p);
let kind = cm.as_ref().map(|cm| cm.kind()).unwrap_or(ERROR);
2019-03-17 05:14:17 -05:00
2019-04-16 23:34:43 -05:00
if has_attrs && !is_expr_stmt_attr_allowed(kind) {
// test_err attr_on_expr_not_allowed
// fn foo() {
2019-04-16 23:34:43 -05:00
// #[A] 1 + 2;
// #[B] if true {};
// }
2019-04-16 23:34:43 -05:00
p.error(format!("attributes are not allowed on {:?}", kind));
}
2019-05-15 07:35:47 -05:00
if p.at(T!['}']) {
2019-04-16 23:34:43 -05:00
// test attr_on_last_expr_in_block
// fn foo() {
// { #[A] bar!()? }
// #[B] &()
// }
if let Some(cm) = cm {
cm.undo_completion(p).abandon(p);
m.complete(p, kind);
} else {
2019-04-16 23:34:43 -05:00
m.abandon(p);
}
} else {
// test no_semi_after_block
// fn foo() {
// if true {}
// loop {}
// match () {}
// while true {}
// for _ in () {}
// {}
// {}
// macro_rules! test {
// () => {}
// }
// test!{}
// }
2019-04-18 14:49:56 -05:00
match with_semi {
StmtWithSemi::Yes => {
if blocklike.is_block() {
2019-05-15 07:35:47 -05:00
p.eat(T![;]);
2019-04-18 14:49:56 -05:00
} else {
2019-05-15 07:35:47 -05:00
p.expect(T![;]);
2019-04-18 14:49:56 -05:00
}
}
StmtWithSemi::No => {}
StmtWithSemi::Optional => {
2019-05-15 07:35:47 -05:00
if p.at(T![;]) {
p.eat(T![;]);
2019-04-18 14:49:56 -05:00
}
2018-08-24 11:27:30 -05:00
}
}
2019-04-18 14:49:56 -05:00
2019-04-16 23:34:43 -05:00
m.complete(p, EXPR_STMT);
2018-08-24 11:27:30 -05:00
}
// test let_stmt
2018-08-24 11:27:30 -05:00
// fn foo() {
// let a;
// let b: i32;
// let c = 92;
// let d: i32 = 92;
// let e: !;
// let _: ! = {};
2018-08-24 11:27:30 -05:00
// }
2019-04-18 14:49:56 -05:00
fn let_stmt(p: &mut Parser, m: Marker, with_semi: StmtWithSemi) {
2019-05-15 07:35:47 -05:00
assert!(p.at(T![let]));
2019-09-09 16:59:29 -05:00
p.bump_any();
2018-08-24 11:27:30 -05:00
patterns::pattern(p);
2019-05-15 07:35:47 -05:00
if p.at(T![:]) {
2018-08-24 11:27:30 -05:00
types::ascription(p);
}
2019-05-15 07:35:47 -05:00
if p.eat(T![=]) {
2018-08-24 11:27:30 -05:00
expressions::expr(p);
}
2019-04-16 23:34:43 -05:00
2019-04-18 14:49:56 -05:00
match with_semi {
StmtWithSemi::Yes => {
2019-05-15 07:35:47 -05:00
p.expect(T![;]);
2019-04-18 14:49:56 -05:00
}
StmtWithSemi::No => {}
StmtWithSemi::Optional => {
2019-05-15 07:35:47 -05:00
if p.at(T![;]) {
p.eat(T![;]);
2019-04-18 14:49:56 -05:00
}
}
2019-04-16 23:34:43 -05:00
}
2018-08-24 11:27:30 -05:00
m.complete(p, LET_STMT);
2018-08-04 08:58:22 -05:00
}
}
2019-04-16 23:34:43 -05:00
pub(crate) fn expr_block_contents(p: &mut Parser) {
// This is checked by a validator
attributes::inner_attributes(p);
2019-05-15 07:35:47 -05:00
while !p.at(EOF) && !p.at(T!['}']) {
2019-04-16 23:34:43 -05:00
// test nocontentexpr
// fn foo(){
// ;;;some_expr();;;;{;;;};;;;Ok(())
// }
2019-06-25 22:36:14 -05:00
// test nocontentexpr_after_item
// fn simple_function() {
// enum LocalEnum {
// One,
// Two,
// };
// fn f() {};
// struct S {};
// }
2019-09-09 05:23:37 -05:00
if p.at(T![;]) {
2019-09-09 16:59:29 -05:00
p.bump_any();
2019-04-16 23:34:43 -05:00
continue;
}
2019-04-18 14:49:56 -05:00
stmt(p, StmtWithSemi::Yes)
2019-04-16 23:34:43 -05:00
}
}
2018-08-04 09:12:00 -05:00
#[derive(Clone, Copy)]
struct Restrictions {
2018-08-07 09:00:45 -05:00
forbid_structs: bool,
prefer_stmt: bool,
2018-08-04 09:12:00 -05:00
}
/// Binding powers of operators for a Pratt parser.
///
/// See https://www.oilshell.org/blog/2016/11/03.html
#[rustfmt::skip]
fn current_op(p: &Parser) -> (u8, SyntaxKind) {
const NOT_AN_OP: (u8, SyntaxKind) = (0, T![@]);
match p.current() {
T![|] if p.at(T![||]) => (3, T![||]),
T![|] if p.at(T![|=]) => (1, T![|=]),
T![|] => (6, T![|]),
T![>] if p.at(T![>>=]) => (1, T![>>=]),
T![>] if p.at(T![>>]) => (9, T![>>]),
T![>] if p.at(T![>=]) => (5, T![>=]),
T![>] => (5, T![>]),
T![=] if p.at(T![=>]) => NOT_AN_OP,
T![=] if p.at(T![==]) => (5, T![==]),
T![=] => (1, T![=]),
T![<] if p.at(T![<=]) => (5, T![<=]),
T![<] if p.at(T![<<=]) => (1, T![<<=]),
T![<] if p.at(T![<<]) => (9, T![<<]),
T![<] => (5, T![<]),
T![+] if p.at(T![+=]) => (1, T![+=]),
T![+] => (10, T![+]),
T![^] if p.at(T![^=]) => (1, T![^=]),
T![^] => (7, T![^]),
T![%] if p.at(T![%=]) => (1, T![%=]),
T![%] => (11, T![%]),
T![&] if p.at(T![&=]) => (1, T![&=]),
T![&] if p.at(T![&&]) => (4, T![&&]),
T![&] => (8, T![&]),
T![/] if p.at(T![/=]) => (1, T![/=]),
T![/] => (11, T![/]),
T![*] if p.at(T![*=]) => (1, T![*=]),
T![*] => (11, T![*]),
T![.] if p.at(T![..=]) => (2, T![..=]),
T![.] if p.at(T![..]) => (2, T![..]),
T![!] if p.at(T![!=]) => (5, T![!=]),
T![-] if p.at(T![-=]) => (1, T![-=]),
T![-] => (10, T![-]),
_ => NOT_AN_OP
2018-08-07 06:24:03 -05:00
}
2018-08-04 08:58:22 -05:00
}
// Parses expression with binding power of at least bp.
fn expr_bp(
p: &mut Parser,
r: Restrictions,
mut bp: u8,
dollar_lvl: &mut usize,
) -> (Option<CompletedMarker>, BlockLike) {
// `newly_dollar_open` is a flag indicated that dollar is just closed after lhs, e.g.
// `$1$ + a`
// We use this flag to skip handling it.
2019-04-26 10:42:56 -05:00
let mut newly_dollar_open = if p.at_l_dollar() {
*dollar_lvl += p.eat_l_dollars();
2019-04-26 10:42:56 -05:00
true
} else {
false
};
let mut lhs = match lhs(p, r, dollar_lvl) {
Some((lhs, blocklike)) => {
2018-08-07 09:00:45 -05:00
// test stmt_bin_expr_ambiguity
// fn foo() {
// let _ = {1} & 2;
// {1} &2;
// }
if r.prefer_stmt && blocklike.is_block() {
return (Some(lhs), BlockLike::Block);
2018-08-07 09:00:45 -05:00
}
2018-08-07 08:32:09 -05:00
lhs
2018-08-07 09:00:45 -05:00
}
None => return (None, BlockLike::NotBlock),
2018-08-04 08:58:22 -05:00
};
loop {
if *dollar_lvl > 0 && p.at_r_dollar() {
*dollar_lvl -= p.eat_r_dollars(*dollar_lvl);
if !newly_dollar_open {
// We "pump" bp for make it highest priority
bp = 255;
}
newly_dollar_open = false;
}
2019-09-09 05:23:37 -05:00
let is_range = p.at(T![..]) || p.at(T![..=]);
2018-08-05 08:09:25 -05:00
let (op_bp, op) = current_op(p);
2018-08-04 08:58:22 -05:00
if op_bp < bp {
break;
}
2018-08-07 07:21:15 -05:00
let m = lhs.precede(p);
p.bump(op);
expr_bp(p, r, op_bp + 1, dollar_lvl);
2018-08-07 07:21:15 -05:00
lhs = m.complete(p, if is_range { RANGE_EXPR } else { BIN_EXPR });
2018-08-04 08:58:22 -05:00
}
(Some(lhs), BlockLike::NotBlock)
2018-08-07 08:32:09 -05:00
}
const LHS_FIRST: TokenSet = atom::ATOM_EXPR_FIRST.union(token_set![AMP, STAR, EXCL, DOT, MINUS]);
2018-08-04 08:58:22 -05:00
fn lhs(
p: &mut Parser,
r: Restrictions,
dollar_lvl: &mut usize,
) -> Option<(CompletedMarker, BlockLike)> {
2018-08-04 09:12:00 -05:00
let m;
let kind = match p.current() {
// test ref_expr
// fn foo() {
// let _ = &1;
// let _ = &mut &f();
// }
2019-05-15 07:35:47 -05:00
T![&] => {
2018-08-04 09:12:00 -05:00
m = p.start();
2019-09-09 16:59:29 -05:00
p.bump_any();
2019-05-15 07:35:47 -05:00
p.eat(T![mut]);
2018-08-04 09:12:00 -05:00
REF_EXPR
2018-08-05 08:15:40 -05:00
}
2018-08-07 06:56:33 -05:00
// test unary_expr
2018-08-04 09:12:00 -05:00
// fn foo() {
// **&1;
// !!true;
2018-08-07 06:24:03 -05:00
// --1;
// }
2019-05-15 07:35:47 -05:00
T![*] | T![!] | T![-] => {
2018-08-07 06:24:03 -05:00
m = p.start();
2019-09-09 16:59:29 -05:00
p.bump_any();
2018-08-07 06:52:03 -05:00
PREFIX_EXPR
2018-08-07 06:24:03 -05:00
}
2018-08-04 08:58:22 -05:00
_ => {
// test full_range_expr
// fn foo() { xs[..]; }
for &op in [T![..=], T![..]].iter() {
if p.at(op) {
m = p.start();
p.bump(op);
if p.at_ts(EXPR_FIRST) {
expr_bp(p, r, 2, dollar_lvl);
}
return Some((m.complete(p, RANGE_EXPR), BlockLike::NotBlock));
}
}
2019-08-13 05:17:10 -05:00
// test expression_after_block
// fn foo() {
// let mut p = F{x: 5};
// {p}.x = 10;
// }
//
let (lhs, blocklike) = atom::atom_expr(p, r)?;
2019-08-03 06:57:07 -05:00
return Some(postfix_expr(p, lhs, blocklike, !(r.prefer_stmt && blocklike.is_block())));
2018-08-04 08:58:22 -05:00
}
};
expr_bp(p, r, 255, dollar_lvl);
Some((m.complete(p, kind), BlockLike::NotBlock))
2018-08-04 08:58:22 -05:00
}
fn postfix_expr(
p: &mut Parser,
mut lhs: CompletedMarker,
// Calls are disallowed if the type is a block and we prefer statements because the call cannot be disambiguated from a tuple
// E.g. `while true {break}();` is parsed as
// `while true {break}; ();`
2019-08-03 06:57:07 -05:00
mut block_like: BlockLike,
mut allow_calls: bool,
2019-08-03 06:57:07 -05:00
) -> (CompletedMarker, BlockLike) {
2018-08-04 08:58:22 -05:00
loop {
lhs = match p.current() {
2018-08-07 09:00:45 -05:00
// test stmt_postfix_expr_ambiguity
// fn foo() {
// match () {
// _ => {}
// () => {}
// [] => {}
// }
// }
2019-05-15 07:35:47 -05:00
T!['('] if allow_calls => call_expr(p, lhs),
T!['['] if allow_calls => index_expr(p, lhs),
T![.] => match postfix_dot_expr(p, lhs) {
Ok(it) => it,
Err(it) => {
lhs = it;
break;
}
},
2019-05-15 07:35:47 -05:00
T![?] => try_expr(p, lhs),
T![as] => cast_expr(p, lhs),
2018-08-04 08:58:22 -05:00
_ => break,
2018-08-07 09:00:45 -05:00
};
2019-08-03 06:57:07 -05:00
allow_calls = true;
block_like = BlockLike::NotBlock;
2018-08-04 08:58:22 -05:00
}
return (lhs, block_like);
fn postfix_dot_expr(
p: &mut Parser,
lhs: CompletedMarker,
) -> Result<CompletedMarker, CompletedMarker> {
assert!(p.at(T![.]));
if p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth_at(2, T![::])) {
return Ok(method_call_expr(p, lhs));
}
// test await_expr
// fn foo() {
// x.await;
// x.0.await;
// x.0().await?.hello();
// }
if p.nth(1) == T![await] {
let m = lhs.precede(p);
p.bump(T![.]);
p.bump(T![await]);
return Ok(m.complete(p, AWAIT_EXPR));
}
// test postfix_range
// fn foo() { let x = 1..; }
for &(op, la) in [(T![..=], 3), (T![..], 2)].iter() {
if p.at(op) {
return if EXPR_FIRST.contains(p.nth(la)) {
Err(lhs)
} else {
let m = lhs.precede(p);
p.bump(op);
Ok(m.complete(p, RANGE_EXPR))
};
}
}
Ok(field_expr(p, lhs))
}
2018-08-04 08:58:22 -05:00
}
// test call_expr
// fn foo() {
// let _ = f();
// let _ = f()(1)(1, 2,);
// let _ = f(<Foo>::func());
// f(<Foo as Trait>::func());
2018-08-04 08:58:22 -05:00
// }
fn call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
2019-05-15 07:35:47 -05:00
assert!(p.at(T!['(']));
2018-08-04 08:58:22 -05:00
let m = lhs.precede(p);
arg_list(p);
m.complete(p, CALL_EXPR)
}
2018-08-05 09:24:44 -05:00
// test index_expr
// fn foo() {
// x[1][2];
// }
fn index_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
2019-05-15 07:35:47 -05:00
assert!(p.at(T!['[']));
2018-08-05 09:24:44 -05:00
let m = lhs.precede(p);
2019-09-09 16:59:29 -05:00
p.bump_any();
2018-08-05 09:24:44 -05:00
expr(p);
2019-05-15 07:35:47 -05:00
p.expect(T![']']);
2018-08-05 09:24:44 -05:00
m.complete(p, INDEX_EXPR)
}
2018-08-04 08:58:22 -05:00
// test method_call_expr
// fn foo() {
// x.foo();
2018-08-05 08:15:40 -05:00
// y.bar::<T>(1, 2,);
2018-08-04 08:58:22 -05:00
// }
fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
assert!(p.at(T![.]) && p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth_at(2, T![::])));
2018-08-04 08:58:22 -05:00
let m = lhs.precede(p);
2019-09-09 16:59:29 -05:00
p.bump_any();
2019-08-09 05:16:47 -05:00
name_ref(p);
2018-08-23 18:14:10 -05:00
type_args::opt_type_arg_list(p, true);
2019-05-15 07:35:47 -05:00
if p.at(T!['(']) {
2018-08-13 10:46:43 -05:00
arg_list(p);
}
2018-08-04 08:58:22 -05:00
m.complete(p, METHOD_CALL_EXPR)
}
// test field_expr
// fn foo() {
// x.foo;
// x.0.bar;
2019-04-05 15:34:45 -05:00
// x.0();
// }
// test_err bad_tuple_index_expr
// fn foo() {
// x.0.;
// x.1i32;
// x.0x01;
2018-08-04 08:58:22 -05:00
// }
2019-06-04 00:43:12 -05:00
#[allow(clippy::if_same_then_else)]
2018-08-04 08:58:22 -05:00
fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
2019-05-15 07:35:47 -05:00
assert!(p.at(T![.]));
2018-08-04 08:58:22 -05:00
let m = lhs.precede(p);
2019-09-09 16:59:29 -05:00
p.bump_any();
2019-08-09 05:16:47 -05:00
if p.at(IDENT) || p.at(INT_NUMBER) {
name_ref_or_index(p)
2019-04-05 15:34:45 -05:00
} else if p.at(FLOAT_NUMBER) {
2019-05-15 07:35:47 -05:00
// FIXME: How to recover and instead parse INT + T![.]?
2019-09-09 16:59:29 -05:00
p.bump_any();
} else {
p.error("expected field name or number")
2018-08-04 08:58:22 -05:00
}
m.complete(p, FIELD_EXPR)
}
// test try_expr
// fn foo() {
// x?;
// }
fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
2019-05-15 07:35:47 -05:00
assert!(p.at(T![?]));
2018-08-04 08:58:22 -05:00
let m = lhs.precede(p);
2019-09-09 16:59:29 -05:00
p.bump_any();
2018-08-04 08:58:22 -05:00
m.complete(p, TRY_EXPR)
}
2018-08-06 19:55:16 -05:00
// test cast_expr
// fn foo() {
// 82 as i32;
// 81 as i8 + 1;
// 79 as i16 - 1;
2019-03-30 06:44:58 -05:00
// 0x36 as u8 <= 0x37;
2018-08-06 19:55:16 -05:00
// }
fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
2019-05-15 07:35:47 -05:00
assert!(p.at(T![as]));
2018-08-06 19:55:16 -05:00
let m = lhs.precede(p);
2019-09-09 16:59:29 -05:00
p.bump_any();
// Use type_no_bounds(), because cast expressions are not
// allowed to have bounds.
types::type_no_bounds(p);
2018-08-06 19:55:16 -05:00
m.complete(p, CAST_EXPR)
}
2018-08-04 08:58:22 -05:00
fn arg_list(p: &mut Parser) {
2019-05-15 07:35:47 -05:00
assert!(p.at(T!['(']));
2018-08-04 08:58:22 -05:00
let m = p.start();
2019-09-09 16:59:29 -05:00
p.bump_any();
2019-05-15 07:35:47 -05:00
while !p.at(T![')']) && !p.at(EOF) {
2018-09-08 02:38:53 -05:00
if !p.at_ts(EXPR_FIRST) {
2018-09-08 02:13:32 -05:00
p.error("expected expression");
break;
}
2018-08-04 08:58:22 -05:00
expr(p);
2019-05-15 07:35:47 -05:00
if !p.at(T![')']) && !p.expect(T![,]) {
2018-08-04 08:58:22 -05:00
break;
}
}
2019-05-15 07:35:47 -05:00
p.eat(T![')']);
2018-08-04 08:58:22 -05:00
m.complete(p, ARG_LIST);
}
// test path_expr
// fn foo() {
// let _ = a;
// let _ = a::b;
// let _ = ::a::<b>;
2018-08-05 06:16:38 -05:00
// let _ = format!();
2018-08-04 08:58:22 -05:00
// }
fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
assert!(paths::is_path_start(p));
2018-08-04 08:58:22 -05:00
let m = p.start();
paths::expr_path(p);
match p.current() {
2019-05-15 07:35:47 -05:00
T!['{'] if !r.forbid_structs => {
2019-08-23 07:55:21 -05:00
record_field_list(p);
(m.complete(p, RECORD_LIT), BlockLike::NotBlock)
2018-08-05 06:16:38 -05:00
}
T![!] if !p.at(T![!=]) => {
let block_like = items::macro_call_after_excl(p);
2019-04-26 10:42:56 -05:00
(m.complete(p, MACRO_CALL), block_like)
2018-08-05 06:16:38 -05:00
}
_ => (m.complete(p, PATH_EXPR), BlockLike::NotBlock),
}
2018-08-04 08:58:22 -05:00
}
2019-08-23 07:55:21 -05:00
// test record_lit
2018-08-04 08:58:22 -05:00
// fn foo() {
// S {};
// S { x, y: 32, };
// S { x, y: 32, ..Default::default() };
// TupleStruct { 0: 1 };
2018-08-04 08:58:22 -05:00
// }
2019-08-23 07:55:21 -05:00
pub(crate) fn record_field_list(p: &mut Parser) {
2019-05-15 07:35:47 -05:00
assert!(p.at(T!['{']));
2018-08-24 11:27:30 -05:00
let m = p.start();
2019-09-09 16:59:29 -05:00
p.bump_any();
2019-05-15 07:35:47 -05:00
while !p.at(EOF) && !p.at(T!['}']) {
2018-08-04 08:58:22 -05:00
match p.current() {
2019-08-23 07:55:21 -05:00
// test record_literal_field_with_attr
// fn main() {
// S { #[cfg(test)] field: 1 }
// }
IDENT | INT_NUMBER | T![#] => {
2018-08-04 08:58:22 -05:00
let m = p.start();
attributes::outer_attributes(p);
2019-08-09 05:16:47 -05:00
name_ref_or_index(p);
2019-05-15 07:35:47 -05:00
if p.eat(T![:]) {
2018-08-04 08:58:22 -05:00
expr(p);
}
2019-08-23 07:55:21 -05:00
m.complete(p, RECORD_FIELD);
2018-08-04 08:58:22 -05:00
}
T![.] if p.at(T![..]) => {
p.bump(T![..]);
2018-08-04 08:58:22 -05:00
expr(p);
}
2019-05-15 07:35:47 -05:00
T!['{'] => error_block(p, "expected a field"),
2018-08-04 08:58:22 -05:00
_ => p.err_and_bump("expected identifier"),
}
2019-05-15 07:35:47 -05:00
if !p.at(T!['}']) {
p.expect(T![,]);
2018-08-04 08:58:22 -05:00
}
}
2019-05-15 07:35:47 -05:00
p.expect(T!['}']);
2019-08-23 07:55:21 -05:00
m.complete(p, RECORD_FIELD_LIST);
2018-08-04 08:58:22 -05:00
}