Prove read-only effects through current source call graphs

This commit is contained in:
2026-10-22 15:55:44 +08:00
parent cd25f819f2
commit ae821aea2e
11 changed files with 614 additions and 58 deletions
+1 -1
View File
@@ -9,7 +9,7 @@
| [execution.rs](execution.rs) | wordcode 与校验、控制流、参数/默认值、嵌套帧、字节码函数创建/默认值/环境捕获、闭包、返回值存活、失败清理、限额 |
| [types.rs](types.rs) | 名义身份、继承与实例关系、类型边保活/循环回收、只读类型元数据与外来句柄、显式Trait身份/继承/参数约束及后代更新原子性;统一函数分类、原生数量元数据/副作用前拒绝/能力更新/默认参数与返回类型错误根清理;仅远端执行 |
| [typed_traits.rs](typed_traits.rs) | 类型化Trait登记、原子拒绝、源码检查关闭时的显式约束、宽参数调用、类型强边GC、体后实际能力结果检查与临时验证集合恢复;仅远端执行 |
| [method_contracts.rs](method_contracts.rs) | 源码/原生方法覆写参数逆变/返回协变、联合参数、已证明源码只读/原生效果及共享赋值保守分类、祖先替换原子性、动态名称重绑定/前向名称与体前拒绝/恢复及清理;仅远端执行 |
| [method_contracts.rs](method_contracts.rs) | 源码/原生方法覆写参数逆变/返回协变、联合参数、已证明源码/调用图只读、全局/闭包/接收者重绑定、控制流汇合与原生效果及共享赋值保守分类、祖先替换原子性、动态名称重绑定/前向名称与体前拒绝/恢复及清理;仅远端执行 |
| [native_context.rs](native_context.rs) | 原生作用域根、分配失败清理、原生签名/联合与可空类型/固定与Delegated效果和委托返回根、绑定方法元数据、委托、只读结果分配/写入拒绝/依赖/校验与普通读取区分及失败恢复、弱引用过期及有界变更;仅远端执行 |
核心对象现由 objects 定义,本目录保留既有 endor_core 导入与 Vm 方法的兼容性检查。独立对象存储检查见 [objects/tests](../../objects/tests/README.md)。堆内部伪造句柄与计数溢出检查在 objects 的 src/heap.rs,公开示例由 src/lib.rs rustdoc 提供。文件职责见 [src](../src/README.md),检查方式和结果边界见 [验证](../../../docs/operations/validation.md)。本地不执行测试;存在测试文件不代表某次提交已通过。返回 [core](../README.md)。
+286
View File
@@ -588,3 +588,289 @@ fn shared_local_assignment_and_dynamic_calls_are_not_inferred_pure() {
.unwrap();
assert!(!call.is_statically_read_only());
}
fn global_caller(vm: &mut Vm, globals: ObjectRef, name: &str) -> ObjectRef {
let code = EndorCode::from_instructions(
&[
Instruction::new(Opcode::LoadGlobal, 0),
Instruction::simple(Opcode::PushNull),
Instruction::new(Opcode::Call, 0),
Instruction::simple(Opcode::ReturnValue),
],
vec![],
CodeLayout {
names: vec![name.into()],
..CodeLayout::default()
},
)
.unwrap();
let code = vm.new_code(code).unwrap();
let function = vm
.new_function("caller", code, globals, vec![], vec![])
.unwrap();
vm.release(code).unwrap();
function
}
#[test]
fn transitive_effect_queries_follow_rebinding_closures_and_recursive_graphs() {
let mut vm = Vm::new().unwrap();
let globals = vm.new_dict().unwrap();
let builtins = vm.new_dict().unwrap();
vm.dict_set(
globals,
Value::Text("__builtins__".into()),
Value::Object(builtins),
)
.unwrap();
let pure = vm
.allocate(ContextNativeFunction::new(
"pure",
Native(CallSignature::exact(
vec![],
T::Number,
CallEffect::ReadOnly,
)),
vec![],
))
.unwrap();
let impure = vm
.allocate(ContextNativeFunction::new(
"impure",
Native(CallSignature::exact(
vec![],
T::Number,
CallEffect::Mutating,
)),
vec![],
))
.unwrap();
vm.dict_set(builtins, Value::Text("target".into()), Value::Object(pure))
.unwrap();
let wrapper = global_caller(&mut vm, globals, "target");
let outer = global_caller(&mut vm, globals, "wrapper");
vm.dict_set(
globals,
Value::Text("wrapper".into()),
Value::Object(wrapper),
)
.unwrap();
assert_eq!(vm.call_effect(outer).unwrap(), Some(CallEffect::ReadOnly));
vm.dict_set(globals, Value::Text("target".into()), Value::Object(impure))
.unwrap();
assert_eq!(vm.call_effect(outer).unwrap(), None);
vm.dict_delete(globals, &Value::Text("target".into()))
.unwrap();
assert_eq!(vm.call_effect(outer).unwrap(), Some(CallEffect::ReadOnly));
let cell = vm.new_cell(Some(Value::Object(pure))).unwrap();
let code = EndorCode::from_instructions(
&[
Instruction::new(Opcode::LoadDeref, 0),
Instruction::simple(Opcode::PushNull),
Instruction::new(Opcode::Call, 0),
Instruction::simple(Opcode::ReturnValue),
],
vec![],
CodeLayout {
free_variables: vec!["target".into()],
..CodeLayout::default()
},
)
.unwrap();
let code = vm.new_code(code).unwrap();
let closure = vm
.new_function("closure", code, globals, vec![], vec![cell])
.unwrap();
assert_eq!(vm.call_effect(closure).unwrap(), Some(CallEffect::ReadOnly));
vm.cell_set(cell, Value::Object(impure)).unwrap();
assert_eq!(vm.call_effect(closure).unwrap(), None);
vm.cell_set(cell, Value::Object(pure)).unwrap();
assert_eq!(vm.call_effect(closure).unwrap(), Some(CallEffect::ReadOnly));
let recursive = global_caller(&mut vm, globals, "recursive");
vm.dict_set(
globals,
Value::Text("recursive".into()),
Value::Object(recursive),
)
.unwrap();
// No function body is executed, including this non-terminating call graph.
assert_eq!(
vm.call_effect(recursive).unwrap(),
Some(CallEffect::ReadOnly)
);
vm.dict_set(
globals,
Value::Text("recursive".into()),
Value::Object(impure),
)
.unwrap();
assert_eq!(vm.call_effect(recursive).unwrap(), None);
for object in [
recursive, closure, code, cell, outer, wrapper, pure, impure, builtins, globals,
] {
vm.release(object).unwrap();
}
vm.collect_cycles();
assert_eq!(vm.object_count(), 0);
}
#[test]
fn effect_control_flow_joins_do_not_keep_a_stale_known_call_target() {
let mut vm = Vm::new().unwrap();
let globals = vm.new_dict().unwrap();
let pure = vm
.allocate(ContextNativeFunction::new(
"pure",
Native(CallSignature::exact(
vec![],
T::Number,
CallEffect::ReadOnly,
)),
vec![],
))
.unwrap();
let impure = vm
.allocate(ContextNativeFunction::new(
"impure",
Native(CallSignature::exact(
vec![],
T::Number,
CallEffect::External,
)),
vec![],
))
.unwrap();
for name in ["left", "right"] {
vm.dict_set(globals, Value::Text(name.into()), Value::Object(pure))
.unwrap();
}
let code = EndorCode::from_instructions(
&[
Instruction::new(Opcode::LoadFast, 0),
Instruction::new(Opcode::PopJumpIfFalse, 2),
Instruction::new(Opcode::LoadGlobal, 0),
Instruction::new(Opcode::JumpForward, 1),
Instruction::new(Opcode::LoadGlobal, 1),
Instruction::simple(Opcode::PushNull),
Instruction::new(Opcode::Call, 0),
Instruction::simple(Opcode::ReturnValue),
],
vec![],
CodeLayout {
parameters: vec!["condition".into()],
locals: vec!["condition".into()],
names: vec!["left".into(), "right".into()],
..CodeLayout::default()
},
)
.unwrap();
let code = vm.new_code(code).unwrap();
let function = vm
.new_function("choose", code, globals, vec![], vec![])
.unwrap();
assert_eq!(
vm.call_effect(function).unwrap(),
Some(CallEffect::ReadOnly)
);
vm.dict_set(globals, Value::Text("right".into()), Value::Object(impure))
.unwrap();
assert_eq!(vm.call_effect(function).unwrap(), None);
vm.dict_set(globals, Value::Text("right".into()), Value::Object(pure))
.unwrap();
assert_eq!(
vm.call_effect(function).unwrap(),
Some(CallEffect::ReadOnly)
);
for object in [function, code, pure, impure, globals] {
vm.release(object).unwrap();
}
vm.collect_cycles();
assert_eq!(vm.object_count(), 0);
}
#[test]
fn bound_source_effects_follow_the_actual_receiver_method_and_instance_field() {
let mut vm = Vm::new().unwrap();
let roots = vm.bootstrap_types().unwrap();
let globals = vm.new_dict().unwrap();
let definition = vm
.new_type("Receiver", roots.object, TypeConstructor::Record)
.unwrap();
let pure = vm
.allocate(ContextNativeFunction::new(
"helper",
Native(CallSignature::exact(
vec![T::Any],
T::Number,
CallEffect::ReadOnly,
)),
vec![],
))
.unwrap();
let impure = vm
.allocate(ContextNativeFunction::new(
"helper",
Native(CallSignature::exact(
vec![T::Any],
T::Number,
CallEffect::Mutating,
)),
vec![],
))
.unwrap();
let code = EndorCode::from_instructions(
&[
Instruction::new(Opcode::LoadFast, 0),
Instruction::new(Opcode::LoadAttr, 0),
Instruction::simple(Opcode::PushNull),
Instruction::new(Opcode::Call, 0),
Instruction::simple(Opcode::ReturnValue),
],
vec![],
CodeLayout {
parameters: vec!["self".into()],
locals: vec!["self".into()],
names: vec!["helper".into()],
..CodeLayout::default()
},
)
.unwrap();
let code = vm.new_code(code).unwrap();
let function = vm
.new_function("check", code, globals, vec![], vec![])
.unwrap();
vm.define_method(definition, "helper", pure).unwrap();
vm.define_method(definition, "check", function).unwrap();
let receiver = vm.new_object().unwrap();
vm.attach_type(receiver, definition).unwrap();
let Value::Object(bound) = vm.bind_attr(receiver, "check").unwrap() else {
panic!("bound")
};
assert_eq!(vm.call_effect(function).unwrap(), None);
assert_eq!(vm.call_effect(bound).unwrap(), Some(CallEffect::ReadOnly));
vm.define_method(definition, "helper", impure).unwrap();
assert_eq!(vm.call_effect(bound).unwrap(), None);
vm.define_method(definition, "helper", pure).unwrap();
assert_eq!(vm.call_effect(bound).unwrap(), Some(CallEffect::ReadOnly));
vm.set_attr(receiver, "helper", Value::Object(impure))
.unwrap();
assert_eq!(vm.call_effect(bound).unwrap(), None);
vm.del_attr(receiver, "helper").unwrap();
assert_eq!(vm.call_effect(bound).unwrap(), Some(CallEffect::ReadOnly));
for object in [
bound,
receiver,
function,
code,
pure,
impure,
definition,
globals,
roots.object,
roots.type_type,
] {
vm.release(object).unwrap();
}
vm.collect_cycles();
assert_eq!(vm.object_count(), 0);
}