From de8b933c6449f61a2699cb59fe215fd6e91a987a Mon Sep 17 00:00:00 2001
From: Ingvar Stepanyan <me@rreverser.com>
Date: Sun, 9 Sep 2018 00:41:34 +0100
Subject: [PATCH] Remove c_literal and c_bytes methods

These seem obsolete and invoke expensive allocations when in fact a direct call to c_char or c_byte would suffice.
---
 src/compile.rs | 40 ++--------------------------------------
 1 file changed, 2 insertions(+), 38 deletions(-)

diff --git a/src/compile.rs b/src/compile.rs
index 6f2321ec05..57793d420b 100644
--- a/src/compile.rs
+++ b/src/compile.rs
@@ -263,11 +263,11 @@ impl Compiler {
         match *expr.kind() {
             Empty => Ok(Patch { hole: Hole::None, entry: self.insts.len() }),
             Literal(hir::Literal::Unicode(c)) => {
-                self.c_literal(&[c])
+                self.c_char(c)
             }
             Literal(hir::Literal::Byte(b)) => {
                 assert!(self.compiled.uses_bytes());
-                self.c_bytes(&[b])
+                self.c_byte(b)
             }
             Class(hir::Class::Unicode(ref cls)) => {
                 self.c_class(cls.ranges())
@@ -395,24 +395,6 @@ impl Compiler {
         })
     }
 
-    fn c_literal(&mut self, chars: &[char]) -> Result {
-        debug_assert!(!chars.is_empty());
-        let mut chars: Box<Iterator<Item=&char>> =
-            if self.compiled.is_reverse {
-                Box::new(chars.iter().rev())
-            } else {
-                Box::new(chars.iter())
-            };
-        let first = *chars.next().expect("non-empty literal");
-        let Patch { mut hole, entry } = self.c_char(first)?;
-        for &c in chars {
-            let p = self.c_char(c)?;
-            self.fill(hole, p.entry);
-            hole = p.hole;
-        }
-        Ok(Patch { hole: hole, entry: entry })
-    }
-
     fn c_char(&mut self, c: char) -> Result {
         self.c_class(&[hir::ClassUnicodeRange::new(c, c)])
     }
@@ -436,24 +418,6 @@ impl Compiler {
         }
     }
 
-    fn c_bytes(&mut self, bytes: &[u8]) -> Result {
-        debug_assert!(!bytes.is_empty());
-        let mut bytes: Box<Iterator<Item=&u8>> =
-            if self.compiled.is_reverse {
-                Box::new(bytes.iter().rev())
-            } else {
-                Box::new(bytes.iter())
-            };
-        let first = *bytes.next().expect("non-empty literal");
-        let Patch { mut hole, entry } = self.c_byte(first)?;
-        for &b in bytes {
-            let p = self.c_byte(b)?;
-            self.fill(hole, p.entry);
-            hole = p.hole;
-        }
-        Ok(Patch { hole: hole, entry: entry })
-    }
-
     fn c_byte(&mut self, b: u8) -> Result {
         self.c_class_bytes(&[hir::ClassBytesRange::new(b, b)])
     }