Fix performance bug with Match.

When building a Match, we should avoid storing a subslice and instead
store the full string. We can punt subslicing to access. This seems to
get LLVM to optimize tight loops better when the subslice isn't needed.

Author: BurntSushi

src/re_bytes.rs

@@ -49,14 +49,14 @@ impl<'t> Match<'t> {
     /// Returns the matched text.
     #[inline]
     pub fn as_bytes(&self) -> &'t [u8] {
-        self.text
+        &self.text[self.start..self.end]
     }
 
     /// Creates a new match from the given haystack and byte offsets.
     #[inline]
     fn new(haystack: &'t [u8], start: usize, end: usize) -> Match<'t> {
         Match {
-            text: &haystack[start..end],
+            text: haystack,
             start: start,
             end: end,
         }
@@ -483,20 +483,19 @@ impl Regex {
         mut rep: R,
     ) -> Cow<'t, [u8]> {
         if let Some(rep) = rep.no_expansion() {
-            let mut it = self.find_iter(text).enumerate().peekable();
-            if it.peek().is_none() {
-                return Cow::Borrowed(text);
-            }
             let mut new = Vec::with_capacity(text.len());
             let mut last_match = 0;
-            for (i, m) in it {
+            for (i, m) in self.find_iter(text).enumerate() {
                 if limit > 0 && i >= limit {
                     break
                 }
                 new.extend_from_slice(&text[last_match..m.start()]);
                 new.extend_from_slice(&rep);
                 last_match = m.end();
             }
+            if new.is_empty() {
+                return Cow::Borrowed(text);
+            }
             new.extend_from_slice(&text[last_match..]);
             return Cow::Owned(new);
         }

src/re_unicode.rs

@@ -59,14 +59,14 @@ impl<'t> Match<'t> {
     /// Returns the matched text.
     #[inline]
     pub fn as_str(&self) -> &'t str {
-        self.text
+        &self.text[self.start..self.end]
     }
 
     /// Creates a new match from the given haystack and byte offsets.
     #[inline]
     fn new(haystack: &'t str, start: usize, end: usize) -> Match<'t> {
         Match {
-            text: &haystack[start..end],
+            text: haystack,
             start: start,
             end: end,
         }
@@ -559,20 +559,19 @@ impl Regex {
         //      replacements inside the replacement string. We just push it
         //      at each match and be done with it.
         if let Some(rep) = rep.no_expansion() {
-            let mut it = self.find_iter(text).enumerate().peekable();
-            if it.peek().is_none() {
-                return Cow::Borrowed(text);
-            }
             let mut new = String::with_capacity(text.len());
             let mut last_match = 0;
-            for (i, m) in it {
+            for (i, m) in self.find_iter(text).enumerate() {
                 if limit > 0 && i >= limit {
                     break
                 }
                 new.push_str(&text[last_match..m.start()]);
                 new.push_str(&rep);
                 last_match = m.end();
             }
+            if new.is_empty() {
+                return Cow::Borrowed(text);
+            }
             new.push_str(&text[last_match..]);
             return Cow::Owned(new);
         }