ctest: Add translation of types and test generation, compilation and running.

Author: mbyx

ctest-next/Cargo.toml

@@ -8,5 +8,8 @@ repository = "https://github.com/rust-lang/libc"
 publish = false
 
 [dependencies]
+askama = "0.14.0"
 cc = "1.2.25"
+quote = "1.0.40"
 syn = { version = "2.0.101", features = ["full", "visit", "extra-traits"] }
+tempfile = "3.20.0"

ctest-next/askama.toml

@@ -0,0 +1,3 @@
+[[escaper]]
+path = "askama::filters::Text"
+extensions = ["rs", "c", "cpp"]

ctest-next/build.rs

@@ -0,0 +1,31 @@
+use std::env;
+
+fn main() {
+    let host = env::var("HOST").unwrap();
+    let target = env::var("TARGET").unwrap();
+    let target_key = target.replace('-', "_");
+
+    println!("cargo:rustc-env=HOST_PLATFORM={host}");
+    println!("cargo:rustc-env=TARGET_PLATFORM={target}");
+
+    let linker = env::var(format!("CARGO_TARGET_{}_LINKER", target_key.to_uppercase()))
+        .or_else(|_| env::var("CC"))
+        .or_else(|_| env::var(format!("CC_{target_key}")))
+        .unwrap_or_default();
+
+    let runner =
+        env::var(format!("CARGO_TARGET_{}_RUNNER", target_key.to_uppercase())).unwrap_or_default();
+
+    // As we invoke rustc directly this does not get passed to it, although RUSTFLAGS does.
+    let flags = env::var(format!(
+        "CARGO_TARGET_{}_RUSTFLAGS",
+        target_key.to_uppercase()
+    ))
+    .unwrap_or_default();
+
+    println!("cargo:rustc-env=LINKER={linker}");
+    println!("cargo:rustc-env=RUNNER={runner}");
+    println!("cargo:rustc-env=FLAGS={flags}");
+
+    println!("cargo:rerun-if-changed-env=TARGET");
+}

ctest-next/src/ast/constant.rs

