borrow original/replacement data instead of cloning

Author: saites

crates/rustfix/src/lib.rs

@@ -216,34 +216,34 @@ pub fn collect_suggestions<S: ::std::hash::BuildHasher>(
 /// 2. Calls [`CodeFix::apply`] to apply suggestions to the source code.
 /// 3. Calls [`CodeFix::finish`] to get the "fixed" code.
 #[derive(Clone)]
-pub struct CodeFix {
-    data: replace::Data,
+pub struct CodeFix<'orig> {
+    data: replace::Data<'orig>,
     /// Whether or not the data has been modified.
     modified: bool,
 }
 
-impl CodeFix {
+impl<'orig> CodeFix<'orig> {
     /// Creates a `CodeFix` with the source of a file to modify.
-    pub fn new(s: &str) -> CodeFix {
+    pub fn new(s: &'orig str) -> CodeFix<'orig> {
         CodeFix {
             data: replace::Data::new(s.as_bytes()),
             modified: false,
         }
     }
 
     /// Applies a suggestion to the code.
-    pub fn apply(&mut self, suggestion: &Suggestion) -> Result<(), Error> {
+    pub fn apply(&mut self, suggestion: &'orig Suggestion) -> Result<(), Error> {
         for solution in &suggestion.solutions {
             self.apply_solution(solution)?;
         }
         Ok(())
     }
 
     /// Applies an individual solution from a [`Suggestion`].
-    pub fn apply_solution(&mut self, solution: &Solution) -> Result<(), Error> {
+    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.as_bytes())
                 .inspect_err(|_| self.data.restore())?;
         }
         self.data.commit();

crates/rustfix/src/replace.rs

@@ -24,22 +24,21 @@
 //! If you want to discard uncommitted changes, simply call [`Data::restore`] first.
 
 use std::ops::Range;
-use std::rc::Rc;
 
 use crate::error::Error;
 
 /// Data that should replace a particular range of the original.
 #[derive(Clone)]
-struct Span {
+struct Span<'orig> {
     /// Span of the parent data to be replaced, inclusive of the start, exclusive of the end.
     range: Range<usize>,
     /// New data to insert at the `start` position of the `original` data.
-    data: Rc<[u8]>,
+    data: &'orig [u8],
     /// Whether this data is committed or provisional.
     committed: bool,
 }
 
-impl std::fmt::Debug for Span {
+impl<'orig> std::fmt::Debug for Span<'orig> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let state = if self.is_insert() {
             "inserted"
@@ -61,11 +60,11 @@ impl std::fmt::Debug for Span {
     }
 }
 
-impl Span {
-    fn new(range: Range<usize>, data: &[u8]) -> Self {
+impl<'orig> Span<'orig> {
+    fn new(range: Range<usize>, data: &'orig [u8]) -> Self {
         Self {
             range,
-            data: data.into(),
+            data,
             committed: false,
         }
     }
@@ -79,7 +78,7 @@ impl Span {
     }
 }
 
-impl PartialEq for Span {
+impl<'orig> PartialEq for Span<'orig> {
     /// Returns `true` if and only if this `Span` and `other` have the same range and data,
     /// regardless of `committed` status.
     fn eq(&self, other: &Self) -> bool {
@@ -89,20 +88,20 @@ impl PartialEq for Span {
 
 /// A container that allows easily replacing chunks of its data.
 #[derive(Debug, Clone, Default)]
-pub struct Data {
+pub struct Data<'orig> {
     /// Original data.
-    original: Vec<u8>,
+    original: &'orig [u8],
     /// [`Span`]s covering the full range of the original data.
     /// Important: it's expected that the underlying implementation maintains this in order,
     /// sorted ascending by start position.
-    parts: Vec<Span>,
+    parts: Vec<Span<'orig>>,
 }
 
-impl Data {
+impl<'orig> Data<'orig> {
     /// Create a new data container from a slice of bytes
-    pub fn new(data: &[u8]) -> Self {
+    pub fn new(data: &'orig [u8]) -> Self {
         Data {
-            original: data.into(),
+            original: data.as_ref(),
             parts: vec![],
         }
     }
@@ -126,7 +125,7 @@ impl Data {
             if span.range.start > prev_end {
                 acc.extend_from_slice(&self.original[prev_end..span.range.start]);
             }
-            acc.extend_from_slice(&span.data);
+            acc.extend_from_slice(span.data);
             prev_end = span.range.end;
             acc
         });
@@ -143,7 +142,7 @@ impl Data {
     /// 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: &[u8]) -> Result<(), Error> {
+    pub fn replace_range(&mut self, range: Range<usize>, data: &'orig [u8]) -> Result<(), Error> {
         if range.start > range.end {
             return Err(Error::InvalidRange(range));
         }