language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-03 11:52:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Fix web REPL error formatting by routing the active Palette everywhere

Browse source
This commit is contained in:
Brian Carroll 2022-11-11 23:38:08 +00:00
parent 58ea07f14f
commit b64514d7e4
No known key found for this signature in database
GPG key ID: 9CF4E3BF9C4722C7
11 changed files with 43 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/ast/src/module.rs
View file

@ -1,5 +1,6 @@
use bumpalo::Bump;
use roc_load::{ExecutionMode, LoadConfig, LoadedModule, Threading};
use roc_reporting::report::DEFAULT_PALETTE;
use roc_target::TargetInfo;
use std::path::Path;
@ -9,6 +10,7 @@ pub fn load_module(src_file: &Path, threading: Threading) -> LoadedModule {
let load_config = LoadConfig {
target_info: TargetInfo::default_x86_64(), // editor only needs type info, so this is unused
render: roc_reporting::report::RenderTarget::ColorTerminal,
palette: DEFAULT_PALETTE,
threading,
exec_mode: ExecutionMode::Check,
};

4
crates/cli/src/build.rs
View file

@ -9,7 +9,7 @@ use roc_load::{
LoadingProblem, Threading,
};
use roc_mono::ir::OptLevel;
use roc_reporting::report::RenderTarget;
use roc_reporting::report::{RenderTarget, DEFAULT_PALETTE};
use roc_target::TargetInfo;
use std::time::{Duration, Instant};
use std::{path::PathBuf, thread::JoinHandle};
@ -81,6 +81,7 @@ pub fn build_file<'a>(
target_info,
// TODO: expose this from CLI?
render: RenderTarget::ColorTerminal,
palette: DEFAULT_PALETTE,
threading,
exec_mode,
};
@ -469,6 +470,7 @@ pub fn check_file(
target_info,
// TODO: expose this from CLI?
render: RenderTarget::ColorTerminal,
palette: DEFAULT_PALETTE,
threading,
exec_mode: ExecutionMode::Check,
};

1
crates/cli/src/lib.rs
View file

@ -408,6 +408,7 @@ pub fn test(matches: &ArgMatches, triple: Triple) -> io::Result<i32> {
target_info,
// TODO: expose this from CLI?
render: roc_reporting::report::RenderTarget::ColorTerminal,
palette: roc_reporting::report::DEFAULT_PALETTE,
threading,
exec_mode: ExecutionMode::Test,
};

1
crates/compiler/load/build.rs
View file

@ -85,6 +85,7 @@ fn write_types_for_module_real(module_id: ModuleId, filename: &str, output_path:
Default::default(),
target_info,
roc_reporting::report::RenderTarget::ColorTerminal,
roc_reporting::report::DEFAULT_PALETTE,
Threading::AllAvailable,
);

10
crates/compiler/load/src/lib.rs
View file