@@ -6,7 +6,6 @@ pub struct Const {
     #[expect(unused)]
     pub(crate) public: bool,
     pub(crate) ident: BoxStr,
-    #[expect(unused)]
     pub(crate) ty: syn::Type,
     #[expect(unused)]
     pub(crate) expr: syn::Expr,

ctest-next/src/ffi_items.rs

@@ -54,7 +54,6 @@ impl FfiItems {
     }
 
     /// Return a list of all constants found.
-    #[cfg_attr(not(test), expect(unused))]
     pub(crate) fn constants(&self) -> &Vec<Const> {
         &self.constants
     }

ctest-next/src/generator.rs

@@ -1,28 +1,159 @@
-use std::path::Path;
+use std::{
+    env,
+    fs::File,
+    io::Write,
+    path::{Path, PathBuf},
+};
 
+use askama::Template;
 use syn::visit::Visit;
 
-use crate::{expand, ffi_items::FfiItems, Result};
+use crate::{
+    expand,
+    ffi_items::FfiItems,
+    template::{CTestTemplate, RustTestTemplate},
+    Result,
+};
 
 /// A builder used to generate a test suite.
 #[non_exhaustive]
 #[derive(Default, Debug, Clone)]
-pub struct TestGenerator {}
+pub struct TestGenerator {
+    headers: Vec<String>,
+    target: Option<String>,
+    host: Option<String>,
+    includes: Vec<PathBuf>,
+    out_dir: Option<PathBuf>,
+}
 
 impl TestGenerator {
     /// Creates a new blank test generator.
     pub fn new() -> Self {
         Self::default()
     }
 
+    /// Add a header to be included as part of the generated C file.
+    pub fn header(&mut self, header: &str) -> &mut Self {
+        self.headers.push(header.to_string());
+        self
+    }
+
+    /// Configures the target to compile C code for.
+    pub fn target(&mut self, target: &str) -> &mut Self {
+        self.target = Some(target.to_string());
+        self
+    }
+
+    /// Configures the host.
+    pub fn host(&mut self, host: &str) -> &mut Self {
+        self.host = Some(host.to_string());
+        self
+    }
+
+    /// Add a path to the C compiler header lookup path.
+    ///
+    /// This is useful for if the C library is installed to a nonstandard
+    /// location to ensure that compiling the C file succeeds.
+    pub fn include<P: AsRef<Path>>(&mut self, p: P) -> &mut Self {
+        self.includes.push(p.as_ref().to_owned());
+        self
+    }
+
+    /// Configures the output directory of the generated Rust and C code.
+    pub fn out_dir<P: AsRef<Path>>(&mut self, p: P) -> &mut Self {
+        self.out_dir = Some(p.as_ref().to_owned());
+        self
+    }
+
     /// Generate all tests for the given crate and output the Rust side to a file.
-    pub fn generate<P: AsRef<Path>>(&mut self, crate_path: P, _output_file_path: P) -> Result<()> {
+    pub fn generate<P: AsRef<Path>>(&mut self, crate_path: P, output_file_path: P) -> Result<()> {
+        let output_file_path = self.generate_files(crate_path, output_file_path)?;
+
+        let target = self
+            .target
+            .clone()
+            .unwrap_or(env::var("TARGET_PLATFORM").unwrap());
+        let host = self
+            .host
+            .clone()
+            .unwrap_or(env::var("HOST_PLATFORM").unwrap());
+
+        let mut cfg = cc::Build::new();
+        // FIXME: Cpp not supported.
+        cfg.file(output_file_path.with_extension("c"));
+        cfg.host(&host);
+        if target.contains("msvc") {
+            cfg.flag("/W3")
+                .flag("/Wall")
+                .flag("/WX")
+                // ignored warnings
+                .flag("/wd4820") // warning about adding padding?
+                .flag("/wd4100") // unused parameters
+                .flag("/wd4996") // deprecated functions
+                .flag("/wd4296") // '<' being always false
+                .flag("/wd4255") // converting () to (void)
+                .flag("/wd4668") // using an undefined thing in preprocessor?
+                .flag("/wd4366") // taking ref to packed struct field might be unaligned
+                .flag("/wd4189") // local variable initialized but not referenced
+                .flag("/wd4710") // function not inlined
+                .flag("/wd5045") // compiler will insert Spectre mitigation
+                .flag("/wd4514") // unreferenced inline function removed
+                .flag("/wd4711"); // function selected for automatic inline
+        } else {
+            cfg.flag("-Wall")
+                .flag("-Wextra")
+                .flag("-Werror")
+                .flag("-Wno-unused-parameter")
+                .flag("-Wno-type-limits")
+                // allow taking address of packed struct members:
+                .flag("-Wno-address-of-packed-member")
+                .flag("-Wno-unknown-warning-option")
+                .flag("-Wno-deprecated-declarations"); // allow deprecated items
+        }
+
+        for p in &self.includes {
+            cfg.include(p);
+        }
+
+        let stem: &str = output_file_path.file_stem().unwrap().to_str().unwrap();
+        cfg.target(&target)
+            .out_dir(output_file_path.parent().unwrap())
+            .compile(stem);
+
+        Ok(())
+    }
+
+    /// Generate the Rust and C testing files.
+    ///
+    /// Returns the path to the generated file.
+    pub(crate) fn generate_files<P: AsRef<Path>>(
+        &mut self,
+        crate_path: P,
+        output_file_path: P,
+    ) -> Result<PathBuf> {
         let expanded = expand(crate_path)?;
         let ast = syn::parse_file(&expanded)?;
 
         let mut ffi_items = FfiItems::new();
         ffi_items.visit_file(&ast);
 
-        Ok(())
+        let output_directory = self
+            .out_dir
+            .clone()
+            .unwrap_or_else(|| PathBuf::from(env::var_os("OUT_DIR").unwrap()));
+        let output_file_path = output_directory.join(output_file_path);
+
+        // Generate the Rust side of the tests.
+        File::create(output_file_path.with_extension("rs"))?
+            .write_all(RustTestTemplate::new(&ffi_items)?.render()?.as_bytes())?;
+
+        // Generate the C side of the tests.
+        // FIXME: Cpp not supported yet.
+        let c_output_path = output_file_path.with_extension("c");
+        let headers = self.headers.iter().map(|h| h.as_str()).collect();
+        File::create(&c_output_path)?
+            .write_all(CTestTemplate::new(headers, &ffi_items).render()?.as_bytes())?;
+
+        Ok(output_file_path)
     }
 }

ctest-next/src/lib.rs

@@ -15,10 +15,16 @@ mod ast;
 mod ffi_items;
 mod generator;
 mod macro_expansion;
+mod runner;
+mod rustc_version;
+mod template;
+mod translator;
 
 pub use ast::{Abi, Const, Field, Fn, Parameter, Static, Struct, Type, Union};
 pub use generator::TestGenerator;
 pub use macro_expansion::expand;
+pub use runner::{compile_test, run_test};
+pub use rustc_version::{rustc_version, RustcVersion};
 
 /// A possible error that can be encountered in our library.
 pub type Error = Box<dyn std::error::Error>;

ctest-next/src/runner.rs

@@ -0,0 +1,83 @@
+use crate::Result;
+use std::env;
+use std::fs::{canonicalize, File};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+/// Compiles a Rust source file and links it against a static library.
+///
+/// Returns the path to the generated binary.
+pub fn compile_test<P: AsRef<Path>>(
+    output_dir: P,
+    crate_path: P,
+    library_file: P,
+) -> Result<PathBuf> {
+    let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".into());
+    let output_dir = output_dir.as_ref();
+    let crate_path = crate_path.as_ref();
+    let library_file = library_file.as_ref();
+
+    let rust_file = output_dir
+        .join(crate_path.file_stem().unwrap())
+        .with_extension("rs");
+    let binary_path = output_dir.join(rust_file.file_stem().unwrap());
+
+    File::create(&rust_file)?.write_all(
+        format!(
+            "include!(r#\"{}\"#);\ninclude!(r#\"{}.rs\"#);",
+            canonicalize(crate_path)?.display(),
+            library_file.display()
+        )
+        .as_bytes(),
+    )?;
+
+    let mut cmd = Command::new(rustc);
+    cmd.arg(&rust_file)
+        .arg(format!("-Lnative={}", output_dir.display()))
+        .arg(format!(
+            "-lstatic={}",
+            library_file.file_stem().unwrap().to_str().unwrap()
+        ))
+        .arg("--target")
+        .arg(env::var("TARGET_PLATFORM").unwrap())
+        .arg("-o")
+        .arg(&binary_path)
+        .arg("-Aunused");
+
+    let linker = env::var("LINKER").unwrap_or_default();
+    if !linker.is_empty() {
+        cmd.arg(format!("-Clinker={linker}"));
+    }
+
+    let flags = env::var("FLAGS").unwrap_or_default();
+    if !flags.is_empty() {
+        cmd.args(flags.split_whitespace());
+    }
+
+    let output = cmd.output()?;
+    if !output.status.success() {
+        return Err(std::str::from_utf8(&output.stderr)?.into());
+    }
+
+    Ok(binary_path)
+}
+
+/// Executes the compiled test binary and returns its output.
+pub fn run_test(test_binary: &str) -> Result<String> {
+    let runner = env::var("RUNNER").unwrap_or_default();
+    let output = if runner.is_empty() {
+        Command::new(test_binary).output()?
+    } else {
+        let mut args = runner.split_whitespace();
+        let mut cmd = Command::new(args.next().unwrap());
+        cmd.args(args).arg(test_binary).output()?
+    };
+
+    if !output.status.success() {
+        return Err(std::str::from_utf8(&output.stderr)?.into());
+    }
+
+    // The template prints to stderr regardless.
+    Ok(std::str::from_utf8(&output.stderr)?.to_string())
+}

ctest-next/src/rustc_version.rs

@@ -0,0 +1,65 @@
+use std::{env, fmt::Display, num::ParseIntError, process::Command};
+
+use crate::Result;
+
+/// Represents the current version of the rustc compiler globally in use.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct RustcVersion {
+    major: u8,
+    minor: u8,
+    patch: u8,
+}
+
+impl RustcVersion {
+    /// Define a rustc version with the given major.minor.patch.
+    pub fn new(major: u8, minor: u8, patch: u8) -> Self {
+        Self {
+            major,
+            minor,
+            patch,
+        }
+    }
+}
+
+impl Display for RustcVersion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "RustcVersion({}, {}, {})",
+            self.major, self.minor, self.patch
+        )
+    }
+}
+
+/// Return the global rustc version.
+pub fn rustc_version() -> Result<RustcVersion> {
+    let rustc = env::var("RUSTC").unwrap_or_else(|_| String::from("rustc"));
+
+    let output = Command::new(rustc).arg("--version").output()?;
+
+    if !output.status.success() {
+        let error = std::str::from_utf8(&output.stderr)?;
+        return Err(error.into());
+    }
+
+    // eg: rustc 1.87.0-(optionally nightly) (17067e9ac 2025-05-09)
+    // Assume the format does not change.
+    let [major, minor, patch] = std::str::from_utf8(&output.stdout)?
+        .split_whitespace()
+        .nth(1)
+        .unwrap()
+        .split('.')
+        .take(3)
+        .map(|s| {
+            s.chars()
+                .take_while(|c| c.is_ascii_digit())
+                .collect::<String>()
+                .trim()
+                .parse::<u8>()
+        })
+        .collect::<Result<Vec<u8>, ParseIntError>>()?
+        .try_into()
+        .unwrap();
+
+    Ok(RustcVersion::new(major, minor, patch))
+}