Make sure tempfiles don't get dropped too early

crates/cli/src/build.rs

@@ -14,7 +14,6 @@ use roc_target::TargetInfo;
 use std::time::{Duration, Instant};
 use std::{path::PathBuf, thread::JoinHandle};
 use target_lexicon::Triple;
-use tempfile::Builder;
 
 fn report_timing(buf: &mut String, label: &str, duration: Duration) {
     use std::fmt::Write;
@@ -328,7 +327,7 @@ pub fn build_file<'a>(
             problems
         }
         (LinkingStrategy::Legacy, _) => {
-            let app_o_file = Builder::new()
+            let app_o_file = tempfile::Builder::new()
                 .prefix("roc_app")
                 .suffix(&format!(".{}", app_extension))
                 .tempfile()
@@ -342,27 +341,31 @@ pub fn build_file<'a>(
                 app_o_file.to_str().unwrap(),
             ];
 
-            let builtins_host_file = tempfile::Builder::new()
+            let builtins_host_tempfile = tempfile::Builder::new()
                 .prefix("host_bitcode")
                 .suffix(".o")
                 .rand_bytes(5)
                 .tempfile()
                 .unwrap();
-            std::fs::write(builtins_host_file.path(), bitcode::HOST_UNIX)
+            std::fs::write(builtins_host_tempfile.path(), bitcode::HOST_UNIX)
                 .expect("failed to write host builtins object to tempfile");
 
             if matches!(code_gen_options.backend, program::CodeGenBackend::Assembly) {
-                inputs.push(builtins_host_file.path().to_str().unwrap());
+                inputs.push(builtins_host_tempfile.path().to_str().unwrap());
             }
 
             let (mut child, _) =  // TODO use lld
-            link(target, binary_path.clone(), &inputs, link_type)
+                link(target, binary_path.clone(), &inputs, link_type)
-                .map_err(|_| todo!("gracefully handle `ld` failing to spawn."))?;
+                    .map_err(|_| todo!("gracefully handle `ld` failing to spawn."))?;
 
             let exit_status = child
                 .wait()
                 .map_err(|_| todo!("gracefully handle error after `ld` spawned"))?;
 
