hecks 6.0.0 → 7.0.0

data/lib/hecks/rust_build/project_rust/codegen_run.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require "json"
+require "open3"
 require "tmpdir"
 require_relative "../write_if_changed"
 
@@ -41,11 +42,10 @@ module Hecks
 
         # @param rust_dir [String] the workspace being generated into
         # @param out_root [String] the crate's `src/generated`
-        # @param target [Bluebook] the domain being projected
-        # @param bluebooks [Array<Bluebook>] every other bluebook the target attached
-        # @param meta [Hash, nil] the self-hosted language's IR; nil leaves the `meta/` module as an
-        #   earlier run wrote it
-        def initialize(rust_dir:, out_root:, target:, declarations:, meta:)
+        # @param target [Declaration, nil] the domain being projected; nil for a run of `meta` alone
+        # @param declarations [Array<Declaration>] every other bluebook the target attached
+        # @param meta [Hash, nil] the self-hosted language's IR; nil leaves `meta` as it is on disk
+        def initialize(rust_dir:, out_root:, meta: nil, target: nil, declarations: [])
           @rust_dir = rust_dir
           @out_root = out_root
           @target = target
@@ -61,18 +61,49 @@ module Hecks
             stage = File.join(tmp, "generated")
             FileUtils.mkdir_p(stage)
             generate_meta(stage, tmp) if @meta
-            generate_target(stage, tmp)
+            generate_target(stage, tmp) if @target
             sync(stage)
           end
         end
 
+        # Builds the binary once, then holds the build as done while the block runs. Each `cargo
+        # build` replaces the binary with a fresh link, so children forked to generate side by side
+        # would each leave a moment when a sibling finds no binary to start; the parent builds
+        # instead, before the fork, and the children skip it.
+        #
+        # @param rust_dir [String] the workspace being generated into
+        # @yield the work that forks the children
+        # @return [Object] the block's value
+        # @raise [Failure] when `hecks-codegen` cannot be built
+        def self.prebuilt(rust_dir)
+          dir = crate_dir(rust_dir)
+          build(dir)
+          @prebuilt = dir
+          yield
+        ensure
+          @prebuilt = nil
+        end
+
+        # @param dir [String] the `hecks-codegen` crate's directory
+        # @return [Boolean] whether a parent process built it for the children it forked
+        def self.prebuilt?(dir) = @prebuilt == dir
+
+        # @param dir [String] the `hecks-codegen` crate's directory
+        # @return [void]
+        # @raise [Failure] when Cargo cannot build it
+        def self.build(dir)
+          output, status = Open3.capture2e("cargo", "build", "--quiet", chdir: dir)
+          $stdout.write(output)
+          return if status.success?
+
+          raise Failure, "hecks project_rust: cargo build failed in #{dir} — run it there directly to see why"
+        end
+
         private
 
         def build_binary
           dir = self.class.crate_dir(@rust_dir)
-          return if system("cargo", "build", "--quiet", chdir: dir, out: $stdout, err: $stderr)
-
-          raise Failure, "hecks project_rust: cargo build failed in #{dir} — run it there directly to see why"
+          self.class.build(dir) unless self.class.prebuilt?(dir)
         end
 
         def generate_meta(stage, tmp)
@@ -114,9 +145,11 @@ module Hecks
         end
 
         def copy_changed(source, dest)
-          Dir.children(source).sort.each do |file|
-            path = File.join(dest, file)
-            wrote = WriteIfChanged.call(path, File.read(File.join(source, file), encoding: "UTF-8"))
+          texts = Dir.children(source).sort.to_h do |file|
+            [File.join(dest, file), File.read(File.join(source, file), encoding: "UTF-8")]
+          end
+          RustFormat.files(texts).each do |path, text|
+            wrote = WriteIfChanged.call(path, text, formatted: true, atomic: true)
             puts(wrote ? "wrote #{path}" : "#{path} unchanged")
           end
         end

