fix tests

crates/compiler/load_internal/tests/test_load.rs

@@ -17,8 +17,8 @@ mod helpers;
 use crate::helpers::fixtures_dir;
 use bumpalo::Bump;
 use roc_can::module::ExposedByModule;
-use roc_load_internal::file::Threading;
+use roc_load_internal::file::{ExecutionMode, LoadConfig, Threading};
-use roc_load_internal::file::{LoadResult, LoadStart, LoadedModule, LoadingProblem, Phase};
+use roc_load_internal::file::{LoadResult, LoadStart, LoadedModule, LoadingProblem};
 use roc_module::ident::ModuleName;
 use roc_module::symbol::{Interns, ModuleId};
 use roc_problem::can::Problem;
@@ -41,16 +41,19 @@ fn load_and_typecheck(
     use LoadResult::*;
 
     let load_start = LoadStart::from_path(arena, filename, RenderTarget::Generic)?;
+    let load_config = LoadConfig {
+        target_info,
+        render: RenderTarget::Generic,
+        threading: Threading::Single,
+        exec_mode: ExecutionMode::Check,
+    };
 
     match roc_load_internal::file::load(
         arena,
         load_start,
         exposed_types,
-        Phase::SolveTypes,
-        target_info,
         Default::default(), // these tests will re-compile the builtins
-        RenderTarget::Generic,
+        load_config,
-        Threading::Single,
     )? {
         Monomorphized(_) => unreachable!(""),
         TypeChecked(module) => Ok(module),

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

@@ -7,7 +7,7 @@ use roc_build::program::FunctionIterator;
 use roc_collections::all::MutSet;
 use roc_gen_llvm::llvm::build::LlvmBackendMode;
 use roc_gen_llvm::llvm::externs::add_default_roc_externs;
-use roc_load::Threading;
+use roc_load::{EntryPoint, ExecutionMode, LoadConfig, Threading};
 use roc_mono::ir::OptLevel;
 use roc_region::all::LineInfo;
 use roc_reporting::report::RenderTarget;
@@ -66,15 +66,19 @@ fn create_llvm_module<'a>(
         module_src = &temp;
     }
 
+    let load_config = LoadConfig {
+        target_info,
+        render: RenderTarget::ColorTerminal,
+        threading: Threading::Single,
+        exec_mode: ExecutionMode::Executable,
+    };
     let loaded = roc_load::load_and_monomorphize_from_str(
         arena,
         filename,
         module_src,
         src_dir,
         Default::default(),
-        target_info,
+        load_config,
-        RenderTarget::ColorTerminal,
-        Threading::Single,
     );
 
     let mut loaded = match loaded {
@@ -226,6 +230,14 @@ fn create_llvm_module<'a>(
     // platform to provide them.
     add_default_roc_externs(&env);
 
+    let entry_point = match entry_point {
+        EntryPoint::Executable { symbol, layout, .. } => {
+            roc_mono::ir::EntryPoint { symbol, layout }
+        }
+        EntryPoint::Test => {
+            unreachable!()
+        }
+    };
     let (main_fn_name, main_fn) = match config.mode {
         LlvmBackendMode::Binary => unreachable!(),
         LlvmBackendMode::CliTest => unreachable!(),

crates/compiler/test_mono/src/tests.rs

@@ -13,6 +13,8 @@ extern crate indoc;
 #[allow(dead_code)]
 const EXPANDED_STACK_SIZE: usize = 8 * 1024 * 1024;
 
+use roc_load::ExecutionMode;
+use roc_load::LoadConfig;
 use test_mono_macros::*;
 
 use roc_collections::all::MutMap;
@@ -91,15 +93,19 @@ fn compiles_to_ir(test_name: &str, src: &str) {
         module_src = &temp;
     }
 
+    let load_config = LoadConfig {
+        target_info: TARGET_INFO,
+        threading: Threading::Single,
+        render: roc_reporting::report::RenderTarget::Generic,
+        exec_mode: ExecutionMode::Executable,
+    };
     let loaded = roc_load::load_and_monomorphize_from_str(
         arena,
         filename,
         module_src,
         src_dir,
         Default::default(),
-        TARGET_INFO,
+        load_config,
-        roc_reporting::report::RenderTarget::Generic,
-        Threading::Single,
     );
 
     let mut loaded = match loaded {

crates/repl_expect/src/lib.rs

@@ -80,7 +80,7 @@ mod test {
     use indoc::indoc;
     use pretty_assertions::assert_eq;
     use roc_gen_llvm::{llvm::build::LlvmBackendMode, run_roc::RocCallResult, run_roc_dylib};
-    use roc_load::Threading;
+    use roc_load::{ExecutionMode, LoadConfig, Threading};
     use roc_reporting::report::RenderTarget;
     use target_lexicon::Triple;
 
@@ -104,15 +104,19 @@ mod test {
 
         std::fs::write(&filename, source).unwrap();
 
+        let load_config = LoadConfig {
+            target_info,
+            render: RenderTarget::ColorTerminal,
+            threading: Threading::Single,
+            exec_mode: ExecutionMode::Executable,
+        };
         let loaded = roc_load::load_and_monomorphize_from_str(
             arena,
             filename,
             source,
             src_dir.path().to_path_buf(),
             Default::default(),
-            target_info,
+            load_config,
-            RenderTarget::ColorTerminal,
-            Threading::Single,
         )
         .unwrap();
 

crates/reporting/tests/test_reporting.rs

@@ -13,7 +13,7 @@ mod test_reporting {
     use indoc::indoc;
     use roc_can::abilities::AbilitiesStore;
     use roc_can::expr::PendingDerives;
-    use roc_load::{self, LoadedModule, LoadingProblem, Threading};
+    use roc_load::{self, ExecutionMode, LoadConfig, LoadedModule, LoadingProblem, Threading};
     use roc_module::symbol::{Interns, ModuleId};
     use roc_region::all::LineInfo;
     use roc_reporting::report::{
@@ -83,14 +83,14 @@ mod test_reporting {
             let full_file_path = file_path.clone();
             let mut file = File::create(file_path).unwrap();
             writeln!(file, "{}", module_src).unwrap();
-            let result = roc_load::load_and_typecheck(
+            let load_config = LoadConfig {
-                arena,
+                target_info: roc_target::TargetInfo::default_x86_64(),
-                full_file_path,
+                render: RenderTarget::Generic,
-                exposed_types,
+                threading: Threading::Single,
-                roc_target::TargetInfo::default_x86_64(),
+                exec_mode: ExecutionMode::Check,
-                RenderTarget::Generic,
+            };
-                Threading::Single,
+            let result =
-            );
+                roc_load::load_and_typecheck(arena, full_file_path, exposed_types, load_config);
             drop(file);
 
             result