Enforce native type signatures and effects across delegated calls
This commit is contained in:
@@ -268,3 +268,352 @@ fn annotation_reads_remain_dependencies_without_becoming_program_content_reads()
|
||||
store.release(object).unwrap();
|
||||
assert_eq!(store.object_count(), 0);
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct TypedNative {
|
||||
signature: endor_core::CallSignature,
|
||||
calls: std::sync::Arc<std::sync::atomic::AtomicUsize>,
|
||||
delegate: Option<ObjectRef>,
|
||||
allocate_result: bool,
|
||||
}
|
||||
impl NativeCallable for TypedNative {
|
||||
fn signature(&self) -> Option<endor_core::CallSignature> {
|
||||
Some(self.signature.clone())
|
||||
}
|
||||
fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result<NativeResult, VmError> {
|
||||
self.calls.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||||
if let Some(function) = self.delegate {
|
||||
return Ok(NativeResult::Invoke {
|
||||
function,
|
||||
arguments: args.to_vec(),
|
||||
});
|
||||
}
|
||||
Ok(NativeResult::Return(if self.allocate_result {
|
||||
Value::Object(cx.new_object()?)
|
||||
} else {
|
||||
args.last().cloned().unwrap_or(Value::Nil)
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_types_preflight_arguments_and_clean_wrong_result_roots() {
|
||||
use endor_core::{AnnotationType as T, CallEffect, CallSignature};
|
||||
use std::sync::{
|
||||
Arc,
|
||||
atomic::{AtomicUsize, Ordering},
|
||||
};
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let function = vm
|
||||
.allocate(ContextNativeFunction::new(
|
||||
"typed",
|
||||
TypedNative {
|
||||
signature: CallSignature::exact(vec![T::Number], T::Number, CallEffect::ReadOnly),
|
||||
calls: calls.clone(),
|
||||
delegate: None,
|
||||
allocate_result: true,
|
||||
},
|
||||
vec![],
|
||||
))
|
||||
.unwrap();
|
||||
assert!(
|
||||
matches!(vm.call(function, &[Value::Text("bad".into())]), Err(VmError::TypeMismatch { position, .. }) if position == "parameter 1")
|
||||
);
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 0);
|
||||
assert!(
|
||||
matches!(vm.call(function, &[Value::Number(7.into())]), Err(VmError::TypeMismatch { position, .. }) if position == "return")
|
||||
);
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(vm.object_count(), 1);
|
||||
vm.release(function).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delegated_source_results_obey_every_native_contract_without_extra_frames() {
|
||||
use endor_core::{
|
||||
AnnotationType as T, CallEffect, CallSignature, CodeLayout, EndorCode, Instruction, Opcode,
|
||||
};
|
||||
use std::sync::{Arc, atomic::AtomicUsize};
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let code = EndorCode::from_instructions(
|
||||
&[
|
||||
Instruction::new(Opcode::LoadConst, 0),
|
||||
Instruction::simple(Opcode::ReturnValue),
|
||||
],
|
||||
vec![Value::Text("source result".into())],
|
||||
CodeLayout::default(),
|
||||
)
|
||||
.unwrap();
|
||||
let code = vm.new_code(code).unwrap();
|
||||
let globals = vm.new_dict().unwrap();
|
||||
let source = vm
|
||||
.new_function("source", code, globals, vec![], vec![])
|
||||
.unwrap();
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let inner = vm
|
||||
.allocate(ContextNativeFunction::new(
|
||||
"inner",
|
||||
TypedNative {
|
||||
signature: CallSignature::exact(vec![], T::String, CallEffect::ReadOnly),
|
||||
calls: calls.clone(),
|
||||
delegate: Some(source),
|
||||
allocate_result: false,
|
||||
},
|
||||
vec![source],
|
||||
))
|
||||
.unwrap();
|
||||
let outer = vm
|
||||
.allocate(ContextNativeFunction::new(
|
||||
"outer",
|
||||
TypedNative {
|
||||
signature: CallSignature::exact(vec![], T::Number, CallEffect::ReadOnly),
|
||||
calls,
|
||||
delegate: Some(inner),
|
||||
allocate_result: false,
|
||||
},
|
||||
vec![inner],
|
||||
))
|
||||
.unwrap();
|
||||
let limits = ExecutionLimits {
|
||||
max_frames: 1,
|
||||
max_instructions: 100,
|
||||
};
|
||||
assert_eq!(
|
||||
vm.call_with_limits(inner, &[], limits).unwrap(),
|
||||
Value::Text("source result".into())
|
||||
);
|
||||
assert!(
|
||||
matches!(vm.call_with_limits(outer, &[], limits), Err(VmError::TypeMismatch { function, position, .. }) if function == "outer" && position == "return")
|
||||
);
|
||||
assert!(matches!(
|
||||
vm.call_with_limits(
|
||||
outer,
|
||||
&[],
|
||||
ExecutionLimits {
|
||||
max_frames: 0,
|
||||
..limits
|
||||
}
|
||||
),
|
||||
Err(VmError::ExecutionLimit("frames"))
|
||||
));
|
||||
for object in [outer, inner, source, globals, code] {
|
||||
vm.release(object).unwrap();
|
||||
}
|
||||
vm.collect_cycles();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn signatures_trace_nominal_types_and_bound_receivers_use_the_actual_contract() {
|
||||
use endor_core::{AnnotationType as T, CallEffect, CallSignature, TypeConstructor};
|
||||
use std::sync::{
|
||||
Arc,
|
||||
atomic::{AtomicUsize, Ordering},
|
||||
};
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let roots = vm.bootstrap_types().unwrap();
|
||||
let definition = vm
|
||||
.new_type("Receiver", roots.object, TypeConstructor::Record)
|
||||
.unwrap();
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let function = vm
|
||||
.allocate(ContextNativeFunction::new(
|
||||
"echo",
|
||||
TypedNative {
|
||||
signature: CallSignature::exact(
|
||||
vec![T::Nominal(definition), T::Number],
|
||||
T::Number,
|
||||
CallEffect::ReadOnly,
|
||||
),
|
||||
calls: calls.clone(),
|
||||
delegate: None,
|
||||
allocate_result: false,
|
||||
},
|
||||
vec![],
|
||||
))
|
||||
.unwrap(); // Metadata alone traces the definition.
|
||||
let weak = vm.downgrade(definition).unwrap();
|
||||
vm.define_method(definition, "echo", function).unwrap();
|
||||
let receiver = vm.new_object().unwrap();
|
||||
vm.attach_type(receiver, definition).unwrap();
|
||||
vm.release(definition).unwrap();
|
||||
let Value::Object(bound) = vm.bind_attr(receiver, "echo").unwrap() else {
|
||||
panic!("bound method")
|
||||
};
|
||||
assert_eq!(
|
||||
vm.call_arity(bound).unwrap(),
|
||||
Some(endor_core::CallArity::exact(1))
|
||||
);
|
||||
assert!(vm.call(bound, &[Value::Bool(true)]).is_err());
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 0);
|
||||
assert_eq!(
|
||||
vm.call(bound, &[Value::Number(9.into())]).unwrap(),
|
||||
Value::Number(9.into())
|
||||
);
|
||||
for object in [bound, receiver, function, roots.object, roots.type_type] {
|
||||
vm.release(object).unwrap();
|
||||
}
|
||||
vm.collect_cycles();
|
||||
assert!(vm.upgrade(weak).unwrap().is_none());
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn declared_host_effects_are_rejected_before_read_only_dispatch() {
|
||||
use endor_core::{AnnotationType as T, CallEffect, CallSignature};
|
||||
use std::sync::{
|
||||
Arc,
|
||||
atomic::{AtomicUsize, Ordering},
|
||||
};
|
||||
for effect in [CallEffect::Mutating, CallEffect::External] {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let function = vm
|
||||
.allocate(ContextNativeFunction::new(
|
||||
"effect",
|
||||
TypedNative {
|
||||
signature: CallSignature::exact(vec![], T::Unit, effect),
|
||||
calls: calls.clone(),
|
||||
delegate: None,
|
||||
allocate_result: false,
|
||||
},
|
||||
vec![],
|
||||
))
|
||||
.unwrap();
|
||||
assert!(
|
||||
vm.call_read_only_with_limits(function, &[], ExecutionLimits::default())
|
||||
.is_err()
|
||||
);
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 0);
|
||||
assert_eq!(vm.call(function, &[]).unwrap(), Value::Nil);
|
||||
vm.release(function).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn legacy_native_signatures_check_optional_variadic_types_and_metadata() {
|
||||
use endor_core::{AnnotationType as T, CallArity, CallEffect, CallSignature, NativeFunction};
|
||||
fn echo(args: &[Value]) -> Result<Value, VmError> {
|
||||
Ok(args.last().cloned().unwrap_or(Value::Nil))
|
||||
}
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let function = vm
|
||||
.allocate(
|
||||
NativeFunction::new("legacy", echo).with_signature(CallSignature {
|
||||
arity: CallArity::range(0, usize::MAX),
|
||||
parameters: vec![],
|
||||
variadic: Some(T::Number),
|
||||
returns: T::Number,
|
||||
effect: CallEffect::ReadOnly,
|
||||
}),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
vm.call(
|
||||
function,
|
||||
&[Value::Number(1.into()), Value::Number(2.into())]
|
||||
)
|
||||
.unwrap(),
|
||||
Value::Number(2.into())
|
||||
);
|
||||
assert!(vm.call(function, &[Value::Bool(true)]).is_err());
|
||||
assert!(
|
||||
matches!(vm.call(function, &[]), Err(VmError::TypeMismatch { position, .. }) if position == "return")
|
||||
);
|
||||
let invalid = vm
|
||||
.allocate(
|
||||
NativeFunction::new("invalid", echo)
|
||||
.with_signature(CallSignature::exact(
|
||||
vec![T::Number],
|
||||
T::Number,
|
||||
CallEffect::ReadOnly,
|
||||
))
|
||||
.with_arity(CallArity::exact(0)),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(vm.call_arity(invalid).is_err());
|
||||
assert!(vm.call(invalid, &[]).is_err());
|
||||
vm.release(invalid).unwrap();
|
||||
vm.release(function).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct EraseThenDelegate {
|
||||
signature: endor_core::CallSignature,
|
||||
target: ObjectRef,
|
||||
}
|
||||
impl NativeCallable for EraseThenDelegate {
|
||||
fn signature(&self) -> Option<endor_core::CallSignature> {
|
||||
Some(self.signature.clone())
|
||||
}
|
||||
fn invoke(&self, cx: &mut NativeContext<'_>, _: &[Value]) -> Result<NativeResult, VmError> {
|
||||
cx.replace_payload(cx.callee(), endor_core::Record)?;
|
||||
Ok(NativeResult::Invoke {
|
||||
function: self.target,
|
||||
arguments: vec![],
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delegated_return_type_survives_removal_of_the_original_signature_edges() {
|
||||
use endor_core::{
|
||||
AnnotationType as T, CallEffect, CallSignature, CodeLayout, EndorCode, Instruction, Opcode,
|
||||
TypeConstructor,
|
||||
};
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let roots = vm.bootstrap_types().unwrap();
|
||||
let definition = vm
|
||||
.new_type("Transient", roots.object, TypeConstructor::Record)
|
||||
.unwrap();
|
||||
let weak = vm.downgrade(definition).unwrap();
|
||||
let code = EndorCode::from_instructions(
|
||||
&[
|
||||
Instruction::new(Opcode::LoadConst, 0),
|
||||
Instruction::simple(Opcode::ReturnValue),
|
||||
],
|
||||
vec![Value::Nil],
|
||||
CodeLayout::default(),
|
||||
)
|
||||
.unwrap();
|
||||
let code = vm.new_code(code).unwrap();
|
||||
let globals = vm.new_dict().unwrap();
|
||||
let source = vm
|
||||
.new_function("source", code, globals, vec![], vec![])
|
||||
.unwrap();
|
||||
let wrapper = vm
|
||||
.allocate(ContextNativeFunction::new(
|
||||
"erased",
|
||||
EraseThenDelegate {
|
||||
signature: CallSignature::exact(
|
||||
vec![],
|
||||
T::Nominal(definition),
|
||||
CallEffect::Mutating,
|
||||
),
|
||||
target: source,
|
||||
},
|
||||
vec![source],
|
||||
))
|
||||
.unwrap();
|
||||
vm.release(definition).unwrap();
|
||||
assert!(
|
||||
matches!(vm.call(wrapper, &[]), Err(VmError::TypeMismatch { function, expected, .. }) if function == "erased" && expected == "Transient")
|
||||
);
|
||||
assert!(vm.upgrade(weak).unwrap().is_none());
|
||||
for object in [
|
||||
wrapper,
|
||||
source,
|
||||
code,
|
||||
globals,
|
||||
roots.object,
|
||||
roots.type_type,
|
||||
] {
|
||||
vm.release(object).unwrap();
|
||||
}
|
||||
vm.collect_cycles();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user