Implement BigInt support and primitive prototype lookup

ssrlive · ssrlive · commit a2c02aed2b85 · 2026-01-07T17:31:53.000+08:00
- src/js_bigint.rs: Add BigInt implementation with constructor, static methods, and instance methods.
- src/core/eval.rs: Add mechanisms to access properties on primitive values via prototype lookup.
- src/core/eval.rs: Route BigInt constructor and method calls in the evaluator.
- src/core.rs: Register BigInt global object during initialization.
- src/core/value.rs: Add to_primitive helper function.
- src/lib.rs: Enable js_bigint module.
diff --git a/js-scripts/bigint_test.js b/js-scripts/bigint_test.js
@@ -0,0 +1,34 @@
+try {
+    console.log("Starting BigInt tests...");
+
+    // 1. Constructor
+    var b1 = BigInt(123);
+    var b2 = BigInt("900719925474099100");
+    console.log("b1 created: " + b1.toString()); 
+    console.log("b2 created: " + b2.toString());
+
+    if (b1.toString() !== "123") throw "b1 value mismatch";
+    if (b2.toString() !== "900719925474099100") throw "b2 value mismatch";
+
+    // 2. Methods
+    console.log("Testing asIntN...");
+    // 64-bit signed int of b2
+    var b3 = BigInt.asIntN(64, b2);
+    console.log("BigInt.asIntN(64, b2) = " + b3.toString());
+
+    console.log("Testing asUintN...");
+    var b4 = BigInt.asUintN(64, b2);
+    console.log("BigInt.asUintN(64, b2) = " + b4.toString());
+
+    console.log("Testing valueOf...");
+    var v1 = b1.valueOf();
+    console.log("b1.valueOf() = " + v1.toString());
+    console.log("Type of b1.valueOf() = " + (typeof v1));
+    console.log("Type of b1 = " + (typeof b1));
+
+    console.log("BigInt tests finished successfully.");
+
+} catch (e) {
+    console.log("Test Failed: " + e);
+    if (e.stack) console.log(e.stack);
+}
diff --git a/src/core.rs b/src/core.rs
@@ -1,5 +1,6 @@
 use crate::error::JSError;
 use crate::js_array::initialize_array;
+use crate::js_bigint::initialize_bigint;
 use crate::js_console::initialize_console_object;
 use crate::js_date::initialize_date;
 use crate::js_math::initialize_math;
@@ -72,6 +73,7 @@ pub fn initialize_global_constructors<'gc>(mc: &MutationContext<'gc>, env: &JSOb
     // Initialize Date constructor and prototype
     initialize_date(mc, env)?;
     initialize_os_module(mc, env)?;
+    initialize_bigint(mc, env)?;
 
     env_set(mc, env, "undefined", Value::Undefined)?;
     env_set(mc, env, "NaN", Value::Number(f64::NAN))?;
diff --git a/src/core/eval.rs b/src/core/eval.rs
@@ -2,6 +2,7 @@
 
 use crate::core::{Gc, GcCell, MutationContext};
 use crate::js_array::handle_array_static_method;
+use crate::js_bigint::bigint_constructor;
 use crate::js_date::{handle_date_method, handle_date_static_method};
 use crate::js_os::handle_os_method;
 use crate::js_string::{string_from_char_code, string_from_code_point, string_raw};
@@ -469,6 +470,34 @@ fn refresh_error_by_additional_stack_frame<'gc>(
     e
 }
 
+fn get_primitive_prototype_property<'gc>(
+    mc: &MutationContext<'gc>,
+    env: &JSObjectDataPtr<'gc>,
+    obj_val: &Value<'gc>,
+    key: &PropertyKey<'gc>,
+) -> Result<Value<'gc>, EvalError<'gc>> {
+    let proto_name = match obj_val {
+        Value::BigInt(_) => "BigInt",
+        Value::Number(_) => "Number",
+        Value::String(_) => "String",
+        Value::Boolean(_) => "Boolean",
+        _ => return Ok(Value::Undefined),
+    };
+
+    if let Ok(ctor) = evaluate_var(mc, env, proto_name) {
+        if let Value::Object(ctor_obj) = ctor {
+            if let Some(proto_ref) = obj_get_key_value(&ctor_obj, &"prototype".into())? {
+                if let Value::Object(proto) = &*proto_ref.borrow() {
+                    if let Some(val) = obj_get_key_value(proto, key)? {
+                        return Ok(val.borrow().clone());
+                    }
+                }
+            }
+        }
+    }
+    Ok(Value::Undefined)
+}
+
 pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>, expr: &Expr) -> Result<Value<'gc>, EvalError<'gc>> {
     match expr {
         Expr::Number(n) => Ok(Value::Number(*n)),
@@ -663,7 +692,7 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                     } else if matches!(obj_val, Value::Undefined | Value::Null) {
                         return Err(EvalError::Js(raise_eval_error!("Cannot read properties of null or undefined")));
                     } else {
-                        Value::Undefined
+                        get_primitive_prototype_property(mc, env, &obj_val, &key.as_str().into())?
                     };
                     (f_val, Some(obj_val))
                 }
