hecks 3.13.0 → 4.0.0

data/rust/Cargo.toml

@@ -6,6 +6,10 @@
 # `--no-default-features --features <name>`.
 [features]
 default = ["reserved_names_fixture"]
+tally = []
+relay = []
+meter = []
+courier = []
 attribute_constraints_fixture = []
 optional_nested_value_object_fixture = []
 computed_sets_fixture = []
@@ -67,3 +71,39 @@ path = "src/main.rs"
 # Only this dev profile is affected; release builds are unchanged.
 [profile.dev]
 debug = 0
+
+# Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
+# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# The same table is in every crate's Cargo.toml; change them together.
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+unwrap_used = "warn"
+expect_used = "warn"
+panic = "warn"
+dbg_macro = "warn"
+todo = "warn"
+unimplemented = "warn"
+# Lints that ask for prose or an attribute on every item rather than for better code.
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+must_use_candidate = "allow"
+return_self_not_must_use = "allow"
+module_name_repetitions = "allow"
+too_many_lines = "allow"
+too_long_first_doc_paragraph = "allow"
+doc_markdown = "allow"
+# Numeric conversions here are deliberate: JSON numbers are f64 and ids are small.
+cast_possible_truncation = "allow"
+cast_possible_wrap = "allow"
+cast_precision_loss = "allow"
+cast_sign_loss = "allow"
+# Naming heuristics that fire on ordinary short names.
+similar_names = "allow"
+many_single_char_names = "allow"
+struct_field_names = "allow"
+# Heuristics that cost more clarity than they buy here.
+redundant_pub_crate = "allow"
+future_not_send = "allow"
+significant_drop_tightening = "allow"
+match_same_arms = "allow"

data/rust/build/Cargo.toml

@@ -17,3 +17,39 @@ path = "src/main.rs"
 # Debug info is off: CI binaries are run once and never attached to a debugger.
 [profile.dev]
 debug = 0
+
+# Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
+# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# The same table is in every crate's Cargo.toml; change them together.
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+unwrap_used = "warn"
+expect_used = "warn"
+panic = "warn"
+dbg_macro = "warn"
+todo = "warn"
+unimplemented = "warn"
+# Lints that ask for prose or an attribute on every item rather than for better code.
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+must_use_candidate = "allow"
+return_self_not_must_use = "allow"
+module_name_repetitions = "allow"
+too_many_lines = "allow"
+too_long_first_doc_paragraph = "allow"
+doc_markdown = "allow"
+# Numeric conversions here are deliberate: JSON numbers are f64 and ids are small.
+cast_possible_truncation = "allow"
+cast_possible_wrap = "allow"
+cast_precision_loss = "allow"
+cast_sign_loss = "allow"
+# Naming heuristics that fire on ordinary short names.
+similar_names = "allow"
+many_single_char_names = "allow"
+struct_field_names = "allow"
+# Heuristics that cost more clarity than they buy here.
+redundant_pub_crate = "allow"
+future_not_send = "allow"
+significant_drop_tightening = "allow"
+match_same_arms = "allow"

data/rust/build/clippy.toml

@@ -0,0 +1,4 @@
+# The restriction lints (unwrap, expect, panic) guard library code; a test panics to fail.
+allow-unwrap-in-tests = true
+allow-expect-in-tests = true
+allow-panic-in-tests = true

data/rust/build/src/adapters_pass.rs

