ctest: Add translation of Rust types.

Author: mbyx

ctest-next/.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+rustflags = ["--cfg", "procmacro2_semver_exempt"]

ctest-next/Cargo.toml

@@ -10,10 +10,10 @@ publish = false
 [dependencies]
 askama = "0.14.0"
 cc = "1.2.25"
+proc-macro2 = { version = "1.0.95", features = ["span-locations"] }
 quote = "1.0.40"
 syn = { version = "2.0.101", features = ["full", "visit", "extra-traits"] }
 thiserror = "2.0.12"
 
 [dev-dependencies]
 tempfile = "3.20.0"
-

ctest-next/build.rs

@@ -6,24 +6,27 @@ use std::env;
 //
 // This is already set by the CI for all platforms, so there is no problem up till here.
 //
-// The integration tests (which are run in qemu, but use host rustc and cc) require the following:
+// The integration tests (which are run in qemu, but use host rustc and cc) require the
+// following:
 // - TARGET_PLATFORM or target set manually. (We forward TARGET in build.rs for this.)
 // - HOST_PLATFORM or host set manually. (We forward HOST in build.rs for this.)
 // - LINKER: To link the C headers. (We forward CARGO_TARGET_{}_LINKER for this.)
-// - FLAGS: Any flags to pass when compiling the test binary for the cross compiled platform. (Forwarded from CARGO_TARGET_{}_RUSTFLAGS)
+// - FLAGS: Any flags to pass when compiling the test binary for the cross compiled platform.
+//   (Forwarded from CARGO_TARGET_{}_RUSTFLAGS)
 // - RUNNER: To run the test binary with. (Forward the same runner as CARGO_TARGET_{}_RUNNER)
 //
-// The TARGET_PLATFORM and HOST_PLATFORM variables are not an issue, cargo will
-// automatically set TARGET and PLATFORM and we will forward them.
+// The TARGET_PLATFORM and HOST_PLATFORM variables are not an issue, cargo will automatically set
+// TARGET and PLATFORM and we will forward them.
 //
-// Similarly FLAGS and RUNNER are also not an issue, if CARGO_TARGET_{}_RUSTFLAGS are present they're forwarded.
-// And RUSTFLAGS works by default anyway. Similarly the test binary doesn't require any external applications so just
-// the RUNNER is enough to run it.
+// Similarly FLAGS and RUNNER are also not an issue, if CARGO_TARGET_{}_RUSTFLAGS are present
+// they're forwarded. And RUSTFLAGS works by default anyway. Similarly the test binary doesn't
+// require any external applications so just the RUNNER is enough to run it.
 //
-// However since rustc and cc are the host versions, they will only work if we specify the correct variables for them.
-// Because we only use them to compile, not run things.
-// For CC we MUST specify CC or CC_target otherwise it will fail. (Other flags like AR etc. work without forwarding because it is run in the host.)
-// For rustc we MUST specify the correct linker. Usually this is the same as CC or CC_target.
+// However since rustc and cc are the host versions, they will only work if we specify the
+// correct variables for them. Because we only use them to compile, not run things. For CC we
+// MUST specify CC or CC_target otherwise it will fail. (Other flags like AR etc. work without
+// forwarding because it is run in the host.) For rustc we MUST specify the correct linker.
+// Usually this is the same as CC or CC_target.
 //
 // In the CI, the CARGO_TARGET_{} variables are always set.
 
@@ -33,23 +36,34 @@ fn main() {
     let target_key = target.replace('-', "_").to_uppercase();
 
     println!("cargo:rustc-env=HOST_PLATFORM={host}");
+    println!("cargo:rerun-if-changed-env=HOST");
+
     println!("cargo:rustc-env=TARGET_PLATFORM={target}");
+    println!("cargo:rerun-if-changed-env=TARGET");
 
-    let linker = env::var(format!("CARGO_TARGET_{target_key}_LINKER")).unwrap_or_default();
-    let runner = env::var(format!("CARGO_TARGET_{target_key}_RUNNER")).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_{target_key}_RUSTFLAGS")).unwrap_or_default();
+    let link_var = format!("CARGO_TARGET_{target_key}_LINKER");
+    println!("cargo:rerun-if-changed-env={link_var}");
+    if let Ok(linker) = env::var(link_var) {
+        println!("cargo:rustc-env=LINKER={linker}");
+    }
 
-    // Forward build environment variables so they can be used in tests.
-    println!("cargo:rustc-env=LINKER={linker}");
-    println!("cargo:rustc-env=RUNNER={runner}");
-    println!("cargo:rustc-env=FLAGS={flags}");
+    let run_var = format!("CARGO_TARGET_{target_key}_RUNNER");
+    println!("cargo:rerun-if-changed-env={run_var}");
+    if let Ok(runner) = env::var(run_var) {
+        println!("cargo:rustc-env=RUNNER={runner}");
+    }
 
-    // Rerun this build script if any of the environment variables change.
-    println!("cargo:rerun-if-changed-env=HOST");
-    println!("cargo:rerun-if-changed-env=TARGET");
-    println!("cargo:rerun-if-changed-env=CARGO_TARGET_{target_key}_LINKER",);
+    // As we invoke rustc directly this does not get passed to it, although RUSTFLAGS does.
+    let flag_var = format!("CARGO_TARGET_{target_key}_RUSTFLAGS");
+    println!("cargo:rerun-if-changed-env={flag_var}");
+    if let Ok(flags) = env::var(flag_var) {
+        println!("cargo:rustc-env=FLAGS={flags}");
+    }
+
+    // Rerun this build script if any of these environment variables change.
     println!("cargo:rerun-if-changed-env=CC");
-    println!("cargo:rerun-if-changed-env=CC_{target_key}");
-    println!("cargo:rerun-if-changed-env=CARGO_TARGET_{target_key}_RUNNER",);
+    println!(
+        "cargo:rerun-if-changed-env=CC_{}",
+        target_key.to_lowercase()
+    );
 }

