Chore/ cleanup 8 (#905)

TilakMaddy · web-flow · commit f3322eb79fab · 2025-04-08T15:02:43.000+05:30
diff --git a/aderyn/src/lsp.rs b/aderyn/src/lsp.rs
@@ -105,7 +105,10 @@ pub fn spin_up_language_server(args: Args) {
 
         // Watch for file changes
         file_system_watcher
-            .watch(PathBuf::from(args.root.clone()).as_path(), RecursiveMode::Recursive)
+            .watch(
+                PathBuf::from(args.input_config.root.clone()).as_path(),
+                RecursiveMode::Recursive,
+            )
             .expect("unable to watch for file changes");
 
         // Most editor's LSP clients communicate through stdout/stdin channels. Theefore use
diff --git a/aderyn/src/main.rs b/aderyn/src/main.rs
@@ -4,7 +4,7 @@ use aderyn::{
     aderyn_is_currently_running_newest_version, create_aderyn_toml_file_at, initialize_niceties,
     lsp::spin_up_language_server, print_all_detectors_view, print_detail_view,
 };
-use aderyn_driver::driver::{self, Args};
+use aderyn_driver::driver::{self, Args, CliArgsOutputConfig};
 
 use clap::{ArgGroup, Parser, Subcommand};
 #[derive(Parser, Debug)]
@@ -137,23 +137,30 @@ fn main() {
         return;
     }
 
-    let mut args: Args = Args {
-        root: cmd_args.root,
-        output: cmd_args.output,
-        src: cmd_args.src,
-        path_includes: cmd_args.path_includes,
-        path_excludes: cmd_args.path_excludes,
-        no_snippets: cmd_args.no_snippets,
-        skip_cloc: cmd_args.skip_cloc,
-        stdout: cmd_args.stdout,
+    let mut args = Args {
         auditor_mode: cmd_args.auditor_mode,
-        highs_only: cmd_args.highs_only,
-        lsp: cmd_args.lsp,
+        input_config: driver::CliArgsInputConfig {
+            root: cmd_args.root,
+            src: cmd_args.src,
+            path_excludes: cmd_args.path_excludes,
+            path_includes: cmd_args.path_includes,
+        },
+        output_config: CliArgsOutputConfig {
+            output: cmd_args.output,
+            stdout: cmd_args.stdout,
+            no_snippets: cmd_args.no_snippets,
+        },
+        common_config: driver::CliArgsCommonConfig {
+            lsp: cmd_args.lsp,
+            skip_cloc: cmd_args.skip_cloc,
+            highs_only: cmd_args.highs_only,
+        },
     };
 
     // Run watcher is watch mode is engaged
     if cmd_args.lsp {
-        args.skip_cloc = true;
+        // FORCE skip cloc
+        args.common_config.skip_cloc = true;
         spin_up_language_server(args);
     } else {
         driver::kick_off_report_creation(args.clone());
diff --git a/aderyn_driver/benches/detectors.rs b/aderyn_driver/benches/detectors.rs
@@ -1,10 +1,6 @@
 use std::path::PathBuf;
 
-use aderyn_driver::{
-    detector::get_all_issue_detectors,
-    driver::{kick_off_report_creation, Args},
-    process::PreprocessedConfig,
-};
+use aderyn_driver::{detector::get_all_issue_detectors, process::PreprocessedConfig};
 
 use criterion::{criterion_group, criterion_main, Criterion};
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
@@ -27,31 +23,8 @@ fn bench_individual_detectors_on_contract_playground(c: &mut Criterion) {
     }
 }
 
-fn bench_aderyn_on_contract_playground(c: &mut Criterion) {
-    let root_path = PathBuf::from("../tests/contract-playground");
-
-    c.bench_function("aderyn", |b| {
-        b.iter(|| {
-            kick_off_report_creation(Args {
-                root: root_path.to_string_lossy().to_string(),
-                output: String::from("aderyn-report-for-bench.md"),
-                no_snippets: false,
-                skip_cloc: true,
-                path_excludes: None,
-                path_includes: None,
-                src: None,
-                stdout: false,
-                auditor_mode: false,
-                highs_only: false,
-                lsp: false,
-            });
-        });
-    });
-}
-
 criterion_group!(
     detectors,                                         // Group name is the first argument
-    bench_aderyn_on_contract_playground,               // Group 1
-    bench_individual_detectors_on_contract_playground, // Group 2
+    bench_individual_detectors_on_contract_playground, // Group 1
 );
 criterion_main!(detectors);
diff --git a/aderyn_driver/src/driver.rs b/aderyn_driver/src/driver.rs
@@ -10,38 +10,52 @@ use tokio::sync::Mutex;
 
 #[derive(Clone, FieldAccess)]
 pub struct Args {
+    pub auditor_mode: bool,
+    pub input_config: CliArgsInputConfig,
+    pub output_config: CliArgsOutputConfig,
+    pub common_config: CliArgsCommonConfig,
+}
+
+#[derive(Debug, Clone)]
+pub struct CliArgsInputConfig {
     pub root: String,
-    pub output: String,
     pub src: Option<String>,
     pub path_excludes: Option<Vec<String>>,
     pub path_includes: Option<Vec<String>>,
+}
+
+#[derive(Debug, Clone)]
+pub struct CliArgsOutputConfig {
+    pub output: String,
+    pub stdout: bool,
     pub no_snippets: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct CliArgsCommonConfig {
+    pub lsp: bool,
     pub skip_cloc: bool,
-    pub stdout: bool,
-    pub auditor_mode: bool,
     pub highs_only: bool,
-    pub lsp: bool,
 }
 
 /// One way pipeline. Used by CLI
 pub fn kick_off_report_creation(args: Args) {
-    // Choose the detectors
     let detectors = detector_list(&args);
 
     let run_pipeline = || -> Result<(), Box<dyn std::error::Error>> {
-        let cx_wrapper = make_context(&args).unwrap_or_else(|e| {
-            eprintln!("Error making context: {}", e);
-            std::process::exit(1);
-        });
+        let cx_wrapper =
+            make_context(&args.input_config, &args.common_config).unwrap_or_else(|e| {
+                eprintln!("Error making context: {}", e);
+                std::process::exit(1);
+            });
 
         if args.auditor_mode {
             run_auditor_mode(&cx_wrapper.contexts)?;
         } else {
             let root_rel_path = cx_wrapper.root_path;
-            let output = args.output.clone();
 
             // Load the workspace context into the run function, which runs the detectors
-            run_detector_mode(&cx_wrapper.contexts, output, root_rel_path, detectors, &args)?;
+            run_detector_mode(&cx_wrapper.contexts, root_rel_path, detectors, &args.output_config)?;
         }
         Ok(())
     };
@@ -55,10 +69,9 @@ pub fn kick_off_report_creation(args: Args) {
 
 /// Drives and returns results. Used by LSP
 pub fn fetch_report_for_lsp(args: Args) -> Arc<Mutex<Option<LspReport>>> {
-    // Choose the detectors
     let detectors = detector_list(&args);
 
-    let ctx_wrapper = match make_context(&args) {
+    let ctx_wrapper = match make_context(&args.input_config, &args.common_config) {
         Ok(ctx_wrapper) => ctx_wrapper,
         Err(_) => {
             return Arc::new(tokio::sync::Mutex::new(None));
@@ -74,6 +87,6 @@ pub fn fetch_report_for_lsp(args: Args) -> Arc<Mutex<Option<LspReport>>> {
 fn detector_list(args: &Args) -> Vec<Box<dyn IssueDetector>> {
     get_all_issue_detectors()
         .into_iter()
-        .filter(|d| !args.highs_only || d.severity() == IssueSeverity::High)
+        .filter(|d| !args.common_config.highs_only || d.severity() == IssueSeverity::High)
         .collect()
 }
diff --git a/aderyn_driver/src/interface/mod.rs b/aderyn_driver/src/interface/mod.rs
@@ -12,7 +12,7 @@ use std::{
 
 use aderyn_core::{context::workspace_context::WorkspaceContext, report::Report};
 
-use crate::driver::Args;
+use crate::driver::CliArgsOutputConfig;
 
 #[derive(Default)]
 pub enum OutputInterface {
@@ -27,10 +27,8 @@ pub fn output_interface_router(
     report: &Report,
     contexts: &[WorkspaceContext],
     root_rel_path: PathBuf,
-    output_file_path: String, /* you writer 'W' may or may not be writing a file. Eg:
-                               * it can simply consume and forget :P */
     detectors_used: &[(String, String)],
-    args: &Args,
+    output_config: &CliArgsOutputConfig,
 ) -> Result<()> {
     let get_writer = |filename: &str| -> io::Result<File> {
         let file_path = Path::new(filename);
@@ -45,30 +43,33 @@ pub fn output_interface_router(
 
     println!("Detectors run, printing report.");
 
-    let mut b: Box<dyn Write> =
-        if args.stdout { Box::new(io::stdout()) } else { Box::new(get_writer(&output_file_path)?) };
+    let mut b: Box<dyn Write> = if output_config.stdout {
+        Box::new(io::stdout())
+    } else {
+        Box::new(get_writer(&output_config.output)?)
+    };
 
     match output_interface {
         OutputInterface::Json => {
-            json::print_report(&mut b, report, contexts, args.stdout, detectors_used)?;
+            json::print_report(&mut b, report, contexts, output_config.stdout, detectors_used)?;
         }
         OutputInterface::Markdown => {
             markdown::print_report(
                 &mut b,
                 report,
                 contexts,
                 root_rel_path,
-                output_file_path.clone(),
-                args.no_snippets,
+                output_config.output.clone(),
+                output_config.no_snippets,
             )?;
         }
         OutputInterface::Sarif => {
-            sarif::print_report(&mut b, report, args.stdout)?;
+            sarif::print_report(&mut b, report, output_config.stdout)?;
         }
     }
 
-    if !args.stdout {
-        println!("Report printed to {}", output_file_path);
+    if !output_config.stdout {
+        println!("Report printed to {}", output_config.output);
     }
 
     Ok(())
diff --git a/aderyn_driver/src/process.rs b/aderyn_driver/src/process.rs
@@ -1,4 +1,8 @@
-use crate::{compile, config::supplement_values_from_aderyn_toml, driver::Args};
+use crate::{
+    compile,
+    config::supplement_values_from_aderyn_toml,
+    driver::{CliArgsCommonConfig, CliArgsInputConfig},
+};
 use aderyn_core::{
     context::{
         graph::{Transpose, WorkspaceCallGraph},
@@ -24,21 +28,22 @@ pub struct PreprocessedConfig {
 }
 
 pub fn make_context(
-    args: &Args,
+    args: &CliArgsInputConfig,
+    common: &CliArgsCommonConfig,
 ) -> Result<WorkspaceContextWrapper, Box<dyn std::error::Error + Send + Sync>> {
     // Preprocess config by supplementing CLI args with aderyn.toml if exists
     let preprocessed_config = obtain_config_values(args.clone())?;
 
-    let is_lsp_mode = args.lsp;
     let root_path = preprocessed_config.root_path.clone();
 
     // Compilation steps:
-    // 1. Processes the config by translating them to runtime values (Cyfrin/solidity-ast-rs)
+    // 1. Processes the above preprocessed config by translating them to runtime values Thanks to
+    //    Cyfrin/solidity-ast-rs
     // 2. Parse those files and prepare ASTs.
-    let mut contexts: Vec<WorkspaceContext> = compile::project(preprocessed_config, is_lsp_mode)?;
+    let mut contexts: Vec<WorkspaceContext> = compile::project(preprocessed_config, common.lsp)?;
 
     // Only make this an error when it's not in LSP mode
-    if !is_lsp_mode && contexts.iter().all(|c| c.src_filepaths.is_empty()) {
+    if !common.lsp && contexts.iter().all(|c| c.src_filepaths.is_empty()) {
         let error = "No solidity files found in given scope!";
         eprintln!("{}", error);
         return Err(error.into());
@@ -53,7 +58,7 @@ pub fn make_context(
         let stats = fscloc::engine::count_lines_of_code_and_collect_line_numbers_to_ignore(
             absolute_root_path.as_path(),
             &context.src_filepaths,
-            args.skip_cloc,
+            common.skip_cloc,
         );
         let sloc_stats: HashMap<String, usize> = stats
             .lock()
@@ -85,7 +90,7 @@ pub fn make_context(
 
 /// Supplement the CLI arguments with values from aderyn.toml
 fn obtain_config_values(
-    args: Args,
+    args: CliArgsInputConfig,
 ) -> Result<PreprocessedConfig, Box<dyn std::error::Error + Send + Sync>> {
     let root_path = PathBuf::from(&args.root);
     let aderyn_path = root_path.join("aderyn.toml");
diff --git a/aderyn_driver/src/runner.rs b/aderyn_driver/src/runner.rs
@@ -2,30 +2,30 @@ use aderyn_core::{context::workspace_context::WorkspaceContext, detect::detector
 use std::{error::Error, path::PathBuf};
 
 use crate::{
-    driver::Args,
+    driver::CliArgsOutputConfig,
     interface::{lsp::LspReport, output_interface_router, OutputInterface},
 };
 use aderyn_core::report::*;
 
 pub fn run_detector_mode(
     contexts: &[WorkspaceContext],
-    output_file_path: String,
     root_rel_path: PathBuf,
     detectors: Vec<Box<dyn IssueDetector>>,
-    args: &Args,
+    output_config: &CliArgsOutputConfig,
 ) -> Result<(), Box<dyn Error>> {
     println!("Running {} detectors", detectors.len());
 
     let detectors_used =
         &detectors.iter().map(|d| (d.name(), d.severity().to_string())).collect::<Vec<_>>();
 
     let report = get_report(contexts, &root_rel_path, detectors)?;
+    let output_file_path = output_config.output.clone();
 
-    let output_interface = if args.output.ends_with(".json") {
+    let output_interface = if output_file_path.ends_with(".json") {
         OutputInterface::Json
-    } else if args.output.ends_with(".sarif") {
+    } else if output_file_path.ends_with(".sarif") {
         OutputInterface::Sarif
-    } else if args.output.ends_with(".md") {
+    } else if output_file_path.ends_with(".md") {
         OutputInterface::Markdown
     } else {
         println!("Warning: Output file extension is unrecognized. Reverting to markdown..");
@@ -37,9 +37,8 @@ pub fn run_detector_mode(
         &report,
         contexts,
         root_rel_path,
-        output_file_path.clone(),
         detectors_used,
-        args,
+        output_config,
     )?;
 
     Ok(())
