accept both &[u8] and &str in rustfix methods

Author: saites

crates/rustfix/src/lib.rs

@@ -226,7 +226,7 @@ impl<'orig> CodeFix<'orig> {
     /// Creates a `CodeFix` with the source of a file to modify.
     pub fn new(s: &'orig str) -> CodeFix<'orig> {
         CodeFix {
-            data: replace::Data::new(s.as_bytes()),
+            data: replace::Data::new(s),
             modified: false,
         }
     }
@@ -243,7 +243,7 @@ impl<'orig> CodeFix<'orig> {
     pub fn apply_solution(&mut self, solution: &'orig Solution) -> Result<(), Error> {
         for r in &solution.replacements {
             self.data
-                .replace_range(r.snippet.range.clone(), &r.replacement.as_bytes())
+                .replace_range(r.snippet.range.clone(), &r.replacement)
                 .inspect_err(|_| self.data.restore())?;
         }
         self.data.commit();

crates/rustfix/src/replace.rs

@@ -99,7 +99,10 @@ pub struct Data<'orig> {
 
 impl<'orig> Data<'orig> {
     /// Create a new data container from a slice of bytes
-    pub fn new(data: &'orig [u8]) -> Self {
+    pub fn new<T>(data: &'orig T) -> Self
+    where
+        T: AsRef<[u8]> + ?Sized,
+    {
         Data {
             original: data.as_ref(),
             parts: vec![],
@@ -142,7 +145,10 @@ impl<'orig> Data<'orig> {
     /// this method will return an error.
     /// It will also return an error if the beginning of the range comes before its end,
     /// or if the range is outside that of the original data.
-    pub fn replace_range(&mut self, range: Range<usize>, data: &'orig [u8]) -> Result<(), Error> {
+    pub fn replace_range<T>(&mut self, range: Range<usize>, data: &'orig T) -> Result<(), Error>
+    where
+        T: AsRef<[u8]> + ?Sized,
+    {
         if range.start > range.end {
             return Err(Error::InvalidRange(range));
         }
@@ -198,63 +204,63 @@ mod tests {
 
     #[test]
     fn insert_at_beginning() {
-        let mut d = Data::new(b"foo bar baz");
-        d.replace_range(0..0, b"oh no ").unwrap();
+        let mut d = Data::new("foo bar baz");
+        d.replace_range(0..0, "oh no ").unwrap();
         assert_eq!("oh no foo bar baz", str(&d.to_vec()));
     }
 
     #[test]
     fn insert_at_end() {
-        let mut d = Data::new(b"foo bar baz");
-        d.replace_range(11..11, b" oh no").unwrap();
+        let mut d = Data::new("foo bar baz");
+        d.replace_range(11..11, " oh no").unwrap();
         assert_eq!("foo bar baz oh no", str(&d.to_vec()));
     }
 
     #[test]
     fn replace_some_stuff() {
-        let mut d = Data::new(b"foo bar baz");
-        d.replace_range(4..7, b"lol").unwrap();
+        let mut d = Data::new("foo bar baz");
+        d.replace_range(4..7, "lol").unwrap();
         assert_eq!("foo lol baz", str(&d.to_vec()));
     }
 
     #[test]
     fn replace_a_single_char() {
-        let mut d = Data::new(b"let y = true;");
-        d.replace_range(4..5, b"mut y").unwrap();
+        let mut d = Data::new("let y = true;");
+        d.replace_range(4..5, "mut y").unwrap();
         assert_eq!("let mut y = true;", str(&d.to_vec()));
     }
 
     #[test]
     fn replace_multiple_lines() {
-        let mut d = Data::new(b"lorem\nipsum\ndolor");
+        let mut d = Data::new("lorem\nipsum\ndolor");
 
-        d.replace_range(6..11, b"lol").unwrap();
+        d.replace_range(6..11, "lol").unwrap();
         assert_eq!("lorem\nlol\ndolor", str(&d.to_vec()));
 
-        d.replace_range(12..17, b"lol").unwrap();
+        d.replace_range(12..17, "lol").unwrap();
         assert_eq!("lorem\nlol\nlol", str(&d.to_vec()));
     }
 
     #[test]
     fn replace_multiple_lines_with_insert_only() {
-        let mut d = Data::new(b"foo!");
+        let mut d = Data::new("foo!");
 
-        d.replace_range(3..3, b"bar").unwrap();
+        d.replace_range(3..3, "bar").unwrap();
         assert_eq!("foobar!", str(&d.to_vec()));
 
-        d.replace_range(0..3, b"baz").unwrap();
+        d.replace_range(0..3, "baz").unwrap();
         assert_eq!("bazbar!", str(&d.to_vec()));
 
-        d.replace_range(3..4, b"?").unwrap();
+        d.replace_range(3..4, "?").unwrap();
         assert_eq!("bazbar?", str(&d.to_vec()));
     }
 
     #[test]
     fn replace_invalid_range() {
-        let mut d = Data::new(b"foo!");
+        let mut d = Data::new("foo!");
 
-        assert!(d.replace_range(2..1, b"bar").is_err());
-        assert!(d.replace_range(0..3, b"bar").is_ok());
+        assert!(d.replace_range(2..1, "bar").is_err());
+        assert!(d.replace_range(0..3, "bar").is_ok());
     }
 
     #[test]
@@ -265,13 +271,13 @@ mod tests {
 
     #[test]
     fn replace_same_range_diff_data() {
-        let mut d = Data::new(b"foo bar baz");
+        let mut d = Data::new("foo bar baz");
 
-        d.replace_range(4..7, b"lol").unwrap();
+        d.replace_range(4..7, "lol").unwrap();
         assert_eq!("foo lol baz", str(&d.to_vec()));
 
         assert!(matches!(
-            d.replace_range(4..7, b"lol2").unwrap_err(),
+            d.replace_range(4..7, "lol2").unwrap_err(),
             Error::AlreadyReplaced {
                 is_identical: false,
                 ..
@@ -281,13 +287,13 @@ mod tests {
 
     #[test]
     fn replace_same_range_same_data() {
-        let mut d = Data::new(b"foo bar baz");
+        let mut d = Data::new("foo bar baz");
 
-        d.replace_range(4..7, b"lol").unwrap();
+        d.replace_range(4..7, "lol").unwrap();
         assert_eq!("foo lol baz", str(&d.to_vec()));
 
         assert!(matches!(
-            d.replace_range(4..7, b"lol").unwrap_err(),
+            d.replace_range(4..7, "lol").unwrap_err(),
             Error::AlreadyReplaced {
                 is_identical: true,
                 ..
@@ -297,28 +303,35 @@ mod tests {
 
     #[test]
     fn broken_replacements() {
-        let mut d = Data::new(b"foo");
+        let mut d = Data::new("foo");
         assert!(matches!(
-            d.replace_range(4..8, b"lol").unwrap_err(),
+            d.replace_range(4..8, "lol").unwrap_err(),
             Error::DataLengthExceeded(std::ops::Range { start: 4, end: 8 }, 3),
         ));
     }
 
     #[test]
-    fn replace_same_twice() {
-        let mut d = Data::new(b"foo");
-        d.replace_range(0..1, b"b").unwrap();
-        d.replace_range(0..1, b"b").unwrap_err();
-        assert_eq!("boo", str(&d.to_vec()));
+    fn insert_same_twice() {
+        let mut d = Data::new("foo");
+        d.replace_range(1..1, "b").unwrap();
+        assert_eq!("fboo", str(&d.to_vec()));
+        assert!(matches!(
+            d.replace_range(1..1, "b").unwrap_err(),
+            Error::AlreadyReplaced {
+                is_identical: true,
+                ..
+            },
+        ));
+        assert_eq!("fboo", str(&d.to_vec()));
     }
 
     #[test]
     fn commit_restore() {
-        let mut d = Data::new(b", ");
+        let mut d = Data::new(", ");
         assert_eq!(", ", str(&d.to_vec()));
 
-        d.replace_range(2..2, b"world").unwrap();
-        d.replace_range(0..0, b"hello").unwrap();
+        d.replace_range(2..2, "world").unwrap();
+        d.replace_range(0..0, "hello").unwrap();
         assert_eq!("hello, world", str(&d.to_vec()));
 
         d.restore();
@@ -327,14 +340,14 @@ mod tests {
         d.commit();
         assert_eq!(", ", str(&d.to_vec()));
 
-        d.replace_range(2..2, b"world").unwrap();
+        d.replace_range(2..2, "world").unwrap();
         assert_eq!(", world", str(&d.to_vec()));
         d.commit();
         assert_eq!(", world", str(&d.to_vec()));
         d.restore();
         assert_eq!(", world", str(&d.to_vec()));
 
-        d.replace_range(0..0, b"hello").unwrap();
+        d.replace_range(0..0, "hello").unwrap();
         assert_eq!("hello, world", str(&d.to_vec()));
         d.commit();
         assert_eq!("hello, world", str(&d.to_vec()));
@@ -345,7 +358,7 @@ mod tests {
     proptest! {
         #[test]
         fn new_to_vec_roundtrip(ref s in "\\PC*") {
-            assert_eq!(s.as_bytes(), Data::new(s.as_bytes()).to_vec().as_slice());
+            assert_eq!(s.as_bytes(), &Data::new(s).to_vec());
         }
 
         #[test]
@@ -356,7 +369,7 @@ mod tests {
                 1..100,
             )
         ) {
-            let mut d = Data::new(data.as_bytes());
+            let mut d = Data::new(data);
             for &(ref range, ref bytes) in replacements {
                 let _ = d.replace_range(range.clone(), bytes);
             }