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

Import both specializations and declared ability mappings

Browse source
This commit is contained in:
Ayaz Hafiz 2022-07-25 10:06:49 -04:00
parent cd0b8577ab
commit 0525c6d616
No known key found for this signature in database
GPG key ID: 0E2A37416A25EF58
5 changed files with 159 additions and 86 deletions
Download patch file Download diff file Expand all files Collapse all files

42
crates/compiler/can/src/abilities.rs
View file

@ -109,6 +109,22 @@ static_assertions::assert_eq_size!(SpecializationId, Option<SpecializationId>);
pub enum SpecializationLambdaSetError {}
/// A key into a particular implementation of an ability member for an opaque type.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub struct ImplKey {
pub opaque: Symbol,
pub ability_member: Symbol,
}
/// Fully-resolved implementation of an ability member for an opaque type.
/// This is only fully known after type solving of the owning module.
#[derive(Clone, Debug)]
pub enum ResolvedImpl {
Impl(MemberSpecializationInfo<Resolved>),
Derived,
Error,
}
/// Stores information about what abilities exist in a scope, what it means to implement an
/// ability, and what types implement them.
// TODO(abilities): this should probably go on the Scope, I don't put it there for now because we
@ -434,7 +450,31 @@ impl IAbilitiesStore<Resolved> {
}
impl IAbilitiesStore<Pending> {
pub fn import_specialization(
pub fn import_implementation(&mut self, impl_key: ImplKey, resolved_impl: &ResolvedImpl) {
let ImplKey {
opaque,
ability_member,
} = impl_key;
let member_impl = match resolved_impl {
ResolvedImpl::Impl(specialization) => {
self.import_specialization(specialization);
MemberImpl::Impl(specialization.symbol)
}
ResolvedImpl::Derived => MemberImpl::Derived,
ResolvedImpl::Error => MemberImpl::Error,
};
let old_declared_impl = self
.declared_implementations
.insert((opaque, ability_member), member_impl);
debug_assert!(
old_declared_impl.is_none(),
"Replacing existing declared impl!"
);
}
fn import_specialization(
&mut self,
specialization: &MemberSpecializationInfo<impl ResolvePhase>,
) {

12
crates/compiler/can/src/module.rs
View file

@ -1,4 +1,4 @@
use crate::abilities::{MemberSpecializationInfo, PendingAbilitiesStore, Resolved};
use crate::abilities::{ImplKey, PendingAbilitiesStore, ResolvedImpl};
use crate::annotation::canonicalize_annotation;
use crate::def::{canonicalize_defs, Def};
use crate::effect_module::HostedGeneratedFunctions;
@ -103,14 +103,20 @@ impl ExposedForModule {
}
}
pub type ResolvedSpecializations = VecMap<Symbol, MemberSpecializationInfo<Resolved>>;
/// During type solving and monomorphization, a module must know how its imported ability
/// implementations are resolved - are they derived, or have a concrete implementation?
///
/// Unfortunately we cannot keep this information opaque, as it's important for properly
/// restoring specialization lambda sets. As such, we need to export implementation information,
/// which is the job of this structure.
pub type ResolvedImplementations = VecMap<ImplKey, ResolvedImpl>;
/// The types of all exposed values/functions of a module. This includes ability member
/// specializations.
#[derive(Clone, Debug)]
pub struct ExposedModuleTypes {
pub exposed_types_storage_subs: ExposedTypesStorageSubs,
pub resolved_specializations: ResolvedSpecializations,
pub resolved_implementations: ResolvedImplementations,
}
#[derive(Debug)]

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

@ -5,13 +5,13 @@ use crossbeam::deque::{Injector, Stealer, Worker};
use crossbeam::thread;
use parking_lot::Mutex;
use roc_builtins::roc::module_source;
use roc_can::abilities::{AbilitiesStore, PendingAbilitiesStore};
use roc_can::abilities::{AbilitiesStore, PendingAbilitiesStore, ResolvedImpl};
use roc_can::constraint::{Constraint as ConstraintSoa, Constraints};
use roc_can::expr::Declarations;
use roc_can::expr::PendingDerives;
use roc_can::module::{
canonicalize_module_defs, ExposedByModule, ExposedForModule, ExposedModuleTypes, Module,
ResolvedSpecializations,
ResolvedImplementations,
};
use roc_collections::{default_hasher, BumpMap, MutMap, MutSet, VecMap, VecSet};
use roc_constrain::module::constrain_module;
@ -42,11 +42,11 @@ use roc_parse::module::module_defs;
use roc_parse::parser::{FileError, Parser, SyntaxError};
use roc_region::all::{LineInfo, Loc, Region};
use roc_reporting::report::RenderTarget;
use roc_solve::module::{Solved, SolvedModule};
use roc_solve::module::{extract_module_owned_implementations, Solved, SolvedModule};
use roc_solve::solve;
use roc_target::TargetInfo;
use roc_types::subs::{ExposedTypesStorageSubs, Subs, VarStore, Variable};
use roc_types::types::{Alias, AliasKind, MemberImpl};
use roc_types::types::{Alias, AliasKind};
use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::collections::HashMap;
use std::env::current_dir;
@ -563,7 +563,7 @@ pub struct LoadedModule {
pub exposed_aliases: MutMap<Symbol, Alias>,
pub exposed_values: Vec<Symbol>,
pub exposed_types_storage: ExposedTypesStorageSubs,
pub resolved_specializations: ResolvedSpecializations,
pub resolved_implementations: ResolvedImplementations,
pub sources: MutMap<ModuleId, (PathBuf, Box<str>)>,
pub timings: MutMap<ModuleId, ModuleTiming>,
pub documentation: MutMap<ModuleId, ModuleDocumentation>,
@ -755,7 +755,7 @@ enum Msg<'a> {
exposed_vars_by_symbol: Vec<(Symbol, Variable)>,
exposed_aliases_by_symbol: MutMap<Symbol, (bool, Alias)>,
exposed_types_storage: ExposedTypesStorageSubs,
resolved_specializations: ResolvedSpecializations,
resolved_implementations: ResolvedImplementations,
dep_idents: IdentIdsByModule,
documentation: MutMap<ModuleId, ModuleDocumentation>,
abilities_store: AbilitiesStore,
@ -1514,7 +1514,7 @@ fn state_thread_step<'a>(
exposed_vars_by_symbol,
exposed_aliases_by_symbol,
exposed_types_storage,
resolved_specializations,
resolved_implementations,
dep_idents,
documentation,
abilities_store,
@ -1533,7 +1533,7 @@ fn state_thread_step<'a>(
exposed_aliases_by_symbol,
exposed_vars_by_symbol,
exposed_types_storage,
resolved_specializations,
resolved_implementations,
dep_idents,
documentation,
abilities_store,
@ -2363,7 +2363,7 @@ fn update<'a>(
exposed_vars_by_symbol: solved_module.exposed_vars_by_symbol,
exposed_aliases_by_symbol: solved_module.aliases,
exposed_types_storage: solved_module.exposed_types,
resolved_specializations: solved_module.solved_specializations,
resolved_implementations: solved_module.solved_implementations,
dep_idents,
documentation,
abilities_store,
@ -2382,7 +2382,7 @@ fn update<'a>(
module_id,
ExposedModuleTypes {
exposed_types_storage_subs: solved_module.exposed_types,
resolved_specializations: solved_module.solved_specializations,
resolved_implementations: solved_module.solved_implementations,
},
);
@ -2844,7 +2844,7 @@ fn finish(
exposed_aliases_by_symbol: MutMap<Symbol, Alias>,
exposed_vars_by_symbol: Vec<(Symbol, Variable)>,
exposed_types_storage: ExposedTypesStorageSubs,
resolved_specializations: ResolvedSpecializations,
resolved_implementations: ResolvedImplementations,
dep_idents: IdentIdsByModule,
documentation: MutMap<ModuleId, ModuleDocumentation>,
abilities_store: AbilitiesStore,
@ -2891,7 +2891,7 @@ fn finish(
exposed_values,
exposed_to_host: exposed_vars_by_symbol.into_iter().collect(),
exposed_types_storage,
resolved_specializations,
resolved_implementations,
sources,
timings: state.timings,
documentation,
@ -3992,7 +3992,7 @@ pub fn add_imports(
match $exposed_by_module.get(&module_id) {
Some(ExposedModuleTypes {
exposed_types_storage_subs: exposed_types,
resolved_specializations: _,
resolved_implementations: _,
}) => {
let variable = match exposed_types.stored_vars_by_symbol.iter().find(|(s, _)| **s == $symbol) {
None => {
@ -4051,8 +4051,8 @@ pub fn add_imports(
// One idea is to just always assume external modules fulfill their specialization obligations
// and save lambda set resolution for mono.
for (_, module_types) in exposed_for_module.exposed_by_module.iter_all() {
for resolved_specialization in module_types.resolved_specializations.values() {
pending_abilities.import_specialization(resolved_specialization)
for (impl_key, resolved_impl) in module_types.resolved_implementations.iter() {
pending_abilities.import_implementation(*impl_key, resolved_impl);
}
}
@ -4082,7 +4082,7 @@ pub fn add_imports(
|ctx, module, lset_var| match ctx.exposed_by_module.get(&module) {
Some(ExposedModuleTypes {
exposed_types_storage_subs: exposed_types,
resolved_specializations: _,
resolved_implementations: _,
}) => {
let var = exposed_types
.stored_specialization_lambda_set_vars
@ -4102,30 +4102,6 @@ pub fn add_imports(
(import_variables, abilities_store)
}
/// Extracts the ability member specializations owned by a solved module.
fn extract_module_owned_specializations(
module_id: ModuleId,
abilities_store: &AbilitiesStore,
) -> ResolvedSpecializations {
abilities_store
.iter_declared_implementations()
.filter(|((member, typ), _)| {
// This module solved this specialization if either the member or the type comes from the
// module.
member.module_id() == module_id || typ.module_id() == module_id
})
.filter_map(|(_, member_impl)| match member_impl {
MemberImpl::Impl(impl_symbol) => {
let specialization = abilities_store.specialization_info(*impl_symbol).expect(
"declared implementations should be resolved conclusively after solving",
);
Some((*impl_symbol, specialization.clone()))
}
MemberImpl::Derived | MemberImpl::Error => None,
})
.collect()
}
#[allow(clippy::complexity)]
fn run_solve_solve(
exposed_for_module: ExposedForModule,
@ -4137,7 +4113,7 @@ fn run_solve_solve(
derived_module: SharedDerivedModule,
) -> (
Solved<Subs>,
ResolvedSpecializations,
ResolvedImplementations,
Vec<(Symbol, Variable)>,
Vec<solve::TypeError>,
AbilitiesStore,
@ -4173,7 +4149,7 @@ fn run_solve_solve(
solve_aliases.insert(*name, alias.clone());
}
let (solved_subs, solved_specializations, exposed_vars_by_symbol, problems, abilities_store) = {
let (solved_subs, solved_implementations, exposed_vars_by_symbol, problems, abilities_store) = {
let module_id = module.module_id;
let (solved_subs, solved_env, problems, abilities_store) = roc_solve::module::run_solve(
@ -4189,11 +4165,17 @@ fn run_solve_solve(
derived_module,
);
let solved_specializations =
extract_module_owned_specializations(module_id, &abilities_store);
let solved_implementations =
extract_module_owned_implementations(module_id, &abilities_store);
let is_specialization_symbol =
|sym| solved_specializations.values().any(|ms| ms.symbol == sym);
let is_specialization_symbol = |sym| {
solved_implementations
.values()
.any(|resolved_impl| match resolved_impl {
ResolvedImpl::Impl(specialization) => specialization.symbol == sym,
ResolvedImpl::Derived | ResolvedImpl::Error => false,
})
};
// Expose anything that is explicitly exposed by the header, or is a specialization of an
// ability.
@ -4204,7 +4186,7 @@ fn run_solve_solve(
(
solved_subs,
solved_specializations,
solved_implementations,
exposed_vars_by_symbol,
problems,
abilities_store,
@ -4213,7 +4195,7 @@ fn run_solve_solve(
(
solved_subs,
solved_specializations,
solved_implementations,
exposed_vars_by_symbol,
problems,
abilities_store,
@ -4246,7 +4228,7 @@ fn run_solve<'a>(
let loc_expects = std::mem::take(&mut module.loc_expects);
let module = module;
let (solved_subs, solved_specializations, exposed_vars_by_symbol, problems, abilities_store) = {
let (solved_subs, solved_implementations, exposed_vars_by_symbol, problems, abilities_store) = {
if module_id.is_builtin() {
match cached_subs.lock().remove(&module_id) {
None => run_solve_solve(
@ -4288,7 +4270,7 @@ fn run_solve<'a>(
module_id,
&mut solved_subs,
&exposed_vars_by_symbol,
&solved_specializations,
&solved_implementations,
&abilities_store,
);
@ -4296,7 +4278,7 @@ fn run_solve<'a>(
exposed_vars_by_symbol,
problems,
aliases,
solved_specializations,
solved_implementations,
exposed_types,
};

99
crates/compiler/solve/src/module.rs
View file

@ -1,15 +1,15 @@
use crate::solve::{self, Aliases};
use roc_can::abilities::AbilitiesStore;
use roc_can::abilities::{AbilitiesStore, ImplKey, ResolvedImpl};
use roc_can::constraint::{Constraint as ConstraintSoa, Constraints};
use roc_can::expr::PendingDerives;
use roc_can::module::{ExposedByModule, ResolvedSpecializations, RigidVariables};
use roc_can::module::{ExposedByModule, ResolvedImplementations, RigidVariables};
use roc_collections::all::MutMap;
use roc_collections::VecMap;
use roc_derive::SharedDerivedModule;
use roc_error_macros::internal_error;
use roc_module::symbol::{ModuleId, Symbol};
use roc_types::subs::{Content, ExposedTypesStorageSubs, FlatType, StorageSubs, Subs, Variable};
use roc_types::types::Alias;
use roc_types::types::{Alias, MemberImpl};
/// A marker that a given Subs has been solved.
/// The only way to obtain a Solved<Subs> is by running the solver on it.
@ -48,7 +48,7 @@ pub struct SolvedModule {
pub exposed_vars_by_symbol: Vec<(Symbol, Variable)>,
/// Used when importing this module into another module
pub solved_specializations: ResolvedSpecializations,
pub solved_implementations: ResolvedImplementations,
pub exposed_types: ExposedTypesStorageSubs,
}
@ -108,7 +108,7 @@ pub fn exposed_types_storage_subs(
home: ModuleId,
solved_subs: &mut Solved<Subs>,
exposed_vars_by_symbol: &[(Symbol, Variable)],
solved_specializations: &ResolvedSpecializations,
solved_implementations: &ResolvedImplementations,
abilities_store: &AbilitiesStore,
) -> ExposedTypesStorageSubs {
let subs = solved_subs.inner_mut();
@ -121,31 +121,42 @@ pub fn exposed_types_storage_subs(
}
let mut stored_specialization_lambda_set_vars =
VecMap::with_capacity(solved_specializations.len());
VecMap::with_capacity(solved_implementations.len());
for (_, member_specialization) in solved_specializations.iter() {
for (_, &lset_var) in member_specialization.specialization_lambda_sets.iter() {
let specialization_lset_ambient_function_var =
subs.get_lambda_set(lset_var).ambient_function;
for (_, member_impl) in solved_implementations.iter() {
match member_impl {
ResolvedImpl::Impl(member_specialization) => {
// Export all the lambda sets and their ambient functions.
for (_, &lset_var) in member_specialization.specialization_lambda_sets.iter() {
let specialization_lset_ambient_function_var =
subs.get_lambda_set(lset_var).ambient_function;
// Import the ambient function of this specialization lambda set; that will import the
// lambda set as well. The ambient function is needed for the lambda set compaction
// algorithm.
let imported_lset_ambient_function_var = storage_subs
.import_variable_from(subs, specialization_lset_ambient_function_var)
.variable;
// Import the ambient function of this specialization lambda set; that will import the
// lambda set as well. The ambient function is needed for the lambda set compaction
// algorithm.
let imported_lset_ambient_function_var = storage_subs
.import_variable_from(subs, specialization_lset_ambient_function_var)
.variable;
let imported_lset_var = match storage_subs
.as_inner()
.get_content_without_compacting(imported_lset_ambient_function_var)
{
Content::Structure(FlatType::Func(_, lambda_set_var, _)) => *lambda_set_var,
content => internal_error!(
"ambient lambda set function import is not a function, found: {:?}",
roc_types::subs::SubsFmtContent(content, storage_subs.as_inner())
),
};
stored_specialization_lambda_set_vars.insert(lset_var, imported_lset_var);
let imported_lset_var = match storage_subs
.as_inner()
.get_content_without_compacting(imported_lset_ambient_function_var)
{
Content::Structure(FlatType::Func(_, lambda_set_var, _)) => *lambda_set_var,
content => internal_error!(
"ambient lambda set function import is not a function, found: {:?}",
roc_types::subs::SubsFmtContent(content, storage_subs.as_inner())
),
};
stored_specialization_lambda_set_vars.insert(lset_var, imported_lset_var);
}
}
ResolvedImpl::Derived => {
// nothing to do
}
ResolvedImpl::Error => {
// nothing to do
}
}
}
@ -171,3 +182,37 @@ pub fn exposed_types_storage_subs(
stored_ability_member_vars,
}
}
/// Extracts the ability member implementations owned by a solved module.
pub fn extract_module_owned_implementations(
module_id: ModuleId,
abilities_store: &AbilitiesStore,
) -> ResolvedImplementations {
abilities_store
.iter_declared_implementations()
.filter_map(|((member, typ), member_impl)| {
// This module solved this specialization if either the member or the type comes from the
// module.
if member.module_id() != module_id && typ.module_id() != module_id {
return None;
}
let impl_key = ImplKey {
opaque: typ,
ability_member: member,
};
let resolved_impl = match member_impl {
MemberImpl::Impl(impl_symbol) => {
let specialization = abilities_store.specialization_info(*impl_symbol).expect(
"declared implementations should be resolved conclusively after solving",
);
ResolvedImpl::Impl(specialization.clone())
}
MemberImpl::Derived => ResolvedImpl::Derived,
MemberImpl::Error => ResolvedImpl::Error,
};
Some((impl_key, resolved_impl))
})
.collect()
}

8
crates/compiler/test_derive/src/encoding.rs
View file

@ -18,7 +18,7 @@ use roc_can::{
def::Def,
expr::Declarations,
module::{
ExposedByModule, ExposedForModule, ExposedModuleTypes, ResolvedSpecializations,
ExposedByModule, ExposedForModule, ExposedModuleTypes, ResolvedImplementations,
RigidVariables,
},
};
@ -137,7 +137,7 @@ fn check_derived_typechecks_and_golden(
ModuleId::ENCODE,
ExposedModuleTypes {
exposed_types_storage_subs: exposed_encode_types,
resolved_specializations: ResolvedSpecializations::default(),
resolved_implementations: ResolvedImplementations::default(),
},
);
let exposed_for_module =
@ -233,7 +233,7 @@ where
mut interns,
exposed_types_storage: exposed_encode_types,
abilities_store,
resolved_specializations,
resolved_implementations,
..
} = roc_load_internal::file::load_and_typecheck_str(
&arena,
@ -259,7 +259,7 @@ where
ModuleId::ENCODE,
ExposedModuleTypes {
exposed_types_storage_subs: exposed_encode_types.clone(),
resolved_specializations,
resolved_implementations,
},
);