docs(compiler): explain class and source pipeline integration tests
This commit is contained in:
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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"),
|
||||
|
||||
Reference in New Issue
Block a user