105 lines
4.2 KiB
Rust
105 lines
4.2 KiB
Rust
use oxide_compiler::compiler::Compiler;
|
|
use oxide_types::value::JsValue;
|
|
use oxide_vm::vm::Vm;
|
|
|
|
fn eval(vm: &mut Vm, source: &str) -> Result<JsValue, String> {
|
|
let allocator = oxide_parser::Allocator::default();
|
|
let program = oxide_parser::parse(&allocator, source).map_err(|e| format!("Parse error: {:?}", e))?;
|
|
let module = Compiler::new().compile(&program).map_err(|e| format!("Compile error: {}", e))?;
|
|
vm.run(&module)
|
|
}
|
|
|
|
fn assert_bool(value: JsValue, expected: bool) {
|
|
assert!(value.is_bool(), "expected boolean, got {value:?}");
|
|
assert_eq!(value.as_bool(), expected);
|
|
}
|
|
|
|
#[test]
|
|
fn function_call_new_target_is_undefined() {
|
|
// 普通调用不传构造目标：`new.target` 应为 undefined。
|
|
let mut vm = Vm::new();
|
|
let result = eval(&mut vm, "function f(){ return new.target === undefined; } f()").unwrap();
|
|
assert_bool(result, true);
|
|
}
|
|
|
|
#[test]
|
|
fn construct_new_target_is_constructor() {
|
|
// `new f()` 以 f 为构造目标：`new.target` 应为 f 本身。
|
|
let mut vm = Vm::new();
|
|
let result = eval(&mut vm, "function f(){ this.t = new.target === f; } new f().t").unwrap();
|
|
assert_bool(result, true);
|
|
}
|
|
|
|
#[test]
|
|
fn class_constructor_new_target_is_class() {
|
|
// 类构造器内 `new.target` 应为被 new 的类自身。
|
|
let mut vm = Vm::new();
|
|
let result = eval(&mut vm, "class A { constructor(){ this.t = new.target; } } new A().t === A").unwrap();
|
|
assert_bool(result, true);
|
|
}
|
|
|
|
#[test]
|
|
fn derived_class_new_target_is_derived_constructor() {
|
|
// 子类构造经 super() 链路：基类构造器内 `new.target` 仍是派生类（new 表达式目标）。
|
|
let mut vm = Vm::new();
|
|
let result = eval(
|
|
&mut vm,
|
|
"class A { constructor(){ this.t = new.target; } } class B extends A {} new B().t === B",
|
|
)
|
|
.unwrap();
|
|
assert_bool(result, true);
|
|
}
|
|
|
|
#[test]
|
|
fn nested_function_new_target_is_undefined() {
|
|
// 内层普通函数是独立调用帧，不继承外层构造目标的 `new.target`。
|
|
let mut vm = Vm::new();
|
|
let result = eval(
|
|
&mut vm,
|
|
"(function(){ var f = function(){ return new.target; }; return f() === undefined; })()",
|
|
)
|
|
.unwrap();
|
|
assert_bool(result, true);
|
|
}
|
|
|
|
#[test]
|
|
fn typeof_and_void_new_target() {
|
|
// unary 表达式组合：构造调用下 `typeof new.target` 为 "function"，普通调用下为 "undefined"。
|
|
let mut vm = Vm::new();
|
|
let result = eval(&mut vm, "function f(){ return typeof new.target; } f()").unwrap();
|
|
assert_eq!(vm.lookup_str(result).expect("typeof should be string"), "undefined");
|
|
|
|
let mut vm = Vm::new();
|
|
let result = eval(&mut vm, "function f(){ this.t = typeof new.target; } new f().t").unwrap();
|
|
assert_eq!(vm.lookup_str(result).expect("typeof should be string"), "function");
|
|
|
|
let mut vm = Vm::new();
|
|
let result = eval(&mut vm, "function f(){ this.u = void new.target; } new f().u").unwrap();
|
|
assert!(result.is_undefined());
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "已知规范缺口：箭头函数 new.target 词法继承未实现（VM 对 arrow 帧写 undefined），修复（闭包捕获）后移除"]
|
|
fn arrow_function_inherits_outer_new_target() {
|
|
// 规范要求箭头函数词法继承外层 `new.target`；当前 VM 对 arrow 帧直接写
|
|
// undefined（普通 CALL 路径传 undefined 为 new.target），无词法捕获——
|
|
// 已知规范缺口，登记不修；修复（闭包捕获）后移除 #[ignore]。
|
|
let mut vm = Vm::new();
|
|
let result = eval(&mut vm, "function f(){ return (() => new.target)(); } new f() === f").unwrap();
|
|
assert_bool(result, true);
|
|
}
|
|
|
|
#[test]
|
|
fn import_meta_is_explicit_error() {
|
|
// `import.meta` 需模块命名空间对象：显式编译报错（含 "not supported" 供
|
|
// test262 分类 Skip），不留静默错误结果。
|
|
let allocator = oxide_parser::Allocator::default();
|
|
let program = oxide_parser::parse_module(&allocator, "import.meta").map_err(|e| format!("Parse error: {:?}", e));
|
|
let program = program.expect("import.meta should parse in module context");
|
|
let err = match Compiler::new().compile(&program) {
|
|
Ok(_) => panic!("import.meta must not compile"),
|
|
Err(e) => e,
|
|
};
|
|
assert!(err.contains("import.meta not yet supported"), "unexpected compile error: {err}");
|
|
}
|