lint: fix a selection of Clippy lints

PR #1129

Author: chris-ha458

regex-automata/src/nfa/thompson/compiler.rs

@@ -1665,7 +1665,7 @@ impl Compiler {
         capture_index: u32,
         name: Option<&str>,
     ) -> Result<StateID, BuildError> {
-        let name = name.map(|n| Arc::from(n));
+        let name = name.map(Arc::from);
         self.builder.borrow_mut().add_capture_start(
             StateID::ZERO,
             capture_index,

regex-automata/src/nfa/thompson/nfa.rs

@@ -1471,13 +1471,13 @@ impl fmt::Debug for Inner {
         }
         let pattern_len = self.start_pattern.len();
         if pattern_len > 1 {
-            writeln!(f, "")?;
+            writeln!(f)?;
             for pid in 0..pattern_len {
                 let sid = self.start_pattern[pid];
                 writeln!(f, "START({:06?}): {:?}", pid, sid.as_usize())?;
             }
         }
-        writeln!(f, "")?;
+        writeln!(f)?;
         writeln!(
             f,
             "transition equivalence classes: {:?}",
@@ -1819,7 +1819,7 @@ impl SparseTransitions {
         &self,
         unit: alphabet::Unit,
     ) -> Option<StateID> {
-        unit.as_u8().map_or(None, |byte| self.matches_byte(byte))
+        unit.as_u8().and_then(|byte| self.matches_byte(byte))
     }
 
     /// This follows the matching transition for a particular byte.
@@ -1909,7 +1909,7 @@ impl DenseTransitions {
         &self,
         unit: alphabet::Unit,
     ) -> Option<StateID> {
-        unit.as_u8().map_or(None, |byte| self.matches_byte(byte))
+        unit.as_u8().and_then(|byte| self.matches_byte(byte))
     }
 
     /// This follows the matching transition for a particular byte.

regex-automata/src/nfa/thompson/pikevm.rs

@@ -1290,7 +1290,7 @@ impl PikeVM {
                 // the only thing in 'curr'. So we might as well just skip
                 // ahead until we find something that we know might advance us
                 // forward.
-                if let Some(ref pre) = pre {
+                if let Some(pre) = pre {
                     let span = Span::from(at..input.end());
                     match pre.find(input.haystack(), span) {
                         None => break,
@@ -1344,7 +1344,7 @@ impl PikeVM {
             // search. If we re-computed it at every position, we would be
             // simulating an unanchored search when we were tasked to perform
             // an anchored search.
-            if (!hm.is_some() || allmatches)
+            if (hm.is_none() || allmatches)
                 && (!anchored || at == input.start())
             {
                 // Since we are adding to the 'curr' active states and since

regex-automata/src/nfa/thompson/range_trie.rs

@@ -235,7 +235,7 @@ impl RangeTrie {
     /// Clear this range trie such that it is empty. Clearing a range trie
     /// and reusing it can beneficial because this may reuse allocations.
     pub fn clear(&mut self) {
-        self.free.extend(self.states.drain(..));
+        self.free.append(&mut self.states);
         self.add_empty(); // final
         self.add_empty(); // root
     }
@@ -296,7 +296,7 @@ impl RangeTrie {
         assert!(!ranges.is_empty());
         assert!(ranges.len() <= 4);
 
-        let mut stack = mem::replace(&mut self.insert_stack, vec![]);
+        let mut stack = core::mem::replace(&mut self.insert_stack, vec![]);
         stack.clear();
 
         stack.push(NextInsert::new(ROOT, ranges));
@@ -866,7 +866,7 @@ impl Split {
 
 impl fmt::Debug for RangeTrie {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(f, "")?;
+        writeln!(f)?;
         for (i, state) in self.states.iter().enumerate() {
             let status = if i == FINAL.as_usize() { '*' } else { ' ' };
             writeln!(f, "{}{:06}: {:?}", status, i, state)?;

regex-automata/src/util/determinize/mod.rs

@@ -131,7 +131,7 @@ pub(crate) fn next(
     if !state.look_need().is_empty() {
         // Add look-ahead assertions that are now true based on the current
         // input unit.
-        let mut look_have = state.look_have().clone();
+        let mut look_have = state.look_have();
         match unit.as_u8() {
             Some(b'\r') => {
                 if !rev || !state.is_half_crlf() {

regex-automata/src/util/determinize/state.rs

@@ -115,7 +115,7 @@ pub(crate) struct State(Arc<[u8]>);
 /// without having to convert it into a State first.
 impl core::borrow::Borrow<[u8]> for State {
     fn borrow(&self) -> &[u8] {
-        &*self.0
+        &self.0
     }
 }
 
@@ -177,7 +177,7 @@ impl State {
     }
 
     fn repr(&self) -> Repr<'_> {
-        Repr(&*self.0)
+        Repr(&self.0)
     }
 }
 
@@ -461,7 +461,7 @@ impl<'a> Repr<'a> {
     /// If this state is not a match state, then this always returns 0.
     fn match_len(&self) -> usize {
         if !self.is_match() {
-            return 0;
+            0
         } else if !self.has_pattern_ids() {
             1
         } else {

regex-automata/src/util/interpolate.rs

@@ -321,10 +321,7 @@ fn find_cap_ref_braced(rep: &[u8], mut i: usize) -> Option<CaptureRef<'_>> {
 /// Returns true if and only if the given byte is allowed in a capture name
 /// written in non-brace form.
 fn is_valid_cap_letter(b: u8) -> bool {
-    match b {
-        b'0'..=b'9' | b'a'..=b'z' | b'A'..=b'Z' | b'_' => true,
-        _ => false,
-    }
+    matches!(b, b'0'..=b'9' | b'a'..=b'z' | b'A'..=b'Z' | b'_')
 }
 
 #[cfg(test)]

regex-automata/src/util/pool.rs

@@ -678,7 +678,7 @@ mod inner {
         #[inline]
         pub(super) fn value(&self) -> &T {
             match self.value {
-                Ok(ref v) => &**v,
+                Ok(ref v) => v,
                 // SAFETY: This is safe because the only way a PoolGuard gets
                 // created for self.value=Err is when the current thread
                 // corresponds to the owning thread, of which there can only
@@ -703,7 +703,7 @@ mod inner {
         #[inline]
         pub(super) fn value_mut(&mut self) -> &mut T {
             match self.value {
-                Ok(ref mut v) => &mut **v,
+                Ok(ref mut v) => v,
                 // SAFETY: This is safe because the only way a PoolGuard gets
                 // created for self.value=None is when the current thread
                 // corresponds to the owning thread, of which there can only

regex-automata/src/util/prefilter/mod.rs

@@ -501,17 +501,17 @@ pub(crate) trait PrefilterI:
 impl<P: PrefilterI + ?Sized> PrefilterI for Arc<P> {
     #[cfg_attr(feature = "perf-inline", inline(always))]
     fn find(&self, haystack: &[u8], span: Span) -> Option<Span> {
-        (&**self).find(haystack, span)
+        (**self).find(haystack, span)
     }
 
     #[cfg_attr(feature = "perf-inline", inline(always))]
     fn prefix(&self, haystack: &[u8], span: Span) -> Option<Span> {
-        (&**self).prefix(haystack, span)
+        (**self).prefix(haystack, span)
     }
 
     #[cfg_attr(feature = "perf-inline", inline(always))]
     fn memory_usage(&self) -> usize {
-        (&**self).memory_usage()
+        (**self).memory_usage()
     }
 
     #[cfg_attr(feature = "perf-inline", inline(always))]

regex-automata/src/util/search.rs

@@ -1694,13 +1694,14 @@ impl Anchored {
 /// # Ok::<(), Box<dyn std::error::Error>>(())
 /// ```
 #[non_exhaustive]
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Default, Debug, Eq, PartialEq)]
 pub enum MatchKind {
     /// Report all possible matches.
     All,
     /// Report only the leftmost matches. When multiple leftmost matches exist,
     /// report the match corresponding to the part of the regex that appears
     /// first in the syntax.
+    #[default]
     LeftmostFirst,
     // There is prior art in RE2 that shows that we should be able to add
     // LeftmostLongest too. The tricky part of it is supporting ungreedy
@@ -1726,12 +1727,6 @@ impl MatchKind {
     }
 }
 
-impl Default for MatchKind {
-    fn default() -> MatchKind {
-        MatchKind::LeftmostFirst
-    }
-}
-
 /// An error indicating that a search stopped before reporting whether a
 /// match exists or not.
 ///