docs(compiler): explain class and source pipeline integration tests

This commit is contained in:
2026-11-15 18:33:08 +08:00
parent 6792ef9a99
commit 5c079c6c58
2 changed files with 264 additions and 1 deletions
+94 -1
View File
@@ -1,3 +1,5 @@
//! Rust 测试框架驱动的源码类集成测试:从前端/编译器到 VM 的宿主构造、绑定方法、字段检查及 GC。
//! execute/try_execute 按现有 globals 声明可用宿主名,加载临时代码,执行后统一归还代码根。
use compiler::{CompileOptions, compile_source};
use endor_core::{
ContextNativeFunction, EndorTypeObject, NativeCallable, NativeContext, NativeResult,
@@ -7,23 +9,30 @@ use endor_core::{ObjectRef, Value, Vm};
use frontend::{EndorReader, ParseMode};
#[derive(Debug)]
/// 原生实例载荷,WidgetFactory 分配;字符串是宿主标签,没有需要 trace 的托管对象边。
struct NativeWidget(String);
impl ObjectPayload for NativeWidget {
/// Store::payload 的类型检查通过 Any 下转,测试据此读取原生标签。
fn as_any(&self) -> &dyn std::any::Any {
self
}
/// 对象种类诊断入口使用稳定标签 widget,与测试载荷检查保持一致。
fn kind_name(&self) -> &'static str {
"widget"
}
/// Store 属性协议查询此开关;允许在原生实例上存放源码类声明的动态字段。
fn allows_attributes(&self) -> bool {
true
}
}
#[derive(Debug)]
/// NativeTyped 构造策略使用的宿主回调;源码子类沿继承链复用它,但实际实例附着请求的子类。
struct WidgetFactory;
impl NativeCallable for WidgetFactory {
/// VM 原生调用入口调用;参数依次为请求的 Type、宿主标签、声明字段值,结果由 NativeContext 返回协议接管。
fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result<NativeResult, VmError> {
// 解构 NativeTyped 调用布局;类型对象与标签必须存在,其余切片作为字段参数。
let [
Value::Object(requested),
Value::Text(native_label),
@@ -32,17 +41,23 @@ impl NativeCallable for WidgetFactory {
else {
return Err(VmError::InvalidArgument("widget constructor arguments"));
};
// 复制请求类型的完整字段元数据,以便稍后可变访问 Store 并分配实例。
let fields = cx
.store()
.payload::<EndorTypeObject>(*requested, "Type")?
.fields()
.to_vec();
// 字段数量必须匹配,错误时还没有分配新实例。
if values.len() != fields.len() {
return Err(VmError::InvalidArgument("widget field count"));
}
// 先校验字段注解,避免无效实参进入实例分配和字段写入阶段。
cx.store().check_class_field_arguments(*requested, values)?;
// 通过当前原生上下文分配载荷;发生后续错误时由上下文清理临时分配根。
let instance = cx.allocate(NativeWidget(native_label.clone()))?;
// 附着实际请求的 Type,而非固定 Widget,保持 Child/Grand 的名义身份。
cx.attach_type(instance, *requested)?;
// 按声明字段顺序写值,Value clone 仍由 Store 属性更新建立内部引用边。
for (field, value) in fields.iter().zip(values) {
cx.set_attr(instance, &field.name, value.clone())?;
}
@@ -51,14 +66,21 @@ impl NativeCallable for WidgetFactory {
}
#[test]
/// 由 Rust 测试框架调用:验证源码两级继承仍由原生工厂分配载荷,字段约束和名义父类型保留,结果根独立保活类型图。
fn source_subclasses_preserve_native_allocation_fields_and_nominal_identity() {
// 隔离本场景堆、类型配置与执行状态,最后检查没有遗留对象。
let mut vm = Vm::new().unwrap();
// 开启源码注解及字段检查,下面的类型错误才会按约束拒绝。
vm.set_source_type_checks(true).unwrap();
// 测试持环境初始根,源码函数和类型声明可在内部引用此环境。
let globals = vm.new_dict().unwrap();
// 引导得到 Object/Type 拥有根,注册环境后分别归还测试根。
let roots = vm.bootstrap_types().unwrap();
// 注册 NativeContext 回调,后续通过 NativeTyped 类型构造协议调用。
let factory = vm
.allocate(ContextNativeFunction::new("widget", WidgetFactory, vec![]))
.unwrap();
// 创建宿主 Widget 类型,以 Object 为父类并保存原生构造器引用。
let widget = vm
.new_type(
"Widget",
@@ -66,6 +88,7 @@ fn source_subclasses_preserve_native_allocation_fields_and_nominal_identity() {
TypeConstructor::NativeTyped(factory),
)
.unwrap();
// 把引导类型/宿主类型放入源码可访问的环境,再归还各自外部根。
for (name, object) in [
("Object", roots.object),
("Type", roots.type_type),
@@ -75,12 +98,15 @@ fn source_subclasses_preserve_native_allocation_fields_and_nominal_identity() {
.unwrap();
vm.release(object).unwrap();
}
// Widget 已持有工厂内部边,测试不再额外持工厂根。
vm.release(factory).unwrap();
// Child 增加数值字段,Grand 再增加文本字段,两层源码继承都沿用 Widget 原生分配策略。
let source = "class Child: Widget { value: Number }\nclass Grand: Child { label: String }";
assert_eq!(
execute(&mut vm, globals, source, ParseMode::Module),
Value::Nil
);
// 检查确实由运行时字段类型约束拒绝,而非返回一个看似成功的实例。
assert!(matches!(
try_execute(
&mut vm,
@@ -90,12 +116,14 @@ fn source_subclasses_preserve_native_allocation_fields_and_nominal_identity() {
),
Err(VmError::TypeMismatch { .. })
));
// 实际调用 Grand 得到拥有实例结果,随后独立于 globals 验证其原生载荷及继承字段。
let value = execute(
&mut vm,
globals,
"Grand(\"native\", 9, \"extra\")",
ParseMode::Expression,
);
// 成功结果必须是托管实例;此句柄持有 execute 返回的拥有根。
let Value::Object(instance) = value else {
panic!("native instance")
};
@@ -112,30 +140,41 @@ fn source_subclasses_preserve_native_allocation_fields_and_nominal_identity() {
vm.get_attr(instance, "label").unwrap(),
Value::Text("extra".into())
);
// 先清环境的全局拥有边,打断函数/类型与环境之间可能的引用环。
vm.dict_clear(globals).unwrap();
// 归还环境外部根,剩余图是否存活只由其他拥有根决定。
vm.release(globals).unwrap();
// 收集已无外部根的类型/函数/环境环;仍由实例或回调拥有的图必须保留。
vm.collect_cycles();
assert!(vm.is_instance(instance, widget).unwrap());
// 归还实例拥有结果根,之后其类型链及内部图也应可清理。
vm.release(instance).unwrap();
// 收集已无外部根的类型/函数/环境环;仍由实例或回调拥有的图必须保留。
vm.collect_cycles();
assert_eq!(vm.object_count(), 0);
}
/// 成功路径测试复用的包装,try_execute 的 VM 错误直接使该断言场景失败;返回 Value 归调用方释放。
fn execute(vm: &mut Vm, globals: ObjectRef, source: &str, mode: ParseMode) -> Value {
try_execute(vm, globals, source, mode).unwrap()
}
/// 类测试共用的编译/执行桥接,解析与加载失败直接使测试失败,VM 执行错误则原样返回给错误用例。
/// globals 是借用环境,返回对象值有独立拥有根;无论执行成功或失败,本辅助函数都归还加载的代码根。
fn try_execute(
vm: &mut Vm,
globals: ObjectRef,
source: &str,
mode: ParseMode,
) -> Result<Value, VmError> {
// 从当前环境条目提取文本键作为编译期已知名;这只声明名称,不复制运行时值。
let names = vm
.dict_items(globals)
.unwrap()
.iter()
// 非文本键不能作为源码标识符,忽略它们而不向编译器提供伪名称。
.filter_map(|(name, _)| {
// 只把文本键转成声明名,其余键留在环境但不参与源码解析。
if let Value::Text(name) = name {
Some(name.clone())
} else {
@@ -143,24 +182,35 @@ fn try_execute(
}
})
.collect();
// 为临时源码添加测试来源身份,错误诊断据此显示文件名与位置。
let source = EndorReader::from_text("<classes>", source);
// 根据当前名字列表编译,前端或语义失败属于测试设置错误而非期望的 VM 错误。
let template = compile_source(&source, mode, &CompileOptions { globals: names }).unwrap();
// 显式加载模板取得当前 VM 的拥有代码根,禁止跨堆复用对象句柄。
let code = template.load(vm).unwrap();
// 先保存 Result,随后即使执行失败也必须释放当前代码根。
let result = vm.execute(code, globals);
// 临时代码的拥有根归还,成功结果若含对象仍有自己的根。
vm.release(code).unwrap();
result
}
#[test]
/// 由 Rust 测试框架调用:验证继承方法绑定真实子类实例、绑定参数数目扣除 self,单独回调根在清空环境后仍能动态派发。
fn source_inheritance_binding_and_dynamic_dispatch_keep_the_real_receiver_alive() {
// 隔离本场景堆、类型配置与执行状态,最后检查没有遗留对象。
let mut vm = Vm::new().unwrap();
// 测试持环境初始根,源码函数和类型声明可在内部引用此环境。
let globals = vm.new_dict().unwrap();
// 引导得到 Object/Type 拥有根,注册环境后分别归还测试根。
let roots = vm.bootstrap_types().unwrap();
// 把引导类型/宿主类型放入源码可访问的环境,再归还各自外部根。
for (name, object) in [("Object", roots.object), ("Type", roots.type_type)] {
vm.dict_set(globals, Value::Text(name.into()), Value::Object(object))
.unwrap();
vm.release(object).unwrap();
}
// Base.via 通过 self.read 动态派发;Child 覆盖 read,withEvent 用于检查绑定后的参数数量。
let source = r#"
class Base {
value: Number
@@ -177,12 +227,14 @@ class Child: Base {
execute(&mut vm, globals, source, ParseMode::Module),
Value::Nil
);
// 读取临时 Child 实例的继承方法 via,返回绑定方法拥有根,方法必须保存实际接收者。
let callback = execute(
&mut vm,
globals,
"Child(9, \"ok\").via",
ParseMode::Expression,
);
// 回调必须是托管绑定方法,拥有根一直保留到环境清理与实际调用之后。
let Value::Object(callback) = callback else {
panic!("bound callback")
};
@@ -192,12 +244,14 @@ class Child: Base {
.unwrap(),
Some(0)
);
// 另取带 event 参数的绑定方法,检查 self 自动绑定后仍剩一个位置参数。
let with_event = execute(
&mut vm,
globals,
"Child(9, \"ok\").withEvent",
ParseMode::Expression,
);
// 将第二个回调结果解构为拥有句柄,稍后单独释放。
let Value::Object(with_event) = with_event else {
panic!("bound callback")
};
@@ -207,27 +261,37 @@ class Child: Base {
.unwrap(),
Some(1)
);
// 参数计数检查结束,归还第二个绑定方法,避免它掩盖主回调的保活责任。
vm.release(with_event).unwrap();
// 先清环境的全局拥有边,打断函数/类型与环境之间可能的引用环。
vm.dict_clear(globals).unwrap();
// 归还环境外部根,剩余图是否存活只由其他拥有根决定。
vm.release(globals).unwrap();
// 收集已无外部根的类型/函数/环境环;仍由实例或回调拥有的图必须保留。
vm.collect_cycles();
// 绑定回调是接收者最后的外部可达入口;Base.via 内的 self.read 应派发到 Child.read。
// No global name or external instance root remains. The bound callback
// alone retains its receiver and can still dispatch to Child.read.
assert_eq!(
vm.call(callback, &[]).unwrap(),
Value::Number(12_i64.into())
);
// 完成清空环境后的动态派发验证,归还最后回调根。
vm.release(callback).unwrap();
// 收集已无外部根的类型/函数/环境环;仍由实例或回调拥有的图必须保留。
vm.collect_cycles();
assert_eq!(vm.object_count(), 0);
}
#[test]
/// 由 Rust 测试框架调用:验证重复字段及缺显式 self 在语义分析阶段被拒绝,不需创建 VM 或执行源码。
fn duplicate_members_and_missing_receivers_fail_before_execution() {
// 两个独立语义错误案例:同类重复字段,以及方法没有显式 self 参数。
for text in [
"class Bad { value: Number value: String }",
"class Bad { function read(): Number { return 1 } }",
] {
// 为临时源码添加测试来源身份,错误诊断据此显示文件名与位置。
let source = EndorReader::from_text("<invalid-class>", text);
assert!(
compile_source(
@@ -243,10 +307,15 @@ fn duplicate_members_and_missing_receivers_fail_before_execution() {
}
#[test]
/// 由 Rust 测试框架调用:验证继承字段构造/赋值/删除检查、失败前后版本不变、动态名义注解重绑定与清理。
fn declared_field_checks_cover_construction_inheritance_writes_and_gc() {
// 隔离本场景堆、类型配置与执行状态,最后检查没有遗留对象。
let mut vm = Vm::new().unwrap();
// 开启源码注解及字段检查,下面的类型错误才会按约束拒绝。
vm.set_source_type_checks(true).unwrap();
// 测试持环境初始根,源码函数和类型声明可在内部引用此环境。
let globals = vm.new_dict().unwrap();
// 引导得到 Object/Type 拥有根,注册环境后分别归还测试根。
let roots = vm.bootstrap_types().unwrap();
vm.dict_set(
globals,
@@ -280,6 +349,7 @@ class Unknown { value: Missing }
"holder = Holder(value)",
ParseMode::Interactive,
);
// 从 globals 借用已登记实例;测试不额外持该句柄的拥有根。
let Value::Object(value) = vm
.dict_get(globals, &Value::Text("value".into()))
.unwrap()
@@ -287,7 +357,9 @@ class Unknown { value: Missing }
else {
panic!("instance")
};
// 记录合法实例当前版本,后续失败的字段写入不得改变它。
let version = vm.object_store().change_version(value).unwrap();
// 覆盖继承字段、子字段、名义对象字段、未知注解及错误赋值,错误必须在更新前返回。
for source in [
r#"Child("bad", "ok")"#,
"Child(9, 2)",
@@ -295,6 +367,7 @@ class Unknown { value: Missing }
"Unknown(1)",
r#"value.count = "bad""#,
] {
// 错误应是类型不匹配或未知注解,不接受其他无关失败掩盖约束问题。
assert!(matches!(
try_execute(&mut vm, globals, source, ParseMode::Interactive),
Err(VmError::TypeMismatch { .. } | VmError::UnknownAnnotation(_))
@@ -309,25 +382,35 @@ class Unknown { value: Missing }
vm.set_attr(value, "count", Value::Number(10.into()))
.unwrap();
execute(&mut vm, globals, "class Base {}", ParseMode::Interactive);
// 其他名义类型名称在声明环境中动态解析;Base 重定义后 Holder 的字段约束应按新身份检查。
// Other nominal names resolve dynamically in the declaring environment.
assert!(matches!(
try_execute(&mut vm, globals, "Holder(value)", ParseMode::Expression),
Err(VmError::TypeMismatch { .. })
));
// 继承来的 count 保留其原声明字段元数据,环境同名类重定义不抹掉旧实例的数值约束。
// An inherited scalar field still belongs to its original declaration.
vm.set_attr(value, "count", Value::Number(11.into()))
.unwrap();
// 先清环境的全局拥有边,打断函数/类型与环境之间可能的引用环。
vm.dict_clear(globals).unwrap();
// 归还环境外部根,剩余图是否存活只由其他拥有根决定。
vm.release(globals).unwrap();
// 收集已无外部根的类型/函数/环境环;仍由实例或回调拥有的图必须保留。
vm.collect_cycles();
assert_eq!(vm.object_count(), 0);
}
#[test]
/// 由 Rust 测试框架调用:验证声明类自身的递归类型按原身份检查,即使全局同名类重定义;关闭检查允许临时写入 Nil。
fn checked_fields_keep_declaring_self_type_and_can_be_opted_out() {
// 隔离本场景堆、类型配置与执行状态,最后检查没有遗留对象。
let mut vm = Vm::new().unwrap();
// 开启源码注解及字段检查,下面的类型错误才会按约束拒绝。
vm.set_source_type_checks(true).unwrap();
// 测试持环境初始根,源码函数和类型声明可在内部引用此环境。
let globals = vm.new_dict().unwrap();
// 引导得到 Object/Type 拥有根,注册环境后分别归还测试根。
let roots = vm.bootstrap_types().unwrap();
vm.dict_set(
globals,
@@ -337,7 +420,7 @@ fn checked_fields_keep_declaring_self_type_and_can_be_opted_out() {
.unwrap();
vm.release(roots.object).unwrap();
vm.release(roots.type_type).unwrap();
// Object permits nil, so a separate numeric field provides an initial instance.
// Link.next 是递归且不可空的字段;Seed 声明展示继承,后续由可信宿主直接构造旧 Link 实例。
execute(
&mut vm,
globals,
@@ -348,6 +431,7 @@ class Seed: Link {}
ParseMode::Module,
);
// A recursive nonnullable field can be initialized by the trusted host in two steps.
// 从 globals 借用最初 Link 类型,后面同名重定义不应改变此类型的自引用身份。
let Value::Object(link) = vm
.dict_get(globals, &Value::Text("Link".into()))
.unwrap()
@@ -355,7 +439,9 @@ class Seed: Link {}
else {
panic!("class")
};
// 宿主先分配空对象再附类型,用两步构造填入不可空的递归 next 字段。
let seed = vm.new_object().unwrap();
// 附上旧 Link 名义类型,此时先由可信宿主完成递归对象初始化。
vm.attach_type(seed, link).unwrap();
vm.set_attr(seed, "next", Value::Object(seed)).unwrap();
vm.dict_set(globals, Value::Text("old".into()), Value::Object(seed))
@@ -367,17 +453,24 @@ class Seed: Link {}
ParseMode::Interactive,
);
vm.set_attr(seed, "next", Value::Object(seed)).unwrap();
// 旧 Link 的自引用字段不可空,即使当前全局 Link 已换成另一个类。
assert!(matches!(
vm.set_attr(seed, "next", Value::Nil),
Err(VmError::TypeMismatch { .. })
));
// 显式关闭检查,允许下一步向不可空字段写 Nil;这不会改变声明本身。
vm.set_source_type_checks(false).unwrap();
vm.set_attr(seed, "next", Value::Nil).unwrap();
// 恢复检查配置后写回旧 Link 自身实例,验证声明身份和约束没有被关闭操作修改。
vm.set_source_type_checks(true).unwrap();
vm.set_attr(seed, "next", Value::Object(seed)).unwrap();
// 归还种子外部根;环境清理后,自引用环仍需循环收集器处理。
vm.release(seed).unwrap();
// 先清环境的全局拥有边,打断函数/类型与环境之间可能的引用环。
vm.dict_clear(globals).unwrap();
// 归还环境外部根,剩余图是否存活只由其他拥有根决定。
vm.release(globals).unwrap();
// 收集已无外部根的类型/函数/环境环;仍由实例或回调拥有的图必须保留。
vm.collect_cycles();
assert_eq!(vm.object_count(), 0);
}
+170
View File
@@ -1,3 +1,5 @@
//! Rust 测试框架驱动的源码→模板→代码对象→VM 集成验证;成功和错误路径都检查拥有根清理。
//! compile/module/function/cleanup 为本文件测试复用,编译器本身不执行源码,只有测试显式 load/execute/call。
use compiler::{CompileOptions, CompiledCode, NameBinding, analyze, compile_ast, compile_source};
use endor_core::{
EndorCodeObject, EndorFunctionObject, EndorNumber, ExecutionLimits, NativeFunction, ObjectRef,
@@ -5,6 +7,7 @@ use endor_core::{
};
use frontend::{DiagnosticKind, EndorReader, ParseMode, SourceUnit, parse_ast};
/// 测试共用的源码入口,按 mode 编译,不声明额外宿主名;返回未加载、独立于 VM 堆的模板。
fn compile(text: &str, mode: ParseMode) -> CompiledCode {
compile_source(
&EndorReader::from_text("<test>", text),
@@ -14,16 +17,23 @@ fn compile(text: &str, mode: ParseMode) -> CompiledCode {
.unwrap()
}
/// 测试共用的模块加载入口:取得代码根、创建环境并执行声明,模块结果应为 Nil;返回两个拥有根供 cleanup。
fn module(vm: &mut Vm, compiled: &CompiledCode) -> (ObjectRef, ObjectRef) {
// 把模板显式装入当前 VM,取得需要归还的代码拥有根。
let code = compiled.load(vm).unwrap();
// 新建环境拥有根;函数声明和宿主值通过内部边持有,测试结束需清理环境。
let globals = vm.new_dict().unwrap();
// 执行加载的代码取得拥有返回值;模块为 Nil,表达式则为其实际结果。
let value = vm.execute(code, globals).unwrap();
assert_eq!(value, Value::Nil);
// 归还 execute/call 返回值拥有根;立即值也可以统一通过此入口处理。
vm.release_value(value).unwrap();
(code, globals)
}
/// 测试按名称从环境借用函数句柄;不 retain,调用者须保持 globals 或其他拥有图存活。
fn function(vm: &Vm, globals: ObjectRef, name: &str) -> ObjectRef {
// 环境键命中必须是函数对象;这里只借用,不新取得外部根。
let Some(Value::Object(function)) = vm.dict_get(globals, &Value::Text(name.into())).unwrap()
else {
panic!("missing function {name}")
@@ -31,16 +41,23 @@ fn function(vm: &Vm, globals: ObjectRef, name: &str) -> ObjectRef {
function
}
/// 测试结束时归还代码根、清环境并归还环境根,再收集引用环;预期结果根已由调用者释放。
fn cleanup(vm: &mut Vm, code: ObjectRef, globals: ObjectRef) {
// 归还本轮代码外部根,函数或返回结果需要的内部图仍由各自引用持有。
vm.release(code).unwrap();
// 清除环境拥有边,打断声明函数/类型到环境的可能引用环。
vm.dict_clear(globals).unwrap();
// 归还环境初始根;之后只应留下测试明确保存的结果或回调根。
vm.release(globals).unwrap();
// 清理零外根的引用环,随后对象数应回到零。
vm.collect_cycles();
assert_eq!(vm.object_count(), 0);
}
#[test]
/// 由 Rust 测试框架调用:逐个加载示例模块并调用 main,验证前向调用、函数值遮蔽、Unicode 返回及精确十进制,并检查代码名和清理。
fn source_files_execute_through_module_and_function_code_objects() {
// 逐项使用独立代码路径核对指定源码与预期值,任一不符都使本测试失败。
for (text, expected) in [
(
include_str!("../examples/hello.endor"),
@@ -59,10 +76,15 @@ fn source_files_execute_through_module_and_function_code_objects() {
Value::Number(EndorNumber::decimal("-123456789012345678901234567890.00100").unwrap()),
),
] {
// 编译得到模板,尚未分配 VM 代码对象;具体模式及宿主名称由当前用例提供。
let compiled = compile(text, ParseMode::Module);
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 加载并执行模块声明,保存两个拥有根,之后统一交 cleanup。
let (code, globals) = module(&mut vm, &compiled);
// 从环境借用 main,环境在调用完成前保持存活。
let main = function(&vm, globals, "main");
// 检查源码函数的代码元数据,证明 main 不是宿主替代回调。
let data = vm.payload::<EndorFunctionObject>(main, "function").unwrap();
assert_eq!(
vm.payload::<EndorCodeObject>(data.code(), "code")
@@ -71,15 +93,19 @@ fn source_files_execute_through_module_and_function_code_objects() {
.name(),
"main"
);
// 取得 VM 调用返回的拥有值,后续比较结果并归还它持有的对象根。
let result = vm.call(main, &[]).unwrap();
assert_eq!(result, expected);
// 归还独立结果根,不让返回对象掩盖环境/代码清理后的保活检查。
vm.release_value(result).unwrap();
cleanup(&mut vm, code, globals);
}
}
#[test]
/// 由 Rust 测试框架调用:表达式模式直接返回结果,验证文本、大整数、连续负号、前导零和负零均保持精确数值语义。
fn expression_mode_preserves_exact_literals_and_signs() {
// 逐项使用独立代码路径核对指定源码与预期值,任一不符都使本测试失败。
for (text, expected) in [
(
include_str!("../examples/literal.endor"),
@@ -95,20 +121,29 @@ fn expression_mode_preserves_exact_literals_and_signs() {
Value::Number(EndorNumber::decimal("-0.000").unwrap()),
),
] {
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 表达式模板在当前 VM 单独装载,加载代码拥有根由本轮测试负责归还。
let code = compile(text, ParseMode::Expression).load(&mut vm).unwrap();
// 新建环境拥有根;函数声明和宿主值通过内部边持有,测试结束需清理环境。
let globals = vm.new_dict().unwrap();
// 执行加载的代码取得拥有返回值;模块为 Nil,表达式则为其实际结果。
let value = vm.execute(code, globals).unwrap();
assert_eq!(value, expected);
// 归还 execute/call 返回值拥有根;立即值也可以统一通过此入口处理。
vm.release_value(value).unwrap();
cleanup(&mut vm, code, globals);
}
}
#[test]
/// 由 Rust 测试框架调用:直接检查符号表的参数/局部槽、前向全局名绑定与空自由变量表,不加载 VM。
fn scope_analysis_resolves_local_shadowing_and_forward_globals() {
// 当前用例的源码或带来源快照,下面按指定模式解析/编译。
let source = "function main(target: Callable): String { let copy = target return later(copy) } function later(value: String): String { return value }";
// 先解析 AST,再单独调用名称分析,隔离解析与分析阶段的结果。
let root = parse_ast(source, ParseMode::Module).unwrap();
// 不创建 VM,直接检查 analyze 输出的稳定参数/局部与全局索引。
let symbols = analyze(&root, &CompileOptions::default()).unwrap();
assert_eq!(symbols.functions[0].layout.parameters, ["target"]);
assert_eq!(symbols.functions[0].layout.locals, ["target", "copy"]);
@@ -124,6 +159,7 @@ fn scope_analysis_resolves_local_shadowing_and_forward_globals() {
NameBinding::Local(1)
]
);
// 当前源码函数不捕获外层局部,所有代码布局的自由变量表都应为空。
assert!(
symbols
.functions
@@ -133,7 +169,9 @@ fn scope_analysis_resolves_local_shadowing_and_forward_globals() {
}
#[test]
/// 由 Rust 测试框架调用:参数/局部/顶层重复、未声明及未初始化读取都在编译时拒绝,并检查 Unicode 与 CRLF 的诊断行列。
fn semantic_errors_prevent_loading_and_keep_unicode_locations() {
// 每例给出非法源码及应包含的诊断片段,确保失败原因与目标规则对应。
for (text, fragment) in [
(
"function f(): String { return missing }",
@@ -165,19 +203,25 @@ fn semantic_errors_prevent_loading_and_keep_unicode_locations() {
"before initialization: later",
),
] {
// 保留来源名和原始源码,编译诊断应带有正确位置及错误说明。
let unit = EndorReader::from_text("<invalid>", text);
// 预期编译失败,之后检查诊断阶段或位置,不能走加载执行路径。
let error =
compile_source(&unit, ParseMode::Module, &CompileOptions::default()).unwrap_err();
assert_eq!(error.diagnostic.kind, DiagnosticKind::Semantic);
assert!(error.to_string().contains(fragment), "{error}");
}
// 保留来源名和原始源码,编译诊断应带有正确位置及错误说明。
let unit = EndorReader::from_text("<日本語>", "function 表示(): T {\r\n return 未定義\r\n}");
// 预期编译失败,之后检查诊断阶段或位置,不能走加载执行路径。
let error = compile_source(&unit, ParseMode::Module, &CompileOptions::default()).unwrap_err();
assert_eq!((error.location.line, error.location.column), (2, 10));
assert!(error.to_string().starts_with("<日本語>:2:10:"));
}
/// 宿主 NativeFunction 调用的恒等回调;参数为借用值,clone 不增对象根,VM 返回协议负责保留结果。
fn identity(arguments: &[Value]) -> Result<Value, VmError> {
// 恒等回调只接受一个实参,多参/缺参明确报错而非越界取参数。
if arguments.len() != 1 {
return Err(VmError::InvalidArgument("identity needs one argument"));
}
@@ -185,18 +229,28 @@ fn identity(arguments: &[Value]) -> Result<Value, VmError> {
}
#[test]
/// 由 Rust 测试框架调用:验证宿主声明、属性原生调用和拥有对象返回;清空环境后仅结果根保活对象,释放结果后句柄失效。
fn host_globals_member_calls_and_object_results_keep_owned_roots() {
// 编译期仅声明可用宿主名;真正的绑定值仍由 globals 提供。
let options = CompileOptions {
globals: vec!["service".into(), "value".into()],
};
// 保留来源名和原始源码,编译诊断应带有正确位置及错误说明。
let unit = EndorReader::from_text("<host>", "service.echo(value)");
// 编译得到模板,尚未分配 VM 代码对象;具体模式及宿主名称由当前用例提供。
let compiled = compile_source(&unit, ParseMode::Expression, &options).unwrap();
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 分配恒等原生回调作为 service.echo,属性内部边随后保留它。
let native = vm.allocate(NativeFunction::new("echo", identity)).unwrap();
// 普通宿主对象承载 echo 属性,用于验证成员查找与原生调用链。
let service = vm.new_object().unwrap();
vm.set_attr(service, "echo", Value::Object(native)).unwrap();
// service.echo 已取得内部边,测试不再额外持原生函数根。
vm.release(native).unwrap();
// 作为实参及最终返回的托管对象,后续归还原根以检查 VM 返回协议。
let object = vm.new_object().unwrap();
// 新建环境拥有根;函数声明和宿主值通过内部边持有,测试结束需清理环境。
let globals = vm.new_dict().unwrap();
vm.dict_set(
globals,
@@ -206,29 +260,45 @@ fn host_globals_member_calls_and_object_results_keep_owned_roots() {
.unwrap();
vm.dict_set(globals, Value::Text("value".into()), Value::Object(object))
.unwrap();
// 环境已持 service,归还宿主初始根。
vm.release(service).unwrap();
// 环境已持实参对象,归还初始根,之后返回结果必须获得自己的根。
vm.release(object).unwrap();
// 把模板显式装入当前 VM,取得需要归还的代码拥有根。
let code = compiled.load(&mut vm).unwrap();
// 取得 VM 调用返回的拥有值,后续比较结果并归还它持有的对象根。
let result = vm.execute(code, globals).unwrap();
assert_eq!(result, Value::Object(object));
// 清除环境拥有边,打断声明函数/类型到环境的可能引用环。
vm.dict_clear(globals).unwrap();
assert!(vm.object(object).is_ok());
// 归还独立结果根,不让返回对象掩盖环境/代码清理后的保活检查。
vm.release_value(result).unwrap();
assert_eq!(vm.object(object).unwrap_err(), VmError::InvalidHandle);
cleanup(&mut vm, code, globals);
}
#[test]
/// 由 Rust 测试框架调用:同一模板装入两个独立 VM,跨堆句柄被拒绝;重复调用复用已加载代码,不增加堆对象。
fn code_templates_load_independently_and_functions_share_loaded_code() {
// 编译得到模板,尚未分配 VM 代码对象;具体模式及宿主名称由当前用例提供。
let compiled = compile(include_str!("../examples/calls.endor"), ParseMode::Module);
// 第一个 VM 单独加载模板,句柄不能被另一个堆接受。
let mut left = Vm::new().unwrap();
// 第二个 VM 加载同一模板,但得到自身堆专属代码及环境。
let mut right = Vm::new().unwrap();
// 左堆建立独立模块图,后续重复调用仅访问这份代码。
let (left_code, left_globals) = module(&mut left, &compiled);
// 右堆建立另一份图,用来检查 ForeignHandle 拒绝跨 VM 引用。
let (right_code, right_globals) = module(&mut right, &compiled);
assert_eq!(left.object(right_code).unwrap_err(), VmError::ForeignHandle);
// 记录多次调用前堆大小,调用结束不应重建源码函数代码或残留临时图。
let before = left.object_count();
// 从环境借用 main,环境在调用完成前保持存活。
let main = function(&left, left_globals, "main");
// 重复运行同一函数三次,每次归还结果,以对象数验证代码复用。
for _ in 0..3 {
// 取得 VM 调用返回的拥有值,后续比较结果并归还它持有的对象根。
let result = left.call(main, &[]).unwrap();
left.release_value(result).unwrap();
}
@@ -238,14 +308,22 @@ fn code_templates_load_independently_and_functions_share_loaded_code() {
}
#[test]
/// 由 Rust 测试框架调用:缺参和递归帧上限错误释放执行临时图,同时保留源码位置或限制深度对应的回溯。
fn argument_and_recursion_failures_unwind_vm_frames_and_keep_traceback() {
// 当前用例的源码或带来源快照,下面按指定模式解析/编译。
let source =
"\nfunction main(): T { return echo() }\nfunction echo(value: T): T { return value }";
// 编译得到模板,尚未分配 VM 代码对象;具体模式及宿主名称由当前用例提供。
let compiled = compile(source, ParseMode::Module);
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 加载并执行模块声明,保存两个拥有根,之后统一交 cleanup。
let (code, globals) = module(&mut vm, &compiled);
// 记录错误调用前对象数,参数/返回检查或帧清理后不能增加存活对象。
let baseline = vm.object_count();
// 从环境借用 main,环境在调用完成前保持存活。
let main = function(&vm, globals, "main");
// main 调用 echo 时漏传 value,错误出在被调函数预检,不能残留执行帧或临时根。
assert!(matches!(
vm.call(main, &[]),
Err(VmError::ArgumentCount { provided: 0, .. })
@@ -254,11 +332,14 @@ fn argument_and_recursion_failures_unwind_vm_frames_and_keep_traceback() {
assert_eq!(vm.last_traceback().last().unwrap().first_line, 2);
cleanup(&mut vm, code, globals);
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 加载并执行模块声明,保存两个拥有根,之后统一交 cleanup。
let (code, globals) = module(
&mut vm,
&compile("function main(): T { return main() }", ParseMode::Module),
);
// 从环境借用 main,环境在调用完成前保持存活。
let main = function(&vm, globals, "main");
assert_eq!(
vm.call_with_limits(
@@ -276,8 +357,11 @@ fn argument_and_recursion_failures_unwind_vm_frames_and_keep_traceback() {
}
#[test]
/// 由 Rust 测试框架调用:编译选项只声明合法名字,不注入 VM 值;空环境执行仍报告 NameNotFound。
fn declared_host_names_are_checked_again_at_runtime() {
// 当前用例的源码或带来源快照,下面按指定模式解析/编译。
let source = EndorReader::from_text("<host>", "missing");
// 编译得到模板,尚未分配 VM 代码对象;具体模式及宿主名称由当前用例提供。
let compiled = compile_source(
&source,
ParseMode::Expression,
@@ -286,8 +370,11 @@ fn declared_host_names_are_checked_again_at_runtime() {
},
)
.unwrap();
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 把模板显式装入当前 VM,取得需要归还的代码拥有根。
let code = compiled.load(&mut vm).unwrap();
// 新建环境拥有根;函数声明和宿主值通过内部边持有,测试结束需清理环境。
let globals = vm.new_dict().unwrap();
assert_eq!(
vm.execute(code, globals),
@@ -297,9 +384,13 @@ fn declared_host_names_are_checked_again_at_runtime() {
}
#[test]
/// 由 Rust 测试框架调用:两次单语句交互共享宿主环境,首次绑定返回 Nil,后续读取返回此前保存值。
fn interactive_submissions_can_share_a_host_owned_namespace() {
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 新建环境拥有根;函数声明和宿主值通过内部边持有,测试结束需清理环境。
let globals = vm.new_dict().unwrap();
// 两次独立交互提交共享同一个宿主环境;名字声明随提交需求分别提供。
for (text, options, expected) in [
(
"let value = \"保留\"",
@@ -314,47 +405,70 @@ fn interactive_submissions_can_share_a_host_owned_namespace() {
Value::Text("保留".into()),
),
] {
// 当前用例的源码或带来源快照,下面按指定模式解析/编译。
let source = EndorReader::from_text("<submission>", text);
// 编译得到模板,尚未分配 VM 代码对象;具体模式及宿主名称由当前用例提供。
let compiled = compile_source(&source, ParseMode::Interactive, &options).unwrap();
// 把模板显式装入当前 VM,取得需要归还的代码拥有根。
let code = compiled.load(&mut vm).unwrap();
// 取得 VM 调用返回的拥有值,后续比较结果并归还它持有的对象根。
let result = vm.execute(code, globals).unwrap();
assert_eq!(result, expected);
// 归还独立结果根,不让返回对象掩盖环境/代码清理后的保活检查。
vm.release_value(result).unwrap();
// 归还本轮代码外部根,函数或返回结果需要的内部图仍由各自引用持有。
vm.release(code).unwrap();
}
// 清除环境拥有边,打断声明函数/类型到环境的可能引用环。
vm.dict_clear(globals).unwrap();
// 归还环境初始根;之后只应留下测试明确保存的结果或回调根。
vm.release(globals).unwrap();
assert_eq!(vm.object_count(), 0);
}
#[test]
/// 由 Rust 测试框架调用:构造 270 个局部与常量,迫使索引使用扩展操作数,执行返回最后一个值验证编码解码贯通。
fn extended_operands_work_for_large_local_and_constant_tables() {
// 动态拼接大量独立局部声明,测试超过单字节的索引编码。
let mut source = String::from("function main(): Number { ");
// 超过 255 的局部/常量索引需要 EXTENDED_ARG,返回值来自最后一个槽。
for index in 0..270 {
source.push_str(&format!("let value{index} = {index} "));
}
source.push_str("return value269 }");
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 加载并执行模块声明,保存两个拥有根,之后统一交 cleanup。
let (code, globals) = module(&mut vm, &compile(&source, ParseMode::Module));
// 从环境借用 main,环境在调用完成前保持存活。
let main = function(&vm, globals, "main");
// 取得 VM 调用返回的拥有值,后续比较结果并归还它持有的对象根。
let result = vm.call(main, &[]).unwrap();
assert_eq!(result, Value::Number(269_i64.into()));
// 归还独立结果根,不让返回对象掩盖环境/代码清理后的保活检查。
vm.release_value(result).unwrap();
cleanup(&mut vm, code, globals);
}
#[test]
/// 由 Rust 测试框架调用:前端可解析的 Symbol 暂无 VM 值,在编译生成阶段明确失败。
fn unsupported_execution_features_are_compile_errors_instead_of_fake_results() {
// 当前用例的源码或带来源快照,下面按指定模式解析/编译。
let source = EndorReader::from_text("<unsupported>", ".title");
// 预期编译失败,之后检查诊断阶段或位置,不能走加载执行路径。
let error =
compile_source(&source, ParseMode::Expression, &CompileOptions::default()).unwrap_err();
assert_eq!(error.diagnostic.kind, DiagnosticKind::Compilation);
}
#[test]
/// 由 Rust 测试框架调用:破坏手工 AST 的 UTF-8 边界,验证直接 AST 编译入口先拒绝无效源跨度。
fn compiling_ast_rejects_invalid_source_ranges() {
// 保留含三字节字符的原始快照,用于故意制造 UTF-8 非边界跨度。
let source: SourceUnit = EndorReader::from_text("<source>", "\"日\"");
// 解析合法表达式 AST,再手工修改跨度,仅测试 AST 入口验证。
let mut root = parse_ast(source.text(), ParseMode::Expression).unwrap();
// 将 end 改到日字的多字节编码内部,语法树内容不变但位置应非法。
if let frontend::ast::AstRoot::Expression(expression) = &mut root {
expression.span.end = 2; // Splits the three-byte character.
}
@@ -362,53 +476,73 @@ fn compiling_ast_rejects_invalid_source_ranges() {
}
#[test]
/// 由 Rust 测试框架调用:交互裸赋值创建再替换全局,下一次编译从现有环境取得宿主名字,最终读取最新值。
fn bare_assignments_create_and_replace_real_interactive_globals() {
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 新建环境拥有根;函数声明和宿主值通过内部边持有,测试结束需清理环境。
let globals = vm.new_dict().unwrap();
// 同一环境连续执行创建、替换和读取,后面的编译应看到前面登记的名字。
for text in ["value = \"first\"", "value = \"second\"", "value"] {
// 编译期仅声明可用宿主名;真正的绑定值仍由 globals 提供。
let options = CompileOptions {
globals: vm
.dict_items(globals)
.unwrap()
.iter()
// 只允许文本环境键成为源码可用名称,不把非文本键当标识符。
.filter_map(|(key, _)| match key {
Value::Text(name) => Some(name.clone()),
_ => None,
})
.collect(),
};
// 编译得到模板,尚未分配 VM 代码对象;具体模式及宿主名称由当前用例提供。
let compiled = compile_source(
&EndorReader::from_text("<session>", text),
ParseMode::Interactive,
&options,
)
.unwrap();
// 把模板显式装入当前 VM,取得需要归还的代码拥有根。
let code = compiled.load(&mut vm).unwrap();
// 取得 VM 调用返回的拥有值,后续比较结果并归还它持有的对象根。
let result = vm.execute(code, globals).unwrap();
// 只有最后的表达式提交返回文本;赋值提交只产生 Nil。
if text == "value" {
assert_eq!(result, Value::Text("second".into()));
}
// 归还独立结果根,不让返回对象掩盖环境/代码清理后的保活检查。
vm.release_value(result).unwrap();
// 归还本轮代码外部根,函数或返回结果需要的内部图仍由各自引用持有。
vm.release(code).unwrap();
}
assert_eq!(
vm.dict_get(globals, &Value::Text("value".into())).unwrap(),
Some(Value::Text("second".into()))
);
// 清除环境拥有边,打断声明函数/类型到环境的可能引用环。
vm.dict_clear(globals).unwrap();
// 归还环境初始根;之后只应留下测试明确保存的结果或回调根。
vm.release(globals).unwrap();
// 清理零外根的引用环,随后对象数应回到零。
vm.collect_cycles();
assert_eq!(vm.object_count(), 0);
}
#[test]
/// 由 Rust 测试框架调用:赋值复用参数及同名局部槽,执行验证更新结果;自读未初始化与重复 let 仍编译失败。
fn assignments_update_parameters_and_allocate_one_local_slot_per_target() {
// 编译得到模板,尚未分配 VM 代码对象;具体模式及宿主名称由当前用例提供。
let compiled = compile(
"function main(value: String): String { copy = value copy = \"updated\" value = copy return value }",
ParseMode::Module,
);
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 加载并执行模块声明,保存两个拥有根,之后统一交 cleanup。
let (code, globals) = module(&mut vm, &compiled);
// 取得 VM 调用返回的拥有值,后续比较结果并归还它持有的对象根。
let result = vm
.call(
function(&vm, globals, "main"),
@@ -416,6 +550,7 @@ fn assignments_update_parameters_and_allocate_one_local_slot_per_target() {
)
.unwrap();
assert_eq!(result, Value::Text("updated".into()));
// 归还独立结果根,不让返回对象掩盖环境/代码清理后的保活检查。
vm.release_value(result).unwrap();
cleanup(&mut vm, code, globals);
assert!(
@@ -440,11 +575,14 @@ fn assignments_update_parameters_and_allocate_one_local_slot_per_target() {
}
#[test]
/// 由 Rust 测试框架调用:检查模板保存类型签名,加载后开启运行时检查分别拒绝错误参数与错误返回,错误不泄漏对象。
fn source_signatures_survive_template_load_and_enable_runtime_checks() {
// 编译得到模板,尚未分配 VM 代码对象;具体模式及宿主名称由当前用例提供。
let compiled = compile(
"function identity(value: Number): Number { return value }\nfunction bad(): Number { return \"wrong\" }",
ParseMode::Module,
);
// 检查首个子函数模板的源码签名,尚未加载时也必须保留注解。
let signature = compiled
.children()
.next()
@@ -453,20 +591,28 @@ fn source_signatures_survive_template_load_and_enable_runtime_checks() {
.unwrap();
assert_eq!(signature.parameters, ["Number"]);
assert_eq!(signature.return_type, "Number");
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 启用运行时源码签名检查,错误参数在函数体前拒绝,错误返回在出口拒绝。
vm.set_source_type_checks(true).unwrap();
// 加载并执行模块声明,保存两个拥有根,之后统一交 cleanup。
let (code, globals) = module(&mut vm, &compiled);
// 借用已加载的 Number 恒等函数,分别尝试合法数值和非法文本。
let identity = function(&vm, globals, "identity");
assert_eq!(
vm.call(identity, &[Value::Number(7.into())]).unwrap(),
Value::Number(7.into())
);
// 开启检查后,String 实参不能通过 Number 参数约束。
assert!(matches!(
vm.call(identity, &[Value::Text("wrong".into())]),
Err(VmError::TypeMismatch { .. })
));
// 借用声明返回 Number 但实际返回文本的函数,专门验证返回类型约束。
let bad = function(&vm, globals, "bad");
// 记录错误调用前对象数,参数/返回检查或帧清理后不能增加存活对象。
let baseline = vm.object_count();
// bad 的函数体能执行,但出口文本不符合声明的 Number 返回类型。
assert!(matches!(
vm.call(bad, &[]),
Err(VmError::TypeMismatch { .. })
@@ -476,15 +622,23 @@ fn source_signatures_survive_template_load_and_enable_runtime_checks() {
}
#[test]
/// 由 Rust 测试框架调用:运行 while/if 与加减得到 -100,再检查精确小数、大整数、有理数和非字面量取负。
fn source_control_flow_and_exact_arithmetic_execute_real_bytecode() {
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 先累加 0..9 再减去 10..19,循环与分支结果应是精确整数 -100。
let text = "function main(): Number { i=0 total=0 while i<20 { if i<10 {total=total+i} else {total=total-i} i=i+1 } return total }";
// 加载并执行模块声明,保存两个拥有根,之后统一交 cleanup。
let (code, globals) = module(&mut vm, &compile(text, ParseMode::Module));
// 从环境借用 main,环境在调用完成前保持存活。
let main = function(&vm, globals, "main");
// 取得 VM 调用返回的拥有值,后续比较结果并归还它持有的对象根。
let result = vm.call(main, &[]).unwrap();
assert_eq!(result, Value::Number((-100_i64).into()));
// 归还独立结果根,不让返回对象掩盖环境/代码清理后的保活检查。
vm.release_value(result).unwrap();
cleanup(&mut vm, code, globals);
// 逐项使用独立代码路径核对指定源码与预期值,任一不符都使本测试失败。
for (text, expected) in [
("0.1 + 0.2 == 0.3", Value::Bool(true)),
(
@@ -494,29 +648,43 @@ fn source_control_flow_and_exact_arithmetic_execute_real_bytecode() {
("1 / 3 + 1 / 3 + 1 / 3", Value::Number(1_i64.into())),
("-(2 + 3)", Value::Number((-5_i64).into())),
] {
// 表达式模板在当前 VM 单独装载,加载代码拥有根由本轮测试负责归还。
let code = compile(text, ParseMode::Expression).load(&mut vm).unwrap();
// 新建环境拥有根;函数声明和宿主值通过内部边持有,测试结束需清理环境。
let globals = vm.new_dict().unwrap();
// 取得 VM 调用返回的拥有值,后续比较结果并归还它持有的对象根。
let result = vm.execute(code, globals).unwrap();
assert_eq!(result, expected);
// 归还独立结果根,不让返回对象掩盖环境/代码清理后的保活检查。
vm.release_value(result).unwrap();
// 归还本轮代码外部根,函数或返回结果需要的内部图仍由各自引用持有。
vm.release(code).unwrap();
// 归还环境初始根;之后只应留下测试明确保存的结果或回调根。
vm.release(globals).unwrap();
}
}
#[test]
/// 由 Rust 测试框架调用:长循环体迫使相对跳转扩展,单侧初始化和零次循环后的读取编译失败,合法无限循环受指令总预算限制。
fn control_flow_definite_initialization_large_jumps_and_loop_budgets() {
// 拼接较长 if/while 体,迫使条件出口和回边跨越扩展编码距离。
let mut body = String::from("function main(): Number { i=0 while i<2 { if i==0 {");
// 重复运行同一函数三次,每次归还结果,以对象数验证代码复用。
for _ in 0..300 {
body.push_str("i=i+0 ");
}
body.push_str("} i=i+1 } return i }");
// 为当前场景或案例新建独立堆,避免其他执行状态掩盖错误与清理问题。
let mut vm = Vm::new().unwrap();
// 加载并执行模块声明,保存两个拥有根,之后统一交 cleanup。
let (code, globals) = module(&mut vm, &compile(&body, ParseMode::Module));
// 取得 VM 调用返回的拥有值,后续比较结果并归还它持有的对象根。
let result = vm.call(function(&vm, globals, "main"), &[]).unwrap();
assert_eq!(result, Value::Number(2_i64.into()));
// 归还独立结果根,不让返回对象掩盖环境/代码清理后的保活检查。
vm.release_value(result).unwrap();
cleanup(&mut vm, code, globals);
// 两种未确定初始化用例:if 只有一侧赋值,以及 while 可能零次执行。
for text in [
"function f(): Number { if 1 {x=2} return x }",
"function f(): Number {while 0 {x=2} return x}",
@@ -530,6 +698,7 @@ fn control_flow_definite_initialization_large_jumps_and_loop_budgets() {
.is_err()
);
}
// 加载并执行模块声明,保存两个拥有根,之后统一交 cleanup。
let (code, globals) = module(
&mut vm,
&compile(
@@ -537,6 +706,7 @@ fn control_flow_definite_initialization_large_jumps_and_loop_budgets() {
ParseMode::Module,
),
);
// 无限循环没有返回出口,必须由累计指令预算终止,之后 cleanup 验证错误清理。
assert!(matches!(
vm.call_with_limits(
function(&vm, globals, "main"),