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;
@@ -0,0 +1,179 @@
use super::*;
use crate::resource_budget::{RuntimeBudget, RuntimeLimits, RuntimeResource as Q};
use prometeu_bytecode::load_limits::LoadBudget;
use prometeu_bytecode::registry::{ImplementationDecl, RegistryDeclarations, TypeDecl};
use std::sync::Arc;
fn fixture() -> (Arc<Registry>, Heap, RuntimeBudget) {
let kind = |kind| TypeDecl { name: None, kind };
let registry = Arc::new(
Registry::resolve(
RegistryDeclarations {
types: vec![
kind(TypeKind::Builtin(B::INT32)),
kind(TypeKind::Struct(vec![])),
kind(TypeKind::Struct(vec![])),
kind(TypeKind::Array(TypeId(0))),
kind(TypeKind::Array(TypeId(1))),
kind(TypeKind::Trait(vec![])),
kind(TypeKind::Trait(vec![])),
kind(TypeKind::Builtin(B::DYNAMIC)),
],
functions: vec![],
implementations: vec![
ImplementationDecl { owner: TypeId(1), trait_id: TypeId(5), methods: vec![] },
ImplementationDecl { owner: TypeId(1), trait_id: TypeId(6), methods: vec![] },
ImplementationDecl { owner: TypeId(2), trait_id: TypeId(6), methods: vec![] },
],
},
0,
&mut LoadBudget::new(Default::default()),
)
.unwrap(),
);
let budget = RuntimeBudget::new(RuntimeLimits::default());
let heap = Heap::with_budget(&budget);
(registry, heap, budget)
}
#[test]
fn cross_trait_conversion_preserves_receiver_and_accepts_implementation_zero() {
let (r, mut heap, budget) = fixture();
let receiver = heap.allocate_typed_struct(r.clone(), TypeId(1)).unwrap();
let concrete = [Value::HeapRef(receiver)];
let before =
[budget.used(Q::GuestBytes), budget.used(Q::AuxiliaryBytes), budget.used(Q::HandleSlots)];
let first = ref_to_trait(&r, &heap, TypeId(1), TypeId(5), &concrete).unwrap();
assert!(matches!(first.as_slice(), [Value::HeapRef(h), Value::Int64(0)] if *h == receiver));
let second = ref_to_trait(&r, &heap, TypeId(5), TypeId(6), first.as_slice()).unwrap();
assert!(matches!(second.as_slice(), [Value::HeapRef(h), Value::Int64(1)] if *h == receiver));
assert!(ref_implements(&r, &heap, TypeId(5), TypeId(6), first.as_slice()).unwrap());
assert!(ref_is_exact(&r, &heap, TypeId(6), TypeId(1), second.as_slice()).unwrap());
let restored = ref_cast(&r, &heap, TypeId(6), TypeId(1), second.as_slice()).unwrap();
assert!(matches!(restored.as_slice(), [Value::HeapRef(h)] if *h == receiver));
assert_eq!(
before,
[budget.used(Q::GuestBytes), budget.used(Q::AuxiliaryBytes), budget.used(Q::HandleSlots)]
);
}
#[test]
fn null_queries_are_false_and_null_conversions_preserve_absence() {
let (r, heap, _) = fixture();
for (source, values) in [
(TypeId(1), vec![Value::Null]),
(TypeId(3), vec![Value::Null]),
(TypeId(5), vec![Value::Null, Value::Null]),
] {
assert!(!ref_is_exact(&r, &heap, source, TypeId(1), &values).unwrap());
assert!(!ref_implements(&r, &heap, source, TypeId(5), &values).unwrap());
assert!(matches!(
ref_cast(&r, &heap, source, TypeId(1), &values).unwrap().as_slice(),
[Value::Null]
));
assert!(matches!(
ref_to_trait(&r, &heap, source, TypeId(5), &values).unwrap().as_slice(),
[Value::Null, Value::Null]
));
}
}
#[test]
fn incompatible_present_values_fault_only_on_conversion() {
let (r, mut heap, _) = fixture();
let receiver = heap.allocate_typed_struct(r.clone(), TypeId(2)).unwrap();
let values = [Value::HeapRef(receiver)];
assert!(!ref_is_exact(&r, &heap, TypeId(2), TypeId(1), &values).unwrap());
assert!(!ref_implements(&r, &heap, TypeId(2), TypeId(5), &values).unwrap());
assert_eq!(ref_cast(&r, &heap, TypeId(2), TypeId(1), &values).unwrap_err(), ValueError::Type);
assert_eq!(
ref_to_trait(&r, &heap, TypeId(2), TypeId(5), &values).unwrap_err(),
ValueError::Type
);
// The actual U view of B cannot masquerade as the T view of A.
let view = ref_to_trait(&r, &heap, TypeId(2), TypeId(6), &values).unwrap();
assert_eq!(
ref_to_trait(&r, &heap, TypeId(6), TypeId(5), view.as_slice()).unwrap_err(),
ValueError::Type
);
}
#[test]
fn arrays_use_exact_constructor_identity_and_never_implement_traits() {
let (r, mut heap, _) = fixture();
let receiver = heap.allocate_typed_array(r.clone(), TypeId(3), 0).unwrap();
let values = [Value::HeapRef(receiver)];
assert!(ref_is_exact(&r, &heap, TypeId(3), TypeId(3), &values).unwrap());
assert!(!ref_is_exact(&r, &heap, TypeId(3), TypeId(4), &values).unwrap());
assert!(!ref_implements(&r, &heap, TypeId(3), TypeId(5), &values).unwrap());
assert_eq!(ref_cast(&r, &heap, TypeId(3), TypeId(4), &values).unwrap_err(), ValueError::Type);
assert_eq!(
ref_to_trait(&r, &heap, TypeId(3), TypeId(5), &values).unwrap_err(),
ValueError::Type
);
}
#[test]
fn malformed_trait_pairs_are_not_ordinary_mismatches() {
let (r, mut heap, _) = fixture();
let receiver = heap.allocate_typed_struct(r.clone(), TypeId(1)).unwrap();
for values in [
vec![Value::Null, Value::Int64(0)],
vec![Value::Null, Value::Int64(1)],
vec![Value::HeapRef(receiver), Value::Int32(0)],
vec![Value::HeapRef(receiver), Value::Int64(1)],
vec![Value::HeapRef(receiver), Value::Int64(2)],
vec![Value::HeapRef(receiver), Value::Int64(-1)],
vec![Value::HeapRef(receiver), Value::Int64(u32::MAX.into())],
] {
assert_eq!(ref_is_exact(&r, &heap, TypeId(5), TypeId(2), &values), Err(ValueError::Type));
assert_eq!(ref_implements(&r, &heap, TypeId(5), TypeId(6), &values), Err(ValueError::Type));
assert_eq!(
ref_to_trait(&r, &heap, TypeId(5), TypeId(6), &values).unwrap_err(),
ValueError::Type
);
}
}
#[test]
fn stale_wrong_registry_and_false_source_type_remain_errors() {
let (r, mut heap, _) = fixture();
let receiver = heap.allocate_typed_struct(r.clone(), TypeId(1)).unwrap();
let values = [Value::HeapRef(receiver)];
assert_eq!(ref_is_exact(&r, &heap, TypeId(2), TypeId(1), &values), Err(ValueError::Type));
let (other, _, _) = fixture();
assert_eq!(ref_implements(&other, &heap, TypeId(1), TypeId(5), &values), Err(ValueError::Type));
heap.mark_from_roots([]).unwrap();
heap.sweep();
assert_eq!(
ref_is_exact(&r, &heap, TypeId(1), TypeId(2), &values),
Err(ValueError::InvalidHandle)
);
assert_eq!(
ref_to_trait(&r, &heap, TypeId(1), TypeId(5), &values).unwrap_err(),
ValueError::InvalidHandle
);
}
#[test]
fn reference_operations_reject_dynamic_builtin_and_wrong_immediate_categories() {
let (r, heap, _) = fixture();
for source in [TypeId(0), TypeId(7), TypeId(u32::MAX)] {
assert_eq!(
ref_is_exact(&r, &heap, source, TypeId(1), &[Value::Null]),
Err(ValueError::Type)
);
}
assert_eq!(
ref_is_exact(&r, &heap, TypeId(1), TypeId(5), &[Value::Null]),
Err(ValueError::Type)
);
assert_eq!(
ref_implements(&r, &heap, TypeId(1), TypeId(1), &[Value::Null]),
Err(ValueError::Type)
);
assert_eq!(
ref_cast(&r, &heap, TypeId(1), TypeId(u32::MAX), &[Value::Null]).unwrap_err(),
ValueError::Type
);
}