remove semantic output format

Author: rizsotto

bear/src/config.rs

@@ -76,7 +76,7 @@
 //! intercept:
 //!   mode: preload
 //! output:
-//!   specification: bear
+//!   specification: clang
 //! ```
 
 // Re-Export the types and the loader module content.
@@ -178,11 +178,12 @@ mod types {
 
     /// Output configuration is used to customize the output format.
     ///
-    /// Allow customizing the output format of the compiler calls.
+    /// Configures how the compiler calls are output in the clang project defined
+    /// "JSON compilation database" format. (The format is used by clang tooling
+    /// and other tools based on that library.)
     ///
-    /// - Clang: Output the compiler calls in the clang project defined "JSON compilation database"
-    ///   format. (The format is used by clang tooling and other tools based on that library.)
-    /// - Semantic: Output the compiler calls in the semantic format. (The format is not defined yet.)
+    /// The configuration allows customization of compiler filtering, source filtering,
+    /// duplicate handling, and output formatting.
     #[derive(Debug, PartialEq, Deserialize, Serialize)]
     #[serde(tag = "specification")]
     pub enum Output {
@@ -197,11 +198,9 @@ mod types {
             #[serde(default)]
             format: Format,
         },
-        #[serde(rename = "bear")]
-        Semantic {},
     }
 
-    /// The default output is the clang format.
+    /// The default output configuration.
     impl Default for Output {
         fn default() -> Self {
             Output::Clang {
@@ -745,17 +744,17 @@ pub mod loader {
           mode: preload
           path: /usr/local/lib/libexec.so
         output:
-          specification: bear
+          specification: clang
         "#;
 
             let result = Loader::from_reader(content).unwrap();
 
             let expected = Main {
+                schema: String::from("4.0"),
                 intercept: Intercept::Preload {
                     path: PathBuf::from("/usr/local/lib/libexec.so"),
                 },
-                output: Output::Semantic {},
-                schema: String::from("4.0"),
+                output: Output::default(),
             };
 
             assert_eq!(expected, result);
@@ -794,6 +793,7 @@ pub mod loader {
             let result = Loader::from_reader(content).unwrap();
 
             let expected = Main {
+                schema: String::from("4.0"),
                 intercept: Intercept::Preload {
                     path: default_preload_library(),
                 },
@@ -838,7 +838,6 @@ pub mod loader {
                         },
                     },
                 },
-                schema: String::from("4.0"),
             };
 
             assert_eq!(expected, result);

bear/src/modes/mod.rs

@@ -276,7 +276,7 @@ mod impls {
         ///
         /// The `output` argument contains the configuration for the output file location,
         /// while the `config` argument contains the configuration for the semantic analysis
-        /// and the output format.
+        /// and clang compilation database formatting.
         pub(super) fn create(
             output: args::BuildSemantic,
             config: &config::Main,

bear/src/output/formats.rs

@@ -8,7 +8,7 @@
 //! - The execution event database format (internal format of this project.)
 
 use super::json;
-use crate::{intercept, semantic, semantic::clang};
+use crate::{intercept, semantic::clang};
 use serde_json::de::IoRead;
 use serde_json::StreamDeserializer;
 use thiserror::Error;
@@ -95,31 +95,6 @@ impl SerializationFormat<clang::Entry> for JsonCompilationDatabase {
     }
 }
 
-/// The type represents a JSON semantic database format.
-///
-/// The format is a JSON array format, which is a sequence of JSON objects
-/// enclosed in square brackets. Each object represents a semantic analysis
-/// result.
-///
-/// # Note
-/// The output format is not stable and may change in future versions.
-pub struct JsonSemanticDatabase;
-
-impl SerializationFormat<semantic::Command> for JsonSemanticDatabase {
-    fn write(
-        writer: impl std::io::Write,
-        commands: impl Iterator<Item = semantic::Command>,
-    ) -> Result<(), SerializationError> {
-        json::serialize_seq(writer, commands).map_err(SerializationError::Syntax)
-    }
-    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()
-    }
-}
-
 /// The type represents a database format for execution events.
 ///
 /// The format is a [JSON line format](https://jsonlines.org/), which is a sequence
@@ -153,9 +128,9 @@ impl SerializationFormat<intercept::Event> for ExecutionEventDatabase {
 #[cfg(test)]
 mod test {
     mod compilation_database {
-        use super::super::semantic::clang::{Entry, EntryError};
         use super::super::JsonCompilationDatabase as Sut;
         use super::super::{SerializationError, SerializationFormat};
+        use crate::semantic::clang::{Entry, EntryError};
         use serde_json::error::Category;
         use serde_json::json;
         use std::io::{Cursor, Seek, SeekFrom};

bear/src/output/json.rs

@@ -44,23 +44,6 @@ where
     Ok(())
 }
 
-/// Serialize entries from an iterator into a JSON array.
-pub fn serialize_seq<W, T>(
-    writer: W,
-    entries: impl Iterator<Item = T>,
-) -> Result<(), serde_json::Error>
-where
-    W: io::Write,
-    T: Serialize,
-{
-    let mut ser = serde_json::Serializer::pretty(writer);
-    let mut seq = ser.serialize_seq(None)?;
-    for entry in entries {
-        seq.serialize_element(&entry)?;
-    }
-    seq.end()
-}
-
 /// Deserialize entries from a JSON array into an iterator.
 ///
 /// from https://github.com/serde-rs/json/issues/404#issuecomment-892957228
@@ -252,7 +235,11 @@ mod tests {
     {
         // Create fake "file"
         let mut buffer = Cursor::new(Vec::new());
-        serialize_seq(&mut buffer, input.iter().cloned()).unwrap();
+        serialize_result_seq(
+            &mut buffer,
+            input.iter().cloned().map(Ok::<_, serde_json::Error>),
+        )
+        .unwrap();
 
         // Use the fake "file" as input
         buffer.seek(SeekFrom::Start(0)).unwrap();

bear/src/output/mod.rs

@@ -2,12 +2,11 @@
 
 //! This module is responsible for writing the output of semantic analysis.
 //!
-//! The output can be in different formats, such as JSON compilation databases
-//! or semantic analysis results in JSON format. The module provides functionality
-//! to write these outputs to files, handle duplicates, and format the output
-//! as needed.
+//! The output is written as JSON compilation databases.
+//! The module provides functionality to write these outputs to files,
+//! handle duplicates, and format the output as needed.
 //!
-//! The `OutputWriter` enum represents the main entry point for writing output.
+//! The `OutputWriter` struct represents the main entry point for writing output.
 //! The input to the `OutputWriter` is a stream of `semantic::Command` instances.
 
 mod formats;
@@ -18,7 +17,7 @@ use crate::{args, config, semantic};
 use thiserror::Error;
 use writers::{
     AppendClangOutputWriter, AtomicClangOutputWriter, ClangOutputWriter,
-    ConverterClangOutputWriter, IteratorWriter, SemanticOutputWriter, UniqueOutputWriter,
+    ConverterClangOutputWriter, IteratorWriter, UniqueOutputWriter,
 };
 
 // Re-export types for convenience.
@@ -29,18 +28,13 @@ type ClangWriterStack = ConverterClangOutputWriter<
     AppendClangOutputWriter<AtomicClangOutputWriter<UniqueOutputWriter<ClangOutputWriter>>>,
 >;
 
-/// Represents the output writer, which can handle different types of outputs.
+/// Represents the output writer for JSON compilation databases.
 ///
-/// This enum provides two variants:
-/// - `Clang`: Writes output as a JSON compilation database.
-/// - `Semantic`: Writes output as a JSON semantic analysis result.
-///
-/// The variants are selected at runtime based on the configuration provided.
-pub enum OutputWriter {
-    #[allow(private_interfaces)]
-    Clang(ClangWriterStack),
+/// The writer handles writing semantic analysis results as JSON compilation databases,
+/// with support for deduplication, atomic writes, and appending to existing files.
+pub struct OutputWriter {
     #[allow(private_interfaces)]
-    Semantic(SemanticOutputWriter),
+    writer: ClangWriterStack,
 }
 
 impl TryFrom<(&args::BuildSemantic, &config::Output)> for OutputWriter {
@@ -64,12 +58,9 @@ impl TryFrom<(&args::BuildSemantic, &config::Output)> for OutputWriter {
                 let formatted_writer =
                     ConverterClangOutputWriter::new(append_writer, &format.entry);
 
-                Ok(Self::Clang(formatted_writer))
-            }
-            config::Output::Semantic { .. } => {
-                let path = std::path::Path::new(&args.path);
-                let result = SemanticOutputWriter::try_from(path)?;
-                Ok(Self::Semantic(result))
+                Ok(Self {
+                    writer: formatted_writer,
+                })
             }
         }
     }
@@ -87,10 +78,7 @@ impl OutputWriter {
         self,
         semantics: impl Iterator<Item = semantic::Command>,
     ) -> Result<(), WriterError> {
-        match self {
-            Self::Clang(writer) => writer.write(semantics),
-            Self::Semantic(writer) => writer.write(semantics),
-        }
+        self.writer.write(semantics)
     }
 }
 

bear/src/output/writers.rs

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-use super::formats::{
-    JsonCompilationDatabase, JsonSemanticDatabase, SerializationError, SerializationFormat,
-};
+use super::formats::{JsonCompilationDatabase, SerializationError, SerializationFormat};
 use super::{WriterCreationError, WriterError};
 use crate::semantic::clang::{DuplicateEntryFilter, Entry};
 use crate::{config, semantic};
@@ -20,38 +18,6 @@ pub(super) trait IteratorWriter<T> {
     fn write(self, items: impl Iterator<Item = T>) -> Result<(), WriterError>;
 }
 
-/// The type represents a writer for semantic analysis results to a file.
-///
-/// # Note
-/// The output format is not stable and may change in future versions.
-/// It reflects the internal representation of the semantic analysis types.
-pub(super) struct SemanticOutputWriter {
-    output: io::BufWriter<fs::File>,
-    path: path::PathBuf,
-}
-
-impl TryFrom<&path::Path> for SemanticOutputWriter {
-    type Error = WriterCreationError;
-
-    fn try_from(output_path: &path::Path) -> Result<Self, Self::Error> {
-        let output = fs::File::create(output_path)
-            .map(io::BufWriter::new)
-            .map_err(|err| WriterCreationError::Io(output_path.to_path_buf(), err))?;
-
-        Ok(Self {
-            output,
-            path: output_path.to_path_buf(),
-        })
-    }
-}
-
-impl IteratorWriter<semantic::Command> for SemanticOutputWriter {
-    fn write(self, semantics: impl Iterator<Item = semantic::Command>) -> Result<(), WriterError> {
-        JsonSemanticDatabase::write(self.output, semantics)
-            .map_err(|err| WriterError::Io(self.path, err))
-    }
-}
-
 /// The type represents a converter that formats `semantic::Command` instances into `Entry` objects.
 pub(super) struct ConverterClangOutputWriter<T: IteratorWriter<Entry>> {
     converter: semantic::clang::CommandConverter,