feat(vm): add reference conversion helpers for PLN-0176 step 22
This commit is contained in:
@@ -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
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user