rust: clang related output are private to the module

rizsotto · rizsotto · commit 1e78597644b1 · 2025-04-27T17:20:45.000+10:00
diff --git a/rust/bear/src/output/clang/filter_duplicates.rs b/rust/bear/src/output/clang/filter_duplicates.rs
@@ -8,7 +8,7 @@
 use std::collections::HashSet;
 use std::hash::{DefaultHasher, Hash, Hasher};
 
-use super::clang::Entry;
+use super::Entry;
 use crate::config;
 use thiserror::Error;
 
@@ -77,8 +77,8 @@ impl TryFrom<config::DuplicateFilter> for DuplicateFilter {
 
 #[cfg(test)]
 mod tests {
+    use super::super::entry;
     use super::*;
-    use std::path::PathBuf;
 
     #[test]
     fn test_try_from_success() {
@@ -208,13 +208,4 @@ mod tests {
         assert!(sut.unique(&entry1));
         assert!(!sut.unique(&entry2));
     }
-
-    fn entry(file: &str, arguments: Vec<&str>, directory: &str, output: Option<&str>) -> Entry {
-        Entry {
-            file: PathBuf::from(file),
-            arguments: arguments.into_iter().map(String::from).collect(),
-            directory: PathBuf::from(directory),
-            output: output.map(PathBuf::from),
-        }
-    }
 }
diff --git a/rust/bear/src/output/clang/formatter.rs b/rust/bear/src/output/clang/formatter.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-use crate::output::clang::Entry;
+use super::Entry;
 use crate::semantic;
 use anyhow::anyhow;
 use std::path::{Path, PathBuf};
@@ -95,6 +95,7 @@ fn into_string(path: &Path) -> anyhow::Result<String> {
 
 #[cfg(test)]
 mod test {
+    use super::super::entry;
     use super::*;
 
     #[test]
@@ -127,15 +128,12 @@ mod test {
         let sut = EntryFormatter::new();
         let result = sut.apply(input);
 
-        let expected = vec![Entry {
-            directory: "/home/user".into(),
-            file: "source.c".into(),
-            arguments: vec!["/usr/bin/clang", "-Wall", "-o", "source.o", "source.c"]
-                .into_iter()
-                .map(String::from)
-                .collect(),
-            output: Some("source.o".into()),
-        }];
+        let expected = vec![entry(
+            "source.c",
+            vec!["/usr/bin/clang", "-Wall", "-o", "source.o", "source.c"],
+            "/home/user",
+            Some("source.o"),
+        )];
         assert_eq!(expected, result);
     }
 
@@ -163,24 +161,18 @@ mod test {
         let result = sut.apply(input);
 
         let expected = vec![
-            Entry {
-                directory: "/home/user".into(),
-                file: "/tmp/source1.c".into(),
-                arguments: vec!["clang", "-o", "./source1.o", "/tmp/source1.c"]
-                    .into_iter()
-                    .map(String::from)
-                    .collect(),
-                output: Some("./source1.o".into()),
-            },
-            Entry {
-                directory: "/home/user".into(),
-                file: "../source2.c".into(),
-                arguments: vec!["clang", "-Wall", "../source2.c"]
-                    .into_iter()
-                    .map(String::from)
-                    .collect(),
-                output: None,
-            },
+            entry(
+                "/tmp/source1.c",
+                vec!["clang", "-o", "./source1.o", "/tmp/source1.c"],
+                "/home/user",
+                Some("./source1.o"),
+            ),
+            entry(
+                "../source2.c",
+                vec!["clang", "-Wall", "../source2.c"],
+                "/home/user",
+                None,
+            ),
         ];
         assert_eq!(expected, result);
     }
diff --git a/rust/bear/src/output/clang/mod.rs b/rust/bear/src/output/clang/mod.rs
@@ -11,53 +11,197 @@
 //! as an array. The definition of the JSON compilation database files is done in the
 //! LLVM project [documentation](https://clang.llvm.org/docs/JSONCompilationDatabase.html).
 
-use crate::output::json;
-use serde::Serialize;
-use serde_json::Error;
+mod filter_duplicates;
+mod formatter;
 mod type_de;
 
+use super::formats::{FileFormat, JsonCompilationDatabase};
+use super::IteratorWriter;
+use crate::{config, semantic};
+use anyhow::Context;
+use serde::Serialize;
+use std::{fs, io, path};
+
 /// Represents an entry of the compilation database.
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub struct Entry {
     /// The main translation unit source processed by this compilation step.
     /// This is used by tools as the key into the compilation database.
     /// There can be multiple command objects for the same file, for example if the same
     /// source file is compiled with different configurations.
-    pub file: std::path::PathBuf,
+    pub file: path::PathBuf,
     /// The compile command executed. This must be a valid command to rerun the exact
     /// compilation step for the translation unit in the environment the build system uses.
     /// Shell expansion is not supported.
     pub arguments: Vec<String>,
     /// The working directory of the compilation. All paths specified in the command or
     /// file fields must be either absolute or relative to this directory.
-    pub directory: std::path::PathBuf,
+    pub directory: path::PathBuf,
     /// The name of the output created by this compilation step. This field is optional.
     /// It can be used to distinguish different processing modes of the same input file.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub output: Option<std::path::PathBuf>,
+    pub output: Option<path::PathBuf>,
 }
 
 #[cfg(test)]
 pub fn entry(file: &str, arguments: Vec<&str>, directory: &str, output: Option<&str>) -> Entry {
     Entry {
-        file: std::path::PathBuf::from(file),
+        file: path::PathBuf::from(file),
         arguments: arguments.into_iter().map(String::from).collect(),
-        directory: std::path::PathBuf::from(directory),
-        output: output.map(std::path::PathBuf::from),
+        directory: path::PathBuf::from(directory),
+        output: output.map(path::PathBuf::from),
+    }
+}
+
+/// Formats `semantic::CompilerCall` instances into `Entry` objects.
+pub(super) struct FormattedClangOutputWriter<T: IteratorWriter<Entry>> {
+    formatter: formatter::EntryFormatter,
+    writer: T,
+}
+
+impl<T: IteratorWriter<Entry>> FormattedClangOutputWriter<T> {
+    pub(super) fn new(writer: T) -> Self {
+        let formatter = formatter::EntryFormatter::new();
+        Self { formatter, writer }
+    }
+}
+
+impl<T: IteratorWriter<Entry>> IteratorWriter<semantic::CompilerCall>
+    for FormattedClangOutputWriter<T>
+{
+    fn write(self, semantics: impl Iterator<Item = semantic::CompilerCall>) -> anyhow::Result<()> {
+        let entries = semantics.flat_map(|semantic| self.formatter.apply(semantic));
+        self.writer.write(entries)
+    }
+}
+
+/// Handles the logic for appending entries to an existing Clang output file.
+///
+/// This writer supports reading existing entries from a compilation database file,
+/// combining them with new entries, and writing the result back to the file.
+/// If the file does not exist and the append option is enabled, it logs a warning
+/// and writes only the new entries.
+pub(super) struct AppendClangOutputWriter<T: IteratorWriter<Entry>> {
+    writer: T,
+    path: Option<path::PathBuf>,
+}
+
+impl<T: IteratorWriter<Entry>> AppendClangOutputWriter<T> {
+    pub(super) fn new(writer: T, append: bool, file_name: &path::Path) -> Self {
+        let path = if file_name.exists() {
+            Some(file_name.to_path_buf())
+        } else {
+            if append {
+                log::warn!("The output file does not exist, the append option is ignored.");
+            }
+            None
+        };
+        Self { writer, path }
+    }
+
+    /// Reads the compilation database from a file.
+    ///
+    /// NOTE: The function is intentionally not getting any `&self` reference,
+    /// because the logic is not bound to the instance.
+    fn read_from_compilation_db(
+        source: &path::Path,
+    ) -> anyhow::Result<impl Iterator<Item = Entry>> {
+        let source_copy = source.to_path_buf();
+
+        let file = fs::File::open(source)
+            .map(io::BufReader::new)
+            .with_context(|| format!("Failed to open file: {:?}", source))?;
+
+        let entries = JsonCompilationDatabase::read_and_ignore(file, source_copy);
+        Ok(entries)
+    }
+}
+
+impl<T: IteratorWriter<Entry>> IteratorWriter<Entry> for AppendClangOutputWriter<T> {
+    fn write(self, entries: impl Iterator<Item = Entry>) -> anyhow::Result<()> {
+        if let Some(path) = self.path {
+            let entries_from_db = Self::read_from_compilation_db(&path)?;
+            let final_entries = entries_from_db.chain(entries);
+            self.writer.write(final_entries)
+        } else {
+            self.writer.write(entries)
+        }
     }
 }
 
-/// Deserialize entries from a JSON array into an iterator.
-pub fn read(reader: impl std::io::Read) -> impl Iterator<Item = Result<Entry, Error>> {
-    json::read_array(reader)
+/// Responsible for writing a JSON compilation database file atomically.
+///
+/// The file is first written to a temporary file and then renamed to the final file name.
+/// This ensures that the output file is not left in an inconsistent state in case of errors.
+pub(super) struct AtomicClangOutputWriter<T: IteratorWriter<Entry>> {
+    writer: T,
+    temp_file_name: path::PathBuf,
+    final_file_name: path::PathBuf,
+}
+
+impl<T: IteratorWriter<Entry>> AtomicClangOutputWriter<T> {
+    pub(super) fn new(
+        writer: T,
+        temp_file_name: &path::Path,
+        final_file_name: &path::Path,
+    ) -> Self {
+        Self {
+            writer,
+            temp_file_name: temp_file_name.to_path_buf(),
+            final_file_name: final_file_name.to_path_buf(),
+        }
+    }
+}
+
+impl<T: IteratorWriter<Entry>> IteratorWriter<Entry> for AtomicClangOutputWriter<T> {
+    fn write(self, entries: impl Iterator<Item = Entry>) -> anyhow::Result<()> {
+        let temp_file_name = self.temp_file_name.clone();
+        let final_file_name = self.final_file_name.clone();
+
+        self.writer.write(entries)?;
+
+        fs::rename(&temp_file_name, &final_file_name).with_context(|| {
+            format!(
+                "Failed to rename file from '{:?}' to '{:?}'.",
+                temp_file_name, final_file_name
+            )
+        })?;
+
+        Ok(())
+    }
 }
 
-/// Serialize entries from an iterator into a JSON array.
+/// Responsible for writing a JSON compilation database file from the given entries.
 ///
-/// It uses the `arguments` field of the `Entry` struct to serialize the array of strings.
-pub fn write(
-    writer: impl std::io::Write,
-    entries: impl Iterator<Item = Entry>,
-) -> Result<(), Error> {
-    json::write_array(writer, entries)
+/// # Features
+/// - Writes the entries to a file.
+/// - Filters duplicates based on the provided configuration.
+pub(super) struct ClangOutputWriter {
+    output: io::BufWriter<fs::File>,
+    filter: filter_duplicates::DuplicateFilter,
+}
+
+impl TryFrom<(&path::Path, &config::DuplicateFilter)> for ClangOutputWriter {
+    type Error = anyhow::Error;
+
+    fn try_from(value: (&path::Path, &config::DuplicateFilter)) -> Result<Self, Self::Error> {
+        let (file_name, config) = value;
+
+        let output = fs::File::create(file_name)
+            .map(io::BufWriter::new)
+            .with_context(|| format!("Failed to open file: {:?}", file_name))?;
+
+        let filter = filter_duplicates::DuplicateFilter::try_from(config.clone())?;
+
+        Ok(Self { output, filter })
+    }
+}
+
+impl IteratorWriter<Entry> for ClangOutputWriter {
+    fn write(self, entries: impl Iterator<Item = Entry>) -> anyhow::Result<()> {
+        let mut filter = self.filter.clone();
+        let filtered_entries = entries.filter(move |entry| filter.unique(entry));
+        JsonCompilationDatabase::write(self.output, filtered_entries)?;
+        Ok(())
+    }
 }
diff --git a/rust/bear/src/output/mod.rs b/rust/bear/src/output/mod.rs
