From 5c079c6c583ce23500a7f2411e34e7a1979470c0 Mon Sep 17 00:00:00 2001 From: Codex Bot Date: Sun, 15 Nov 2026 18:33:08 +0800 Subject: [PATCH] docs(compiler): explain class and source pipeline integration tests --- crates/compiler/tests/classes.rs | 95 ++++++++++++++++- crates/compiler/tests/pipeline.rs | 170 ++++++++++++++++++++++++++++++ 2 files changed, 264 insertions(+), 1 deletion(-) diff --git a/crates/compiler/tests/classes.rs b/crates/compiler/tests/classes.rs index 71e12e4..3a74e99 100644 --- a/crates/compiler/tests/classes.rs +++ b/crates/compiler/tests/classes.rs @@ -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 { + // 解构 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::(*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 { + // 从当前环境条目提取文本键作为编译期已知名;这只声明名称,不复制运行时值。 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("", 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("", 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); } diff --git a/crates/compiler/tests/pipeline.rs b/crates/compiler/tests/pipeline.rs index ab644a2..e46c151 100644 --- a/crates/compiler/tests/pipeline.rs +++ b/crates/compiler/tests/pipeline.rs @@ -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("", 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::(main, "function").unwrap(); assert_eq!( vm.payload::(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("", 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 { + // 恒等回调只接受一个实参,多参/缺参明确报错而非越界取参数。 if arguments.len() != 1 { return Err(VmError::InvalidArgument("identity needs one argument")); } @@ -185,18 +229,28 @@ fn identity(arguments: &[Value]) -> Result { } #[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("", "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("", "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("", 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("", ".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("", "\"日\""); + // 解析合法表达式 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("", 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"),