Files
prometeu-runtime/crates/console/prometeu-vm/src/value_contract.rs
T
bquarkz ec84a6bba5
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
feat(vm)!: implement typed callables and single-context execution
Add structural Fn signatures, typed capture environments, indirect calls and Trait dispatch while preserving logical parameter and result groups, ownership and budgets.

Remove guest coroutine execution and legacy loading. Activate bounded sealed PBX v1 with mandatory capture metadata, preserve frame continuations and root return results, and migrate producers and shipped cartridges.

Publish coordinated specs, handoffs and the completed runtime lesson. Validation: 880 workspace tests passed, 9 existing tests ignored; both cartridges completed six production-host frames.
2026-10-09 05:47:24 +01:00

308 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 = &registry.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<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;