language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-16 01:50:15 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Make sure late specializations of opaques inherit Inspect as needed

Browse source 
A "late specialization" of a type is an ability specialization that
is not visible or needed until after type-specialization; i.e. during
monomorphization.

The `Inspect.toInspector` ability is special-cased for opaques that do
not claim or explicitly implement `Inspect`. In such cases, they are
treated as structural types, and given the immediate specialization of
`Inpect.inspectOpaque`.

However, prior to this commit, that special-casing would only be applied
during early specialiation (i.e. specializations visible during
generalized type inference). This commit applies the special case to
late specialization as well - the specialization decision for an opaque
type is always the specialization of the opaque type in the late case,
but now, when we go to look up the ambient lambda set of the
specialization, if it does not exist and corresponds to
`Inspect.toInspector`, we fall back to the immediate.

One concern I have here is that in a case like

```
Op := {}

x =
    dbg (@Op {})
```

the specialization of `Inspect.toInspector` for `Op` should be known
early. Indeed, the program

```
Op := {}

x =
    Inspect.toInspector (@Op {}) |> Inspect.apply (Inspect.init {}) |> Inspect.toDbgStr
```

Compiles fine without this change. This makes me suspect there is an
issue with the implementation of `dbg`'s desugaring. If possible, this
should be addressed sooner rather than later.

Closes #6127
This commit is contained in:
Ayaz Hafiz 2023-11-30 22:16:01 -06:00
parent 7d2b8a509d
commit a53da2bc24
No known key found for this signature in database
GPG key ID: 0E2A37416A25EF58
5 changed files with 285 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

218
crates/compiler/solve/src/specialize.rs
View file

