Refactor and clean the code

.github/workflows/code-quality.yml

@@ -47,7 +47,7 @@ jobs:
           cargo fmt --all -- --check
 
   unit-and-doc-tests:
-    name: Verify code formatting
+    name: Run unit and doc tests
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3

zork++/Cargo.toml

@@ -18,6 +18,8 @@ path = "src/bin/main.rs"
 toml = "0.5.11"
 glob = "0.3.1"
 serde = { version = "1.0.202", features = ["derive"] }
+typetag = "0.2"
+transient = "0.4.0"
 clap = { version = "4.0.32", features = ["derive"] }
 log = "0.4.17"
 env_logger = "0.11.3"

zork++/benches/benchmarks.rs

@@ -4,10 +4,10 @@
 
 use clap::Parser;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use zork::compiler::generate_commands;
 use zork::{
     cache::{self, ZorkCache},
     cli::input::CliArgs,
-    compiler::build_project,
     config_file::{self, ZorkConfigFile},
     utils::{self, reader::build_model},
 };
@@ -15,12 +15,18 @@
 pub fn build_project_benchmark(c: &mut Criterion) {
     let config: ZorkConfigFile =
         config_file::zork_cfg_from_file(utils::constants::CONFIG_FILE_MOCK).unwrap();
     let cli_args = CliArgs::parse();
-    let program_data = build_model(&config, &cli_args, Path::new(".")).unwrap();
+    let program_data = build_model(config, &cli_args, Path::new(".")).unwrap();
     let mut cache = ZorkCache::default();
-
-    c.bench_function("Build project", |b| {
-        b.iter(|| build_project(black_box(&program_data), black_box(&mut cache), false))
+
+    c.bench_function("Generate commands", |b| {
+        b.iter(|| {
+            generate_commands(
+                black_box(&program_data),
+                black_box(&mut cache),
+                &cli_args,
+            )
+        })
     });
 
     c.bench_function("Cache loading time", |b| {

zork++/src/lib/cache/compile_commands.rs

@@ -1,51 +1,59 @@
 use crate::cache::ZorkCache;
+use crate::cli::output::arguments::Arguments;
+use crate::cli::output::commands::SourceCommandLine;
 use crate::utils;
 use crate::utils::constants::COMPILATION_DATABASE;
 use color_eyre::eyre::{Context, Result};
 use serde::Serialize;
 use std::fs::File;
 use std::path::{Path, PathBuf};
 
+pub type CompileCommands<'a> = Vec<CompileCommand<'a>>;
+
 /// Generates the `compile_commands.json` file, that acts as a compilation database
 /// for some static analysis external tools, like `clang-tidy`, and populates it with
 /// the generated commands for the translation units
-pub(crate) fn map_generated_commands_to_compilation_db(cache: &ZorkCache) -> Result<()> {
+pub(crate) fn map_generated_commands_to_compilation_db<'a>(
+    cache: &'a ZorkCache<'a>,
+) -> Result<CompileCommands<'a>> {
     log::trace!("Generating the compilation database...");
-    let mut compilation_db_entries = Vec::with_capacity(cache.last_generated_commands.len());
 
-    for command in cache.last_generated_commands.iter() {
-        compilation_db_entries.push(CompileCommands::from(command));
+    let generated_commands = cache.get_all_commands_iter();
+    let mut compilation_db_entries: Vec<CompileCommand> =
+        Vec::with_capacity(cache.count_total_generated_commands()); // Without the linker one
+
+    for command in generated_commands {
+        compilation_db_entries.push(CompileCommand::from(command));
     }
 
     let compile_commands_path = Path::new(COMPILATION_DATABASE);
     if !Path::new(&compile_commands_path).exists() {
         File::create(compile_commands_path)
             .with_context(|| "Error creating the compilation database")?;
     }
+
     utils::fs::serialize_object_to_file(Path::new(compile_commands_path), &compilation_db_entries)
-        .with_context(move || "Error saving the compilation database")
+        .with_context(move || "Error saving the compilation database")?;
+
+    Ok(compilation_db_entries)
 }
 
 /// Data model for serialize the data that will be outputted
 /// to the `compile_commands.json` compilation database file
 #[derive(Serialize, Debug, Default, Clone)]
-pub struct CompileCommands {
-    pub directory: String,
+pub struct CompileCommand<'a> {
+    pub directory: PathBuf,
     pub file: String,
-    pub arguments: Vec<String>,
+    pub arguments: Arguments<'a>,
 }
 
-impl From<(&'_ PathBuf, &'_ Vec<String>)> for CompileCommands {
-    fn from(value: (&PathBuf, &Vec<String>)) -> Self {
-        let dir = value.0.parent().unwrap_or(Path::new("."));
-        let mut file = value.0.file_stem().unwrap_or_default().to_os_string();
-        file.push(".");
-        file.push(value.0.extension().unwrap_or_default());
-
+impl<'a> From<&SourceCommandLine<'a>> for CompileCommand<'a> {
+    fn from(value: &SourceCommandLine<'a>) -> Self {
+        let value = value.clone();
         Self {
-            directory: dir.to_str().unwrap_or_default().to_string(),
-            file: file.to_str().unwrap_or_default().to_string(),
-            arguments: value.1.clone(),
+            directory: value.directory,
+            file: value.filename,
+            arguments: value.args,
         }
     }
 }