mirror of
https://github.com/pjh456/OxideJS.git
synced 2026-10-24 02:31:13 +08:00
test: 新增 emit 顶层与模块链接 IR 集成测试网
This commit is contained in:
@@ -0,0 +1,258 @@
|
||||
//! 脚本顶层形态的 IR 级结构断言：parse → `emit_program` 为止，钉死现状 emit 行为。
|
||||
//!
|
||||
//! 断言顺序无关：只表达 存在 / 计数 / 名字集 / 键名集。GDI 序言对组与 var 入口
|
||||
//! MAKE_CELL 组的指令序逐进程轮换，这两组只断言键名集；断言不依赖寄存器号
|
||||
//! 与 `n_registers` 绝对值。
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::collections::HashSet;
|
||||
|
||||
use oxide_bytecode::opcode::OpCode;
|
||||
use oxide_emit::{Constant, Emitter};
|
||||
use oxide_ir::inst::Inst;
|
||||
use oxide_ir::operand::Operand;
|
||||
use oxide_ir::IRFunction;
|
||||
|
||||
/// 夹具：parse + 脚本口径 emit，失败 panic 带源串。
|
||||
fn emit_ir(src: &str) -> IRFunction {
|
||||
let alloc = oxide_parser::Allocator::default();
|
||||
let program = oxide_parser::parse(&alloc, src).unwrap_or_else(|errs| panic!("parse 失败 {src:?}: {errs:?}"));
|
||||
Emitter::new()
|
||||
.emit_program(&program, false, false)
|
||||
.unwrap_or_else(|e| panic!("emit 失败 {src:?}: {e}"))
|
||||
}
|
||||
|
||||
fn count_op(insts: &[Inst], op: OpCode) -> usize {
|
||||
insts.iter().filter(|i| i.op == op).count()
|
||||
}
|
||||
|
||||
fn tree_count(ir: &IRFunction, op: OpCode) -> usize {
|
||||
let mut n = count_op(&ir.insts, op);
|
||||
for sub in &ir.nested {
|
||||
n += tree_count(sub, op);
|
||||
}
|
||||
n
|
||||
}
|
||||
|
||||
fn pool_strings(ir: &IRFunction) -> HashSet<String> {
|
||||
ir.constants
|
||||
.iter()
|
||||
.filter_map(|c| if let Constant::String(s) = c { Some(s.clone()) } else { None })
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 寄存器 → 其被 LOAD_CONST 装入的常量（vreg 号单调不复用，映射唯一）。
|
||||
fn loaded_consts(ir: &IRFunction) -> HashMap<u32, &Constant> {
|
||||
let mut m: HashMap<u32, &Constant> = HashMap::new();
|
||||
for i in &ir.insts {
|
||||
if i.op == OpCode::LOAD_CONST {
|
||||
if let (Operand::Reg(r), Operand::Const(c)) = (&i.rd, &i.a) {
|
||||
m.insert(*r, &ir.constants[*c as usize]);
|
||||
}
|
||||
}
|
||||
}
|
||||
m
|
||||
}
|
||||
|
||||
/// 指定 opcode 的 b 槽键寄存器回溯其 LOAD_CONST 装入的池字符串名集。
|
||||
/// 用于 GDI 序言对组（`DEFINE_GLOBAL_PROP_IF_ABSENT`）与顶层 A 侧全局写
|
||||
/// （`DEFINE_GLOBAL_PROP`）的键名集断言（对序逐进程轮换，只按名集断言）。
|
||||
fn key_names_of(ir: &IRFunction, op: OpCode) -> HashSet<String> {
|
||||
let loads = loaded_consts(ir);
|
||||
let mut keys = HashSet::new();
|
||||
for i in &ir.insts {
|
||||
if i.op == op {
|
||||
if let Operand::Reg(r) = &i.b {
|
||||
if let Some(Constant::String(s)) = loads.get(r) {
|
||||
keys.insert(s.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
keys
|
||||
}
|
||||
|
||||
fn gdi_key_names(ir: &IRFunction) -> HashSet<String> {
|
||||
key_names_of(ir, OpCode::DEFINE_GLOBAL_PROP_IF_ABSENT)
|
||||
}
|
||||
|
||||
fn define_global_prop_keys(ir: &IRFunction) -> HashSet<String> {
|
||||
key_names_of(ir, OpCode::DEFINE_GLOBAL_PROP)
|
||||
}
|
||||
|
||||
fn class_flags_scan(f: &IRFunction, base: &mut bool, derived: &mut bool, home: &mut bool) {
|
||||
if f.is_class_constructor && !f.is_derived_constructor {
|
||||
*base = true;
|
||||
}
|
||||
if f.is_class_constructor && f.is_derived_constructor {
|
||||
*derived = true;
|
||||
}
|
||||
if f.needs_home_object {
|
||||
*home = true;
|
||||
}
|
||||
for n in &f.nested {
|
||||
class_flags_scan(n, base, derived, home);
|
||||
}
|
||||
}
|
||||
|
||||
/// 面 1：GDI 序言只覆盖顶层 var 名，lexical（let/const）不进序言。
|
||||
#[test]
|
||||
fn gdi_prologue_covers_var_not_lexical() {
|
||||
let ir = emit_ir("var a = 1; var b = 2; let c = 3;");
|
||||
assert_eq!(
|
||||
gdi_key_names(&ir),
|
||||
["a", "b"].map(String::from).into_iter().collect(),
|
||||
"GDI 序言键名集应恰为顶层 var 名"
|
||||
);
|
||||
}
|
||||
|
||||
/// 面 2：顶层函数声明的 GDI 检查、全局绑定与闭包物化形态。
|
||||
#[test]
|
||||
fn top_level_function_declaration() {
|
||||
let ir = emit_ir("function f(n) { return n + 1; }");
|
||||
assert_eq!(count_op(&ir.insts, OpCode::CAN_DECLARE_GLOBAL_FUNC), 1);
|
||||
assert_eq!(count_op(&ir.insts, OpCode::DEFINE_GLOBAL_FUNC_BIND), 1);
|
||||
assert_eq!(count_op(&ir.insts, OpCode::CREATE_CLOSURE), 1);
|
||||
assert_eq!(ir.nested.len(), 1);
|
||||
assert!(ir.is_top_level);
|
||||
let f = &ir.nested[0];
|
||||
assert_eq!(f.function_name.as_deref(), Some("f"));
|
||||
assert_eq!(f.function_length, 1);
|
||||
assert!(!f.is_top_level);
|
||||
}
|
||||
|
||||
/// 面 3：块级函数入口物化——每块函数全流恰 1 个 CREATE_CLOSURE（声明点不重编），
|
||||
/// 外层 var 写回存在；三常量名（NaN）被守卫：无 GDI 对、无 A 侧全局写。
|
||||
#[test]
|
||||
fn block_fn_entry_materialized_once() {
|
||||
let src = "{ function g() { return 2; } var y = g(); }\n\
|
||||
label: { function h() { return 3; } }\n\
|
||||
for (var i = 0; i < 1; i++) { function f() { return i; } }\n\
|
||||
label3: { function NaN() { return 0; } }";
|
||||
let ir = emit_ir(src);
|
||||
assert_eq!(tree_count(&ir, OpCode::CREATE_CLOSURE), 4, "块函数数 = 闭包物化数");
|
||||
assert_eq!(
|
||||
gdi_key_names(&ir),
|
||||
["f", "g", "h", "i", "y"].map(String::from).into_iter().collect(),
|
||||
"GDI 键名集应含外层 var 与块函数泄漏名，不含三常量名 NaN"
|
||||
);
|
||||
assert_eq!(
|
||||
define_global_prop_keys(&ir),
|
||||
["f", "g", "h", "i"].map(String::from).into_iter().collect(),
|
||||
"A 侧全局写键名集不含 NaN（不可写内置守卫）"
|
||||
);
|
||||
assert!(count_op(&ir.insts, OpCode::STORE_VAR) >= 1, "外层 var 写回 STORE_VAR 应存在");
|
||||
}
|
||||
|
||||
/// 面 4：三级闭包链的 cell 分配与 upvalue 捕获（cell 下标按名排序分配）。
|
||||
#[test]
|
||||
fn closure_captures_cell_and_upvalue() {
|
||||
let src = "function f() { var x = 1; var s = 0; return function g() { x = x + 1; \
|
||||
return function h() { s = s + x; return x; }; }; }";
|
||||
let ir = emit_ir(src);
|
||||
let f = &ir.nested[0];
|
||||
assert!(f.cells_needed >= 1);
|
||||
assert!(count_op(&f.insts, OpCode::MAKE_CELL) >= 1);
|
||||
let g = &f.nested[0];
|
||||
let g_cells: HashMap<&str, u8> = g.upvalue_captures.iter().map(|c| (c.name.as_str(), c.cell_idx)).collect();
|
||||
let mut expected: HashMap<&str, u8> = HashMap::new();
|
||||
expected.insert("s", 0);
|
||||
expected.insert("x", 1);
|
||||
assert_eq!(g_cells, expected, "g 的捕获应按名排序分配 cell 下标");
|
||||
assert!(count_op(&g.insts, OpCode::LOAD_UPVALUE) >= 1);
|
||||
assert!(count_op(&g.insts, OpCode::STORE_UPVALUE) >= 1);
|
||||
let h = &g.nested[0];
|
||||
let h_names: HashSet<&str> = h.upvalue_captures.iter().map(|c| c.name.as_str()).collect();
|
||||
let mut expected_names: HashSet<&str> = HashSet::new();
|
||||
expected_names.insert("s");
|
||||
expected_names.insert("x");
|
||||
assert_eq!(h_names, expected_names);
|
||||
assert!(
|
||||
h.upvalue_captures.iter().all(|c| c.parent_uv_idx.is_some()),
|
||||
"链式捕获应经父闭包 upvalue 数组取 cell"
|
||||
);
|
||||
}
|
||||
|
||||
/// 面 5：对象 rest 展开与数组 holes 的现状形态：REST_OBJECT 的 ext 键是排除键
|
||||
/// （显式绑定的键名）；解构赋值经 for-of 迭代面（FOR_OF_INIT）逐元素绑定，
|
||||
/// 空洞元素被消费但不绑定；常量池含 Undefined。
|
||||
#[test]
|
||||
fn destructured_rest_and_holes() {
|
||||
let src = "var {a, ...r} = {a: 1, b: 2}; var [x, , z] = [1, 2, 3]; \
|
||||
var p = [[\"k\", 1]]; for (var [k, v] of p) {}";
|
||||
let ir = emit_ir(src);
|
||||
let rest = ir
|
||||
.insts
|
||||
.iter()
|
||||
.find(|i| i.op == OpCode::REST_OBJECT)
|
||||
.expect("REST_OBJECT 应存在");
|
||||
assert_eq!(rest.ext.len(), 1);
|
||||
assert_eq!(
|
||||
ir.constants[rest.ext[0] as usize],
|
||||
Constant::String("a".to_string()),
|
||||
"REST_OBJECT 排除键应为显式绑定的键名"
|
||||
);
|
||||
assert!(count_op(&ir.insts, OpCode::FOR_OF_INIT) >= 1);
|
||||
assert!(ir.constants.iter().any(|c| matches!(c, Constant::Undefined)), "常量池应含 Undefined");
|
||||
}
|
||||
|
||||
/// 面 6：模板字面量的 TEMPLATE_STR 面与 quasis 池键（键经 string_forge 编码，
|
||||
/// 纯 ASCII 键按值还原即原形态）。
|
||||
#[test]
|
||||
fn template_literal_pool_keys() {
|
||||
let src = "\"use strict\";\nconst t = `a${1}b`;\nconst tag = (s) => s[0];\ntag`x${2}y`";
|
||||
let ir = emit_ir(src);
|
||||
assert!(count_op(&ir.insts, OpCode::TEMPLATE_STR) >= 1);
|
||||
let pool = pool_strings(&ir);
|
||||
assert!(pool.contains("a") && pool.contains("b"), "quasis 池键按值应含 a/b: {pool:?}");
|
||||
}
|
||||
|
||||
/// 面 7：类构造器/派生标志、home object 与私有名指令面。
|
||||
#[test]
|
||||
fn class_nested_flags() {
|
||||
let src = "class B { m() { return 1; } } class A extends B { #p = 2; static s = 3; \
|
||||
m() { return this.#p; } }";
|
||||
let ir = emit_ir(src);
|
||||
let (mut base, mut derived, mut home) = (false, false, false);
|
||||
class_flags_scan(&ir, &mut base, &mut derived, &mut home);
|
||||
assert!(base, "基类构造器应标 is_class_constructor");
|
||||
assert!(derived, "extends 构造器应标 is_derived_constructor");
|
||||
assert!(home, "原型方法应标 needs_home_object");
|
||||
assert!(tree_count(&ir, OpCode::INIT_PRIVATE) >= 1, "私有字段初始化面应存在");
|
||||
assert!(tree_count(&ir, OpCode::GET_PRIVATE) >= 1, "私有成员读面应存在");
|
||||
}
|
||||
|
||||
/// 面 8：严格模式标志在函数体内与脚本顶层的继承口径。
|
||||
#[test]
|
||||
fn strict_flag_inherited() {
|
||||
let ir = emit_ir("function f() { \"use strict\"; } function g() { return 1; }");
|
||||
let by_name = |n: &str| -> &IRFunction {
|
||||
ir.nested
|
||||
.iter()
|
||||
.find(|f| f.function_name.as_deref() == Some(n))
|
||||
.unwrap_or_else(|| panic!("nested 缺 {n}"))
|
||||
};
|
||||
assert!(by_name("f").is_strict, "函数体内 use strict 应置位");
|
||||
assert!(!by_name("g").is_strict, "无 directive 函数不应继承严格");
|
||||
let top = emit_ir("\"use strict\"; var x = 1;");
|
||||
assert!(top.is_strict, "脚本顶层 use strict 应置位");
|
||||
}
|
||||
|
||||
/// 面 9：source_encoded 口径下正则源池键为 marker 形态（与静态口径的明文键不同形）。
|
||||
#[test]
|
||||
fn source_encoded_regex_pool_key() {
|
||||
let src = "var r = /\\ud800/g;";
|
||||
let encode_ir = {
|
||||
let alloc = oxide_parser::Allocator::default();
|
||||
let program = oxide_parser::parse(&alloc, src).unwrap();
|
||||
Emitter::new()
|
||||
.with_source_encoded(true)
|
||||
.emit_program(&program, false, false)
|
||||
.unwrap()
|
||||
};
|
||||
let static_ir = emit_ir(src);
|
||||
let enc = pool_strings(&encode_ir);
|
||||
assert!(enc.contains("\u{FFFD}d800"), "编码源池键应为 FFFD+hex marker 形态: {enc:?}");
|
||||
assert!(!enc.contains("\\ud800"));
|
||||
assert!(pool_strings(&static_ir).contains("\\ud800"), "静态源池键为明文转义文本");
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
//! 模块链接面的 IR 级断言：内存版 `ModuleSourceLoader` +
|
||||
//! `emit_program_module`，钉死 import prelude / export 就地注册 / star 再导出 /
|
||||
//! 循环导入编译期报错 / 数据模块的现状行为。
|
||||
//!
|
||||
//! 路径口径：加载器 `path` 回填表键原样字符串，与入口 `module_path` 入参逐字符
|
||||
//! 一致（虚拟路径 canonicalize 失败保留原路径），自导入身份比较与循环检测依赖
|
||||
//! 此口径。断言不依赖寄存器号与指令序。
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::collections::HashSet;
|
||||
|
||||
use oxide_bytecode::opcode::OpCode;
|
||||
use oxide_emit::module::{ModuleKind, ModuleSourceLoader, ResolvedModule};
|
||||
use oxide_emit::{Constant, Emitter};
|
||||
use oxide_ir::IRFunction;
|
||||
|
||||
/// 内存版加载器：specifier 精确查表；`path` 原样回填表键。
|
||||
/// `resolved` 记录每次 resolve 的 (specifier, 属性对)，供链接期观察。
|
||||
struct MemLoader {
|
||||
table: HashMap<String, (ModuleKind, String)>,
|
||||
resolved: Vec<(String, Vec<(String, String)>)>,
|
||||
}
|
||||
|
||||
impl ModuleSourceLoader for MemLoader {
|
||||
fn resolve(
|
||||
&mut self, _base_dir: &str, specifier: &str, attributes: &[(&str, &str)],
|
||||
) -> Result<ResolvedModule, String> {
|
||||
self.resolved.push((
|
||||
specifier.to_string(),
|
||||
attributes.iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),
|
||||
));
|
||||
self.table
|
||||
.get(specifier)
|
||||
.cloned()
|
||||
.map(|(kind, source)| ResolvedModule {
|
||||
source,
|
||||
path: specifier.to_string(),
|
||||
kind,
|
||||
})
|
||||
.ok_or_else(|| format!("MemLoader 无 {specifier}"))
|
||||
}
|
||||
}
|
||||
|
||||
/// 夹具：parse_module + emit_program_module，返回 IR 与加载器。
|
||||
fn emit_module(src: &str, path: &str, deps: &[(&str, ModuleKind, &str)]) -> Result<(IRFunction, MemLoader), String> {
|
||||
let alloc = oxide_parser::Allocator::default();
|
||||
let program =
|
||||
oxide_parser::parse_module(&alloc, src).map_err(|errs| format!("parse_module 失败 {src:?}: {errs:?}"))?;
|
||||
let mut loader = MemLoader {
|
||||
table: deps.iter().map(|(s, k, t)| (s.to_string(), (*k, t.to_string()))).collect(),
|
||||
resolved: Vec::new(),
|
||||
};
|
||||
let ir = Emitter::new().emit_program_module(&program, path, &mut loader)?;
|
||||
Ok((ir, loader))
|
||||
}
|
||||
|
||||
fn builtin_names(ir: &IRFunction) -> HashSet<String> {
|
||||
ir.builtin_reg_map.iter().map(|(n, _)| n.clone()).collect()
|
||||
}
|
||||
|
||||
fn builtin_reg(ir: &IRFunction, name: &str) -> Option<u32> {
|
||||
ir.builtin_reg_map.iter().find(|(n, _)| n == name).map(|(_, r)| *r)
|
||||
}
|
||||
|
||||
/// 以某 built-in 为 callee（rd 槽）的 CALL_NATIVE 计数。
|
||||
fn native_calls_to(ir: &IRFunction, name: &str) -> usize {
|
||||
let Some(reg) = builtin_reg(ir, name) else {
|
||||
return 0;
|
||||
};
|
||||
ir.insts
|
||||
.iter()
|
||||
.filter(|i| i.op == OpCode::CALL_NATIVE && matches!(i.rd, oxide_ir::operand::Operand::Reg(r) if r == reg))
|
||||
.count()
|
||||
}
|
||||
|
||||
fn pool_strings(ir: &IRFunction) -> HashSet<String> {
|
||||
ir.constants
|
||||
.iter()
|
||||
.filter_map(|c| if let Constant::String(s) = c { Some(s.clone()) } else { None })
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 面 1：import 绑定 prelude 经 `__moduleLinkGet` 链接，依赖模块编入子模块树。
|
||||
#[test]
|
||||
fn import_binding_prelude() {
|
||||
let (ir, _) = emit_module(
|
||||
"import { x } from \"./dep.js\"; var y = x;",
|
||||
"./entry.js",
|
||||
&[("./dep.js", ModuleKind::Js, "export var x = 42;")],
|
||||
)
|
||||
.expect("模块编译应成功");
|
||||
assert!(builtin_names(&ir).contains("__moduleLinkGet"), "prelude 应链接 __moduleLinkGet");
|
||||
assert!(native_calls_to(&ir, "__moduleLinkGet") >= 1, "命名导入应发 __moduleLinkGet 调用");
|
||||
assert_eq!(ir.nested.len(), 1, "依赖模块应编入子模块树");
|
||||
let dep = &ir.nested[0];
|
||||
assert!(!dep.insts.is_empty());
|
||||
assert!(builtin_names(dep).contains("__moduleSet"), "依赖的 export 应就地注册");
|
||||
}
|
||||
|
||||
/// 面 2：export 声明就地注册导出值到命名空间（`__moduleSet` 逐名成对）。
|
||||
#[test]
|
||||
fn export_in_place_register() {
|
||||
let (ir, _) = emit_module("export function f() {} export const c = 2;", "./entry.js", &[]).expect("模块编译应成功");
|
||||
assert!(builtin_names(&ir).contains("__moduleSet"));
|
||||
assert_eq!(native_calls_to(&ir, "__moduleSet"), 2, "f 与 c 各注册一次");
|
||||
let pool = pool_strings(&ir);
|
||||
assert!(pool.contains("f") && pool.contains("c"), "导出名应成对入池: {pool:?}");
|
||||
}
|
||||
|
||||
/// 面 3：`export * from` 匿名 star 再导出经 `__moduleStar` 整体转发（现状口径）。
|
||||
#[test]
|
||||
fn export_all_from() {
|
||||
let (ir, _) = emit_module(
|
||||
"export * from \"./dep.js\";",
|
||||
"./entry.js",
|
||||
&[("./dep.js", ModuleKind::Js, "export var z = 1;")],
|
||||
)
|
||||
.expect("star 再导出应编译通过");
|
||||
assert!(builtin_names(&ir).contains("__moduleStar"), "匿名 star 应走 __moduleStar");
|
||||
assert_eq!(ir.nested.len(), 1);
|
||||
}
|
||||
|
||||
/// 面 4：循环导入在编译期报错，错误文本即循环检测点产物。
|
||||
#[test]
|
||||
fn circular_import_compile_error() {
|
||||
let src_a = "import { y } from \"./b.js\"; export var x = 1;";
|
||||
let result = emit_module(
|
||||
src_a,
|
||||
"./a.js",
|
||||
&[
|
||||
("./a.js", ModuleKind::Js, src_a),
|
||||
("./b.js", ModuleKind::Js, "import { x } from \"./a.js\"; export var y = 2;"),
|
||||
],
|
||||
);
|
||||
assert_eq!(
|
||||
result.err().as_deref(),
|
||||
Some("circular module import not supported: ./a.js"),
|
||||
"Err 应来自循环检测点（自导入身份比较命中）"
|
||||
);
|
||||
}
|
||||
|
||||
/// 面 5：json 数据模块经 `__moduleData` 物化，数据源文本入子模块常量池。
|
||||
#[test]
|
||||
fn json_data_module() {
|
||||
let json = r#"{"k":1}"#;
|
||||
let (ir, loader) = emit_module(
|
||||
"import data from \"./d.json\" assert { type: \"json\" }; data;",
|
||||
"./entry.js",
|
||||
&[("./d.json", ModuleKind::Json, json)],
|
||||
)
|
||||
.expect("数据模块编译应成功");
|
||||
// import 属性应原样传给加载器。
|
||||
let attrs = loader
|
||||
.resolved
|
||||
.iter()
|
||||
.find(|(s, _)| s == "./d.json")
|
||||
.map(|(_, a)| a.clone())
|
||||
.expect("d.json 应被 resolve");
|
||||
assert_eq!(attrs, vec![("type".to_string(), "json".to_string())]);
|
||||
assert_eq!(ir.nested.len(), 1);
|
||||
let data = &ir.nested[0];
|
||||
assert!(builtin_names(data).contains("__moduleData"), "数据模块应链接 __moduleData");
|
||||
let pool = pool_strings(data);
|
||||
assert!(pool.contains("json") && pool.contains(json), "json 源文本应入池: {pool:?}");
|
||||
}
|
||||
Reference in New Issue
Block a user