style: cargo fmt across workspace

JuanMarchetto · JuanMarchetto · commit a4c63e97da99 · 2026-03-07T21:46:44.000-03:00
diff --git a/crates/noricum-agents/src/translation.rs b/crates/noricum-agents/src/translation.rs
@@ -165,7 +165,7 @@ pub async fn translate_chunked(
             chunk_source.push_str(
                 "\n\n// === INSTRUCTION: Translate data model to idiomatic Rust types FIRST. ===\n\
                  // Use enum variants instead of type tags. Convert linked-lists to Vec.\n\
-                 // Use String instead of *char. Replace malloc/free with RAII.\n"
+                 // Use String instead of *char. Replace malloc/free with RAII.\n",
             );
         }
         chunk_source.push_str("\n\n// === Functions to translate ===\n");
diff --git a/crates/noricum-cli/src/commands/bench.rs b/crates/noricum-cli/src/commands/bench.rs
@@ -23,8 +23,7 @@ pub async fn cmd_bench(
         ollama_model,
         ..MigrationConfig::default()
     };
-    let use_llm = config.anthropic_api_key.is_some()
-        || config.ollama_model.is_some();
+    let use_llm = config.anthropic_api_key.is_some() || config.ollama_model.is_some();
 
     let mut c_files: Vec<PathBuf> = Vec::new();
     for entry in std::fs::read_dir(&fixtures_dir)? {
diff --git a/crates/noricum-cli/src/commands/compare.rs b/crates/noricum-cli/src/commands/compare.rs
@@ -26,14 +26,8 @@ pub fn cmd_compare(
 
     // Header
     let col_w = 22;
-    println!(
-        "{:<20} | {:<col_w$} | {:<col_w$}",
-        "File", label_a, label_b
-    );
-    println!(
-        "{:-<20}-+-{:-<col_w$}-+-{:-<col_w$}",
-        "", "", ""
-    );
+    println!("{:<20} | {:<col_w$} | {:<col_w$}", "File", label_a, label_b);
+    println!("{:-<20}-+-{:-<col_w$}-+-{:-<col_w$}", "", "", "");
 
     // Collect all file names from both baselines
     let mut all_names: Vec<String> = Vec::new();
@@ -98,10 +92,7 @@ pub fn cmd_compare(
         "{:<20} | {:<col_w$} | {:<col_w$}",
         "Metric", label_a, label_b
     );
-    println!(
-        "{:-<20}-+-{:-<col_w$}-+-{:-<col_w$}",
-        "", "", ""
-    );
+    println!("{:-<20}-+-{:-<col_w$}-+-{:-<col_w$}", "", "", "");
 
     let a_rate = if a_count > 0 {
         a_pass as f64 / a_count as f64 * 100.0
@@ -182,11 +173,7 @@ fn format_entry(entry: Option<&serde_json::Value>) -> String {
     };
 
     let state = e["state"].as_str().unwrap_or("?");
-    let status = if state == "Validated" {
-        "PASS"
-    } else {
-        "FAIL"
-    };
+    let status = if state == "Validated" { "PASS" } else { "FAIL" };
     let score = e["idiomatic_score"].as_u64().unwrap_or(0);
     let ms = e["total_ms"].as_u64().unwrap_or(0);
     let secs = ms as f64 / 1000.0;
diff --git a/crates/noricum-cli/src/crust_bench.rs b/crates/noricum-cli/src/crust_bench.rs
@@ -29,7 +29,13 @@ const REPAIR_TEMP_STEP: f64 = 0.10;
 /// Multi-module projects get more iterations since failures are often localized.
 fn effective_max_repairs(interface_count: usize, c_loc: u32) -> u32 {
     let module_bonus = (interface_count / 3) as u32;
-    let size_bonus = if c_loc > 2000 { 2 } else if c_loc > 1000 { 1 } else { 0 };
+    let size_bonus = if c_loc > 2000 {
+        2
+    } else if c_loc > 1000 {
+        1
+    } else {
+        0
+    };
     (BASE_REPAIR_ITERATIONS + module_bonus + size_bonus).min(MAX_REPAIR_ITERATIONS)
 }
 
@@ -83,16 +89,10 @@ fn discover_projects(dataset_path: &Path) -> Result<Vec<CrustProject>> {
     let rbench = dataset_path.join("RBench");
 
     if !cbench.is_dir() {
-        anyhow::bail!(
-            "CBench directory not found at {}",
-            cbench.display()
-        );
+        anyhow::bail!("CBench directory not found at {}", cbench.display());
     }
     if !rbench.is_dir() {
-        anyhow::bail!(
-            "RBench directory not found at {}",
-            rbench.display()
-        );
+        anyhow::bail!("RBench directory not found at {}", rbench.display());
     }
 
     let mut rbench_names: std::collections::HashMap<String, PathBuf> =
@@ -141,8 +141,8 @@ fn read_c_sources(cbench_dir: &Path) -> Result<String> {
     let mut combined = String::new();
     for path in &sources {
         let name = path.strip_prefix(cbench_dir).unwrap_or(path);
-        let content = std::fs::read_to_string(path)
-            .with_context(|| format!("reading {}", path.display()))?;
+        let content =
+            std::fs::read_to_string(path).with_context(|| format!("reading {}", path.display()))?;
         combined.push_str(&format!("// === {} ===\n", name.display()));
         combined.push_str(&content);
         combined.push_str("\n\n");
@@ -633,7 +633,13 @@ fn write_and_read_impls(
     read_current_impls(workdir, interface_files)
 }
 
-fn make_error_result(name: String, c_loc: u32, start: std::time::Instant, llm_calls: u32, error: String) -> ProjectResult {
+fn make_error_result(
+    name: String,
+    c_loc: u32,
+    start: std::time::Instant,
+    llm_calls: u32,
+    error: String,
+) -> ProjectResult {
     ProjectResult {
         name,
         c_loc,
@@ -721,7 +727,13 @@ async fn run_project(project: &CrustProject, config: &MigrationConfig) -> Projec
             );
 
             match client
-                .run_prompt(&module_model, TRANSLATION_PREAMBLE, 0.3, module_tokens, &module_prompt)
+                .run_prompt(
+                    &module_model,
+                    TRANSLATION_PREAMBLE,
+                    0.3,
+                    module_tokens,
+                    &module_prompt,
+                )
                 .await
             {
                 Ok(response) => {
@@ -760,7 +772,13 @@ async fn run_project(project: &CrustProject, config: &MigrationConfig) -> Projec
                 }
             }
             Err(e) => {
-                return make_error_result(name, c_loc, start, 1, format!("translation failed: {e}"));
+                return make_error_result(
+                    name,
+                    c_loc,
+                    start,
+                    1,
+                    format!("translation failed: {e}"),
+                );
             }
         }
     }
@@ -785,13 +803,26 @@ async fn run_project(project: &CrustProject, config: &MigrationConfig) -> Projec
             let temp = 0.3 + (iter as f64 - 1.0) * REPAIR_TEMP_STEP;
 
             let repair_prompt = build_repair_prompt(
-                &c_source, &interface_files, &current_impl, &last_errors,
-                iter, max_repairs,
+                &c_source,
+                &interface_files,
+                &current_impl,
+                &last_errors,
+                iter,
+                max_repairs,
             );
 
             info!(project = %name, iteration = iter, max = max_repairs, temp, "repair attempt (build)");
 
-            match client.run_prompt(&repair_model, REPAIR_PREAMBLE, temp, max_tokens, &repair_prompt).await {
+            match client
+                .run_prompt(
+                    &repair_model,
+                    REPAIR_PREAMBLE,
+                    temp,
+                    max_tokens,
+                    &repair_prompt,
+                )
+                .await
+            {
                 Ok(response) => {
                     llm_calls += 1;
                     let repaired = parse_multi_file_output(&response, &interface_files);
@@ -838,22 +869,43 @@ async fn run_project(project: &CrustProject, config: &MigrationConfig) -> Projec
                 let temp = 0.3 + (iter as f64 - 1.0) * REPAIR_TEMP_STEP;
 
                 // Use targeted repair if we have per-binary failure info
-                let failed_only: Vec<_> = failed_binaries.iter().filter(|b| !b.passed).cloned().collect();
+                let failed_only: Vec<_> = failed_binaries
+                    .iter()
+                    .filter(|b| !b.passed)
+                    .cloned()
+                    .collect();
                 let repair_prompt = if !failed_only.is_empty() {
                     build_targeted_repair_prompt(
-                        &c_source, &interface_files, &current_impl,
-                        &failed_only, iter, max_repairs,
+                        &c_source,
+                        &interface_files,
+                        &current_impl,
+                        &failed_only,
+                        iter,
+                        max_repairs,
                     )
                 } else {
                     build_repair_prompt(
-                        &c_source, &interface_files, &current_impl,
-                        &test_out, iter, max_repairs,
+                        &c_source,
+                        &interface_files,
+                        &current_impl,
+                        &test_out,
+                        iter,
+                        max_repairs,
                     )
                 };
 
                 info!(project = %name, iteration = iter, max = max_repairs, temp, "repair attempt (tests)");
 
-                match client.run_prompt(&repair_model, REPAIR_PREAMBLE, temp, max_tokens, &repair_prompt).await {
+                match client
+                    .run_prompt(
+                        &repair_model,
+                        REPAIR_PREAMBLE,
+                        temp,
+                        max_tokens,
+                        &repair_prompt,
+                    )
+                    .await
+                {
                     Ok(response) => {
                         llm_calls += 1;
                         let repaired = parse_multi_file_output(&response, &interface_files);
@@ -894,13 +946,23 @@ async fn run_project(project: &CrustProject, config: &MigrationConfig) -> Projec
     let unsafe_count = count_unsafe(&current_impl);
     let idiomatic_score = if compilation_success {
         let base = 100.0_f64 - (unsafe_count as f64 * 10.0);
-        if tests_passed { base.max(0.0) } else { (base * 0.5).max(0.0) }
+        if tests_passed {
+            base.max(0.0)
+        } else {
+            (base * 0.5).max(0.0)
+        }
     } else {
         0.0
     };
 
     let elapsed = start.elapsed().as_millis() as u64;
-    let status = if tests_passed { "PASS" } else if compilation_success { "BUILD_OK" } else { "FAIL" };
+    let status = if tests_passed {
+        "PASS"
+    } else if compilation_success {
+        "BUILD_OK"
+    } else {
+        "FAIL"
+    };
     info!(project = %name, status, c_loc, rust_loc, unsafe_count, repair_iterations, llm_calls, elapsed_ms = elapsed, "project complete");
 
     ProjectResult {
@@ -915,7 +977,11 @@ async fn run_project(project: &CrustProject, config: &MigrationConfig) -> Projec
         repair_iterations,
         llm_calls,
         total_ms: elapsed,
-        error: if compilation_success { None } else { Some(last_errors) },
+        error: if compilation_success {
+            None
+        } else {
+            Some(last_errors)
+        },
     }
 }
 
@@ -953,7 +1019,13 @@ pub async fn run_crust_bench(config: &CrustBenchConfig) -> Result<CrustBenchRepo
     for (i, project) in projects.iter().enumerate() {
         info!(project = %project.name, progress = format!("[{}/{}]", i + 1, projects.len()), "starting project");
         let result = run_project(project, &config.migration_config).await;
-        let status = if result.tests_passed { "PASS" } else if result.compilation_success { "BUILD_OK" } else { "FAIL" };
+        let status = if result.tests_passed {
+            "PASS"
+        } else if result.compilation_success {
+            "BUILD_OK"
+        } else {
+            "FAIL"
+        };
         info!(project = %result.name, status, score = format!("{:.0}", result.idiomatic_score_avg), llm_calls = result.llm_calls, time_ms = result.total_ms, progress = format!("[{}/{}]", i + 1, projects.len()), "completed project");
         results.push(result);
     }
@@ -969,12 +1041,23 @@ pub async fn run_crust_bench(config: &CrustBenchConfig) -> Result<CrustBenchRepo
     let total_llm_calls: u32 = results.iter().map(|r| r.llm_calls).sum();
     let total_repair_iterations: u32 = results.iter().map(|r| r.repair_iterations).sum();
 
-    info!(total, compiled, passed, total_llm_calls, "CRUST-Bench evaluation complete");
+    info!(
+        total,
+        compiled, passed, total_llm_calls, "CRUST-Bench evaluation complete"
+    );
 
     Ok(CrustBenchReport {
         total_projects: total,
-        compilation_rate: if total > 0 { compiled as f64 / total as f64 } else { 0.0 },
-        test_pass_rate: if total > 0 { passed as f64 / total as f64 } else { 0.0 },
+        compilation_rate: if total > 0 {
+            compiled as f64 / total as f64
+        } else {
+            0.0
+        },
+        test_pass_rate: if total > 0 {
+            passed as f64 / total as f64
+        } else {
+            0.0
+        },
         avg_idiomatic_score: avg_score,
         total_llm_calls,
         total_repair_iterations,
@@ -1049,10 +1132,14 @@ mod tests {
 
     #[test]
     fn test_build_single_module_prompt() {
-        let target = (PathBuf::from("src/interfaces/foo.rs"), "fn foo() { unimplemented!() }".to_string());
-        let others = vec![
-            (PathBuf::from("src/interfaces/bar.rs"), "fn bar() -> i32 { 42 }".to_string()),
-        ];
+        let target = (
+            PathBuf::from("src/interfaces/foo.rs"),
+            "fn foo() { unimplemented!() }".to_string(),
+        );
+        let others = vec![(
+            PathBuf::from("src/interfaces/bar.rs"),
+            "fn bar() -> i32 { 42 }".to_string(),
+        )];
         let prompt = build_single_module_prompt("int foo() { return 1; }", &target, &others);
         assert!(prompt.contains("Target: implement foo.rs"));
         assert!(prompt.contains("Other module interfaces"));
@@ -1063,14 +1150,20 @@ mod tests {
     fn test_select_module_model_haiku() {
         let config = MigrationConfig::default();
         let model = select_module_model(50, &config);
-        assert!(model.contains("haiku"), "small module should use Haiku: {model}");
+        assert!(
+            model.contains("haiku"),
+            "small module should use Haiku: {model}"
+        );
     }
 
     #[test]
     fn test_select_module_model_sonnet() {
         let config = MigrationConfig::default();
         let model = select_module_model(200, &config);
-        assert!(model.contains("sonnet"), "medium module should use Sonnet: {model}");
+        assert!(
+            model.contains("sonnet"),
+            "medium module should use Sonnet: {model}"
+        );
     }
 
     #[test]
diff --git a/crates/noricum-core/src/orchestrator.rs b/crates/noricum-core/src/orchestrator.rs
@@ -626,13 +626,18 @@ pub async fn migrate_file(
         let c_lines_for_chunk = unit.c_source.lines().count();
         let use_chunked = c_lines_for_chunk > MEDIUM_FILE_LOC;
         let rust_code = if use_chunked {
-            let chunk_target = if c_lines_for_chunk > VERY_LARGE_FILE_LOC { 500 } else { 400 };
+            let chunk_target = if c_lines_for_chunk > VERY_LARGE_FILE_LOC {
+                500
+            } else {
+                400
+            };
             // Use structural chunking when data model patterns are detected
             let has_data_model = analysis.patterns.iter().any(|p| {
                 p.contains("struct") || p.contains("linked_list") || p.contains("recursive")
             });
             let chunks = if has_data_model {
-                let structural = noricum_tools::ast::chunk_c_source_structural(&unit.c_source, chunk_target);
+                let structural =
+                    noricum_tools::ast::chunk_c_source_structural(&unit.c_source, chunk_target);
                 if structural.len() > 1 {
                     info!(
                         function = %name,
diff --git a/crates/noricum-mcp/src/server.rs b/crates/noricum-mcp/src/server.rs
@@ -339,12 +339,7 @@ fn handle_tools_call(id: serde_json::Value, params: serde_json::Value) -> JsonRp
     let input_size: usize = call_params
         .arguments
         .as_object()
-        .map(|m| {
-            m.values()
-                .filter_map(|v| v.as_str())
-                .map(|s| s.len())
-                .sum()
-        })
+        .map(|m| m.values().filter_map(|v| v.as_str()).map(|s| s.len()).sum())
         .unwrap_or(0);
 
     info!(tool = %tool_name, input_bytes = input_size, "MCP tool call started");
diff --git a/crates/noricum-validation/src/lib.rs b/crates/noricum-validation/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ pub async fn translate_chunked(`
`165`	`165`	`chunk_source.push_str(`
`166`	`166`	`"\n\n// === INSTRUCTION: Translate data model to idiomatic Rust types FIRST. ===\n\`
`167`	`167`	`// Use enum variants instead of type tags. Convert linked-lists to Vec.\n\`
`168`		`- // Use String instead of *char. Replace malloc/free with RAII.\n"`
	`168`	`+ // Use String instead of *char. Replace malloc/free with RAII.\n",`
`169`	`169`	`);`
`170`	`170`	`}`
`171`	`171`	`chunk_source.push_str("\n\n// === Functions to translate ===\n");`