no-mistakes(lint): apply rustfmt and clippy fixes across workspace

Author: anvanster

crates/codegraph-cpp/src/visitor.rs

@@ -6,7 +6,7 @@
 use codegraph_parser_api::{
     truncate_body_prefix, CallRelation, ClassEntity, ComplexityBuilder, ComplexityMetrics,
     FunctionEntity, ImplementationRelation, ImportRelation, InheritanceRelation, Parameter,
-    TraitEntity, BODY_PREFIX_MAX_CHARS,
+    TraitEntity,
 };
 use tree_sitter::Node;
 
@@ -165,7 +165,7 @@ impl<'a> CppVisitor<'a> {
             .child_by_field_name("body")
             .and_then(|b| b.utf8_text(self.source).ok())
             .filter(|t| !t.is_empty())
-            .map(|t| truncate_body_prefix(t))
+            .map(truncate_body_prefix)
             .map(|t| t.to_string());
 
         let class_entity = ClassEntity {
@@ -323,7 +323,7 @@ impl<'a> CppVisitor<'a> {
             .child_by_field_name("body")
             .and_then(|b| b.utf8_text(self.source).ok())
             .filter(|t| !t.is_empty())
-            .map(|t| truncate_body_prefix(t))
+            .map(truncate_body_prefix)
             .map(|t| t.to_string());
 
         if is_virtual {
@@ -385,7 +385,7 @@ impl<'a> CppVisitor<'a> {
             .child_by_field_name("body")
             .and_then(|b| b.utf8_text(self.source).ok())
             .filter(|t| !t.is_empty())
-            .map(|t| truncate_body_prefix(t))
+            .map(truncate_body_prefix)
             .map(|t| t.to_string());
 
         if is_virtual {
@@ -509,7 +509,7 @@ impl<'a> CppVisitor<'a> {
             .child_by_field_name("body")
             .and_then(|b| b.utf8_text(self.source).ok())
             .filter(|t| !t.is_empty())
-            .map(|t| truncate_body_prefix(t))
+            .map(truncate_body_prefix)
             .map(|t| t.to_string());
 
         let enum_entity = ClassEntity {
@@ -1017,6 +1017,7 @@ impl<'a> CppVisitor<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use codegraph_parser_api::BODY_PREFIX_MAX_CHARS;
     use tree_sitter::Parser;
 
     fn parse_and_visit(source: &[u8]) -> CppVisitor<'_> {

crates/codegraph-erlang/src/mapper.rs

@@ -257,7 +257,7 @@ mod tests {
         }
     }
 
-    fn prop<'a>(graph: &'a CodeGraph, id: NodeId, key: &str) -> Option<PropertyValue> {
+    fn prop(graph: &CodeGraph, id: NodeId, key: &str) -> Option<PropertyValue> {
         graph.get_node(id).unwrap().properties.get(key).cloned()
     }
 

crates/codegraph-harness/src/bless.rs

@@ -27,10 +27,9 @@ use std::path::Path;
 /// YAML are preserved structurally — keys keep their order best-
 /// effort, but comments are lost.
 pub fn rewrite_expect_data(path: &Path, new_data: &Json) -> Result<()> {
-    let raw = std::fs::read_to_string(path)
-        .with_context(|| format!("read {}", path.display()))?;
-    let mut doc: Yaml = serde_yaml::from_str(&raw)
-        .with_context(|| format!("parse {} as YAML", path.display()))?;
+    let raw = std::fs::read_to_string(path).with_context(|| format!("read {}", path.display()))?;
+    let mut doc: Yaml =
+        serde_yaml::from_str(&raw).with_context(|| format!("parse {} as YAML", path.display()))?;
 
     let expect = doc
         .as_mapping_mut()
@@ -43,8 +42,7 @@ pub fn rewrite_expect_data(path: &Path, new_data: &Json) -> Result<()> {
 
     let serialised = serde_yaml::to_string(&doc)
         .with_context(|| format!("serialise {} after rewrite", path.display()))?;
-    std::fs::write(path, serialised)
-        .with_context(|| format!("write {}", path.display()))?;
+    std::fs::write(path, serialised).with_context(|| format!("write {}", path.display()))?;
     Ok(())
 }
 
@@ -98,15 +96,8 @@ mod tests {
         // Round-trip the file through serde_yaml so we can assert on
         // the structured content rather than literal text formatting.
         let parsed: serde_yaml::Value = serde_yaml::from_str(&after).unwrap();
-        let data = parsed
-            .get("expect")
-            .unwrap()
-            .get("data")
-            .unwrap();
-        let expected_yaml: Yaml = serde_yaml::from_str(
-            "results:\n  - name: a\n",
-        )
-        .unwrap();
+        let data = parsed.get("expect").unwrap().get("data").unwrap();
+        let expected_yaml: Yaml = serde_yaml::from_str("results:\n  - name: a\n").unwrap();
         assert_eq!(*data, expected_yaml);
     }
 

crates/codegraph-harness/src/compare.rs

@@ -63,14 +63,26 @@ pub fn compare(actual: &Value, expected: &Value, mode: MatchMode) -> Result<Comp
     let mut errors = Vec::new();
     walk(&mut path, actual, expected, mode, &mut errors);
     if errors.is_empty() {
-        Ok(Comparison { passed: true, diff: String::new() })
+        Ok(Comparison {
+            passed: true,
+            diff: String::new(),
+        })
     } else {
         let diff = format_diff(&errors, actual, expected, mode);
-        Ok(Comparison { passed: false, diff })
+        Ok(Comparison {
+            passed: false,
+            diff,
+        })
     }
 }
 
-fn walk(path: &mut String, actual: &Value, expected: &Value, mode: MatchMode, errors: &mut Vec<String>) {
+fn walk(
+    path: &mut String,
+    actual: &Value,
+    expected: &Value,
+    mode: MatchMode,
+    errors: &mut Vec<String>,
+) {
     // Tolerance sentinel: `expected` is `{ "__tol__": { value, tol } }`.
     // Recognised at every depth, every match mode.
     if let Some(band) = parse_tol(expected) {
@@ -99,13 +111,7 @@ fn walk(path: &mut String, actual: &Value, expected: &Value, mode: MatchMode, er
                 path.push_str(k);
                 match a.get(k) {
                     None => errors.push(format!("{}: missing key", path)),
-                    Some(av) => {
-                        if mode == MatchMode::CountOnly {
-                            walk(path, av, ev, mode, errors);
-                        } else {
-                            walk(path, av, ev, mode, errors);
-                        }
-                    }
+                    Some(av) => walk(path, av, ev, mode, errors),
                 }
                 path.truncate(len);
             }
@@ -121,12 +127,7 @@ fn walk(path: &mut String, actual: &Value, expected: &Value, mode: MatchMode, er
         (Value::Array(a), Value::Array(e)) => match mode {
             MatchMode::Exact | MatchMode::Structural | MatchMode::CountOnly => {
                 if a.len() != e.len() {
-                    errors.push(format!(
-                        "{}: array length {} != {}",
-                        path,
-                        a.len(),
-                        e.len()
-                    ));
+                    errors.push(format!("{}: array length {} != {}", path, a.len(), e.len()));
                     return;
                 }
                 if mode == MatchMode::CountOnly {
@@ -242,7 +243,10 @@ fn format_diff(errors: &[String], actual: &Value, expected: &Value, mode: MatchM
 }
 
 fn prefix_lines(s: &str, prefix: &str) -> String {
-    s.lines().map(|l| format!("{}{}", prefix, l)).collect::<Vec<_>>().join("\n")
+    s.lines()
+        .map(|l| format!("{}{}", prefix, l))
+        .collect::<Vec<_>>()
+        .join("\n")
 }
 
 #[cfg(test)]
@@ -258,12 +262,7 @@ mod tests {
 
     #[test]
     fn exact_flags_extra_actual_key() {
-        let r = compare(
-            &json!({"a": 1, "b": 2}),
-            &json!({"a": 1}),
-            MatchMode::Exact,
-        )
-        .unwrap();
+        let r = compare(&json!({"a": 1, "b": 2}), &json!({"a": 1}), MatchMode::Exact).unwrap();
         assert!(!r.passed);
         assert!(r.diff.contains("unexpected key"));
     }
@@ -413,7 +412,9 @@ mod tests {
         assert!(parse_tol(&json!("x")).is_none());
         // Object but not a single key.
         assert!(parse_tol(&json!({})).is_none());
-        assert!(parse_tol(&json!({TOL_SENTINEL: {"value": 1.0, "tol": 0.1}, "extra": 1})).is_none());
+        assert!(
+            parse_tol(&json!({TOL_SENTINEL: {"value": 1.0, "tol": 0.1}, "extra": 1})).is_none()
+        );
     }
 
     #[test]

crates/codegraph-harness/src/jsonrpc.rs

@@ -35,11 +35,20 @@ impl McpClient {
             .stdout(Stdio::piped())
             .stderr(Stdio::null());
         let mut child = cmd.spawn().with_context(|| {
-            format!("spawn {} --mcp --workspace {}", binary.display(), workspace.display())
+            format!(
+                "spawn {} --mcp --workspace {}",
+                binary.display(),
+                workspace.display()
+            )
         })?;
         let stdin = child.stdin.take().ok_or_else(|| anyhow!("no stdin"))?;
         let stdout = BufReader::new(child.stdout.take().ok_or_else(|| anyhow!("no stdout"))?);
-        let mut client = McpClient { child, stdin, stdout, next_id: 1 };
+        let mut client = McpClient {
+            child,
+            stdin,
+            stdout,
+            next_id: 1,
+        };
         client.handshake()?;
         Ok(client)
     }

crates/codegraph-harness/src/main.rs

@@ -73,9 +73,7 @@ fn main() -> Result<()> {
     let args = Args::parse();
     let crate_root = Path::new(env!("CARGO_MANIFEST_DIR"));
     let binary = resolve_binary(args.binary.as_deref(), crate_root)?;
-    let cases_dir = args
-        .cases_dir
-        .unwrap_or_else(|| crate_root.join("cases"));
+    let cases_dir = args.cases_dir.unwrap_or_else(|| crate_root.join("cases"));
     let fixtures_dir = args
         .fixtures_dir
         .unwrap_or_else(|| crate_root.join("fixtures"));
@@ -179,7 +177,10 @@ fn main() -> Result<()> {
         match report.drift_against(&coverage_path) {
             Ok(d) => d,
             Err(e) => {
-                eprintln!("warning: could not read previous coverage snapshot: {:#}", e);
+                eprintln!(
+                    "warning: could not read previous coverage snapshot: {:#}",
+                    e
+                );
                 None
             }
         }
@@ -214,7 +215,12 @@ fn discover_cases(cases_dir: &Path, filter: Option<&str>) -> Result<Vec<case::Te
         ));
     }
     let patterns: Vec<&str> = filter
-        .map(|f| f.split(',').map(str::trim).filter(|s| !s.is_empty()).collect())
+        .map(|f| {
+            f.split(',')
+                .map(str::trim)
+                .filter(|s| !s.is_empty())
+                .collect()
+        })
         .unwrap_or_default();
     for entry in walkdir::WalkDir::new(cases_dir) {
         let entry = entry?;

crates/codegraph-harness/src/normalize.rs

@@ -109,7 +109,7 @@ fn strip_volatile(value: &Value, extra: &[String], keep: &[String]) -> Value {
         Value::Object(map) => {
             let mut new_map = serde_json::Map::with_capacity(map.len());
             for (k, v) in map {
-                let is_global = VOLATILE_FIELDS.iter().any(|f| *f == k.as_str());
+                let is_global = VOLATILE_FIELDS.contains(&k.as_str());
                 let is_extra = extra.iter().any(|f| f == k);
                 let is_kept = keep.iter().any(|f| f == k);
                 if (is_global || is_extra) && !is_kept {
@@ -119,11 +119,9 @@ fn strip_volatile(value: &Value, extra: &[String], keep: &[String]) -> Value {
             }
             Value::Object(new_map)
         }
-        Value::Array(arr) => Value::Array(
-            arr.iter()
-                .map(|v| strip_volatile(v, extra, keep))
-                .collect(),
-        ),
+        Value::Array(arr) => {
+            Value::Array(arr.iter().map(|v| strip_volatile(v, extra, keep)).collect())
+        }
         other => other.clone(),
     }
 }
@@ -302,11 +300,7 @@ mod tests {
     #[test]
     fn strip_volatile_keep_overrides_extra() {
         let input = json!({"name": "foo", "trace_id": "abc"});
-        let out = strip_volatile(
-            &input,
-            &["trace_id".to_string()],
-            &["trace_id".to_string()],
-        );
+        let out = strip_volatile(&input, &["trace_id".to_string()], &["trace_id".to_string()]);
         assert_eq!(out, json!({"name": "foo", "trace_id": "abc"}));
     }
 
@@ -346,10 +340,13 @@ mod tests {
         ]);
         let out = canonical_sort(&input);
         // Sorted by JSON string — `{"id":1,"name":"a"}` < `{"id":2,"name":"b"}`.
-        assert_eq!(out, json!([
-            {"name": "a", "id": 1},
-            {"name": "b", "id": 2}
-        ]));
+        assert_eq!(
+            out,
+            json!([
+                {"name": "a", "id": 1},
+                {"name": "b", "id": 2}
+            ])
+        );
     }
 
     #[test]
@@ -387,10 +384,7 @@ mod tests {
         });
         let patterns = vec![json!({"kind": "y"})];
         let out = drop_array_elements_matching(&input, &patterns);
-        assert_eq!(
-            out,
-            json!({"outer": [{"inner": [{"kind": "x"}]}]})
-        );
+        assert_eq!(out, json!({"outer": [{"inner": [{"kind": "x"}]}]}));
     }
 
     #[test]
@@ -450,12 +444,15 @@ mod tests {
             drop_where: vec![],
         };
         let out = normalize(&input, "", "", &opts);
-        assert_eq!(out, json!({
-            "results": [
-                {"name": "a", "weight": 0.91},
-                {"name": "b", "weight": 0.78}
-            ]
-        }));
+        assert_eq!(
+            out,
+            json!({
+                "results": [
+                    {"name": "a", "weight": 0.91},
+                    {"name": "b", "weight": 0.78}
+                ]
+            })
+        );
     }
 
     #[test]

crates/codegraph-harness/src/report.rs

@@ -306,6 +306,7 @@ pub fn record_from_result(case: &crate::case::TestCase, result: &CaseResult) ->
 /// - `languages/<lang>/<file>` — single-file fixtures
 /// - `multifile/<lang>_<scenario>/...` — multi-file fixtures, where
 ///   `<lang>` is everything before the first `_` of the directory name
+///
 /// Falls back to `unknown` for off-convention paths.
 fn language_from_fixture(fixture: &str) -> String {
     let parts: Vec<&str> = fixture.split('/').collect();