data/lib/hecks/rust_build/project_rust/declared.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Hecks
+  module RustBuild
+    class ProjectRust
+      # The corpus's declared domains, which a corpus run hands every `hecks project_rust` it
+      # makes. Given them, a run writes `mod.rs` and Cargo's features for exactly these domains and
+      # leaves Cargo's `default` on `default`, so what a domain generates does not depend on which
+      # domains ran before it. Without them (a workspace of one's own) a run follows the domains on
+      # disk and points `default` at the domain it generated.
+      #
+      # A run that regenerates only some of the declared domains says so with `--partial`. It writes
+      # those domains and leaves `mod.rs` and Cargo's features to a run of the whole corpus: the
+      # bluebooks `mod.rs` lists are the ones on disk, so a few domains' run would drop the rest.
+      #
+      #   hecks project_rust examples/pizzas --declared=banking,pizzas --default=pizzas --partial
+      class Declared
+        # The flag naming the declared domains, comma-separated.
+        DOMAINS_FLAG = "--declared="
+        # The flag naming the declared feature Cargo's `default` stays on.
+        DEFAULT_FLAG = "--default="
+        # The flag saying this run is one of some, not of the whole corpus.
+        PARTIAL_FLAG = "--partial"
+
+        # @return [Array<String>] the declared domains' feature names
+        attr_reader :domains
+        # @return [String] the one of them Cargo's `default` stays on
+        attr_reader :default
+
+        # Takes the declared flags out of a command line.
+        #
+        # @param argv [Array<String>] the arguments of `hecks project_rust`
+        # @return [Array(Declared, Array<String>), Array(nil, Array<String>)] what the flags
+        #   declared (nil when there are none) and the arguments left
+        # @raise [Failure] when one flag is given without the other, or `default` is not declared
+        def self.split(argv)
+          flags, rest = argv.partition { |arg| arg.start_with?(DOMAINS_FLAG, DEFAULT_FLAG) || arg == PARTIAL_FLAG }
+          return [nil, rest] if flags.empty?
+
+          [read(flags), rest]
+        end
+
+        # @param flags [Array<String>] the declared flags of a command line
+        # @return [Declared] what they declare
+        # @raise [Failure] when one flag is given without the other, or `default` is not declared
+        def self.read(flags)
+          domains = value(flags, DOMAINS_FLAG)&.split(",")
+          default = value(flags, DEFAULT_FLAG)
+          unless domains && default && domains.include?(default)
+            raise Failure, "hecks project_rust: #{DOMAINS_FLAG}<a,b,...> and #{DEFAULT_FLAG}<one of them> go together"
+          end
+
+          new(domains, default, partial: flags.include?(PARTIAL_FLAG))
+        end
+
+        def self.value(flags, flag)
+          flags.find { |arg| arg.start_with?(flag) }&.delete_prefix(flag)
+        end
+        private_class_method :value, :read
+
+        # @param domains [Array<String>] the declared domains' feature names
+        # @param default [String] the declared domain Cargo's `default` stays on
+        # @param partial [Boolean] whether this run generates only some of them
+        def initialize(domains, default, partial: false)
+          @domains = domains
+          @default = default
+          @partial = partial
+        end
+
+        # @return [Boolean] whether this run leaves `mod.rs` and Cargo's features to a whole run
+        def partial? = @partial
+
+        # @return [Array<String>] the flags that declare these domains to `hecks project_rust`
+        def flags
+          ["#{DOMAINS_FLAG}#{domains.join(",")}", "#{DEFAULT_FLAG}#{default}", *(PARTIAL_FLAG if partial?)]
+        end
+      end
+    end
+  end
+end