ctest-next/src/generator.rs

@@ -20,7 +20,6 @@ use crate::{
 pub struct TestGenerator {
     headers: Vec<String>,
     pub(crate) target: Option<String>,
-    pub(crate) host: Option<String>,
     pub(crate) includes: Vec<PathBuf>,
     out_dir: Option<PathBuf>,
 }
@@ -50,12 +49,6 @@ impl TestGenerator {
         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
@@ -96,7 +89,7 @@ impl TestGenerator {
             .write_all(RustTestTemplate::new(&ffi_items)?.render()?.as_bytes())?;
 
         // Generate the C side of the tests.
-        // FIXME: Cpp not supported yet.
+        // FIXME(ctest): 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)?

ctest-next/src/runner.rs

@@ -6,25 +6,24 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 
 /// Generate all tests for the given crate and output the Rust side to a file.
+#[doc(hidden)]
 pub fn generate_test(
     generator: &mut TestGenerator,
     crate_path: impl AsRef<Path>,
     output_file_path: impl AsRef<Path>,
 ) -> Result<PathBuf> {
     let output_file_path = generator.generate_files(crate_path, output_file_path)?;
 
-    // Search for the target and host to build for if specified manually (generator.target, generator.host),
+    // Search for the target and host to build for if specified manually
+    // (generator.target, generator.host),
     // via build script (TARGET, HOST), or for internal testing (TARGET_PLATFORM, HOST_PLATFORM).
     let target = generator.target.clone().unwrap_or_else(|| {
         env::var("TARGET").unwrap_or_else(|_| env::var("TARGET_PLATFORM").unwrap())
     });
-    let host = generator
-        .host
-        .clone()
-        .unwrap_or_else(|| env::var("HOST").unwrap_or_else(|_| env::var("HOST_PLATFORM").unwrap()));
+    let host = env::var("HOST").unwrap_or_else(|_| env::var("HOST_PLATFORM").unwrap());
 
     let mut cfg = cc::Build::new();
-    // FIXME: Cpp not supported.
+    // FIXME(ctest): Cpp not supported.
     cfg.file(output_file_path.with_extension("c"));
     cfg.host(&host);
 
@@ -143,18 +142,21 @@ pub fn __compile_test(
 #[doc(hidden)]
 pub fn __run_test<P: AsRef<Path>>(test_binary: P) -> Result<String> {
     let runner = env::var("RUNNER").unwrap_or_default();
-    let output = if runner.is_empty() {
-        Command::new(test_binary.as_ref()).output()?
+    let mut cmd;
+    if runner.is_empty() {
+        cmd = Command::new(test_binary.as_ref());
     } else {
         let mut args = runner.split_whitespace();
-        let mut cmd = Command::new(args.next().unwrap());
-        cmd.args(args).arg(test_binary.as_ref()).output()?
+        cmd = Command::new(args.next().unwrap());
+        cmd.args(args);
     };
 
+    cmd.arg(test_binary.as_ref());
+    let output = cmd.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())
+    Ok(std::str::from_utf8(&output.stdout)?.to_string())
 }

ctest-next/src/tests.rs

@@ -1,4 +1,4 @@
-use crate::{ffi_items::FfiItems, translator::Translator};
+use crate::{ffi_items::FfiItems, translator::Translator, Result, TranslationError};
 
 use syn::visit::Visit;
 
@@ -34,6 +34,12 @@ macro_rules! collect_idents {
     };
 }
 
+fn ty(s: &str) -> Result<String, TranslationError> {
+    let translator = Translator {};
+    let ty: syn::Type = syn::parse_str(s).unwrap();
+    translator.translate_type(&ty)
+}
+
 #[test]
 fn test_extraction_ffi_items() {
     let ast = syn::parse_file(ALL_ITEMS).unwrap();
@@ -51,127 +57,50 @@ fn test_extraction_ffi_items() {
 
 #[test]
 fn test_translation_type_ptr() {
-    let translator = Translator {};
-    let ty: syn::Type = syn::parse_str("*const *mut i32").unwrap();
-
     assert_eq!(
-        translator.translate_type(&ty),
-        Ok("int32_t * const*".to_string())
+        ty("*const *mut i32").unwrap(),
+        "int32_t * const*".to_string()
     );
-}
-
-#[test]
-fn test_translation_type_ptr_to_array() {
-    let translator = Translator {};
-    let ty: syn::Type = syn::parse_str("*const [u128; 2 + 3]").unwrap();
-
     assert_eq!(
-        translator.translate_type(&ty),
-        Ok("unsigned __int128 (*const) [2 + 3]".to_string())
+        ty("*const [u128; 2 + 3]").unwrap(),
+        "unsigned __int128 (*const) [2 + 3]".to_string()
     );
-}
-
-#[test]
-fn test_translation_type_ptr_to_ptr_array() {
-    let translator = Translator {};
-    let ty: syn::Type = syn::parse_str("*const *mut [u8; 5]").unwrap();
-
     assert_eq!(
-        translator.translate_type(&ty),
-        Ok("uint8_t (*const *) [5]".to_string())
-    );
-}
-
-#[test]
-fn test_translation_type_ptr_to_fn_with_array() {
-    let translator = Translator {};
-    let ty: syn::Type =
-        syn::parse_str("*const fn(*mut u8, &mut [u8; 16]) -> &mut *mut u8").unwrap();
-
-    assert_eq!(
-        translator.translate_type(&ty),
-        Ok("uint8_t * *(*const)(uint8_t *, uint8_t (*) [16])".to_string())
+        ty("*const *mut [u8; 5]").unwrap(),
+        "uint8_t (*const *) [5]".to_string()
     );
 }
 
 #[test]
 fn test_translation_type_reference() {
-    let translator = Translator {};
-    let ty: syn::Type = syn::parse_str("&u8").unwrap();
-
-    assert_eq!(
-        translator.translate_type(&ty),
-        Ok("const uint8_t*".to_string())
-    );
-}
-
-#[test]
-fn test_translation_type_double_reference() {
-    let translator = Translator {};
-    let ty: syn::Type = syn::parse_str("&&u8").unwrap();
-
-    assert_eq!(
-        translator.translate_type(&ty),
-        Ok("const uint8_t* const*".to_string())
-    );
+    assert_eq!(ty("&u8").unwrap(), "const uint8_t*".to_string());
+    assert_eq!(ty("&&u8").unwrap(), "const uint8_t* const*".to_string());
+    assert_eq!(ty("*mut &u8").unwrap(), "const uint8_t* *".to_string());
+    assert_eq!(ty("& &mut u8").unwrap(), "uint8_t* const*".to_string());
 }
 
 #[test]
-fn test_translation_type_pointer_reference() {
-    let translator = Translator {};
-    let ty: syn::Type = syn::parse_str("*mut &u8").unwrap();
-
+fn test_translation_type_bare_fn() {
     assert_eq!(
-        translator.translate_type(&ty),
-        Ok("const uint8_t* *".to_string())
+        ty("fn(*mut u8, i16) -> *const char").unwrap(),
+        "char const*(*)(uint8_t *, int16_t)".to_string()
     );
-}
-
-#[test]
-fn test_translation_type_reference_pointer() {
-    let translator = Translator {};
-    let ty: syn::Type = syn::parse_str("& &mut u8").unwrap();
-
     assert_eq!(
-        translator.translate_type(&ty),
-        Ok("uint8_t* const*".to_string())
-    );
-}
-
-#[test]
-fn test_translation_type_bare_fn() {
-    let translator = Translator {};
-    let ty: syn::Type = syn::parse_str("fn(*mut u8, i16) -> *const char").unwrap();
-
-    assert_eq!(
-        translator.translate_type(&ty),
-        Ok("char const*(*)(uint8_t *, int16_t)".to_string())
+        ty("*const fn(*mut u8, &mut [u8; 16]) -> &mut *mut u8").unwrap(),
+        "uint8_t * *(*const)(uint8_t *, uint8_t (*) [16])".to_string()
     );
 }
 
 #[test]
 fn test_translation_type_array() {
-    let translator = Translator {};
-    let ty: syn::Type = syn::parse_str("[&u8; 2 + 2]").unwrap();
-
     assert_eq!(
-        translator.translate_type(&ty),
-        Ok("const uint8_t*[2 + 2]".to_string())
+        ty("[&u8; 2 + 2]").unwrap(),
+        "const uint8_t*[2 + 2]".to_string()
     );
 }
 
 #[test]
-fn test_translation_fails_for_str() {
-    let translator = Translator {};
-    let ty: syn::Type = syn::parse_str("[&str; 2 + 2]").unwrap();
-
-    assert!(translator.translate_type(&ty).is_err());
-}
-
-#[test]
-fn test_translation_fails_for_slice() {
-    let translator = Translator {};
-    let ty: syn::Type = syn::parse_str("fn(*mut [u8], i16) -> *const char").unwrap();
-
-    assert!(translator.translate_type(&ty).is_err());
+fn test_translation_fails_for_unsupported() {
+    assert!(ty("[&str; 2 + 2]").is_err());
+    assert!(ty("fn(*mut [u8], i16) -> *const char").is_err());
 }