writer error contains filename

rizsotto · rizsotto · commit 835a06b2b12b · 2025-08-01T15:00:15.000+10:00
diff --git a/bear/src/modes/execution.rs b/bear/src/modes/execution.rs
@@ -4,7 +4,7 @@ use crate::args::BuildCommand;
 use crate::intercept;
 use crate::intercept::supervise::SuperviseError;
 use crate::intercept::tcp::ReceivingError;
-use crate::output::FormatError;
+use crate::output::WriterError;
 use crossbeam_channel::{bounded, unbounded, Receiver};
 use std::process::{ExitCode, ExitStatus};
 use std::sync::Arc;
@@ -28,7 +28,7 @@ pub trait Consumer: Send {
     /// # Returns
     /// * `Ok(())` - All items were successfully processed
     /// * `Err(FormatError)` - An error occurred during processing
-    fn consume(self: Box<Self>, receiver: Receiver<intercept::Event>) -> Result<(), FormatError>;
+    fn consume(self: Box<Self>, receiver: Receiver<intercept::Event>) -> Result<(), WriterError>;
 }
 
 /// A trait for producing events to a channel-based stream.
@@ -235,7 +235,7 @@ pub enum RuntimeError {
     #[error("Producer error: {0}")]
     Producer(#[from] ReceivingError),
     #[error("Consumer error: {0}")]
-    Consumer(#[from] FormatError),
+    Consumer(#[from] WriterError),
     #[error("Executor error: {0}")]
     Executor(#[from] SuperviseError),
     #[error("Thread error: {0}")]
@@ -246,6 +246,7 @@ pub enum RuntimeError {
 mod tests {
     use super::*;
     use crate::intercept::Event;
+    use crate::output::{SerializationError, WriterError};
     use std::collections::HashMap;
     use std::sync::{Arc, Mutex};
     use std::time::Duration;
@@ -465,10 +466,12 @@ mod tests {
         });
 
         let mut consumer_mock = MockConsumer::new();
-        consumer_mock
-            .expect_consume()
-            .times(1)
-            .returning(|_| Err(FormatError::Io(std::io::Error::other("Test failure"))));
+        consumer_mock.expect_consume().times(1).returning(|_| {
+            Err(WriterError::Io(
+                std::path::PathBuf::new(),
+                SerializationError::Io(std::io::Error::other("Test failure")),
+            ))
+        });
 
         let replayer = Replayer::new(Box::new(producer_mock), Box::new(consumer_mock));
         let result = replayer.run();
@@ -632,10 +635,12 @@ mod tests {
         let producer_mock = Arc::new(MockCancellableProducer::new(events));
 
         let mut consumer_mock = MockConsumer::new();
-        consumer_mock
-            .expect_consume()
-            .times(1)
-            .returning(|_| Err(FormatError::Io(std::io::Error::other("Test failure"))));
+        consumer_mock.expect_consume().times(1).returning(|_| {
+            Err(WriterError::Io(
+                std::path::PathBuf::new(),
+                SerializationError::Io(std::io::Error::other("Test failure")),
+            ))
+        });
 
         let mut executor_mock = MockExecutor::new();
         executor_mock
diff --git a/bear/src/modes/mod.rs b/bear/src/modes/mod.rs
@@ -124,7 +124,9 @@ mod impls {
     use crate::intercept::environment;
     use crate::intercept::supervise::SuperviseError;
     use crate::intercept::tcp::{CollectorOnTcp, ReceivingError};
-    use crate::output::{ExecutionEventDatabase, FileFormat, FormatError, WriterCreationError};
+    use crate::output::{
+        ExecutionEventDatabase, SerializationFormat, WriterCreationError, WriterError,
+    };
     use crate::{args, config, intercept, output, semantic};
     use crossbeam_channel::{Receiver, Sender};
     use std::process::ExitStatus;
@@ -221,26 +223,29 @@ mod impls {
     /// The raw event writer will write the intercepted events as they are observed
     /// without any transformation. This can be later replayed to analyze the build.
     pub(super) struct RawEventWriter {
+        path: path::PathBuf,
         destination: io::BufWriter<fs::File>,
     }
 
     impl RawEventWriter {
         /// Create a new raw event writer.
         ///
         /// This writer will write the intercepted events to a file in a raw format.
-        pub(super) fn create(file_name: &str) -> Result<Self, WriterCreationError> {
-            let destination = fs::File::create(file_name)
+        pub(super) fn create(filename: &str) -> Result<Self, WriterCreationError> {
+            let path = path::PathBuf::from(filename);
+            let destination = fs::File::create(filename)
                 .map(io::BufWriter::new)
-                .map_err(WriterCreationError::Io)?;
+                .map_err(|err| WriterCreationError::Io(path.clone(), err))?;
 
-            Ok(Self { destination })
+            Ok(Self { path, destination })
         }
     }
 
     impl execution::Consumer for RawEventWriter {
         /// Using existing file format, write the intercepted events to the output file.
-        fn consume(self: Box<Self>, events: Receiver<intercept::Event>) -> Result<(), FormatError> {
+        fn consume(self: Box<Self>, events: Receiver<intercept::Event>) -> Result<(), WriterError> {
             ExecutionEventDatabase::write(self.destination, events.into_iter())
+                .map_err(|err| WriterError::Io(self.path.clone(), err))
         }
     }
 
@@ -278,7 +283,7 @@ mod impls {
     impl execution::Consumer for SemanticEventWriter {
         /// Consume the intercepted events, and transform them into semantic events,
         /// and write them into the target file (with the right format).
-        fn consume(self: Box<Self>, events: Receiver<intercept::Event>) -> Result<(), FormatError> {
+        fn consume(self: Box<Self>, events: Receiver<intercept::Event>) -> Result<(), WriterError> {
             // Transform and log the events to semantics.
             let semantics = events
                 .into_iter()
diff --git a/bear/src/output/formats.rs b/bear/src/output/formats.rs
@@ -7,25 +7,25 @@
 //! - The semantic database format. (Internal format of this project.)
 //! - The execution event database format. (Internal format of this project.)
 
-use super::{json, FormatError};
+use super::json;
 use crate::{intercept, semantic, semantic::clang};
 use serde_json::de::IoRead;
 use serde_json::StreamDeserializer;
-use std::io;
+use thiserror::Error;
 
 /// The trait represents a file format that can be written to and read from.
 ///
 /// The file format in this project is usually a sequence of values. This trait
 /// provides a type-independent abstraction over the file format.
-pub trait FileFormat<T> {
-    fn write(_: impl io::Write, _: impl Iterator<Item = T>) -> Result<(), FormatError>;
+pub trait SerializationFormat<T> {
+    fn write(_: impl std::io::Write, _: impl Iterator<Item = T>) -> Result<(), SerializationError>;
 
-    fn read(_: impl io::Read) -> impl Iterator<Item = Result<T, FormatError>>;
+    fn read(_: impl std::io::Read) -> impl Iterator<Item = Result<T, SerializationError>>;
 
     /// Reads the entries from the file and ignores any errors.
     /// This is not always feasible, when the file format is strict.
     fn read_and_ignore(
-        reader: impl io::Read,
+        reader: impl std::io::Read,
         message_writer: impl Fn(&str),
     ) -> impl Iterator<Item = T> {
         Self::read(reader).filter_map(move |result| match result {
@@ -38,6 +38,17 @@ pub trait FileFormat<T> {
     }
 }
 
+/// Represents errors that can occur while working with file formats.
+#[derive(Debug, Error)]
+pub enum SerializationError {
+    #[error("Generic IO error: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("Format syntax error: {0}")]
+    Syntax(#[from] serde_json::Error),
+    #[error("Format semantic error: {0}")]
+    Semantic(#[from] clang::EntryError),
+}
+
 /// The type represents a JSON compilation database format.
 ///
 /// The format is a JSON array format, which is a sequence of JSON objects
@@ -49,28 +60,30 @@ pub trait FileFormat<T> {
 /// https://clang.llvm.org/docs/JSONCompilationDatabase.html
 pub struct JsonCompilationDatabase;
 
-impl FileFormat<clang::Entry> for JsonCompilationDatabase {
+impl SerializationFormat<clang::Entry> for JsonCompilationDatabase {
     fn write(
-        writer: impl io::Write,
+        writer: impl std::io::Write,
         entries: impl Iterator<Item = clang::Entry>,
-    ) -> Result<(), FormatError> {
+    ) -> Result<(), SerializationError> {
         json::serialize_result_seq(
             writer,
             // Ensure only valid entries are serialized.
             entries.map(|entry| match entry.validate() {
                 Ok(_) => Ok(entry),
-                Err(err) => Err(FormatError::Semantic(err)),
+                Err(err) => Err(SerializationError::Semantic(err)),
             }),
         )
     }
 
-    fn read(reader: impl io::Read) -> impl Iterator<Item = Result<clang::Entry, FormatError>> {
+    fn read(
+        reader: impl std::io::Read,
+    ) -> impl Iterator<Item = Result<clang::Entry, SerializationError>> {
         json::deserialize_seq(reader).map(|res| {
-            res.map_err(FormatError::Syntax)
+            res.map_err(SerializationError::Syntax)
                 // Ensure only valid entries are returned.
                 .and_then(|entry: clang::Entry| match entry.validate() {
                     Ok(_) => Ok(entry),
-                    Err(err) => Err(FormatError::Semantic(err)),
+                    Err(err) => Err(SerializationError::Semantic(err)),
                 })
         })
     }
@@ -86,14 +99,16 @@ impl FileFormat<clang::Entry> for JsonCompilationDatabase {
 /// The output format is not stable and may change in future versions.
 pub struct JsonSemanticDatabase;
 
-impl FileFormat<semantic::Command> for JsonSemanticDatabase {
+impl SerializationFormat<semantic::Command> for JsonSemanticDatabase {
     fn write(
-        writer: impl io::Write,
+        writer: impl std::io::Write,
         entries: impl Iterator<Item = semantic::Command>,
-    ) -> Result<(), FormatError> {
-        json::serialize_seq(writer, entries).map_err(FormatError::Syntax)
+    ) -> Result<(), SerializationError> {
+        json::serialize_seq(writer, entries).map_err(SerializationError::Syntax)
     }
-    fn read(_: impl io::Read) -> impl Iterator<Item = Result<semantic::Command, FormatError>> {
+    fn read(
+        _: impl std::io::Read,
+    ) -> impl Iterator<Item = Result<semantic::Command, SerializationError>> {
         // Not implemented! (No reader for the semantic output in this project.)
         std::iter::empty()
     }
@@ -108,22 +123,24 @@ impl FileFormat<semantic::Command> for JsonSemanticDatabase {
 /// The output format is not stable and may change in future versions.
 pub struct ExecutionEventDatabase;
 
-impl FileFormat<intercept::Event> for ExecutionEventDatabase {
+impl SerializationFormat<intercept::Event> for ExecutionEventDatabase {
     fn write(
-        writer: impl io::Write,
+        writer: impl std::io::Write,
         events: impl Iterator<Item = intercept::Event>,
-    ) -> Result<(), FormatError> {
+    ) -> Result<(), SerializationError> {
         let mut writer = writer;
         for event in events {
-            serde_json::to_writer(&mut writer, &event).map_err(FormatError::Syntax)?;
-            writer.write_all(b"\n").map_err(FormatError::Io)?;
+            serde_json::to_writer(&mut writer, &event).map_err(SerializationError::Syntax)?;
+            writer.write_all(b"\n").map_err(SerializationError::Io)?;
         }
         Ok(())
     }
 
-    fn read(reader: impl io::Read) -> impl Iterator<Item = Result<intercept::Event, FormatError>> {
+    fn read(
+        reader: impl std::io::Read,
+    ) -> impl Iterator<Item = Result<intercept::Event, SerializationError>> {
         let stream = StreamDeserializer::new(IoRead::new(reader));
-        stream.map(|value| value.map_err(FormatError::Syntax))
+        stream.map(|value| value.map_err(SerializationError::Syntax))
     }
 }
 
@@ -132,15 +149,15 @@ mod test {
     mod compilation_database {
         use super::super::semantic::clang::{Entry, EntryError};
         use super::super::JsonCompilationDatabase as Sut;
-        use super::super::{FileFormat, FormatError};
+        use super::super::{SerializationError, SerializationFormat};
         use serde_json::error::Category;
         use serde_json::json;
         use std::io::{Cursor, Seek, SeekFrom};
 
         macro_rules! assert_json_error {
             ($x:expr) => {
                 match $x {
-                    Some(Err(FormatError::Syntax(error))) => {
+                    Some(Err(SerializationError::Syntax(error))) => {
                         assert_eq!(error.classify(), Category::Data)
                     }
                     _ => assert!(false, "shout be JSON error"),
@@ -151,7 +168,7 @@ mod test {
         macro_rules! assert_format_error {
             ($x:expr) => {
                 assert!(
-                    matches!($x, Some(Err(FormatError::Semantic(_)))),
+                    matches!($x, Some(Err(SerializationError::Semantic(_)))),
                     "should be format error"
                 );
             };
@@ -226,7 +243,7 @@ mod test {
             let result = Sut::write(&mut buffer, vec![entry].into_iter());
 
             assert!(result.is_err());
-            assert!(matches!(result, Err(FormatError::Semantic(_))));
+            assert!(matches!(result, Err(SerializationError::Semantic(_))));
         }
 
         fn expected_values_with_arguments() -> Vec<Entry> {
@@ -316,7 +333,7 @@ mod test {
         }
 
         #[test]
-        fn save_with_array_command_syntax() -> Result<(), FormatError> {
+        fn save_with_array_command_syntax() -> Result<(), SerializationError> {
             let input = expected_values_with_arguments();
 
             // Create fake "file"
@@ -434,7 +451,7 @@ mod test {
         }
 
         #[test]
-        fn save_quoted_with_array_command_syntax() -> Result<(), FormatError> {
+        fn save_quoted_with_array_command_syntax() -> Result<(), SerializationError> {
             let input = expected_quoted_values_with_argument();
 
             // Create fake "file"
@@ -454,7 +471,7 @@ mod test {
 
     mod execution_events {
         use super::super::ExecutionEventDatabase as Sut;
-        use super::super::FileFormat;
+        use super::super::SerializationFormat;
         use crate::intercept::Event;
         use serde_json::json;
         use std::collections::HashMap;
diff --git a/bear/src/output/mod.rs b/bear/src/output/mod.rs
@@ -22,7 +22,7 @@ use writers::{
 };
 
 // Re-export types for convenience.
-pub use formats::{ExecutionEventDatabase, FileFormat};
+pub use formats::{ExecutionEventDatabase, SerializationError, SerializationFormat};
 
 /// Represents the output writer, which can handle different types of outputs.
 ///
@@ -59,7 +59,7 @@ impl TryFrom<(&args::BuildSemantic, &config::Output)> for OutputWriter {
                 let atomic_writer =
                     AtomicClangOutputWriter::new(unique_writer, &temp_file_name, final_file_name);
                 let append_writer =
-                    AppendClangOutputWriter::new(atomic_writer, args.append, final_file_name);
+                    AppendClangOutputWriter::new(atomic_writer, final_file_name, args.append);
                 let formatted_writer =
                     ConverterClangOutputWriter::new(append_writer, &format.entry);
 
@@ -74,34 +74,30 @@ impl TryFrom<(&args::BuildSemantic, &config::Output)> for OutputWriter {
     }
 }
 
-/// Represents errors that can occur while creating an output writer.
-#[derive(Error, Debug)]
-pub enum WriterCreationError {
-    #[error("Failed to create the output writer: {0}")]
-    Io(#[from] std::io::Error),
-    #[error("Failed to configure the output writer: {0}")]
-    Configuration(String),
-}
-
 impl OutputWriter {
     pub fn write(
         self,
         semantics: impl Iterator<Item = semantic::Command>,
-    ) -> Result<(), FormatError> {
+    ) -> Result<(), WriterError> {
         match self {
             Self::Clang(writer) => writer.write(semantics),
             Self::Semantic(writer) => writer.write(semantics),
         }
     }
 }
 
-/// Represents errors that can occur while working with file formats.
-#[derive(Debug, Error)]
-pub enum FormatError {
-    #[error("Generic IO error: {0}")]
-    Io(#[from] std::io::Error),
-    #[error("Format syntax error: {0}")]
-    Syntax(#[from] serde_json::Error),
-    #[error("Format semantic error: {0}")]
-    Semantic(#[from] semantic::clang::EntryError),
+/// Represents errors that can occur while creating an output writer.
+#[derive(Error, Debug)]
+pub enum WriterCreationError {
+    #[error("Failed to create the output writer {0}: {1}")]
+    Io(std::path::PathBuf, std::io::Error),
+    #[error("Failed to configure the output writer: {0}")]
+    Configuration(String),
+}
+
+/// Represents errors that can occur while writing output.
+#[derive(Error, Debug)]
+pub enum WriterError {
+    #[error("Serialization error {0}: {1}")]
+    Io(std::path::PathBuf, SerializationError),
 }
diff --git a/bear/src/output/writers.rs b/bear/src/output/writers.rs
