Revert some unwarranted clippy-changes

Author: lukaslueg

examples/shootout-regex-dna-replace.rs

@@ -9,8 +9,6 @@ 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,8 +11,6 @@ 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();

examples/shootout-regex-dna.rs

@@ -13,8 +13,6 @@ 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();

src/compile.rs

@@ -569,7 +569,7 @@ impl Compiler {
         greedy: bool,
         min: u32,
     ) -> Result {
-        let min = min as usize;
+        let min = u32_to_usize(min);
         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) = (min as usize, max as usize);
+        let (min, max) = (u32_to_usize(min), u32_to_usize(max));
         let patch_concat = try!(self.c_concat(iter::repeat(expr).take(min)));
         let initial_entry = patch_concat.entry;
         if min == max {
@@ -713,12 +713,6 @@ impl Compiler {
     }
 }
 
-impl Default for Compiler {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 #[derive(Debug)]
 enum Hole {
     None,
@@ -1055,6 +1049,16 @@ impl ByteClassSet {
     }
 }
 
+fn u32_to_usize(n: u32) -> usize {
+    // In case usize is less than 32 bits, we need to guard against overflow.
+    // On most platforms this compiles to nothing.
+    // TODO Use `std::convert::TryFrom` once it's stable.
+    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

@@ -271,7 +271,7 @@ struct State{
     data: Box<[u8]>,
 }
 
-/// `InstPt`r is a 32 bit pointer into a sequence of opcodes (i.e., it indexes
+/// `InstPtr` 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
@@ -484,7 +484,7 @@ impl<'a> Fsm<'a> {
             Some(STATE_DEAD) => return Result::NoMatch(at),
             Some(si) => si,
         };
-        debug_assert_ne!(dfa.start, STATE_UNKNOWN);
+        debug_assert!(dfa.start != STATE_UNKNOWN);
         dfa.exec_at(&mut cache.qcur, &mut cache.qnext, text)
     }
 
@@ -517,7 +517,7 @@ impl<'a> Fsm<'a> {
             Some(STATE_DEAD) => return Result::NoMatch(at),
             Some(si) => si,
         };
-        debug_assert_ne!(dfa.start, STATE_UNKNOWN);
+        debug_assert!(dfa.start != STATE_UNKNOWN);
         dfa.exec_at_reverse(&mut cache.qcur, &mut cache.qnext, text)
     }
 
