ITStudio_OUC/OxideJS-New
0
1
Fork 0
mirror of https://github.com/pjh456/OxideJS.git synced 2026-10-24 18:51:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: num-bigint 接入任意精度 BigInt（字面量、算术、toString、asIntN/asUintN）

Browse Source
This commit is contained in:
彭俊皓
2026-08-12 03:15:18 +08:00
parent 4474702735
commit 1824ef0df1
18 changed files with 227 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/oxide_vm/Cargo.toml
+2
View File
@@ -26,6 +26,8 @@ indexmap.workspace = true
smallvec.workspace = true
unicode-normalization.workspace = true
rustc-hash.workspace = true
num-bigint = "0.4"
num-traits = "0.2"
[dev-dependencies]
proptest.workspace = true
crates/oxide_vm/src/dispatch/arithmetic.rs
+77 -45
View File
@@ -3,6 +3,11 @@ use crate::vm_trace;
use oxide_runtime_api as coercion;
use oxide_types::value::JsValue;
/// 判断 JsValue 是否为 BigInt 且值为 0（num_bigint 零值判断）。
fn bigint_is_zero(v: &num_bigint::BigInt) -> bool {
num_traits::Zero::is_zero(v)
}
impl Vm {
#[inline(always)]
pub(crate) fn dispatch_add(&mut self, rd: usize, a: usize, b: usize) -> Result<(), String> {
@@ -22,36 +27,43 @@ impl Vm {
// 必须放在 coerce 之后。
let lhs = self.coerce_primitive_bounded(lv, false)?;
let rhs = self.coerce_primitive_bounded(rv, false)?;
if lhs.is_string() || rhs.is_string() {
self.regs[rd] = self.concat_strings(lhs, rhs);
return Ok(());
}
if lhs.is_bigint() && rhs.is_bigint() {
// 包装对象 coerce 后暴露双 BigInt（如 Object(2n) + 2n）。
self.regs[rd] = self.new_bigint(self.bigint_value(lhs) + self.bigint_value(rhs));
return Ok(());
}
if lhs.is_bigint() != rhs.is_bigint() {
// 包装对象 coerce 后暴露 BigInt：与另一非 BigInt 操作数混合加法必须抛
// TypeError（规范不允许 BigInt 与 Number/String 相加）。
// 包装对象 coerce 后暴露 BigInt：与另一非 BigInt 非字符串操作数混合加法
// 必须抛 TypeError（规范只允许 String + BigInt 走字符串拼接）。
return self.raise_type_error("Cannot mix BigInt and other types, use explicit conversions");
}
if lhs.is_string() || rhs.is_string() {
let lbytes = if lhs.is_string() { unsafe { (*lhs.as_string_ptr()).len() } } else { 0 };
let rbytes = if rhs.is_string() { unsafe { (*rhs.as_string_ptr()).len() } } else { 0 };
// 预分配精确容量：字符串操作数 O(1) 取字节长，一次分配写齐，免 push_str
// 几何 realloc 的二次拷贝（字符串拼接热路径的主要额外成本）。
// 32 字节余量覆盖数字/布尔等格式化文本（f64 文本最长约 24 字节），
// 避免追加非字符串操作数时二次扩容。
let mut buf = String::with_capacity(lbytes + rbytes + 32);
coercion::push_to_string(lhs, &mut buf);
coercion::push_to_string(rhs, &mut buf);
let result = self.new_string_owned(buf);
self.regs[rd] = result;
} else {
let ln = coercion::to_number(lhs);
let rn = coercion::to_number(rhs);
self.regs[rd] = JsValue::float(ln + rn);
}
let ln = coercion::to_number(lhs);
let rn = coercion::to_number(rhs);
self.regs[rd] = JsValue::float(ln + rn);
Ok(())
}
/// 字符串拼接热路径：一次预分配写齐两个操作数的 ToString 文本。
///
/// # 步骤
/// 1. 按字符串操作数字节长预分配容量（余量覆盖数字/布尔等格式化文本）。
/// 2. 两个操作数依次走 push_to_string（BigInt 输出十进制，Symbol 由调用方先行拒绝）。
/// 3. 生成会话字符串写入目标寄存器。
///
/// # 副作用
/// 新建一个会话字符串，登记到 session 生命周期。
fn concat_strings(&mut self, lhs: JsValue, rhs: JsValue) -> JsValue {
let lbytes = if lhs.is_string() { unsafe { (*lhs.as_string_ptr()).len() } } else { 0 };
let rbytes = if rhs.is_string() { unsafe { (*rhs.as_string_ptr()).len() } } else { 0 };
let mut buf = String::with_capacity(lbytes + rbytes + 32);
coercion::push_to_string(lhs, &mut buf);
coercion::push_to_string(rhs, &mut buf);
self.new_string_owned(buf)
}
#[inline(always)]
pub(crate) fn dispatch_neg(&mut self, rd: usize, a: usize) -> Result<(), String> {
vm_trace!("NEG rd={} r{}={:?}", rd, a, self.regs[a]);
@@ -69,12 +81,14 @@ impl Vm {
pub(crate) fn dispatch_unary_plus(&mut self, rd: usize, a: usize) -> Result<(), String> {
vm_trace!("UNARY_PLUS rd={} r{}={:?}", rd, a, self.regs[a]);
let v = self.regs[a];
if v.is_bigint() {
// 一元 + 对 BigInt 必须抛 TypeError（ToNumber(BigInt) 在隐式路径禁止）。
// ToPrimitive 先解盒（BigInt 包装对象如 Object(1n) 的 valueOf 返回 BigInt），
// 解盒后是 BigInt 才抛 TypeError——用户覆盖 valueOf/toString 的普通对象不受影响。
let prim = self.coerce_primitive_bounded(v, false)?;
if prim.is_bigint() {
return self.raise_type_error("Cannot convert a BigInt value to a number");
}
let v = self.coerce_number_bounded(v)?;
self.regs[rd] = JsValue::float(v);
let n = coercion::to_number(prim);
self.regs[rd] = JsValue::float(n);
Ok(())
}
@@ -92,30 +106,22 @@ impl Vm {
}
let lhs = self.coerce_primitive_bounded(lv, false)?;
let rhs = self.coerce_primitive_bounded(rv, false)?;
if lhs.is_string() || rhs.is_string() {
self.regs[rd] = self.concat_strings(lhs, rhs);
return Ok(());
}
if lhs.is_bigint() && rhs.is_bigint() {
self.regs[rd] = self.new_bigint(self.bigint_value(lhs) + self.bigint_value(rhs));
return Ok(());
}
if lhs.is_bigint() != rhs.is_bigint() {
// 包装对象 coerce 后暴露 BigInt：与另一非 BigInt 非字符串操作数混合加法
// 必须抛 TypeError（规范只允许 String + BigInt 走字符串拼接）。
return self.raise_type_error("Cannot mix BigInt and other types, use explicit conversions");
}
if lhs.is_string() || rhs.is_string() {
let lbytes = if lhs.is_string() { unsafe { (*lhs.as_string_ptr()).len() } } else { 0 };
let rbytes = if rhs.is_string() { unsafe { (*rhs.as_string_ptr()).len() } } else { 0 };
// 预分配精确容量：字符串操作数 O(1) 取字节长，一次分配写齐，免 push_str
// 几何 realloc 的二次拷贝（字符串拼接热路径的主要额外成本）。
// 32 字节余量覆盖数字/布尔等格式化文本（f64 文本最长约 24 字节），
// 避免追加非字符串操作数时二次扩容。
let mut buf = String::with_capacity(lbytes + rbytes + 32);
coercion::push_to_string(lhs, &mut buf);
coercion::push_to_string(rhs, &mut buf);
let result = self.new_string_owned(buf);
self.regs[rd] = result;
} else {
let ln = coercion::to_number(lhs);
let rn = coercion::to_number(rhs);
self.regs[rd] = JsValue::float(ln + rn);
}
let ln = coercion::to_number(lhs);
let rn = coercion::to_number(rhs);
self.regs[rd] = JsValue::float(ln + rn);
Ok(())
}
@@ -186,7 +192,7 @@ impl Vm {
}
if lv.is_bigint() && rv.is_bigint() {
let r = self.bigint_value(rv);
if r == 0 {
if bigint_is_zero(r) {
return self.raise_error_kind("RangeError", "Division by zero");
}
self.regs[rd] = self.new_bigint(self.bigint_value(lv) / r);
@@ -196,7 +202,7 @@ impl Vm {
let r = self.coerce_primitive_bounded(rv, false)?;
if l.is_bigint() && r.is_bigint() {
let rv = self.bigint_value(r);
if rv == 0 {
if bigint_is_zero(rv) {
return self.raise_error_kind("RangeError", "Division by zero");
}
self.regs[rd] = self.new_bigint(self.bigint_value(l) / rv);
@@ -222,7 +228,7 @@ impl Vm {
}
if lv.is_bigint() && rv.is_bigint() {
let r = self.bigint_value(rv);
if r == 0 {
if bigint_is_zero(r) {
return self.raise_error_kind("RangeError", "Division by zero");
}
self.regs[rd] = self.new_bigint(self.bigint_value(lv) % r);
@@ -232,7 +238,7 @@ impl Vm {
let r = self.coerce_primitive_bounded(rv, false)?;
if l.is_bigint() && r.is_bigint() {
let rv = self.bigint_value(r);
if rv == 0 {
if bigint_is_zero(rv) {
return self.raise_error_kind("RangeError", "Division by zero");
}
self.regs[rd] = self.new_bigint(self.bigint_value(l) % rv);
@@ -265,6 +271,13 @@ impl Vm {
#[inline(always)]
pub(crate) fn dispatch_inc_pre(&mut self, rd: usize, a: usize) -> Result<(), String> {
vm_trace!("INC_PRE rd={} a={}", rd, a);
if self.regs[rd].is_bigint() {
let v = self.bigint_value(self.regs[rd]) + 1;
let result = self.new_bigint(v);
self.regs[rd] = result;
self.regs[a] = result;
return Ok(());
}
let n = self.coerce_number_bounded(self.regs[rd])?;
let result = JsValue::float(n + 1.0);
self.regs[rd] = result;
@@ -275,6 +288,12 @@ impl Vm {
#[inline(always)]
pub(crate) fn dispatch_inc_post(&mut self, rd: usize, a: usize) -> Result<(), String> {
vm_trace!("INC_POST rd={} a={}", rd, a);
if self.regs[rd].is_bigint() {
let v = self.bigint_value(self.regs[rd]).clone();
self.regs[a] = self.regs[rd];
self.regs[rd] = self.new_bigint(v + 1);
return Ok(());
}
let n = self.coerce_number_bounded(self.regs[rd])?;
self.regs[a] = JsValue::float(n);
self.regs[rd] = JsValue::float(n + 1.0);
@@ -284,6 +303,13 @@ impl Vm {
#[inline(always)]
pub(crate) fn dispatch_dec_pre(&mut self, rd: usize, a: usize) -> Result<(), String> {
vm_trace!("DEC_PRE rd={} a={}", rd, a);
if self.regs[rd].is_bigint() {
let v = self.bigint_value(self.regs[rd]).clone() - 1;
let result = self.new_bigint(v);
self.regs[rd] = result;
self.regs[a] = result;
return Ok(());
}
let n = self.coerce_number_bounded(self.regs[rd])?;
let result = JsValue::float(n - 1.0);
self.regs[rd] = result;
@@ -294,6 +320,12 @@ impl Vm {
#[inline(always)]
pub(crate) fn dispatch_dec_post(&mut self, rd: usize, a: usize) -> Result<(), String> {
vm_trace!("DEC_POST rd={} a={}", rd, a);
if self.regs[rd].is_bigint() {
let v = self.bigint_value(self.regs[rd]).clone();
self.regs[a] = self.regs[rd];
self.regs[rd] = self.new_bigint(v - 1);
return Ok(());
}
let n = self.coerce_number_bounded(self.regs[rd])?;
self.regs[a] = JsValue::float(n);
self.regs[rd] = JsValue::float(n - 1.0);
crates/oxide_vm/src/vm.rs
+10 -9
View File
@@ -3,6 +3,7 @@
use std::collections::VecDeque;
use std::sync::{Arc, OnceLock};
use num_traits::Zero;
use oxide_bytecode::module::{CompiledModule, Constant};
use oxide_bytecode::opcode::{self, OpCode};
use smallvec::SmallVec;
@@ -85,9 +86,9 @@ macro_rules! binary_arith {
if lv.is_int() && rv.is_int() {
$self.regs[$rd] = JsValue::float(lv.as_int() as f64 $op rv.as_int() as f64);
} else if lv.is_bigint() && rv.is_bigint() {
let l = $self.bigint_value(lv);
let r = $self.bigint_value(rv);
if r == 0 {
let l = $self.bigint_value(lv).clone();
let r = $self.bigint_value(rv).clone();
if r.is_zero() {
// BigInt 除/模零：规范要求 RangeError（Number 路径走 f64 inf/NaN）。
$self.raise_error_kind("RangeError", "Division by zero")?;
$self.regs[$rd] = JsValue::undefined();
@@ -101,9 +102,9 @@ macro_rules! binary_arith {
let r = $self.coerce_primitive_bounded(rv, false)?;
if l.is_bigint() && r.is_bigint() {
// 包装对象 coerce 后暴露双 BigInt（如 Object(2n) / 2n）。
let lv = $self.bigint_value(l);
let rv = $self.bigint_value(r);
if rv == 0 {
let lv = $self.bigint_value(l).clone();
let rv = $self.bigint_value(r).clone();
if rv.is_zero() {
$self.raise_error_kind("RangeError", "Division by zero")?;
$self.regs[$rd] = JsValue::undefined();
} else {
@@ -1781,10 +1782,10 @@ impl oxide_runtime_api::VmHost for Vm {
fn new_string(&mut self, s: &str) -> JsValue {
self.new_string(s)
}
fn new_bigint(&mut self, v: i128) -> JsValue {
fn new_bigint(&mut self, v: num_bigint::BigInt) -> JsValue {
Vm::new_bigint(self, v)
}
fn bigint_value(&mut self, val: JsValue) -> i128 {
fn bigint_value(&mut self, val: JsValue) -> &num_bigint::BigInt {
Vm::bigint_value(self, val)
}
fn kernel_core(&self) -> &Arc<KernelCore> {
@@ -1983,11 +1984,11 @@ fn rehome_subtree(module: &CompiledModule, base: u32, out: &mut Vec<Arc<Compiled
#[cfg(test)]
mod tests {
use super::{opcode, JsValue, TryHandler, Vm};
use std::sync::Arc;
use oxide_bytecode::module::CompiledModule;
use oxide_runtime_api::NativeResult;
use oxide_types::object::NativeFnPtr;
use oxide_types::object::{JsObject, PropAttributes};
use std::sync::Arc;
fn native_return_7(_vm: &mut Vm, _args: &[u8]) -> NativeResult {
NativeResult::Ok(JsValue::int(7))
crates/oxide_vm/src/vm_state.rs
+3 -3
View File
@@ -13,10 +13,10 @@ use std::collections::HashMap;
use rustc_hash::FxBuildHasher;
use oxide_types::object::{JsObject, JsString};
use oxide_types::value::JsValue;
use crate::session_gc::SessionGc;
use crate::vm::ForInIter;
use oxide_types::object::{JsObject, JsString};
use oxide_types::value::JsValue;
/// session arena 与 GC 簿记。
///
@@ -32,7 +32,7 @@ pub(crate) struct GcState {
/// BigInt 堆 box（`Box<i128>`）追踪表。`RefCell` 使 `&self` 的
/// `convert_immutables` 也能登记新 box。与字符串不同，BigInt 不参与
/// mark/sweep 回收（值量少），只在 full_reset 统一释放。
pub(crate) session_bigint_ptrs: RefCell<Vec<*mut i128>>,
pub(crate) session_bigint_ptrs: RefCell<Vec<*mut num_bigint::BigInt>>,
pub(crate) session_bytes_allocated: usize,
pub(crate) forwarding: HashMap<*mut JsObject, *mut JsObject, FxBuildHasher>,
}
crates/oxide_vm/src/vm_support.rs
+8 -8
View File
@@ -484,23 +484,23 @@ impl Vm {
///
/// box 指针登记进 `gc_state.session_bigint_ptrs`，在 `full_reset` 统一释放。
/// `&self` 使 `convert_immutables`（常量池 → JsValue）也能分配。
pub fn new_bigint(&self, v: i128) -> JsValue {
pub fn new_bigint(&self, v: num_bigint::BigInt) -> JsValue {
let ptr = Box::into_raw(Box::new(v));
self.gc_state.session_bigint_ptrs.borrow_mut().push(ptr);
JsValue::bigint(ptr)
}
/// 读取 BigInt 值；调用方须保证 `val.is_bigint()`。
pub fn bigint_value(&self, val: JsValue) -> i128 {
pub fn bigint_value(&self, val: JsValue) -> &num_bigint::BigInt {
// SAFETY: bigint 指针由 new_bigint 经 Box::into_raw 产生，存活至 full_reset。
unsafe { *val.as_bigint_ptr() }
unsafe { &*val.as_bigint_ptr() }
}
/// 释放全部 session 堆 `i128` box。仅在完全隔离重置（`full_reset`）时调用，
/// 释放全部 session 堆 BigInt box。仅在完全隔离重置（`full_reset`）时调用，
/// 此时没有存活的 session 对象/寄存器会引用它们。
fn free_session_bigint_heap_data(&mut self) {
for ptr in self.gc_state.session_bigint_ptrs.borrow_mut().drain(..) {
// SAFETY: 每个指针来自 new_bigint 的 Box::into_raw(Box::new(i128))，
// SAFETY: 每个指针来自 new_bigint 的 Box::into_raw(Box::new(BigInt))，
// 且只在这里恰好释放一次。
unsafe {
drop(Box::from_raw(ptr));
@@ -512,7 +512,7 @@ impl Vm {
match constant {
Constant::Number(v) => JsValue::float(*v),
Constant::Int(v) => JsValue::int(*v),
Constant::BigInt(v) => self.new_bigint(*v),
Constant::BigInt(v) => self.new_bigint(v.clone()),
Constant::String(s) => self.perm_string(s),
Constant::Boolean(b) => JsValue::bool(*b),
Constant::Null => JsValue::null(),
@@ -835,10 +835,10 @@ mod tests {
let mut vm = Vm::new();
let result = run_source(&mut vm, "100n + 23n");
assert!(result.is_bigint());
assert_eq!(vm.bigint_value(result), 123);
assert_eq!(vm.bigint_value(result), &num_bigint::BigInt::from(123));
vm.reset();
// reset 保留 session 字符串/bigint box：值仍可读。
assert_eq!(vm.bigint_value(result), 123);
assert_eq!(vm.bigint_value(result), &num_bigint::BigInt::from(123));
}
#[test]