9 files changed, 69 insertions, 75 deletions

diff --git a/crates/mbe/src/benchmark.rs b/crates/mbe/src/benchmark.rs
index 38707ffa5..18eb97f0d 100644
--- a/crates/mbe/src/benchmark.rs
+++ b/crates/mbe/src/benchmark.rs
@@ -187,7 +187,7 @@ fn invocation_fixtures(rules: &FxHashMap<String, MacroRules>) -> Vec<(String, tt
             let a = 1664525;
             let c = 1013904223;
             *seed = usize::wrapping_add(usize::wrapping_mul(*seed, a), c);
-            return *seed;
+            *seed
         }
         fn make_ident(ident: &str) -> tt::TokenTree {
             tt::Leaf::Ident(tt::Ident { id: tt::TokenId::unspecified(), text: SmolStr::new(ident) })
diff --git a/crates/mbe/src/expander/matcher.rs b/crates/mbe/src/expander/matcher.rs
index 84ca3ff87..c2a9a38c9 100644
--- a/crates/mbe/src/expander/matcher.rs
+++ b/crates/mbe/src/expander/matcher.rs
@@ -1,6 +1,6 @@
 //! An NFA-based parser, which is porting from rustc mbe parsing code
 //!
-//! See https://github.com/rust-lang/rust/blob/70b18bc2cbac4712020019f5bf57c00905373205/compiler/rustc_expand/src/mbe/macro_parser.rs
+//! See <https://github.com/rust-lang/rust/blob/70b18bc2cbac4712020019f5bf57c00905373205/compiler/rustc_expand/src/mbe/macro_parser.rs>
 //! Here is a quick intro to how the parser works, copied from rustc:
 //!
 //! A 'position' is a dot in the middle of a matcher, usually represented as a
@@ -121,7 +121,7 @@ impl Match {
 
 /// Matching errors are added to the `Match`.
 pub(super) fn match_(pattern: &MetaTemplate, input: &tt::Subtree) -> Match {
-    let mut res = match_loop(pattern, &input);
+    let mut res = match_loop(pattern, input);
     res.bound_count = count(res.bindings.bindings());
     return res;
 
@@ -202,7 +202,7 @@ impl BindingsBuilder {
     }
 
     fn push_nested(&mut self, parent: &mut BindingsIdx, child: &BindingsIdx) {
-        let BindingsIdx(idx, nidx) = self.copy(&child);
+        let BindingsIdx(idx, nidx) = self.copy(child);
         self.nodes[parent.0].push(LinkNode::Node(Rc::new(BindingKind::Nested(idx, nidx))));
     }
 
@@ -219,9 +219,9 @@ impl BindingsBuilder {
         bindings
     }
 
-    fn build_inner(&self, bindings: &mut Bindings, link_nodes: &Vec<LinkNode<Rc<BindingKind>>>) {
+    fn build_inner(&self, bindings: &mut Bindings, link_nodes: &[LinkNode<Rc<BindingKind>>]) {
         let mut nodes = Vec::new();
-        self.collect_nodes(&link_nodes, &mut nodes);
+        self.collect_nodes(link_nodes, &mut nodes);
 
         for cmd in nodes {
             match &**cmd {
@@ -282,7 +282,7 @@ impl BindingsBuilder {
 
         nested_refs.into_iter().for_each(|iter| {
             let mut child_bindings = Bindings::default();
-            self.build_inner(&mut child_bindings, &iter);
+            self.build_inner(&mut child_bindings, iter);
             nested.push(child_bindings)
         })
     }
@@ -301,7 +301,7 @@ impl BindingsBuilder {
 
     fn collect_nodes<'a>(
         &'a self,
-        link_nodes: &'a Vec<LinkNode<Rc<BindingKind>>>,
+        link_nodes: &'a [LinkNode<Rc<BindingKind>>],
         nodes: &mut Vec<&'a Rc<BindingKind>>,
     ) {
         link_nodes.iter().for_each(|it| match it {
@@ -417,7 +417,7 @@ fn match_loop_inner<'t>(
                     let sep_len = item.sep.as_ref().map_or(0, Separator::tt_count);
                     if item.sep.is_some() && sep_idx != sep_len {
                         let sep = item.sep.as_ref().unwrap();
-                        if src.clone().expect_separator(&sep, sep_idx) {
+                        if src.clone().expect_separator(sep, sep_idx) {
                             item.dot.next();
                             item.sep_parsed = Some(sep_idx + 1);
                             try_push!(next_items, item);
@@ -487,22 +487,15 @@ fn match_loop_inner<'t>(
                                 item.meta_result = Some((fork, match_res));
                                 try_push!(bb_items, item);
                             } else {
-                                bindings_builder.push_optional(&mut item.bindings, &name);
+                                bindings_builder.push_optional(&mut item.bindings, name);
                                 item.dot.next();
                                 cur_items.push(item);
                             }
                         }
                         Some(err) => {
                             res.add_err(err);
-                            match match_res.value {
-                                Some(fragment) => {
-                                    bindings_builder.push_fragment(
-                                        &mut item.bindings,
-                                        &name,
-                                        fragment,
-                                    );
-                                }
-                                _ => {}
+                            if let Some(fragment) = match_res.value {
+                                bindings_builder.push_fragment(&mut item.bindings, name, fragment);
                             }
                             item.is_error = true;
                             error_items.push(item);
@@ -511,7 +504,7 @@ fn match_loop_inner<'t>(
                 }
             }
             OpDelimited::Op(Op::Leaf(leaf)) => {
-                if let Err(err) = match_leaf(&leaf, &mut src.clone()) {
+                if let Err(err) = match_leaf(leaf, &mut src.clone()) {
                     res.add_err(err);
                     item.is_error = true;
                 } else {
@@ -578,9 +571,9 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
         );
         stdx::always!(cur_items.is_empty());
 
-        if error_items.len() > 0 {
+        if !error_items.is_empty() {
             error_recover_item = error_items.pop().map(|it| it.bindings);
-        } else if eof_items.len() > 0 {
+        } else if !eof_items.is_empty() {
             error_recover_item = Some(eof_items[0].bindings.clone());
         }
 
@@ -647,10 +640,10 @@ fn match_loop(pattern: &MetaTemplate, src: &tt::Subtree) -> Match {
                 let (iter, match_res) = item.meta_result.take().unwrap();
                 match match_res.value {
                     Some(fragment) => {
-                        bindings_builder.push_fragment(&mut item.bindings, &name, fragment);
+                        bindings_builder.push_fragment(&mut item.bindings, name, fragment);
                     }
                     None if match_res.err.is_none() => {
-                        bindings_builder.push_optional(&mut item.bindings, &name);
+                        bindings_builder.push_optional(&mut item.bindings, name);
                     }
                     _ => {}
                 }
@@ -793,7 +786,7 @@ impl<'a> TtIter<'a> {
             _ => (),
         }
 
-        let tt = self.next().ok_or_else(|| ())?.clone();
+        let tt = self.next().ok_or(())?.clone();
         let punct = match tt {
             tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if punct.spacing == tt::Spacing::Joint => {
                 punct
diff --git a/crates/mbe/src/expander/transcriber.rs b/crates/mbe/src/expander/transcriber.rs
index dd7fa97d7..49a137577 100644
--- a/crates/mbe/src/expander/transcriber.rs
+++ b/crates/mbe/src/expander/transcriber.rs
@@ -55,7 +55,7 @@ pub(super) fn transcribe(
     template: &MetaTemplate,
     bindings: &Bindings,
 ) -> ExpandResult<tt::Subtree> {
-    let mut ctx = ExpandCtx { bindings: &bindings, nesting: Vec::new() };
+    let mut ctx = ExpandCtx { bindings, nesting: Vec::new() };
     let mut arena: Vec<tt::TokenTree> = Vec::new();
     expand_subtree(&mut ctx, template, None, &mut arena)
 }
@@ -91,12 +91,12 @@ fn expand_subtree(
             Op::Leaf(tt) => arena.push(tt.clone().into()),
             Op::Subtree { tokens, delimiter } => {
                 let ExpandResult { value: tt, err: e } =
-                    expand_subtree(ctx, &tokens, *delimiter, arena);
+                    expand_subtree(ctx, tokens, *delimiter, arena);
                 err = err.or(e);
                 arena.push(tt.into());
             }
             Op::Var { name, id, .. } => {
-                let ExpandResult { value: fragment, err: e } = expand_var(ctx, &name, *id);
+                let ExpandResult { value: fragment, err: e } = expand_var(ctx, name, *id);
                 err = err.or(e);
                 push_fragment(arena, fragment);
             }
@@ -141,7 +141,7 @@ fn expand_var(ctx: &mut ExpandCtx, v: &SmolStr, id: tt::TokenId) -> ExpandResult
         .into();
         ExpandResult::ok(Fragment::Tokens(tt))
     } else {
-        ctx.bindings.get(&v, &mut ctx.nesting).map_or_else(
+        ctx.bindings.get(v, &mut ctx.nesting).map_or_else(
             |e| ExpandResult { value: Fragment::Tokens(tt::TokenTree::empty()), err: Some(e) },
             |b| ExpandResult::ok(b.clone()),
         )
diff --git a/crates/mbe/src/lib.rs b/crates/mbe/src/lib.rs
index b95374b76..8c8528aaf 100644
--- a/crates/mbe/src/lib.rs
+++ b/crates/mbe/src/lib.rs
@@ -280,8 +280,8 @@ impl Rule {
             .expect_subtree()
             .map_err(|()| ParseError::Expected("expected subtree".to_string()))?;
 
-        let lhs = MetaTemplate(parse_pattern(&lhs)?);
-        let rhs = MetaTemplate(parse_template(&rhs)?);
+        let lhs = MetaTemplate(parse_pattern(lhs)?);
+        let rhs = MetaTemplate(parse_template(rhs)?);
 
         Ok(crate::Rule { lhs, rhs })
     }
@@ -290,13 +290,13 @@ impl Rule {
 fn validate(pattern: &MetaTemplate) -> Result<(), ParseError> {
     for op in pattern.iter() {
         match op {
-            Op::Subtree { tokens, .. } => validate(&tokens)?,
+            Op::Subtree { tokens, .. } => validate(tokens)?,
             Op::Repeat { tokens: subtree, separator, .. } => {
                 // Checks that no repetition which could match an empty token
                 // https://github.com/rust-lang/rust/blob/a58b1ed44f5e06976de2bdc4d7dc81c36a96934f/src/librustc_expand/mbe/macro_rules.rs#L558
 
-                if separator.is_none() {
-                    if subtree.iter().all(|child_op| {
+                if separator.is_none()
+                    && subtree.iter().all(|child_op| {
                         match child_op {
                             Op::Var { kind, .. } => {
                                 // vis is optional
@@ -314,9 +314,9 @@ fn validate(pattern: &MetaTemplate) -> Result<(), ParseError> {
                             Op::Subtree { .. } => {}
                         }
                         false
-                    }) {
-                        return Err(ParseError::RepetitionEmptyTokenTree);
-                    }
+                    })
+                {
+                    return Err(ParseError::RepetitionEmptyTokenTree);
                 }
                 validate(subtree)?
             }
diff --git a/crates/mbe/src/parser.rs b/crates/mbe/src/parser.rs
index 61b2a4955..deed884d2 100644
--- a/crates/mbe/src/parser.rs
+++ b/crates/mbe/src/parser.rs
@@ -42,7 +42,7 @@ impl<'a> OpDelimitedIter<'a> {
     }
 
     pub(crate) fn reset(&self) -> Self {
-        Self { inner: &self.inner, idx: 0, delimited: self.delimited }
+        Self { inner: self.inner, idx: 0, delimited: self.delimited }
     }
 }
 
@@ -126,11 +126,11 @@ impl Separator {
 }
 
 pub(crate) fn parse_template(template: &tt::Subtree) -> Result<Vec<Op>, ParseError> {
-    parse_inner(&template, Mode::Template).into_iter().collect()
+    parse_inner(template, Mode::Template).into_iter().collect()
 }
 
 pub(crate) fn parse_pattern(pattern: &tt::Subtree) -> Result<Vec<Op>, ParseError> {
-    parse_inner(&pattern, Mode::Pattern).into_iter().collect()
+    parse_inner(pattern, Mode::Pattern).into_iter().collect()
 }
 
 #[derive(Clone, Copy)]
@@ -140,7 +140,7 @@ enum Mode {
 }
 
 fn parse_inner(tt: &tt::Subtree, mode: Mode) -> Vec<Result<Op, ParseError>> {
-    let mut src = TtIter::new(&tt);
+    let mut src = TtIter::new(tt);
     std::iter::from_fn(move || {
         let first = src.next()?;
         Some(next_op(first, &mut src, mode))
@@ -171,7 +171,7 @@ fn next_op<'a>(first: &tt::TokenTree, src: &mut TtIter<'a>, mode: Mode) -> Resul
             match second {
                 tt::TokenTree::Subtree(subtree) => {
                     let (separator, kind) = parse_repeat(src)?;
-                    let tokens = parse_inner(&subtree, mode)
+                    let tokens = parse_inner(subtree, mode)
                         .into_iter()
                         .collect::<Result<Vec<Op>, ParseError>>()?;
                     Op::Repeat { tokens: MetaTemplate(tokens), separator, kind }
@@ -191,7 +191,7 @@ fn next_op<'a>(first: &tt::TokenTree, src: &mut TtIter<'a>, mode: Mode) -> Resul
                         Op::Var { name, kind, id }
                     }
                     tt::Leaf::Literal(lit) => {
-                        if is_boolean_literal(&lit) {
+                        if is_boolean_literal(lit) {
                             let name = lit.text.clone();
                             let kind = eat_fragment_kind(src, mode)?;
                             let id = lit.id;
@@ -206,14 +206,14 @@ fn next_op<'a>(first: &tt::TokenTree, src: &mut TtIter<'a>, mode: Mode) -> Resul
         tt::TokenTree::Leaf(tt) => Op::Leaf(tt.clone()),
         tt::TokenTree::Subtree(subtree) => {
             let tokens =
-                parse_inner(&subtree, mode).into_iter().collect::<Result<Vec<Op>, ParseError>>()?;
+                parse_inner(subtree, mode).into_iter().collect::<Result<Vec<Op>, ParseError>>()?;
             Op::Subtree { tokens: MetaTemplate(tokens), delimiter: subtree.delimiter }
         }
     };
     Ok(res)
 }
 
-fn eat_fragment_kind<'a>(src: &mut TtIter<'a>, mode: Mode) -> Result<Option<SmolStr>, ParseError> {
+fn eat_fragment_kind(src: &mut TtIter<'_>, mode: Mode) -> Result<Option<SmolStr>, ParseError> {
     if let Mode::Pattern = mode {
         src.expect_char(':').map_err(|()| err!("bad fragment specifier 1"))?;
         let ident = src.expect_ident().map_err(|()| err!("bad fragment specifier 1"))?;
diff --git a/crates/mbe/src/subtree_source.rs b/crates/mbe/src/subtree_source.rs
index bde370fdb..ee80807ad 100644
--- a/crates/mbe/src/subtree_source.rs
+++ b/crates/mbe/src/subtree_source.rs
@@ -22,7 +22,7 @@ impl<'a> SubtreeTokenSource {
     #[cfg(test)]
     pub(crate) fn text(&self) -> SmolStr {
         match self.cached.get(self.curr.1) {
-            Some(ref tt) => tt.text.clone(),
+            Some(tt) => tt.text.clone(),
             _ => SmolStr::new(""),
         }
     }
@@ -59,7 +59,7 @@ impl<'a> SubtreeTokenSource {
 
             current = match tt {
                 Some(tt::buffer::TokenTreeRef::Leaf(leaf, _)) => {
-                    cached.push(convert_leaf(&leaf));
+                    cached.push(convert_leaf(leaf));
                     cursor.bump()
                 }
                 Some(tt::buffer::TokenTreeRef::Subtree(subtree, _)) => {
@@ -114,7 +114,7 @@ impl<'a> TokenSource for SubtreeTokenSource {
     /// Is the current token a specified keyword?
     fn is_keyword(&self, kw: &str) -> bool {
         match self.cached.get(self.curr.1) {
-            Some(ref t) => t.text == *kw,
+            Some(t) => t.text == *kw,
             _ => false,
         }
     }
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index b11172caf..cdc22425d 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -243,8 +243,7 @@ trait TokenConvertor {
     type Token: SrcToken;
 
     fn go(&mut self) -> tt::Subtree {
-        let mut subtree = tt::Subtree::default();
-        subtree.delimiter = None;
+        let mut subtree = tt::Subtree { delimiter: None, ..Default::default() };
         while self.peek().is_some() {
             self.collect_leaf(&mut subtree.token_trees);
         }
@@ -506,7 +505,7 @@ impl TokenConvertor for Convertor {
 
     fn peek(&self) -> Option<Self::Token> {
         if let Some((punct, mut offset)) = self.punct_offset.clone() {
-            offset = offset + TextSize::of('.');
+            offset += TextSize::of('.');
             if usize::from(offset) < punct.text().len() {
                 return Some(SynToken::Punch(punct, offset));
             }
@@ -634,7 +633,7 @@ impl<'a> TreeSink for TtTreeSink<'a> {
                     }
                 }
             };
-            self.buf += &text;
+            self.buf += text;
             self.text_pos += TextSize::of(text);
         }
 
diff --git a/crates/mbe/src/tests/expand.rs b/crates/mbe/src/tests/expand.rs
index 5f173f513..c788e427e 100644
--- a/crates/mbe/src/tests/expand.rs
+++ b/crates/mbe/src/tests/expand.rs
@@ -490,7 +490,7 @@ [email protected]
 
 fn to_subtree(tt: &tt::TokenTree) -> &tt::Subtree {
     if let tt::TokenTree::Subtree(subtree) = tt {
-        return &subtree;
+        return subtree;
     }
     unreachable!("It is not a subtree");
 }
@@ -1846,16 +1846,17 @@ fn test_no_space_after_semi_colon() {
     [email protected]
       [email protected] "#"
       [email protected] "["
-      [email protected]
-        [email protected]
-          [email protected]
-            [email protected] "cfg"
-      [email protected]
-        [email protected] "("
-        [email protected] "feature"
-        [email protected] "="
-        [email protected] "\"std\""
-        [email protected] ")"
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected] "cfg"
+        [email protected]
+          [email protected] "("
+          [email protected] "feature"
+          [email protected] "="
+          [email protected] "\"std\""
+          [email protected] ")"
       [email protected] "]"
     [email protected] "mod"
     [email protected]
@@ -1865,16 +1866,17 @@ fn test_no_space_after_semi_colon() {
     [email protected]
       [email protected] "#"
       [email protected] "["
-      [email protected]
-        [email protected]
-          [email protected]
-            [email protected] "cfg"
-      [email protected]
-        [email protected] "("
-        [email protected] "feature"
-        [email protected] "="
-        [email protected] "\"std\""
-        [email protected] ")"
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected] "cfg"
+        [email protected]
+          [email protected] "("
+          [email protected] "feature"
+          [email protected] "="
+          [email protected] "\"std\""
+          [email protected] ")"
       [email protected] "]"
     [email protected] "mod"
     [email protected]
diff --git a/crates/mbe/src/tt_iter.rs b/crates/mbe/src/tt_iter.rs
index 99a8d250b..5a4eca7bf 100644
--- a/crates/mbe/src/tt_iter.rs
+++ b/crates/mbe/src/tt_iter.rs
@@ -115,7 +115,7 @@ impl<'a> TtIter<'a> {
             }
         }
 
-        let buffer = TokenBuffer::from_tokens(&self.inner.as_slice());
+        let buffer = TokenBuffer::from_tokens(self.inner.as_slice());
         let mut src = SubtreeTokenSource::new(&buffer);
         let mut sink = OffsetTokenSink { cursor: buffer.begin(), error: false };
 
@@ -138,7 +138,7 @@ impl<'a> TtIter<'a> {
             }
         }
         self.inner = self.inner.as_slice()[res.len()..].iter();
-        if res.len() == 0 && err.is_none() {
+        if res.is_empty() && err.is_none() {
             err = Some(err!("no tokens consumed"));
         }
         let res = match res.len() {