@@ -529,7 +529,7 @@ impl<'a> Fsm<'a> {
         text: &[u8],
         at: usize,
     ) -> Result<usize> {
-        debug_assert_eq!(matches.len(), prog.matches.len());
+        debug_assert!(matches.len() == prog.matches.len());
         let mut cache = cache.borrow_mut();
         let mut cache = &mut cache.dfa;
         let mut dfa = Fsm {
@@ -551,14 +551,14 @@ impl<'a> Fsm<'a> {
             Some(STATE_DEAD) => return Result::NoMatch(at),
             Some(si) => si,
         };
-        debug_assert_ne!(dfa.start, STATE_UNKNOWN);
+        debug_assert!(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_ne!(dfa.last_match_si, STATE_UNKNOWN);
-                debug_assert_ne!(dfa.last_match_si, STATE_DEAD);
+                debug_assert!(dfa.last_match_si != STATE_UNKNOWN);
+                debug_assert!(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;
@@ -730,7 +730,7 @@ impl<'a> Fsm<'a> {
                     Some(STATE_DEAD) => return result.set_non_match(at),
                     Some(si) => si,
                 };
-                debug_assert_ne!(next_si, STATE_UNKNOWN);
+                debug_assert!(next_si != STATE_UNKNOWN);
                 if next_si & STATE_MATCH > 0 {
                     next_si &= !STATE_MATCH;
                     result = Result::Match(at - 1);
@@ -754,7 +754,7 @@ impl<'a> Fsm<'a> {
             Some(STATE_DEAD) => return result.set_non_match(text.len()),
             Some(si) => si & !STATE_START,
         };
-        debug_assert_ne!(prev_si, STATE_UNKNOWN);
+        debug_assert!(prev_si != STATE_UNKNOWN);
         if prev_si & STATE_MATCH > 0 {
             prev_si &= !STATE_MATCH;
             self.last_match_si = prev_si;
@@ -835,7 +835,7 @@ impl<'a> Fsm<'a> {
                     Some(STATE_DEAD) => return result.set_non_match(at),
                     Some(si) => si,
                 };
-                debug_assert_ne!(next_si, STATE_UNKNOWN);
+                debug_assert!(next_si != STATE_UNKNOWN);
                 if next_si & STATE_MATCH > 0 {
                     next_si &= !STATE_MATCH;
                     result = Result::Match(at + 1);
@@ -856,7 +856,7 @@ impl<'a> Fsm<'a> {
             Some(STATE_DEAD) => return result.set_non_match(0),
             Some(si) => si,
         };
-        debug_assert_ne!(prev_si, STATE_UNKNOWN);
+        debug_assert!(prev_si != STATE_UNKNOWN);
         if prev_si & STATE_MATCH > 0 {
             prev_si &= !STATE_MATCH;
             self.last_match_si = prev_si;
@@ -1001,17 +1001,18 @@ impl<'a> Fsm<'a> {
             }
         }
 
-        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.
-            false
-        } else {
-            true
-        };
+        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.
+                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
@@ -1037,7 +1038,7 @@ impl<'a> Fsm<'a> {
         if next <= STATE_MAX && self.state(next).flags().is_match() {
             next |= STATE_MATCH;
         }
-        debug_assert_ne!(next, STATE_UNKNOWN);
+        debug_assert!(next != STATE_UNKNOWN);
         // And now store our state in the current state's next list.
         if cache {
             let cls = self.byte_class(b);
@@ -1173,10 +1174,11 @@ impl<'a> Fsm<'a> {
         }
         // If the cache has gotten too big, wipe it.
         if self.approximate_size() > self.prog.dfa_size_limit
-            && !self.clear_cache_and_save(current_state) {
-            // Ooops. DFA is giving up.
-            return None;
-        }
+            && !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)
     }
@@ -1377,7 +1379,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) |
+            (((empty_flags.start as u8) << 0) |
              ((empty_flags.end as u8) << 1) |
              ((empty_flags.start_line as u8) << 2) |
              ((empty_flags.end_line as u8) << 3) |
@@ -1502,8 +1504,10 @@ 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_eq!(self.cache.states.len(), self.cache.trans.num_states());
-        debug_assert_eq!(self.cache.states.len(), self.cache.compiled.len());
+        debug_assert!(self.cache.states.len()
+                      == self.cache.trans.num_states());
+        debug_assert!(self.cache.states.len()
+                      == self.cache.compiled.len());
         Some(si)
     }
 

src/exec.rs

@@ -226,13 +226,14 @@ impl ExecBuilder {
             let expr = try!(parser.parse(pat));
             bytes = bytes || expr.has_bytes();
 
-            if (is_set || !expr.is_anchored_start())
-                && expr.has_anchored_start() {
-                // Regex sets with anchors do not go well with literal
-                // optimizations.
+            if !expr.is_anchored_start() && expr.has_anchored_start() {
                 // Partial anchors unfortunately make it hard to use prefixes,
                 // so disable them.
                 prefixes = None;
+            } else if is_set && expr.is_anchored_start() {
+                // Regex sets with anchors do not go well with literal
+                // optimizations.
+                prefixes = None;
             }
             prefixes = prefixes.and_then(|mut prefixes| {
                 if !prefixes.union_prefixes(&expr) {

src/input.rs

@@ -58,7 +58,7 @@ impl InputAt {
         self.len
     }
 
-    /// Returns wether the UTF-8 width of the character at this position
+    /// Returns whether the UTF-8 width of the character at this position
     /// is zero.
     pub fn is_empty(&self) -> bool {
         self.len == 0

src/lib.rs

@@ -488,8 +488,6 @@ another matching engine with fixed memory requirements.
 */
 
 #![deny(missing_docs)]
-#![allow(inline_always)]
-#![cfg_attr(not(feature = "cargo-clippy"), allow(unknown_lints))]
 #![cfg_attr(test, deny(warnings))]
 #![cfg_attr(feature = "pattern", feature(pattern))]
 #![cfg_attr(feature = "simd-accel", feature(cfg_target_feature))]

src/pikevm.rs

@@ -234,7 +234,6 @@ impl<'r, I: Input> Fsm<'r, I> {
     ///
     /// at and at_next are the current and next positions in the input. at or
     /// at_next may be EOF.
-    #[allow(too_many_arguments)]
     fn step(
         &mut self,
         nlist: &mut Threads,

src/prog.rs

@@ -158,12 +158,6 @@ impl Program {
     }
 }
 
-impl Default for Program {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl Deref for Program {
     type Target = [Inst];
 

src/re_bytes.rs

@@ -785,7 +785,6 @@ pub struct Captures<'t> {
     named_groups: Arc<HashMap<String, usize>>,
 }
 
-#[allow(len_without_is_empty)]
 impl<'t> Captures<'t> {
     /// Returns the match associated with the capture group at index `i`. If
     /// `i` does not correspond to a capture group, or if the capture group
@@ -987,7 +986,7 @@ pub trait Replacer {
     /// be beneficial to avoid finding sub-captures.
     ///
     /// In general, this is called once for every call to `replacen`.
-    fn no_expansion(&mut self) -> Option<Cow<[u8]>> {
+    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, [u8]>> {
         None
     }
 }

src/re_trait.rs

@@ -20,7 +20,6 @@ pub type Slot = Option<usize>;
 #[doc(hidden)]
 pub struct Locations(Vec<Slot>);
 
-#[allow(len_without_is_empty)]
 impl Locations {
     /// Returns the start and end positions of the Nth capture group. Returns
     /// `None` if `i` is not a valid capture group or if the capture group did
@@ -165,7 +164,7 @@ pub trait RegularExpression: Sized {
     /// matches with captures.
     fn captures_iter(
         self,
-        text: & Self::Text,
+        text: &Self::Text,
     ) -> CaptureMatches<Self> {
         CaptureMatches(self.find_iter(text))
     }

src/re_unicode.rs

@@ -936,7 +936,6 @@ pub struct Captures<'t> {
     named_groups: NamedGroups,
 }
 
-#[allow(len_without_is_empty)]
 impl<'t> Captures<'t> {
     /// Returns the match associated with the capture group at index `i`. If
     /// `i` does not correspond to a capture group, or if the capture group
@@ -1199,7 +1198,7 @@ pub trait Replacer {
     /// be beneficial to avoid finding sub-captures.
     ///
     /// In general, this is called once for every call to `replacen`.
-    fn no_expansion(&mut self) -> Option<Cow<str>> {
+    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, str>> {
         None
     }
 }