Shorten crate directory names and update workspace paths
Verify databases and deploy Aster VM / verify-and-deploy (push) Successful in 14m53s
Verify databases and deploy Aster VM / verify-and-deploy (push) Successful in 14m53s
This commit is contained in:
@@ -0,0 +1,9 @@
|
||||
[package]
|
||||
name = "aster-core"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
rust-version.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
@@ -0,0 +1,393 @@
|
||||
use std::any::Any;
|
||||
use std::collections::hash_map::DefaultHasher;
|
||||
use std::hash::{Hash, Hasher};
|
||||
|
||||
use crate::{CompareOp, ObjectPayload, ObjectRef, Value, VmError};
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct EndorStringObject {
|
||||
text: String,
|
||||
}
|
||||
|
||||
impl EndorStringObject {
|
||||
pub fn new(text: impl Into<String>) -> Self {
|
||||
Self { text: text.into() }
|
||||
}
|
||||
|
||||
pub fn as_str(&self) -> &str {
|
||||
&self.text
|
||||
}
|
||||
|
||||
pub fn char_count(&self) -> usize {
|
||||
self.text.chars().count()
|
||||
}
|
||||
|
||||
pub fn char_at(&self, index: usize) -> Option<char> {
|
||||
self.text.chars().nth(index)
|
||||
}
|
||||
}
|
||||
|
||||
impl ObjectPayload for EndorStringObject {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"string"
|
||||
}
|
||||
fn repr(&self, _identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(format!("{:?}", self.text))
|
||||
}
|
||||
fn str(&self, _identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(self.text.clone())
|
||||
}
|
||||
fn is_true(&self) -> Result<bool, VmError> {
|
||||
Ok(!self.text.is_empty())
|
||||
}
|
||||
fn hash(&self, _identity: ObjectRef) -> Result<u64, VmError> {
|
||||
let mut hasher = DefaultHasher::new();
|
||||
self.text.hash(&mut hasher);
|
||||
Ok(hasher.finish())
|
||||
}
|
||||
fn compare(&self, other: &dyn ObjectPayload, op: CompareOp) -> Result<Option<bool>, VmError> {
|
||||
let Some(other) = other.as_any().downcast_ref::<Self>() else {
|
||||
return Ok(None);
|
||||
};
|
||||
Ok(Some(match op {
|
||||
CompareOp::Eq => self.text == other.text,
|
||||
CompareOp::Ne => self.text != other.text,
|
||||
CompareOp::Lt => self.text < other.text,
|
||||
CompareOp::Le => self.text <= other.text,
|
||||
CompareOp::Gt => self.text > other.text,
|
||||
CompareOp::Ge => self.text >= other.text,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
/// Insertion-ordered entries. Mutation is only exposed through Vm so every
|
||||
/// key/value reference is validated, retained, traced, and released correctly.
|
||||
/// Linear lookup is intentional for the initial representation layer.
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct EndorDictObject {
|
||||
pub(crate) entries: Vec<(Value, Value)>,
|
||||
}
|
||||
|
||||
impl EndorDictObject {
|
||||
pub fn new() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
pub fn len(&self) -> usize {
|
||||
self.entries.len()
|
||||
}
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.entries.is_empty()
|
||||
}
|
||||
pub fn entries(&self) -> &[(Value, Value)] {
|
||||
&self.entries
|
||||
}
|
||||
}
|
||||
|
||||
impl ObjectPayload for EndorDictObject {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"dict"
|
||||
}
|
||||
fn trace(&self, visit: &mut dyn FnMut(ObjectRef)) {
|
||||
for (key, value) in &self.entries {
|
||||
trace_value(key, visit);
|
||||
trace_value(value, visit);
|
||||
}
|
||||
}
|
||||
fn repr(&self, _identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(format!("<dict len={}>", self.len()))
|
||||
}
|
||||
fn is_true(&self) -> Result<bool, VmError> {
|
||||
Ok(!self.is_empty())
|
||||
}
|
||||
fn hash(&self, _identity: ObjectRef) -> Result<u64, VmError> {
|
||||
Err(VmError::UnsupportedOperation("dict hash"))
|
||||
}
|
||||
}
|
||||
|
||||
/// An empty cell differs from a cell containing Value::Nil.
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct EndorCellObject {
|
||||
pub(crate) value: Option<Value>,
|
||||
}
|
||||
|
||||
impl EndorCellObject {
|
||||
pub fn new(value: Option<Value>) -> Self {
|
||||
Self { value }
|
||||
}
|
||||
pub fn value(&self) -> Option<&Value> {
|
||||
self.value.as_ref()
|
||||
}
|
||||
}
|
||||
|
||||
impl ObjectPayload for EndorCellObject {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"cell"
|
||||
}
|
||||
fn trace(&self, visit: &mut dyn FnMut(ObjectRef)) {
|
||||
if let Some(value) = &self.value {
|
||||
trace_value(value, visit);
|
||||
}
|
||||
}
|
||||
fn repr(&self, _identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(if self.value.is_some() {
|
||||
"<cell occupied>"
|
||||
} else {
|
||||
"<cell empty>"
|
||||
}
|
||||
.into())
|
||||
}
|
||||
fn hash(&self, _identity: ObjectRef) -> Result<u64, VmError> {
|
||||
Err(VmError::UnsupportedOperation("cell hash"))
|
||||
}
|
||||
}
|
||||
|
||||
/// Code data only: bytecode is opaque until an instruction format/executor
|
||||
/// is defined. Constants may own managed objects through the enclosing function.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct EndorCode {
|
||||
bytecode: Vec<u8>,
|
||||
constants: Vec<Value>,
|
||||
parameters: Vec<String>,
|
||||
free_variables: Vec<String>,
|
||||
}
|
||||
|
||||
impl EndorCode {
|
||||
pub fn new(
|
||||
bytecode: Vec<u8>,
|
||||
constants: Vec<Value>,
|
||||
parameters: Vec<String>,
|
||||
free_variables: Vec<String>,
|
||||
) -> Result<Self, VmError> {
|
||||
for names in [¶meters, &free_variables] {
|
||||
let mut seen = std::collections::BTreeSet::new();
|
||||
for name in names {
|
||||
if name.is_empty() || !seen.insert(name) {
|
||||
return Err(VmError::InvalidArgument(
|
||||
"empty or duplicate code variable name",
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Self {
|
||||
bytecode,
|
||||
constants,
|
||||
parameters,
|
||||
free_variables,
|
||||
})
|
||||
}
|
||||
pub fn bytecode(&self) -> &[u8] {
|
||||
&self.bytecode
|
||||
}
|
||||
pub fn constants(&self) -> &[Value] {
|
||||
&self.constants
|
||||
}
|
||||
pub fn parameters(&self) -> &[String] {
|
||||
&self.parameters
|
||||
}
|
||||
pub fn free_variables(&self) -> &[String] {
|
||||
&self.free_variables
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct EndorFunctionObject {
|
||||
name: String,
|
||||
code: EndorCode,
|
||||
globals: ObjectRef,
|
||||
defaults: Vec<Value>,
|
||||
closure: Vec<ObjectRef>,
|
||||
}
|
||||
|
||||
impl EndorFunctionObject {
|
||||
pub fn new(
|
||||
name: impl Into<String>,
|
||||
code: EndorCode,
|
||||
globals: ObjectRef,
|
||||
defaults: Vec<Value>,
|
||||
closure: Vec<ObjectRef>,
|
||||
) -> Result<Self, VmError> {
|
||||
if defaults.len() > code.parameters.len() || closure.len() != code.free_variables.len() {
|
||||
return Err(VmError::InvalidArgument(
|
||||
"function defaults or closure do not match code",
|
||||
));
|
||||
}
|
||||
Ok(Self {
|
||||
name: name.into(),
|
||||
code,
|
||||
globals,
|
||||
defaults,
|
||||
closure,
|
||||
})
|
||||
}
|
||||
pub fn name(&self) -> &str {
|
||||
&self.name
|
||||
}
|
||||
pub fn code(&self) -> &EndorCode {
|
||||
&self.code
|
||||
}
|
||||
pub fn globals(&self) -> ObjectRef {
|
||||
self.globals
|
||||
}
|
||||
pub fn defaults(&self) -> &[Value] {
|
||||
&self.defaults
|
||||
}
|
||||
pub fn closure(&self) -> &[ObjectRef] {
|
||||
&self.closure
|
||||
}
|
||||
}
|
||||
|
||||
impl ObjectPayload for EndorFunctionObject {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"function"
|
||||
}
|
||||
fn allows_attributes(&self) -> bool {
|
||||
true
|
||||
}
|
||||
fn trace(&self, visit: &mut dyn FnMut(ObjectRef)) {
|
||||
visit(self.globals);
|
||||
for reference in &self.closure {
|
||||
visit(*reference);
|
||||
}
|
||||
for value in self.defaults.iter().chain(&self.code.constants) {
|
||||
trace_value(value, visit);
|
||||
}
|
||||
}
|
||||
fn repr(&self, _identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(format!("<function {}>", self.name))
|
||||
}
|
||||
fn call(&self, _arguments: &[Value]) -> Result<Value, VmError> {
|
||||
Err(VmError::UnsupportedOperation("language function execution"))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct EndorTracebackEntry {
|
||||
pub function: String,
|
||||
pub file: String,
|
||||
pub line: usize,
|
||||
}
|
||||
|
||||
/// Common exception instance data, not an exception class or inheritance tree.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct EndorBaseExceptionObject {
|
||||
name: String,
|
||||
args: Vec<Value>,
|
||||
cause: Option<ObjectRef>,
|
||||
context: Option<ObjectRef>,
|
||||
suppress_context: bool,
|
||||
notes: Vec<String>,
|
||||
traceback: Vec<EndorTracebackEntry>,
|
||||
}
|
||||
|
||||
impl EndorBaseExceptionObject {
|
||||
pub fn new(name: impl Into<String>, args: Vec<Value>) -> Self {
|
||||
Self {
|
||||
name: name.into(),
|
||||
args,
|
||||
cause: None,
|
||||
context: None,
|
||||
suppress_context: false,
|
||||
notes: Vec::new(),
|
||||
traceback: Vec::new(),
|
||||
}
|
||||
}
|
||||
pub fn with_cause(mut self, cause: ObjectRef) -> Self {
|
||||
self.cause = Some(cause);
|
||||
self.suppress_context = true;
|
||||
self
|
||||
}
|
||||
pub fn with_context(mut self, context: ObjectRef) -> Self {
|
||||
self.context = Some(context);
|
||||
self
|
||||
}
|
||||
pub fn suppress_context(mut self, suppress: bool) -> Self {
|
||||
self.suppress_context = suppress;
|
||||
self
|
||||
}
|
||||
pub fn with_note(mut self, note: impl Into<String>) -> Self {
|
||||
self.notes.push(note.into());
|
||||
self
|
||||
}
|
||||
pub fn with_traceback(mut self, entry: EndorTracebackEntry) -> Self {
|
||||
self.traceback.push(entry);
|
||||
self
|
||||
}
|
||||
pub fn name(&self) -> &str {
|
||||
&self.name
|
||||
}
|
||||
pub fn args(&self) -> &[Value] {
|
||||
&self.args
|
||||
}
|
||||
pub fn cause(&self) -> Option<ObjectRef> {
|
||||
self.cause
|
||||
}
|
||||
pub fn context(&self) -> Option<ObjectRef> {
|
||||
self.context
|
||||
}
|
||||
pub fn context_suppressed(&self) -> bool {
|
||||
self.suppress_context
|
||||
}
|
||||
pub fn notes(&self) -> &[String] {
|
||||
&self.notes
|
||||
}
|
||||
pub fn traceback(&self) -> &[EndorTracebackEntry] {
|
||||
&self.traceback
|
||||
}
|
||||
}
|
||||
|
||||
impl ObjectPayload for EndorBaseExceptionObject {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"exception"
|
||||
}
|
||||
fn allows_attributes(&self) -> bool {
|
||||
true
|
||||
}
|
||||
fn trace(&self, visit: &mut dyn FnMut(ObjectRef)) {
|
||||
for value in &self.args {
|
||||
trace_value(value, visit);
|
||||
}
|
||||
for reference in [self.cause, self.context].into_iter().flatten() {
|
||||
visit(reference);
|
||||
}
|
||||
}
|
||||
fn repr(&self, _identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(format!(
|
||||
"{}({})",
|
||||
self.name,
|
||||
self.args
|
||||
.iter()
|
||||
.map(|arg| format!("{arg:?}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(", ")
|
||||
))
|
||||
}
|
||||
fn str(&self, _identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(match self.args.as_slice() {
|
||||
[] => String::new(),
|
||||
[Value::Text(text)] => text.clone(),
|
||||
[Value::Number(number)] => number.to_string(),
|
||||
args => format!("{args:?}"),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn trace_value(value: &Value, visit: &mut dyn FnMut(ObjectRef)) {
|
||||
if let Value::Object(reference) = value {
|
||||
visit(*reference);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,381 @@
|
||||
use std::collections::BTreeMap;
|
||||
use std::fmt;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
|
||||
use crate::{EndorObject, ObjectHeader, ObjectPayload, Value, VmError};
|
||||
|
||||
static NEXT_HEAP_ID: AtomicU64 = AtomicU64::new(1);
|
||||
|
||||
/// Checked, process-local reference. Copying it never retains an object.
|
||||
/// The generation prevents a released handle from aliasing a reused slot.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
pub struct ObjectRef {
|
||||
heap_id: u64,
|
||||
index: usize,
|
||||
generation: u64,
|
||||
}
|
||||
|
||||
impl fmt::Display for ObjectRef {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "{}:{}:{}", self.heap_id, self.index, self.generation)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Slot {
|
||||
generation: u64,
|
||||
object: Option<Box<EndorObject>>,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct Heap {
|
||||
id: u64,
|
||||
slots: Vec<Slot>,
|
||||
free: Vec<usize>,
|
||||
live: usize,
|
||||
}
|
||||
|
||||
impl Heap {
|
||||
pub(crate) fn new() -> Result<Self, VmError> {
|
||||
let id = NEXT_HEAP_ID
|
||||
.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |id| id.checked_add(1))
|
||||
.map_err(|_| VmError::IdentityExhausted)?;
|
||||
Ok(Self {
|
||||
id,
|
||||
slots: Vec::new(),
|
||||
free: Vec::new(),
|
||||
live: 0,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn allocate(
|
||||
&mut self,
|
||||
payload: Box<dyn ObjectPayload>,
|
||||
) -> Result<ObjectRef, VmError> {
|
||||
let mut edges = Vec::new();
|
||||
payload.trace(&mut |reference| edges.push(reference));
|
||||
let increments = self.prepare_increments(&edges)?;
|
||||
let index = self.free.pop().unwrap_or(self.slots.len());
|
||||
if index == self.slots.len() {
|
||||
self.slots.push(Slot {
|
||||
generation: 0,
|
||||
object: None,
|
||||
});
|
||||
}
|
||||
let reference = ObjectRef {
|
||||
heap_id: self.id,
|
||||
index,
|
||||
generation: self.slots[index].generation,
|
||||
};
|
||||
let object = Box::new(EndorObject {
|
||||
header: ObjectHeader {
|
||||
identity: reference,
|
||||
strong_refs: 1,
|
||||
external_refs: 1,
|
||||
},
|
||||
payload,
|
||||
attributes: BTreeMap::new(),
|
||||
payload_edges: edges,
|
||||
});
|
||||
self.apply_increments(increments);
|
||||
self.slots[index].object = Some(object);
|
||||
self.live += 1;
|
||||
Ok(reference)
|
||||
}
|
||||
|
||||
pub(crate) fn get(&self, reference: ObjectRef) -> Result<&EndorObject, VmError> {
|
||||
self.validate_owner(reference)?;
|
||||
self.slots
|
||||
.get(reference.index)
|
||||
.filter(|slot| slot.generation == reference.generation)
|
||||
.and_then(|slot| slot.object.as_deref())
|
||||
.ok_or(VmError::InvalidHandle)
|
||||
}
|
||||
|
||||
/// 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.
|
||||
pub(crate) fn replace_payload(
|
||||
&mut self,
|
||||
reference: ObjectRef,
|
||||
payload: impl ObjectPayload,
|
||||
) -> Result<(), VmError> {
|
||||
self.get(reference)?;
|
||||
let mut edges = Vec::new();
|
||||
payload.trace(&mut |target| edges.push(target));
|
||||
let increments = self.prepare_increments(&edges)?;
|
||||
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.release_edges(old_edges);
|
||||
drop(old_payload);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn get_mut(&mut self, reference: ObjectRef) -> Result<&mut EndorObject, VmError> {
|
||||
self.get(reference)?;
|
||||
Ok(self.slots[reference.index].object.as_deref_mut().unwrap())
|
||||
}
|
||||
|
||||
fn validate_owner(&self, reference: ObjectRef) -> Result<(), VmError> {
|
||||
if reference.heap_id != self.id {
|
||||
return Err(VmError::ForeignHandle);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn prepare_increments(
|
||||
&self,
|
||||
references: &[ObjectRef],
|
||||
) -> Result<BTreeMap<ObjectRef, usize>, VmError> {
|
||||
let mut counts = BTreeMap::<ObjectRef, usize>::new();
|
||||
for reference in references {
|
||||
self.get(*reference)?;
|
||||
let count = counts.entry(*reference).or_default();
|
||||
*count = count.checked_add(1).ok_or(VmError::RefCountOverflow)?;
|
||||
}
|
||||
for (reference, count) in &counts {
|
||||
self.get(*reference)?
|
||||
.header
|
||||
.strong_refs
|
||||
.checked_add(*count)
|
||||
.ok_or(VmError::RefCountOverflow)?;
|
||||
}
|
||||
Ok(counts)
|
||||
}
|
||||
|
||||
fn apply_increments(&mut self, increments: BTreeMap<ObjectRef, usize>) {
|
||||
for (reference, count) in increments {
|
||||
self.get_mut(reference).unwrap().header.strong_refs += count;
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn retain(&mut self, reference: ObjectRef) -> Result<(), VmError> {
|
||||
let header = &mut self.get_mut(reference)?.header;
|
||||
let strong = header
|
||||
.strong_refs
|
||||
.checked_add(1)
|
||||
.ok_or(VmError::RefCountOverflow)?;
|
||||
let external = header
|
||||
.external_refs
|
||||
.checked_add(1)
|
||||
.ok_or(VmError::RefCountOverflow)?;
|
||||
header.strong_refs = strong;
|
||||
header.external_refs = external;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn release(&mut self, reference: ObjectRef) -> Result<(), VmError> {
|
||||
let header = &mut self.get_mut(reference)?.header;
|
||||
if header.external_refs == 0 {
|
||||
return Err(VmError::NoOwnedReference);
|
||||
}
|
||||
header.external_refs -= 1;
|
||||
header.strong_refs -= 1;
|
||||
let pending = if header.strong_refs == 0 {
|
||||
vec![reference]
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
self.drain_zero_counts(pending);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn set_attr(
|
||||
&mut self,
|
||||
reference: ObjectRef,
|
||||
name: String,
|
||||
value: Value,
|
||||
) -> Result<(), VmError> {
|
||||
self.check_attributes(reference)?;
|
||||
let edges: Vec<_> = match &value {
|
||||
Value::Object(target) => vec![*target],
|
||||
_ => Vec::new(),
|
||||
};
|
||||
let increments = self.prepare_increments(&edges)?;
|
||||
self.apply_increments(increments);
|
||||
let old = self.get_mut(reference)?.attributes.insert(name, value);
|
||||
if let Some(Value::Object(target)) = old {
|
||||
self.release_edges(vec![target]);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn get_attr(&self, reference: ObjectRef, name: &str) -> Result<Value, VmError> {
|
||||
self.check_attributes(reference)?;
|
||||
self.get(reference)?
|
||||
.attributes
|
||||
.get(name)
|
||||
.cloned()
|
||||
.ok_or_else(|| VmError::AttributeNotFound(name.into()))
|
||||
}
|
||||
|
||||
pub(crate) fn del_attr(&mut self, reference: ObjectRef, name: &str) -> Result<(), VmError> {
|
||||
self.check_attributes(reference)?;
|
||||
let old = self
|
||||
.get_mut(reference)?
|
||||
.attributes
|
||||
.remove(name)
|
||||
.ok_or_else(|| VmError::AttributeNotFound(name.into()))?;
|
||||
if let Value::Object(target) = old {
|
||||
self.release_edges(vec![target]);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn check_attributes(&self, reference: ObjectRef) -> Result<(), VmError> {
|
||||
if !self.get(reference)?.payload.allows_attributes() {
|
||||
return Err(VmError::UnsupportedOperation("attributes"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn release_edges(&mut self, edges: Vec<ObjectRef>) {
|
||||
let mut pending = Vec::new();
|
||||
for target in edges {
|
||||
let header = &mut self.get_mut(target).unwrap().header;
|
||||
header.strong_refs -= 1;
|
||||
if header.strong_refs == 0 {
|
||||
pending.push(target);
|
||||
}
|
||||
}
|
||||
self.drain_zero_counts(pending);
|
||||
}
|
||||
|
||||
/// Removes the object before running Drop. Reuse increments its generation;
|
||||
/// an exhausted generation permanently retires that slot.
|
||||
fn take(&mut self, reference: ObjectRef) -> Box<EndorObject> {
|
||||
let slot = &mut self.slots[reference.index];
|
||||
let object = slot.object.take().unwrap();
|
||||
if let Some(next) = slot.generation.checked_add(1) {
|
||||
slot.generation = next;
|
||||
self.free.push(reference.index);
|
||||
}
|
||||
self.live -= 1;
|
||||
object
|
||||
}
|
||||
|
||||
fn drain_zero_counts(&mut self, mut pending: Vec<ObjectRef>) {
|
||||
while let Some(reference) = pending.pop() {
|
||||
let object = self.take(reference);
|
||||
for target in object.edges() {
|
||||
let header = &mut self.get_mut(target).unwrap().header;
|
||||
header.strong_refs -= 1;
|
||||
if header.strong_refs == 0 {
|
||||
pending.push(target);
|
||||
}
|
||||
}
|
||||
drop(object);
|
||||
}
|
||||
}
|
||||
|
||||
/// Full, explicit cycle collection. External references are roots; every
|
||||
/// managed attribute and declared payload edge participates in tracing.
|
||||
pub(crate) fn collect_cycles(&mut self) -> usize {
|
||||
let mut marked = vec![false; self.slots.len()];
|
||||
let mut pending = Vec::new();
|
||||
for slot in &self.slots {
|
||||
if let Some(object) = &slot.object
|
||||
&& object.header.external_refs > 0
|
||||
{
|
||||
pending.push(object.header.identity);
|
||||
}
|
||||
}
|
||||
while let Some(reference) = pending.pop() {
|
||||
if marked[reference.index] {
|
||||
continue;
|
||||
}
|
||||
marked[reference.index] = true;
|
||||
pending.extend(self.get(reference).unwrap().edges());
|
||||
}
|
||||
let garbage: Vec<_> = self
|
||||
.slots
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter(|(index, _)| !marked[*index])
|
||||
.filter_map(|(_, slot)| slot.object.as_ref().map(|object| object.header.identity))
|
||||
.collect();
|
||||
let objects: Vec<_> = garbage
|
||||
.iter()
|
||||
.map(|reference| self.take(*reference))
|
||||
.collect();
|
||||
// All garbage slots are detached before touching edges or running Drop.
|
||||
for object in &objects {
|
||||
for target in object.edges() {
|
||||
if let Ok(survivor) = self.get_mut(target) {
|
||||
survivor.header.strong_refs -= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
let collected = objects.len();
|
||||
drop(objects);
|
||||
collected
|
||||
}
|
||||
|
||||
pub(crate) fn len(&self) -> usize {
|
||||
self.live
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::Record;
|
||||
|
||||
#[test]
|
||||
fn invalid_slots_and_generations_are_rejected() {
|
||||
let mut heap = Heap::new().unwrap();
|
||||
let reference = heap.allocate(Box::new(Record)).unwrap();
|
||||
let invalid = ObjectRef {
|
||||
index: usize::MAX,
|
||||
..reference
|
||||
};
|
||||
let stale = ObjectRef {
|
||||
generation: 1,
|
||||
..reference
|
||||
};
|
||||
assert!(matches!(heap.get(invalid), Err(VmError::InvalidHandle)));
|
||||
assert!(matches!(heap.get_mut(stale), Err(VmError::InvalidHandle)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reused_slots_never_alias_and_exhausted_generations_retire() {
|
||||
let mut heap = Heap::new().unwrap();
|
||||
let first = heap.allocate(Box::new(Record)).unwrap();
|
||||
heap.release(first).unwrap();
|
||||
let second = heap.allocate(Box::new(Record)).unwrap();
|
||||
assert_eq!(first.index, second.index);
|
||||
assert_ne!(first.generation, second.generation);
|
||||
assert!(matches!(heap.get(first), Err(VmError::InvalidHandle)));
|
||||
heap.slots[second.index].generation = u64::MAX;
|
||||
let last = ObjectRef {
|
||||
generation: u64::MAX,
|
||||
..second
|
||||
};
|
||||
heap.slots[last.index]
|
||||
.object
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.header
|
||||
.identity = last;
|
||||
heap.release(last).unwrap();
|
||||
let next = heap.allocate(Box::new(Record)).unwrap();
|
||||
assert_ne!(next.index, last.index);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_reference_increments_leave_counts_and_attributes_unchanged() {
|
||||
let mut heap = Heap::new().unwrap();
|
||||
let owner = heap.allocate(Box::new(Record)).unwrap();
|
||||
let target = heap.allocate(Box::new(Record)).unwrap();
|
||||
heap.get_mut(target).unwrap().header.strong_refs = usize::MAX;
|
||||
assert_eq!(heap.retain(target), Err(VmError::RefCountOverflow));
|
||||
assert_eq!(heap.get(target).unwrap().header.external_refs, 1);
|
||||
assert_eq!(
|
||||
heap.set_attr(owner, "edge".into(), Value::Object(target)),
|
||||
Err(VmError::RefCountOverflow)
|
||||
);
|
||||
assert!(heap.get(owner).unwrap().attributes.is_empty());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
//! Embeddable object runtime. No language type system, parser or executor.
|
||||
//!
|
||||
//! ```
|
||||
//! use aster_core::{Value, Vm};
|
||||
//! let mut vm = Vm::new()?;
|
||||
//! let object = vm.new_object()?; // One owned external reference.
|
||||
//! vm.set_attr(object, "x", Value::Number(42_i64.into()))?;
|
||||
//! assert_eq!(vm.get_attr(object, "x")?, Value::Number(42_i64.into()));
|
||||
//! vm.retain(object)?; // Own an additional reference.
|
||||
//! vm.release(object)?;
|
||||
//! assert_eq!(vm.ref_count(object)?, 1);
|
||||
//! vm.release(object)?; // The object is destroyed.
|
||||
//! assert_eq!(vm.object_count(), 0);
|
||||
//! # Ok::<(), aster_core::VmError>(())
|
||||
//! ```
|
||||
|
||||
mod builtins;
|
||||
mod heap;
|
||||
mod number;
|
||||
mod object;
|
||||
mod vm;
|
||||
mod vm_builtins;
|
||||
|
||||
pub use builtins::{
|
||||
EndorBaseExceptionObject, EndorCellObject, EndorCode, EndorDictObject, EndorFunctionObject,
|
||||
EndorStringObject, EndorTracebackEntry,
|
||||
};
|
||||
pub use heap::ObjectRef;
|
||||
pub use number::{
|
||||
EndorDecimal, EndorInteger, EndorNumber, EndorNumberObject, EndorRational, EndorReal,
|
||||
};
|
||||
pub use object::{
|
||||
CompareOp, EndorNativeCall, EndorNativeFunctionObject, EndorObject, NativeCall, NativeFunction,
|
||||
ObjectHeader, ObjectPayload, Record, Value,
|
||||
};
|
||||
pub use vm::{Vm, VmError};
|
||||
@@ -0,0 +1,317 @@
|
||||
//! Lossless number representations. Arithmetic and numeric equivalence are
|
||||
//! deliberately separate from representation equality.
|
||||
|
||||
use std::any::Any;
|
||||
use std::fmt;
|
||||
|
||||
use crate::{CompareOp, ObjectPayload, ObjectRef, VmError};
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct EndorInteger {
|
||||
negative: bool,
|
||||
digits: String,
|
||||
}
|
||||
|
||||
impl EndorInteger {
|
||||
/// Decimal digits of any length, limited only by available memory.
|
||||
pub fn parse(text: &str) -> Result<Self, VmError> {
|
||||
let (negative, digits) = split_sign(text);
|
||||
if !is_digits(digits) {
|
||||
return Err(VmError::InvalidArgument("invalid integer"));
|
||||
}
|
||||
let digits = digits.trim_start_matches('0');
|
||||
Ok(Self {
|
||||
negative: negative && !digits.is_empty(),
|
||||
digits: if digits.is_empty() { "0" } else { digits }.into(),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn digits(&self) -> &str {
|
||||
&self.digits
|
||||
}
|
||||
|
||||
pub fn is_negative(&self) -> bool {
|
||||
self.negative
|
||||
}
|
||||
|
||||
pub fn is_zero(&self) -> bool {
|
||||
self.digits == "0"
|
||||
}
|
||||
|
||||
pub fn to_i64(&self) -> Option<i64> {
|
||||
self.to_string().parse().ok()
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for EndorInteger {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
if self.negative {
|
||||
f.write_str("-")?;
|
||||
}
|
||||
f.write_str(&self.digits)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct EndorDecimal {
|
||||
literal: String,
|
||||
zero: bool,
|
||||
}
|
||||
|
||||
impl EndorDecimal {
|
||||
/// Retains all digits, trailing zeroes, sign, and an arbitrarily long
|
||||
/// decimal exponent. No intermediate binary floating-point conversion.
|
||||
pub fn parse(text: &str) -> Result<Self, VmError> {
|
||||
let (_, unsigned) = split_sign(text);
|
||||
let mut parts = unsigned.split(['e', 'E']);
|
||||
let mantissa = parts.next().unwrap_or_default();
|
||||
if let Some(exponent) = parts.next()
|
||||
&& (!is_digits(split_sign(exponent).1) || parts.next().is_some())
|
||||
{
|
||||
return Err(VmError::InvalidArgument("invalid decimal exponent"));
|
||||
}
|
||||
let mut decimal_point = false;
|
||||
let mut digits = 0_usize;
|
||||
let mut zero = true;
|
||||
for byte in mantissa.bytes() {
|
||||
match byte {
|
||||
b'.' if !decimal_point => decimal_point = true,
|
||||
b'0'..=b'9' => {
|
||||
digits += 1;
|
||||
zero &= byte == b'0';
|
||||
}
|
||||
_ => return Err(VmError::InvalidArgument("invalid decimal")),
|
||||
}
|
||||
}
|
||||
if digits == 0 {
|
||||
return Err(VmError::InvalidArgument("decimal needs digits"));
|
||||
}
|
||||
Ok(Self {
|
||||
literal: text.into(),
|
||||
zero,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn literal(&self) -> &str {
|
||||
&self.literal
|
||||
}
|
||||
|
||||
pub fn is_zero(&self) -> bool {
|
||||
self.zero
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for EndorDecimal {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.write_str(&self.literal)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct EndorRational {
|
||||
numerator: EndorInteger,
|
||||
denominator: EndorInteger,
|
||||
}
|
||||
|
||||
impl EndorRational {
|
||||
/// Normalizes denominator sign, without reducing or rounding the fraction.
|
||||
pub fn new(
|
||||
mut numerator: EndorInteger,
|
||||
mut denominator: EndorInteger,
|
||||
) -> Result<Self, VmError> {
|
||||
if denominator.is_zero() {
|
||||
return Err(VmError::InvalidArgument("zero rational denominator"));
|
||||
}
|
||||
if denominator.negative {
|
||||
denominator.negative = false;
|
||||
if !numerator.is_zero() {
|
||||
numerator.negative = !numerator.negative;
|
||||
}
|
||||
}
|
||||
Ok(Self {
|
||||
numerator,
|
||||
denominator,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn numerator(&self) -> &EndorInteger {
|
||||
&self.numerator
|
||||
}
|
||||
|
||||
pub fn denominator(&self) -> &EndorInteger {
|
||||
&self.denominator
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for EndorRational {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "{}/{}", self.numerator, self.denominator)
|
||||
}
|
||||
}
|
||||
|
||||
/// Internal storage forms within one Endor number API, not language classes.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum EndorReal {
|
||||
Integer(EndorInteger),
|
||||
Decimal(EndorDecimal),
|
||||
Rational(EndorRational),
|
||||
/// IEEE-754 bits preserve signed zero, infinities and NaN payloads.
|
||||
BinaryFloat(u64),
|
||||
}
|
||||
|
||||
impl EndorReal {
|
||||
pub fn is_zero(&self) -> bool {
|
||||
match self {
|
||||
Self::Integer(value) => value.is_zero(),
|
||||
Self::Decimal(value) => value.is_zero(),
|
||||
Self::Rational(value) => value.numerator.is_zero(),
|
||||
Self::BinaryFloat(bits) => f64::from_bits(*bits) == 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for EndorReal {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Integer(value) => value.fmt(f),
|
||||
Self::Decimal(value) => value.fmt(f),
|
||||
Self::Rational(value) => value.fmt(f),
|
||||
Self::BinaryFloat(bits) => f64::from_bits(*bits).fmt(f),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Unified, lossless number value. PartialEq/Eq compare representations, NOT
|
||||
/// mathematical values: decimal scale and IEEE NaN bits remain observable.
|
||||
/// Language-level comparison and hashing are not defined by these Rust traits.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum EndorNumber {
|
||||
Real(EndorReal),
|
||||
Complex {
|
||||
real: EndorReal,
|
||||
imaginary: EndorReal,
|
||||
},
|
||||
}
|
||||
|
||||
impl EndorNumber {
|
||||
pub fn integer(text: &str) -> Result<Self, VmError> {
|
||||
Ok(Self::Real(EndorReal::Integer(EndorInteger::parse(text)?)))
|
||||
}
|
||||
|
||||
pub fn decimal(text: &str) -> Result<Self, VmError> {
|
||||
Ok(Self::Real(EndorReal::Decimal(EndorDecimal::parse(text)?)))
|
||||
}
|
||||
|
||||
pub fn rational(numerator: &str, denominator: &str) -> Result<Self, VmError> {
|
||||
Ok(Self::Real(EndorReal::Rational(EndorRational::new(
|
||||
EndorInteger::parse(numerator)?,
|
||||
EndorInteger::parse(denominator)?,
|
||||
)?)))
|
||||
}
|
||||
|
||||
pub fn binary_float(value: f64) -> Self {
|
||||
Self::Real(EndorReal::BinaryFloat(value.to_bits()))
|
||||
}
|
||||
|
||||
pub fn complex(real: EndorReal, imaginary: EndorReal) -> Self {
|
||||
Self::Complex { real, imaginary }
|
||||
}
|
||||
|
||||
pub fn as_real(&self) -> Option<&EndorReal> {
|
||||
match self {
|
||||
Self::Real(value) => Some(value),
|
||||
Self::Complex { .. } => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn as_i64(&self) -> Option<i64> {
|
||||
match self {
|
||||
Self::Real(EndorReal::Integer(value)) => value.to_i64(),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_zero(&self) -> bool {
|
||||
match self {
|
||||
Self::Real(value) => value.is_zero(),
|
||||
Self::Complex { real, imaginary } => real.is_zero() && imaginary.is_zero(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<i64> for EndorNumber {
|
||||
fn from(value: i64) -> Self {
|
||||
Self::integer(&value.to_string()).expect("i64 always has valid decimal digits")
|
||||
}
|
||||
}
|
||||
|
||||
impl From<f64> for EndorNumber {
|
||||
fn from(value: f64) -> Self {
|
||||
Self::binary_float(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for EndorNumber {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Real(value) => value.fmt(f),
|
||||
Self::Complex { real, imaginary } => write!(f, "({real} + ({imaginary})i)"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct EndorNumberObject {
|
||||
value: EndorNumber,
|
||||
}
|
||||
|
||||
impl EndorNumberObject {
|
||||
pub fn new(value: EndorNumber) -> Self {
|
||||
Self { value }
|
||||
}
|
||||
|
||||
pub fn value(&self) -> &EndorNumber {
|
||||
&self.value
|
||||
}
|
||||
}
|
||||
|
||||
impl ObjectPayload for EndorNumberObject {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"number"
|
||||
}
|
||||
|
||||
fn repr(&self, _identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(self.value.to_string())
|
||||
}
|
||||
|
||||
fn is_true(&self) -> Result<bool, VmError> {
|
||||
Ok(!self.value.is_zero())
|
||||
}
|
||||
|
||||
fn hash(&self, _identity: ObjectRef) -> Result<u64, VmError> {
|
||||
Err(VmError::UnsupportedOperation("numeric hash"))
|
||||
}
|
||||
|
||||
fn compare(&self, other: &dyn ObjectPayload, _op: CompareOp) -> Result<Option<bool>, VmError> {
|
||||
if other.as_any().is::<Self>() {
|
||||
return Err(VmError::UnsupportedOperation("numeric comparison"));
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
fn split_sign(text: &str) -> (bool, &str) {
|
||||
if let Some(rest) = text.strip_prefix('-') {
|
||||
(true, rest)
|
||||
} else {
|
||||
(false, text.strip_prefix('+').unwrap_or(text))
|
||||
}
|
||||
}
|
||||
|
||||
fn is_digits(text: &str) -> bool {
|
||||
!text.is_empty() && text.bytes().all(|byte| byte.is_ascii_digit())
|
||||
}
|
||||
@@ -0,0 +1,220 @@
|
||||
use std::any::Any;
|
||||
use std::collections::BTreeMap;
|
||||
use std::collections::hash_map::DefaultHasher;
|
||||
use std::fmt;
|
||||
use std::hash::{Hash, Hasher};
|
||||
|
||||
use crate::{EndorNumber, ObjectRef, VmError};
|
||||
|
||||
/// Immediate values stay outside the object heap. Object values are borrowed
|
||||
/// handles: copying or cloning one does not retain an external strong reference.
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum Value {
|
||||
Nil,
|
||||
Bool(bool),
|
||||
/// Rust equality preserves representation; it is not numeric equivalence.
|
||||
Number(EndorNumber),
|
||||
Text(String),
|
||||
Object(ObjectRef),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum CompareOp {
|
||||
Eq,
|
||||
Ne,
|
||||
Lt,
|
||||
Le,
|
||||
Gt,
|
||||
Ge,
|
||||
}
|
||||
|
||||
impl CompareOp {
|
||||
pub(crate) fn reflected(self) -> Self {
|
||||
match self {
|
||||
Self::Eq => Self::Eq,
|
||||
Self::Ne => Self::Ne,
|
||||
Self::Lt => Self::Gt,
|
||||
Self::Le => Self::Ge,
|
||||
Self::Gt => Self::Lt,
|
||||
Self::Ge => Self::Le,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Rust-side operation interface, not a language type or metaclass.
|
||||
///
|
||||
/// Implementations must report every payload-owned object reference in trace(),
|
||||
/// including duplicates. Those edges must stay immutable after allocation;
|
||||
/// mutable object references belong in VM-managed attributes or built-in
|
||||
/// containers updated transactionally by the VM instead.
|
||||
/// Rust Drop releases host resources when the payload is destroyed.
|
||||
/// Equal payloads must provide compatible hashes, or reject hashing explicitly.
|
||||
pub trait ObjectPayload: Any + fmt::Debug + Send + Sync {
|
||||
fn as_any(&self) -> &dyn Any;
|
||||
|
||||
/// A diagnostic label only, with no language type or inheritance semantics.
|
||||
fn kind_name(&self) -> &'static str;
|
||||
|
||||
fn trace(&self, _visit: &mut dyn FnMut(ObjectRef)) {}
|
||||
|
||||
fn allows_attributes(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn repr(&self, identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(format!("<{} {identity}>", self.kind_name()))
|
||||
}
|
||||
|
||||
fn str(&self, identity: ObjectRef) -> Result<String, VmError> {
|
||||
self.repr(identity)
|
||||
}
|
||||
|
||||
fn is_true(&self) -> Result<bool, VmError> {
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
fn hash(&self, identity: ObjectRef) -> Result<u64, VmError> {
|
||||
let mut hasher = DefaultHasher::new();
|
||||
identity.hash(&mut hasher);
|
||||
Ok(hasher.finish())
|
||||
}
|
||||
|
||||
/// None means "not implemented"; the VM tries the reflected operation,
|
||||
/// then falls back to identity for Eq/Ne or rejects ordering.
|
||||
fn compare(
|
||||
&self,
|
||||
_other: &dyn ObjectPayload,
|
||||
_operation: CompareOp,
|
||||
) -> Result<Option<bool>, VmError> {
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
/// Object arguments and object results are borrowed handles. Native calls
|
||||
/// compute values without mutating the VM; this is not a language executor.
|
||||
fn call(&self, _arguments: &[Value]) -> Result<Value, VmError> {
|
||||
Err(VmError::UnsupportedOperation("call"))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
pub struct Record;
|
||||
|
||||
impl ObjectPayload for Record {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"record"
|
||||
}
|
||||
|
||||
fn allows_attributes(&self) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
pub type EndorNativeCall = fn(&[Value]) -> Result<Value, VmError>;
|
||||
pub type NativeCall = EndorNativeCall;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct EndorNativeFunctionObject {
|
||||
name: String,
|
||||
function: NativeCall,
|
||||
}
|
||||
|
||||
impl EndorNativeFunctionObject {
|
||||
pub fn new(name: impl Into<String>, function: NativeCall) -> Self {
|
||||
Self {
|
||||
name: name.into(),
|
||||
function,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn name(&self) -> &str {
|
||||
&self.name
|
||||
}
|
||||
}
|
||||
|
||||
/// Compatibility name for existing embedders.
|
||||
pub type NativeFunction = EndorNativeFunctionObject;
|
||||
|
||||
impl ObjectPayload for EndorNativeFunctionObject {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"native-function"
|
||||
}
|
||||
|
||||
fn repr(&self, _identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(format!("<native-function {}>", self.name))
|
||||
}
|
||||
|
||||
fn call(&self, arguments: &[Value]) -> Result<Value, VmError> {
|
||||
(self.function)(arguments)
|
||||
}
|
||||
}
|
||||
|
||||
/// Common runtime state. There is deliberately no language type pointer.
|
||||
#[derive(Debug)]
|
||||
pub struct ObjectHeader {
|
||||
pub(crate) identity: ObjectRef,
|
||||
pub(crate) strong_refs: usize,
|
||||
pub(crate) external_refs: usize,
|
||||
}
|
||||
|
||||
impl ObjectHeader {
|
||||
pub fn identity(&self) -> ObjectRef {
|
||||
self.identity
|
||||
}
|
||||
|
||||
pub fn ref_count(&self) -> usize {
|
||||
self.strong_refs
|
||||
}
|
||||
|
||||
pub fn external_ref_count(&self) -> usize {
|
||||
self.external_refs
|
||||
}
|
||||
}
|
||||
|
||||
/// Runtime object foundation, analogous in role to CPython's common object
|
||||
/// structure, without its type system or binary layout. The heap boxes this
|
||||
/// structure so its address remains stable throughout its lifetime.
|
||||
#[derive(Debug)]
|
||||
pub struct EndorObject {
|
||||
pub(crate) header: ObjectHeader,
|
||||
pub(crate) payload: Box<dyn ObjectPayload>,
|
||||
pub(crate) attributes: BTreeMap<String, Value>,
|
||||
pub(crate) payload_edges: Vec<ObjectRef>,
|
||||
}
|
||||
|
||||
impl EndorObject {
|
||||
pub fn header(&self) -> &ObjectHeader {
|
||||
&self.header
|
||||
}
|
||||
|
||||
pub fn payload(&self) -> &dyn ObjectPayload {
|
||||
self.payload.as_ref()
|
||||
}
|
||||
|
||||
/// Visits owned edges, not external roots. Payload edges are snapshotted at
|
||||
/// allocation and refreshed on VM-managed payload replacement; attributes
|
||||
/// are maintained by the VM's reference accounting.
|
||||
pub fn trace(&self, visit: &mut dyn FnMut(ObjectRef)) {
|
||||
for reference in &self.payload_edges {
|
||||
visit(*reference);
|
||||
}
|
||||
for value in self.attributes.values() {
|
||||
if let Value::Object(reference) = value {
|
||||
visit(*reference);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn edges(&self) -> Vec<ObjectRef> {
|
||||
let mut edges = Vec::new();
|
||||
self.trace(&mut |reference| edges.push(reference));
|
||||
edges
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
use std::fmt;
|
||||
|
||||
use crate::heap::Heap;
|
||||
use crate::{CompareOp, EndorObject, ObjectPayload, ObjectRef, Record, Value};
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum VmError {
|
||||
ForeignHandle,
|
||||
InvalidHandle,
|
||||
IdentityExhausted,
|
||||
RefCountOverflow,
|
||||
NoOwnedReference,
|
||||
AttributeNotFound(String),
|
||||
UnsupportedOperation(&'static str),
|
||||
InvalidArgument(&'static str),
|
||||
ObjectKindMismatch(&'static str),
|
||||
EmptyCell,
|
||||
}
|
||||
|
||||
impl fmt::Display for VmError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::ForeignHandle => f.write_str("handle belongs to another VM"),
|
||||
Self::InvalidHandle => f.write_str("handle does not identify a live object"),
|
||||
Self::IdentityExhausted => f.write_str("process-local VM identities exhausted"),
|
||||
Self::RefCountOverflow => f.write_str("object reference count exhausted"),
|
||||
Self::NoOwnedReference => f.write_str("no external strong reference to release"),
|
||||
Self::AttributeNotFound(name) => write!(f, "attribute not found: {name}"),
|
||||
Self::UnsupportedOperation(operation) => {
|
||||
write!(f, "object does not support {operation}")
|
||||
}
|
||||
Self::InvalidArgument(message) => f.write_str(message),
|
||||
Self::ObjectKindMismatch(expected) => write!(f, "expected {expected} object"),
|
||||
Self::EmptyCell => f.write_str("cell is empty"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for VmError {}
|
||||
|
||||
/// Runtime owner. Construction creates an empty heap, without language classes,
|
||||
/// metaclasses or a Python type system. Dropping it releases all host resources.
|
||||
#[derive(Debug)]
|
||||
pub struct Vm {
|
||||
pub(crate) heap: Heap,
|
||||
}
|
||||
|
||||
impl Vm {
|
||||
pub fn new() -> Result<Self, VmError> {
|
||||
Ok(Self { heap: Heap::new()? })
|
||||
}
|
||||
|
||||
pub fn object_count(&self) -> usize {
|
||||
self.heap.len()
|
||||
}
|
||||
|
||||
/// Returns one external strong reference. Copies of the returned handle
|
||||
/// are borrowed; use retain/release to manage additional owned references.
|
||||
pub fn allocate(&mut self, payload: impl ObjectPayload) -> Result<ObjectRef, VmError> {
|
||||
self.validate_builtin(&payload)?;
|
||||
self.heap.allocate(Box::new(payload))
|
||||
}
|
||||
|
||||
pub fn new_object(&mut self) -> Result<ObjectRef, VmError> {
|
||||
self.allocate(Record)
|
||||
}
|
||||
|
||||
pub fn object(&self, reference: ObjectRef) -> Result<&EndorObject, VmError> {
|
||||
self.heap.get(reference)
|
||||
}
|
||||
|
||||
pub fn retain(&mut self, reference: ObjectRef) -> Result<(), VmError> {
|
||||
self.heap.retain(reference)
|
||||
}
|
||||
|
||||
pub fn release(&mut self, reference: ObjectRef) -> Result<(), VmError> {
|
||||
self.heap.release(reference)
|
||||
}
|
||||
|
||||
pub fn ref_count(&self, reference: ObjectRef) -> Result<usize, VmError> {
|
||||
Ok(self.heap.get(reference)?.header().ref_count())
|
||||
}
|
||||
|
||||
pub fn is_same(&self, left: ObjectRef, right: ObjectRef) -> Result<bool, VmError> {
|
||||
self.heap.get(left)?;
|
||||
self.heap.get(right)?;
|
||||
Ok(left == right)
|
||||
}
|
||||
|
||||
pub fn repr(&self, reference: ObjectRef) -> Result<String, VmError> {
|
||||
self.heap.get(reference)?.payload().repr(reference)
|
||||
}
|
||||
|
||||
pub fn str(&self, reference: ObjectRef) -> Result<String, VmError> {
|
||||
self.heap.get(reference)?.payload().str(reference)
|
||||
}
|
||||
|
||||
pub fn is_true(&self, reference: ObjectRef) -> Result<bool, VmError> {
|
||||
self.heap.get(reference)?.payload().is_true()
|
||||
}
|
||||
|
||||
pub fn hash(&self, reference: ObjectRef) -> Result<u64, VmError> {
|
||||
self.heap.get(reference)?.payload().hash(reference)
|
||||
}
|
||||
|
||||
pub fn compare(
|
||||
&self,
|
||||
left: ObjectRef,
|
||||
right: ObjectRef,
|
||||
operation: CompareOp,
|
||||
) -> Result<bool, VmError> {
|
||||
let left_payload = self.heap.get(left)?.payload();
|
||||
let right_payload = self.heap.get(right)?.payload();
|
||||
if let Some(result) = left_payload.compare(right_payload, operation)? {
|
||||
return Ok(result);
|
||||
}
|
||||
if let Some(result) = right_payload.compare(left_payload, operation.reflected())? {
|
||||
return Ok(result);
|
||||
}
|
||||
match operation {
|
||||
CompareOp::Eq => Ok(left == right),
|
||||
CompareOp::Ne => Ok(left != right),
|
||||
_ => Err(VmError::UnsupportedOperation("ordering")),
|
||||
}
|
||||
}
|
||||
|
||||
/// Reads a borrowed value. An Object result needs retain() if the host
|
||||
/// wants it to survive removal of the attribute that currently owns it.
|
||||
pub fn get_attr(&self, reference: ObjectRef, name: &str) -> Result<Value, VmError> {
|
||||
self.heap.get_attr(reference, name)
|
||||
}
|
||||
|
||||
/// Object-valued attributes own internal strong references independently
|
||||
/// of the caller's external references. Failure leaves the field unchanged.
|
||||
pub fn set_attr(
|
||||
&mut self,
|
||||
reference: ObjectRef,
|
||||
name: impl Into<String>,
|
||||
value: Value,
|
||||
) -> Result<(), VmError> {
|
||||
self.heap.set_attr(reference, name.into(), value)
|
||||
}
|
||||
|
||||
pub fn del_attr(&mut self, reference: ObjectRef, name: &str) -> Result<(), VmError> {
|
||||
self.heap.del_attr(reference, name)
|
||||
}
|
||||
|
||||
/// Results are borrowed values; native operations cannot mutate this VM.
|
||||
pub fn call(&self, reference: ObjectRef, arguments: &[Value]) -> Result<Value, VmError> {
|
||||
let payload = self.heap.get(reference)?.payload();
|
||||
for argument in arguments {
|
||||
self.validate_value(argument)?;
|
||||
}
|
||||
let result = payload.call(arguments)?;
|
||||
self.validate_value(&result)?;
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
pub(crate) fn validate_value(&self, value: &Value) -> Result<(), VmError> {
|
||||
if let Value::Object(reference) = value {
|
||||
self.heap.get(*reference)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Explicit full collection of unreachable cycles, using external strong
|
||||
/// references as roots. A tracing execution stack can be added later.
|
||||
pub fn collect_cycles(&mut self) -> usize {
|
||||
self.heap.collect_cycles()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
use std::collections::hash_map::DefaultHasher;
|
||||
use std::hash::{Hash, Hasher};
|
||||
|
||||
use crate::{
|
||||
CompareOp, EndorBaseExceptionObject, EndorCellObject, EndorDictObject, EndorFunctionObject,
|
||||
EndorNumber, EndorNumberObject, EndorStringObject, ObjectPayload, ObjectRef, Value, Vm,
|
||||
VmError,
|
||||
};
|
||||
|
||||
impl Vm {
|
||||
pub(crate) fn validate_builtin(&self, payload: &dyn ObjectPayload) -> Result<(), VmError> {
|
||||
if let Some(function) = payload.as_any().downcast_ref::<EndorFunctionObject>() {
|
||||
self.payload::<EndorDictObject>(function.globals(), "dict")?;
|
||||
for cell in function.closure() {
|
||||
self.payload::<EndorCellObject>(*cell, "cell")?;
|
||||
}
|
||||
}
|
||||
if let Some(exception) = payload.as_any().downcast_ref::<EndorBaseExceptionObject>() {
|
||||
for reference in [exception.cause(), exception.context()]
|
||||
.into_iter()
|
||||
.flatten()
|
||||
{
|
||||
self.payload::<EndorBaseExceptionObject>(reference, "exception")?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn payload<T: ObjectPayload>(
|
||||
&self,
|
||||
reference: ObjectRef,
|
||||
expected: &'static str,
|
||||
) -> Result<&T, VmError> {
|
||||
self.object(reference)?
|
||||
.payload()
|
||||
.as_any()
|
||||
.downcast_ref()
|
||||
.ok_or(VmError::ObjectKindMismatch(expected))
|
||||
}
|
||||
|
||||
pub fn new_string(&mut self, text: impl Into<String>) -> Result<ObjectRef, VmError> {
|
||||
self.allocate(EndorStringObject::new(text))
|
||||
}
|
||||
|
||||
pub fn new_number(&mut self, number: EndorNumber) -> Result<ObjectRef, VmError> {
|
||||
self.allocate(EndorNumberObject::new(number))
|
||||
}
|
||||
|
||||
pub fn new_dict(&mut self) -> Result<ObjectRef, VmError> {
|
||||
self.allocate(EndorDictObject::new())
|
||||
}
|
||||
|
||||
/// Returns borrowed keys and values in insertion order.
|
||||
pub fn dict_items(&self, dictionary: ObjectRef) -> Result<&[(Value, Value)], VmError> {
|
||||
Ok(self
|
||||
.payload::<EndorDictObject>(dictionary, "dict")?
|
||||
.entries())
|
||||
}
|
||||
|
||||
pub fn dict_get(&self, dictionary: ObjectRef, key: &Value) -> Result<Option<Value>, VmError> {
|
||||
let dict = self.payload::<EndorDictObject>(dictionary, "dict")?;
|
||||
self.key_hash(key)?;
|
||||
Ok(self
|
||||
.dict_position(dict, key)?
|
||||
.map(|index| dict.entries[index].1.clone()))
|
||||
}
|
||||
|
||||
pub fn dict_set(
|
||||
&mut self,
|
||||
dictionary: ObjectRef,
|
||||
key: Value,
|
||||
value: Value,
|
||||
) -> Result<(), VmError> {
|
||||
let mut dict = self.payload::<EndorDictObject>(dictionary, "dict")?.clone();
|
||||
self.key_hash(&key)?;
|
||||
self.validate_value(&value)?;
|
||||
if let Some(index) = self.dict_position(&dict, &key)? {
|
||||
// Preserve the first key object and insertion position.
|
||||
dict.entries[index].1 = value;
|
||||
} else {
|
||||
dict.entries.push((key, value));
|
||||
}
|
||||
self.heap.replace_payload(dictionary, dict)
|
||||
}
|
||||
|
||||
pub fn dict_delete(&mut self, dictionary: ObjectRef, key: &Value) -> Result<bool, VmError> {
|
||||
let mut dict = self.payload::<EndorDictObject>(dictionary, "dict")?.clone();
|
||||
self.key_hash(key)?;
|
||||
let Some(index) = self.dict_position(&dict, key)? else {
|
||||
return Ok(false);
|
||||
};
|
||||
dict.entries.remove(index);
|
||||
self.heap.replace_payload(dictionary, dict)?;
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
pub fn dict_clear(&mut self, dictionary: ObjectRef) -> Result<(), VmError> {
|
||||
self.payload::<EndorDictObject>(dictionary, "dict")?;
|
||||
self.heap
|
||||
.replace_payload(dictionary, EndorDictObject::new())
|
||||
}
|
||||
|
||||
fn dict_position(&self, dict: &EndorDictObject, key: &Value) -> Result<Option<usize>, VmError> {
|
||||
for (index, (existing, _)) in dict.entries.iter().enumerate() {
|
||||
if self.key_equal(existing, key)? {
|
||||
return Ok(Some(index));
|
||||
}
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
fn key_hash(&self, value: &Value) -> Result<u64, VmError> {
|
||||
self.validate_value(value)?;
|
||||
let mut hasher = DefaultHasher::new();
|
||||
match value {
|
||||
Value::Nil => "nil".hash(&mut hasher),
|
||||
Value::Bool(value) => value.hash(&mut hasher),
|
||||
Value::Text(value) => value.hash(&mut hasher),
|
||||
Value::Number(_) => return Err(VmError::UnsupportedOperation("numeric hash")),
|
||||
Value::Object(reference) => return self.hash(*reference),
|
||||
}
|
||||
Ok(hasher.finish())
|
||||
}
|
||||
|
||||
fn key_equal(&self, left: &Value, right: &Value) -> Result<bool, VmError> {
|
||||
let text = |value: &Value| -> Result<Option<String>, VmError> {
|
||||
Ok(match value {
|
||||
Value::Text(text) => Some(text.clone()),
|
||||
Value::Object(reference) => self
|
||||
.object(*reference)?
|
||||
.payload()
|
||||
.as_any()
|
||||
.downcast_ref::<EndorStringObject>()
|
||||
.map(|string| string.as_str().to_owned()),
|
||||
_ => None,
|
||||
})
|
||||
};
|
||||
if let (Some(left), Some(right)) = (text(left)?, text(right)?) {
|
||||
return Ok(left == right);
|
||||
}
|
||||
match (left, right) {
|
||||
(Value::Object(left), Value::Object(right)) => {
|
||||
self.compare(*left, *right, CompareOp::Eq)
|
||||
}
|
||||
_ => Ok(left == right),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new_cell(&mut self, value: Option<Value>) -> Result<ObjectRef, VmError> {
|
||||
self.allocate(EndorCellObject::new(value))
|
||||
}
|
||||
|
||||
/// Reads a borrowed value; an empty cell is not Value::Nil.
|
||||
pub fn cell_get(&self, cell: ObjectRef) -> Result<Value, VmError> {
|
||||
self.payload::<EndorCellObject>(cell, "cell")?
|
||||
.value()
|
||||
.cloned()
|
||||
.ok_or(VmError::EmptyCell)
|
||||
}
|
||||
|
||||
pub fn cell_set(&mut self, cell: ObjectRef, value: Value) -> Result<(), VmError> {
|
||||
self.payload::<EndorCellObject>(cell, "cell")?;
|
||||
self.heap
|
||||
.replace_payload(cell, EndorCellObject::new(Some(value)))
|
||||
}
|
||||
|
||||
pub fn cell_clear(&mut self, cell: ObjectRef) -> Result<(), VmError> {
|
||||
self.payload::<EndorCellObject>(cell, "cell")?;
|
||||
self.heap.replace_payload(cell, EndorCellObject::default())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,343 @@
|
||||
use aster_core::{
|
||||
CompareOp, EndorBaseExceptionObject, EndorCode, EndorDictObject, EndorFunctionObject,
|
||||
EndorInteger, EndorNativeFunctionObject, EndorNumber, EndorNumberObject, EndorReal,
|
||||
EndorStringObject, EndorTracebackEntry, Value, Vm, VmError,
|
||||
};
|
||||
|
||||
fn text(value: &str) -> Value {
|
||||
Value::Text(value.into())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn numbers_preserve_large_digits_decimal_scale_exponents_and_fraction_parts() {
|
||||
let huge = "123456789012345678901234567890123456789012345678901234567890";
|
||||
assert_eq!(EndorNumber::integer(huge).unwrap().to_string(), huge);
|
||||
assert_eq!(EndorNumber::integer("-000").unwrap().to_string(), "0");
|
||||
assert_eq!(EndorNumber::integer("+0012").unwrap().as_i64(), Some(12));
|
||||
assert_eq!(EndorNumber::integer(huge).unwrap().as_i64(), None);
|
||||
for literal in [
|
||||
"-0.0000",
|
||||
"1.2300000000000000000001",
|
||||
".5",
|
||||
"1.",
|
||||
"2e+999999999999999999999999999999",
|
||||
] {
|
||||
assert_eq!(EndorNumber::decimal(literal).unwrap().to_string(), literal);
|
||||
}
|
||||
assert_ne!(
|
||||
EndorNumber::decimal("1.00").unwrap(),
|
||||
EndorNumber::decimal("1.0").unwrap()
|
||||
);
|
||||
assert_eq!(
|
||||
EndorNumber::rational("2", "-6").unwrap().to_string(),
|
||||
"-2/6"
|
||||
);
|
||||
assert_eq!(EndorNumber::rational("0", "-6").unwrap().to_string(), "0/6");
|
||||
assert!(EndorNumber::rational("1", "0").is_err());
|
||||
for invalid in ["", "+", " 1", "1 ", "1_000", "12", "1.0"] {
|
||||
assert!(EndorNumber::integer(invalid).is_err(), "{invalid}");
|
||||
}
|
||||
for invalid in ["", ".", "1.2.3", "1e", "1e+", "1e2e3", "nan", " 0.1", "--1"] {
|
||||
assert!(EndorNumber::decimal(invalid).is_err(), "{invalid}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn number_objects_preserve_ieee_bits_and_reject_undefined_numeric_operations() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let bits = 0x7ff8_0000_0000_0042;
|
||||
let nan = EndorNumber::binary_float(f64::from_bits(bits));
|
||||
assert_eq!(nan.as_real(), Some(&EndorReal::BinaryFloat(bits)));
|
||||
assert_ne!(
|
||||
EndorNumber::binary_float(-0.0),
|
||||
EndorNumber::binary_float(0.0)
|
||||
);
|
||||
assert!(!EndorNumber::binary_float(f64::INFINITY).is_zero());
|
||||
let zero = vm
|
||||
.new_number(EndorNumber::decimal("-0.000e99999999999").unwrap())
|
||||
.unwrap();
|
||||
assert!(!vm.is_true(zero).unwrap());
|
||||
let complex = EndorNumber::complex(
|
||||
EndorReal::Integer(EndorInteger::parse("3").unwrap()),
|
||||
EndorNumber::rational("1", "3")
|
||||
.unwrap()
|
||||
.as_real()
|
||||
.unwrap()
|
||||
.clone(),
|
||||
);
|
||||
let object = vm.new_number(complex).unwrap();
|
||||
assert_eq!(vm.str(object).unwrap(), "(3 + (1/3)i)");
|
||||
assert_eq!(
|
||||
vm.hash(object),
|
||||
Err(VmError::UnsupportedOperation("numeric hash"))
|
||||
);
|
||||
assert_eq!(
|
||||
vm.compare(object, zero, CompareOp::Eq),
|
||||
Err(VmError::UnsupportedOperation("numeric comparison"))
|
||||
);
|
||||
assert!(
|
||||
vm.payload::<EndorNumberObject>(object, "number")
|
||||
.unwrap()
|
||||
.value()
|
||||
.as_real()
|
||||
.is_none()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn strings_use_unicode_characters_and_content_equality() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let a = vm.new_string("Endor中文🦀").unwrap();
|
||||
let b = vm.new_string("Endor中文🦀").unwrap();
|
||||
let empty = vm.new_string("").unwrap();
|
||||
let string = vm.payload::<EndorStringObject>(a, "string").unwrap();
|
||||
assert_eq!(string.char_count(), 8);
|
||||
assert_eq!(string.char_at(7), Some('🦀'));
|
||||
assert_eq!(string.char_at(8), None);
|
||||
assert!(vm.compare(a, b, CompareOp::Eq).unwrap());
|
||||
assert_eq!(vm.hash(a).unwrap(), vm.hash(b).unwrap());
|
||||
assert_eq!(vm.str(a).unwrap(), "Endor中文🦀");
|
||||
assert!(!vm.is_true(empty).unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dictionaries_keep_order_and_first_key_and_own_keys_and_values() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let dict = vm.new_dict().unwrap();
|
||||
let key = vm.new_string("answer").unwrap();
|
||||
let old = vm.new_object().unwrap();
|
||||
vm.dict_set(dict, Value::Object(key), Value::Object(old))
|
||||
.unwrap();
|
||||
vm.release(key).unwrap();
|
||||
vm.release(old).unwrap();
|
||||
vm.dict_set(dict, text("second"), Value::Nil).unwrap();
|
||||
vm.dict_set(dict, text("answer"), text("replacement"))
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
vm.dict_get(dict, &text("answer")).unwrap(),
|
||||
Some(text("replacement"))
|
||||
);
|
||||
assert_eq!(vm.dict_items(dict).unwrap()[0].0, Value::Object(key));
|
||||
assert_eq!(vm.dict_items(dict).unwrap().len(), 2);
|
||||
assert!(matches!(vm.object(old), Err(VmError::InvalidHandle)));
|
||||
assert!(vm.dict_delete(dict, &text("answer")).unwrap());
|
||||
assert!(matches!(vm.object(key), Err(VmError::InvalidHandle)));
|
||||
assert!(!vm.dict_delete(dict, &text("missing")).unwrap());
|
||||
vm.dict_clear(dict).unwrap();
|
||||
assert!(!vm.is_true(dict).unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_container_writes_leave_values_and_counts_unchanged() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let mut other = Vm::new().unwrap();
|
||||
let foreign = other.new_object().unwrap();
|
||||
let dict = vm.new_dict().unwrap();
|
||||
let child = vm.new_object().unwrap();
|
||||
vm.dict_set(dict, text("x"), Value::Object(child)).unwrap();
|
||||
assert_eq!(
|
||||
vm.dict_set(dict, text("x"), Value::Object(foreign)),
|
||||
Err(VmError::ForeignHandle)
|
||||
);
|
||||
assert_eq!(
|
||||
vm.dict_get(dict, &text("x")).unwrap(),
|
||||
Some(Value::Object(child))
|
||||
);
|
||||
assert_eq!(vm.ref_count(child).unwrap(), 2);
|
||||
assert_eq!(
|
||||
vm.dict_set(dict, Value::Number(1_i64.into()), Value::Nil),
|
||||
Err(VmError::UnsupportedOperation("numeric hash"))
|
||||
);
|
||||
assert_eq!(
|
||||
vm.dict_set(dict, Value::Object(dict), Value::Nil),
|
||||
Err(VmError::UnsupportedOperation("dict hash"))
|
||||
);
|
||||
let cell = vm.new_cell(Some(Value::Object(child))).unwrap();
|
||||
assert_eq!(
|
||||
vm.cell_set(cell, Value::Object(foreign)),
|
||||
Err(VmError::ForeignHandle)
|
||||
);
|
||||
assert_eq!(vm.cell_get(cell).unwrap(), Value::Object(child));
|
||||
let dead = vm.new_object().unwrap();
|
||||
vm.release(dead).unwrap();
|
||||
assert_eq!(
|
||||
vm.cell_set(cell, Value::Object(dead)),
|
||||
Err(VmError::InvalidHandle)
|
||||
);
|
||||
assert_eq!(vm.ref_count(child).unwrap(), 3);
|
||||
assert_eq!(
|
||||
vm.dict_clear(child),
|
||||
Err(VmError::ObjectKindMismatch("dict"))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cells_share_rebinding_distinguish_empty_and_none_and_keep_stable_objects() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let cell = vm.new_cell(None).unwrap();
|
||||
assert_eq!(vm.cell_get(cell), Err(VmError::EmptyCell));
|
||||
vm.cell_set(cell, Value::Nil).unwrap();
|
||||
assert_eq!(vm.cell_get(cell).unwrap(), Value::Nil);
|
||||
let child = vm.new_object().unwrap();
|
||||
vm.cell_set(cell, Value::Object(child)).unwrap();
|
||||
vm.release(child).unwrap();
|
||||
vm.cell_set(cell, Value::Object(child)).unwrap();
|
||||
assert_eq!(vm.ref_count(child).unwrap(), 1);
|
||||
vm.cell_clear(cell).unwrap();
|
||||
assert!(matches!(vm.object(child), Err(VmError::InvalidHandle)));
|
||||
assert_eq!(vm.cell_get(cell), Err(VmError::EmptyCell));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn container_cycles_and_duplicate_edges_are_collected() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let dict = vm.new_dict().unwrap();
|
||||
let cell = vm.new_cell(Some(Value::Object(dict))).unwrap();
|
||||
vm.dict_set(dict, text("a"), Value::Object(cell)).unwrap();
|
||||
vm.dict_set(dict, text("b"), Value::Object(cell)).unwrap();
|
||||
assert_eq!(vm.ref_count(cell).unwrap(), 3);
|
||||
vm.release(dict).unwrap();
|
||||
vm.release(cell).unwrap();
|
||||
assert_eq!(vm.collect_cycles(), 2);
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn functions_retain_globals_constants_defaults_and_shared_closure_cells() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let globals = vm.new_dict().unwrap();
|
||||
let constant = vm.new_string("constant").unwrap();
|
||||
let cell = vm.new_cell(Some(text("first"))).unwrap();
|
||||
let code = EndorCode::new(
|
||||
vec![0],
|
||||
vec![Value::Object(constant)],
|
||||
vec!["argument".into()],
|
||||
vec!["captured".into()],
|
||||
)
|
||||
.unwrap();
|
||||
let function = vm
|
||||
.allocate(
|
||||
EndorFunctionObject::new(
|
||||
"read",
|
||||
code.clone(),
|
||||
globals,
|
||||
vec![Value::Object(constant)],
|
||||
vec![cell],
|
||||
)
|
||||
.unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
let second = vm
|
||||
.allocate(
|
||||
EndorFunctionObject::new("read_again", code, globals, vec![], vec![cell]).unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(vm.ref_count(constant).unwrap(), 4);
|
||||
vm.release(constant).unwrap();
|
||||
vm.release(cell).unwrap();
|
||||
vm.cell_set(cell, text("updated")).unwrap();
|
||||
for reference in [function, second] {
|
||||
let f = vm
|
||||
.payload::<EndorFunctionObject>(reference, "function")
|
||||
.unwrap();
|
||||
assert_eq!(vm.cell_get(f.closure()[0]).unwrap(), text("updated"));
|
||||
}
|
||||
assert_eq!(
|
||||
vm.call(function, &[]),
|
||||
Err(VmError::UnsupportedOperation("language function execution"))
|
||||
);
|
||||
vm.dict_set(globals, text("read"), Value::Object(function))
|
||||
.unwrap();
|
||||
vm.release(globals).unwrap();
|
||||
vm.release(function).unwrap();
|
||||
vm.release(second).unwrap();
|
||||
assert_eq!(vm.collect_cycles(), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_function_environments_are_rejected_without_retaining_any_edges() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let globals = vm.new_object().unwrap();
|
||||
let code = EndorCode::new(vec![], vec![], vec![], vec![]).unwrap();
|
||||
let function = EndorFunctionObject::new("bad", code, globals, vec![], vec![]).unwrap();
|
||||
assert_eq!(
|
||||
vm.allocate(function),
|
||||
Err(VmError::ObjectKindMismatch("dict"))
|
||||
);
|
||||
assert_eq!(vm.ref_count(globals).unwrap(), 1);
|
||||
assert!(EndorCode::new(vec![], vec![], vec!["x".into(), "x".into()], vec![]).is_err());
|
||||
let code = EndorCode::new(vec![], vec![], vec![], vec!["x".into()]).unwrap();
|
||||
assert!(EndorFunctionObject::new("bad", code, globals, vec![], vec![]).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exceptions_preserve_arguments_chains_notes_and_traceback_without_type_classes() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let argument = vm.new_string("detail").unwrap();
|
||||
let cause = vm
|
||||
.allocate(EndorBaseExceptionObject::new(
|
||||
"ValueError",
|
||||
vec![Value::Object(argument)],
|
||||
))
|
||||
.unwrap();
|
||||
let exception = vm
|
||||
.allocate(
|
||||
EndorBaseExceptionObject::new("RuntimeError", vec![text("failed")])
|
||||
.with_cause(cause)
|
||||
.with_context(cause)
|
||||
.with_note("while loading")
|
||||
.with_traceback(EndorTracebackEntry {
|
||||
function: "load".into(),
|
||||
file: "demo.endor".into(),
|
||||
line: 12,
|
||||
}),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(vm.ref_count(cause).unwrap(), 3);
|
||||
vm.release(argument).unwrap();
|
||||
vm.release(cause).unwrap();
|
||||
let data = vm
|
||||
.payload::<EndorBaseExceptionObject>(exception, "exception")
|
||||
.unwrap();
|
||||
assert!(data.context_suppressed());
|
||||
assert_eq!(data.notes(), &["while loading"]);
|
||||
assert_eq!(data.traceback()[0].line, 12);
|
||||
assert_eq!(vm.str(exception).unwrap(), "failed");
|
||||
vm.release(exception).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
let wrong = vm.new_dict().unwrap();
|
||||
assert_eq!(
|
||||
vm.allocate(EndorBaseExceptionObject::new("Error", vec![]).with_cause(wrong)),
|
||||
Err(VmError::ObjectKindMismatch("exception"))
|
||||
);
|
||||
}
|
||||
|
||||
fn echo(arguments: &[Value]) -> Result<Value, VmError> {
|
||||
match arguments {
|
||||
[value] => Ok(value.clone()),
|
||||
_ => Err(VmError::InvalidArgument("expected one value")),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_functions_pass_lossless_numbers_and_borrowed_objects() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let function = vm
|
||||
.allocate(EndorNativeFunctionObject::new("echo", echo))
|
||||
.unwrap();
|
||||
let number = Value::Number(EndorNumber::decimal("12345678901234567890.000100").unwrap());
|
||||
assert_eq!(
|
||||
vm.call(function, std::slice::from_ref(&number)).unwrap(),
|
||||
number
|
||||
);
|
||||
let dict = vm.new_dict().unwrap();
|
||||
assert_eq!(
|
||||
vm.call(function, &[Value::Object(dict)]).unwrap(),
|
||||
Value::Object(dict)
|
||||
);
|
||||
assert_eq!(vm.ref_count(dict).unwrap(), 1);
|
||||
assert_eq!(
|
||||
vm.payload::<EndorDictObject>(dict, "dict").unwrap().len(),
|
||||
0
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,480 @@
|
||||
use std::any::Any;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
use aster_core::{CompareOp, NativeFunction, ObjectPayload, ObjectRef, Record, Value, Vm, VmError};
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Resource {
|
||||
drops: Arc<AtomicUsize>,
|
||||
edges: Vec<ObjectRef>,
|
||||
}
|
||||
|
||||
impl Drop for Resource {
|
||||
fn drop(&mut self) {
|
||||
self.drops.fetch_add(1, Ordering::SeqCst);
|
||||
}
|
||||
}
|
||||
|
||||
impl ObjectPayload for Resource {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"resource"
|
||||
}
|
||||
|
||||
fn trace(&self, visit: &mut dyn FnMut(ObjectRef)) {
|
||||
for reference in &self.edges {
|
||||
visit(*reference);
|
||||
}
|
||||
}
|
||||
|
||||
fn allows_attributes(&self) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Number(i64);
|
||||
|
||||
impl ObjectPayload for Number {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"number"
|
||||
}
|
||||
|
||||
fn repr(&self, _identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(self.0.to_string())
|
||||
}
|
||||
|
||||
fn is_true(&self) -> Result<bool, VmError> {
|
||||
Ok(self.0 != 0)
|
||||
}
|
||||
|
||||
fn hash(&self, _identity: ObjectRef) -> Result<u64, VmError> {
|
||||
Ok(self.0 as u64)
|
||||
}
|
||||
|
||||
fn compare(
|
||||
&self,
|
||||
other: &dyn ObjectPayload,
|
||||
operation: CompareOp,
|
||||
) -> Result<Option<bool>, VmError> {
|
||||
let Some(other) = other.as_any().downcast_ref::<Self>() else {
|
||||
return Ok(None);
|
||||
};
|
||||
Ok(Some(match operation {
|
||||
CompareOp::Eq => self.0 == other.0,
|
||||
CompareOp::Ne => self.0 != other.0,
|
||||
CompareOp::Lt => self.0 < other.0,
|
||||
CompareOp::Le => self.0 <= other.0,
|
||||
CompareOp::Gt => self.0 > other.0,
|
||||
CompareOp::Ge => self.0 >= other.0,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
fn resource(vm: &mut Vm, drops: &Arc<AtomicUsize>, edges: Vec<ObjectRef>) -> ObjectRef {
|
||||
vm.allocate(Resource {
|
||||
drops: drops.clone(),
|
||||
edges,
|
||||
})
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn starts_empty_without_language_classes_or_a_type_system() {
|
||||
let vm = Vm::new().unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn defaults_provide_identity_representation_hash_and_truth() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let first = vm.new_object().unwrap();
|
||||
let second = vm.new_object().unwrap();
|
||||
assert_eq!(vm.object(first).unwrap().header().identity(), first);
|
||||
assert!(vm.is_same(first, first).unwrap());
|
||||
assert!(!vm.is_same(first, second).unwrap());
|
||||
assert!(vm.repr(first).unwrap().contains(&first.to_string()));
|
||||
assert_eq!(vm.repr(first).unwrap(), vm.str(first).unwrap());
|
||||
assert_eq!(vm.hash(first).unwrap(), vm.hash(first).unwrap());
|
||||
assert!(vm.is_true(first).unwrap());
|
||||
assert!(vm.compare(first, first, CompareOp::Eq).unwrap());
|
||||
assert!(vm.compare(first, second, CompareOp::Ne).unwrap());
|
||||
assert_eq!(
|
||||
vm.compare(first, second, CompareOp::Lt),
|
||||
Err(VmError::UnsupportedOperation("ordering"))
|
||||
);
|
||||
assert_eq!(
|
||||
vm.call(first, &[]),
|
||||
Err(VmError::UnsupportedOperation("call"))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_references_control_lifetime_and_copies_are_borrowed() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let owned = resource(&mut vm, &drops, vec![]);
|
||||
let borrowed = owned;
|
||||
assert_eq!(vm.ref_count(borrowed).unwrap(), 1);
|
||||
vm.retain(owned).unwrap();
|
||||
assert_eq!(vm.ref_count(owned).unwrap(), 2);
|
||||
vm.release(owned).unwrap();
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 0);
|
||||
vm.release(owned).unwrap();
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
assert!(matches!(vm.object(borrowed), Err(VmError::InvalidHandle)));
|
||||
assert_eq!(vm.release(borrowed), Err(VmError::InvalidHandle));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_keep_objects_alive_and_delete_releases_them() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let owner = vm.new_object().unwrap();
|
||||
let child = resource(&mut vm, &drops, vec![]);
|
||||
vm.set_attr(owner, "child", Value::Object(child)).unwrap();
|
||||
assert_eq!(vm.ref_count(child).unwrap(), 2);
|
||||
vm.release(child).unwrap();
|
||||
assert_eq!(vm.ref_count(child).unwrap(), 1);
|
||||
assert_eq!(vm.release(child), Err(VmError::NoOwnedReference));
|
||||
assert_eq!(vm.get_attr(owner, "child").unwrap(), Value::Object(child));
|
||||
vm.del_attr(owner, "child").unwrap();
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(
|
||||
vm.get_attr(owner, "child"),
|
||||
Err(VmError::AttributeNotFound("child".into()))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn replacing_the_same_edge_does_not_destroy_the_target() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let owner = vm.new_object().unwrap();
|
||||
let target = vm.new_object().unwrap();
|
||||
vm.set_attr(owner, "child", Value::Object(target)).unwrap();
|
||||
vm.release(target).unwrap();
|
||||
vm.set_attr(owner, "child", Value::Object(target)).unwrap();
|
||||
assert_eq!(vm.ref_count(target).unwrap(), 1);
|
||||
vm.set_attr(owner, "child", Value::Number(7_i64.into()))
|
||||
.unwrap();
|
||||
assert!(matches!(vm.object(target), Err(VmError::InvalidHandle)));
|
||||
assert_eq!(
|
||||
vm.get_attr(owner, "child").unwrap(),
|
||||
Value::Number(7_i64.into())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn borrowed_attribute_results_can_be_retained_by_the_host() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let parent = vm.new_object().unwrap();
|
||||
let child = vm.new_object().unwrap();
|
||||
vm.set_attr(parent, "child", Value::Object(child)).unwrap();
|
||||
vm.release(child).unwrap();
|
||||
let Value::Object(borrowed) = vm.get_attr(parent, "child").unwrap() else {
|
||||
panic!("expected an object");
|
||||
};
|
||||
vm.retain(borrowed).unwrap();
|
||||
vm.release(parent).unwrap();
|
||||
assert_eq!(vm.ref_count(borrowed).unwrap(), 1);
|
||||
vm.release(borrowed).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_foreign_and_stale_writes_preserve_the_old_attribute() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let mut other = Vm::new().unwrap();
|
||||
let owner = vm.new_object().unwrap();
|
||||
let foreign = other.new_object().unwrap();
|
||||
let stale = vm.new_object().unwrap();
|
||||
vm.release(stale).unwrap();
|
||||
vm.set_attr(owner, "value", Value::Number(1_i64.into()))
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
vm.set_attr(owner, "value", Value::Object(foreign)),
|
||||
Err(VmError::ForeignHandle)
|
||||
);
|
||||
assert_eq!(
|
||||
vm.set_attr(owner, "value", Value::Object(stale)),
|
||||
Err(VmError::InvalidHandle)
|
||||
);
|
||||
assert_eq!(
|
||||
vm.get_attr(owner, "value").unwrap(),
|
||||
Value::Number(1_i64.into())
|
||||
);
|
||||
assert_eq!(vm.retain(foreign), Err(VmError::ForeignHandle));
|
||||
assert_eq!(vm.release(foreign), Err(VmError::ForeignHandle));
|
||||
assert_eq!(vm.is_same(owner, foreign), Err(VmError::ForeignHandle));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn released_handles_cannot_alias_new_objects_or_new_vms() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let old = vm.new_object().unwrap();
|
||||
vm.release(old).unwrap();
|
||||
let new = vm.new_object().unwrap();
|
||||
assert_ne!(old, new);
|
||||
assert_eq!(vm.repr(old), Err(VmError::InvalidHandle));
|
||||
let other = Vm::new().unwrap();
|
||||
assert!(matches!(other.object(new), Err(VmError::ForeignHandle)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boxed_objects_keep_their_addresses_when_the_slot_vector_grows() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let first = vm.new_object().unwrap();
|
||||
let address = std::ptr::from_ref(vm.object(first).unwrap());
|
||||
for _ in 0..4096 {
|
||||
vm.new_object().unwrap();
|
||||
}
|
||||
assert_eq!(std::ptr::from_ref(vm.object(first).unwrap()), address);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_reference_chains_are_released_without_recursive_destructors() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let head = vm.new_object().unwrap();
|
||||
let mut tail = head;
|
||||
for _ in 0..4096 {
|
||||
let next = vm.new_object().unwrap();
|
||||
vm.set_attr(tail, "next", Value::Object(next)).unwrap();
|
||||
vm.release(next).unwrap();
|
||||
tail = next;
|
||||
}
|
||||
vm.release(head).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cycles_remain_while_rooted_and_are_collected_when_unreachable() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let first = resource(&mut vm, &drops, vec![]);
|
||||
let second = resource(&mut vm, &drops, vec![]);
|
||||
vm.set_attr(first, "next", Value::Object(second)).unwrap();
|
||||
vm.set_attr(second, "next", Value::Object(first)).unwrap();
|
||||
vm.release(second).unwrap();
|
||||
assert_eq!(vm.collect_cycles(), 0);
|
||||
vm.release(first).unwrap();
|
||||
assert_eq!(vm.object_count(), 2);
|
||||
assert_eq!(vm.collect_cycles(), 2);
|
||||
assert_eq!(vm.collect_cycles(), 0);
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 2);
|
||||
assert!(matches!(vm.object(first), Err(VmError::InvalidHandle)));
|
||||
assert!(matches!(vm.object(second), Err(VmError::InvalidHandle)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cycle_collection_preserves_rooted_targets_and_updates_counts() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let live = vm.new_object().unwrap();
|
||||
let cycle = vm.new_object().unwrap();
|
||||
vm.set_attr(cycle, "self", Value::Object(cycle)).unwrap();
|
||||
vm.set_attr(cycle, "live", Value::Object(live)).unwrap();
|
||||
vm.release(cycle).unwrap();
|
||||
assert_eq!(vm.ref_count(live).unwrap(), 2);
|
||||
assert_eq!(vm.collect_cycles(), 1);
|
||||
assert_eq!(vm.ref_count(live).unwrap(), 1);
|
||||
vm.release(live).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn payload_edges_are_owned_and_duplicate_edges_are_counted() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let target = vm.new_object().unwrap();
|
||||
let holder = resource(&mut vm, &drops, vec![target, target]);
|
||||
assert_eq!(vm.ref_count(target).unwrap(), 3);
|
||||
vm.release(target).unwrap();
|
||||
vm.release(holder).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn payload_edges_participate_in_cycle_tracing() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let record = vm.new_object().unwrap();
|
||||
let native = resource(&mut vm, &drops, vec![record]);
|
||||
vm.set_attr(record, "native", Value::Object(native))
|
||||
.unwrap();
|
||||
vm.release(record).unwrap();
|
||||
vm.release(native).unwrap();
|
||||
assert_eq!(vm.collect_cycles(), 2);
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_payload_edges_abort_allocation_without_retaining_valid_edges() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let mut other = Vm::new().unwrap();
|
||||
let local = vm.new_object().unwrap();
|
||||
let foreign = other.new_object().unwrap();
|
||||
assert_eq!(
|
||||
vm.allocate(Resource {
|
||||
drops: drops.clone(),
|
||||
edges: vec![local, foreign],
|
||||
}),
|
||||
Err(VmError::ForeignHandle)
|
||||
);
|
||||
assert_eq!(vm.ref_count(local).unwrap(), 1);
|
||||
assert_eq!(vm.object_count(), 1);
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rust_payload_operations_override_defaults_without_language_types() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let zero = vm.allocate(Number(0)).unwrap();
|
||||
let first = vm.allocate(Number(42)).unwrap();
|
||||
let equal = vm.allocate(Number(42)).unwrap();
|
||||
assert!(!vm.is_same(first, equal).unwrap());
|
||||
assert!(vm.compare(first, equal, CompareOp::Eq).unwrap());
|
||||
assert!(vm.compare(zero, first, CompareOp::Lt).unwrap());
|
||||
assert_eq!(vm.hash(first).unwrap(), vm.hash(equal).unwrap());
|
||||
assert_eq!(vm.str(first).unwrap(), "42");
|
||||
assert!(!vm.is_true(zero).unwrap());
|
||||
assert!(vm.is_true(first).unwrap());
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct ReflectedOrdering;
|
||||
|
||||
impl ObjectPayload for ReflectedOrdering {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"reflected-ordering"
|
||||
}
|
||||
|
||||
fn compare(
|
||||
&self,
|
||||
_other: &dyn ObjectPayload,
|
||||
operation: CompareOp,
|
||||
) -> Result<Option<bool>, VmError> {
|
||||
Ok(Some(operation == CompareOp::Gt))
|
||||
}
|
||||
|
||||
fn hash(&self, _identity: ObjectRef) -> Result<u64, VmError> {
|
||||
Err(VmError::UnsupportedOperation("hash"))
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reflected_operations_and_explicitly_unsupported_hashing_are_respected() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let left = vm.allocate(Record).unwrap();
|
||||
let right = vm.allocate(ReflectedOrdering).unwrap();
|
||||
assert!(vm.compare(left, right, CompareOp::Lt).unwrap());
|
||||
assert_eq!(vm.hash(right), Err(VmError::UnsupportedOperation("hash")));
|
||||
}
|
||||
|
||||
fn add(arguments: &[Value]) -> Result<Value, VmError> {
|
||||
match arguments {
|
||||
[Value::Number(left), Value::Number(right)] => {
|
||||
let (left, right) = left
|
||||
.as_i64()
|
||||
.zip(right.as_i64())
|
||||
.ok_or(VmError::InvalidArgument("expected two integers"))?;
|
||||
left.checked_add(right)
|
||||
.map(|value| Value::Number(value.into()))
|
||||
.ok_or(VmError::InvalidArgument("integer overflow"))
|
||||
}
|
||||
_ => Err(VmError::InvalidArgument("expected two integers")),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_calls_dispatch_validate_arguments_and_propagate_errors() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let function = vm.allocate(NativeFunction::new("add", add)).unwrap();
|
||||
assert_eq!(vm.repr(function).unwrap(), "<native-function add>");
|
||||
assert_eq!(
|
||||
vm.call(
|
||||
function,
|
||||
&[Value::Number(2_i64.into()), Value::Number(3_i64.into())]
|
||||
)
|
||||
.unwrap(),
|
||||
Value::Number(5_i64.into())
|
||||
);
|
||||
assert_eq!(
|
||||
vm.call(function, &[]),
|
||||
Err(VmError::InvalidArgument("expected two integers"))
|
||||
);
|
||||
assert_eq!(
|
||||
vm.call(
|
||||
function,
|
||||
&[Value::Number(i64::MAX.into()), Value::Number(1_i64.into())]
|
||||
),
|
||||
Err(VmError::InvalidArgument("integer overflow"))
|
||||
);
|
||||
assert_eq!(
|
||||
vm.set_attr(function, "x", Value::Nil),
|
||||
Err(VmError::UnsupportedOperation("attributes"))
|
||||
);
|
||||
let mut other = Vm::new().unwrap();
|
||||
let foreign = other.new_object().unwrap();
|
||||
assert_eq!(
|
||||
vm.call(function, &[Value::Object(foreign)]),
|
||||
Err(VmError::ForeignHandle)
|
||||
);
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct ReturnsObject(ObjectRef);
|
||||
|
||||
impl ObjectPayload for ReturnsObject {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"invalid-return"
|
||||
}
|
||||
|
||||
fn call(&self, _arguments: &[Value]) -> Result<Value, VmError> {
|
||||
Ok(Value::Object(self.0))
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_results_cannot_smuggle_foreign_or_dead_handles_into_the_vm() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let mut other = Vm::new().unwrap();
|
||||
let foreign = other.new_object().unwrap();
|
||||
let invalid_return = vm.allocate(ReturnsObject(foreign)).unwrap();
|
||||
assert_eq!(vm.call(invalid_return, &[]), Err(VmError::ForeignHandle));
|
||||
let dead = vm.new_object().unwrap();
|
||||
vm.release(dead).unwrap();
|
||||
let invalid_return = vm.allocate(ReturnsObject(dead)).unwrap();
|
||||
assert_eq!(vm.call(invalid_return, &[]), Err(VmError::InvalidHandle));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dropping_the_vm_cleans_up_rooted_objects_and_uncollected_cycles() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
{
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let rooted = resource(&mut vm, &drops, vec![]);
|
||||
let cycle = resource(&mut vm, &drops, vec![]);
|
||||
vm.set_attr(cycle, "self", Value::Object(cycle)).unwrap();
|
||||
vm.release(cycle).unwrap();
|
||||
assert_eq!(vm.ref_count(rooted).unwrap(), 1);
|
||||
}
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 2);
|
||||
}
|
||||
Reference in New Issue
Block a user