3 files changed, 25 insertions, 26 deletions

diff --git a/crates/ra_mbe/src/mbe_expander.rs b/crates/ra_mbe/src/mbe_expander.rs
index a0bd0c5f8..55a6ecf58 100644
--- a/crates/ra_mbe/src/mbe_expander.rs
+++ b/crates/ra_mbe/src/mbe_expander.rs
@@ -105,17 +105,15 @@ impl Bindings {
     }
 
     fn get(&self, name: &SmolStr, nesting: &[usize]) -> Result<&tt::TokenTree, ExpandError> {
-        let mut b = self
-            .inner
-            .get(name)
-            .ok_or(ExpandError::BindingError(format!("could not find binding `{}`", name)))?;
+        let mut b = self.inner.get(name).ok_or_else(|| {
+            ExpandError::BindingError(format!("could not find binding `{}`", name))
+        })?;
         for &idx in nesting.iter() {
             b = match b {
                 Binding::Simple(_) => break,
-                Binding::Nested(bs) => bs.get(idx).ok_or(ExpandError::BindingError(format!(
-                    "could not find nested binding `{}`",
-                    name
-                )))?,
+                Binding::Nested(bs) => bs.get(idx).ok_or_else(|| {
+                    ExpandError::BindingError(format!("could not find nested binding `{}`", name))
+                })?,
                 Binding::Empty => {
                     return Err(ExpandError::BindingError(format!(
                         "could not find empty binding `{}`",
@@ -206,48 +204,48 @@ fn match_lhs(pattern: &crate::Subtree, input: &mut TtCursor) -> Result<Bindings,
                         "path" => {
                             let path =
                                 input.eat_path().ok_or(ExpandError::UnexpectedToken)?.clone();
-                            res.inner.insert(text.clone(), Binding::Simple(path.into()));
+                            res.inner.insert(text.clone(), Binding::Simple(path));
                         }
                         "expr" => {
                             let expr =
                                 input.eat_expr().ok_or(ExpandError::UnexpectedToken)?.clone();
-                            res.inner.insert(text.clone(), Binding::Simple(expr.into()));
+                            res.inner.insert(text.clone(), Binding::Simple(expr));
                         }
                         "ty" => {
                             let ty = input.eat_ty().ok_or(ExpandError::UnexpectedToken)?.clone();
-                            res.inner.insert(text.clone(), Binding::Simple(ty.into()));
+                            res.inner.insert(text.clone(), Binding::Simple(ty));
                         }
                         "pat" => {
                             let pat = input.eat_pat().ok_or(ExpandError::UnexpectedToken)?.clone();
-                            res.inner.insert(text.clone(), Binding::Simple(pat.into()));
+                            res.inner.insert(text.clone(), Binding::Simple(pat));
                         }
                         "stmt" => {
                             let pat = input.eat_stmt().ok_or(ExpandError::UnexpectedToken)?.clone();
-                            res.inner.insert(text.clone(), Binding::Simple(pat.into()));
+                            res.inner.insert(text.clone(), Binding::Simple(pat));
                         }
                         "block" => {
                             let block =
                                 input.eat_block().ok_or(ExpandError::UnexpectedToken)?.clone();
-                            res.inner.insert(text.clone(), Binding::Simple(block.into()));
+                            res.inner.insert(text.clone(), Binding::Simple(block));
                         }
                         "meta" => {
                             let meta =
                                 input.eat_meta().ok_or(ExpandError::UnexpectedToken)?.clone();
-                            res.inner.insert(text.clone(), Binding::Simple(meta.into()));
+                            res.inner.insert(text.clone(), Binding::Simple(meta));
                         }
                         "tt" => {
                             let token = input.eat().ok_or(ExpandError::UnexpectedToken)?.clone();
-                            res.inner.insert(text.clone(), Binding::Simple(token.into()));
+                            res.inner.insert(text.clone(), Binding::Simple(token));
                         }
                         "item" => {
                             let item =
                                 input.eat_item().ok_or(ExpandError::UnexpectedToken)?.clone();
-                            res.inner.insert(text.clone(), Binding::Simple(item.into()));
+                            res.inner.insert(text.clone(), Binding::Simple(item));
                         }
                         "lifetime" => {
                             let lifetime =
                                 input.eat_lifetime().ok_or(ExpandError::UnexpectedToken)?.clone();
-                            res.inner.insert(text.clone(), Binding::Simple(lifetime.into()));
+                            res.inner.insert(text.clone(), Binding::Simple(lifetime));
                         }
                         "literal" => {
                             let literal =
@@ -262,7 +260,7 @@ fn match_lhs(pattern: &crate::Subtree, input: &mut TtCursor) -> Result<Bindings,
                             // `vis` is optional
                             if let Some(vis) = input.try_eat_vis() {
                                 let vis = vis.clone();
-                                res.inner.insert(text.clone(), Binding::Simple(vis.into()));
+                                res.inner.insert(text.clone(), Binding::Simple(vis));
                             } else {
                                 res.push_optional(&text);
                             }
@@ -452,7 +450,7 @@ fn expand_tt(
 
                 let idx = ctx.nesting.pop().unwrap();
                 ctx.nesting.push(idx + 1);
-                token_trees.push(reduce_single_token(t).into());
+                token_trees.push(reduce_single_token(t));
 
                 if let Some(ref sep) = repeat.separator {
                     match sep {
diff --git a/crates/ra_mbe/src/mbe_parser.rs b/crates/ra_mbe/src/mbe_parser.rs
index d8fe293c7..dca16b537 100644
--- a/crates/ra_mbe/src/mbe_parser.rs
+++ b/crates/ra_mbe/src/mbe_parser.rs
@@ -125,8 +125,8 @@ fn parse_repeat(p: &mut TtCursor, transcriber: bool) -> Result<crate::Repeat, Pa
         }
     }
 
-    let sep = p.eat_seperator().ok_or(ParseError::Expected(String::from("separator")))?;
-    let rep = p.eat_punct().ok_or(ParseError::Expected(String::from("repeat")))?;
+    let sep = p.eat_seperator().ok_or_else(|| ParseError::Expected(String::from("separator")))?;
+    let rep = p.eat_punct().ok_or_else(|| ParseError::Expected(String::from("repeat")))?;
 
     mk_repeat(rep.char, subtree, Some(sep))
 }
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index 0edb6f9a2..9d3d2ad5b 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -155,9 +155,10 @@ fn convert_doc_comment<'a>(token: &ra_syntax::SyntaxToken<'a>) -> Option<Vec<tt:
     if let ast::CommentPlacement::Inner = doc {
         token_trees.push(mk_punct('!'));
     }
-    token_trees.push(tt::TokenTree::from(tt::Subtree::from(
-        tt::Subtree { delimiter: tt::Delimiter::Bracket, token_trees: meta_tkns }.into(),
-    )));
+    token_trees.push(tt::TokenTree::from(tt::Subtree {
+        delimiter: tt::Delimiter::Bracket,
+        token_trees: meta_tkns,
+    }));
 
     return Some(token_trees);
 
@@ -292,7 +293,7 @@ fn delim_to_str(d: tt::Delimiter, closing: bool) -> SmolStr {
     };
 
     let idx = closing as usize;
-    let text = if texts.len() > 0 { &texts[idx..texts.len() - (1 - idx)] } else { "" };
+    let text = if !texts.is_empty() { &texts[idx..texts.len() - (1 - idx)] } else { "" };
     text.into()
 }