+            // Extend the lifetime of the tempfile so it doesn't get dropped
+            // (and thus deleted) before the child process is done using it!
+            let _ = builtins_host_tempfile;
+
             if exit_status.success() {
                 problems
             } else {

crates/compiler/build/src/link.rs

@@ -1417,19 +1417,19 @@ pub fn preprocess_host_wasm32(host_input_path: &Path, preprocessed_host_path: &P
             (but seems to be an unofficial API)
     */
 
-    let builtins_host_file = tempfile::Builder::new()
+    let builtins_host_tempfile = tempfile::Builder::new()
         .prefix("host_bitcode")
         .suffix(".wasm")
         .rand_bytes(5)
         .tempfile()
         .unwrap();
-    std::fs::write(builtins_host_file.path(), bitcode::HOST_WASM)
+    std::fs::write(builtins_host_tempfile.path(), bitcode::HOST_WASM)
         .expect("failed to write host builtins object to tempfile");
 
     let mut zig_cmd = zig();
     let args = &[
         "wasm-ld",
-        builtins_host_file.path().to_str().unwrap(),
+        builtins_host_tempfile.path().to_str().unwrap(),
         host_input,
         WASI_LIBC_PATH,
         WASI_COMPILER_RT_PATH, // builtins need __multi3, __udivti3, __fixdfti
@@ -1446,7 +1446,11 @@ pub fn preprocess_host_wasm32(host_input_path: &Path, preprocessed_host_path: &P
     // println!("\npreprocess_host_wasm32");
     // println!("zig {}\n", args.join(" "));
 
-    run_build_command(zig_cmd, output_file, 0)
+    run_build_command(zig_cmd, output_file, 0);
+
+    // Extend the lifetime of the tempfile so it doesn't get dropped
+    // (and thus deleted) before the Zig process is done using it!
+    let _ = builtins_host_tempfile;
 }
 
 fn run_build_command(mut command: Command, file_to_build: &str, flaky_fail_counter: usize) {

crates/compiler/test_gen/build.rs

@@ -100,18 +100,18 @@ fn build_wasm_test_host() {
     let mut outfile = PathBuf::from(&out_dir).join(PLATFORM_FILENAME);
     outfile.set_extension("wasm");
 
-    let builtins_host_file = tempfile::Builder::new()
+    let builtins_host_tempfile = tempfile::Builder::new()
         .prefix("host_bitcode")
         .suffix(".wasm")
         .rand_bytes(5)
         .tempfile()
         .unwrap();
-    std::fs::write(builtins_host_file.path(), bitcode::HOST_WASM)
+    std::fs::write(builtins_host_tempfile.path(), bitcode::HOST_WASM)
         .expect("failed to write host builtins object to tempfile");
 
     run_zig(&[
         "wasm-ld",
-        builtins_host_file.path().to_str().unwrap(),
+        builtins_host_tempfile.path().to_str().unwrap(),
         platform_path.to_str().unwrap(),
         WASI_COMPILER_RT_PATH,
         WASI_LIBC_PATH,
@@ -120,6 +120,10 @@ fn build_wasm_test_host() {
         "--no-entry",
         "--relocatable",
     ]);
+
+    // Extend the lifetime of the tempfile so it doesn't get dropped
+    // (and thus deleted) before the Zig process is done using it!
+    let _ = builtins_host_tempfile;
 }
 
 fn build_wasm_platform(out_dir: &str, source_path: &str) -> PathBuf {

crates/compiler/test_gen/src/helpers/dev.rs

@@ -193,13 +193,13 @@ pub fn helper(
         .expect("failed to build output object");
     std::fs::write(&app_o_file, module_out).expect("failed to write object to file");
 
-    let builtins_host_file = tempfile::Builder::new()
+    let builtins_host_tempfile = tempfile::Builder::new()
         .prefix("host_bitcode")
         .suffix(".o")
         .rand_bytes(5)
         .tempfile()
         .unwrap();
-    std::fs::write(builtins_host_file.path(), bitcode::HOST_UNIX)
+    std::fs::write(builtins_host_tempfile.path(), bitcode::HOST_UNIX)
         .expect("failed to write host builtins object to tempfile");
 
     let (mut child, dylib_path) = link(
@@ -209,7 +209,7 @@ pub fn helper(
         // With the current method all methods are kept and it adds about 100k to all outputs.
         &[
             app_o_file.to_str().unwrap(),
-            builtins_host_file.path().to_str().unwrap(),
+            builtins_host_tempfile.path().to_str().unwrap(),
         ],
         LinkType::Dylib,
     )
@@ -217,6 +217,10 @@ pub fn helper(
 
     child.wait().unwrap();
 
+    // Extend the lifetime of the tempfile so it doesn't get dropped
+    // (and thus deleted) before the linking process is done using it!
+    let _ = builtins_host_tempfile;
+
     // Load the dylib
     let path = dylib_path.as_path().to_str().unwrap();
 

crates/linker/src/generate_dylib/macho.rs

@@ -4,19 +4,17 @@ use roc_error_macros::internal_error;
 use std::path::Path;
 use std::process::Command;
 use target_lexicon::Triple;
-use tempfile::Builder;
 
 // TODO: Eventually do this from scratch and in memory instead of with ld.
 pub fn create_dylib_macho(
     custom_names: &[String],
     triple: &Triple,
 ) -> object::read::Result<Vec<u8>> {
-    let dummy_obj_file = Builder::new()
+    let dummy_obj_file = tempfile::Builder::new()
         .prefix("roc_lib")
         .suffix(".o")
         .tempfile()
         .unwrap_or_else(|e| internal_error!("{}", e));
-    let dummy_obj_file = dummy_obj_file.path();
     let tmp = tempfile::tempdir().unwrap_or_else(|e| internal_error!("{}", e));
     let dummy_lib_file = tmp.path().to_path_buf().with_file_name("libapp.so");
 
@@ -47,7 +45,7 @@ pub fn create_dylib_macho(
     }
 
     std::fs::write(
-        dummy_obj_file,
+        dummy_obj_file.path(),
         out_object.write().expect("failed to build output object"),
     )
     .expect("failed to write object to file");
@@ -70,13 +68,17 @@ pub fn create_dylib_macho(
         .args([
             ld_flag_soname,
             dummy_lib_file.file_name().unwrap().to_str().unwrap(),
-            dummy_obj_file.to_str().unwrap(),
+            dummy_obj_file.path().to_str().unwrap(),
             "-o",
             dummy_lib_file.to_str().unwrap(),
         ])
         .output()
         .unwrap();
 
+    // Extend the lifetime of the tempfile so it doesn't get dropped
+    // (and thus deleted) before the linker process is done using it!
+    let _ = dummy_obj_file;
+
     if !output.status.success() {
         match std::str::from_utf8(&output.stderr) {
             Ok(stderr) => panic!(

crates/repl_wasm/build.rs

@@ -23,19 +23,19 @@ fn main() {
     pre_linked_binary_path.extend(["pre_linked_binary"]);
     pre_linked_binary_path.set_extension("o");
 
-    let builtins_host_file = tempfile::Builder::new()
+    let builtins_host_tempfile = tempfile::Builder::new()
         .prefix("host_bitcode")
         .suffix(".wasm")
         .rand_bytes(5)
         .tempfile()
         .unwrap();
-    std::fs::write(builtins_host_file.path(), bitcode::HOST_WASM)
+    std::fs::write(builtins_host_tempfile.path(), bitcode::HOST_WASM)
         .expect("failed to write host builtins object to tempfile");
 
     let output = Command::new(&zig_executable())
         .args([
             "wasm-ld",
-            builtins_host_file.path().to_str().unwrap(),
+            builtins_host_tempfile.path().to_str().unwrap(),
             platform_obj.to_str().unwrap(),
             WASI_COMPILER_RT_PATH,
             WASI_LIBC_PATH,
@@ -48,6 +48,10 @@ fn main() {
         .output()
         .unwrap();
 
+    // Extend the lifetime of the tempfile so it doesn't get dropped
+    // (and thus deleted) before the Zig process is done using it!
+    let _ = builtins_host_tempfile;
+
     assert!(output.status.success(), "{:#?}", output);
     assert!(output.stdout.is_empty(), "{:#?}", output);
     assert!(output.stderr.is_empty(), "{:#?}", output);