restructure how load is used

Cargo.lock

@@ -3675,6 +3675,7 @@ version = "0.1.0"
 dependencies = [
  "bumpalo",
  "roc_builtins",
+ "roc_constrain",
  "roc_load_internal",
  "roc_module",
  "roc_target",

compiler/load/Cargo.toml

@@ -7,6 +7,9 @@ edition = "2018"
 
 [dependencies]
 roc_load_internal = { path = "../load_internal" }
+bumpalo = { version = "3.8.0", features = ["collections"] }
+roc_target = { path = "../roc_target" }
+roc_constrain= { path = "../constrain" }
 
 [build-dependencies]
 roc_load_internal = { path = "../load_internal" }
@@ -14,4 +17,3 @@ roc_builtins = { path = "../builtins" }
 roc_module = { path = "../module" }
 bumpalo = { version = "3.8.0", features = ["collections"] }
 roc_target = { path = "../roc_target" }
-# roc_types = { path = "../types" }

compiler/load/src/lib.rs

@@ -1,6 +1,102 @@
-pub use roc_load_internal::file::{
+use bumpalo::Bump;
-    load_and_monomorphize, load_and_monomorphize_from_str, load_and_typecheck, LoadedModule,
+use roc_constrain::module::ExposedByModule;
-    LoadingProblem, MonomorphizedModule,
+use roc_target::TargetInfo;
-};
+use std::path::{Path, PathBuf};
 
 pub use roc_load_internal::docs;
+pub use roc_load_internal::file::{
+    LoadResult, LoadStart, LoadedModule, LoadingProblem, MonomorphizedModule, Phase,
+};
+
+fn load<'a>(
+    arena: &'a Bump,
+    load_start: LoadStart<'a>,
+    src_dir: &Path,
+    exposed_types: ExposedByModule,
+    goal_phase: Phase,
+    target_info: TargetInfo,
+) -> Result<LoadResult<'a>, LoadingProblem<'a>> {
+    // dbg!(env!("OUT_DIR"));
+    // TODO inject the stdlib subs
+    roc_load_internal::file::load(
+        arena,
+        load_start,
+        src_dir,
+        exposed_types,
+        goal_phase,
+        target_info,
+    )
+}
+
+pub fn load_and_monomorphize_from_str<'a>(
+    arena: &'a Bump,
+    filename: PathBuf,
+    src: &'a str,
+    src_dir: &Path,
+    exposed_types: ExposedByModule,
+    target_info: TargetInfo,
+) -> Result<MonomorphizedModule<'a>, LoadingProblem<'a>> {
+    use LoadResult::*;
+
+    let load_start = LoadStart::from_str(arena, filename, src)?;
+
+    match load(
+        arena,
+        load_start,
+        src_dir,
+        exposed_types,
+        Phase::MakeSpecializations,
+        target_info,
+    )? {
+        Monomorphized(module) => Ok(module),
+        TypeChecked(_) => unreachable!(""),
+    }
+}
+
+pub fn load_and_monomorphize<'a>(
+    arena: &'a Bump,
+    filename: PathBuf,
+    src_dir: &Path,
+    exposed_types: ExposedByModule,
+    target_info: TargetInfo,
+) -> Result<MonomorphizedModule<'a>, LoadingProblem<'a>> {
+    use LoadResult::*;
+
+    let load_start = LoadStart::from_path(arena, filename)?;
+
+    match load(
+        arena,
+        load_start,
+        src_dir,
+        exposed_types,
+        Phase::MakeSpecializations,
+        target_info,
+    )? {
+        Monomorphized(module) => Ok(module),
+        TypeChecked(_) => unreachable!(""),
+    }
+}
+
+pub fn load_and_typecheck<'a>(
+    arena: &'a Bump,
+    filename: PathBuf,
+    src_dir: &Path,
+    exposed_types: ExposedByModule,
+    target_info: TargetInfo,
+) -> Result<LoadedModule, LoadingProblem<'a>> {
+    use LoadResult::*;
+
+    let load_start = LoadStart::from_path(arena, filename)?;
+
+    match load(
+        arena,
+        load_start,
+        src_dir,
+        exposed_types,
+        Phase::SolveTypes,
+        target_info,
+    )? {
+        Monomorphized(_) => unreachable!(""),
+        TypeChecked(module) => Ok(module),
+    }
+}

compiler/load_internal/src/file.rs

@@ -47,7 +47,8 @@ use std::str::from_utf8_unchecked;
 use std::sync::Arc;
 use std::{env, fs};
 
-use crate::work::{Dependencies, Phase};
+use crate::work::Dependencies;
+pub use crate::work::Phase;
 
 #[cfg(target_family = "wasm")]
 use crate::wasm_system_time::{Duration, SystemTime};
@@ -808,30 +809,6 @@ fn enqueue_task<'a>(
     Ok(())
 }
 
