Fix clippy warnings

Author: lukaslueg

examples/shootout-regex-dna-bytes.rs

@@ -55,7 +55,7 @@ fn main() {
         (regex!("Y"), &b"(c|t)"[..]),
     ];
     let mut seq = seq;
-    for (re, replacement) in substs.into_iter() {
+    for (re, replacement) in substs {
         seq = re.replace_all(&seq, replacement).into_owned();
     }
 

examples/shootout-regex-dna-replace.rs

@@ -9,6 +9,8 @@ macro_rules! regex {
     }}
 }
 
+#[cfg_attr(not(feature = "cargo-clippy"), allow(unknown_lints))]
+#[allow(regex_macro)]
 fn main() {
     let mut seq = String::with_capacity(50 * (1 << 20));
     io::stdin().read_to_string(&mut seq).unwrap();

examples/shootout-regex-dna-single.rs

@@ -11,6 +11,8 @@ use std::io::{self, Read};
 
 macro_rules! regex { ($re:expr) => { ::regex::Regex::new($re).unwrap() } }
 
+#[cfg_attr(not(feature = "cargo-clippy"), allow(unknown_lints))]
+#[allow(trivial_regex)]
 fn main() {
     let mut seq = String::with_capacity(50 * (1 << 20));
     io::stdin().read_to_string(&mut seq).unwrap();
@@ -48,7 +50,7 @@ fn main() {
         (regex!("Y"), "(c|t)"),
     ];
     let mut seq = seq;
-    for (re, replacement) in substs.into_iter() {
+    for (re, replacement) in substs {
         seq = re.replace_all(&seq, replacement).into_owned();
     }
     println!("\n{}\n{}\n{}", ilen, clen, seq.len());

examples/shootout-regex-dna.rs

@@ -13,6 +13,8 @@ use std::thread;
 
 macro_rules! regex { ($re:expr) => { ::regex::Regex::new($re).unwrap() } }
 
+#[cfg_attr(not(feature = "cargo-clippy"), allow(unknown_lints))]
+#[allow(trivial_regex)]
 fn main() {
     let mut seq = String::with_capacity(51 * (1 << 20));
     io::stdin().read_to_string(&mut seq).unwrap();
@@ -55,7 +57,7 @@ fn main() {
         (regex!("Y"), "(c|t)"),
     ];
     let mut seq = seq;
-    for (re, replacement) in substs.into_iter() {
+    for (re, replacement) in substs {
         seq = re.replace_all(&seq, replacement).into_owned();
     }
 

src/compile.rs

@@ -569,7 +569,7 @@ impl Compiler {
         greedy: bool,
         min: u32,
     ) -> Result {
-        let min = u32_to_usize(min);
+        let min = min as usize;
         let patch_concat = try!(self.c_concat(iter::repeat(expr).take(min)));
         let patch_rep = try!(self.c_repeat_zero_or_more(expr, greedy));
         self.fill(patch_concat.hole, patch_rep.entry);
@@ -583,7 +583,7 @@ impl Compiler {
         min: u32,
         max: u32,
     ) -> Result {
-        let (min, max) = (u32_to_usize(min), u32_to_usize(max));
+        let (min, max) = (min as usize, max as usize);
         let patch_concat = try!(self.c_concat(iter::repeat(expr).take(min)));
         let initial_entry = patch_concat.entry;
         if min == max {
@@ -713,6 +713,12 @@ impl Compiler {
     }
 }
 
+impl Default for Compiler {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[derive(Debug)]
 enum Hole {
     None,
@@ -833,7 +839,7 @@ impl<'a, 'b> CompileClass<'a, 'b> {
         let mut utf8_seqs = self.c.utf8_seqs.take().unwrap();
         self.c.suffix_cache.clear();
 
-        for (i, ref range) in self.ranges.iter().enumerate() {
+        for (i, range) in self.ranges.iter().enumerate() {
             let is_last_range = i + 1 == self.ranges.len();
             utf8_seqs.reset(range.start, range.end);
             let mut it = (&mut utf8_seqs).peekable();
@@ -916,7 +922,7 @@ impl<'a, 'b> CompileClass<'a, 'b> {
     }
 }
 
-/// SuffixCache is a simple bounded hash map for caching suffix entries in
+/// `SuffixCache` is a simple bounded hash map for caching suffix entries in
 /// UTF-8 automata. For example, consider the Unicode range \u{0}-\u{FFFF}.
 /// The set of byte ranges looks like this:
 ///
@@ -1049,13 +1055,6 @@ impl ByteClassSet {
     }
 }
 
-fn u32_to_usize(n: u32) -> usize {
-    if (n as u64) > (::std::usize::MAX as u64) {
-        panic!("BUG: {} is too big to be pointer sized", n)
-    }
-    n as usize
-}
-
 #[cfg(test)]
 mod tests {
     use super::ByteClassSet;

src/dfa.rs

@@ -58,7 +58,7 @@ use sparse::SparseSet;
 /// Return true if and only if the given program can be executed by a DFA.
 ///
 /// Generally, a DFA is always possible. A pathological case where it is not
-/// possible is if the number of NFA states exceeds u32::MAX, in which case,
+/// possible is if the number of NFA states exceeds `u32::MAX`, in which case,
 /// this function will return false.
 ///
 /// This function will also return false if the given program has any Unicode
@@ -104,7 +104,7 @@ pub struct Cache {
     qnext: SparseSet,
 }
 
-/// CacheInner is logically just a part of Cache, but groups together fields
+/// `CacheInner` is logically just a part of Cache, but groups together fields
 /// that aren't passed as function parameters throughout search. (This split
 /// is mostly an artifact of the borrow checker. It is happily paid.)
 #[derive(Clone, Debug)]
@@ -162,8 +162,8 @@ struct CacheInner {
 /// It is laid out in row-major order, with states as rows and byte class
 /// transitions as columns.
 ///
-/// The transition table is responsible for producing valid StatePtrs. A
-/// StatePtr points to the start of a particular row in this table. When
+/// The transition table is responsible for producing valid `StatePtrs`. A
+/// `StatePtr` points to the start of a particular row in this table. When
 /// indexing to find the next state this allows us to avoid a multiplication
 /// when computing an index into the table.
 #[derive(Clone)]
@@ -252,7 +252,7 @@ impl<T> Result<T> {
     }
 }
 
-/// State is a DFA state. It contains an ordered set of NFA states (not
+/// `State` is a DFA state. It contains an ordered set of NFA states (not
 /// necessarily complete) and a smattering of flags.
 ///
 /// The flags are packed into the first byte of data.
@@ -271,7 +271,7 @@ struct State{
     data: Box<[u8]>,
 }
 
-/// InstPtr is a 32 bit pointer into a sequence of opcodes (i.e., it indexes
+/// `InstPt`r is a 32 bit pointer into a sequence of opcodes (i.e., it indexes
 /// an NFA state).
 ///
 /// Throughout this library, this is usually set to `usize`, but we force a
@@ -322,7 +322,8 @@ impl State {
     }
 }
 
-/// StatePtr is a 32 bit pointer to the start of a row in the transition table.
+/// `StatePtr` is a 32 bit pointer to the start of a row in the transition
+/// table.
 ///
 /// It has many special values. There are two types of special values:
 /// sentinels and flags.
@@ -345,7 +346,8 @@ impl State {
 ///
 /// The other type of state pointer is a state pointer with special flag bits.
 /// There are two flags: a start flag and a match flag. The lower bits of both
-/// kinds always contain a "valid" StatePtr (indicated by the STATE_MAX mask).
+/// kinds always contain a "valid" `StatePtr` (indicated by the `STATE_MAX`
+/// mask).
 ///
 /// The start flag means that the state is a start state, and therefore may be
 /// subject to special prefix scanning optimizations.
@@ -482,7 +484,7 @@ impl<'a> Fsm<'a> {
             Some(STATE_DEAD) => return Result::NoMatch(at),
             Some(si) => si,
         };
-        debug_assert!(dfa.start != STATE_UNKNOWN);
+        debug_assert_ne!(dfa.start, STATE_UNKNOWN);
         dfa.exec_at(&mut cache.qcur, &mut cache.qnext, text)
     }
 
@@ -515,7 +517,7 @@ impl<'a> Fsm<'a> {
             Some(STATE_DEAD) => return Result::NoMatch(at),
             Some(si) => si,
         };
-        debug_assert!(dfa.start != STATE_UNKNOWN);
+        debug_assert_ne!(dfa.start, STATE_UNKNOWN);
         dfa.exec_at_reverse(&mut cache.qcur, &mut cache.qnext, text)
     }
 
@@ -527,7 +529,7 @@ impl<'a> Fsm<'a> {
         text: &[u8],
         at: usize,
     ) -> Result<usize> {
-        debug_assert!(matches.len() == prog.matches.len());
+        debug_assert_eq!(matches.len(), prog.matches.len());
         let mut cache = cache.borrow_mut();
         let mut cache = &mut cache.dfa;
         let mut dfa = Fsm {
@@ -549,14 +551,14 @@ impl<'a> Fsm<'a> {
             Some(STATE_DEAD) => return Result::NoMatch(at),
             Some(si) => si,
         };
-        debug_assert!(dfa.start != STATE_UNKNOWN);
+        debug_assert_ne!(dfa.start, STATE_UNKNOWN);
         let result = dfa.exec_at(&mut cache.qcur, &mut cache.qnext, text);
         if result.is_match() {
             if matches.len() == 1 {
                 matches[0] = true;
             } else {
-                debug_assert!(dfa.last_match_si != STATE_UNKNOWN);
-                debug_assert!(dfa.last_match_si != STATE_DEAD);
+                debug_assert_ne!(dfa.last_match_si, STATE_UNKNOWN);
+                debug_assert_ne!(dfa.last_match_si, STATE_DEAD);
                 for ip in dfa.state(dfa.last_match_si).inst_ptrs() {
                     if let Inst::Match(slot) = dfa.prog[ip] {
                         matches[slot] = true;
@@ -728,7 +730,7 @@ impl<'a> Fsm<'a> {
                     Some(STATE_DEAD) => return result.set_non_match(at),
                     Some(si) => si,
                 };
-                debug_assert!(next_si != STATE_UNKNOWN);
+                debug_assert_ne!(next_si, STATE_UNKNOWN);
                 if next_si & STATE_MATCH > 0 {
                     next_si &= !STATE_MATCH;
                     result = Result::Match(at - 1);
@@ -752,7 +754,7 @@ impl<'a> Fsm<'a> {
             Some(STATE_DEAD) => return result.set_non_match(text.len()),
             Some(si) => si & !STATE_START,
         };
-        debug_assert!(prev_si != STATE_UNKNOWN);
+        debug_assert_ne!(prev_si, STATE_UNKNOWN);
         if prev_si & STATE_MATCH > 0 {
             prev_si &= !STATE_MATCH;
             self.last_match_si = prev_si;
@@ -833,7 +835,7 @@ impl<'a> Fsm<'a> {
                     Some(STATE_DEAD) => return result.set_non_match(at),
                     Some(si) => si,
                 };
-                debug_assert!(next_si != STATE_UNKNOWN);
+                debug_assert_ne!(next_si, STATE_UNKNOWN);
                 if next_si & STATE_MATCH > 0 {
                     next_si &= !STATE_MATCH;
                     result = Result::Match(at + 1);
@@ -854,7 +856,7 @@ impl<'a> Fsm<'a> {
             Some(STATE_DEAD) => return result.set_non_match(0),
             Some(si) => si,
         };
-        debug_assert!(prev_si != STATE_UNKNOWN);
+        debug_assert_ne!(prev_si, STATE_UNKNOWN);
         if prev_si & STATE_MATCH > 0 {
             prev_si &= !STATE_MATCH;
             self.last_match_si = prev_si;
@@ -998,16 +1000,19 @@ impl<'a> Fsm<'a> {
                 }
             }
         }
-        let mut cache = true;
-        if b.is_eof() && self.prog.matches.len() > 1 {
+
+        let cache = if b.is_eof() && self.prog.matches.len() > 1 {
             // If we're processing the last byte of the input and we're
             // matching a regex set, then make the next state contain the
             // previous states transitions. We do this so that the main
             // matching loop can extract all of the match instructions.
             mem::swap(qcur, qnext);
             // And don't cache this state because it's totally bunk.
-            cache = false;
-        }
+            false
+        } else {
+            true
+        };
+
         // We've now built up the set of NFA states that ought to comprise the
         // next DFA state, so try to find it in the cache, and if it doesn't
         // exist, cache it.
@@ -1030,9 +1035,9 @@ impl<'a> Fsm<'a> {
             next = self.start_ptr(next);
         }
         if next <= STATE_MAX && self.state(next).flags().is_match() {
-            next = STATE_MATCH | next;
+            next |= STATE_MATCH;
         }
-        debug_assert!(next != STATE_UNKNOWN);
+        debug_assert_ne!(next, STATE_UNKNOWN);
         // And now store our state in the current state's next list.
         if cache {
             let cls = self.byte_class(b);
@@ -1113,9 +1118,9 @@ impl<'a> Fsm<'a> {
                         NotWordBoundary if flags.not_word_boundary => {
                             self.cache.stack.push(inst.goto as InstPtr);
                         }
-                        StartLine | EndLine | StartText | EndText => {}
-                        WordBoundaryAscii | NotWordBoundaryAscii => {}
-                        WordBoundary | NotWordBoundary => {}
+                        StartLine | EndLine | StartText | EndText
+                        | WordBoundaryAscii | NotWordBoundaryAscii
+                        | WordBoundary | NotWordBoundary => {}
                     }
                 }
                 Save(ref inst) => self.cache.stack.push(inst.goto as InstPtr),
@@ -1167,11 +1172,10 @@ impl<'a> Fsm<'a> {
             return Some(si);
         }
         // If the cache has gotten too big, wipe it.
-        if self.approximate_size() > self.prog.dfa_size_limit {
-            if !self.clear_cache_and_save(current_state) {
-                // Ooops. DFA is giving up.
-                return None;
-            }
+        if self.approximate_size() > self.prog.dfa_size_limit
+            && !self.clear_cache_and_save(current_state) {
+            // Ooops. DFA is giving up.
+            return None;
         }
         // Allocate room for our state and add it.
         self.add_state(key)
@@ -1210,8 +1214,7 @@ impl<'a> Fsm<'a> {
             let ip = usize_to_u32(ip);
             match self.prog[ip as usize] {
                 Char(_) | Ranges(_) => unreachable!(),
-                Save(_) => {}
-                Split(_) => {}
+                Save(_) | Split(_) => {}
                 Bytes(_) => push_inst_ptr(&mut insts, &mut prev, ip),
                 EmptyLook(_) => {
                     state_flags.set_empty();
@@ -1301,7 +1304,7 @@ impl<'a> Fsm<'a> {
         self.cache.trans.clear();
         self.cache.states.clear();
         self.cache.compiled.clear();
-        for s in self.cache.start_states.iter_mut() {
+        for s in &mut self.cache.start_states {
             *s = STATE_UNKNOWN;
         }
         // The unwraps are OK because we just cleared the cache and therefore
@@ -1374,7 +1377,7 @@ impl<'a> Fsm<'a> {
         // matches are delayed by one byte, start states can never be match
         // states.
         let flagi = {
-            (((empty_flags.start as u8) << 0) |
+            ((empty_flags.start as u8) |
              ((empty_flags.end as u8) << 1) |
              ((empty_flags.start_line as u8) << 2) |
              ((empty_flags.end_line as u8) << 3) |
@@ -1411,9 +1414,9 @@ impl<'a> Fsm<'a> {
         let mut empty_flags = EmptyFlags::default();
         let mut state_flags = StateFlags::default();
         empty_flags.start = at == 0;
-        empty_flags.end = text.len() == 0;
+        empty_flags.end = text.is_empty();
         empty_flags.start_line = at == 0 || text[at - 1] == b'\n';
-        empty_flags.end_line = text.len() == 0;
+        empty_flags.end_line = text.is_empty();
 
         let is_word_last = at > 0 && Byte::byte(text[at - 1]).is_ascii_word();
         let is_word = at < text.len() && Byte::byte(text[at]).is_ascii_word();
@@ -1440,9 +1443,9 @@ impl<'a> Fsm<'a> {
         let mut empty_flags = EmptyFlags::default();
         let mut state_flags = StateFlags::default();
         empty_flags.start = at == text.len();
-        empty_flags.end = text.len() == 0;
+        empty_flags.end = text.is_empty();
         empty_flags.start_line = at == text.len() || text[at] == b'\n';
-        empty_flags.end_line = text.len() == 0;
+        empty_flags.end_line = text.is_empty();
 
         let is_word_last =
             at < text.len() && Byte::byte(text[at]).is_ascii_word();
@@ -1499,10 +1502,8 @@ impl<'a> Fsm<'a> {
         self.cache.states.push(state.clone());
         self.cache.compiled.insert(state, si);
         // Transition table and set of states and map should all be in sync.
-        debug_assert!(self.cache.states.len()
-                      == self.cache.trans.num_states());
-        debug_assert!(self.cache.states.len()
-                      == self.cache.compiled.len());
+        debug_assert_eq!(self.cache.states.len(), self.cache.trans.num_states());
+        debug_assert_eq!(self.cache.states.len(), self.cache.compiled.len());
         Some(si)
     }