perf: optimize use of ClangParams struct (#231)

This clones a reference (pointer) to the same `ClangParams` instance
instead of cloning the instance data (when processing each source file).

Some param types updated to reflect the actual life cycle of the
`ClangParams` instance. Another param type change relies on internal
mutability when passing around references to `FileObj` instances in an
array.

Added auto-trait `Debug` to `ClangVersions` struct, in case debug
printing is ever needed.

Removes a duplicate condition where ranges of changed lines are an empty
list if `lines-changed-only` is `Off`.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Refactor**
* Optimized memory handling in the analysis pipeline for improved
efficiency.
  * Refined line-filter logic for more consistent processing.

* **Tests**
  * Updated test variable naming for clarity.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: 2bndy5

cpp-linter/src/clang_tools/clang_tidy.rs

@@ -17,7 +17,7 @@ use serde::Deserialize;
 // project-specific modules/crates
 use super::MakeSuggestions;
 use crate::{
-    cli::{ClangParams, LinesChangedOnly},
+    cli::ClangParams,
     common_fs::{FileObj, normalize_path},
 };
 
@@ -263,19 +263,17 @@ pub fn run_clang_tidy(
         cmd.args(["--extra-arg", format!("\"{}\"", arg).as_str()]);
     }
     let file_name = file.name.to_string_lossy().to_string();
-    if clang_params.lines_changed_only != LinesChangedOnly::Off {
-        let ranges = file.get_ranges(&clang_params.lines_changed_only);
-        if !ranges.is_empty() {
-            let filter = format!(
-                "[{{\"name\":{:?},\"lines\":{:?}}}]",
-                &file_name.replace('/', if OS == "windows" { "\\" } else { "/" }),
-                ranges
-                    .iter()
-                    .map(|r| [r.start(), r.end()])
-                    .collect::<Vec<_>>()
-            );
-            cmd.args(["--line-filter", filter.as_str()]);
-        }
+    let ranges = file.get_ranges(&clang_params.lines_changed_only);
+    if !ranges.is_empty() {
+        let filter = format!(
+            "[{{\"name\":{:?},\"lines\":{:?}}}]",
+            &file_name.replace('/', if OS == "windows" { "\\" } else { "/" }),
+            ranges
+                .iter()
+                .map(|r| [r.start(), r.end()])
+                .collect::<Vec<_>>()
+        );
+        cmd.args(["--line-filter", filter.as_str()]);
     }
     let original_content = if !clang_params.tidy_review {
         None
@@ -429,7 +427,7 @@ mod test {
             )
             .unwrap();
         let file = FileObj::new(PathBuf::from("tests/demo/demo.cpp"));
-        let arc_ref = Arc::new(Mutex::new(file));
+        let arc_file = Arc::new(Mutex::new(file));
         let extra_args = vec!["-std=c++17".to_string(), "-Wall".to_string()];
         let clang_params = ClangParams {
             style: "".to_string(),
@@ -445,7 +443,7 @@ mod test {
             clang_tidy_command: Some(exe_path),
             clang_format_command: None,
         };
-        let mut file_lock = arc_ref.lock().unwrap();
+        let mut file_lock = arc_file.lock().unwrap();
         let logs = run_clang_tidy(&mut file_lock, &clang_params)
             .unwrap()
             .into_iter()

cpp-linter/src/clang_tools/mod.rs

@@ -185,7 +185,7 @@ fn analyze_single_file(
 }
 
 /// A struct to contain the version numbers of the clang-tools used
-#[derive(Default)]
+#[derive(Debug, Default)]
 pub struct ClangVersions {
     /// The clang-format version used.
     pub format_version: Option<String>,
@@ -199,9 +199,9 @@ pub struct ClangVersions {
 /// If `tidy_checks` is `"-*"` then clang-tidy is not executed.
 /// If `style` is a blank string (`""`), then clang-format is not executed.
 pub async fn capture_clang_tools_output(
-    files: &mut Vec<Arc<Mutex<FileObj>>>,
+    files: &[Arc<Mutex<FileObj>>],
     version: &RequestedVersion,
-    clang_params: &mut ClangParams,
+    mut clang_params: ClangParams,
     rest_api_client: &impl RestApiClient,
 ) -> Result<ClangVersions> {
     let mut clang_versions = ClangVersions::default();
@@ -240,10 +240,11 @@ pub async fn capture_clang_tools_output(
     };
 
     let mut executors = JoinSet::new();
+    let arc_params = Arc::new(clang_params);
     // iterate over the discovered files and run the clang tools
     for file in files {
-        let arc_params = Arc::new(clang_params.clone());
-        let arc_file = Arc::clone(file);
+        let arc_file = file.clone();
+        let arc_params = arc_params.clone();
         executors.spawn(async move { analyze_single_file(arc_file, arc_params) });
     }
 

cpp-linter/src/run.rs

@@ -138,9 +138,9 @@ pub async fn run_main(args: Vec<String>) -> Result<()> {
     clang_params.tidy_review &= is_pr;
     let user_inputs = FeedbackInput::from(&cli);
     let clang_versions = capture_clang_tools_output(
-        &mut arc_files,
+        &arc_files,
         &cli.general_options.version,
-        &mut clang_params,
+        clang_params,
         &rest_api_client,
     )
     .await?;