mirror of
https://github.com/pjh456/OxideJS.git
synced 2026-10-23 18:21:13 +08:00
800 lines
31 KiB
Rust
800 lines
31 KiB
Rust
//! splice/reverse/copyWithin/at 四方法洞语义与原型链读语义引擎钉：
|
||
//! 源洞保洞/换洞/删洞、重叠反向复制、元素读走 Get。
|
||
|
||
use std::sync::Arc;
|
||
|
||
use oxide_compiler::compiler::Compiler;
|
||
use oxide_types::value::JsValue;
|
||
use oxide_vm::vm::Vm;
|
||
|
||
fn eval_value(source: &str) -> Result<(Vm, 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))?;
|
||
let mut vm = Vm::new();
|
||
let result = vm.run(&Arc::new(module))?;
|
||
Ok((vm, result))
|
||
}
|
||
|
||
fn eval_str(source: &str) -> Result<String, String> {
|
||
let (vm, result) = eval_value(source)?;
|
||
vm.lookup_str(result)
|
||
.ok_or_else(|| "completion value is not a string".to_string())
|
||
}
|
||
|
||
// splice 被删收集：源洞位在 removed 保洞，present 值原样落入。
|
||
#[test]
|
||
fn test_splice_removed_keeps_holes() {
|
||
let out = eval_str(
|
||
"(() => { const a = new Array(3); a[1] = 1; a[2] = 3; \
|
||
const r = a.splice(0, 3); \
|
||
return r.length + '|' + (0 in r) + '|' + r[1]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "3|false|1");
|
||
}
|
||
|
||
// splice 被删收集走 Get：洞位落原型链，访问器值落入 removed 且该位为 present。
|
||
#[test]
|
||
fn test_splice_removed_get_through_proto() {
|
||
let out = eval_str(
|
||
"(() => { Object.defineProperty(Array.prototype, 0, { get: () => 'G0' }); \
|
||
try { const a = new Array(2); a[1] = 1; const r = a.splice(0, 2); \
|
||
return r[0] + '|' + (0 in r) + '|' + r.length; } \
|
||
finally { delete Array.prototype[0]; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "G0|true|2");
|
||
}
|
||
|
||
// splice 扩容：洞洞源 removed 全洞；数组体洞位随搬移保留、插入位 present。
|
||
#[test]
|
||
fn test_splice_grow_keeps_array_holes() {
|
||
let out = eval_str(
|
||
"(() => { const a = new Array(3); const r = a.splice(0, 2, 'a'); \
|
||
return (0 in r) + '|' + (1 in r) + '|' + r.length + '|' + \
|
||
(0 in a) + '|' + (1 in a) + '|' + a.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "false|false|2|true|false|2");
|
||
}
|
||
|
||
// splice 中插：插入点之后的既有洞位随搬移落位，`3 in` 为 false。
|
||
#[test]
|
||
fn test_splice_insert_mid_hole_moves() {
|
||
let out = eval_str(
|
||
"(() => { const a = new Array(4); a[0] = 1; a[1] = 2; a[3] = 4; \
|
||
a.splice(2, 0, 'x'); \
|
||
return (3 in a) + '|' + (2 in a) + '|' + a[2] + '|' + a.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "false|true|x|5");
|
||
}
|
||
|
||
// reverse 洞对 present：值位互换、洞位互换，洞不物化。
|
||
#[test]
|
||
fn test_reverse_hole_and_value_swap() {
|
||
let out = eval_str(
|
||
"(() => { const a = new Array(3); a[0] = 1; a[2] = 3; a.reverse(); \
|
||
return (1 in a) + '|' + a[0] + '|' + a[2]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "false|3|1");
|
||
}
|
||
|
||
// reverse 洞对洞：双缺失端不动，洞位互换后各归其位。
|
||
#[test]
|
||
fn test_reverse_hole_to_hole() {
|
||
let out = eval_str(
|
||
"(() => { const a = new Array(3); a[1] = 2; a[2] = 3; a.reverse(); \
|
||
return (2 in a) + '|' + a[0] + '|' + a[1]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "false|3|2");
|
||
}
|
||
|
||
// reverse 原型链存在性：自身洞 + 原型 present 视同双存在，两端互写为 present。
|
||
#[test]
|
||
fn test_reverse_proto_present_both_sides() {
|
||
let out = eval_str(
|
||
"(() => { Array.prototype[1] = 1; \
|
||
try { const x = [0]; x.length = 2; x.reverse(); \
|
||
return (0 in x) + '|' + (1 in x) + '|' + x[0] + '|' + x[1]; } \
|
||
finally { delete Array.prototype[1]; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true|true|1|0");
|
||
}
|
||
|
||
// copyWithin 自拷贝：源洞位 DeleteProperty 自身，洞保洞。
|
||
#[test]
|
||
fn test_copy_within_self_copy_hole_stays_hole() {
|
||
let out = eval_str(
|
||
"(() => { const a = new Array(3); a[0] = 1; a[2] = 3; a.copyWithin(0); \
|
||
return (1 in a) + '|' + a[0] + '|' + a[2]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "false|1|3");
|
||
}
|
||
|
||
// copyWithin 重叠正向陷阱：目标领先且重叠须反向迭代，源洞目标位删洞。
|
||
#[test]
|
||
fn test_copy_within_overlap_reverse_direction() {
|
||
let out = eval_str(
|
||
"(() => { const a = new Array(4); a[1] = 1; a[2] = 3; a[3] = 4; \
|
||
a.copyWithin(1, 0, 2); \
|
||
return (0 in a) + '|' + (1 in a) + '|' + (2 in a) + '|' + a[2]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "false|false|true|1");
|
||
}
|
||
|
||
// copyWithin 重叠方向判别：密集数组反向复制结果与正向不同。
|
||
#[test]
|
||
fn test_copy_within_dense_overlap() {
|
||
let out = eval_str("(() => { const a = [0, 1, 2, 3]; a.copyWithin(1, 0, 2); return a.join(','); })()").unwrap();
|
||
assert_eq!(out, "0,0,1,3");
|
||
}
|
||
|
||
// at 元素读走 Get：洞位落原型链，索引访问器触发。
|
||
#[test]
|
||
fn test_at_get_through_proto() {
|
||
let out = eval_str(
|
||
"(() => { Object.defineProperty(Array.prototype, 0, { get: () => 'AG' }); \
|
||
try { const a = new Array(2); a[1] = 5; \
|
||
return a.at(0) + '|' + a.at(-2) + '|' + a.at(1); } \
|
||
finally { delete Array.prototype[0]; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "AG|AG|5");
|
||
}
|
||
|
||
// reverse 读值期 getter 截断元素区：上端写越界扩展不得物化被删端，
|
||
// 终态被删端保洞、值端 present。
|
||
#[test]
|
||
fn test_reverse_getter_truncation_pair() {
|
||
let out = eval_str(
|
||
"(() => { const a = ['first', 'second']; \
|
||
Object.defineProperty(a, 0, { get: () => { a.length = 0; return 'first'; } }); \
|
||
a.reverse(); \
|
||
return (0 in a) + '|' + (1 in a) + '|' + a[1] + '|' + a.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "false|true|first|2");
|
||
}
|
||
|
||
// reverse 读值期 getter 中间截断：上端写越界扩展的整段间隙 [old_count, upper)
|
||
// 补置洞，不只补被删端一洞。
|
||
#[test]
|
||
fn test_reverse_getter_mid_truncation_gaps_holes() {
|
||
let out = eval_str(
|
||
"(() => { const a = new Array(5); a[0] = 1; \
|
||
Object.defineProperty(a, 0, { get: () => { a.length = 3; return 1; } }); \
|
||
a.reverse(); \
|
||
return (1 in a) + '|' + (3 in a) + '|' + a[4] + '|' + a.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "false|false|1|5");
|
||
}
|
||
|
||
// 防过度修护栏：fill 对洞位无条件 Set，洞位变 present-0，不改。
|
||
#[test]
|
||
fn test_fill_materializes_hole_unchanged() {
|
||
let out = eval_str(
|
||
"(() => { const a = new Array(3); a[0] = 1; a[2] = 3; a.fill(0); \
|
||
return (1 in a) + '|' + a[1]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true|0");
|
||
}
|
||
|
||
// at 越界返回 undefined（无原型链参与，防误改读路径的回归护栏）。
|
||
#[test]
|
||
fn test_at_out_of_bounds_undefined() {
|
||
let (_vm, result) = eval_value("[1, 2].at(9)").unwrap();
|
||
assert!(result.is_undefined());
|
||
}
|
||
|
||
// splice species：Ctor 返回体直接作结果，构造器恰收单参 actualDeleteCount，O 已搬移。
|
||
#[test]
|
||
fn test_splice_species_ctor_returned_instance() {
|
||
let out = eval_str(
|
||
"(() => { let seen = null; const inst = { mark: 1 }; \
|
||
function Ctor(n) { seen = n; inst.len = n; return inst; } \
|
||
const a = [0,1,2,3]; a.constructor = {}; a.constructor[Symbol.species] = Ctor; \
|
||
const r = a.splice(2); \
|
||
return seen + '|' + (r === inst) + '|' + r.len + '|' + a.join(','); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "2|true|2|0,1");
|
||
}
|
||
|
||
// splice species 普通 Ctor 无返回体：结果非数组、原型为 Ctor.prototype，
|
||
// Set(A,"length") 扩长至删除数且值逐位填入。
|
||
#[test]
|
||
fn test_splice_species_plain_ctor_extends_length() {
|
||
let out = eval_str(
|
||
"(() => { function Ctor() {} \
|
||
const a = [0,1,2,3]; a.constructor = {}; a.constructor[Symbol.species] = Ctor; \
|
||
const r = a.splice(0); \
|
||
return Array.isArray(r) + '|' + (Object.getPrototypeOf(r) === Ctor.prototype) + '|' + \
|
||
r.length + '|' + r[0] + ',' + r[1] + ',' + r[2] + ',' + r[3]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "false|true|4|0,1,2,3");
|
||
}
|
||
|
||
// splice species 为 null / 缺省：回退真数组（原型为 Array.prototype），值与长度正确。
|
||
#[test]
|
||
fn test_splice_species_null_undef_plain_array() {
|
||
let out = eval_str(
|
||
"(() => { const a = [0,1,2]; a.constructor = {}; a.constructor[Symbol.species] = null; \
|
||
const r1 = a.splice(1); \
|
||
const b = [0,1,2]; b.constructor = {}; \
|
||
const r2 = b.splice(1); \
|
||
return Array.isArray(r1) + '|' + (Object.getPrototypeOf(r1) === Array.prototype) + '|' + \
|
||
r1.length + '|' + r1[0] + '|' + Array.isArray(r2) + '|' + \
|
||
(Object.getPrototypeOf(r2) === Array.prototype) + '|' + r2.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true|true|2|1|true|true|2");
|
||
}
|
||
|
||
// splice species 构造器收 -0 折算的删除数时收到 +0（非 -0）。
|
||
#[test]
|
||
fn test_splice_species_neg_zero() {
|
||
let out = eval_str(
|
||
"(() => { let isNeg = null; \
|
||
function Ctor(n) { isNeg = Object.is(n, -0); } \
|
||
const a = []; a.constructor = {}; a.constructor[Symbol.species] = Ctor; \
|
||
const r = a.splice(0, -0); \
|
||
return 'neg=' + isNeg + '|len=' + r.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "neg=false|len=0");
|
||
}
|
||
|
||
// splice species 结果 "0" 不可写：CreateDataPropertyOrThrow 覆盖为 present，
|
||
// 描述符恢复可写可配置。
|
||
#[test]
|
||
fn test_splice_species_writable_false_overwritten() {
|
||
let out = eval_str(
|
||
"(() => { function Ctor(n) { const o = {}; o.length = n; \
|
||
Object.defineProperty(o, '0', { writable: false, configurable: true, enumerable: true, value: 99 }); \
|
||
return o; } \
|
||
const a = [0,1,2]; a.constructor = {}; a.constructor[Symbol.species] = Ctor; \
|
||
const r = a.splice(1); \
|
||
const d = Object.getOwnPropertyDescriptor(r, '0'); \
|
||
return r[0] + '|' + d.writable + '|' + d.configurable + '|' + r.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1|true|true|2");
|
||
}
|
||
|
||
// splice species 结果 "0" 不可配置：CreateDataPropertyOrThrow 抛 TypeError。
|
||
#[test]
|
||
fn test_splice_species_non_configurable_throws() {
|
||
let out = eval_str(
|
||
"(() => { function Ctor(n) { const o = {}; o.length = n; \
|
||
Object.defineProperty(o, '0', { writable: true, configurable: false, enumerable: true, value: 99 }); \
|
||
return o; } \
|
||
const a = [0,1,2]; a.constructor = {}; a.constructor[Symbol.species] = Ctor; \
|
||
try { a.splice(1); return 'no-throw'; } catch (e) { return e.constructor.name; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "TypeError");
|
||
}
|
||
|
||
// splice species 结果不可扩展：CreateDataPropertyOrThrow 抛 TypeError。
|
||
#[test]
|
||
fn test_splice_species_non_extensible_throws() {
|
||
let out = eval_str(
|
||
"(() => { function Ctor(n) { const o = {}; o.length = n; Object.preventExtensions(o); return o; } \
|
||
const a = [0,1,2]; a.constructor = {}; a.constructor[Symbol.species] = Ctor; \
|
||
try { a.splice(1); return 'no-throw'; } catch (e) { return e.constructor.name; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "TypeError");
|
||
}
|
||
|
||
// splice constructor 为非对象非 undefined（null/数字/字符串/布尔四值）均抛 TypeError。
|
||
#[test]
|
||
fn test_splice_ctor_non_object_throws() {
|
||
let out = eval_str(
|
||
"(() => { let ok = 0; \
|
||
for (const cv of [null, 1, 'string', true]) { \
|
||
const a = [0,1,2]; a.constructor = cv; \
|
||
try { a.splice(1); } catch (e) { if (e instanceof TypeError) ok++; } } \
|
||
return String(ok); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "4");
|
||
}
|
||
|
||
// 防过度修：无 species 时结果仍为真数组、原型为 Array.prototype，自定义 Ctor 不被调用。
|
||
#[test]
|
||
fn test_splice_no_species_plain_array() {
|
||
let out = eval_str(
|
||
"(() => { let calls = 0; function Ctor() { calls++; } \
|
||
const a = [0,1,2]; \
|
||
const r = a.splice(1); \
|
||
return Array.isArray(r) + '|' + (Object.getPrototypeOf(r) === Array.prototype) + '|' + r.length + '|' + calls; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true|true|2|0");
|
||
}
|
||
|
||
// 步骤序：构造器在收集与搬移之前执行，读到未改动的 O。
|
||
#[test]
|
||
fn test_splice_ctor_reads_o_before_mutation() {
|
||
let out = eval_str(
|
||
"(() => { let seenLen = null, seen0 = null; \
|
||
function Ctor(n) { seenLen = a.length; seen0 = a[0]; } \
|
||
const a = [0,1,2,3]; a.constructor = {}; a.constructor[Symbol.species] = Ctor; \
|
||
a.splice(0, 2, 9); \
|
||
return seenLen + '|' + seen0 + '|' + a.join(','); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "4|0|9,2,3");
|
||
}
|
||
|
||
// @@species getter 抛错原样透传（非构造器 constructor 上的 species 读取异常上抛）。
|
||
#[test]
|
||
fn test_splice_species_poisoned_propagates() {
|
||
let out = eval_str(
|
||
"(() => { const a = [0,1,2]; a.constructor = {}; \
|
||
Object.defineProperty(a.constructor, Symbol.species, { get() { throw new RangeError('species-get'); } }); \
|
||
try { a.splice(1); return 'no-throw'; } catch (e) { return e.constructor.name + ':' + e.message; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "RangeError:species-get");
|
||
}
|
||
|
||
// length 不可写（语料同形 defineProperty 仅收窄 writable 位）：新旧长度相同的
|
||
// 空 splice 与收缩/插入 splice 均抛 TypeError。
|
||
#[test]
|
||
fn test_splice_length_nonwritable_throws() {
|
||
let out = eval_str(
|
||
"(() => { const a = [0,1,2]; Object.defineProperty(a, 'length', { writable: false }); \
|
||
let k1; try { a.splice(1, 2, 4); return 'shrink-no-throw'; } catch (e) { k1 = e.constructor.name; } \
|
||
const b = [0,1,2]; Object.defineProperty(b, 'length', { writable: false }); \
|
||
try { b.splice(0, 0); return 'noop-no-throw'; } catch (e) { return k1 + '|' + e.constructor.name; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "TypeError|TypeError");
|
||
}
|
||
|
||
// 冻结数组空删除也走 length 写：抛 TypeError（防空 splice 被特例放行）。
|
||
#[test]
|
||
fn test_splice_frozen_empty_delete_throws_length() {
|
||
let out = eval_str(
|
||
"(() => { try { Object.freeze([0,1,2]).splice(0, 0); return 'no-throw'; } \
|
||
catch (e) { return e.constructor.name; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "TypeError");
|
||
}
|
||
|
||
// 冻结数组删除命中元素：元素严格 Set 面抛 TypeError（回归护栏）。
|
||
#[test]
|
||
fn test_splice_frozen_element_set_throws() {
|
||
let out = eval_str(
|
||
"(() => { try { Object.freeze([0,1,2]).splice(1, 1); return 'no-throw'; } \
|
||
catch (e) { return e.constructor.name; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "TypeError");
|
||
}
|
||
|
||
// 引擎钉：splice 长度源按 ToLength 读取，2^53 及以上钳位到 2^53-1。
|
||
#[test]
|
||
fn test_splice_length_clamped_to_integer_limit() {
|
||
let out = eval_str(
|
||
"(() => { const o = {}; o.length = 9007199254740992; \
|
||
Array.prototype.splice.call(o); return String(o.length); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "9007199254740991");
|
||
}
|
||
|
||
// 引擎钉：splice 新长度（len + insertCount - actualDeleteCount）超 2^53-1 抛 TypeError。
|
||
#[test]
|
||
fn test_splice_new_length_over_integer_limit_throws() {
|
||
let out = eval_str(
|
||
"(() => { const o = {}; o.length = 9007199254740991; \
|
||
try { Array.prototype.splice.call(o, 0, 0, null); return 'no-throw'; } \
|
||
catch (e) { return e.constructor.name; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "TypeError");
|
||
}
|
||
|
||
// 引擎钉：splice 极限扩容对——arraylike 上元素右移一位、插入位落值、长度扩到 2^53-1。
|
||
#[test]
|
||
fn test_splice_integer_limit_grow_pair() {
|
||
let out = eval_str(
|
||
"(() => { const o = { '9007199254740985': '9007199254740985', \
|
||
'9007199254740986': '9007199254740986', '9007199254740987': '9007199254740987', \
|
||
'9007199254740989': '9007199254740989', '9007199254740991': '9007199254740991', \
|
||
length: 9007199254740990 }; \
|
||
const r = Array.prototype.splice.call(o, 9007199254740986, 0, 'new-value'); \
|
||
return r.length + '|' + o.length + '|' + o['9007199254740986'] + '|' + \
|
||
o['9007199254740987'] + '|' + o['9007199254740988'] + '|' + \
|
||
('9007199254740989' in o) + '|' + o['9007199254740990'] + '|' + o['9007199254740991']; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(
|
||
out,
|
||
"0|9007199254740991|new-value|9007199254740986|9007199254740987|false|9007199254740989|9007199254740991"
|
||
);
|
||
}
|
||
|
||
// 引擎钉：splice 极限收缩对——搬移 + 尾部删位 + 长度缩到 2^53-2。
|
||
#[test]
|
||
fn test_splice_integer_limit_shrink_pair() {
|
||
let out = eval_str(
|
||
"(() => { const o = { '9007199254740986': '9007199254740986', \
|
||
'9007199254740987': '9007199254740987', '9007199254740988': '9007199254740988', \
|
||
'9007199254740990': '9007199254740990', '9007199254740991': '9007199254740991', \
|
||
length: 9007199254740992 }; \
|
||
const r = Array.prototype.splice.call(o, 9007199254740987, 1); \
|
||
return r.length + '|' + r[0] + '|' + o.length + '|' + o['9007199254740986'] + '|' + \
|
||
o['9007199254740987'] + '|' + ('9007199254740988' in o) + '|' + \
|
||
o['9007199254740989'] + '|' + ('9007199254740990' in o) + '|' + o['9007199254740991']; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1|9007199254740987|9007199254740990|9007199254740986|9007199254740988|false|9007199254740990|false|9007199254740991");
|
||
}
|
||
|
||
// 引擎钉：splice 无参——length getter 恰读一次、setter 恰写一次且值为 0。
|
||
#[test]
|
||
fn test_splice_no_args_length_get_set_once() {
|
||
let out = eval_str(
|
||
"(() => { let g = 0, s = 0, v = null; \
|
||
const o = { get length() { g += 1; return '0'; }, \
|
||
set length(x) { s += 1; v = x; } }; \
|
||
Array.prototype.splice.call(o); return g + '|' + s + '|' + v; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1|1|0");
|
||
}
|
||
|
||
// 引擎钉：reverse 在超大 arraylike 上首对即触发上端 getter（StopReverse 上抛）。
|
||
#[test]
|
||
fn test_reverse_integer_limit_object_throws_on_first_pair() {
|
||
let out = eval_str(
|
||
"(() => { function StopReverse() {} \
|
||
const o = { get '9007199254740990'() { throw new StopReverse(); }, \
|
||
length: 9007199254740994 }; \
|
||
try { Array.prototype.reverse.call(o); return 'no-throw'; } \
|
||
catch (e) { return String(e instanceof StopReverse); } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true");
|
||
}
|
||
|
||
// 引擎钉：copyWithin 极限区间——源缺失位目标删位、present 位跨极大下标拷贝。
|
||
#[test]
|
||
fn test_copy_within_integer_limit_range() {
|
||
let out = eval_str(
|
||
"(() => { const si = 9007199254740988; \
|
||
const o = { 0: 0, 1: 1, 2: 2, length: 9007199254740992 }; \
|
||
o[si] = -3; o[si + 2] = -1; \
|
||
Array.prototype.copyWithin.call(o, 0, si, si + 3); \
|
||
return o[0] + '|' + (1 in o) + '|' + o[2]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "-3|false|-1");
|
||
}
|
||
|
||
// 引擎钉：fill 极限区间三格全落值；setter 抛错原样上抛（严格 Set 面）。
|
||
#[test]
|
||
fn test_fill_integer_limit_range_and_setter_throws() {
|
||
let out = eval_str(
|
||
"(() => { const si = 9007199254740988; const v = { m: 1 }; \
|
||
const o = { length: 9007199254740992 }; \
|
||
Array.prototype.fill.call(o, v, si, si + 3); \
|
||
const a2 = { length: 1 }; \
|
||
Object.defineProperty(a2, '0', { set: function () { throw new RangeError('set'); } }); \
|
||
let th = null; try { Array.prototype.fill.call(a2); } catch (e) { th = e.constructor.name; } \
|
||
return (o[si] === v) + '|' + (o[si + 1] === v) + '|' + (o[si + 2] === v) + '|' + th; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true|true|true|RangeError");
|
||
}
|
||
|
||
// 引擎钉：at 负索引自逻辑长度（稀疏覆盖值）折算，越界返回 undefined。
|
||
#[test]
|
||
fn test_at_negative_index_uses_logical_length() {
|
||
let out = eval_str(
|
||
"(() => { const a = new Array(1); a.length = 2147483653; a[0] = 'x'; \
|
||
const b = new Array(1); b.length = 2147483649; \
|
||
return a.at(-2147483653) + '|' + String(b.at(2147483648) === undefined); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "x|true");
|
||
}
|
||
|
||
// 引擎钉：at 极负索引 k = len + relative < 0 返 undefined（不钳零回首元素）；
|
||
// at(-len) 为首元素、at(-len-1) 为 undefined。
|
||
#[test]
|
||
fn test_at_extreme_negative_index_undefined() {
|
||
let out = eval_str(
|
||
"(() => { const a = [7, 8]; \
|
||
return String(a.at(-1e20) === undefined) + '|' + a.at(-2) + '|' + String(a.at(-3) === undefined); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true|7|true");
|
||
}
|
||
|
||
// 引擎钉：基元 this 经 ToObject 装箱——reverse 返回 Boolean 包装体、splice 返回真数组。
|
||
#[test]
|
||
fn test_splice_reverse_primitive_this_boxed() {
|
||
let out = eval_str(
|
||
"(() => { const r1 = Array.prototype.reverse.call(true); \
|
||
const r2 = Array.prototype.splice.call(false); \
|
||
return (r1 instanceof Boolean) + '|' + Array.isArray(r2) + '|' + r2.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true|true|0");
|
||
}
|
||
|
||
// 引擎钉：concat 空数组实参按 ConcatSteps 展开为零元素——不贡献元素也不占位。
|
||
#[test]
|
||
fn test_concat_empty_array_arg_expands_zero_elements() {
|
||
let out = eval_str(
|
||
"(() => { return [1].concat([]).length + '|' + [1].concat([], []).length + '|' + \
|
||
[].concat([]).length + '|' + [1, 2].concat(new Array(0)).length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1|1|0|2");
|
||
}
|
||
|
||
// 引擎钉：concat 多实参混合 present/空数组/非数组实参展开序与规范一致，
|
||
// 空数组实参中间穿插不占位（length 观察面钉死）；洞实参位保洞。
|
||
#[test]
|
||
fn test_concat_mixed_args_order_and_holes() {
|
||
let out = eval_str(
|
||
"(() => { const mixed = [].concat([], 5, []); \
|
||
const ordered = [1].concat([2, 3], 0, []); \
|
||
const r = [].concat(new Array(1)); \
|
||
return mixed.join(',') + '|' + mixed.length + '|' + ordered.join(',') + '|' + \
|
||
ordered.length + '|' + r.length + '|' + (0 in r); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "5|1|1,2,3,0|4|1|false");
|
||
}
|
||
|
||
// ── flat / flatMap 收口钉（node v20.19.2 实测值钉死） ──────────────────────
|
||
|
||
// 引擎钉：reverse (S,N) 臂非可配置 lower——Delete 先于 Set，抛时零改动。
|
||
#[test]
|
||
fn test_reverse_sn_non_configurable_lower_throws_untouched() {
|
||
let out = eval_str(
|
||
"(() => { const a = [1, 2]; delete a[1]; \
|
||
Object.defineProperty(a, '0', { value: 1, writable: true, enumerable: true, configurable: false }); \
|
||
let threw = false; try { a.reverse(); } catch (e) { threw = e.name === 'TypeError'; } \
|
||
return threw + '|' + (1 in a) + '|' + a[0] + '|' + a[1]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true|false|1|undefined");
|
||
}
|
||
|
||
// 引擎钉：reverse (N,S) 臂非可配置 upper——Set(lower) 先成功、Delete(upper) 抛，
|
||
// 部分改动形态保留（判别力核心）。
|
||
#[test]
|
||
fn test_reverse_ns_non_configurable_upper_partial_mutation() {
|
||
let out = eval_str(
|
||
"(() => { const a = [undefined, 2, 3]; delete a[0]; \
|
||
Object.defineProperty(a, '2', { value: 3, writable: true, enumerable: true, configurable: false }); \
|
||
let threw = false; try { a.reverse(); } catch (e) { threw = e.name === 'TypeError'; } \
|
||
return threw + '|' + a[0] + '|' + a[1] + '|' + a[2]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true|3|2|3");
|
||
}
|
||
|
||
// 引擎钉：reverse 读序 Hf,Gf,Ht,Gt 逐对交错 + (S,S) 臂写序 S0,S3,S1,S2；
|
||
// getter 还原原值，终读经 getter 呈现原序列（读序钉位核心）。
|
||
// 访问器逐条显式定义（不走 for 循环闭包捕获，规避既有作用域面）。
|
||
#[test]
|
||
fn test_reverse_get_set_order_and_final_values() {
|
||
let out = eval_str(
|
||
"(() => { const a = [10, 11, 22, 30]; const log = []; \
|
||
Object.defineProperty(a, 0, { configurable: true, get() { log.push('G0'); return 10; }, set(x) { log.push('S0=' + x); } }); \
|
||
Object.defineProperty(a, 1, { configurable: true, get() { log.push('G1'); return 11; }, set(x) { log.push('S1=' + x); } }); \
|
||
Object.defineProperty(a, 2, { configurable: true, get() { log.push('G2'); return 22; }, set(x) { log.push('S2=' + x); } }); \
|
||
Object.defineProperty(a, 3, { configurable: true, get() { log.push('G3'); return 30; }, set(x) { log.push('S3=' + x); } }); \
|
||
a.reverse(); return log.join(',') + '|' + a.join(','); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "G0,G3,S0=30,S3=10,G1,G2,S1=22,S2=11|10,11,22,30");
|
||
}
|
||
|
||
// 引擎钉：reverse getter 内 length=0 截断（GID 形态）——(S,N) 臂 Delete(lower)
|
||
// 后 upper 写越界扩长，`0 in` 假、`1 in` 真、a[1] 为下值。
|
||
#[test]
|
||
fn test_reverse_getter_length_zero_in_check() {
|
||
let out = eval_str(
|
||
"(() => { const array = ['first', 'second']; \
|
||
Object.defineProperty(array, 0, { get() { array.length = 0; return 'first'; } }); \
|
||
array.reverse(); return (0 in array) + '|' + (1 in array) + '|' + array[1]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "false|true|first");
|
||
}
|
||
|
||
// 引擎钉：flat arraylike 接收者——ToObject 通用入口 + LengthOfArrayLike 长度源，
|
||
// 嵌套数组元素展开一层。
|
||
#[test]
|
||
fn test_flat_arraylike_receiver_nested() {
|
||
let out = eval_str(
|
||
"(() => { const r = Array.prototype.flat.call({ length: 2, 0: [1], 1: [2] }); \
|
||
return r.join(',') + '|' + r.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1,2|2");
|
||
}
|
||
|
||
// 引擎钉：flat arraylike 分数长度——ToLength 折算 2.9 → 2，第三元素不入。
|
||
#[test]
|
||
fn test_flat_arraylike_fractional_length() {
|
||
let out = eval_str(
|
||
"(() => { const r = Array.prototype.flat.call({ length: 2.9, 0: 1, 1: 2, 2: 3 }); \
|
||
return r.join(',') + '|' + r.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1,2|2");
|
||
}
|
||
|
||
// 引擎钉：flat arraylike NaN 长度——ToLength(NaN) = 0，空结果。
|
||
#[test]
|
||
fn test_flat_arraylike_nan_length() {
|
||
let out = eval_str(
|
||
"(() => { const r = Array.prototype.flat.call({ length: NaN, 0: 1 }); \
|
||
return r.join(',') + '|' + r.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "|0");
|
||
}
|
||
|
||
// 引擎钉：flat arraylike undefined 长度——Get length 缺省 undefined，ToLength 0。
|
||
#[test]
|
||
fn test_flat_arraylike_undefined_length() {
|
||
let out = eval_str(
|
||
"(() => { const r = Array.prototype.flat.call({ length: undefined, 0: [1] }); \
|
||
return r.join(',') + '|' + r.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "|0");
|
||
}
|
||
|
||
// 引擎钉：flat 装箱基元 this——ToObject 后长度为 0，结果空真数组。
|
||
#[test]
|
||
fn test_flat_boxed_primitive_this() {
|
||
let out = eval_str(
|
||
"(() => { const r = Array.prototype.flat.call(true); \
|
||
return r.length + '|' + Array.isArray(r); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "0|true");
|
||
}
|
||
|
||
// 引擎钉：flat 负 depth——ToIntegerOrInfinity 后归 0，不展开。
|
||
#[test]
|
||
fn test_flat_negative_depth_no_flatten() {
|
||
assert_eq!(eval_str("(() => { return JSON.stringify([[1]].flat(-1)); })()").unwrap(), "[[1]]");
|
||
}
|
||
|
||
// 引擎钉：flat NaN depth——ToIntegerOrInfinity(NaN) = 0，不展开（非默认深 1）。
|
||
#[test]
|
||
fn test_flat_nan_depth_no_flatten() {
|
||
assert_eq!(eval_str("(() => { return JSON.stringify([[1]].flat(NaN)); })()").unwrap(), "[[1]]");
|
||
}
|
||
|
||
// 引擎钉：flat 0 depth——0 不展开（旧 (n as i32).max(1) 形态会误展开一层）。
|
||
#[test]
|
||
fn test_flat_zero_depth_no_flatten() {
|
||
assert_eq!(eval_str("(() => { return JSON.stringify([[1]].flat(0)); })()").unwrap(), "[[1]]");
|
||
}
|
||
|
||
// 引擎钉：flat +∞ depth——无限深度臂，全嵌套展开。
|
||
#[test]
|
||
fn test_flat_infinity_depth() {
|
||
let out = eval_str("(() => { return [1, [2, [3, [4]]]].flat(Infinity).join(','); })()").unwrap();
|
||
assert_eq!(out, "1,2,3,4");
|
||
}
|
||
|
||
// 引擎钉：flat 超大 depth（i32 回绕域）——f64 域无回绕，浅数组上等效深 1。
|
||
#[test]
|
||
fn test_flat_huge_depth_no_wrap() {
|
||
assert_eq!(eval_str("(() => { return JSON.stringify([[1]].flat(3000000000)); })()").unwrap(), "[1]",);
|
||
}
|
||
|
||
// 引擎钉：flat Symbol / null 原型对象 depth——ToPrimitive 转换异常按规范传播
|
||
// TypeError（旧 unwrap_or 吞错形态会静默返空）。
|
||
#[test]
|
||
fn test_flat_symbol_null_proto_depth_throws() {
|
||
let out = eval_str(
|
||
"(() => { let t1 = '?'; let t2 = '?'; \
|
||
try { [1].flat(Symbol()); } catch (e) { t1 = e.name; } \
|
||
try { [1].flat(Object.create(null)); } catch (e) { t2 = e.name; } \
|
||
return t1 + '|' + t2; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "TypeError|TypeError");
|
||
}
|
||
|
||
// 引擎钉：flat species frozen 目标——CreateDataPropertyOrThrow 抛 TypeError。
|
||
#[test]
|
||
fn test_flat_species_frozen_target_throws() {
|
||
let out = eval_str(
|
||
"(() => { const a = [1, 2]; a.constructor = {}; \
|
||
a.constructor[Symbol.species] = (n) => Object.freeze([]); \
|
||
let t = '?'; try { a.flat(); } catch (e) { t = e.name; } return t; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "TypeError");
|
||
}
|
||
|
||
// 引擎钉：flat species 构造器为 null——ArraySpeciesCreate 步 9 抛 TypeError。
|
||
#[test]
|
||
fn test_flat_species_null_ctor_throws() {
|
||
let out = eval_str(
|
||
"(() => { const a = [1, 2]; a.constructor = null; \
|
||
let t = '?'; try { a.flat(); } catch (e) { t = e.name; } return t; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "TypeError");
|
||
}
|
||
|
||
// 引擎钉：flat species 非可写 '0' 槽（configurable）——CDO 覆写并恢复可写描述符；
|
||
// 普通对象目标 length 为普通属性，不随 CDO 扩长。
|
||
#[test]
|
||
fn test_flat_species_non_writable_slot_overwritten() {
|
||
let out = eval_str(
|
||
"(() => { function Ctor(n) { const o = {}; o.length = n; \
|
||
Object.defineProperty(o, '0', { writable: false, configurable: true, enumerable: true, value: 99 }); \
|
||
return o; } \
|
||
const a = [0, 1]; a.constructor = {}; a.constructor[Symbol.species] = Ctor; \
|
||
const r = a.flat(); const d = Object.getOwnPropertyDescriptor(r, '0'); \
|
||
return r[0] + '|' + d.writable + '|' + d.configurable + '|' + r.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "0|true|true|0");
|
||
}
|
||
|
||
// 引擎钉：flat 洞语义——HasProperty 门控丢洞，结果恒紧凑（防误修回归）。
|
||
#[test]
|
||
fn test_flat_holes_dropped_compact() {
|
||
let out = eval_str(
|
||
"(() => { const r1 = [1, , 2].flat(); const r2 = [[1, , 2], [3]].flat(); \
|
||
return r1.join(',') + '|' + r1.length + '|' + r2.join(',') + '|' + r2.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1,2|2|1,2,3|3");
|
||
}
|
||
|
||
// 引擎钉：flat 真数组 length 增/减后——长度源为 ToLength(Get length)，洞位丢洞。
|
||
#[test]
|
||
fn test_flat_logical_length_grow_shrink() {
|
||
let out = eval_str(
|
||
"(() => { const a = [1, 2, 3]; a.length = 5; const r1 = a.flat(); \
|
||
const b = [1, 2, 3]; b.length = 1; const r2 = b.flat(); \
|
||
return r1.join(',') + '|' + r1.length + '|' + r2.join(',') + '|' + r2.length; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1,2,3|3|1|1");
|
||
}
|
||
|
||
// 引擎钉：flat 非数组嵌套元素原样保留（防过度展开：仅真数组递归）。
|
||
#[test]
|
||
fn test_flat_non_array_elements_kept() {
|
||
let out = eval_str(
|
||
"(() => { const o = { a: 1 }; const r = [[o], 2].flat(); \
|
||
return r.length + '|' + (r[0] === o) + '|' + r[1]; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "2|true|2");
|
||
}
|