@@ -703,6 +732,11 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                     } else if let Some(method) = name.strip_prefix("os.") {
                         let this_val = this_val.clone().unwrap_or(Value::Object(*env));
                         Ok(handle_os_method(mc, this_val, method, &eval_args, env).map_err(EvalError::Js)?)
+                    } else if let Some(method) = name.strip_prefix("BigInt.prototype.") {
+                        let this_v = this_val.clone().unwrap_or(Value::Undefined);
+                        Ok(crate::js_bigint::handle_bigint_object_method(this_v, method, &eval_args).map_err(EvalError::Js)?)
+                    } else if let Some(method) = name.strip_prefix("BigInt.") {
+                        Ok(crate::js_bigint::handle_bigint_static_method(method, &eval_args, env).map_err(EvalError::Js)?)
                     } else if let Some(method) = name.strip_prefix("Math.") {
                         Ok(handle_math_call(mc, method, &eval_args, env).map_err(EvalError::Js)?)
                     } else if let Some(method) = name.strip_prefix("Date.prototype.") {
@@ -843,6 +877,8 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                             Value::String(name) => {
                                 if name == &crate::unicode::utf8_to_utf16("String") {
                                     Ok(crate::js_string::string_constructor(mc, &eval_args, env)?)
+                                } else if name == &crate::unicode::utf8_to_utf16("BigInt") {
+                                    Ok(bigint_constructor(&eval_args, env)?)
                                 } else {
                                     Err(EvalError::Js(raise_eval_error!("Not a function")))
                                 }
@@ -911,39 +947,44 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
         }
         Expr::Property(obj_expr, key) => {
             let obj_val = evaluate_expr(mc, env, obj_expr)?;
-            if let Value::Object(obj) = obj_val {
-                if let Some(val) = obj_get_key_value(&obj, &key.as_str().into())? {
-                    Ok(val.borrow().clone())
+
+            if let Value::Object(obj) = &obj_val {
+                if let Some(val) = obj_get_key_value(obj, &key.as_str().into())? {
+                    return Ok(val.borrow().clone());
                 } else {
-                    Ok(Value::Undefined)
+                    return Ok(Value::Undefined);
                 }
-            } else if matches!(obj_val, Value::Undefined | Value::Null) {
-                Err(EvalError::Js(raise_eval_error!("Cannot read properties of null or undefined")))
-            } else {
-                Ok(Value::Undefined)
             }
+
+            if matches!(obj_val, Value::Undefined | Value::Null) {
+                return Err(EvalError::Js(raise_eval_error!("Cannot read properties of null or undefined")));
+            }
+
+            get_primitive_prototype_property(mc, env, &obj_val, &key.as_str().into())
         }
         Expr::Index(obj_expr, key_expr) => {
             let obj_val = evaluate_expr(mc, env, obj_expr)?;
             let key_val = evaluate_expr(mc, env, key_expr)?;
 
-            if let Value::Object(obj) = obj_val {
-                let key = match key_val {
-                    Value::String(s) => PropertyKey::String(utf16_to_utf8(&s)),
-                    Value::Number(n) => PropertyKey::String(n.to_string()),
-                    _ => PropertyKey::String(value_to_string(&key_val)),
-                };
+            let key = match key_val {
+                Value::String(s) => PropertyKey::String(utf16_to_utf8(&s)),
+                Value::Number(n) => PropertyKey::String(n.to_string()),
+                _ => PropertyKey::String(value_to_string(&key_val)),
+            };
 
-                if let Some(val) = obj_get_key_value(&obj, &key)? {
-                    Ok(val.borrow().clone())
+            if let Value::Object(obj) = &obj_val {
+                if let Some(val) = obj_get_key_value(obj, &key)? {
+                    return Ok(val.borrow().clone());
                 } else {
-                    Ok(Value::Undefined)
+                    return Ok(Value::Undefined);
                 }
-            } else if matches!(obj_val, Value::Undefined | Value::Null) {
-                Err(EvalError::Js(raise_eval_error!("Cannot read properties of null or undefined")))
-            } else {
-                Ok(Value::Undefined)
             }
+
+            if matches!(obj_val, Value::Undefined | Value::Null) {
+                return Err(EvalError::Js(raise_eval_error!("Cannot read properties of null or undefined")));
+            }
+
+            get_primitive_prototype_property(mc, env, &obj_val, &key)
         }
         Expr::TemplateString(parts) => {
             let mut result = Vec::new();
diff --git a/src/core/value.rs b/src/core/value.rs
@@ -445,6 +445,74 @@ impl<'gc> std::fmt::Debug for Value<'gc> {
         }
     }
 }
+// Helper: perform ToPrimitive coercion with a given hint ('string', 'number', 'default')
+pub fn to_primitive<'gc>(val: &Value<'gc>, _hint: &str, _env: &JSObjectDataPtr<'gc>) -> Result<Value<'gc>, JSError> {
+    match val {
+        Value::Number(_) | Value::String(_) | Value::Boolean(_) | Value::Undefined | Value::Null | Value::Symbol(_) => Ok(val.clone()),
+        Value::Object(_object) => {
+            /*
+            // Prefer explicit [Symbol.toPrimitive] if present and callable
+            if let Some(tp_sym) = get_well_known_symbol_rc("toPrimitive") {
+                let key = PropertyKey::Symbol(tp_sym.clone());
+                if let Some(method_rc) = obj_get_key_value(object, &key)? {
+                    let method_val = method_rc.borrow().clone();
+                    // Accept direct closures or function-objects that wrap a closure
+                    if let Some((params, body, captured_env)) = extract_closure_from_value(&method_val) {
+                        // Pass hint as first param if the function declares params
+                        let args = vec![Value::String(utf8_to_utf16(hint))];
+                        let func_env = prepare_function_call_env(
+                            Some(&captured_env),
+                            Some(Value::Object(object.clone())),
+                            Some(&params),
+                            &args,
+                            None,
+                            None,
+                        )?;
+                        let result = evaluate_statements(&func_env, &body)?;
+                        match result {
+                            Value::Number(_) | Value::String(_) | Value::Boolean(_) | Value::BigInt(_) | Value::Symbol(_) => {
+                                return Ok(result);
+                            }
+                            _ => {
+                                return Err(raise_type_error!("[Symbol.toPrimitive] must return a primitive"));
+                            }
+                        }
+                    } else {
+                        // Not a closure/minimally supported callable - fall through to default algorithm
+                    }
+                }
+            }
+
+            // Default algorithm: order depends on hint
+            if hint == "string" {
+                // toString -> valueOf
+                let to_s = crate::js_object::handle_to_string_method(&Value::Object(object.clone()), &[], env)?;
+                if matches!(to_s, Value::String(_) | Value::Number(_) | Value::Boolean(_) | Value::BigInt(_)) {
+                    return Ok(to_s);
+                }
+                let val_of = crate::js_object::handle_value_of_method(&Value::Object(object.clone()), &[], env)?;
+                if matches!(val_of, Value::String(_) | Value::Number(_) | Value::Boolean(_) | Value::BigInt(_)) {
+                    return Ok(val_of);
+                }
+            } else {
+                // number or default: valueOf -> toString
+                let val_of = crate::js_object::handle_value_of_method(&Value::Object(object.clone()), &[], env)?;
+                if matches!(val_of, Value::Number(_) | Value::String(_) | Value::Boolean(_) | Value::BigInt(_)) {
+                    return Ok(val_of);
+                }
+                let to_s = crate::js_object::handle_to_string_method(&Value::Object(object.clone()), &[], env)?;
+                if matches!(to_s, Value::String(_) | Value::Number(_) | Value::Boolean(_) | Value::BigInt(_)) {
+                    return Ok(to_s);
+                }
+            }
+
+            Err(raise_type_error!("Cannot convert object to primitive"))
+            // */
+            todo!("to_primitive not yet implemented for objects");
+        }
+        _ => Ok(val.clone()),
+    }
+}
 
 pub fn value_to_string<'gc>(val: &Value<'gc>) -> String {
     match val {
diff --git a/src/js_bigint.rs b/src/js_bigint.rs
diff --git a/src/lib.rs b/src/lib.rs
