feat: add managed types, source classes and scoped native calls

This commit is contained in:
2026-10-21 01:47:08 +08:00
parent 7c842789c0
commit a970fd7707
48 changed files with 2069 additions and 134 deletions
+83 -1
View File
@@ -2,6 +2,8 @@ use std::collections::BTreeMap;
use std::fmt;
use std::sync::atomic::{AtomicU64, Ordering};
use crate::changes::MAX_PENDING_CHANGES;
use crate::{ChangeBatch, ChangeKey, ObjectChange};
use crate::{EndorObject, ObjectHeader, ObjectPayload, Value, VmError};
static NEXT_HEAP_ID: AtomicU64 = AtomicU64::new(1);
@@ -21,6 +23,11 @@ impl fmt::Display for ObjectRef {
}
}
/// A non-owning reference. Only the originating store can upgrade it; slot
/// reuse never makes a dead weak reference point at a different object.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct WeakObjectRef(pub(crate) ObjectRef);
#[derive(Debug)]
struct Slot {
generation: u64,
@@ -33,6 +40,8 @@ pub(crate) struct Heap {
slots: Vec<Slot>,
free: Vec<usize>,
live: usize,
changes: BTreeMap<(ObjectRef, ChangeKey), u64>,
changes_overflow: bool,
}
impl Heap {
@@ -45,6 +54,8 @@ impl Heap {
slots: Vec::new(),
free: Vec::new(),
live: 0,
changes: BTreeMap::new(),
changes_overflow: false,
})
}
@@ -72,6 +83,8 @@ impl Heap {
identity: reference,
strong_refs: 1,
external_refs: 1,
change_version: 0,
type_object: None,
},
payload,
attributes: BTreeMap::new(),
@@ -92,6 +105,27 @@ impl Heap {
.ok_or(VmError::InvalidHandle)
}
pub(crate) fn attach_type(
&mut self,
reference: ObjectRef,
type_object: ObjectRef,
) -> Result<(), VmError> {
if self.get(reference)?.header.type_object.is_some() {
return Err(VmError::InvalidArgument("object already has a type"));
}
if self.get(reference)?.attributes.contains_key("type") {
return Err(VmError::InvalidArgument(
"type attribute conflicts with managed type",
));
}
let increments = self.prepare_increments(&[type_object])?;
self.prepare_change(reference)?;
self.apply_increments(increments);
self.get_mut(reference)?.header.type_object = Some(type_object);
self.record_change(reference, ChangeKey::Contents);
Ok(())
}
/// Transactional copy-on-update for built-in containers. The EndorObject
/// box and identity stay stable; only its payload and edge snapshot change.
/// All new edges are validated/retained before any old edge is released.
@@ -104,10 +138,12 @@ impl Heap {
let mut edges = Vec::new();
payload.trace(&mut |target| edges.push(target));
let increments = self.prepare_increments(&edges)?;
self.prepare_change(reference)?;
self.apply_increments(increments);
let object = self.get_mut(reference)?;
let old_edges = std::mem::replace(&mut object.payload_edges, edges);
let old_payload = std::mem::replace(&mut object.payload, Box::new(payload));
self.record_change(reference, ChangeKey::Contents);
self.release_edges(old_edges);
drop(old_payload);
Ok(())
@@ -194,8 +230,13 @@ impl Heap {
_ => Vec::new(),
};
let increments = self.prepare_increments(&edges)?;
self.prepare_change(reference)?;
self.apply_increments(increments);
let old = self.get_mut(reference)?.attributes.insert(name, value);
let old = self
.get_mut(reference)?
.attributes
.insert(name.clone(), value);
self.record_change(reference, ChangeKey::Attribute(name));
if let Some(Value::Object(target)) = old {
self.release_edges(vec![target]);
}
@@ -213,17 +254,58 @@ impl Heap {
pub(crate) fn del_attr(&mut self, reference: ObjectRef, name: &str) -> Result<(), VmError> {
self.check_attributes(reference)?;
self.prepare_change(reference)?;
let old = self
.get_mut(reference)?
.attributes
.remove(name)
.ok_or_else(|| VmError::AttributeNotFound(name.into()))?;
self.record_change(reference, ChangeKey::Attribute(name.into()));
if let Value::Object(target) = old {
self.release_edges(vec![target]);
}
Ok(())
}
pub(crate) fn prepare_change(&self, reference: ObjectRef) -> Result<(), VmError> {
self.get(reference)?
.header
.change_version
.checked_add(1)
.ok_or(VmError::ExecutionLimit("object change version"))?;
Ok(())
}
pub(crate) fn record_change(&mut self, reference: ObjectRef, key: ChangeKey) {
let object = self.get_mut(reference).expect("validated change target");
object.header.change_version += 1;
let version = object.header.change_version;
if self.changes_overflow {
return;
}
let entry = (reference, key);
if self.changes.len() >= MAX_PENDING_CHANGES && !self.changes.contains_key(&entry) {
self.changes.clear();
self.changes_overflow = true;
} else {
self.changes.insert(entry, version);
}
}
pub(crate) fn take_changes(&mut self) -> ChangeBatch {
ChangeBatch {
changes: std::mem::take(&mut self.changes)
.into_iter()
.map(|((object, key), version)| ObjectChange {
object,
key,
version,
})
.collect(),
rescan_required: std::mem::take(&mut self.changes_overflow),
}
}
fn check_attributes(&self, reference: ObjectRef) -> Result<(), VmError> {
if !self.get(reference)?.payload.allows_attributes() {
return Err(VmError::UnsupportedOperation("attributes"));