Fix web REPL error formatting by routing the active Palette everywhere

crates/compiler/load_internal/src/file.rs

@@ -44,7 +44,7 @@ use roc_parse::ident::UppercaseIdent;
 use roc_parse::module::module_defs;
 use roc_parse::parser::{FileError, Parser, SourceError, SyntaxError};
 use roc_region::all::{LineInfo, Loc, Region};
-use roc_reporting::report::{Annotation, RenderTarget};
+use roc_reporting::report::{Annotation, RenderTarget, Palette};
 use roc_solve::module::{extract_module_owned_implementations, Solved, SolvedModule};
 use roc_solve_problem::TypeError;
 use roc_target::TargetInfo;
@@ -88,6 +88,7 @@ macro_rules! log {
 pub struct LoadConfig {
     pub target_info: TargetInfo,
     pub render: RenderTarget,
+    pub palette: Palette,
     pub threading: Threading,
     pub exec_mode: ExecutionMode,
 }
@@ -930,6 +931,7 @@ struct State<'a> {
     pub layout_caches: std::vec::Vec<LayoutCache<'a>>,
 
     pub render: RenderTarget,
+    pub palette: Palette,
     pub exec_mode: ExecutionMode,
 
     /// All abilities across all modules.
@@ -959,6 +961,7 @@ impl<'a> State<'a> {
         ident_ids_by_module: SharedIdentIdsByModule,
         cached_types: MutMap<ModuleId, TypeState>,
         render: RenderTarget,
+        palette: Palette,
         number_of_workers: usize,
         exec_mode: ExecutionMode,
     ) -> Self {
@@ -990,6 +993,7 @@ impl<'a> State<'a> {
             layout_caches: std::vec::Vec::with_capacity(number_of_workers),
             cached_types: Arc::new(Mutex::new(cached_types)),
             render,
+            palette,
             exec_mode,
             make_specializations_pass: MakeSpecializationsPass::Pass(1),
             world_abilities: Default::default(),
@@ -1199,6 +1203,7 @@ pub fn load_and_typecheck_str<'a>(
     exposed_types: ExposedByModule,
     target_info: TargetInfo,
     render: RenderTarget,
+    palette: Palette,
     threading: Threading,
 ) -> Result<LoadedModule, LoadingProblem<'a>> {
     use LoadResult::*;
@@ -1212,6 +1217,7 @@ pub fn load_and_typecheck_str<'a>(
     let load_config = LoadConfig {
         target_info,
         render,
+        palette,
         threading,
         exec_mode: ExecutionMode::Check,
     };
@@ -1241,6 +1247,7 @@ impl<'a> LoadStart<'a> {
         arena: &'a Bump,
         filename: PathBuf,
         render: RenderTarget,
+        palette: Palette,
     ) -> Result<Self, LoadingProblem<'a>> {
         let arc_modules = Arc::new(Mutex::new(PackageModuleIds::default()));
         let root_exposed_ident_ids = IdentIds::exposed_builtins(0);
@@ -1305,6 +1312,7 @@ impl<'a> LoadStart<'a> {
                         module_ids,
                         root_exposed_ident_ids,
                         render,
+                        palette,
                     );
                     return Err(LoadingProblem::FormattedReport(buf));
                 }
@@ -1501,6 +1509,7 @@ pub fn load<'a>(
             load_config.target_info,
             cached_types,
             load_config.render,
+            load_config.palette,
             load_config.exec_mode,
         ),
         Threads::Many(threads) => load_multi_threaded(
@@ -1510,6 +1519,7 @@ pub fn load<'a>(
             load_config.target_info,
             cached_types,
             load_config.render,
+            load_config.palette,
             threads,
             load_config.exec_mode,
         ),
@@ -1525,6 +1535,7 @@ pub fn load_single_threaded<'a>(
     target_info: TargetInfo,
     cached_types: MutMap<ModuleId, TypeState>,
     render: RenderTarget,
+    palette: Palette,
     exec_mode: ExecutionMode,
 ) -> Result<LoadResult<'a>, LoadingProblem<'a>> {
     let LoadStart {
@@ -1551,6 +1562,7 @@ pub fn load_single_threaded<'a>(
         ident_ids_by_module,
         cached_types,
         render,
+        palette,
         number_of_workers,
         exec_mode,
     );
@@ -1666,6 +1678,7 @@ fn state_thread_step<'a>(
                         module_ids,
                         state.constrained_ident_ids,
                         state.render,
+                        state.palette,
                     );
                     Err(LoadingProblem::FormattedReport(buf))
                 }
@@ -1691,6 +1704,7 @@ fn state_thread_step<'a>(
                     let arc_modules = state.arc_modules.clone();
 
                     let render = state.render;
+                    let palette = state.palette;
 
                     let res_state = update(
                         state,
@@ -1720,6 +1734,7 @@ fn state_thread_step<'a>(
                                 module_ids,
                                 root_exposed_ident_ids,
                                 render,
+                                palette,
                             );
                             Err(LoadingProblem::FormattedReport(buf))
                         }
@@ -1773,6 +1788,7 @@ fn load_multi_threaded<'a>(
     target_info: TargetInfo,
     cached_types: MutMap<ModuleId, TypeState>,
     render: RenderTarget,
+    palette: Palette,
     available_threads: usize,
     exec_mode: ExecutionMode,
 ) -> Result<LoadResult<'a>, LoadingProblem<'a>> {
@@ -1815,6 +1831,7 @@ fn load_multi_threaded<'a>(
         ident_ids_by_module,
         cached_types,
         render,
+        palette,
         num_workers,
         exec_mode,
     );
@@ -5867,8 +5884,9 @@ fn to_parse_problem_report<'a>(
     mut module_ids: ModuleIds,
     all_ident_ids: IdentIdsByModule,
     render: RenderTarget,
+    palette: Palette,
 ) -> String {
-    use roc_reporting::report::{parse_problem, RocDocAllocator, DEFAULT_PALETTE};
+    use roc_reporting::report::{parse_problem, RocDocAllocator};
 
     // TODO this is not in fact safe
     let src = unsafe { from_utf8_unchecked(problem.problem.bytes) };
@@ -5899,7 +5917,6 @@ fn to_parse_problem_report<'a>(
     );
 
     let mut buf = String::new();
-    let palette = DEFAULT_PALETTE;
 
     report.render(render, &mut buf, &alloc, &palette);