Add typed trait requirements and enforce actual capability results

This commit is contained in:
2026-10-22 14:36:57 +08:00
parent e26e227dd0
commit 100bf637f9
16 changed files with 799 additions and 107 deletions
+2 -2
View File
@@ -5,9 +5,9 @@
| 文件 | 职责 |
| --- | --- |
| [lib.rs](lib.rs) | VM 类型导出、objects 类型兼容重导出(含 ReadAccess/CallSignature/CallType/CallEffect)、宿主调用与字节码 rustdoc 示例 |
| [vm.rs](vm.rs) | Vm 拥有 ObjectStore 与错误位置记录;对象操作和宿主 new_class 和显式Trait注册/关系查询显式委托给 objects;函数/字段检查统一开关、统一参数区间查询与函数类型配置 |
| [vm.rs](vm.rs) | Vm 拥有 ObjectStore 与错误位置记录;对象操作和宿主 new_class 和显式/类型化Trait注册/关系查询显式委托给 objects;函数/字段检查统一开关、统一参数区间查询与函数类型配置 |
| [frame.rs](frame.rs) | EndorFrame、栈条目、源码与原生委托返回契约执行根、执行位置元数据、ExecutionLimits |
| [eval.rs](eval.rs) | execute/call、只读调用与依赖结果、参数绑定、原生实现前数量/类型/效果检查和委托返回检查、可选注解/动态覆写兼容检查、源码类字段环境绑定、帧切换、取指分派、MakeFunction、结果根转移与失败清理 |
| [eval.rs](eval.rs) | execute/call、只读调用与依赖结果、参数绑定、原生实现前数量/类型/效果检查和原生/类型化Trait委托返回检查、可选注解/动态覆写兼容检查、源码类字段环境绑定、帧切换、取指分派、MakeFunction、结果根转移与失败清理 |
## 常见修改入口
+45 -21
View File
@@ -179,14 +179,14 @@ impl Vm {
Value::Object(receiver) => Some(*receiver),
_ => None,
});
if self.source_type_checks
&& let Some(receiver) = receiver
{
let typed_method = if let Some(receiver) = receiver {
self.objects
.check_method_override_call(function, receiver)?;
}
.check_method_contract_call(function, receiver, self.source_type_checks)?
} else {
false
};
let mut return_type = None;
if self.source_type_checks
if (self.source_type_checks || typed_method)
&& let Some(signature) = executable.source_signature()
{
for (index, expected_name) in signature.parameters.iter().enumerate() {
@@ -234,6 +234,14 @@ impl Vm {
executable,
};
let initialized = (|| -> Result<(), VmError> {
if let Some(receiver) = receiver {
for (name, expected) in self.objects.method_trait_returns(function, receiver)? {
self.push_native_return(
&mut frame.native_returns,
NativeReturn { name, expected },
)?;
}
}
let defaults = data.defaults().iter().skip(arguments.len() - required);
for (slot, value) in frame
.localsplus
@@ -277,11 +285,12 @@ impl Vm {
for argument in arguments {
self.validate_value(argument)?;
}
if self.source_type_checks
&& let Some(Value::Object(receiver)) = arguments.first()
{
self.objects
.check_method_override_call(function, *receiver)?;
if let Some(Value::Object(receiver)) = arguments.first() {
self.objects.check_method_contract_call(
function,
*receiver,
self.source_type_checks,
)?;
}
if let Some(arity) = self.objects.call_arity(function)?
&& !arity.accepts(arguments.len())
@@ -326,7 +335,9 @@ impl Vm {
.is::<EndorFunctionObject>()
{
let mut frame = self.prepare_frame(function, &arguments)?;
let mut local = std::mem::take(&mut frame.native_returns);
frame.native_returns = std::mem::take(&mut returns);
frame.native_returns.append(&mut local);
return Ok(PreparedCall::Frame(frame));
}
if *executed >= limits.max_instructions {
@@ -340,17 +351,12 @@ impl Vm {
name: self.object(function)?.payload().kind_name().into(),
expected: signature.returns,
};
let mut retained = Vec::new();
for reference in check.expected.references() {
if let Err(error) = self.retain(reference) {
for reference in retained {
self.release(reference)?;
}
return Err(error);
}
retained.push(reference);
self.push_native_return(&mut returns, check)?;
}
if let Some(Value::Object(receiver)) = arguments.first() {
for (name, expected) in self.objects.method_trait_returns(function, *receiver)? {
self.push_native_return(&mut returns, NativeReturn { name, expected })?;
}
returns.push(check);
}
match self.invoke_native(function, &arguments)? {
NativeResult::Return(value) => {
@@ -389,6 +395,24 @@ impl Vm {
result
}
fn push_native_return(
&mut self,
returns: &mut Vec<NativeReturn>,
check: NativeReturn,
) -> Result<(), VmError> {
let mut retained = Vec::new();
for reference in check.expected.references() {
if let Err(error) = self.retain(reference) {
for reference in retained {
self.release(reference)?;
}
return Err(error);
}
retained.push(reference);
}
returns.push(check);
Ok(())
}
fn clear_native_returns(&mut self, returns: Vec<NativeReturn>) {
for check in returns {
for reference in check.expected.references() {
+1 -1
View File
@@ -47,7 +47,7 @@ pub use frame::{EndorFrame, ExecutionLimits, ExecutionLocation};
pub use objects::ObjectStore;
pub use objects::{
AnnotationType, ClassField, EndorTraitObject, EndorTypeObject, MethodRequirement, RootTypes,
TypeConstructor,
TypeConstructor, TypedMethodRequirement,
};
pub use objects::{
CallArity, CallEffect, CallSignature, CallType, ChangeBatch, ChangeKey, CodeLayout, CompareOp,
+7
View File
@@ -40,6 +40,13 @@ impl Vm {
) -> Result<ObjectRef, VmError> {
self.objects.new_trait(name, requirements)
}
pub fn new_typed_trait(
&mut self,
name: impl Into<String>,
requirements: Vec<crate::TypedMethodRequirement>,
) -> Result<ObjectRef, VmError> {
self.objects.new_typed_trait(name, requirements)
}
pub fn implement_trait(
&mut self,
definition: ObjectRef,
+1
View File
@@ -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) | 原生作用域根、分配失败清理、原生签名/联合与可空类型/效果和委托返回根、绑定方法元数据、委托、只读结果分配/写入拒绝/依赖/校验与普通读取区分及失败恢复、弱引用过期及有界变更;仅远端执行 |
+365
View File
@@ -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);
}