data/lib/hecks/rust_build/project_rust/features_header.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Hecks
+  module RustBuild
+    class ProjectRust
+      # What a Cargo manifest with no `[features]` table is given in front of its text.
+      FEATURES_HEADER = <<~TOML
+        # One feature per generated domain: it selects which domain's own
+        # generated::<domain>::merged module `generated::active` re-exports
+        # (rust/src/generated/mod.rs). `hecks project_rust` adds a feature when a new domain is
+        # generated and never removes one (the domain's own generated/<name>/ directory is the
+        # source of truth for whether it exists). `default` tracks the domain generated most
+        # recently, so a bare `cargo build` keeps working; any other still-generated domain stays
+        # reachable via `--no-default-features --features <name>`.
+        [features]
+        default = []
+
+      TOML
+      private_constant :FEATURES_HEADER
+    end
+  end
+end

data/lib/hecks/rust_build/project_rust/manifest.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "../write_if_changed"
+
+module Hecks
+  module RustBuild
+    class ProjectRust
+      # The two files every domain's generation shares: `src/generated/mod.rs` and the workspace's
+      # `Cargo.toml` features. A run of one domain writes them after its own files; a corpus run
+      # that generates its domains side by side tells each `--partial` and writes them once, here,
+      # after the last domain is done, so no two processes ever write them.
+      class Manifest
+        # The `default = [...]` line of a Cargo manifest's `[features]` table.
+        DEFAULT_FEATURE = /^default\s*=.*$/
+        # The `[features]` table of a Cargo manifest, up to the next table header.
+        FEATURES_TABLE = /^\[features\](?:\n(?!\[).*)*$/
+
+        # @param rust_dir [String] the workspace, which holds `Cargo.toml` and `src/generated`
+        # @param declared [Declared, nil] the corpus's declared domains; nil follows the domains on
+        #   disk
+        # @param default [String] the feature `mod.rs` treats as the default and Cargo's `default`
+        #   points at
+        def initialize(rust_dir, declared, default)
+          @rust_dir = rust_dir
+          @out_root = File.join(rust_dir, "src/generated")
+          @declared = declared
+          @default = default
+        end
+
+        # Writes `mod.rs` and syncs Cargo's features, each only when its bytes change.
+        #
+        # @return [void]
+        def call
+          write_root_mod
+          sync_cargo_features
+        end
+
+        private
+
+        # `src/generated/mod.rs`. A directory is a selectable domain exactly when it carries its own
+        # `merged.rs`; a framework bluebook has none and is always compiled in. The domains are
+        # scanned off disk, or, for the corpus, taken from its declared list.
+        def write_root_mod
+          all_dirs = generated_directories
+          @domains = domains_among(all_dirs)
+          path = File.join(@out_root, "mod.rs")
+          wrote = WriteIfChanged.block(path) do |file|
+            RootMod.new(file, all_dirs, @domains, @default).write
+          end
+          puts(wrote ? "wrote #{path}" : "#{path} unchanged")
+        end
+
+        # Every directory under `src/generated`. Under a declared list, its domains are named
+        # even when not generated here yet, and a leftover domain directory it does not declare is
+        # dropped.
+        def generated_directories
+          dirs = Dir.children(@out_root).select { |name| File.directory?(File.join(@out_root, name)) }
+          return dirs.sort unless @declared
+
+          bluebooks = dirs.reject { |name| File.exist?(File.join(@out_root, name, "merged.rs")) }
+          (bluebooks | @declared.domains).sort
+        end
+
+        def domains_among(directories)
+          return @declared.domains.sort if @declared
+
+          directories.select { |name| File.exist?(File.join(@out_root, name, "merged.rs")) }
+        end
+
+        # One Cargo feature per domain (added when missing, never removed), with `default` set to
+        # the default feature so a bare `cargo build` builds it. A feature is inserted right after
+        # `default = [...]`, not appended: past `[[bin]]` it would parse into that table.
+        def sync_cargo_features
+          path = File.join(@rust_dir, "Cargo.toml")
+          manifest = File.read(path)
+          manifest = "#{FEATURES_HEADER}#{manifest}" unless manifest.include?("[features]")
+          @domains.each { |name| manifest = add_feature(manifest, name) }
+          manifest = manifest.sub(DEFAULT_FEATURE, "default = [#{@default.inspect}]")
+          # An unchanged manifest is not rewritten: a new mtime makes Cargo rebuild the whole crate.
+          return puts("#{path} unchanged (default feature already #{@default})") unless WriteIfChanged.call(path, manifest)
+
+          puts "wrote #{path} (default feature: #{@default})"
+        end
+
+        # Checked against the `[features]` table only: `[package]`'s `name` or a `[[bin]]` path can
+        # share a word with a domain name.
+        def add_feature(manifest, name)
+          table = manifest[FEATURES_TABLE] || ""
+          return manifest if table =~ /^#{Regexp.escape(name)}\s*=/
+
+          manifest.sub(DEFAULT_FEATURE) { "#{Regexp.last_match(0)}\n#{name} = []" }
+        end
+      end
+    end
+  end
+end

data/lib/hecks/rust_build/project_rust/meta.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../../bluebook/meta_validator"
+
+module Hecks
+  module RustBuild
+    class ProjectRust
+      # The self-hosted language's Rust, `src/generated/meta`. It is generated from the grammar
+      # registry alone, so it is the same whichever domain a run projects: a corpus run generates it
+      # once here and tells each of its `hecks project_rust` children to skip it (`SKIP_FLAG`),
+      # instead of every child writing the identical files again.
+      module Meta
+        # The flag telling a `hecks project_rust` run that `meta` is already generated.
+        SKIP_FLAG = "--skip-meta"
+
+        # @return [Hash] the self-hosted language's IR, shaped for `hecks-codegen`
+        def self.ir
+          bluebook = Hecks::Projector::Exporter.call(Hecks::Bluebook::MetaValidator.grammar_registry).fetch("Bluebook")
+          TargetIr.json_shaped(bluebook)
+        end
+
+        # Generates `meta` into the workspace, writing only the files whose bytes changed.
+        #
+        # @param rust_dir [String] the workspace being generated into
+        # @return [void]
+        # @raise [Failure] when `hecks-codegen` cannot be built or exits non-zero
+        def self.generate(rust_dir = RustBuild.rust_dir)
+          out_root = File.join(rust_dir, "src/generated")
+          FileUtils.mkdir_p(out_root)
+          CodegenRun.new(rust_dir: rust_dir, out_root: out_root, meta: ir).call
+        end
+      end
+    end
+  end
+end

data/lib/hecks/rust_build/project_rust.rb

@@ -22,25 +22,28 @@ module Hecks
     # The era plugin is required unconditionally so the generator works for any domain, lineage
     # capable or not; `pg` stays lazy inside it, so nothing here opens a database connection.
     class ProjectRust
-      # The flag that leaves the self-hosted language's `meta/` module as it is: every domain
-      # writes the same one, so a run over many domains asks for it once.
-      SKIP_META = "--skip-meta"
-
-      # @param argv [Array<String>] the domain's directory, and `--skip-meta` to leave `meta/` alone
+      # @param argv [Array<String>] the domain's directory, then optionally the corpus run's
+      #   `Declared` flags
       # @return [Integer] the exit status
       # @raise [Failure] when the domain's name cannot be a Rust module and Cargo feature name
       def self.call(argv)
-        flags, paths = argv.partition { |arg| arg == SKIP_META }
-        domain = paths.first or raise Failure, "usage: hecks project_rust <domain> [#{SKIP_META}]"
-        new(domain, skip_meta: !flags.empty?).call
+        skip_meta, argv = argv.partition { |arg| arg == Meta::SKIP_FLAG }
+        declared, rest = Declared.split(argv)
+        domain = rest.first or raise Failure, "usage: hecks project_rust <domain>"
+        new(domain, declared: declared, meta: skip_meta.empty?).call
       end
 
       # @param domain [String] the domain's directory
-      # @param skip_meta [Boolean] leave the `meta/` module as an earlier run wrote it
-      def initialize(domain, skip_meta: false)
+      # @param declared [Declared, nil] the corpus's declared domains; nil for a workspace of one's
+      #   own, where `mod.rs` and Cargo's features follow the domains on disk and `default` the
+      #   domain this run generated
+      # @param meta [Boolean] whether this run generates `meta`; a corpus run that has done so once
+      #   says `Meta::SKIP_FLAG` to each domain
+      def initialize(domain, declared: nil, meta: true)
         @domain = domain
         @mod_name = File.basename(domain)
-        @skip_meta = skip_meta
+        @declared = declared
+        @meta = meta
       end
 
       # @return [Integer] the exit status
@@ -73,8 +76,9 @@ module Hecks
         @ir = TargetIr.new(@registry, @domain_name, loader.bluebook_dir).call
         FileUtils.rm_rf(File.join(@out_root, "active"))
         generate_with_codegen
-        write_root_mod
-        sync_cargo_features
+        return puts("mod.rs and Cargo.toml left to a run of the whole corpus (--partial)") if @declared&.partial?
+
+        Manifest.new(@rust_dir, @declared, default_feature).call
       end
 
       def prepare_output
@@ -87,98 +91,32 @@ module Hecks
       # registry, so a domain's persistence, seams, translations and source text reach `ir.json`.
       def generate_with_codegen
         CodegenRun.new(
-          rust_dir: @rust_dir, out_root: @out_root, meta: meta_ir, declarations: declarations,
+          rust_dir: @rust_dir, out_root: @out_root, meta: (Meta.ir if @meta), declarations: declarations,
           target: CodegenRun::Declaration.new(@mod_name, @domain, @ir)
         ).call
       end
 
-      # @return [Hash, nil] the self-hosted language's IR, or nil when `--skip-meta` leaves it be
-      def meta_ir
-        return nil if @skip_meta
-
-        meta = Hecks::Projector::Exporter.call(Hecks::Bluebook::MetaValidator.grammar_registry).fetch("Bluebook")
-        TargetIr.json_shaped(meta)
-      end
-
+      # A declaration is labelled by its own name: its files read the same whoever attached it, so
+      # regenerating one domain never changes what another domain's files contain.
       def declarations
-        vendored = @registry.hecksagons.values.flat_map(&:vendored_packages)
         (@registry.bluebooks.keys - [@domain_name]).map do |name|
           ir = Hecks::Projector::Exporter.call(@registry).fetch(name)
-          label = "#{@domain} (#{attachment(name, vendored)})"
-          CodegenRun::Declaration.new(name.downcase, label, TargetIr.json_shaped(ir))
-        end
-      end
-
-      # How the target attached a bluebook, across every hecksagon the registry loaded: a bluebook a
-      # sibling hecksagon vendors in is labelled as vendored.
-      def attachment(declaration_name, vendored)
-        name = vendored.find { |candidate| Hecks::Naming.pascal(candidate.to_s) == declaration_name }
-        name ? "attaches #{name.inspect}, from: :vendor" : "attaches #{declaration_name.inspect}"
-      end
-
-      # `src/generated/mod.rs`: every domain ever generated, scanned off disk. A directory is a
-      # selectable domain exactly when it carries its own `merged.rs`; a framework bluebook has
-      # none and is always compiled in.
-      def write_root_mod
-        all_dirs = Dir.children(@out_root).select { |name| File.directory?(File.join(@out_root, name)) }.sort
-        @domains = all_dirs.select { |name| File.exist?(File.join(@out_root, name, "merged.rs")) }
-        path = File.join(@out_root, "mod.rs")
-        wrote = WriteIfChanged.block(path) do |file|
-          RootMod.new(file, all_dirs, @domains, @mod_name).write
+          CodegenRun::Declaration.new(name.downcase, name, TargetIr.json_shaped(ir))
         end
-        puts(wrote ? "wrote #{path}" : "#{path} unchanged")
       end
 
-      # One Cargo feature per domain on disk (added when missing, never removed), with `default`
-      # set to this run's domain so a bare `cargo build` builds it. A feature is inserted right
-      # after `default = [...]`, not appended: past `[[bin]]` it would parse into that table.
-      def sync_cargo_features
-        path = File.join(@rust_dir, "Cargo.toml")
-        manifest = File.read(path)
-        manifest = "#{FEATURES_HEADER}#{manifest}" unless manifest.include?("[features]")
-        @domains.each { |name| manifest = add_feature(manifest, name) }
-        manifest = manifest.sub(DEFAULT_FEATURE, "default = [#{@mod_name.inspect}]")
-        # An unchanged manifest is not rewritten: a new mtime makes Cargo rebuild the whole crate.
-        if WriteIfChanged.call(path, manifest)
-          puts "wrote #{path} (default feature: #{@mod_name})"
-        else
-          puts "#{path} unchanged (default feature already #{@mod_name})"
-        end
-      end
-
-      # Checked against the `[features]` table only: `[package]`'s `name` or a `[[bin]]` path can
-      # share a word with a domain name.
-      def add_feature(manifest, name)
-        table = manifest[FEATURES_TABLE] || ""
-        return manifest if table =~ /^#{Regexp.escape(name)}\s*=/
-
-        manifest.sub(DEFAULT_FEATURE) { "#{Regexp.last_match(0)}\n#{name} = []" }
-      end
-
-      FEATURES_HEADER = <<~TOML
-        # One feature per generated domain: it selects which domain's own
-        # generated::<domain>::merged module `generated::active` re-exports
-        # (rust/src/generated/mod.rs). `hecks project_rust` adds a feature when a new domain is
-        # generated and never removes one (the domain's own generated/<name>/ directory is the
-        # source of truth for whether it exists). `default` tracks the domain generated most
-        # recently, so a bare `cargo build` keeps working; any other still-generated domain stays
-        # reachable via `--no-default-features --features <name>`.
-        [features]
-        default = []
-
-      TOML
-      private_constant :FEATURES_HEADER
-
-      # The `default = [...]` line of a Cargo manifest's `[features]` table.
-      DEFAULT_FEATURE = /^default\s*=.*$/
-      # The `[features]` table of a Cargo manifest, up to the next table header.
-      FEATURES_TABLE = /^\[features\](?:\n(?!\[).*)*$/
-      private_constant :DEFAULT_FEATURE, :FEATURES_TABLE
+      # The feature `default` points at, and the one `mod.rs` treats as the default: the corpus's
+      # fixed one, else the domain this run generated.
+      def default_feature = @declared ? @declared.default : @mod_name
     end
   end
 end
 
+require_relative "project_rust/declared"
+require_relative "project_rust/features_header"
 require_relative "project_rust/root_mod"
 require_relative "project_rust/codegen_run"
+require_relative "project_rust/meta"
 require_relative "project_rust/domain_loader"
 require_relative "project_rust/target_ir"
+require_relative "project_rust/manifest"

data/lib/hecks/rust_build/write_if_changed.rb

@@ -45,18 +45,33 @@ module Hecks
       private_class_method :record_touch
 
       # Writes `content` to `path` unless it already holds identical bytes.
-      # Returns whether it wrote.
-      def call(path, content)
+      # Returns whether it wrote. `formatted` says the caller already ran `content` through rustfmt.
+      # `atomic` writes a sibling temp file and renames it into place, so a process reading `path`
+      # while others write the same bytes never sees a truncated or half-written file.
+      def call(path, content, formatted: false, atomic: false)
         record_touch(path)
-        content = RustFormat.call(content) if RustFormat.rust?(path)
+        content = RustFormat.call(content) if RustFormat.rust?(path) && !formatted
         # `.b` on both sides: String#== is encoding-aware, so UTF-8 vs ASCII-8BIT
         # content can compare unequal even when the bytes are identical.
         return false if File.exist?(path) && File.binread(path) == content.b
 
-        File.write(path, content)
+        atomic ? replace(path, content) : File.write(path, content)
         true
       end
 
+      # Puts `content` at `path` by renaming a finished temp file over it. The temp file is hidden
+      # (a leading dot), so a directory's `*` listing, which prunes what a run did not write, never
+      # sees it, and it keeps the existing file's permissions.
+      def replace(path, content)
+        tmp = File.join(File.dirname(path), ".#{File.basename(path)}.tmp-#{Process.pid}")
+        File.write(tmp, content)
+        File.chmod(File.stat(path).mode & 0o7777, tmp) if File.exist?(path)
+        File.rename(tmp, path)
+      ensure
+        FileUtils.rm_f(tmp)
+      end
+      private_class_method :replace
+
       # Fills `tmp` from the block, then lays it out with rustfmt when `path` is Rust source.
       def write_formatted(tmp, path, &)
         File.open(tmp, "w", &)

data/lib/hecks/rust_build.rb

@@ -35,7 +35,8 @@ module Hecks
       "project_wasm_browser"  => ["rust_build/wasm_browser", :WasmBrowser],
       "rust_conformance"      => ["rust_build/conformance", :Conformance],
       "rust_conformance_fuzz" => ["rust_build/conformance_fuzz", :ConformanceFuzz],
-      "rust_coverage"         => ["rust_build/coverage", :Coverage]
+      "rust_coverage"         => ["rust_build/coverage", :Coverage],
+      "build_parser"          => ["rust_build/parser", :Parser]
     }.freeze
 
     # The process-wide lock a call holds while it swaps `ENV`, `$stdout` and `$stderr`; the same

data/lib/hecks/rust_format.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "etc"
 require "open3"
 
 module Hecks
@@ -21,6 +22,10 @@ module Hecks
     # The most passes `call` makes; a text still changing after them keeps the last result.
     PASSES = 3
 
+    # Serializes the rustfmt children of this process. In a whole-suite run, worker threads capturing
+    # at once end with `Errno::EBADF` in `Open3.popen_run`, so each capture waits for this lock.
+    SPAWN_LOCK = Mutex.new
+
     module_function
 
     # @param path [String] where the text will be written
@@ -56,7 +61,9 @@ module Hecks
     # @return [String] the source after one pass, or unchanged when rustfmt cannot parse it
     # @raise [Failed] when rustfmt fails for a reason other than the text
     def pass(text)
-      out, err, status = Open3.capture3("rustfmt", "--edition", EDITION, "--emit", "stdout", stdin_data: text)
+      out, err, status = SPAWN_LOCK.synchronize do
+        Open3.capture3("rustfmt", "--edition", EDITION, "--emit", "stdout", stdin_data: text)
+      end
       return out if status.success?
       raise Failed, "rustfmt failed: #{err.lines.first&.strip}" unless err.include?("<stdin>")
 
@@ -71,7 +78,30 @@ module Hecks
     # @param content [Hash{String => String}] absolute path to text
     # @return [Hash{String => String}] the same map with each `.rs` text formatted
     def files(content)
-      content.to_h { |path, text| [path, rust?(path) ? call(text) : text] }
+      rust = content.select { |path, _| rust?(path) }
+      formatted = parallel_map(rust.values) { |text| call(text) }
+      content.to_h { |path, text| [path, rust.key?(path) ? formatted.shift : text] }
+    end
+
+    # Maps `items` through the block on one thread per core. rustfmt runs as a child process, so
+    # the threads wait on it rather than on the interpreter lock; order is kept.
+    #
+    # @param items [Array] the inputs
+    # @return [Array] the block's result for each input, in order
+    def parallel_map(items)
+      results = Array.new(items.size)
+      queue = closed_queue(items.size)
+      workers = Array.new([Etc.nprocessors, items.size].min) do
+        Thread.new { while (index = queue.pop) do results[index] = yield(items[index]) end }
+      end
+      workers.each(&:join)
+      results
+    end
+
+    # @param size [Integer] how many indexes to hold
+    # @return [Queue] the indexes 0...size, closed, so a pop past the last returns nil
+    def closed_queue(size)
+      Queue.new((0...size).to_a).tap(&:close)
     end
   end
 end