@ -723,115 +723,155 @@ fn get_specialization_lambda_set_ambient_function<P: Phase>(
phase: &P,
ability_member: Symbol,
lset_region: u8,
specialization_key: SpecializationTypeKey,
mut specialization_key: SpecializationTypeKey,
target_rank: Rank,
) -> Result<Variable, ()> {
match specialization_key {
SpecializationTypeKey::Opaque(opaque) => {
let opaque_home = opaque.module_id();
let external_specialized_lset =
phase.with_module_abilities_store(opaque_home, |abilities_store| {
let impl_key = roc_can::abilities::ImplKey {
loop {
match specialization_key {
SpecializationTypeKey::Opaque(opaque) => {
let opaque_home = opaque.module_id();
let found = phase.with_module_abilities_store(opaque_home, |abilities_store| {
find_opaque_specialization_ambient_function(
abilities_store,
opaque,
ability_member,
};
lset_region,
)
});
let opt_specialization =
abilities_store.get_implementation(impl_key);
match opt_specialization {
None => {
if P::IS_LATE {
internal_error!(
"expected to know a specialization for {:?}#{:?}, but it wasn't found",
opaque,
ability_member
);
} else {
// doesn't specialize, we'll have reported an error for this
Err(())
}
}
Some(member_impl) => match member_impl {
MemberImpl::Impl(spec_symbol) => {
let specialization =
abilities_store.specialization_info(*spec_symbol).expect("expected custom implementations to always have complete specialization info by this point");
let specialized_lambda_set = *specialization
.specialization_lambda_sets
.get(&lset_region)
.unwrap_or_else(|| panic!("lambda set region not resolved: {:?}", (spec_symbol, specialization)));
Ok(specialized_lambda_set)
}
MemberImpl::Error => todo_abilities!(),
},
let external_specialized_lset = match found {
FoundOpaqueSpecialization::UpdatedSpecializationKey(key) => {
specialization_key = key;
continue;
}
})?;
FoundOpaqueSpecialization::AmbientFunction(lset) => lset,
FoundOpaqueSpecialization::NotFound => {
if P::IS_LATE {
internal_error!(
"expected to know a specialization for {:?}#{:?}, but it wasn't found",
opaque,
ability_member
);
} else {
// We'll have reported an error for this.
return Err(());
}
}
};
let specialized_ambient = phase.copy_lambda_set_ambient_function_to_home_subs(
external_specialized_lset,
opaque_home,
subs,
);
let specialized_ambient = phase.copy_lambda_set_ambient_function_to_home_subs(
external_specialized_lset,
opaque_home,
subs,
);
Ok(specialized_ambient)
}
return Ok(specialized_ambient);
}
SpecializationTypeKey::Derived(derive_key) => {
let mut derived_module = derived_env.derived_module.lock().unwrap();
SpecializationTypeKey::Derived(derive_key) => {
let mut derived_module = derived_env.derived_module.lock().unwrap();
let (_, _, specialization_lambda_sets) =
derived_module.get_or_insert(derived_env.exposed_types, derive_key);
let (_, _, specialization_lambda_sets) =
derived_module.get_or_insert(derived_env.exposed_types, derive_key);
let specialized_lambda_set = *specialization_lambda_sets
.get(&lset_region)
.expect("lambda set region not resolved");
let specialized_lambda_set = *specialization_lambda_sets
.get(&lset_region)
.expect("lambda set region not resolved");
let specialized_ambient = derived_module.copy_lambda_set_ambient_function_to_subs(
specialized_lambda_set,
subs,
target_rank,
);
let specialized_ambient = derived_module.copy_lambda_set_ambient_function_to_subs(
specialized_lambda_set,
subs,
target_rank,
);
Ok(specialized_ambient)
}
return Ok(specialized_ambient);
}
SpecializationTypeKey::Immediate(imm) => {
// Immediates are like opaques in that we can simply look up their type definition in
// the ability store, there is nothing new to synthesize.
//
// THEORY: if something can become an immediate, it will always be available in the
// local ability store, because the transformation is local (?)
//
// TODO: I actually think we can get what we need here by examining `derived_env.exposed_types`,
// since immediates can only refer to builtins - and in userspace, all builtin types
// are available in `exposed_types`.
let immediate_lambda_set_at_region =
phase.get_and_copy_ability_member_ambient_function(imm, lset_region, subs);
SpecializationTypeKey::Immediate(imm) => {
// Immediates are like opaques in that we can simply look up their type definition in
// the ability store, there is nothing new to synthesize.
//
// THEORY: if something can become an immediate, it will always be available in the
// local ability store, because the transformation is local (?)
//
// TODO: I actually think we can get what we need here by examining `derived_env.exposed_types`,
// since immediates can only refer to builtins - and in userspace, all builtin types
// are available in `exposed_types`.
let immediate_lambda_set_at_region =
phase.get_and_copy_ability_member_ambient_function(imm, lset_region, subs);
Ok(immediate_lambda_set_at_region)
}
return Ok(immediate_lambda_set_at_region);
}
SpecializationTypeKey::SingleLambdaSetImmediate(imm) => {
let module_id = imm.module_id();
debug_assert!(module_id.is_builtin());
SpecializationTypeKey::SingleLambdaSetImmediate(imm) => {
let module_id = imm.module_id();
debug_assert!(module_id.is_builtin());
let module_types = &derived_env
.exposed_types
.get(&module_id)
.unwrap()
.exposed_types_storage_subs;
let module_types = &derived_env
.exposed_types
.get(&module_id)
.unwrap()
.exposed_types_storage_subs;
// Since this immediate has only one lambda set, the region must be pointing to 1, and
// moreover the imported function type is the ambient function of the single lset.
debug_assert_eq!(lset_region, 1);
let storage_var = module_types.stored_vars_by_symbol.get(&imm).unwrap();
let imported = module_types
.storage_subs
.export_variable_to(subs, *storage_var);
// Since this immediate has only one lambda set, the region must be pointing to 1, and
// moreover the imported function type is the ambient function of the single lset.
debug_assert_eq!(lset_region, 1);
let storage_var = module_types.stored_vars_by_symbol.get(&imm).unwrap();
let imported = module_types
.storage_subs
.export_variable_to(subs, *storage_var);
roc_types::subs::instantiate_rigids(subs, imported.variable);
roc_types::subs::instantiate_rigids(subs, imported.variable);
Ok(imported.variable)
return Ok(imported.variable);
}
}
}
}
enum FoundOpaqueSpecialization {
UpdatedSpecializationKey(SpecializationTypeKey),
AmbientFunction(Variable),
NotFound,
}
fn find_opaque_specialization_ambient_function(
abilities_store: &AbilitiesStore,
opaque: Symbol,
ability_member: Symbol,
lset_region: u8,
) -> FoundOpaqueSpecialization {
let impl_key = roc_can::abilities::ImplKey {
opaque,
ability_member,
};
let opt_specialization = abilities_store.get_implementation(impl_key);
match opt_specialization {
None => match ability_member {
Symbol::INSPECT_TO_INSPECTOR => FoundOpaqueSpecialization::UpdatedSpecializationKey(
SpecializationTypeKey::Immediate(Symbol::INSPECT_OPAQUE),
),
_ => FoundOpaqueSpecialization::NotFound,
},
Some(member_impl) => match member_impl {
MemberImpl::Impl(spec_symbol) => {
let specialization =
abilities_store.specialization_info(*spec_symbol).expect("expected custom implementations to always have complete specialization info by this point");
let specialized_lambda_set = *specialization
.specialization_lambda_sets
.get(&lset_region)
.unwrap_or_else(|| {
panic!(
"lambda set region not resolved: {:?}",
(spec_symbol, specialization)
)
});
FoundOpaqueSpecialization::AmbientFunction(specialized_lambda_set)
}
MemberImpl::Error => todo_abilities!(),
},
}
}