fortrangoingonforty/armfortas / 0ebb1f5

+# Ensure cargo bin dir is in PATH

+export PATH="$HOME/.cargo/bin:$PATH"

+

+//! Incremental compilation tests.

+//!

+//! Verifies that the .amod module file system handles incremental

+//! rebuilds correctly:

+//!   - Recompiling a module produces the same .amod when the public

+//!     interface is unchanged.

+//!   - Changing a module's public interface produces a different .amod.

+//!   - Changing only private implementation does NOT change .amod.

+//!   - A consumer recompiled against the same .amod produces the

+//!     same .o (no unnecessary recompilation cascade).

+

+use std::fs;

+use std::path::{Path, PathBuf};

+use std::process::Command;

+use std::sync::atomic::{AtomicU64, Ordering};

+

+static NEXT_ID: AtomicU64 = AtomicU64::new(0);

+

+fn unique_dir() -> PathBuf {

+    let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);

+    let dir = std::env::temp_dir().join(format!(

+        "afs_incr_{}_{}", std::process::id(), id

+    ));

+    fs::create_dir_all(&dir).unwrap();

+    dir

+}

+

+fn find_compiler() -> PathBuf {

+    for c in &["target/release/armfortas", "target/debug/armfortas"] {

+        let p = PathBuf::from(c);

+        if p.exists() { return fs::canonicalize(&p).unwrap(); }

+    }

+    panic!("armfortas binary not found");

+}

+

+fn compile(compiler: &Path, source: &Path, obj: &Path, search: &Path) {

+    let result = Command::new(compiler)

+        .args([

+            source.to_str().unwrap(), "-c", "-O0",

+            "-o", obj.to_str().unwrap(),

+            &format!("-I{}", search.display()),

+        ])

+        .output()

+        .expect("compiler launch failed");

+    assert!(

+        result.status.success(),

+        "compile {} failed:\n{}",

+        source.display(),

+        String::from_utf8_lossy(&result.stderr)

+    );

+}

+

+/// Extract the interface body from an .amod file (everything after the

+/// first blank line, which separates the header from the interface).

+fn extract_amod_body(amod: &[u8]) -> &[u8] {

+    let text = std::str::from_utf8(amod).unwrap_or("");

+    if let Some(idx) = text.find("\n\n") {

+        &amod[idx + 2..]

+    } else {

+        amod

+    }

+}

+

+/// Compile a module and return the .amod contents.

+fn compile_module(compiler: &Path, dir: &Path, name: &str, source: &str) -> Vec<u8> {

+    let f90 = dir.join(format!("{}.f90", name));

+    let obj = dir.join(format!("{}.o", name));

+    fs::write(&f90, source).unwrap();

+    compile(compiler, &f90, &obj, dir);

+    let amod = dir.join(format!("{}.amod", name));

+    fs::read(&amod).unwrap_or_else(|e| panic!("{}.amod not found: {}", name, e))

+}

+

+#[test]

+fn same_source_produces_identical_amod() {

+    let compiler = find_compiler();

+    let dir = unique_dir();

+    let src = "module m\n  implicit none\n  integer :: x = 42\nend module\n";

+

+    let amod1 = compile_module(&compiler, &dir, "m", src);

+    // Recompile with identical source.

+    let amod2 = compile_module(&compiler, &dir, "m", src);

+

+    assert_eq!(amod1, amod2, ".amod changed despite identical source");

+    let _ = fs::remove_dir_all(&dir);

+}

+

+#[test]

+fn changed_public_interface_changes_amod() {

+    let compiler = find_compiler();

+    let dir = unique_dir();

+

+    let v1 = "module m\n  implicit none\n  integer :: x = 42\nend module\n";

+    let v2 = "module m\n  implicit none\n  integer :: x = 42\n  integer :: y = 99\nend module\n";

+

+    let amod1 = compile_module(&compiler, &dir, "m", v1);

+    let amod2 = compile_module(&compiler, &dir, "m", v2);

+

+    assert_ne!(amod1, amod2, ".amod should differ when public interface changes");

+    let _ = fs::remove_dir_all(&dir);

+}

+

+#[test]

+fn changed_private_impl_does_not_change_amod() {

+    let compiler = find_compiler();

+    let dir = unique_dir();

+

+    let v1 = "\

+module m

+  implicit none

+  integer :: x = 42

+contains

+  subroutine bump()

+    x = x + 1

+  end subroutine

+end module

+";

+    let v2 = "\

+module m

+  implicit none

+  integer :: x = 42

+contains

+  subroutine bump()

+    x = x + 10

+  end subroutine

+end module

+";

+

+    let amod1 = compile_module(&compiler, &dir, "m", v1);

+    let amod2 = compile_module(&compiler, &dir, "m", v2);

+

+    // The header includes a source checksum which will differ. But the

+    // interface section (everything after the blank line separating the

+    // header from the body) should be identical.

+    let body1 = extract_amod_body(&amod1);

+    let body2 = extract_amod_body(&amod2);

+    assert_eq!(body1, body2, ".amod interface body changed but only private impl differs");

+    let _ = fs::remove_dir_all(&dir);

+}

+

+#[test]

+fn consumer_object_stable_when_amod_unchanged() {

+    let compiler = find_compiler();

+    let dir = unique_dir();

+

+    let mod_src = "module m\n  implicit none\n  integer :: x = 42\nend module\n";

+    let main_src = "program p\n  use m\n  implicit none\n  print *, x\nend program\n";

+

+    // Compile module.

+    compile_module(&compiler, &dir, "m", mod_src);

+

+    // Compile consumer.

+    let main_f90 = dir.join("main.f90");

+    let main_o = dir.join("main.o");

+    fs::write(&main_f90, main_src).unwrap();

+    compile(&compiler, &main_f90, &main_o, &dir);

+    let obj1 = fs::read(&main_o).unwrap();

+

+    // Recompile consumer without changing anything.

+    compile(&compiler, &main_f90, &main_o, &dir);

+    let obj2 = fs::read(&main_o).unwrap();

+

+    assert_eq!(obj1, obj2, "consumer .o changed despite no source/amod change");

+    let _ = fs::remove_dir_all(&dir);

+}

+

+#[test]

+fn consumer_object_changes_when_amod_changes() {

+    let compiler = find_compiler();

+    let dir = unique_dir();

+

+    let mod_v1 = "module m\n  implicit none\n  integer :: x = 42\nend module\n";

+    let mod_v2 = "module m\n  implicit none\n  integer :: x = 42\n  integer :: y = 99\nend module\n";

+    let main_src = "program p\n  use m\n  implicit none\n  print *, x\nend program\n";

+

+    // Compile module v1 and consumer.

+    compile_module(&compiler, &dir, "m", mod_v1);

+    let main_f90 = dir.join("main.f90");

+    let main_o = dir.join("main.o");

+    fs::write(&main_f90, main_src).unwrap();

+    compile(&compiler, &main_f90, &main_o, &dir);

+    let obj1 = fs::read(&main_o).unwrap();

+

+    // Recompile module with changed public interface.

+    compile_module(&compiler, &dir, "m", mod_v2);

+    // Recompile consumer against new .amod.

+    compile(&compiler, &main_f90, &main_o, &dir);

+    let obj2 = fs::read(&main_o).unwrap();

+

+    // The consumer .o may or may not change (depends on whether the

+    // consumer references the new symbol). But the .amod definitely

+    // changed, so this test documents the observation either way.

+    // The key point: no crash, no stale symbol resolution.

+    let _ = fs::remove_dir_all(&dir);

+}