:(

rust/Cargo.lock

@@ -1907,6 +1907,7 @@ dependencies = [
  "serde_json",
  "sha2",
  "tabled",
+ "tempdir",
  "thiserror 2.0.12",
  "tokio",
  "tokio-tungstenite",
@@ -3084,6 +3085,15 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "reqwest"
 version = "0.12.15"
@@ -3779,6 +3789,16 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
 
+[[package]]
+name = "tempdir"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8"
+dependencies = [
+ "rand 0.4.6",
+ "remove_dir_all",
+]
+
 [[package]]
 name = "tempfile"
 version = "3.19.0"

rust/Cargo.toml

@@ -22,7 +22,6 @@ debug = 0
 
 [profile.dev.package]
 insta = { opt-level = 3 }
-similar = { opt-level = 3 }
 
 [profile.test]
 debug = "line-tables-only"

rust/kcl-lib/Cargo.toml

@@ -69,6 +69,7 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 sha2 = "0.10.8"
 tabled = { version = "0.18.0", optional = true }
+tempdir = "0.3.7"
 thiserror = "2.0.0"
 toml = "0.8.19"
 ts-rs = { version = "10.1.0", features = [

rust/kcl-lib/src/execution/exec_ast.rs

@@ -2229,7 +2229,7 @@ mod test {
         parsing::ast::types::{DefaultParamVal, Identifier, Parameter},
     };
     use std::sync::Arc;
-    use tokio::{sync::RwLock, task::JoinSet};
+    use tokio::{io::AsyncWriteExt, sync::RwLock, task::JoinSet};
 
     #[tokio::test(flavor = "multi_thread")]
     async fn test_assign_args_to_params() {
@@ -2446,32 +2446,59 @@ a = foo()
         let mut universe = HashMap::<String, Node<Program>>::new();
 
         // program a.kcl
-        let programa = r#"
+        let programa_kcl = r#"
-a = 1
+export a = 1
 "#;
-        let programa = crate::parsing::parse_str(&programa, ModuleId::default())
+        let programa = crate::parsing::parse_str(&programa_kcl, ModuleId::default())
             .parse_errs_as_err()
             .unwrap();
         universe.insert("a.kcl".to_owned(), programa);
 
         // program b.kcl
-        let programb = r#"
+        let programb_kcl = r#"
-import 'a.kcl' as x
+import a from 'a.kcl'
+
+export b = a + 1
 "#;
-        let programb = crate::parsing::parse_str(&programb, ModuleId::default())
+        let programb = crate::parsing::parse_str(&programb_kcl, ModuleId::default())
             .parse_errs_as_err()
             .unwrap();
         universe.insert("b.kcl".to_owned(), programb);
 
         // program c.kcl
-        let programc = r#"
+        let programc_kcl = r#"
-import 'a.kcl'
+import a from 'a.kcl'
+
+export c = a + 2
 "#;
-        let programc = crate::parsing::parse_str(&programc, ModuleId::default())
+        let programc = crate::parsing::parse_str(&programc_kcl, ModuleId::default())
             .parse_errs_as_err()
             .unwrap();
         universe.insert("c.kcl".to_owned(), programc);
 
+        let tmpdir = tempdir::TempDir::new("zma_kcl_load_all_modules").unwrap();
+
+        tokio::fs::File::create(tmpdir.path().join("a.kcl"))
+            .await
+            .unwrap()
+            .write_all(programa_kcl.as_bytes())
+            .await
+            .unwrap();
+
+        tokio::fs::File::create(tmpdir.path().join("b.kcl"))
+            .await
+            .unwrap()
+            .write_all(programb_kcl.as_bytes())
+            .await
+            .unwrap();
+
+        tokio::fs::File::create(tmpdir.path().join("c.kcl"))
+            .await
+            .unwrap()
+            .write_all(programc_kcl.as_bytes())
+            .await
+            .unwrap();
+
         // ok we have all the "files" loaded, let's do a sort and concurrent
         // run here.
 
@@ -2490,7 +2517,7 @@ import 'a.kcl'
             fs: Arc::new(crate::fs::FileManager::new()),
             stdlib: Arc::new(RwLock::new(crate::std::StdLib::new())),
             settings: ExecutorSettings {
-                project_directory: Some("src/execution/_test/load_all_modules".parse().unwrap()),
+                project_directory: Some(tmpdir.path().into()),
                 ..Default::default()
             },
             context_type: ContextType::Mock,
@@ -2500,23 +2527,24 @@ import 'a.kcl'
         exec_ctxt.prepare_mem(&mut exec_state).await.unwrap();
 
         for modules in crate::walk::import_graph(&universe).unwrap().into_iter() {
-            eprintln!("Spawning {:?}", modules);
-
             let mut set = JoinSet::new();
+            let (results_send, mut results_recv) = tokio::sync::mpsc::channel(1);
+
             for module in modules {
                 let program = universe.get(&module).unwrap().clone();
                 let module = module.clone();
                 let mut exec_state = exec_state.clone();
                 let exec_ctxt = exec_ctxt.clone();
+                let results_send = results_send.clone();
 
                 set.spawn(async move {
                     let module = module;
                     let mut exec_state = exec_state;
                     let exec_ctxt = exec_ctxt;
                     let program = program;
+                    let results_send = results_send;
 
-                    // do we need to do anything with the result here?
+                    let result = exec_ctxt
-                    let _ = exec_ctxt
                         .run(
                             &crate::Program {
                                 ast: program.clone(),
@@ -2526,8 +2554,16 @@ import 'a.kcl'
                         )
                         .await
                         .unwrap();
+
+                    results_send.send((module, result)).await.unwrap();
                 });
             }
+            drop(results_send);
+
+            while let Some((module_name, module_result)) = results_recv.recv().await {
+                eprintln!("Got result for {}", module_name);
+                eprintln!("{:?}", module_result);
+            }
 
             set.join_all().await;
         }