Turn ExpandResult into struct

2 files changed, 19 insertions, 24 deletions

diff --git a/crates/ra_mbe/src/mbe_expander/matcher.rs b/crates/ra_mbe/src/mbe_expander/matcher.rs
index f40d55d4e..22fb5d74c 100644
--- a/crates/ra_mbe/src/mbe_expander/matcher.rs
+++ b/crates/ra_mbe/src/mbe_expander/matcher.rs
@@ -79,7 +79,7 @@ pub(super) fn match_(pattern: &tt::Subtree, src: &tt::Subtree) -> ExpandResult<M
         err = Some(err!("leftover tokens"));
     }
 
-    (res, err)
+    ExpandResult(res, err)
 }
 
 fn match_subtree(
@@ -148,7 +148,7 @@ fn match_subtree(
                         continue;
                     }
                 };
-                let (matched, match_err) = match_meta_var(kind.as_str(), src);
+                let ExpandResult(matched, match_err) = match_meta_var(kind.as_str(), src);
                 match matched {
                     Some(fragment) => {
                         res.bindings.inner.insert(name.clone(), Binding::Fragment(fragment));
@@ -308,17 +308,17 @@ impl<'a> TtIter<'a> {
                 token_trees: res.into_iter().cloned().collect(),
             })),
         };
-        (res, err)
+        ExpandResult(res, err)
     }
 
     pub(crate) fn eat_vis(&mut self) -> Option<tt::TokenTree> {
         let mut fork = self.clone();
         match fork.expect_fragment(Visibility) {
-            (tt, None) => {
+            ExpandResult(tt, None) => {
                 *self = fork;
                 tt
             }
-            (_, Some(_)) => None,
+            ExpandResult(_, Some(_)) => None,
         }
     }
 }
@@ -419,12 +419,11 @@ fn match_meta_var(kind: &str, input: &mut TtIter) -> ExpandResult<Option<Fragmen
                 },
                 _ => Err(ExpandError::UnexpectedToken),
             };
-            return to_expand_result(tt_result.map(|it| it.map(Fragment::Tokens)));
+            return tt_result.map(|it| it.map(Fragment::Tokens)).into();
         }
     };
-    let (tt, err) = input.expect_fragment(fragment);
-    let fragment = if kind == "expr" { tt.map(Fragment::Ast) } else { tt.map(Fragment::Tokens) };
-    (fragment, err)
+    let result = input.expect_fragment(fragment);
+    result.map(|tt| if kind == "expr" { tt.map(Fragment::Ast) } else { tt.map(Fragment::Tokens) })
 }
 
 fn collect_vars(buf: &mut Vec<SmolStr>, pattern: &tt::Subtree) -> Result<(), ExpandError> {
@@ -438,7 +437,3 @@ fn collect_vars(buf: &mut Vec<SmolStr>, pattern: &tt::Subtree) -> Result<(), Exp
     }
     Ok(())
 }
-
-fn to_expand_result<T: Default>(result: Result<T, ExpandError>) -> ExpandResult<T> {
-    result.map_or_else(|e| (Default::default(), Some(e)), |it| (it, None))
-}
diff --git a/crates/ra_mbe/src/mbe_expander/transcriber.rs b/crates/ra_mbe/src/mbe_expander/transcriber.rs
index c53c2d35e..4b173edd3 100644
--- a/crates/ra_mbe/src/mbe_expander/transcriber.rs
+++ b/crates/ra_mbe/src/mbe_expander/transcriber.rs
@@ -87,23 +87,23 @@ fn expand_subtree(ctx: &mut ExpandCtx, template: &tt::Subtree) -> ExpandResult<t
         match op {
             Op::TokenTree(tt @ tt::TokenTree::Leaf(..)) => buf.push(tt.clone()),
             Op::TokenTree(tt::TokenTree::Subtree(tt)) => {
-                let (tt, e) = expand_subtree(ctx, tt);
+                let ExpandResult(tt, e) = expand_subtree(ctx, tt);
                 err = err.or(e);
                 buf.push(tt.into());
             }
             Op::Var { name, kind: _ } => {
-                let (fragment, e) = expand_var(ctx, name);
+                let ExpandResult(fragment, e) = expand_var(ctx, name);
                 err = err.or(e);
                 push_fragment(&mut buf, fragment);
             }
             Op::Repeat { subtree, kind, separator } => {
-                let (fragment, e) = expand_repeat(ctx, subtree, kind, separator);
+                let ExpandResult(fragment, e) = expand_repeat(ctx, subtree, kind, separator);
                 err = err.or(e);
                 push_fragment(&mut buf, fragment)
             }
         }
     }
-    (tt::Subtree { delimiter: template.delimiter, token_trees: buf }, err)
+    ExpandResult(tt::Subtree { delimiter: template.delimiter, token_trees: buf }, err)
 }
 
 fn expand_var(ctx: &mut ExpandCtx, v: &SmolStr) -> ExpandResult<Fragment> {
@@ -112,7 +112,7 @@ fn expand_var(ctx: &mut ExpandCtx, v: &SmolStr) -> ExpandResult<Fragment> {
         let tt =
             tt::Leaf::from(tt::Ident { text: "$crate".into(), id: tt::TokenId::unspecified() })
                 .into();
-        (Fragment::Tokens(tt), None)
+        ExpandResult::ok(Fragment::Tokens(tt))
     } else if !ctx.bindings.contains(v) {
         // Note that it is possible to have a `$var` inside a macro which is not bound.
         // For example:
@@ -141,11 +141,11 @@ fn expand_var(ctx: &mut ExpandCtx, v: &SmolStr) -> ExpandResult<Fragment> {
             ],
         }
         .into();
-        (Fragment::Tokens(tt), None)
+        ExpandResult::ok(Fragment::Tokens(tt))
     } else {
         ctx.bindings.get(&v, &mut ctx.nesting).map_or_else(
-            |e| (Fragment::Tokens(tt::TokenTree::empty()), Some(e)),
-            |b| (b.clone(), None),
+            |e| ExpandResult(Fragment::Tokens(tt::TokenTree::empty()), Some(e)),
+            |b| ExpandResult::ok(b.clone()),
         )
     }
 }
@@ -165,7 +165,7 @@ fn expand_repeat(
     let mut counter = 0;
 
     loop {
-        let (mut t, e) = expand_subtree(ctx, template);
+        let ExpandResult(mut t, e) = expand_subtree(ctx, template);
         let nesting_state = ctx.nesting.last_mut().unwrap();
         if nesting_state.at_end || !nesting_state.hit {
             break;
@@ -225,9 +225,9 @@ fn expand_repeat(
     let tt = tt::Subtree { delimiter: None, token_trees: buf }.into();
 
     if RepeatKind::OneOrMore == kind && counter == 0 {
-        return (Fragment::Tokens(tt), Some(ExpandError::UnexpectedToken));
+        return ExpandResult(Fragment::Tokens(tt), Some(ExpandError::UnexpectedToken));
     }
-    (Fragment::Tokens(tt), None)
+    ExpandResult::ok(Fragment::Tokens(tt))
 }
 
 fn push_fragment(buf: &mut Vec<tt::TokenTree>, fragment: Fragment) {