language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-27 05:49:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Merge remote-tracking branch 'origin/main' into glue-getters-rtfeldman

Browse source
This commit is contained in:
Richard Feldman 2022-11-15 12:12:30 -05:00
commit d3d21630e8
No known key found for this signature in database
GPG key ID: F1F21AA5B1D9E43B
124 changed files with 7072 additions and 3881 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -44,12 +44,12 @@ 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, Palette, RenderTarget};
use roc_solve::module::{extract_module_owned_implementations, Solved, SolvedModule};
use roc_solve_problem::TypeError;
use roc_target::TargetInfo;
use roc_types::subs::{ExposedTypesStorageSubs, Subs, VarStore, Variable};
use roc_types::types::{Alias, AliasKind};
use roc_types::types::{Alias, Types};
use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::collections::HashMap;
use std::env::current_dir;
@ -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,
}
@ -384,6 +385,7 @@ fn start_phase<'a>(
declarations,
dep_idents,
pending_derives,
types,
..
} = constrained;
@ -393,6 +395,7 @@ fn start_phase<'a>(
module,
ident_ids,
module_timing,
types,
constraints,
constraint,
pending_derives,
@ -646,6 +649,7 @@ struct ConstrainedModule {
var_store: VarStore,
dep_idents: IdentIdsByModule,
module_timing: ModuleTiming,
types: Types,
// Rather than adding pending derives as constraints, hand them directly to solve because they
// must be solved at the end of a module.
pending_derives: PendingDerives,
@ -931,6 +935,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.
@ -960,6 +965,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 {
@ -991,6 +997,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(),
@ -1096,6 +1103,7 @@ enum BuildTask<'a> {
ident_ids: IdentIds,
exposed_for_module: ExposedForModule,
module_timing: ModuleTiming,
types: Types,
constraints: Constraints,
constraint: ConstraintSoa,
pending_derives: PendingDerives,
@ -1200,6 +1208,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::*;
@ -1213,6 +1222,7 @@ pub fn load_and_typecheck_str<'a>(
let load_config = LoadConfig {
target_info,
render,
palette,
threading,
exec_mode: ExecutionMode::Check,
};
@ -1242,6 +1252,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);
@ -1306,6 +1317,7 @@ impl<'a> LoadStart<'a> {
module_ids,
root_exposed_ident_ids,
render,
palette,
);
return Err(LoadingProblem::FormattedReport(buf));
}
@ -1502,6 +1514,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(
@ -1511,6 +1524,7 @@ pub fn load<'a>(
load_config.target_info,
cached_types,
load_config.render,
load_config.palette,
threads,
load_config.exec_mode,
),
@ -1526,6 +1540,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 {
@ -1552,6 +1567,7 @@ pub fn load_single_threaded<'a>(
ident_ids_by_module,
cached_types,
render,
palette,
number_of_workers,
exec_mode,
);
@ -1672,6 +1688,7 @@ fn state_thread_step<'a>(
module_ids,
state.constrained_ident_ids,
state.render,
state.palette,
);
Err(LoadingProblem::FormattedReport(buf))
}
@ -1697,6 +1714,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,
@ -1726,6 +1744,7 @@ fn state_thread_step<'a>(
module_ids,
root_exposed_ident_ids,
render,
palette,
);
Err(LoadingProblem::FormattedReport(buf))
}
@ -1779,6 +1798,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>> {
@ -1821,6 +1841,7 @@ fn load_multi_threaded<'a>(
ident_ids_by_module,
cached_types,
render,
palette,
num_workers,
exec_mode,
);
@ -4242,6 +4263,7 @@ impl<'a> BuildTask<'a> {
module: Module,
ident_ids: IdentIds,
module_timing: ModuleTiming,
types: Types,
constraints: Constraints,
constraint: ConstraintSoa,
pending_derives: PendingDerives,
@ -4263,6 +4285,7 @@ impl<'a> BuildTask<'a> {
module,
ident_ids,
exposed_for_module,
types,
constraints,
constraint,
pending_derives,
@ -4324,8 +4347,6 @@ pub fn add_imports(
def_types: &mut Vec<(Symbol, Loc<TypeOrVar>)>,
rigid_vars: &mut Vec<Variable>,
) -> (Vec<Variable>, AbilitiesStore) {
use roc_types::types::Type;
let mut import_variables = Vec::new();
let mut cached_symbol_vars = VecMap::default();
@ -4350,7 +4371,7 @@ pub fn add_imports(
};
let copied_import = exposed_types.storage_subs.export_variable_to($subs, variable);
let copied_import_index = constraints.push_type(Type::Variable(copied_import.variable));
let copied_import_index = constraints.push_variable(copied_import.variable);
def_types.push((
$symbol,
@ -4385,7 +4406,7 @@ pub fn add_imports(
if my_module == ModuleId::NUM {
// Num needs List.len, but List imports Num.
let list_len_type_var = synth_list_len_type(subs);
let list_len_type_index = constraints.push_type(Type::Variable(list_len_type_var));
let list_len_type_index = constraints.push_variable(list_len_type_var);
def_types.push((Symbol::LIST_LEN, Loc::at_zero(list_len_type_index)));
import_variables.push(list_len_type_var);
}
@ -4451,6 +4472,7 @@ pub fn add_imports(
#[allow(clippy::complexity)]
fn run_solve_solve(
exposed_for_module: ExposedForModule,
mut types: Types,
mut constraints: Constraints,
constraint: ConstraintSoa,
pending_derives: PendingDerives,
@ -4490,10 +4512,9 @@ fn run_solve_solve(
let actual_constraint =
constraints.let_import_constraint(rigid_vars, def_types, constraint, &import_variables);
let mut solve_aliases = default_aliases();
let mut solve_aliases = roc_solve::solve::Aliases::with_capacity(aliases.len());
for (name, (_, alias)) in aliases.iter() {
solve_aliases.insert(*name, alias.clone());
solve_aliases.insert(&mut types, *name, alias.clone());
}
let (solved_subs, solved_implementations, exposed_vars_by_symbol, problems, abilities_store) = {
@ -4501,6 +4522,7 @@ fn run_solve_solve(
let (solved_subs, solved_env, problems, abilities_store) = roc_solve::module::run_solve(
module_id,
types,
&constraints,
actual_constraint,
rigid_variables,
@ -4559,6 +4581,7 @@ fn run_solve<'a>(
ident_ids: IdentIds,
mut module_timing: ModuleTiming,
exposed_for_module: ExposedForModule,
types: Types,
constraints: Constraints,
constraint: ConstraintSoa,
pending_derives: PendingDerives,
@ -4584,6 +4607,7 @@ fn run_solve<'a>(
match cached_types.lock().remove(&module_id) {
None => run_solve_solve(
exposed_for_module,
types,
constraints,
constraint,
pending_derives,
@ -4607,6 +4631,7 @@ fn run_solve<'a>(
} else {
run_solve_solve(
exposed_for_module,
types,
constraints,
constraint,
pending_derives,
@ -4751,6 +4776,7 @@ fn canonicalize_and_constrain<'a>(
&symbols_from_requires,
&mut var_store,
);
let mut types = Types::new();
// _after has an underscore because it's unused in --release builds
let _after = roc_types::types::get_type_clone_count();
@ -4794,6 +4820,7 @@ fn canonicalize_and_constrain<'a>(
roc_can::constraint::Constraint::True
} else {
constrain_module(
&mut types,
&mut constraints,
module_output.symbols_from_requires,
&module_output.scope.abilities_store,
@ -4865,6 +4892,7 @@ fn canonicalize_and_constrain<'a>(
ident_ids: module_output.scope.locals.ident_ids,
dep_idents,
module_timing,
types,
pending_derives: module_output.pending_derives,
};
@ -5635,6 +5663,7 @@ fn run_task<'a>(
module,
module_timing,
exposed_for_module,
types,
constraints,
constraint,
pending_derives,
@ -5649,6 +5678,7 @@ fn run_task<'a>(
ident_ids,
module_timing,
exposed_for_module,
types,
constraints,
constraint,
pending_derives,
@ -5915,8 +5945,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) };
@ -5947,7 +5978,6 @@ fn to_parse_problem_report<'a>(
);
let mut buf = String::new();
let palette = DEFAULT_PALETTE;
report.render(render, &mut buf, &alloc, &palette);
@ -6037,46 +6067,3 @@ fn to_missing_platform_report(module_id: ModuleId, other: PlatformPath) -> Strin
buf
}
/// Builtin aliases that are not covered by type checker optimizations
///
/// Types like `F64` and `I32` are hardcoded into Subs and therefore we don't define them here.
/// Generic number types (Num, Int, Float, etc.) are treated as `DelayedAlias`es resolved during
/// type solving.
/// All that remains are Signed8, Signed16, etc.
pub fn default_aliases() -> roc_solve::solve::Aliases {
use roc_types::types::Type;
let mut solve_aliases = roc_solve::solve::Aliases::default();
let mut zero_opaque = |alias_name: Symbol| {
let alias = Alias {
region: Region::zero(),
type_variables: vec![],
lambda_set_variables: Default::default(),
recursion_variables: Default::default(),
infer_ext_in_output_variables: Default::default(),
typ: Type::EmptyTagUnion,
kind: AliasKind::Opaque,
};
solve_aliases.insert(alias_name, alias);
};
zero_opaque(Symbol::NUM_SIGNED8);
zero_opaque(Symbol::NUM_SIGNED16);
zero_opaque(Symbol::NUM_SIGNED32);
zero_opaque(Symbol::NUM_SIGNED64);
zero_opaque(Symbol::NUM_SIGNED128);
zero_opaque(Symbol::NUM_UNSIGNED8);
zero_opaque(Symbol::NUM_UNSIGNED16);
zero_opaque(Symbol::NUM_UNSIGNED32);
zero_opaque(Symbol::NUM_UNSIGNED64);
zero_opaque(Symbol::NUM_UNSIGNED128);
zero_opaque(Symbol::NUM_BINARY32);
zero_opaque(Symbol::NUM_BINARY64);
solve_aliases
}