From 8d32fef65c96ff990483b4b5fe9d7b6b32ada1d6 Mon Sep 17 00:00:00 2001 From: bQUARKz Date: Wed, 7 Oct 2026 18:27:10 +0100 Subject: [PATCH] feat(vm): add reference conversion helpers for PLN-0176 step 22 --- .../console/prometeu-vm/src/value_contract.rs | 96 ++++++++++ .../src/value_contract/reference_tests.rs | 179 ++++++++++++++++++ 2 files changed, 275 insertions(+) create mode 100644 crates/console/prometeu-vm/src/value_contract/reference_tests.rs diff --git a/crates/console/prometeu-vm/src/value_contract.rs b/crates/console/prometeu-vm/src/value_contract.rs index 329705b..2303aa0 100644 --- a/crates/console/prometeu-vm/src/value_contract.rs +++ b/crates/console/prometeu-vm/src/value_contract.rs @@ -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, 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 { + 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 { + 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 { + 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 { + 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; diff --git a/crates/console/prometeu-vm/src/value_contract/reference_tests.rs b/crates/console/prometeu-vm/src/value_contract/reference_tests.rs new file mode 100644 index 0000000..8e0c7f1 --- /dev/null +++ b/crates/console/prometeu-vm/src/value_contract/reference_tests.rs @@ -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, 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 + ); +}