//! Exact Registry-aware boundary checks. No numeric coercion or object-graph walk. use crate::heap::Heap; use crate::resource_budget::ResourceFailure; use prometeu_bytecode::registry::{BuiltinId as B, Registry, TypeId, TypeKind}; use prometeu_bytecode::{HeapRef, Value}; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub(crate) enum ValueError { Type, InvalidHandle, NullReference, Bounds, Resource(ResourceFailure), } impl From for ValueError { fn from(value: ResourceFailure) -> Self { Self::Resource(value) } } /// The accepted catalogue has at most three slots per stored value. This buffer /// clones native owners, but never allocates a temporary Vec for a read. #[derive(Debug)] pub(crate) struct ValueGroup { values: [Value; 3], len: usize, } impl ValueGroup { pub fn new(values: &[Value]) -> Self { assert!(values.len() <= 3); let mut result = Self { values: [Value::Null, Value::Null, Value::Null], len: values.len() }; result.values[..values.len()].clone_from_slice(values); result } pub fn as_slice(&self) -> &[Value] { &self.values[..self.len] } } pub(crate) fn u32_carrier(value: &Value) -> Result { match value { Value::Int64(n) => u32::try_from(*n).map_err(|_| ValueError::Type), _ => Err(ValueError::Type), } } pub(crate) fn validate( registry: &Registry, heap: &Heap, type_id: TypeId, values: &[Value], ) -> Result<(), ValueError> { let layout = registry.type_layout(type_id).ok_or(ValueError::Type)?; if values.len() != layout.storage.slots as usize { return Err(ValueError::Type); } let kind = ®istry.declarations().types[type_id.0 as usize].kind; let valid = match kind { TypeKind::Struct(_) | TypeKind::Array(_) => match &values[0] { Value::Null => true, Value::HeapRef(r) => { if r.is_null() { return Err(ValueError::Type); } heap.concrete_type(*r, registry)? == type_id } _ => false, }, TypeKind::Fn(_) => match &values[0] { Value::Null => true, Value::HeapRef(r) if !r.is_null() => heap.closure_type(*r)? == type_id, _ => false, }, TypeKind::Trait(_) => return validate_trait(registry, heap, type_id, values), TypeKind::Builtin(B::DYNAMIC) => return validate_dynamic(registry, heap, values), TypeKind::Builtin(id) => match (*id, values) { (B::INT32, [Value::Int32(_)]) | (B::INT64, [Value::Int64(_)]) | (B::FLOAT, [Value::Float(_)]) | (B::BOOL, [Value::Boolean(_)]) | (B::STRING, [Value::String(_) | Value::Null]) | (B::VEC2, [Value::Float(_), Value::Float(_)]) => true, (B::COLOR, [color]) => u32_carrier(color).is_ok(), (B::PIXEL, [Value::Int64(_), Value::Int64(_), color]) => u32_carrier(color).is_ok(), _ => false, }, }; if valid { Ok(()) } else { Err(ValueError::Type) } } fn validate_trait( registry: &Registry, heap: &Heap, trait_id: TypeId, values: &[Value], ) -> Result<(), ValueError> { if matches!(values, [Value::Null, Value::Null]) { return Ok(()); } let [Value::HeapRef(receiver), implementation] = values else { return Err(ValueError::Type) }; if receiver.is_null() { return Err(ValueError::Type); } let owner = heap.concrete_type(*receiver, registry)?; let id = u32_carrier(implementation)?; let implementation = registry.declarations().implementations.get(id as usize).ok_or(ValueError::Type)?; if implementation.owner == owner && implementation.trait_id == trait_id { Ok(()) } else { Err(ValueError::Type) } } fn validate_dynamic(registry: &Registry, heap: &Heap, values: &[Value]) -> Result<(), ValueError> { if values.len() != 2 { return Err(ValueError::Type); } if matches!(values, [Value::Null, Value::Null]) { return Ok(()); } let type_id = TypeId(u32_carrier(&values[0])?); let layout = registry.type_layout(type_id).ok_or(ValueError::Type)?; if matches!( registry.declarations().types[type_id.0 as usize].kind, TypeKind::Builtin(B::DYNAMIC) ) { return Err(ValueError::Type); // Repacking is identity, never Dynamic. } if matches!(values[1], Value::Null) { return if layout.storage.nullable() { Ok(()) } else { Err(ValueError::Type) }; } if layout.storage.slots == 1 { return validate(registry, heap, type_id, &values[1..]); } let Value::HeapRef(handle) = values[1] else { return Err(ValueError::Type) }; if handle == HeapRef::NULL { return Err(ValueError::Type); } heap.dynamic_box_values(registry, handle, type_id)?; Ok(()) } /// Semantic pack helper. The interpreter must retain source stack roots until /// this returns and publish/consume the complete group atomically. pub(crate) fn pack_dynamic( registry: &std::sync::Arc, heap: &mut Heap, type_id: TypeId, values: &[Value], ) -> Result { validate(registry, heap, type_id, values)?; if is_dynamic(registry, type_id) { return Ok(ValueGroup::new(values)); } let payload = if values.iter().all(|v| matches!(v, Value::Null)) { Value::Null // Includes absent traits: typed null does not need a box. } else if values.len() == 1 { values[0].clone() } else { Value::HeapRef(heap.allocate_dynamic_box(registry.clone(), type_id, values)?) }; Ok(ValueGroup::new(&[Value::Int64(type_id.0.into()), payload])) } fn is_dynamic(registry: &Registry, type_id: TypeId) -> bool { matches!(registry.declarations().types[type_id.0 as usize].kind, TypeKind::Builtin(B::DYNAMIC)) } /// Compatibility validates malformed input even for a mismatched destination. /// No allocation, extraction, or Arc/box clone occurs in a query. pub(crate) fn can_unpack_dynamic( registry: &Registry, heap: &Heap, target: TypeId, values: &[Value], ) -> Result { let target_layout = registry.type_layout(target).ok_or(ValueError::Type)?; validate_dynamic(registry, heap, values)?; if is_dynamic(registry, target) { return Ok(true); } match &values[0] { Value::Null => Ok(target_layout.storage.nullable()), tag => Ok(TypeId(u32_carrier(tag)?) == target), } } pub(crate) fn unpack_dynamic( registry: &Registry, heap: &Heap, target: TypeId, values: &[Value], ) -> Result { if !can_unpack_dynamic(registry, heap, target, values)? { return Err(ValueError::Type); } if is_dynamic(registry, target) { return Ok(ValueGroup::new(values)); } let layout = registry.type_layout(target).unwrap().storage; if matches!(values[1], Value::Null) { return Ok(ValueGroup::new(layout.default_values())); } if layout.slots == 1 { return Ok(ValueGroup::new(&values[1..])); } 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;