feat(error): offset-based span tracking

Cargo.toml

@@ -18,6 +18,9 @@ color = ["dep:anstyle"]
 [dependencies]
 anstyle = { version = "1.0.13", optional = true }
 
+[dev-dependencies]
+snapbox = "0.6.24"
+
 [[example]]
 name = "patch_formatter"
 required-features = ["color"]

src/patch/error.rs

@@ -1,26 +1,46 @@
 //! Error types for patch parsing.
 
 use std::fmt;
+use std::ops::Range;
 
 /// An error returned when parsing a `Patch` using [`Patch::from_str`] fails.
 ///
 /// [`Patch::from_str`]: struct.Patch.html#method.from_str
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ParsePatchError {
     pub(crate) kind: ParsePatchErrorKind,
+    span: Option<Range<usize>>,
+}
+
+impl ParsePatchError {
+    /// Creates a new error with the given kind and span.
+    pub(crate) fn new(kind: ParsePatchErrorKind, span: Range<usize>) -> Self {
+        Self {
+            kind,
+            span: Some(span),
+        }
+    }
 }
 
 impl fmt::Display for ParsePatchError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "error parsing patch: {}", self.kind)
+        if let Some(span) = &self.span {
+            write!(
+                f,
+                "error parsing patch at byte {}: {}",
+                span.start, self.kind
+            )
+        } else {
+            write!(f, "error parsing patch: {}", self.kind)
+        }
     }
 }
 
 impl std::error::Error for ParsePatchError {}
 
 impl From<ParsePatchErrorKind> for ParsePatchError {
     fn from(kind: ParsePatchErrorKind) -> Self {
-        Self { kind }
+        Self { kind, span: None }
     }
 }
 

src/patch/mod.rs

@@ -3,6 +3,8 @@ mod format;
 mod parse;
 #[cfg(feature = "color")]
 mod style;
+#[cfg(test)]
+mod tests;
 
 pub use error::ParsePatchError;
 pub use format::PatchFormatter;