Revert "Fix #186."

The fix is totally bogus. We obviously can't do anything meaningful with
recording matches while computing cached states, since once a state is
cached, we won't actually record the match.

Stay tuned for greener pastures.

This reverts commit 3fb34e2.

Author: BurntSushi

src/compile.rs

@@ -998,7 +998,7 @@ impl ByteClassSet {
         // N.B. If you're debugging the DFA, it's useful to simply return
         // `(0..256).collect()`, which effectively removes the byte classes
         // and makes the transitions easier to read.
-        // return (0..256).map(|b| b as u8).collect();
+        // return (0..256).collect();
         let mut byte_classes = vec![0; 256];
         let mut class = 0u8;
         for i in 0..256 {

src/dfa.rs

@@ -46,7 +46,7 @@ use std::fmt;
 use std::mem;
 
 use exec::Search;
-use prog::Program;
+use prog::{Inst, Program};
 use sparse::SparseSet;
 
 /// The cache limit specifies approximately how much space we're willing to
@@ -465,7 +465,6 @@ impl<'a, 'b, 'c, 'm> Dfa<'a, 'b, 'c, 'm> {
             }
             self.at += 1;
         }
-        // println!("exiting loop at input {:?}", self.at);
         // Run the DFA once more on the special EOF senitnel value.
         si = match self.next_state(qcur, qnext, si, Byte::eof()) {
             None => return DfaResult::Quit,
@@ -482,6 +481,13 @@ impl<'a, 'b, 'c, 'm> Dfa<'a, 'b, 'c, 'm> {
             result = DfaResult::Match;
             self.search.set_end(Some(text.len()));
         }
+        if result.is_match() && !self.search.find_one_match() {
+            for &ip in &self.states[si as usize].insts {
+                if let Inst::Match(slot) = self.prog[ip as usize] {
+                    self.search.set_match(slot);
+                }
+            }
+        }
         result
     }
 
@@ -622,16 +628,16 @@ impl<'a, 'b, 'c, 'm> Dfa<'a, 'b, 'c, 'm> {
                 Char(_) | Ranges(_) => unreachable!(),
                 // These states are handled when following epsilon transitions.
                 Save(_) | Split(_) | EmptyLook(_) => {}
-                Match(slot) => {
+                Match(_) => {
                     is_match = true;
                     if !self.continue_past_first_match() {
                         break;
-                    } else if !self.search.find_one_match()
-                            && !self.search.has_match(slot)
-                            && !qnext.contains_ip(ip as usize) {
+                    } else if !self.search.find_one_match() {
                         // If we are continuing on to find other matches,
                         // then keep a record of the match states we've seen.
-                        qnext.add(ip);
+                        if !qnext.contains_ip(ip as usize) {
+                            qnext.add(ip);
+                        }
                     }
                 }
                 Bytes(ref inst) => {
@@ -870,9 +876,8 @@ impl<'a, 'b, 'c, 'm> Dfa<'a, 'b, 'c, 'm> {
                         | NotWordBoundaryAscii => unreachable!(),
                     }
                 }
-                Match(slot) => {
+                Match(_) => {
                     insts.push(ip);
-                    self.search.set_match(slot);
                     if !self.continue_past_first_match() {
                         break;
                     }

src/exec.rs

@@ -76,10 +76,6 @@ impl<'caps, 'matches> Search<'caps, 'matches> {
         self.matches.iter().all(|m| *m)
     }
 
-    pub fn has_match(&mut self, match_slot: usize) -> bool {
-        self.matches.get(match_slot).map_or(false, |&b| b)
-    }
-
     pub fn set_match(&mut self, match_slot: usize) {
         self.matched_any = true;
         if let Some(old) = self.matches.get_mut(match_slot) {