303 lines
10 KiB
Rust
303 lines
10 KiB
Rust
//! 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<ResourceFailure> 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<u32, ValueError> {
|
|
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::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<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<Registry>,
|
|
heap: &mut Heap,
|
|
type_id: TypeId,
|
|
values: &[Value],
|
|
) -> Result<ValueGroup, ValueError> {
|
|
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<bool, ValueError> {
|
|
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<ValueGroup, ValueError> {
|
|
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<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;
|