feat(registry): checkpoint PLN-0176 foundations and validated partial integrations
This commit is contained in:
@@ -0,0 +1,206 @@
|
||||
//! 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)?))
|
||||
}
|
||||
Reference in New Issue
Block a user