hecks 3.14.0 → 4.0.0

data/rust/build/src/lineage_pass.rs

@@ -11,18 +11,29 @@ use crate::json::Json;
 ///
 /// An aggregate with no `persisted_by` bind falls back to `world_path`'s own
 /// `default_adapter` for the target chapter, then to `"Memory"`.
-pub fn run(ir: &mut Json, hecksagon_path: Option<&Path>, world_path: Option<&Path>, root: &Path) -> Result<(), String> {
+pub fn run(
+    ir: &mut Json,
+    hecksagon_path: Option<&Path>,
+    world_path: Option<&Path>,
+    root: &Path,
+) -> Result<(), String> {
     let binds = match hecksagon_path {
         Some(path) => {
-            let text = std::fs::read_to_string(path).map_err(|e| format!("reading {}: {e}", path.display()))?;
+            let text = std::fs::read_to_string(path)
+                .map_err(|e| format!("reading {}: {e}", path.display()))?;
             persistence_binds(&text)
         }
         None => HashMap::new(),
     };
-    let chapter_name = ir.get("name").and_then(Json::as_str).unwrap_or_default().to_string();
+    let chapter_name = ir
+        .get("name")
+        .and_then(Json::as_str)
+        .unwrap_or_default()
+        .to_string();
     let fallback_adapter = match world_path {
         Some(path) => {
-            let text = std::fs::read_to_string(path).map_err(|e| format!("reading {}: {e}", path.display()))?;
+            let text = std::fs::read_to_string(path)
+                .map_err(|e| format!("reading {}: {e}", path.display()))?;
             default_adapter_name(&text, &chapter_name)
         }
         None => None,
@@ -30,29 +41,35 @@ pub fn run(ir: &mut Json, hecksagon_path: Option<&Path>, world_path: Option<&Pat
     .unwrap_or_else(|| "Memory".to_string());
     let capable_adapters = lineage_capable_adapter_names(root)?;
 
-    // Collected up front: Rust can't hold this borrow of `ir` alongside the
-    // `&mut` call to `ir.set` below.
-    let aggregate_names: Vec<String> = ir
+    // Collected before `ir.set` below: Rust can't hold this borrow of `ir`
+    // alongside the `&mut` call.
+    let capable_aggregates: Vec<Json> = ir
         .get("aggregates")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or(&[][..], Json::each)
         .iter()
         .filter_map(|a| a.get("name").and_then(Json::as_str).map(str::to_string))
-        .collect();
-
-    let capable_aggregates: Vec<Json> = aggregate_names
-        .into_iter()
         .filter(|name| {
-            let adapter_name = binds.get(name.as_str()).map(String::as_str).unwrap_or(fallback_adapter.as_str());
+            let adapter_name = binds
+                .get(name.as_str())
+                .map_or(fallback_adapter.as_str(), String::as_str);
             capable_adapters.iter().any(|a| a == adapter_name)
         })
         .map(|name| {
-            let storage_name = snake_case(&name);
-            Json::Object(vec![("name".to_string(), Json::String(name)), ("storage_name".to_string(), Json::String(storage_name))])
+            let storage_name = crate::hecks_naming::snake(&name);
+            Json::Object(vec![
+                ("name".to_string(), Json::String(name)),
+                ("storage_name".to_string(), Json::String(storage_name)),
+            ])
         })
         .collect();
 
-    ir.set("lineage", Json::Object(vec![("capable_aggregates".to_string(), Json::Array(capable_aggregates))]));
+    ir.set(
+        "lineage",
+        Json::Object(vec![(
+            "capable_aggregates".to_string(),
+            Json::Array(capable_aggregates),
+        )]),
+    );
     Ok(())
 }
 
@@ -65,18 +82,31 @@ pub(crate) fn persistence_binds(text: &str) -> HashMap<String, String> {
             continue;
         }
 
-        let Some(call_pos) = line.find(".persisted_by(") else { continue };
+        let Some(call_pos) = line.find(".persisted_by(") else {
+            continue;
+        };
 
         let before = &line[..call_pos];
-        let aggregate_name: String = before.chars().rev().take_while(|c| c.is_alphanumeric() || *c == '_').collect::<String>().chars().rev().collect();
+        let aggregate_name: String = before
+            .chars()
+            .rev()
+            .take_while(|c| c.is_alphanumeric() || *c == '_')
+            .collect::<String>()
+            .chars()
+            .rev()
+            .collect();
         if aggregate_name.is_empty() {
             continue;
         }
 
         let after = &line[call_pos + ".persisted_by(".len()..];
-        let Some(open_quote) = after.find('"') else { continue };
+        let Some(open_quote) = after.find('"') else {
+            continue;
+        };
         let rest = &after[open_quote + 1..];
-        let Some(close_quote) = rest.find('"') else { continue };
+        let Some(close_quote) = rest.find('"') else {
+            continue;
+        };
         let adapter_name = &rest[..close_quote];
 
         binds.insert(aggregate_name, adapter_name.to_string());
@@ -100,13 +130,19 @@ pub(crate) fn default_adapter_name(text: &str, chapter: &str) -> Option<String>
             continue;
         }
 
-        let Some(rest) = line.trim_start().strip_prefix("default_adapter") else { continue };
+        let Some(rest) = line.trim_start().strip_prefix("default_adapter") else {
+            continue;
+        };
         if !rest.starts_with(char::is_whitespace) {
             continue;
         }
-        let Some(open_quote) = rest.find('"') else { continue };
+        let Some(open_quote) = rest.find('"') else {
+            continue;
+        };
         let quoted = &rest[open_quote + 1..];
-        let Some(close_quote) = quoted.find('"') else { continue };
+        let Some(close_quote) = quoted.find('"') else {
+            continue;
+        };
         found = Some(quoted[..close_quote].to_string());
     }
 
@@ -121,14 +157,18 @@ fn world_opener_name(line: &str) -> Option<String> {
 
 // Where an adapter class can live: the driven adapters, and the era plugin that holds `PostgresEra`,
 // the one adapter that declares itself lineage-capable.
-const ADAPTER_DIRS: [&str; 2] = ["lib/hecks/adapters/driven", "lib/hecks/ports/persistence/plugins/era"];
+const ADAPTER_DIRS: [&str; 2] = [
+    "lib/hecks/adapters/driven",
+    "lib/hecks/ports/persistence/plugins/era",
+];
 
 // Reads each adapter's own source file rather than invoking Ruby.
 fn lineage_capable_adapter_names(root: &Path) -> Result<Vec<String>, String> {
     let mut names = Vec::new();
     for relative in ADAPTER_DIRS {
         let dir = root.join(relative);
-        let entries = std::fs::read_dir(&dir).map_err(|e| format!("reading {}: {e}", dir.display()))?;
+        let entries =
+            std::fs::read_dir(&dir).map_err(|e| format!("reading {}: {e}", dir.display()))?;
 
         for entry in entries {
             let entry = entry.map_err(|e| format!("reading {}: {e}", dir.display()))?;
@@ -137,7 +177,8 @@ fn lineage_capable_adapter_names(root: &Path) -> Result<Vec<String>, String> {
                 continue;
             }
 
-            let text = std::fs::read_to_string(&path).map_err(|e| format!("reading {}: {e}", path.display()))?;
+            let text = std::fs::read_to_string(&path)
+                .map_err(|e| format!("reading {}: {e}", path.display()))?;
             if !declares_lineage_capable_true(&text) {
                 continue;
             }
@@ -171,7 +212,10 @@ fn top_level_class_name(text: &str) -> Option<String> {
     for line in text.lines() {
         let trimmed = line.trim_start();
         if let Some(rest) = trimmed.strip_prefix("class ") {
-            let name: String = rest.chars().take_while(|c| c.is_alphanumeric() || *c == '_').collect();
+            let name: String = rest
+                .chars()
+                .take_while(|c| c.is_alphanumeric() || *c == '_')
+                .collect();
             if !name.is_empty() {
                 return Some(name);
             }
@@ -180,58 +224,6 @@ fn top_level_class_name(text: &str) -> Option<String> {
     None
 }
 
-// Hand-ported `Naming.snake` (Ruby): split acronym boundaries, then camelCase
-// boundaries, then downcase — no regex dependency.
-pub(crate) fn snake_case(name: &str) -> String {
-    let after_pass1 = split_acronym_boundaries(name);
-    let after_pass2 = split_camel_boundaries(&after_pass1);
-    after_pass2.to_ascii_lowercase()
-}
-
-fn split_acronym_boundaries(text: &str) -> String {
-    let chars: Vec<char> = text.chars().collect();
-    let mut out = String::with_capacity(text.len() + 4);
-    let mut i = 0;
-    while i < chars.len() {
-        // A maximal uppercase run starting at i.
-        if chars[i].is_ascii_uppercase() {
-            let mut run_end = i;
-            while run_end < chars.len() && chars[run_end].is_ascii_uppercase() {
-                run_end += 1;
-            }
-            let run_len = run_end - i;
-            let followed_by_lowercase = run_end < chars.len() && chars[run_end].is_ascii_lowercase();
-            if run_len >= 2 && followed_by_lowercase {
-                // Emit the run minus its last char, an underscore, then
-                // continue scanning from the run's own last char (which
-                // pass 2 or a plain copy picks up next iteration).
-                out.extend(&chars[i..run_end - 1]);
-                out.push('_');
-                i = run_end - 1;
-                continue;
-            }
-        }
-        out.push(chars[i]);
-        i += 1;
-    }
-    out
-}
-
-fn split_camel_boundaries(text: &str) -> String {
-    let chars: Vec<char> = text.chars().collect();
-    let mut out = String::with_capacity(text.len() + 4);
-    for (idx, &c) in chars.iter().enumerate() {
-        if idx > 0 {
-            let prev = chars[idx - 1];
-            if (prev.is_ascii_lowercase() || prev.is_ascii_digit()) && c.is_ascii_uppercase() {
-                out.push('_');
-            }
-        }
-        out.push(c);
-    }
-    out
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -257,7 +249,11 @@ mod tests {
             ("Statement", "statement"),
         ];
         for (input, expected) in cases {
-            assert_eq!(snake_case(input), expected, "snake_case({input:?})");
+            assert_eq!(
+                crate::hecks_naming::snake(input),
+                expected,
+                "snake({input:?})"
+            );
         }
     }
 
@@ -272,15 +268,25 @@ mod tests {
     #[test]
     fn reads_the_default_adapter_of_the_target_chapters_own_world_only() {
         let text = "Hecks.world \"Alpha\" do\n  # default_adapter \"Heki\"\n  default_adapter \"PostgresEra\"\nend\n\nHecks.world(\"Beta\") do\n  default_adapter \"Memory\"\nend\n";
-        assert_eq!(default_adapter_name(text, "Alpha"), Some("PostgresEra".to_string()));
-        assert_eq!(default_adapter_name(text, "Beta"), Some("Memory".to_string()));
+        assert_eq!(
+            default_adapter_name(text, "Alpha"),
+            Some("PostgresEra".to_string())
+        );
+        assert_eq!(
+            default_adapter_name(text, "Beta"),
+            Some("Memory".to_string())
+        );
         assert_eq!(default_adapter_name(text, "Gamma"), None);
     }
 
     #[test]
     fn declares_lineage_capable_true_matches_the_endless_method_form() {
-        assert!(declares_lineage_capable_true("      def self.lineage_capable? = true\n"));
-        assert!(!declares_lineage_capable_true("      def self.lineage_capable? = false\n"));
+        assert!(declares_lineage_capable_true(
+            "      def self.lineage_capable? = true\n"
+        ));
+        assert!(!declares_lineage_capable_true(
+            "      def self.lineage_capable? = false\n"
+        ));
         assert!(!declares_lineage_capable_true("no such method here\n"));
     }
 
@@ -290,11 +296,19 @@ mod tests {
     fn finds_postgres_era_in_the_real_source_tree() {
         let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
         let names = lineage_capable_adapter_names(&root).expect("scans the adapter directories");
-        assert!(names.iter().any(|name| name == "PostgresEra"), "lineage-capable adapters found: {names:?}");
+        assert!(
+            names.iter().any(|name| name == "PostgresEra"),
+            "lineage-capable adapters found: {names:?}"
+        );
     }
 
     #[test]
     fn finds_the_top_level_class_name() {
-        assert_eq!(top_level_class_name("module Hecks\n  module Adapters\n    class Postgres\n      def x; end\n"), Some("Postgres".to_string()));
+        assert_eq!(
+            top_level_class_name(
+                "module Hecks\n  module Adapters\n    class Postgres\n      def x; end\n"
+            ),
+            Some("Postgres".to_string())
+        );
     }
 }

data/rust/build/src/main.rs

@@ -2,23 +2,30 @@
 //! `<domain>` is a domain directory such as `examples/pizzas`; `--wasm` also cross-compiles to
 //! `wasm32-wasip1`, and `--no-build` generates source only.
 
+mod adapters_pass;
 mod build_artifact;
 mod cargo_sync;
 // The one JSON implementation, compiled from `hecks-codegen`'s own source: neither crate depends on
 // the other, and a packaged workspace ships both side by side. This crate reads only part of it.
+mod binding_pass;
 #[allow(dead_code)]
 #[path = "../../codegen/src/json.rs"]
 mod json;
-mod binding_pass;
+// The one `Hecks::Naming` port, compiled from `hecks-codegen`'s source for the same reason.
+#[allow(dead_code)]
+#[path = "../../codegen/src/hecks_naming.rs"]
+mod hecks_naming;
 mod lineage_pass;
 mod pipeline;
 mod reserved_names;
 mod resolve;
 mod root;
+mod rustfmt;
 mod seams_pass;
 mod subprocess;
 mod tmp;
 mod translation_pass;
+mod world_pass;
 
 use std::process::ExitCode;
 
@@ -50,7 +57,9 @@ fn run(args: &[String]) -> Result<(), String> {
         }
     }
 
-    let domain = domain.ok_or_else(|| "usage: hecks-build <domain> [--wasm] [--no-build] [--out <dir>]".to_string())?;
+    let domain = domain.ok_or_else(|| {
+        "usage: hecks-build <domain> [--wasm] [--no-build] [--out <dir>]".to_string()
+    })?;
     let root = root::find()?;
 
     // `--out` generates the module tree into that directory only: no `Cargo.toml` rewrite, no

data/rust/build/src/pipeline.rs

@@ -3,15 +3,18 @@
 
 use std::path::{Path, PathBuf};
 
+use crate::adapters_pass;
 use crate::binding_pass;
 use crate::build_artifact;
 use crate::cargo_sync;
 use crate::json::Json;
 use crate::lineage_pass;
 use crate::resolve;
+use crate::rustfmt;
 use crate::seams_pass;
 use crate::subprocess;
 use crate::tmp::TempDir;
+use crate::world_pass;
 
 pub struct Options {
     pub build_native: bool,
@@ -53,7 +56,9 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
 
     let bluebook_directory = domain_path.join("bluebook");
     let bluebook_paths = resolve::bluebook_files(&bluebook_directory)?;
-    let first_bluebook = bluebook_paths.first().ok_or_else(|| format!("{} has no .bluebook files", domain_path.display()))?;
+    let first_bluebook = bluebook_paths
+        .first()
+        .ok_or_else(|| format!("{} has no .bluebook files", domain_path.display()))?;
     let hecksagon_candidate = bluebook_directory.join(format!("{target_mod_name}.hecksagon"));
     let hecksagon_path = hecksagon_candidate.is_file().then_some(hecksagon_candidate);
     let world_candidate = bluebook_directory.join(format!("{target_mod_name}.world"));
@@ -92,9 +97,26 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     // Only the target chapter gets a `lineage` key — a framework chapter or
     // `meta` never does, matching `derive_lineage` (Ruby) re-`JSON.parse`ing
     // rather than chaining a live object through both passes.
-    let mut target_ir = Json::parse(&target_ir_text).map_err(|e| format!("re-parsing target ir.json for lineage: {e}"))?;
-    lineage_pass::run(&mut target_ir, hecksagon_path.as_deref(), world_path.as_deref(), root)?;
-    binding_pass::run(&mut target_ir, hecksagon_path.as_deref(), world_path.as_deref())?;
+    let mut target_ir = Json::parse(&target_ir_text)
+        .map_err(|e| format!("re-parsing target ir.json for lineage: {e}"))?;
+    lineage_pass::run(
+        &mut target_ir,
+        hecksagon_path.as_deref(),
+        world_path.as_deref(),
+        root,
+    )?;
+    binding_pass::run(
+        &mut target_ir,
+        hecksagon_path.as_deref(),
+        world_path.as_deref(),
+        |ir| {
+            // The same two places `TargetIr#adapters` scans: the source root's `lib/` and the
+            // domain's own directory.
+            let directories = [root.join("lib"), domain_path.clone()];
+            adapters_pass::declarations(&parser_bin, &directories, ir)
+        },
+    )?;
+    world_pass::run(&mut target_ir, &parser_bin, world_path.as_deref())?;
 
     // Every other chapter the gem supplies by `attaches "Name"`, resolved through the
     // same directory listing (`resolve::framework_members`) the Ruby
@@ -104,7 +126,9 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     let other_gem_chapters = resolve::other_gem_chapter_names(root)?;
     let mut chapters: Vec<Chapter> = Vec::new();
     for fw_name in &gem_chapter_names {
-        if other_gem_chapters.contains(fw_name) && !framework_members.iter().any(|(name, _)| name == fw_name) {
+        if other_gem_chapters.contains(fw_name)
+            && !framework_members.iter().any(|(name, _)| name == fw_name)
+        {
             continue;
         }
         let fw_path = framework_members
@@ -114,7 +138,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
             .ok_or_else(|| {
                 let mut known: Vec<&str> = framework_members.iter().map(|(n, _)| n.as_str()).collect();
                 known.extend(other_gem_chapters.iter().map(String::as_str));
-                known.sort();
+                known.sort_unstable();
                 format!("hecks-build: attaches {fw_name:?} names no chapter the gem carries — known: {}", known.join(", "))
             })?;
         let fw_chapter_name = resolve::header_chapter_name(&fw_path)?;
@@ -124,7 +148,11 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
                 fw_path.display()
             ));
         }
-        let fw_ir_text = parse_chapter(&parser_bin, &fw_chapter_name, std::slice::from_ref(&fw_path))?;
+        let fw_ir_text = parse_chapter(
+            &parser_bin,
+            &fw_chapter_name,
+            std::slice::from_ref(&fw_path),
+        )?;
         chapters.push(Chapter {
             mod_name: fw_name.to_lowercase(),
             source_label: format!("{domain} (attaches {fw_name:?})"),
@@ -138,7 +166,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     for pkg_name in &vendored_package_names {
         let pkg_files = resolve::vendored_bluebook_files(&domain_path, pkg_name)?;
         let pkg_chapter_name = resolve::header_chapter_name(&pkg_files[0])?;
-        let expected_chapter_name = resolve::pascal(pkg_name);
+        let expected_chapter_name = crate::hecks_naming::pascal(pkg_name);
         if pkg_chapter_name != expected_chapter_name {
             return Err(format!(
                 "hecks-build: {} declares chapter {pkg_chapter_name:?}, but attaches {pkg_name:?}, from: :vendor \
@@ -200,7 +228,10 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     // once every chapter is loaded; `translations` and `source_text` close the binding facts.
     let mut member_irs = Vec::new();
     for c in &chapters {
-        member_irs.push(Json::parse(&c.ir_text).map_err(|e| format!("re-parsing {} ir.json for its seams: {e}", c.mod_name))?);
+        member_irs.push(
+            Json::parse(&c.ir_text)
+                .map_err(|e| format!("re-parsing {} ir.json for its seams: {e}", c.mod_name))?,
+        );
     }
     seams_pass::run(&mut target_ir, &member_irs)?;
     binding_pass::finish(&mut target_ir, &source_files, &bluebook_directory)?;
@@ -211,8 +242,12 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     let grammar_files = resolve::grammar_files(root)?;
     let meta_ir_text = parse_chapter(&parser_bin, "Bluebook", &grammar_files)?;
 
-    let out_root = opts.out_dir.clone().unwrap_or_else(|| root.join("rust/src/generated"));
-    std::fs::create_dir_all(&out_root).map_err(|e| format!("creating {}: {e}", out_root.display()))?;
+    let out_root = opts
+        .out_dir
+        .clone()
+        .unwrap_or_else(|| root.join("rust/src/generated"));
+    std::fs::create_dir_all(&out_root)
+        .map_err(|e| format!("creating {}: {e}", out_root.display()))?;
 
     // Scoped clearing — identical reasoning to both Ruby pipelines'
     // own: multiple domains coexist on disk, so only this run's own
@@ -227,11 +262,21 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     let tmp = TempDir::new("hecks-build-codegen")?;
 
     let meta_ir_path = tmp.path().join("meta_ir.json");
-    std::fs::write(&meta_ir_path, &meta_ir_text).map_err(|e| format!("writing {}: {e}", meta_ir_path.display()))?;
-    run_codegen_full(&codegen_bin, &[out_root.to_string_lossy().to_string(), "meta".to_string(), META_SOURCE_LABEL.to_string(), meta_ir_path.to_string_lossy().to_string()])?;
+    std::fs::write(&meta_ir_path, &meta_ir_text)
+        .map_err(|e| format!("writing {}: {e}", meta_ir_path.display()))?;
+    run_codegen_full(
+        &codegen_bin,
+        &[
+            out_root.to_string_lossy().to_string(),
+            "meta".to_string(),
+            META_SOURCE_LABEL.to_string(),
+            meta_ir_path.to_string_lossy().to_string(),
+        ],
+    )?;
 
     let target_ir_path = tmp.path().join("target_ir.json");
-    std::fs::write(&target_ir_path, &target_ir_text).map_err(|e| format!("writing {}: {e}", target_ir_path.display()))?;
+    std::fs::write(&target_ir_path, &target_ir_text)
+        .map_err(|e| format!("writing {}: {e}", target_ir_path.display()))?;
 
     let mut codegen_args = vec![
         out_root.to_string_lossy().to_string(),
@@ -239,14 +284,13 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
         domain.to_string(),
         target_ir_path.to_string_lossy().to_string(),
     ];
-    let mut chapter_ir_paths = Vec::new();
     for (idx, c) in chapters.iter().enumerate() {
         let ir_path = tmp.path().join(format!("chapter_{idx}_ir.json"));
-        std::fs::write(&ir_path, &c.ir_text).map_err(|e| format!("writing {}: {e}", ir_path.display()))?;
+        std::fs::write(&ir_path, &c.ir_text)
+            .map_err(|e| format!("writing {}: {e}", ir_path.display()))?;
         codegen_args.push(c.mod_name.clone());
         codegen_args.push(c.source_label.clone());
         codegen_args.push(ir_path.to_string_lossy().to_string());
-        chapter_ir_paths.push(ir_path);
     }
     run_codegen_full(&codegen_bin, &codegen_args)?;
 
@@ -257,6 +301,15 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
         cargo_sync::run(&out_root, &cargo_toml_path, &target_mod_name)?;
     }
 
+    // `hecks project_rust` lays its Rust out with rustfmt; the tree must match it byte for byte.
+    let mut generated_dirs = vec![
+        "meta".to_string(),
+        "active".to_string(),
+        target_mod_name.clone(),
+    ];
+    generated_dirs.extend(chapters.iter().map(|c| c.mod_name.clone()));
+    rustfmt::format_generated(&out_root, &generated_dirs)?;
+
     let rust_dir = root.join("rust");
     if opts.build_native {
         build_artifact::build_native(&rust_dir)?;
@@ -270,9 +323,17 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
 
 // Parses via `hecks-parse chapter`. `hecks-codegen` marks the IR and writes its `ir.json` and
 // `metadata.rs` itself, so the text goes through as `hecks-parse` printed it.
-fn parse_chapter(parser_bin: &Path, chapter_name: &str, files: &[PathBuf]) -> Result<String, String> {
+fn parse_chapter(
+    parser_bin: &Path,
+    chapter_name: &str,
+    files: &[PathBuf],
+) -> Result<String, String> {
     let parser_bin_str = parser_bin.to_string_lossy().to_string();
-    let mut args: Vec<String> = vec!["chapter".to_string(), "--chapter".to_string(), chapter_name.to_string()];
+    let mut args: Vec<String> = vec![
+        "chapter".to_string(),
+        "--chapter".to_string(),
+        chapter_name.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();
 

data/rust/build/src/reserved_names.rs

@@ -2,57 +2,13 @@
 // CargoReservedName vocabularies (lib/hecks/language/bluebook/
 // vocabulary.bluebook). Do not hand-edit — re-run hecks project_reserved_names.
 
-/// The `RustReservedWord` vocabulary, 49 entries.
+/// The `RustReservedWord` vocabulary, 51 entries.
 pub const RUST_KEYWORDS: &[&str] = &[
-    "as",
-    "break",
-    "const",
-    "continue",
-    "crate",
-    "dyn",
-    "else",
-    "enum",
-    "extern",
-    "false",
-    "fn",
-    "for",
-    "if",
-    "impl",
-    "in",
-    "let",
-    "loop",
-    "match",
-    "mod",
-    "move",
-    "mut",
-    "pub",
-    "ref",
-    "return",
-    "self",
-    "Self",
-    "static",
-    "struct",
-    "super",
-    "trait",
-    "true",
-    "type",
-    "unsafe",
-    "use",
-    "where",
-    "while",
-    "abstract",
-    "become",
-    "box",
-    "do",
-    "final",
-    "macro",
-    "override",
-    "priv",
-    "typeof",
-    "unsized",
-    "virtual",
-    "yield",
-    "try",
+    "as", "async", "await", "break", "const", "continue", "crate", "dyn", "else", "enum", "extern",
+    "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub",
+    "ref", "return", "self", "Self", "static", "struct", "super", "trait", "true", "type",
+    "unsafe", "use", "where", "while", "abstract", "become", "box", "do", "final", "macro",
+    "override", "priv", "typeof", "unsized", "virtual", "yield", "try",
 ];
 
 /// The `CargoReservedName` vocabulary, 16 entries.