language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-30 23:31:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

report errors per-module

Browse source
This commit is contained in:
Folkert 2020-11-03 16:59:37 +01:00
parent 2fb803cdd0
commit af0600dc25
4 changed files with 109 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

74
compiler/load/src/file.rs
View file

@ -201,6 +201,8 @@ impl Dependencies {
#[derive(Debug, Default)]
struct ModuleCache<'a> {
module_names: MutMap<ModuleId, ModuleName>,
/// Phases
headers: MutMap<ModuleId, ModuleHeader<'a>>,
parsed: MutMap<ModuleId, ParsedModule<'a>>,
canonicalized: MutMap<ModuleId, CanonicalizedModule<'a>>,
@ -209,7 +211,14 @@ struct ModuleCache<'a> {
typechecked: MutMap<ModuleId, TypeCheckedModule<'a>>,
found_specializations: MutMap<ModuleId, FoundSpecializationsModule<'a>>,
external_specializations_requested: MutMap<ModuleId, ExternalSpecializations>,
/// Various information
documentation: MutMap<ModuleId, ModuleDocumentation>,
can_problems: MutMap<ModuleId, Vec<roc_problem::can::Problem>>,
type_problems: MutMap<ModuleId, Vec<solve::TypeError>>,
mono_problems: MutMap<ModuleId, Vec<roc_mono::ir::MonoProblem>>,
sources: MutMap<ModuleId, (PathBuf, &'a str)>,
}
fn start_phase<'a>(module_id: ModuleId, phase: Phase, state: &mut State<'a>) -> BuildTask<'a> {
@ -399,8 +408,8 @@ pub struct LoadedModule {
pub module_id: ModuleId,
pub interns: Interns,
pub solved: Solved<Subs>,
pub can_problems: Vec<roc_problem::can::Problem>,
pub type_problems: Vec<solve::TypeError>,
pub can_problems: MutMap<ModuleId, Vec<roc_problem::can::Problem>>,
pub type_problems: MutMap<ModuleId, Vec<solve::TypeError>>,
pub declarations_by_id: MutMap<ModuleId, Vec<Declaration>>,
pub exposed_to_host: MutMap<Symbol, Variable>,
pub src: Box<str>,
@ -417,6 +426,7 @@ pub enum BuildProblem<'a> {
struct ModuleHeader<'a> {
module_id: ModuleId,
module_name: ModuleName,
module_path: PathBuf,
exposed_ident_ids: IdentIds,
deps_by_name: MutMap<ModuleName, ModuleId>,
imported_modules: MutSet<ModuleId>,
@ -464,12 +474,12 @@ pub struct MonomorphizedModule<'a> {
pub module_id: ModuleId,
pub interns: Interns,
pub subs: Subs,
pub can_problems: Vec<roc_problem::can::Problem>,
pub type_problems: Vec<solve::TypeError>,
pub mono_problems: Vec<roc_mono::ir::MonoProblem>,
pub can_problems: MutMap<ModuleId, Vec<roc_problem::can::Problem>>,
pub type_problems: MutMap<ModuleId, Vec<solve::TypeError>>,
pub mono_problems: MutMap<ModuleId, Vec<roc_mono::ir::MonoProblem>>,
pub procedures: MutMap<(Symbol, Layout<'a>), Proc<'a>>,
pub exposed_to_host: MutMap<Symbol, Variable>,
pub src: Box<str>,
pub sources: MutMap<ModuleId, (PathBuf, Box<str>)>,
pub timings: MutMap<ModuleId, ModuleTiming>,
}
@ -477,6 +487,7 @@ pub struct MonomorphizedModule<'a> {
struct ParsedModule<'a> {
module_id: ModuleId,
module_name: ModuleName,
module_path: PathBuf,
src: &'a str,
module_timing: ModuleTiming,
deps_by_name: MutMap<ModuleName, ModuleId>,
@ -559,10 +570,7 @@ struct State<'a> {
pub stdlib: StdLib,
pub exposed_types: SubsByModule,
pub can_problems: std::vec::Vec<roc_problem::can::Problem>,
pub mono_problems: std::vec::Vec<MonoProblem>,
pub headers_parsed: MutSet<ModuleId>,
pub type_problems: std::vec::Vec<solve::TypeError>,
pub module_cache: ModuleCache<'a>,
pub dependencies: Dependencies,
@ -1105,9 +1113,6 @@ where
exposed_types,
headers_parsed,
loading_started,
can_problems: std::vec::Vec::new(),
type_problems: std::vec::Vec::new(),
mono_problems: std::vec::Vec::new(),
arc_modules,
constrained_ident_ids: IdentIds::exposed_builtins(0),
ident_ids_by_module,
@ -1267,6 +1272,11 @@ fn update<'a>(
Ok(state)
}
Parsed(parsed) => {
state
.module_cache
.sources
.insert(parsed.module_id, (parsed.module_path.clone(), parsed.src));
let module_id = parsed.module_id;
state.module_cache.parsed.insert(parsed.module_id, parsed);
@ -1288,7 +1298,10 @@ fn update<'a>(
} => {
let module_id = constrained_module.module.module_id;
log!("generated constraints for {:?}", module_id);
state.can_problems.extend(canonicalization_problems);
state
.module_cache
.can_problems
.insert(module_id, canonicalization_problems);
state
.module_cache
@ -1329,7 +1342,10 @@ fn update<'a>(
log!("solved types for {:?}", module_id);
module_timing.end_time = SystemTime::now();
state.type_problems.extend(solved_module.problems);
state
.module_cache
.type_problems
.insert(module_id, solved_module.problems);
let work = state.dependencies.notify(module_id, Phase::SolveTypes);
@ -1476,7 +1492,7 @@ fn update<'a>(
} => {
log!("made specializations for {:?}", module_id);
state.mono_problems.extend(problems);
state.module_cache.mono_problems.insert(module_id, problems);
for (module_id, requested) in external_specializations_requested {
let existing = match state
@ -1554,12 +1570,23 @@ fn finish_specialization<'a>(
};
let State {
procedures,
module_cache,
..
} = state;
let ModuleCache {
mono_problems,
type_problems,
can_problems,
procedures,
sources,
..
} = state;
} = module_cache;
let sources = sources
.into_iter()
.map(|(id, (path, src))| (id, (path, src.into())))
.collect();
MonomorphizedModule {
can_problems,
@ -1570,7 +1597,8 @@ fn finish_specialization<'a>(
subs,
interns,
procedures,
src: src.into(),
// src: src.into(),
sources,
timings: state.timings,
}
}
@ -1595,8 +1623,8 @@ fn finish<'a>(
module_id: state.root_id,
interns,
solved,
can_problems: state.can_problems,
type_problems: state.type_problems,
can_problems: state.module_cache.can_problems,
type_problems: state.module_cache.type_problems,
declarations_by_id: state.declarations_by_id,
exposed_to_host: exposed_vars_by_symbol.into_iter().collect(),
src: src.into(),
@ -1693,6 +1721,7 @@ fn parse_header<'a>(
match parsed {
Ok((ast::Module::Interface { header }, parse_state)) => Ok(send_header(
header.name,
filename,
header.exposes.into_bump_slice(),
header.imports.into_bump_slice(),
parse_state,
@ -1702,6 +1731,7 @@ fn parse_header<'a>(
)),
Ok((ast::Module::App { header }, parse_state)) => Ok(send_header(
header.name,
filename,
header.provides.into_bump_slice(),
header.imports.into_bump_slice(),
parse_state,
@ -1776,6 +1806,7 @@ fn load_from_str<'a>(
#[allow(clippy::too_many_arguments)]
fn send_header<'a>(
name: Located<roc_parse::header::ModuleName<'a>>,
filename: PathBuf,
exposes: &'a [Located<ExposesEntry<'a>>],
imports: &'a [Located<ImportsEntry<'a>>],
parse_state: parser::State<'a>,
@ -1895,6 +1926,7 @@ fn send_header<'a>(
home,
Msg::Header(ModuleHeader {
module_id: home,
module_path: filename,
exposed_ident_ids: ident_ids,
module_name: declared_name,
imported_modules,
@ -2145,12 +2177,14 @@ fn parse<'a>(arena: &'a Bump, header: ModuleHeader<'a>) -> Result<Msg<'a>, Loadi
deps_by_name,
exposed_ident_ids,
exposed_imports,
module_path,
..
} = header;
let parsed = ParsedModule {
module_id,
module_name,
module_path,
deps_by_name,
exposed_ident_ids,
exposed_imports,