feat(vm): add reference conversion helpers for PLN-0176 step 22

This commit is contained in:
2026-10-07 18:27:10 +01:00
parent 60d66d22a5
commit 8d32fef65c
2 changed files with 275 additions and 0 deletions
@@ -204,3 +204,99 @@ pub(crate) fn unpack_dynamic(
let Value::HeapRef(r) = values[1] else { return Err(ValueError::Type) };
Ok(ValueGroup::new(heap.dynamic_box_values(registry, r, target)?))
}
// All reference operations validate complete source values before querying the
// underlying concrete object. Invalid handles/pairs never become false or null.
fn reference(
registry: &Registry,
heap: &Heap,
source: TypeId,
values: &[Value],
) -> Result<Option<(HeapRef, TypeId)>, ValueError> {
let kind = registry.declarations().types.get(source.0 as usize).ok_or(ValueError::Type)?;
if !matches!(kind.kind, TypeKind::Struct(_) | TypeKind::Array(_) | TypeKind::Trait(_)) {
return Err(ValueError::Type);
}
validate(registry, heap, source, values)?;
match values.first() {
Some(Value::Null) => Ok(None),
Some(Value::HeapRef(receiver)) => {
Ok(Some((*receiver, heap.concrete_type(*receiver, registry)?)))
}
_ => Err(ValueError::Type),
}
}
fn concrete_target(registry: &Registry, target: TypeId) -> Result<(), ValueError> {
if matches!(
registry.declarations().types.get(target.0 as usize).map(|t| &t.kind),
Some(TypeKind::Struct(_) | TypeKind::Array(_))
) {
Ok(())
} else {
Err(ValueError::Type)
}
}
fn trait_target(registry: &Registry, target: TypeId) -> Result<(), ValueError> {
if matches!(
registry.declarations().types.get(target.0 as usize).map(|t| &t.kind),
Some(TypeKind::Trait(_))
) {
Ok(())
} else {
Err(ValueError::Type)
}
}
pub(crate) fn ref_is_exact(
registry: &Registry,
heap: &Heap,
source: TypeId,
target: TypeId,
values: &[Value],
) -> Result<bool, ValueError> {
concrete_target(registry, target)?;
Ok(reference(registry, heap, source, values)?.is_some_and(|(_, ty)| ty == target))
}
pub(crate) fn ref_implements(
registry: &Registry,
heap: &Heap,
source: TypeId,
target: TypeId,
values: &[Value],
) -> Result<bool, ValueError> {
trait_target(registry, target)?;
Ok(reference(registry, heap, source, values)?
.is_some_and(|(_, ty)| registry.implementation(ty, target).is_some()))
}
pub(crate) fn ref_to_trait(
registry: &Registry,
heap: &Heap,
source: TypeId,
target: TypeId,
values: &[Value],
) -> Result<ValueGroup, ValueError> {
trait_target(registry, target)?;
let Some((receiver, ty)) = reference(registry, heap, source, values)? else {
return Ok(ValueGroup::new(&[Value::Null, Value::Null]));
};
let implementation = registry.implementation(ty, target).ok_or(ValueError::Type)?;
Ok(ValueGroup::new(&[Value::HeapRef(receiver), Value::Int64(implementation.0.into())]))
}
pub(crate) fn ref_cast(
registry: &Registry,
heap: &Heap,
source: TypeId,
target: TypeId,
values: &[Value],
) -> Result<ValueGroup, ValueError> {
concrete_target(registry, target)?;
let Some((receiver, ty)) = reference(registry, heap, source, values)? else {
return Ok(ValueGroup::new(&[Value::Null]));
};
if ty != target {
return Err(ValueError::Type);
}
Ok(ValueGroup::new(&[Value::HeapRef(receiver)]))
}
#[cfg(test)]
mod reference_tests;