Add typed trait requirements and enforce actual capability results
This commit is contained in:
@@ -8,6 +8,7 @@
|
||||
| [builtins.rs](builtins.rs) | 无损 Number、Unicode 字符串、Dict 顺序与键、Cell、函数环境/共享代码、异常数据 |
|
||||
| [execution.rs](execution.rs) | wordcode 与校验、控制流、参数/默认值、嵌套帧、字节码函数创建/默认值/环境捕获、闭包、返回值存活、失败清理、限额 |
|
||||
| [types.rs](types.rs) | 名义身份、继承与实例关系、类型边保活/循环回收、只读类型元数据与外来句柄、显式Trait身份/继承/参数约束及后代更新原子性;统一函数分类、原生数量元数据/副作用前拒绝/能力更新/默认参数与返回类型错误根清理;仅远端执行 |
|
||||
| [typed_traits.rs](typed_traits.rs) | 类型化Trait登记、原子拒绝、源码检查关闭时的显式约束、宽参数调用、类型强边GC、体后实际能力结果检查与临时验证集合恢复;仅远端执行 |
|
||||
| [method_contracts.rs](method_contracts.rs) | 源码/原生方法覆写参数逆变/返回协变、联合参数、效果、祖先替换原子性、动态名称重绑定/前向名称与体前拒绝/恢复及清理;仅远端执行 |
|
||||
| [native_context.rs](native_context.rs) | 原生作用域根、分配失败清理、原生签名/联合与可空类型/效果和委托返回根、绑定方法元数据、委托、只读结果分配/写入拒绝/依赖/校验与普通读取区分及失败恢复、弱引用过期及有界变更;仅远端执行 |
|
||||
|
||||
|
||||
@@ -0,0 +1,365 @@
|
||||
//! Remote-only coverage of explicit typed capability contracts.
|
||||
use endor_core::{
|
||||
AnnotationType as T, CallEffect, CallSignature, CodeLayout, ContextNativeFunction, EndorCode,
|
||||
Instruction, NativeCallable, NativeContext, NativeResult, ObjectRef, Opcode, SourceSignature,
|
||||
TypeConstructor, TypedMethodRequirement, Value, Vm, VmError,
|
||||
};
|
||||
|
||||
fn capability(
|
||||
vm: &mut Vm,
|
||||
name: &str,
|
||||
parameters: Vec<T>,
|
||||
returns: T,
|
||||
effect: CallEffect,
|
||||
) -> ObjectRef {
|
||||
vm.new_typed_trait(
|
||||
name,
|
||||
vec![TypedMethodRequirement {
|
||||
name: "check".into(),
|
||||
signature: CallSignature::exact(parameters, returns, effect),
|
||||
}],
|
||||
)
|
||||
.unwrap()
|
||||
}
|
||||
fn source(
|
||||
vm: &mut Vm,
|
||||
globals: ObjectRef,
|
||||
owner: &str,
|
||||
types: &[&str],
|
||||
returns: &str,
|
||||
value: Value,
|
||||
) -> ObjectRef {
|
||||
let code = EndorCode::from_instructions(
|
||||
&[
|
||||
Instruction::new(Opcode::LoadConst, 0),
|
||||
Instruction::new(Opcode::StoreGlobal, 0),
|
||||
Instruction::new(Opcode::LoadConst, 1),
|
||||
Instruction::simple(Opcode::ReturnValue),
|
||||
],
|
||||
vec![Value::Number(42.into()), value],
|
||||
CodeLayout {
|
||||
parameters: (0..types.len()).map(|i| format!("p{i}")).collect(),
|
||||
names: vec!["ran".into()],
|
||||
..CodeLayout::default()
|
||||
},
|
||||
)
|
||||
.unwrap()
|
||||
.with_source_signature(SourceSignature {
|
||||
parameters: types.iter().map(|s| (*s).into()).collect(),
|
||||
return_type: returns.into(),
|
||||
method_owner: Some(owner.into()),
|
||||
})
|
||||
.unwrap();
|
||||
let code = vm.new_code(code).unwrap();
|
||||
let function = vm
|
||||
.new_function("check", code, globals, vec![], vec![])
|
||||
.unwrap();
|
||||
vm.release(code).unwrap();
|
||||
function
|
||||
}
|
||||
#[derive(Debug)]
|
||||
struct Native(CallSignature);
|
||||
impl NativeCallable for Native {
|
||||
fn signature(&self) -> Option<CallSignature> {
|
||||
Some(self.0.clone())
|
||||
}
|
||||
fn invoke(&self, _: &mut NativeContext<'_>, _: &[Value]) -> Result<NativeResult, VmError> {
|
||||
Ok(NativeResult::Return(Value::Number(7.into())))
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn typed_registration_is_atomic_and_wider_native_inputs_remain_callable() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let roots = vm.bootstrap_types().unwrap();
|
||||
let definition = vm
|
||||
.new_type("Model", roots.object, TypeConstructor::Record)
|
||||
.unwrap();
|
||||
let contract = capability(
|
||||
&mut vm,
|
||||
"Numeric",
|
||||
vec![T::Any, T::Number],
|
||||
T::Number,
|
||||
CallEffect::ReadOnly,
|
||||
);
|
||||
for (argument, effect) in [
|
||||
(T::String, CallEffect::ReadOnly),
|
||||
(T::Any, CallEffect::Mutating),
|
||||
] {
|
||||
let function = vm
|
||||
.allocate(ContextNativeFunction::new(
|
||||
"bad",
|
||||
Native(CallSignature::exact(
|
||||
vec![T::Nominal(definition), argument],
|
||||
T::Number,
|
||||
effect,
|
||||
)),
|
||||
vec![],
|
||||
))
|
||||
.unwrap();
|
||||
vm.define_method(definition, "check", function).unwrap();
|
||||
let version = vm.change_version(definition).unwrap();
|
||||
assert!(matches!(
|
||||
vm.implement_trait(definition, contract),
|
||||
Err(VmError::TraitViolation { .. })
|
||||
));
|
||||
assert_eq!(vm.change_version(definition).unwrap(), version);
|
||||
assert!(!vm.implements_trait(definition, contract).unwrap());
|
||||
vm.release(function).unwrap();
|
||||
}
|
||||
let function = vm
|
||||
.allocate(ContextNativeFunction::new(
|
||||
"good",
|
||||
Native(CallSignature::exact(
|
||||
vec![T::Nominal(definition), T::Any],
|
||||
T::Number,
|
||||
CallEffect::ReadOnly,
|
||||
)),
|
||||
vec![],
|
||||
))
|
||||
.unwrap();
|
||||
vm.define_method(definition, "check", function).unwrap();
|
||||
vm.implement_trait(definition, contract).unwrap();
|
||||
let receiver = vm.new_object().unwrap();
|
||||
vm.attach_type(receiver, definition).unwrap();
|
||||
assert_eq!(
|
||||
vm.call(
|
||||
function,
|
||||
&[
|
||||
Value::Object(receiver),
|
||||
Value::Text("extra supported input".into())
|
||||
]
|
||||
)
|
||||
.unwrap(),
|
||||
Value::Number(7.into())
|
||||
);
|
||||
for object in [
|
||||
receiver,
|
||||
function,
|
||||
definition,
|
||||
contract,
|
||||
roots.object,
|
||||
roots.type_type,
|
||||
] {
|
||||
vm.release(object).unwrap();
|
||||
}
|
||||
vm.collect_cycles();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_source_methods_enforce_their_annotations_even_when_global_checks_are_off() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let roots = vm.bootstrap_types().unwrap();
|
||||
let definition = vm
|
||||
.new_type("Model", roots.object, TypeConstructor::Record)
|
||||
.unwrap();
|
||||
let globals = vm.new_dict().unwrap();
|
||||
let function = source(
|
||||
&mut vm,
|
||||
globals,
|
||||
"Model",
|
||||
&["Model", "Number"],
|
||||
"Number",
|
||||
Value::Bool(true),
|
||||
);
|
||||
vm.define_method(definition, "check", function).unwrap();
|
||||
let receiver = vm.new_object().unwrap();
|
||||
vm.attach_type(receiver, definition).unwrap();
|
||||
// Existing untyped declarations retain the default-off compatibility mode.
|
||||
assert_eq!(
|
||||
vm.call(function, &[Value::Object(receiver), Value::Bool(false)])
|
||||
.unwrap(),
|
||||
Value::Bool(true)
|
||||
);
|
||||
let contract = capability(
|
||||
&mut vm,
|
||||
"Numeric",
|
||||
vec![T::Any, T::Number],
|
||||
T::Number,
|
||||
CallEffect::ReadOnly,
|
||||
);
|
||||
vm.implement_trait(definition, contract).unwrap();
|
||||
vm.dict_set(globals, Value::Text("ran".into()), Value::Number(0.into()))
|
||||
.unwrap();
|
||||
assert!(matches!(
|
||||
vm.call(function, &[Value::Object(receiver), Value::Bool(false)]),
|
||||
Err(VmError::TypeMismatch { .. })
|
||||
));
|
||||
assert_eq!(
|
||||
vm.dict_get(globals, &Value::Text("ran".into())).unwrap(),
|
||||
Some(Value::Number(0.into()))
|
||||
);
|
||||
assert!(
|
||||
matches!(vm.call(function, &[Value::Object(receiver), Value::Number(1.into())]), Err(VmError::TypeMismatch { position, .. }) if position=="return")
|
||||
);
|
||||
assert_eq!(
|
||||
vm.dict_get(globals, &Value::Text("ran".into())).unwrap(),
|
||||
Some(Value::Number(42.into()))
|
||||
);
|
||||
for object in [
|
||||
receiver,
|
||||
function,
|
||||
definition,
|
||||
contract,
|
||||
globals,
|
||||
roots.object,
|
||||
roots.type_type,
|
||||
] {
|
||||
vm.release(object).unwrap();
|
||||
}
|
||||
vm.collect_cycles();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_trait_definitions_trace_their_signature_types_without_hidden_roots() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let roots = vm.bootstrap_types().unwrap();
|
||||
let definition = vm
|
||||
.new_type("Value", roots.object, TypeConstructor::Record)
|
||||
.unwrap();
|
||||
let weak = vm.downgrade(definition).unwrap();
|
||||
let contract = capability(
|
||||
&mut vm,
|
||||
"ValueContract",
|
||||
vec![T::Any, T::Nominal(definition)],
|
||||
T::Nominal(definition),
|
||||
CallEffect::ReadOnly,
|
||||
);
|
||||
vm.release(definition).unwrap();
|
||||
let retained = vm
|
||||
.upgrade(weak)
|
||||
.unwrap()
|
||||
.expect("signature retains its type");
|
||||
vm.release(retained).unwrap();
|
||||
vm.release(contract).unwrap();
|
||||
vm.collect_cycles();
|
||||
assert!(vm.upgrade(weak).unwrap().is_none());
|
||||
for object in [roots.object, roots.type_type] {
|
||||
vm.release(object).unwrap();
|
||||
}
|
||||
vm.collect_cycles();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct RebindThenReturn {
|
||||
signature: CallSignature,
|
||||
globals: ObjectRef,
|
||||
other: ObjectRef,
|
||||
result: ObjectRef,
|
||||
}
|
||||
impl NativeCallable for RebindThenReturn {
|
||||
fn signature(&self) -> Option<CallSignature> {
|
||||
Some(self.signature.clone())
|
||||
}
|
||||
fn invoke(&self, cx: &mut NativeContext<'_>, _: &[Value]) -> Result<NativeResult, VmError> {
|
||||
cx.dict_set(
|
||||
self.globals,
|
||||
Value::Text("Current".into()),
|
||||
Value::Object(self.other),
|
||||
)?;
|
||||
Ok(NativeResult::Return(Value::Object(self.result)))
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn actual_trait_returns_revalidate_capabilities_after_body_side_effects_and_restore_guards() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let roots = vm.bootstrap_types().unwrap();
|
||||
let result_base = vm
|
||||
.new_type("Result", roots.object, TypeConstructor::Record)
|
||||
.unwrap();
|
||||
let result_child = vm
|
||||
.new_type("ResultChild", result_base, TypeConstructor::Record)
|
||||
.unwrap();
|
||||
let other = vm
|
||||
.new_type("Other", roots.object, TypeConstructor::Record)
|
||||
.unwrap();
|
||||
let model = vm
|
||||
.new_type("Model", roots.object, TypeConstructor::Record)
|
||||
.unwrap();
|
||||
let globals = vm.new_dict().unwrap();
|
||||
vm.dict_set(
|
||||
globals,
|
||||
Value::Text("Current".into()),
|
||||
Value::Object(result_child),
|
||||
)
|
||||
.unwrap();
|
||||
let read = source(&mut vm, globals, "Model", &["Model"], "Current", Value::Nil);
|
||||
vm.define_method(model, "check", read).unwrap();
|
||||
let feature = capability(
|
||||
&mut vm,
|
||||
"Feature",
|
||||
vec![T::Any],
|
||||
T::Nominal(result_base),
|
||||
CallEffect::External,
|
||||
);
|
||||
vm.implement_trait(model, feature).unwrap();
|
||||
let value = vm.new_object().unwrap();
|
||||
vm.attach_type(value, model).unwrap();
|
||||
let actor = vm
|
||||
.new_type("Actor", roots.object, TypeConstructor::Record)
|
||||
.unwrap();
|
||||
let contract = capability(
|
||||
&mut vm,
|
||||
"Producer",
|
||||
vec![T::Any],
|
||||
T::Capability(feature),
|
||||
CallEffect::External,
|
||||
);
|
||||
let function = vm
|
||||
.allocate(ContextNativeFunction::new(
|
||||
"produce",
|
||||
RebindThenReturn {
|
||||
signature: CallSignature::exact(
|
||||
vec![T::Nominal(actor)],
|
||||
T::Nominal(model),
|
||||
CallEffect::Mutating,
|
||||
),
|
||||
globals,
|
||||
other,
|
||||
result: value,
|
||||
},
|
||||
vec![globals, other, value],
|
||||
))
|
||||
.unwrap();
|
||||
vm.define_method(actor, "check", function).unwrap();
|
||||
vm.implement_trait(actor, contract).unwrap();
|
||||
let receiver = vm.new_object().unwrap();
|
||||
vm.attach_type(receiver, actor).unwrap();
|
||||
assert!(matches!(
|
||||
vm.call(function, &[Value::Object(receiver)]),
|
||||
Err(VmError::TraitViolation { .. })
|
||||
));
|
||||
// Repeated failures must not leave a recursive-validation guard marked active.
|
||||
for _ in 0..2 {
|
||||
assert!(vm.implements_trait(model, feature).is_err());
|
||||
}
|
||||
vm.dict_set(
|
||||
globals,
|
||||
Value::Text("Current".into()),
|
||||
Value::Object(result_child),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(vm.implements_trait(model, feature).unwrap());
|
||||
for object in [
|
||||
receiver,
|
||||
function,
|
||||
actor,
|
||||
contract,
|
||||
value,
|
||||
read,
|
||||
model,
|
||||
feature,
|
||||
globals,
|
||||
other,
|
||||
result_child,
|
||||
result_base,
|
||||
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