@ -4,7 +4,7 @@ use bumpalo::Bump;
use roc_can::module::{ExposedByModule, TypeState};
use roc_collections::all::MutMap;
use roc_module::symbol::ModuleId;
use roc_reporting::report::RenderTarget;
use roc_reporting::report::{RenderTarget, Palette};
use roc_target::TargetInfo;
use std::path::PathBuf;
@ -40,6 +40,7 @@ pub fn load_single_threaded<'a>(
exposed_types: ExposedByModule,
target_info: TargetInfo,
render: RenderTarget,
palette: Palette,
exec_mode: ExecutionMode,
) -> Result<LoadResult<'a>, LoadingProblem<'a>> {
let cached_subs = read_cached_types();
@ -51,6 +52,7 @@ pub fn load_single_threaded<'a>(
target_info,
cached_subs,
render,
palette,
exec_mode,
)
}
@ -105,7 +107,7 @@ pub fn load_and_monomorphize(
) -> Result<MonomorphizedModule<'_>, LoadMonomorphizedError<'_>> {
use LoadResult::*;
let load_start = LoadStart::from_path(arena, filename, load_config.render)?;
let load_start = LoadStart::from_path(arena, filename, load_config.render, load_config.palette)?;
match load(arena, load_start, exposed_types, load_config)? {
Monomorphized(module) => Ok(module),
@ -121,7 +123,7 @@ pub fn load_and_typecheck(
) -> Result<LoadedModule, LoadingProblem<'_>> {
use LoadResult::*;
let load_start = LoadStart::from_path(arena, filename, load_config.render)?;
let load_start = LoadStart::from_path(arena, filename, load_config.render, load_config.palette)?;
match load(arena, load_start, exposed_types, load_config)? {
Monomorphized(_) => unreachable!(""),
@ -137,6 +139,7 @@ pub fn load_and_typecheck_str<'a>(
exposed_types: ExposedByModule,
target_info: TargetInfo,
render: RenderTarget,
palette: Palette,
) -> Result<LoadedModule, LoadingProblem<'a>> {
use LoadResult::*;
@ -151,6 +154,7 @@ pub fn load_and_typecheck_str<'a>(
exposed_types,
target_info,
render,
palette,
ExecutionMode::Check,
)? {
Monomorphized(_) => unreachable!(""),

23
crates/compiler/load_internal/src/file.rs
View file

@ -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);

1
crates/docs/src/lib.rs
View file

@ -458,6 +458,7 @@ pub fn load_modules_for_files(filenames: Vec<PathBuf>) -> Vec<LoadedModule> {
let load_config = LoadConfig {
target_info: roc_target::TargetInfo::default_x86_64(), // This is just type-checking for docs, so "target" doesn't matter
render: roc_reporting::report::RenderTarget::ColorTerminal,
palette: roc_reporting::report::DEFAULT_PALETTE,
threading: Threading::AllAvailable,
exec_mode: ExecutionMode::Check,
};

3
crates/glue/src/load.rs
View file

@ -3,7 +3,7 @@ use crate::types::{Env, Types};
use bumpalo::Bump;
use roc_intern::GlobalInterner;
use roc_load::{ExecutionMode, LoadConfig, LoadedModule, LoadingProblem, Threading};
use roc_reporting::report::RenderTarget;
use roc_reporting::report::{RenderTarget, DEFAULT_PALETTE};
use roc_target::{Architecture, OperatingSystem, TargetInfo};
use std::fs::File;
use std::io::{self, ErrorKind, Write};
@ -100,6 +100,7 @@ pub fn load_types(
LoadConfig {
target_info,
render: RenderTarget::Generic,
palette: DEFAULT_PALETTE,
threading,
exec_mode: ExecutionMode::Check,
},

3
crates/linker/src/lib.rs
View file

@ -9,7 +9,7 @@ use roc_build::link::{rebuild_host, LinkType};
use roc_error_macros::internal_error;
use roc_load::{EntryPoint, ExecutionMode, LoadConfig, Threading};
use roc_mono::ir::OptLevel;
use roc_reporting::report::RenderTarget;
use roc_reporting::report::{RenderTarget, DEFAULT_PALETTE};
use std::cmp::Ordering;
use std::mem;
use std::path::{Path, PathBuf};
@ -117,6 +117,7 @@ pub fn generate_stub_lib(input_path: &Path, triple: &Triple) -> std::io::Result<
LoadConfig {
target_info,
render: RenderTarget::Generic,
palette: DEFAULT_PALETTE,
threading: Threading::AllAvailable,
exec_mode: ExecutionMode::Executable,
},

1
crates/repl_eval/src/gen.rs
View file

@ -62,6 +62,7 @@ pub fn compile_to_mono<'a, 'i, I: Iterator<Item = &'i str>>(
LoadConfig {
target_info,
render: roc_reporting::report::RenderTarget::ColorTerminal,
palette,
threading: Threading::Single,
exec_mode: ExecutionMode::Executable,
},

4
crates/reporting/src/report.rs
View file

@ -149,7 +149,8 @@ impl<'b> Report<'b> {
.expect(err_msg);
}
/// Render to a color terminal using ANSI escape sequences
/// Render to a color terminal using ANSI escape sequences,
/// or to the web REPL, using HTML tags.
pub fn render_color_terminal(
self,
buf: &mut String,
@ -188,6 +189,7 @@ impl<'b> Report<'b> {
/// 2. A set of colors we decided to use
/// 3. A mapping from UI elements to the styles we use for them
/// Note: This should really be called Theme! Usually a "palette" is just (2).
#[derive(Debug, Clone, Copy)]
pub struct Palette {
pub primary: &'static str,
pub code_block: &'static str,