From ffed132e52964f029a586a3efd4afc879ed39c59 Mon Sep 17 00:00:00 2001 From: pcpthm Date: Tue, 19 Mar 2019 17:24:02 +0900 Subject: Allow attributes on top level expression A top level expression is either - a expression statement or - the last expression in a block --- crates/ra_parser/src/event.rs | 4 +- crates/ra_parser/src/grammar/expressions.rs | 83 +++++++++++++++--------- crates/ra_parser/src/grammar/expressions/atom.rs | 4 +- crates/ra_parser/src/parser.rs | 23 +++++++ 4 files changed, 79 insertions(+), 35 deletions(-) (limited to 'crates/ra_parser/src') diff --git a/crates/ra_parser/src/event.rs b/crates/ra_parser/src/event.rs index 6361d5d86..c1773e8e0 100644 --- a/crates/ra_parser/src/event.rs +++ b/crates/ra_parser/src/event.rs @@ -105,7 +105,9 @@ pub(super) fn process(sink: &mut dyn TreeSink, mut events: Vec) { // append `A`'s forward_parent `B` fp = match mem::replace(&mut events[idx], Event::tombstone()) { Event::Start { kind, forward_parent } => { - forward_parents.push(kind); + if kind != TOMBSTONE { + forward_parents.push(kind); + } forward_parent } _ => unreachable!(), diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs index 83812e938..e35c46a5e 100644 --- a/crates/ra_parser/src/grammar/expressions.rs +++ b/crates/ra_parser/src/grammar/expressions.rs @@ -8,10 +8,10 @@ const EXPR_FIRST: TokenSet = LHS_FIRST; pub(super) fn expr(p: &mut Parser) -> BlockLike { let r = Restrictions { forbid_structs: false, prefer_stmt: false }; - expr_bp(p, r, 1) + expr_bp(p, r, 1).1 } -pub(super) fn expr_stmt(p: &mut Parser) -> BlockLike { +pub(super) fn expr_stmt(p: &mut Parser) -> (Option, BlockLike) { let r = Restrictions { forbid_structs: false, prefer_stmt: true }; expr_bp(p, r, 1) } @@ -55,7 +55,13 @@ pub(crate) fn expr_block_contents(p: &mut Parser) { // test block_items // fn a() { fn b() {} } let m = p.start(); - let has_attrs = p.at(POUND); + // test attr_on_expr_stmt + // fn foo() { + // #[A] foo(); + // #[B] bar!{} + // #[C] #[D] {} + // #[D] return (); + // } attributes::outer_attributes(p); if p.at(LET_KW) { let_stmt(p, m); @@ -67,35 +73,48 @@ pub(crate) fn expr_block_contents(p: &mut Parser) { Err(m) => m, }; - if has_attrs { - m.abandon(p); - p.error("expected a let statement or an item after attributes in block"); - } else { - let is_blocklike = expressions::expr_stmt(p) == BlockLike::Block; - if p.at(R_CURLY) { - m.abandon(p); - } else { - // test no_semi_after_block - // fn foo() { - // if true {} - // loop {} - // match () {} - // while true {} - // for _ in () {} - // {} - // {} - // macro_rules! test { - // () => {} - // } - // test!{} - // } - if is_blocklike { - p.eat(SEMI); + let (cm, blocklike) = expr_stmt(p); + let cm = match cm { + None => { + if p.at(R_CURLY) { + m.abandon(p); } else { p.expect(SEMI); + m.complete(p, EXPR_STMT); } - m.complete(p, EXPR_STMT); + continue; + } + Some(cm) => cm, + }; + + if p.at(R_CURLY) { + // test attr_on_last_expr_in_block + // fn foo() { + // { #[A] bar!()? } + // #[B] &() + // } + m.contract_child(p, cm); + } else { + // test no_semi_after_block + // fn foo() { + // if true {} + // loop {} + // match () {} + // while true {} + // for _ in () {} + // {} + // {} + // macro_rules! test { + // () => {} + // } + // test!{} + // } + if blocklike.is_block() { + p.eat(SEMI); + } else { + p.expect(SEMI); } + m.complete(p, EXPR_STMT); } } @@ -176,7 +195,7 @@ fn current_op(p: &Parser) -> (u8, Op) { } // Parses expression with binding power of at least bp. -fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike { +fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option, BlockLike) { let mut lhs = match lhs(p, r) { Some((lhs, blocklike)) => { // test stmt_bin_expr_ambiguity @@ -185,11 +204,11 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike { // {1} &2; // } if r.prefer_stmt && blocklike.is_block() { - return BlockLike::Block; + return (Some(lhs), BlockLike::Block); } lhs } - None => return BlockLike::NotBlock, + None => return (None, BlockLike::NotBlock), }; loop { @@ -208,7 +227,7 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike { expr_bp(p, r, op_bp + 1); lhs = m.complete(p, if is_range { RANGE_EXPR } else { BIN_EXPR }); } - BlockLike::NotBlock + (Some(lhs), BlockLike::NotBlock) } const LHS_FIRST: TokenSet = diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs index d933288cd..a23977bfb 100644 --- a/crates/ra_parser/src/grammar/expressions/atom.rs +++ b/crates/ra_parser/src/grammar/expressions/atom.rs @@ -392,9 +392,9 @@ fn match_arm(p: &mut Parser) -> BlockLike { match_guard(p); } p.expect(FAT_ARROW); - let ret = expr_stmt(p); + let blocklike = expr_stmt(p).1; m.complete(p, MATCH_ARM); - ret + blocklike } // test match_guard diff --git a/crates/ra_parser/src/parser.rs b/crates/ra_parser/src/parser.rs index a18458148..702669eb9 100644 --- a/crates/ra_parser/src/parser.rs +++ b/crates/ra_parser/src/parser.rs @@ -228,6 +228,29 @@ impl Marker { } } } + + /// Contract a node `cm` and complete as `cm`'s `kind`. + /// `cm` must be a child of `m` to work correctly. + /// ``` + /// m--A m--A + /// +--cm--B -> +--B + /// +--C C + /// + /// [m: TOMBSTONE, A, cm: Start(k), B, Finish, C] + /// [m: Start(k), A, cm: TOMBSTONE, B, Finish, C] + /// ``` + pub(crate) fn contract_child(mut self, p: &mut Parser, cm: CompletedMarker) -> CompletedMarker { + self.bomb.defuse(); + match p.events[self.pos as usize] { + Event::Start { kind: ref mut slot, .. } => *slot = cm.kind(), + _ => unreachable!(), + }; + match p.events[cm.0 as usize] { + Event::Start { kind: ref mut slot, .. } => *slot = TOMBSTONE, + _ => unreachable!(), + }; + CompletedMarker::new(self.pos, cm.kind()) + } } pub(crate) struct CompletedMarker(u32, SyntaxKind); -- cgit v1.2.3 From 2fb110e1faa1daabd96a9c961da38a838c906553 Mon Sep 17 00:00:00 2001 From: pcpthm Date: Tue, 19 Mar 2019 17:37:08 +0900 Subject: Error about attributes on unallowed types of expression statement --- crates/ra_parser/src/grammar/expressions.rs | 35 +++++++++++++++++++---------- 1 file changed, 23 insertions(+), 12 deletions(-) (limited to 'crates/ra_parser/src') diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs index e35c46a5e..c8ce07179 100644 --- a/crates/ra_parser/src/grammar/expressions.rs +++ b/crates/ra_parser/src/grammar/expressions.rs @@ -38,6 +38,13 @@ pub(crate) fn block(p: &mut Parser) { m.complete(p, BLOCK); } +fn is_expr_stmt_attr_allowed(kind: SyntaxKind) -> bool { + match kind { + BIN_EXPR | RANGE_EXPR | IF_EXPR => false, + _ => true, + } +} + pub(crate) fn expr_block_contents(p: &mut Parser) { // This is checked by a validator attributes::inner_attributes(p); @@ -62,6 +69,7 @@ pub(crate) fn expr_block_contents(p: &mut Parser) { // #[C] #[D] {} // #[D] return (); // } + let has_attrs = p.at(POUND); attributes::outer_attributes(p); if p.at(LET_KW) { let_stmt(p, m); @@ -74,18 +82,17 @@ pub(crate) fn expr_block_contents(p: &mut Parser) { }; let (cm, blocklike) = expr_stmt(p); - let cm = match cm { - None => { - if p.at(R_CURLY) { - m.abandon(p); - } else { - p.expect(SEMI); - m.complete(p, EXPR_STMT); - } - continue; + + if let Some(cm) = &cm { + if has_attrs && !is_expr_stmt_attr_allowed(cm.kind()) { + // test_err attr_on_expr_not_allowed + // fn foo() { + // #[A] 1 + 2; + // #[B] if true {}; + // } + p.error(format!("attributes are not allowed on {:?}", cm.kind())); } - Some(cm) => cm, - }; + } if p.at(R_CURLY) { // test attr_on_last_expr_in_block @@ -93,7 +100,11 @@ pub(crate) fn expr_block_contents(p: &mut Parser) { // { #[A] bar!()? } // #[B] &() // } - m.contract_child(p, cm); + if let Some(cm) = cm { + m.contract_child(p, cm); + } else { + m.abandon(p); + } } else { // test no_semi_after_block // fn foo() { -- cgit v1.2.3 From e2ed813e8951517f59552323c55a0ff05167c945 Mon Sep 17 00:00:00 2001 From: pcpthm Date: Tue, 19 Mar 2019 18:12:05 +0900 Subject: Mark non-code block as text --- crates/ra_parser/src/parser.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'crates/ra_parser/src') diff --git a/crates/ra_parser/src/parser.rs b/crates/ra_parser/src/parser.rs index 702669eb9..fa036bdbf 100644 --- a/crates/ra_parser/src/parser.rs +++ b/crates/ra_parser/src/parser.rs @@ -231,7 +231,7 @@ impl Marker { /// Contract a node `cm` and complete as `cm`'s `kind`. /// `cm` must be a child of `m` to work correctly. - /// ``` + /// ```text /// m--A m--A /// +--cm--B -> +--B /// +--C C -- cgit v1.2.3 From 4cf179c089aeed381cd67bcd265e76a27f11facd Mon Sep 17 00:00:00 2001 From: pcpthm Date: Tue, 19 Mar 2019 18:44:23 +0900 Subject: Replace `contract_child` to a less ad-hoc API --- crates/ra_parser/src/grammar/expressions.rs | 20 +++++----- crates/ra_parser/src/parser.rs | 57 ++++++++++++++--------------- 2 files changed, 37 insertions(+), 40 deletions(-) (limited to 'crates/ra_parser/src') diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs index c8ce07179..73e1acd5a 100644 --- a/crates/ra_parser/src/grammar/expressions.rs +++ b/crates/ra_parser/src/grammar/expressions.rs @@ -82,16 +82,15 @@ pub(crate) fn expr_block_contents(p: &mut Parser) { }; let (cm, blocklike) = expr_stmt(p); + let kind = cm.as_ref().map(|cm| cm.kind()).unwrap_or(ERROR); - if let Some(cm) = &cm { - if has_attrs && !is_expr_stmt_attr_allowed(cm.kind()) { - // test_err attr_on_expr_not_allowed - // fn foo() { - // #[A] 1 + 2; - // #[B] if true {}; - // } - p.error(format!("attributes are not allowed on {:?}", cm.kind())); - } + if has_attrs && !is_expr_stmt_attr_allowed(kind) { + // test_err attr_on_expr_not_allowed + // fn foo() { + // #[A] 1 + 2; + // #[B] if true {}; + // } + p.error(format!("attributes are not allowed on {:?}", kind)); } if p.at(R_CURLY) { @@ -101,7 +100,8 @@ pub(crate) fn expr_block_contents(p: &mut Parser) { // #[B] &() // } if let Some(cm) = cm { - m.contract_child(p, cm); + cm.undo_completion(p).abandon(p); + m.complete(p, kind); } else { m.abandon(p); } diff --git a/crates/ra_parser/src/parser.rs b/crates/ra_parser/src/parser.rs index fa036bdbf..3c326452b 100644 --- a/crates/ra_parser/src/parser.rs +++ b/crates/ra_parser/src/parser.rs @@ -212,8 +212,9 @@ impl Marker { } _ => unreachable!(), } + let finish_pos = p.events.len() as u32; p.push_event(Event::Finish); - CompletedMarker::new(self.pos, kind) + CompletedMarker::new(self.pos, finish_pos, kind) } /// Abandons the syntax tree node. All its children @@ -228,36 +229,17 @@ impl Marker { } } } - - /// Contract a node `cm` and complete as `cm`'s `kind`. - /// `cm` must be a child of `m` to work correctly. - /// ```text - /// m--A m--A - /// +--cm--B -> +--B - /// +--C C - /// - /// [m: TOMBSTONE, A, cm: Start(k), B, Finish, C] - /// [m: Start(k), A, cm: TOMBSTONE, B, Finish, C] - /// ``` - pub(crate) fn contract_child(mut self, p: &mut Parser, cm: CompletedMarker) -> CompletedMarker { - self.bomb.defuse(); - match p.events[self.pos as usize] { - Event::Start { kind: ref mut slot, .. } => *slot = cm.kind(), - _ => unreachable!(), - }; - match p.events[cm.0 as usize] { - Event::Start { kind: ref mut slot, .. } => *slot = TOMBSTONE, - _ => unreachable!(), - }; - CompletedMarker::new(self.pos, cm.kind()) - } } -pub(crate) struct CompletedMarker(u32, SyntaxKind); +pub(crate) struct CompletedMarker { + start_pos: u32, + finish_pos: u32, + kind: SyntaxKind, +} impl CompletedMarker { - fn new(pos: u32, kind: SyntaxKind) -> Self { - CompletedMarker(pos, kind) + fn new(start_pos: u32, finish_pos: u32, kind: SyntaxKind) -> Self { + CompletedMarker { start_pos, finish_pos, kind } } /// This method allows to create a new node which starts @@ -274,17 +256,32 @@ impl CompletedMarker { /// distance to `NEWSTART` into forward_parent(=2 in this case); pub(crate) fn precede(self, p: &mut Parser) -> Marker { let new_pos = p.start(); - let idx = self.0 as usize; + let idx = self.start_pos as usize; match p.events[idx] { Event::Start { ref mut forward_parent, .. } => { - *forward_parent = Some(new_pos.pos - self.0); + *forward_parent = Some(new_pos.pos - self.start_pos); } _ => unreachable!(), } new_pos } + /// Undo this completion and turns into a `Marker` + pub(crate) fn undo_completion(self, p: &mut Parser) -> Marker { + let start_idx = self.start_pos as usize; + let finish_idx = self.finish_pos as usize; + match p.events[start_idx] { + Event::Start { ref mut kind, forward_parent: None } => *kind = TOMBSTONE, + _ => unreachable!(), + } + match p.events[finish_idx] { + ref mut slot @ Event::Finish => *slot = Event::tombstone(), + _ => unreachable!(), + } + Marker::new(self.start_pos) + } + pub(crate) fn kind(&self) -> SyntaxKind { - self.1 + self.kind } } -- cgit v1.2.3