Merge #987

987: Refactor maybe_item to use Marker argument r=pcpthm a=pcpthm

As suggested at <https://github.com/rust-analyzer/rust-analyzer/pull/980#issuecomment-473659745>.
For expression paring functions, changing signature
- from `fn(&mut Parser) -> Option<CompletedMarker>` to `fn(&mut Parser, Marker) -> Result<CompletedMarker, Marker>`
- from `fn(&mut Parser) -> CompletedMarker` to `fn(&mut Parser, Marker) -> CompletedMarker`
is my plan.

Co-authored-by: pcpthm <pcpthm@gmail.com>

crates/ra_parser/src/grammar/expressions.rs

@@ -62,17 +62,13 @@ pub(crate) fn expr_block_contents(p: &mut Parser) {
             continue;
         }
 
-        match items::maybe_item(p, items::ItemFlavor::Mod) {
+        let m = match items::maybe_item(p, m, items::ItemFlavor::Mod) {
-            items::MaybeItem::Item(kind) => {
+            Ok(()) => continue,
-                m.complete(p, kind);
+            Err(m) => m,
-            }
+        };
-            items::MaybeItem::Modifiers => {
+
-                m.abandon(p);
-                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");
@@ -104,8 +100,6 @@ pub(crate) fn expr_block_contents(p: &mut Parser) {
             }
         }
     }
-        }
-    }
 
     // test let_stmt;
     // fn foo() {

crates/ra_parser/src/grammar/items.rs

@@ -37,11 +37,10 @@ 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) {
+    let m = match maybe_item(p, m, flavor) {
-        MaybeItem::Item(kind) => {
+        Ok(()) => return,
-            m.complete(p, kind);
+        Err(m) => m,
-        }
+    };
-        MaybeItem::None => {
     if paths::is_path_start(p) {
         match macro_call(p) {
             BlockLike::Block => (),
@@ -65,24 +64,13 @@ pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool, flavor: ItemF
             p.error("expected an item");
         }
     }
-        }
-        MaybeItem::Modifiers => {
-            p.error("expected fn, trait or impl");
-            m.complete(p, ERROR);
-        }
-    }
 }
 
-pub(super) enum MaybeItem {
+pub(super) fn maybe_item(p: &mut Parser, m: Marker, flavor: ItemFlavor) -> Result<(), Marker> {
-    None,
-    Item(SyntaxKind),
-    Modifiers,
-}
-
-pub(super) fn maybe_item(p: &mut Parser, flavor: ItemFlavor) -> MaybeItem {
     opt_visibility(p);
     if let Some(kind) = items_without_modifiers(p) {
-        return MaybeItem::Item(kind);
+        m.complete(p, kind);
+        return Ok(());
     }
 
     let mut has_mods = false;
@@ -115,7 +103,7 @@ pub(super) fn maybe_item(p: &mut Parser, flavor: ItemFlavor) -> MaybeItem {
     }
 
     // items
-    let kind = match p.current() {
+    match p.current() {
         // test async_fn
         // async fn foo() {}
 
@@ -135,7 +123,7 @@ pub(super) fn maybe_item(p: &mut Parser, flavor: ItemFlavor) -> MaybeItem {
         // unsafe fn foo() {}
         FN_KW => {
             fn_def(p, flavor);
-            FN_DEF
+            m.complete(p, FN_DEF);
         }
 
         // test unsafe_trait
@@ -148,7 +136,7 @@ pub(super) fn maybe_item(p: &mut Parser, flavor: ItemFlavor) -> MaybeItem {
         // unsafe auto trait T {}
         TRAIT_KW => {
             traits::trait_def(p);
-            TRAIT_DEF
+            m.complete(p, TRAIT_DEF);
         }
 
         // test unsafe_impl
@@ -161,14 +149,18 @@ pub(super) fn maybe_item(p: &mut Parser, flavor: ItemFlavor) -> MaybeItem {
         // unsafe default impl Foo {}
         IMPL_KW => {
             traits::impl_block(p);
-            IMPL_BLOCK
+            m.complete(p, IMPL_BLOCK);
         }
         _ => {
-            return if has_mods { MaybeItem::Modifiers } else { MaybeItem::None };
+            if !has_mods {
+                return Err(m);
+            } else {
+                p.error("expected fn, trait or impl");
+                m.complete(p, ERROR);
             }
-    };
+        }
-
+    }
-    MaybeItem::Item(kind)
+    Ok(())
 }
 
 fn items_without_modifiers(p: &mut Parser) -> Option<SyntaxKind> {