refactor: use custom error instead of anyhow

crates/rustfix/Cargo.toml

@@ -18,12 +18,13 @@ exclude = [
 ]
 
 [dependencies]
-anyhow.workspace = true
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
+thiserror.workspace = true
 tracing.workspace = true
 
 [dev-dependencies]
+anyhow.workspace = true
 proptest.workspace = true
 similar = "2.2.1"
 tempfile.workspace = true

crates/rustfix/src/error.rs

@@ -0,0 +1,21 @@
+//! Error types.
+
+use std::ops::Range;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+ #[error("invalid range {0:?}, start is larger than end")]
+ InvalidRange(Range<usize>),
+
+ #[error("invalid range {0:?}, original data is only {1} byte long")]
+ DataLengthExceeded(Range<usize>, usize),
+
+ #[error("could not replace range {0:?}, maybe parts of it were already replaced?")]
+ MaybeAlreadyReplaced(Range<usize>),
+
+ #[error("cannot replace slice of data that was already replaced")]
+ AlreadyReplaced,
+
+ #[error(transparent)]
+ Utf8(#[from] std::string::FromUtf8Error),
+}

crates/rustfix/src/lib.rs

@@ -22,12 +22,14 @@
 use std::collections::HashSet;
 use std::ops::Range;
 
-use anyhow::Error;
-
 pub mod diagnostics;
-use crate::diagnostics::{Diagnostic, DiagnosticSpan};
+mod error;
 mod replace;
 
+use diagnostics::Diagnostic;
+use diagnostics::DiagnosticSpan;
+pub use error::Error;
+
 /// A filter to control which suggestion should be applied.
 #[derive(Debug, Clone, Copy)]
 pub enum Filter {

crates/rustfix/src/replace.rs

@@ -2,9 +2,10 @@
 //! replacement of parts of its content, with the ability to prevent changing
 //! the same parts multiple times.
 
-use anyhow::{anyhow, ensure, Error};
 use std::rc::Rc;
 
+use crate::error::Error;
+
 /// Indicates the change state of a [`Span`].
 #[derive(Debug, Clone, PartialEq, Eq)]
 enum State {
@@ -77,22 +78,13 @@ impl Data {
  range: std::ops::Range<usize>,
  data: &[u8],
  ) -> Result<(), Error> {
- let exclusive_end = range.end;
-
- ensure!(
- range.start <= exclusive_end,
- "Invalid range {}..{}, start is larger than end",
- range.start,
- range.end
- );
-
- ensure!(
- exclusive_end <= self.original.len(),
- "Invalid range {}..{} given, original data is only {} byte long",
- range.start,
- range.end,
- self.original.len()
- );
+ if range.start > range.end {
+ return Err(Error::InvalidRange(range));
+ }
+
+ if range.end > self.original.len() {
+ return Err(Error::DataLengthExceeded(range, self.original.len()));
+ }
 
  let insert_only = range.start == range.end;
 
@@ -106,42 +98,35 @@ impl Data {
  // the whole chunk. As an optimization and without loss of generality we
  // don't add empty parts.
  let new_parts = {
- let index_of_part_to_split = self
- .parts
- .iter()
- .position(|p| !p.data.is_inserted() && p.start <= range.start && p.end >= range.end)
- .ok_or_else(|| {
- if tracing::enabled!(tracing::Level::DEBUG) {
- let slices = self
- .parts
- .iter()
- .map(|p| {
- (
- p.start,
- p.end,
- match p.data {
- State::Initial => "initial",
- State::Replaced(..) => "replaced",
- State::Inserted(..) => "inserted",
- },
- )
- })
- .collect::<Vec<_>>();
- tracing::debug!(
- "no single slice covering {}..{}, current slices: {:?}",
- range.start,
- range.end,
- slices,
- );
- }
-
- anyhow!(
- "Could not replace range {}..{} in file \
- -- maybe parts of it were already replaced?",
+ let Some(index_of_part_to_split) = self.parts.iter().position(|p| {
+ !p.data.is_inserted() && p.start <= range.start && p.end >= range.end
+ }) else {
+ if tracing::enabled!(tracing::Level::DEBUG) {
+ let slices = self
+ .parts
+ .iter()
+ .map(|p| {
+ (
+ p.start,
+ p.end,
+ match p.data {
+ State::Initial => "initial",
+ State::Replaced(..) => "replaced",
+ State::Inserted(..) => "inserted",
+ },
+ )
+ })
+ .collect::<Vec<_>>();
+ tracing::debug!(
+ "no single slice covering {}..{}, current slices: {:?}",
  range.start,
  range.end,
- )
- })?;
+ slices,
+ );
+ }
+
+ return Err(Error::MaybeAlreadyReplaced(range));
+ };
 
  let part_to_split = &self.parts[index_of_part_to_split];
 
@@ -161,10 +146,9 @@ impl Data {
  }
  }
 
- ensure!(
- part_to_split.data == State::Initial,
- "Cannot replace slice of data that was already replaced"
- );
+ if part_to_split.data != State::Initial {
+ return Err(Error::AlreadyReplaced);
+ }
 
  let mut new_parts = Vec::with_capacity(self.parts.len() + 2);
 
@@ -293,21 +277,25 @@ mod tests {
  }
 
  #[test]
- #[should_panic(expected = "Cannot replace slice of data that was already replaced")]
  fn replace_overlapping_stuff_errs() {
  let mut d = Data::new(b"foo bar baz");
 
  d.replace_range(4..7, b"lol").unwrap();
  assert_eq!("foo lol baz", str(&d.to_vec()));
 
- d.replace_range(4..7, b"lol2").unwrap();
+ assert!(matches!(
+ d.replace_range(4..7, b"lol2").unwrap_err(),
+ Error::AlreadyReplaced,
+ ));
  }
 
  #[test]
- #[should_panic(expected = "original data is only 3 byte long")]
  fn broken_replacements() {
  let mut d = Data::new(b"foo");
- d.replace_range(4..8, b"lol").unwrap();
+ assert!(matches!(
+ d.replace_range(4..8, b"lol").unwrap_err(),
+ Error::DataLengthExceeded(std::ops::Range { start: 4, end: 8 }, 3),
+ ));
  }
 
  #[test]