Use single-threaded builds in tests

compiler/load/build.rs

@@ -1,6 +1,7 @@
 use std::path::PathBuf;
 
 use bumpalo::Bump;
+use roc_load_internal::file::Threading;
 use roc_module::symbol::ModuleId;
 
 const MODULES: &[(ModuleId, &str)] = &[
@@ -37,6 +38,7 @@ fn write_subs_for_module(module_id: ModuleId, filename: &str) {
         Default::default(),
         target_info,
         roc_reporting::report::RenderTarget::ColorTerminal,
+        Threading::Multi,
     );
 
     let module = res_module.unwrap();

compiler/load/src/lib.rs

@@ -1,3 +1,5 @@
+pub use roc_load_internal::file::Threading;
+
 use bumpalo::Bump;
 use roc_collections::all::MutMap;
 use roc_constrain::module::ExposedByModule;
@@ -20,6 +22,7 @@ fn load<'a>(
     goal_phase: Phase,
     target_info: TargetInfo,
     render: RenderTarget,
+    threading: Threading,
 ) -> Result<LoadResult<'a>, LoadingProblem<'a>> {
     let cached_subs = read_cached_subs();
 
@@ -32,6 +35,7 @@ fn load<'a>(
         target_info,
         cached_subs,
         render,
+        threading,
     )
 }
 
@@ -67,6 +71,7 @@ pub fn load_and_monomorphize_from_str<'a>(
     exposed_types: ExposedByModule,
     target_info: TargetInfo,
     render: RenderTarget,
+    threading: Threading,
 ) -> Result<MonomorphizedModule<'a>, LoadingProblem<'a>> {
     use LoadResult::*;
 
@@ -80,6 +85,7 @@ pub fn load_and_monomorphize_from_str<'a>(
         Phase::MakeSpecializations,
         target_info,
         render,
+        threading,
     )? {
         Monomorphized(module) => Ok(module),
         TypeChecked(_) => unreachable!(""),
@@ -93,6 +99,7 @@ pub fn load_and_monomorphize<'a>(
     exposed_types: ExposedByModule,
     target_info: TargetInfo,
     render: RenderTarget,
+    threading: Threading,
 ) -> Result<MonomorphizedModule<'a>, LoadingProblem<'a>> {
     use LoadResult::*;
 
@@ -106,6 +113,7 @@ pub fn load_and_monomorphize<'a>(
         Phase::MakeSpecializations,
         target_info,
         render,
+        threading,
     )? {
         Monomorphized(module) => Ok(module),
         TypeChecked(_) => unreachable!(""),
@@ -119,6 +127,7 @@ pub fn load_and_typecheck<'a>(
     exposed_types: ExposedByModule,
     target_info: TargetInfo,
     render: RenderTarget,
+    threading: Threading,
 ) -> Result<LoadedModule, LoadingProblem<'a>> {
     use LoadResult::*;
 
@@ -132,6 +141,7 @@ pub fn load_and_typecheck<'a>(
         Phase::SolveTypes,
         target_info,
         render,
+        threading,
     )? {
         Monomorphized(_) => unreachable!(""),
         TypeChecked(module) => Ok(module),

compiler/load_internal/src/file.rs

@@ -956,6 +956,7 @@ pub fn load_and_typecheck_str<'a>(
     exposed_types: ExposedByModule,
     target_info: TargetInfo,
     render: RenderTarget,
+    threading: Threading,
 ) -> Result<LoadedModule, LoadingProblem<'a>> {
     use LoadResult::*;
 
@@ -974,6 +975,7 @@ pub fn load_and_typecheck_str<'a>(
         target_info,
         cached_subs,
         render,
+        threading,
     )? {
         Monomorphized(_) => unreachable!(""),
         TypeChecked(module) => Ok(module),
@@ -1091,6 +1093,12 @@ pub enum LoadResult<'a> {
     Monomorphized(MonomorphizedModule<'a>),
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum Threading {
+    Single,
+    Multi,
+}
+
 /// The loading process works like this, starting from the given filename (e.g. "main.roc"):
 ///
 /// 1. Open the file.
@@ -1144,10 +1152,11 @@ pub fn load<'a>(
     target_info: TargetInfo,
     cached_subs: MutMap<ModuleId, (Subs, Vec<(Symbol, Variable)>)>,
     render: RenderTarget,
+    threading: Threading,
 ) -> Result<LoadResult<'a>, LoadingProblem<'a>> {
     // When compiling to wasm, we cannot spawn extra threads
     // so we have a single-threaded implementation
-    if cfg!(target_family = "wasm") {
+    if threading == Threading::Single || cfg!(target_family = "wasm") {
         load_single_threaded(
             arena,
             load_start,

compiler/load_internal/tests/test_load.rs

@@ -19,6 +19,7 @@ mod test_load {
     use roc_can::def::Declaration::*;
     use roc_can::def::Def;
     use roc_constrain::module::ExposedByModule;
+    use roc_load_internal::file::Threading;
     use roc_load_internal::file::{LoadResult, LoadStart, LoadedModule, LoadingProblem, Phase};
     use roc_module::ident::ModuleName;
     use roc_module::symbol::{Interns, ModuleId};
@@ -53,6 +54,7 @@ mod test_load {
             target_info,
             Default::default(), // these tests will re-compile the builtins
             RenderTarget::Generic,
+            Threading::Single,
         )? {
             Monomorphized(_) => unreachable!(""),
             TypeChecked(module) => Ok(module),

compiler/test_gen/src/helpers/dev.rs

@@ -2,6 +2,7 @@ use libloading::Library;
 use roc_build::link::{link, LinkType};
 use roc_builtins::bitcode;
 use roc_collections::all::MutMap;
+use roc_load::Threading;
 use roc_region::all::LineInfo;
 use tempfile::tempdir;
 
@@ -55,6 +56,7 @@ pub fn helper(
         Default::default(),
         roc_target::TargetInfo::default_x86_64(),
         roc_reporting::report::RenderTarget::ColorTerminal,
+        Threading::Single,
     );
 
     let mut loaded = loaded.expect("failed to load module");

compiler/test_gen/src/helpers/llvm.rs

@@ -5,6 +5,7 @@ use roc_build::link::module_to_dylib;
 use roc_build::program::FunctionIterator;
 use roc_collections::all::MutSet;
 use roc_gen_llvm::llvm::externs::add_default_roc_externs;
+use roc_load::Threading;
 use roc_mono::ir::OptLevel;
 use roc_region::all::LineInfo;
 use roc_reporting::report::RenderTarget;
@@ -59,6 +60,7 @@ fn create_llvm_module<'a>(
         Default::default(),
         target_info,
         RenderTarget::ColorTerminal,
+        Threading::Multi,
     );
 
     let mut loaded = match loaded {

compiler/test_mono/src/tests.rs

@@ -16,9 +16,9 @@ const EXPANDED_STACK_SIZE: usize = 8 * 1024 * 1024;
 use test_mono_macros::*;
 
 use roc_collections::all::MutMap;
+use roc_load::Threading;
 use roc_module::symbol::Symbol;
 use roc_mono::ir::Proc;
-
 use roc_mono::ir::ProcLayout;
 
 const TARGET_INFO: roc_target::TargetInfo = roc_target::TargetInfo::default_x86_64();
@@ -99,6 +99,7 @@ fn compiles_to_ir(test_name: &str, src: &str) {
         Default::default(),
         TARGET_INFO,
         roc_reporting::report::RenderTarget::Generic,
+        Threading::Single,
     );
 
     let mut loaded = match loaded {