Merge #685

685: Support attributes on let statements r=matklad a=DJMcNab

Fix #677.

Co-authored-by: DJMcNab <[email protected]>

2 files changed, 47 insertions, 36 deletions

diff --git a/crates/ra_syntax/src/grammar/expressions.rs b/crates/ra_syntax/src/grammar/expressions.rs
index 1604d9b5a..d27eb8b7e 100644
--- a/crates/ra_syntax/src/grammar/expressions.rs
+++ b/crates/ra_syntax/src/grammar/expressions.rs
@@ -45,7 +45,6 @@ pub(crate) fn block(p: &mut Parser) {
 
     while !p.at(EOF) && !p.at(R_CURLY) {
         match p.current() {
-            LET_KW => let_stmt(p),
             // test nocontentexpr
             // fn foo(){
             //     ;;;some_expr();;;;{;;;};;;;Ok(())
@@ -55,41 +54,54 @@ pub(crate) fn block(p: &mut Parser) {
                 // test block_items
                 // fn a() { fn b() {} }
                 let m = p.start();
-                match items::maybe_item(p, items::ItemFlavor::Mod) {
-                    items::MaybeItem::Item(kind) => {
-                        m.complete(p, kind);
-                    }
-                    items::MaybeItem::Modifiers => {
-                        m.abandon(p);
-                        p.error("expected an item");
-                    }
-                    // test pub_expr
-                    // fn foo() { pub 92; } //FIXME
-                    items::MaybeItem::None => {
-                        let is_blocklike = expressions::expr_stmt(p) == BlockLike::Block;
-                        if p.at(R_CURLY) {
+                let has_attrs = p.at(POUND);
+                attributes::outer_attributes(p);
+                if p.at(LET_KW) {
+                    let_stmt(p, m);
+                } else {
+                    match items::maybe_item(p, items::ItemFlavor::Mod) {
+                        items::MaybeItem::Item(kind) => {
+                            m.complete(p, kind);
+                        }
+                        items::MaybeItem::Modifiers => {
                             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);
+                            p.error("expected an item");
+                        }
+                        // test pub_expr
+                        // fn foo() { pub 92; } //FIXME
+                        items::MaybeItem::None => {
+                            if has_attrs {
+                                m.abandon(p);
+                                p.error(
+                                    "expected a let statement or an item after attributes in block",
+                                );
                             } else {
-                                p.expect(SEMI);
+                                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);
+                                    } else {
+                                        p.expect(SEMI);
+                                    }
+                                    m.complete(p, EXPR_STMT);
+                                }
                             }
-                            m.complete(p, EXPR_STMT);
                         }
                     }
                 }
@@ -106,9 +118,8 @@ pub(crate) fn block(p: &mut Parser) {
     //     let c = 92;
     //     let d: i32 = 92;
     // }
-    fn let_stmt(p: &mut Parser) {
+    fn let_stmt(p: &mut Parser, m: Marker) {
         assert!(p.at(LET_KW));
-        let m = p.start();
         p.bump();
         patterns::pattern(p);
         if p.at(COLON) {
diff --git a/crates/ra_syntax/src/grammar/items.rs b/crates/ra_syntax/src/grammar/items.rs
index 265e84570..18039cd3f 100644
--- a/crates/ra_syntax/src/grammar/items.rs
+++ b/crates/ra_syntax/src/grammar/items.rs
@@ -36,6 +36,7 @@ pub(super) const ITEM_RECOVERY_SET: TokenSet = token_set![
 
 pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool, flavor: ItemFlavor) {
     let m = p.start();
+    attributes::outer_attributes(p);
     match maybe_item(p, flavor) {
         MaybeItem::Item(kind) => {
             m.complete(p, kind);
@@ -79,7 +80,6 @@ pub(super) enum MaybeItem {
 }
 
 pub(super) fn maybe_item(p: &mut Parser, flavor: ItemFlavor) -> MaybeItem {
-    attributes::outer_attributes(p);
     opt_visibility(p);
     if let Some(kind) = items_without_modifiers(p) {
         return MaybeItem::Item(kind);