Tests are now handled by cargo test instead of a separate makefile, simplifing build process

Author: FractalFir

makefile

@@ -6,31 +6,7 @@ RUST_FLAGS =
 # this function compiles a particular test lib
 compile_lib = cd test && rustc -O --emit=mir --crate-type=lib $(1).rs && $(DEBUGER) rustc $(RUST_FLAGS) --crate-type lib -O -Z codegen-backend=$(CODEGEN_BACKEND) $(1).rs -o libs/$(1).rlib
 
-test: setup build_backend identity branches binops casts types calls references structs libc nbody hello
-setup:
-	cd test && mkdir -p libs
-build_backend:
-	cargo build
-calls:
-	$(call compile_lib,calls)
-libc:
-	$(call compile_lib,libc)
-identity:
-	$(call compile_lib,identity)
-binops:
-	$(call compile_lib,binops)
-references:
-	$(call compile_lib,references)
-nbody:
-	$(call compile_lib,nbody)
-casts:
-	$(call compile_lib,casts)
-types:
-	$(call compile_lib,types)
-branches:
-	$(call compile_lib,branches)
-structs:
-	$(call compile_lib,structs)
+test: hello
 hello:
 	cd test && $(DEBUGER) rustc $(RUST_FLAGS) -O -Z codegen-backend=$(CODEGEN_BACKEND) hello.rs && \
 	ilasm hello && \

src/assembly_exporter/ilasm_exporter.rs

@@ -1,4 +1,7 @@
-use crate::{base_ir::BaseIR, clr_method::CLRMethod, types::Type, IString};
+use crate::{
+    assembly_exporter::AssemblyExportError, base_ir::BaseIR, clr_method::CLRMethod, types::Type,
+    IString,
+};
 
 use super::{AssemblyExporter, ClassInfo};
 #[must_use]
@@ -22,13 +25,14 @@ impl AssemblyExporter for ILASMExporter {
     fn add_method(&mut self, method: CLRMethod) {
         self.methods.push(method);
     }
-    fn finalize(self, final_path: &std::path::Path) -> Result<(), super::AssemblyExportError> {
+    fn finalize(self, final_path: &std::path::Path) -> Result<(), AssemblyExportError> {
         use std::io::Write;
         //println!("final_path:{final_path:?}");
-        let directory = final_path
+        let directory = absolute_path(final_path)
+            .map_err(|io| AssemblyExportError::CouldNotCanonalizePath(io, final_path.to_owned()))?
             .parent()
             .expect("Can't get the target directory")
-            .canonicalize()?;
+            .to_owned();
 
         let mut out_path = directory.clone();
         out_path.set_file_name(final_path.file_name().expect("Target file has no name!"));
@@ -39,11 +43,12 @@ impl AssemblyExporter for ILASMExporter {
         ); //final_path.expect("Could not canonialize path!");
 
         let cil_path = out_path.with_extension("il");
-        let cil = self.get_cil()?;
+        let cil = self.get_cil().expect("Could not get cil");
         println!("cil_path:{cil_path:?}");
         std::fs::File::create(&cil_path)
             .expect("Could not create file")
-            .write_all(cil.as_bytes())?;
+            .write_all(cil.as_bytes())
+            .expect("Could not write bytes");
         let asm_type = "/dll";
         let target = format!(
             "/output:{out_path}",
@@ -61,6 +66,15 @@ impl AssemblyExporter for ILASMExporter {
         Ok(())
     }
 }
+fn absolute_path(path: &std::path::Path) -> std::io::Result<std::path::PathBuf> {
+    if path.has_root() {
+        Ok(path.to_owned())
+    } else {
+        let mut abs_path = std::env::current_dir()?;
+        abs_path.extend(path);
+        Ok(abs_path)
+    }
+}
 impl ILASMExporter {
     fn version(&self) -> (u8, u8, u8, u8) {
         (0, 0, 0, 0)

src/assembly_exporter/mod.rs

@@ -60,12 +60,15 @@ pub(crate) trait AssemblyExporter: Sized {
         for method in asm.methods() {
             asm_exporter.add_method(method.clone());
         }
-        asm_exporter.finalize(final_path)
+        Ok(asm_exporter
+            .finalize(final_path)
+            .expect("Could not export assembly"))
     }
 }
 #[derive(Debug)]
 pub(crate) enum AssemblyExportError {
     InvalidIL,
+    CouldNotCanonalizePath(std::io::Error, std::path::PathBuf),
     IoError(std::io::Error),
 }
 impl From<std::io::Error> for AssemblyExportError {

src/compile_test.rs

@@ -0,0 +1,49 @@
+macro_rules! test_lib {
+    ($test_name:ident) => {
+        #[test]
+        fn $test_name() {
+            // Ensures the test directory is present
+            std::fs::create_dir_all("./test/out").expect("Could not setup the test env");
+            // Builds the backend if neceasry
+            std::process::Command::new("cargo")
+                .args(["build"])
+                .output()
+                .expect("could not build the backend");
+            // Compiles the test project
+            let out = std::process::Command::new("rustc")
+                .current_dir("./test/out")
+                .args([
+                    "-O",
+                    "--crate-type=lib",
+                    "-Z",
+                    BACKEND_PATH,
+                    concat!("../", stringify!($test_name), ".rs"),
+                    "-o",
+                    concat!("./", stringify!($test_name), ".dll"),
+                ])
+                .output()
+                .expect("failed to execute process");
+            // If stderr is not empty, then something went wrong, so print the stdout and stderr for debuging.
+            if !out.stderr.is_empty() {
+                let stdout = String::from_utf8(out.stdout)
+                    .expect("rustc error contained non-UTF8 characters.");
+                let stderr = String::from_utf8(out.stderr)
+                    .expect("rustc error contained non-UTF8 characters.");
+                panic!("stdout:\n{stdout}\nstderr:\n{stderr}");
+            }
+        }
+    };
+}
+#[cfg(test)]
+const BACKEND_PATH: &str = "codegen-backend=../../target/debug/librustc_codegen_clr.so";
+test_lib! {binops}
+test_lib! {branches}
+test_lib! {calls}
+test_lib! {casts}
+test_lib! {identity}
+test_lib! {libc}
+test_lib! {nbody}
+test_lib! {references}
+test_lib! {structs}
+
+test_lib! {types}

src/lib.rs

@@ -46,6 +46,7 @@ use assembly::*;
 mod base_ir;
 use base_ir::BaseIR;
 mod assembly_exporter;
+mod compile_test;
 mod projection;
 mod statement;
 mod types;
@@ -205,7 +206,7 @@ impl CodegenBackend for MyBackend {
             &final_assembly,
             &path,
         )
-        .expect("Could not create the final assembly!");
+        .expect("Could not create the final asm!");
         Ok(())
     }
 }

test/calls.rs

@@ -1,7 +1,7 @@
 fn test(){}
 pub extern "C" fn call_test(){test()}
 fn sqr_mag(x:f32,y:f32)->f32{x*x + y*y}
-pub extern "C" fn distance(x1:f32,y1:f32,x2:f32,y2:f32)->f32{sqr_mag(x1 - x2,y1 - y1)}
+pub extern "C" fn distance(x1:f32,y1:f32,x2:f32,y2:f32)->f32{sqr_mag(x1 - x2,y1 - y2)}
 /*
 #[no_mangle]
 pub extern fn for_loop()->i32{