@@ -0,0 +1,196 @@
+//! Rust port of `Projector::Exporter#persistence_adapters`: the `adapters` key, the declarations
+//! of the persistence adapters a domain binds, so `rust/host` looks adapters up in the IR instead
+//! of a hard-coded list. Only declarations: a world's setting values never enter it.
+
+use std::path::{Path, PathBuf};
+
+use crate::json::Json;
+use crate::subprocess;
+
+// Never a source `.adapter`: build output and copies. Hidden directories are skipped too, as
+// Ruby's `Dir.glob` skips them.
+const SKIPPED_DIRS: [&str; 5] = ["target", "vendor", "node_modules", "tmp", ".git"];
+
+/// The `adapters` array for `ir`: one entry per distinct adapter name in
+/// `ir["persistence"]["aggregates"][].adapter` that an `.adapter` file under `directories`
+/// declares, in name byte order. `hecks-parse adapter` reads all the files in one run.
+///
+/// # Errors
+///
+/// Returns the parser's failure, or a message naming an unreadable directory or output that
+/// is not the JSON array `hecks-parse adapter` prints.
+pub fn declarations(parser_bin: &Path, directories: &[PathBuf], ir: &Json) -> Result<Json, String> {
+    let names = bound_names(ir);
+    if names.is_empty() {
+        return Ok(Json::Array(Vec::new()));
+    }
+    let files = files_under(directories)?;
+    if files.is_empty() {
+        return Ok(Json::Array(Vec::new()));
+    }
+    let mut args = vec!["adapter".to_string()];
+    args.extend(files.iter().map(|p| p.to_string_lossy().to_string()));
+    let arg_refs: Vec<&str> = args.iter().map(String::as_str).collect();
+    let printed = subprocess::run_capture(&parser_bin.to_string_lossy(), &arg_refs)?;
+    let parsed = Json::parse(&printed).map_err(|e| format!("parsing hecks-parse adapter: {e}"))?;
+    Ok(select(&parsed, &names))
+}
+
+/// The distinct adapter names `ir`'s persistence block binds, in byte order.
+pub fn bound_names(ir: &Json) -> Vec<String> {
+    let aggregates = ir
+        .get("persistence")
+        .and_then(|persistence| persistence.get("aggregates"))
+        .map_or(&[][..], Json::each);
+    let mut names: Vec<String> = aggregates
+        .iter()
+        .filter_map(|aggregate| aggregate.get("adapter").and_then(Json::as_str))
+        .map(str::to_string)
+        .collect();
+    names.sort();
+    names.dedup();
+    names
+}
+
+/// The entries of `declared` whose name is in `names`, the first of any repeated name
+/// winning, in name byte order.
+pub fn select(declared: &Json, names: &[String]) -> Json {
+    let mut chosen: Vec<(String, Json)> = Vec::new();
+    for adapter in declared.each() {
+        let Some(name) = adapter.get("name").and_then(Json::as_str) else {
+            continue;
+        };
+        if names.iter().any(|wanted| wanted == name) && !chosen.iter().any(|(n, _)| n == name) {
+            chosen.push((name.to_string(), adapter.clone()));
+        }
+    }
+    chosen.sort_by(|a, b| a.0.as_bytes().cmp(b.0.as_bytes()));
+    Json::Array(chosen.into_iter().map(|(_, adapter)| adapter).collect())
+}
+
+/// Every `.adapter` file beneath `directories`, as absolute paths, unique and in byte order of
+/// the path text. A directory that does not exist contributes none.
+///
+/// # Errors
+///
+/// Returns a message when a directory that exists cannot be read.
+pub fn files_under(directories: &[PathBuf]) -> Result<Vec<PathBuf>, String> {
+    let mut found = Vec::new();
+    for directory in directories {
+        let absolute = std::path::absolute(directory)
+            .map_err(|e| format!("resolving {}: {e}", directory.display()))?;
+        if absolute.is_dir() {
+            walk(&absolute, &mut found)?;
+        }
+    }
+    found.sort_by(|a, b| {
+        a.to_string_lossy()
+            .as_bytes()
+            .cmp(b.to_string_lossy().as_bytes())
+    });
+    found.dedup();
+    Ok(found)
+}
+
+fn walk(directory: &Path, found: &mut Vec<PathBuf>) -> Result<(), String> {
+    let entries = std::fs::read_dir(directory)
+        .map_err(|e| format!("reading {}: {e}", directory.display()))?;
+    for entry in entries {
+        let entry = entry.map_err(|e| format!("reading {}: {e}", directory.display()))?;
+        let path = entry.path();
+        let file_name = entry.file_name().to_string_lossy().to_string();
+        let is_dir = entry.file_type().is_ok_and(|kind| kind.is_dir());
+        if is_dir {
+            if !file_name.starts_with('.') && !SKIPPED_DIRS.contains(&file_name.as_str()) {
+                walk(&path, found)?;
+            }
+        } else if !file_name.starts_with('.') && file_name.ends_with(".adapter") && path.is_file() {
+            found.push(path);
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::tmp::TempDir;
+
+    fn parsed(text: &str) -> Json {
+        Json::parse(text).expect("fixture json")
+    }
+
+    fn ir(adapters: &[&str]) -> Json {
+        let rows: Vec<String> = adapters
+            .iter()
+            .map(|a| format!("{{\"name\":\"A\",\"storage_name\":\"a\",\"adapter\":\"{a}\"}}"))
+            .collect();
+        parsed(&format!(
+            "{{\"persistence\":{{\"aggregates\":[{}]}}}}",
+            rows.join(",")
+        ))
+    }
+
+    #[test]
+    fn bound_names_are_distinct_and_sorted() {
+        let names = bound_names(&ir(&["Postgres", "Heki", "Postgres"]));
+        assert_eq!(names, vec!["Heki".to_string(), "Postgres".to_string()]);
+        assert!(bound_names(&parsed("{}")).is_empty());
+    }
+
+    #[test]
+    fn select_keeps_bound_declarations_sorted_and_first_wins() {
+        let declared = parsed(
+            "[{\"name\":\"Postgres\",\"port\":\"persistence\",\"fields\":[],\"secrets\":[],\"defaults\":{}},\
+              {\"name\":\"Unbound\",\"port\":null,\"fields\":[],\"secrets\":[],\"defaults\":{}},\
+              {\"name\":\"Heki\",\"port\":\"persistence\",\"fields\":[\"dir\"],\"secrets\":[],\"defaults\":{\"dir\":\"data\"}},\
+              {\"name\":\"Heki\",\"port\":null,\"fields\":[],\"secrets\":[],\"defaults\":{}}]",
+        );
+        let wanted = ["Heki", "Missing", "Postgres"].map(str::to_string);
+        let chosen = select(&declared, &wanted);
+        let names: Vec<&str> = chosen
+            .each()
+            .iter()
+            .filter_map(|a| a.get("name").and_then(Json::as_str))
+            .collect();
+        assert_eq!(names, vec!["Heki", "Postgres"]);
+        let heki_fields = chosen.each()[0].get("fields").map(|f| f.each().len());
+        assert_eq!(heki_fields, Some(1));
+    }
+
+    #[test]
+    fn files_under_skips_build_and_hidden_directories() {
+        let dir = TempDir::new("adapters-pass").expect("temp dir");
+        let root = dir.path();
+        for relative in [
+            "lib/a/heki.adapter",
+            "lib/b/memory.adapter",
+            "lib/target/skipped.adapter",
+            "lib/vendor/skipped.adapter",
+            "lib/node_modules/skipped.adapter",
+            "lib/tmp/skipped.adapter",
+            "lib/.hidden/skipped.adapter",
+            "lib/a/notes.txt",
+        ] {
+            let path = root.join(relative);
+            std::fs::create_dir_all(path.parent().expect("parent")).expect("mkdir");
+            std::fs::write(&path, "").expect("write");
+        }
+        let scanned = [root.join("lib"), root.join("lib"), root.join("absent")];
+        let found = files_under(&scanned).expect("scan");
+        let relative: Vec<String> = found
+            .iter()
+            .map(|p| {
+                let under = p.strip_prefix(root).expect("under root");
+                under.to_string_lossy().to_string()
+            })
+            .collect();
+        assert_eq!(relative, vec!["lib/a/heki.adapter", "lib/b/memory.adapter"]);
+    }
+
+    #[test]
+    fn no_bound_adapter_means_an_empty_array_without_running_the_parser() {
+        let none = declarations(Path::new("/no/such/parser"), &[], &ir(&[])).expect("empty");
+        assert_eq!(none, Json::Array(Vec::new()));
+    }
+}

data/rust/build/src/binding_pass.rs

@@ -1,5 +1,6 @@
 //! Rust port of the binding facts `lib/hecks/rust_build/project_rust/target_ir.rb` adds beside the
-//! declared IR: `persistence`, `translations` and `source_text`. The capability seams
+//! declared IR: `persistence`, `adapters` (the bound adapters' declarations, from the closure
+//! the caller passes), `translations` and `source_text`. The capability seams
 //! (authorization, identity, payments, ...) are `seams_pass`'s.
 
 use std::collections::HashMap;
@@ -10,10 +11,21 @@ use crate::lineage_pass;
 use crate::translation_pass;
 
 /// Sets `persistence`, the first of the binding facts, in `TargetIr#call`'s order.
-pub fn run(ir: &mut Json, hecksagon_path: Option<&Path>, world_path: Option<&Path>) -> Result<(), String> {
-    let chapter_name = ir.get("name").and_then(Json::as_str).unwrap_or_default().to_string();
+pub fn run(
+    ir: &mut Json,
+    hecksagon_path: Option<&Path>,
+    world_path: Option<&Path>,
+    adapter_declarations: impl FnOnce(&Json) -> Result<Json, String>,
+) -> Result<(), String> {
+    let chapter_name = ir
+        .get("name")
+        .and_then(Json::as_str)
+        .unwrap_or_default()
+        .to_string();
     let persistence = persistence(ir, &chapter_name, hecksagon_path, world_path)?;
     ir.set("persistence", persistence);
+    let adapters = adapter_declarations(ir)?;
+    ir.set("adapters", adapters);
     Ok(())
 }
 
@@ -23,7 +35,11 @@ pub fn run(ir: &mut Json, hecksagon_path: Option<&Path>, world_path: Option<&Pat
 /// `translations` carries each `translations/*.bluebook` edge with its precompiled SQL, from
 /// `translation_pass`; an edge using a rule kind that pass does not compile is refused, never
 /// shipped without its SQL. A `translates` declaration in a bluebook is refused outright.
-pub fn finish(ir: &mut Json, bluebook_files: &[PathBuf], bluebook_dir: &Path) -> Result<(), String> {
+pub fn finish(
+    ir: &mut Json,
+    bluebook_files: &[PathBuf],
+    bluebook_dir: &Path,
+) -> Result<(), String> {
     let mut texts = Vec::new();
     for path in bluebook_files {
         let text = read(path)?;
@@ -35,7 +51,10 @@ pub fn finish(ir: &mut Json, bluebook_files: &[PathBuf], bluebook_dir: &Path) ->
         }
         texts.push(text);
     }
-    ir.set("translations", Json::Array(translation_pass::edges(bluebook_dir)?));
+    ir.set(
+        "translations",
+        Json::Array(translation_pass::edges(bluebook_dir)?),
+    );
     if !texts.is_empty() {
         ir.set("source_text", Json::String(texts.join("\n")));
     }
@@ -47,11 +66,19 @@ fn declares_translation(line: &str) -> bool {
     line.starts_with("translates") || line.starts_with("translation ")
 }
 
-fn persistence(ir: &Json, chapter: &str, hecksagon: Option<&Path>, world: Option<&Path>) -> Result<Json, String> {
+fn persistence(
+    ir: &Json,
+    chapter: &str,
+    hecksagon: Option<&Path>,
+    world: Option<&Path>,
+) -> Result<Json, String> {
     let (binds, hecksagon_default) = match hecksagon {
         Some(path) => {
             let text = read(path)?;
-            (lineage_pass::persistence_binds(&text), domain_default(&text, chapter))
+            (
+                lineage_pass::persistence_binds(&text),
+                domain_default(&text, chapter),
+            )
         }
         None => (HashMap::new(), None),
     };
@@ -61,8 +88,12 @@ fn persistence(ir: &Json, chapter: &str, hecksagon: Option<&Path>, world: Option
     };
     let declared = hecksagon_default.or(world_default);
     let mut aggregates = Vec::new();
-    for aggregate in ir.get("aggregates").map(Json::each).unwrap_or(&[]) {
-        let name = aggregate.get("name").and_then(Json::as_str).unwrap_or_default().to_string();
+    for aggregate in ir.get("aggregates").map_or(&[][..], Json::each) {
+        let name = aggregate
+            .get("name")
+            .and_then(Json::as_str)
+            .unwrap_or_default()
+            .to_string();
         let adapter = match (binds.get(&name), &declared, hecksagon.is_some()) {
             (Some(adapter), _, _) => adapter.clone(),
             (None, Some(adapter), _) => adapter.clone(),
@@ -73,11 +104,17 @@ fn persistence(ir: &Json, chapter: &str, hecksagon: Option<&Path>, world: Option
         };
         aggregates.push(Json::Object(vec![
             ("name".to_string(), Json::String(name.clone())),
-            ("storage_name".to_string(), Json::String(lineage_pass::snake_case(&name))),
+            (
+                "storage_name".to_string(),
+                Json::String(crate::hecks_naming::snake(&name)),
+            ),
             ("adapter".to_string(), Json::String(adapter)),
         ]));
     }
-    Ok(Json::Object(vec![("aggregates".to_string(), Json::Array(aggregates))]))
+    Ok(Json::Object(vec![(
+        "aggregates".to_string(),
+        Json::Array(aggregates),
+    )]))
 }
 
 // The bare `persisted_by "X"` line of the chapter's own `Hecks.hecksagon` block: every aggregate
@@ -90,8 +127,12 @@ fn domain_default(text: &str, chapter: &str) -> Option<String> {
             in_chapter = rest.contains(&format!("\"{chapter}\""));
             continue;
         }
-        let Some(rest) = line.trim_start().strip_prefix("persisted_by ") else { continue };
-        let Some(open) = rest.find('"').filter(|_| in_chapter) else { continue };
+        let Some(rest) = line.trim_start().strip_prefix("persisted_by ") else {
+            continue;
+        };
+        let Some(open) = rest.find('"').filter(|_| in_chapter) else {
+            continue;
+        };
         let quoted = &rest[open + 1..];
         found = quoted.find('"').map(|close| quoted[..close].to_string());
     }

data/rust/build/src/build_artifact.rs

@@ -26,20 +26,38 @@ pub fn build_wasm(root: &Path, rust_dir: &Path, target_mod_name: &str) -> Result
     }
 
     println!("== cargo build --release --target wasm32-wasip1 (via rustup run stable) ==");
-    subprocess::run_in(rust_dir, "rustup", &["run", "stable", "cargo", "build", "--release", "--target", "wasm32-wasip1"])?;
+    subprocess::run_in(
+        rust_dir,
+        "rustup",
+        &[
+            "run",
+            "stable",
+            "cargo",
+            "build",
+            "--release",
+            "--target",
+            "wasm32-wasip1",
+        ],
+    )?;
 
     let dist_dir = root.join("rust/dist");
-    std::fs::create_dir_all(&dist_dir).map_err(|e| format!("creating {}: {e}", dist_dir.display()))?;
+    std::fs::create_dir_all(&dist_dir)
+        .map_err(|e| format!("creating {}: {e}", dist_dir.display()))?;
 
     let built = rust_dir.join("target/wasm32-wasip1/release/rust.wasm");
     let out = dist_dir.join(format!("{target_mod_name}.wasm"));
-    std::fs::copy(&built, &out).map_err(|e| format!("copying {} to {}: {e}", built.display(), out.display()))?;
+    std::fs::copy(&built, &out)
+        .map_err(|e| format!("copying {} to {}: {e}", built.display(), out.display()))?;
     println!("wrote {}", out.display());
 
-    let ir_json = root.join("rust/src/generated").join(target_mod_name).join("ir.json");
+    let ir_json = root
+        .join("rust/src/generated")
+        .join(target_mod_name)
+        .join("ir.json");
     if ir_json.is_file() {
         let ir_out = dist_dir.join(format!("{target_mod_name}.ir.json"));
-        std::fs::copy(&ir_json, &ir_out).map_err(|e| format!("copying {} to {}: {e}", ir_json.display(), ir_out.display()))?;
+        std::fs::copy(&ir_json, &ir_out)
+            .map_err(|e| format!("copying {} to {}: {e}", ir_json.display(), ir_out.display()))?;
         println!("wrote {}", ir_out.display());
     }
 

data/rust/build/src/cargo_sync.rs

@@ -1,6 +1,7 @@
 //! Rewrites the root `generated/mod.rs` and syncs `rust/Cargo.toml` `[features]`.
 //! Ports `sync_mod_and_cargo!`, keeping its output byte-identical.
 
+use std::fmt::Write as _;
 use std::path::Path;
 
 // Both tables come from the reserved-word vocabularies via `hecks project_reserved_names`.
@@ -11,21 +12,30 @@ pub fn valid_domain_mod_name(name: &str) -> bool {
     let mut chars = name.chars();
     let starts_ok = matches!(chars.next(), Some(c) if c == '_' || c.is_ascii_lowercase());
     let rest_ok = chars.all(|c| c == '_' || c.is_ascii_lowercase() || c.is_ascii_digit());
-    starts_ok && rest_ok && !RUST_KEYWORDS.contains(&name) && !CARGO_RESERVED_DOMAIN_NAMES.contains(&name)
+    starts_ok
+        && rest_ok
+        && !RUST_KEYWORDS.contains(&name)
+        && !CARGO_RESERVED_DOMAIN_NAMES.contains(&name)
 }
 
 /// Lists the directories under `out_root`, and those with a `merged.rs` (activatable domains).
 fn scan_generated_dirs(out_root: &Path) -> Result<(Vec<String>, Vec<String>), String> {
     let mut all_dirs = Vec::new();
-    for entry in std::fs::read_dir(out_root).map_err(|e| format!("reading {}: {e}", out_root.display()))? {
+    for entry in
+        std::fs::read_dir(out_root).map_err(|e| format!("reading {}: {e}", out_root.display()))?
+    {
         let entry = entry.map_err(|e| format!("reading {}: {e}", out_root.display()))?;
-        if entry.file_type().map(|t| t.is_dir()).unwrap_or(false) {
+        if entry.file_type().is_ok_and(|t| t.is_dir()) {
             all_dirs.push(entry.file_name().to_string_lossy().to_string());
         }
     }
     all_dirs.sort();
 
-    let domains = all_dirs.iter().filter(|name| out_root.join(name).join("merged.rs").is_file()).cloned().collect();
+    let domains = all_dirs
+        .iter()
+        .filter(|name| out_root.join(name).join("merged.rs").is_file())
+        .cloned()
+        .collect();
 
     Ok((all_dirs, domains))
 }
@@ -35,7 +45,12 @@ fn scan_generated_dirs(out_root: &Path) -> Result<(Vec<String>, Vec<String>), St
 /// Cargo has no mutually-exclusive features, so the default domain's re-export backs off when
 /// another domain feature is on, and two non-default features hit an explicit `compile_error!`
 /// instead of a duplicate-import E0252.
-fn write_root_mod(out_root: &Path, all_dirs: &[String], domains: &[String], target_mod_name: &str) -> Result<(), String> {
+fn write_root_mod(
+    out_root: &Path,
+    all_dirs: &[String],
+    domains: &[String],
+    target_mod_name: &str,
+) -> Result<(), String> {
     let mut out = String::new();
     out.push_str("// GENERATED by hecks project_rust — re-run it to refresh this list.\n");
     out.push_str("//\n");
@@ -53,9 +68,9 @@ fn write_root_mod(out_root: &Path, all_dirs: &[String], domains: &[String], targ
     out.push_str("// it via `attaches`.\n");
     for name in all_dirs {
         if domains.iter().any(|d| d == name) {
-            out.push_str(&format!("#[cfg(feature = {name:?})]\n"));
+            let _ = writeln!(out, "#[cfg(feature = {name:?})]");
         }
-        out.push_str(&format!("pub mod {name};\n"));
+        let _ = writeln!(out, "pub mod {name};");
     }
     out.push('\n');
     out.push_str("// `active` is whichever ONE domain's own merged Store/dispatch table\n");
@@ -65,7 +80,10 @@ fn write_root_mod(out_root: &Path, all_dirs: &[String], domains: &[String], targ
     out.push_str("// no matter which domain that resolves to.\n");
     out.push_str("//\n");
     out.push_str("// DOMAIN FEATURES ARE MUTUALLY EXCLUSIVE (R5) — Cargo has no native\n");
-    out.push_str(&format!("// concept of that, and `default = [{target_mod_name:?}]` in\n"));
+    let _ = writeln!(
+        out,
+        "// concept of that, and `default = [{target_mod_name:?}]` in"
+    );
     out.push_str("// Cargo.toml stays enabled unless a build passes\n");
     out.push_str("// `--no-default-features`, so a plain `cargo build --features banking`\n");
     out.push_str("// used to enable BOTH the default domain's feature and banking's,\n");
@@ -84,17 +102,27 @@ fn write_root_mod(out_root: &Path, all_dirs: &[String], domains: &[String], targ
     out.push_str("//      `compile_error!` naming both features instead of a cryptic\n");
     out.push_str("//      \"defined multiple times\".\n");
     for name in domains {
-        let other_domains: Vec<&String> = domains.iter().filter(|n| n.as_str() != name.as_str()).collect();
+        let other_domains: Vec<&String> = domains
+            .iter()
+            .filter(|n| n.as_str() != name.as_str())
+            .collect();
         if name.as_str() == target_mod_name && !other_domains.is_empty() {
-            let guard = other_domains.iter().map(|o| format!("feature = {o:?}")).collect::<Vec<_>>().join(", ");
-            out.push_str(&format!("#[cfg(all(feature = {name:?}, not(any({guard}))))]\n"));
+            let guard = other_domains
+                .iter()
+                .map(|o| format!("feature = {o:?}"))
+                .collect::<Vec<_>>()
+                .join(", ");
+            let _ = writeln!(out, "#[cfg(all(feature = {name:?}, not(any({guard}))))]");
         } else {
-            out.push_str(&format!("#[cfg(feature = {name:?})]\n"));
+            let _ = writeln!(out, "#[cfg(feature = {name:?})]");
         }
-        out.push_str(&format!("pub use {name}::merged as active;\n"));
+        let _ = writeln!(out, "pub use {name}::merged as active;");
     }
 
-    let non_default_domains: Vec<&String> = domains.iter().filter(|n| n.as_str() != target_mod_name).collect();
+    let non_default_domains: Vec<&String> = domains
+        .iter()
+        .filter(|n| n.as_str() != target_mod_name)
+        .collect();
     if non_default_domains.len() > 1 {
         out.push('\n');
         out.push_str("// Explicit conflict guard — see point 2 above. Only fires when TWO\n");
@@ -106,10 +134,10 @@ fn write_root_mod(out_root: &Path, all_dirs: &[String], domains: &[String], targ
             for j in (i + 1)..non_default_domains.len() {
                 let a = non_default_domains[i];
                 let b = non_default_domains[j];
-                out.push_str(&format!("#[cfg(all(feature = {a:?}, feature = {b:?}))]\n"));
-                out.push_str(&format!(
-                    "compile_error!(\"domain features are mutually exclusive — enable only one of: {domains_joined} (both {a} and {b} are enabled)\");\n"
-                ));
+                let _ = writeln!(out, "#[cfg(all(feature = {a:?}, feature = {b:?}))]");
+                let _ = writeln!(out,
+                    "compile_error!(\"domain features are mutually exclusive — enable only one of: {domains_joined} (both {a} and {b} are enabled)\");"
+                );
             }
         }
     }
@@ -123,7 +151,9 @@ fn write_root_mod(out_root: &Path, all_dirs: &[String], domains: &[String], targ
 /// The `[features]` table text, from its header to the next `[section]` header or EOF.
 /// Empty if there is no `[features]` header.
 fn features_table_slice(text: &str) -> &str {
-    let Some(start) = text.find("[features]") else { return "" };
+    let Some(start) = text.find("[features]") else {
+        return "";
+    };
     let rest = &text[start..];
     let mut pos = 0;
     for (i, line) in rest.split_inclusive('\n').enumerate() {
@@ -135,8 +165,13 @@ fn features_table_slice(text: &str) -> &str {
     rest
 }
 
-fn sync_cargo_toml_features(cargo_toml_path: &Path, domains: &[String], target_mod_name: &str) -> Result<(), String> {
-    let mut cargo_toml = std::fs::read_to_string(cargo_toml_path).map_err(|e| format!("reading {}: {e}", cargo_toml_path.display()))?;
+fn sync_cargo_toml_features(
+    cargo_toml_path: &Path,
+    domains: &[String],
+    target_mod_name: &str,
+) -> Result<(), String> {
+    let mut cargo_toml = std::fs::read_to_string(cargo_toml_path)
+        .map_err(|e| format!("reading {}: {e}", cargo_toml_path.display()))?;
 
     if !cargo_toml.contains("[features]") {
         let preamble = "# ONE FEATURE PER GENERATED DOMAIN — selects which domain's own\n\
@@ -157,7 +192,9 @@ fn sync_cargo_toml_features(cargo_toml_path: &Path, domains: &[String], target_m
     // Scoped to `[features]`: matching `name = ` file-wide hits `[package]` keys like `version`.
     for name in domains {
         let already_declared = features_table_slice(&cargo_toml).lines().any(|line| {
-            line.trim_start().strip_prefix(name.as_str()).map(|rest| rest.trim_start().starts_with('=')).unwrap_or(false)
+            line.trim_start()
+                .strip_prefix(name.as_str())
+                .is_some_and(|rest| rest.trim_start().starts_with('='))
         });
         if already_declared {
             continue;
@@ -165,10 +202,14 @@ fn sync_cargo_toml_features(cargo_toml_path: &Path, domains: &[String], target_m
         cargo_toml = insert_after_default(&cargo_toml, &format!("{name} = []"));
     }
 
-    cargo_toml = replace_default_line(&cargo_toml, &format!("default = [{:?}]", target_mod_name));
+    cargo_toml = replace_default_line(&cargo_toml, &format!("default = [{target_mod_name:?}]"));
 
-    std::fs::write(cargo_toml_path, &cargo_toml).map_err(|e| format!("writing {}: {e}", cargo_toml_path.display()))?;
-    println!("wrote {} (default feature: {target_mod_name})", cargo_toml_path.display());
+    std::fs::write(cargo_toml_path, &cargo_toml)
+        .map_err(|e| format!("writing {}: {e}", cargo_toml_path.display()))?;
+    println!(
+        "wrote {} (default feature: {target_mod_name})",
+        cargo_toml_path.display()
+    );
     Ok(())
 }
 
@@ -209,7 +250,9 @@ fn replace_default_line(text: &str, new_line: &str) -> String {
 
 fn is_default_line(line_content: &str) -> bool {
     let trimmed = line_content.trim_start();
-    trimmed.strip_prefix("default").map(|rest| rest.trim_start().starts_with('=')).unwrap_or(false)
+    trimmed
+        .strip_prefix("default")
+        .is_some_and(|rest| rest.trim_start().starts_with('='))
 }
 
 /// Rewrites only the root `mod.rs`, for a generation into a directory other than `rust/src/generated`.