transpile: add --postprocess to run c2rust-postprocess (#1626)

`c2rust-postprocess` is run after transpiling and potentially
refactoring (if `--reorganize-definitions` and not
`--disable-refactoring`). Since `c2rust-postprocess` is not a Rust
binary, it's not always a sibling to the `c2rust`/`c2rust-transpile`
binary. It's a bash script that runs a Python script with `uv`. Thus, to
find it, we look in `$PATH` first and if it's not there, we assume we're
in the `c2rust` repo and `cargo build` has been run and find the
relative path of `c2rust-postprocess` (i.e.,
`target/$profile/../../c2rust-postprocess/c2rust-postprocess`).

Similarly to `--reorganize-definitions`/`c2rust-refactor`, this requires
`--emit-build-files`, as we need the `crate_file` (e.g., `src/lib.rs`)
to run `c2rust-postprocess`. `c2rust-postprocess` can be easily set up
to run on a single Rust file, though, so we should be able to drop this
requirement later.

Author: kkysen

Cargo.lock

@@ -1,2 +1,2 @@
 #!/bin/sh
-uv run postprocess "$@"
+uv run --project "$(dirname "$0")" postprocess "$@"

c2rust-postprocess/c2rust-postprocess

@@ -39,6 +39,7 @@ strum = "0.24"
 strum_macros = "0.24"
 syn = { version = "2.0", features = ["full", "extra-traits", "parsing", "printing"]}
 tempfile = "3.5.0"
+which = "4.4.0"
 
 [features]
 # Force static linking of LLVM

c2rust-transpile/Cargo.toml

@@ -14,19 +14,20 @@ pub mod with_stmts;
 
 use std::collections::HashSet;
 use std::fs::{self, File};
-use std::io::prelude::*;
+use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::{env, io};
 
 use crate::compile_cmds::CompileCmd;
 use c2rust_rust_tools::rustfmt;
-use failure::Error;
+use failure::{format_err, Error};
 use itertools::Itertools;
 use log::{info, warn};
 use regex::Regex;
 use serde_derive::Serialize;
 pub use tempfile::TempDir;
+use which::which;
 
 use crate::c_ast::Printer;
 use crate::c_ast::*;
@@ -106,6 +107,9 @@ pub struct TranspilerConfig {
     pub preserve_unused_functions: bool,
     pub log_level: log::LevelFilter,
 
+    /// Run `c2rust-postprocess` after transpiling and potentially refactoring.
+    pub postprocess: bool,
+
     // Options that control build files
     /// Emit `Cargo.toml` and `lib.rs`
     pub emit_build_files: bool,
@@ -438,8 +442,10 @@ pub fn transpile(tcfg: TranspilerConfig, cc_db: &Path, extra_clang_args: &[&str]
                 top_level_ccfg = Some(ccfg);
             } else {
                 let crate_file = emit_build_files(&tcfg, &build_dir, Some(ccfg), None);
+                let crate_file = crate_file.as_deref();
                 reorganize_definitions(&tcfg, &build_dir, crate_file)
                     .unwrap_or_else(|e| warn!("Reorganizing definitions failed: {}", e));
+                run_postprocess(&tcfg, &build_dir, crate_file).unwrap_or_else(|e| warn!("{e}"));
                 workspace_members.push(lcmd_name);
             }
         }
@@ -453,8 +459,10 @@ pub fn transpile(tcfg: TranspilerConfig, cc_db: &Path, extra_clang_args: &[&str]
     if tcfg.emit_build_files {
         let crate_file =
             emit_build_files(&tcfg, &build_dir, top_level_ccfg, Some(workspace_members));
+        let crate_file = crate_file.as_deref();
         reorganize_definitions(&tcfg, &build_dir, crate_file)
             .unwrap_or_else(|e| warn!("Reorganizing definitions failed: {}", e));
+        run_postprocess(&tcfg, &build_dir, crate_file).unwrap_or_else(|e| warn!("{e}"));
     }
 
     tcfg.check_if_all_binaries_used(&transpiled_modules);
@@ -535,7 +543,7 @@ fn invoke_refactor(build_dir: &Path) -> Result<(), Error> {
 fn reorganize_definitions(
     tcfg: &TranspilerConfig,
     build_dir: &Path,
-    crate_file: Option<PathBuf>,
+    crate_file: Option<&Path>,
 ) -> Result<(), Error> {
     // We only run the reorganization refactoring if we emitted a fresh crate file
     if crate_file.is_none() || tcfg.disable_refactoring || !tcfg.reorganize_definitions {
@@ -558,7 +566,80 @@ fn reorganize_definitions(
     Ok(())
 }
 
-/// Transpile one input C file, writing transpilation output to the filesystem.
+/// Invokes `c2rust-postprocess`.
+///
+/// This assumes the subcommand executable is either in `$PATH`
+/// or in the same relative directory as it is in the repo
+/// and the current executable is in `target/$profile/`.
+fn invoke_postprocess(crate_file: &Path, build_dir: &Path) -> Result<(), Error> {
+    let subcommand = "c2rust-postprocess";
+    let subcommand_path_buf;
+    let subcommand_path = match which(subcommand) {
+        Ok(_) => Path::new(subcommand),
+        Err(_) => {
+            let current_exe = env::current_exe()?;
+            let current_exe_dir = current_exe.parent();
+            let current_exe = current_exe.display();
+            let target_dir = current_exe_dir
+                .ok_or_else(|| format_err!("no parent of {current_exe}"))?
+                .parent()
+                .ok_or_else(|| format_err!("no grandparent of {current_exe}"))?;
+            let target_dir_name = target_dir
+                .file_name()
+                .unwrap_or_default()
+                .to_str()
+                .unwrap_or_default();
+            if target_dir_name != "target" {
+                Err(format_err!(
+                    "{current_exe} not in `target/$profile/` and {subcommand} not in $PATH"
+                ))?;
+            }
+            let repo_root = target_dir
+                .parent()
+                .ok_or_else(|| format_err!("no repo root ancestor of {current_exe}"))?;
+            subcommand_path_buf = repo_root.join(subcommand).join(subcommand);
+            &subcommand_path_buf
+        }
+    };
+
+    let mut cmd = Command::new(subcommand_path);
+    cmd.arg("--update-rust")
+        .arg(crate_file)
+        .current_dir(build_dir);
+    let status =  cmd
+        .status()
+        .map_err(|e| {
+            let path = subcommand_path.display();
+            failure::format_err!("unable to run {path}: {e}\nNote that {subcommand} must be installed separately from c2rust and c2rust-transpile.\
+            It must be either installed in $PATH or c2rust/c2rust-transpile must be in `target/$profile/` from the c2rust repo.")
+        })?;
+
+    if !status.success() {
+        Err(format_err!("postprocess failed: {cmd:?}"))?;
+    }
+
+    Ok(())
+}
+
+fn run_postprocess(
+    tcfg: &TranspilerConfig,
+    build_dir: &Path,
+    crate_file: Option<&Path>,
+) -> Result<(), Error> {
+    let crate_file = match crate_file {
+        Some(crate_file) => crate_file,
+        None => return Ok(()),
+    };
+    if !tcfg.postprocess {
+        return Ok(());
+    }
+
+    invoke_postprocess(crate_file, build_dir)?;
+
+    Ok(())
+}
+
+/// Transpiles one input C file, writing transpilation output to the filesystem.
 fn transpile_single(
     tcfg: &TranspilerConfig,
     input_path: &Path,

c2rust-transpile/src/lib.rs

@@ -50,6 +50,7 @@ fn config() -> TranspilerConfig {
         disable_refactoring: false,
         preserve_unused_functions: false,
         log_level: log::LevelFilter::Warn,
+        postprocess: false,
         emit_build_files: false,
         binaries: Vec::new(),
         c2rust_dir: Some(

c2rust-transpile/tests/snapshots.rs

@@ -139,6 +139,10 @@ struct Args {
     #[clap(short = 'r', long)]
     reorganize_definitions: bool,
 
+    /// Run `c2rust-postprocess` after transpiling and potentially refactoring.
+    #[clap(long)]
+    postprocess: bool,
+
     /// Extra arguments to pass to clang frontend during parsing the input C file
     #[clap(multiple = true, last(true))]
     extra_clang_args: Vec<String>,
@@ -288,6 +292,7 @@ fn main() {
         overwrite_existing: args.overwrite_existing,
         reduce_type_annotations: args.reduce_type_annotations,
         reorganize_definitions: args.reorganize_definitions,
+        postprocess: args.postprocess,
         emit_modules: args.emit_modules,
         emit_build_files: args.emit_build_files,
         c2rust_dir: args.c2rust_dir,

c2rust/src/bin/c2rust-transpile.rs

@@ -24,6 +24,7 @@ impl SubCommand {
     /// Find all [`SubCommand`]s adjacent to the current (`c2rust`) executable.
     /// They are of the form `c2rust-{name}`.
     pub fn find_all() -> anyhow::Result<Vec<Self>> {
+        // TODO Add support for finding `c2rust-postprocess`, which won't be directly adjacent.
         let c2rust = env::current_exe()?;
         let c2rust_name = c2rust
             .file_name()
@@ -60,12 +61,19 @@ impl SubCommand {
     /// Get all known [`SubCommand`]s.  These have no [`SubCommand::path`].
     /// Even if the subcommand executables aren't there, we can still suggest them.
     pub fn known() -> impl Iterator<Item = Self> {
-        ["transpile", "refactor", "instrument", "pdg", "analyze"]
-            .into_iter()
-            .map(|name| Self {
-                path: None,
-                name: name.into(),
-            })
+        [
+            "transpile",
+            "refactor",
+            "postprocess",
+            "instrument",
+            "pdg",
+            "analyze",
+        ]
+        .into_iter()
+        .map(|name| Self {
+            path: None,
+            name: name.into(),
+        })
     }
 
     /// Get all known ([`Self::known`]) and actual, found ([`Self::find_all`]) subcommands,