-pub fn load_and_typecheck<'a>(
-    arena: &'a Bump,
-    filename: PathBuf,
-    src_dir: &Path,
-    exposed_types: ExposedByModule,
-    target_info: TargetInfo,
-) -> Result<LoadedModule, LoadingProblem<'a>> {
-    use LoadResult::*;
-
-    let load_start = LoadStart::from_path(arena, filename)?;
-
-    match load(
-        arena,
-        load_start,
-        src_dir,
-        exposed_types,
-        Phase::SolveTypes,
-        target_info,
-    )? {
-        Monomorphized(_) => unreachable!(""),
-        TypeChecked(module) => Ok(module),
-    }
-}
-
 pub fn load_and_typecheck_str<'a>(
     arena: &'a Bump,
     filename: PathBuf,
@@ -857,62 +834,11 @@ pub fn load_and_typecheck_str<'a>(
     }
 }
 
-/// Main entry point to the compiler from the CLI and tests
+pub struct LoadStart<'a> {
-pub fn load_and_monomorphize<'a>(
+    arc_modules: Arc<Mutex<PackageModuleIds<'a>>>,
-    arena: &'a Bump,
+    ident_ids_by_module: Arc<Mutex<MutMap<ModuleId, IdentIds>>>,
-    filename: PathBuf,
+    root_id: ModuleId,
-    src_dir: &Path,
+    root_msg: Msg<'a>,
-    exposed_types: ExposedByModule,
-    target_info: TargetInfo,
-) -> Result<MonomorphizedModule<'a>, LoadingProblem<'a>> {
-    use LoadResult::*;
-
-    let load_start = LoadStart::from_path(arena, filename)?;
-
-    match load(
-        arena,
-        load_start,
-        src_dir,
-        exposed_types,
-        Phase::MakeSpecializations,
-        target_info,
-    )? {
-        Monomorphized(module) => Ok(module),
-        TypeChecked(_) => unreachable!(""),
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn load_and_monomorphize_from_str<'a>(
-    arena: &'a Bump,
-    filename: PathBuf,
-    src: &'a str,
-    src_dir: &Path,
-    exposed_types: ExposedByModule,
-    target_info: TargetInfo,
-) -> Result<MonomorphizedModule<'a>, LoadingProblem<'a>> {
-    use LoadResult::*;
-
-    let load_start = LoadStart::from_str(arena, filename, src)?;
-
-    match load(
-        arena,
-        load_start,
-        src_dir,
-        exposed_types,
-        Phase::MakeSpecializations,
-        target_info,
-    )? {
-        Monomorphized(module) => Ok(module),
-        TypeChecked(_) => unreachable!(""),
-    }
-}
-
-struct LoadStart<'a> {
-    pub arc_modules: Arc<Mutex<PackageModuleIds<'a>>>,
-    pub ident_ids_by_module: Arc<Mutex<MutMap<ModuleId, IdentIds>>>,
-    pub root_id: ModuleId,
-    pub root_msg: Msg<'a>,
 }
 
 impl<'a> LoadStart<'a> {
@@ -999,7 +925,7 @@ impl<'a> LoadStart<'a> {
     }
 }
 
-enum LoadResult<'a> {
+pub enum LoadResult<'a> {
     TypeChecked(LoadedModule),
     Monomorphized(MonomorphizedModule<'a>),
 }
@@ -1048,7 +974,7 @@ enum LoadResult<'a> {
 ///     specializations, so if none of their specializations changed, we don't even need
 ///     to rebuild the module and can link in the cached one directly.)
 #[allow(clippy::too_many_arguments)]
-fn load<'a>(
+pub fn load<'a>(
     arena: &'a Bump,
     load_start: LoadStart<'a>,
     src_dir: &Path,
@@ -3214,11 +3140,12 @@ fn run_solve<'a>(
     let solved_subs = if true {
         solved_subs
     } else {
-        let mut serialized = Vec::new();
+        panic!();
-        solved_subs.inner().serialize(&mut serialized).unwrap();
+        //        let mut serialized = Vec::new();
-        let subs = Subs::deserialize(&serialized);
+        //        solved_subs.inner().serialize(&mut serialized).unwrap();
-
+        //        let subs = Subs::deserialize(&serialized);
-        Solved(subs)
+        //
+        //        Solved(subs)
     };
 
     let exposed_vars_by_symbol: Vec<_> = solved_env
@@ -3226,6 +3153,8 @@ fn run_solve<'a>(
         .filter(|(k, _)| exposed_symbols.contains(k))
         .collect();
 
+    dbg!(&exposed_vars_by_symbol);
+
     let mut solved_subs = solved_subs;
     let (storage_subs, stored_vars_by_symbol) =
         roc_solve::module::exposed_types_storage_subs(&mut solved_subs, &exposed_vars_by_symbol);