Implement JSON object and integrate it into the engine

- Add js_json.rs with JSON.parse and JSON.stringify implementation.
- Register JSON object in initialize_global_constructors.
- Add dispatch logic for JSON methods in eval.rs.
- Refactor array literal evaluation to use create_array to ensure correct array prototype and internal flags.

Author: ssrlive

src/core/eval.rs

@@ -1,9 +1,10 @@
 #![allow(warnings)]
 
 use crate::core::{Gc, GcCell, MutationContext};
-use crate::js_array::{handle_array_static_method, is_array};
+use crate::js_array::{create_array, handle_array_static_method, is_array, set_array_length};
 use crate::js_bigint::bigint_constructor;
 use crate::js_date::{handle_date_method, handle_date_static_method, is_date_object};
+use crate::js_json::handle_json_method;
 use crate::js_number::{handle_number_instance_method, handle_number_prototype_method, handle_number_static_method, number_constructor};
 use crate::js_string::{string_from_char_code, string_from_code_point, string_raw};
 use crate::{
@@ -986,24 +987,15 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
             Ok(Value::Object(obj))
         }
         Expr::Array(elements) => {
-            let arr_obj = crate::core::new_js_object_data(mc);
-            if let Ok(Value::Object(arr_ctor)) = evaluate_var(mc, env, "Array") {
-                if let Some(proto_val) = obj_get_key_value(&arr_ctor, &"prototype".into())? {
-                    if let Value::Object(proto) = &*proto_val.borrow() {
-                        arr_obj.borrow_mut(mc).prototype = Some(*proto);
-                    }
-                }
-            }
+            let arr_obj = create_array(mc, env)?;
 
-            let mut len = 0;
             for (i, elem_opt) in elements.iter().enumerate() {
                 if let Some(elem) = elem_opt {
                     let val = evaluate_expr(mc, env, elem)?;
                     obj_set_key_value(mc, &arr_obj, &i.to_string().into(), val)?;
                 }
-                len = i + 1;
             }
-            obj_set_key_value(mc, &arr_obj, &"length".into(), Value::Number(len as f64))?;
+            set_array_length(mc, &arr_obj, elements.len())?;
             Ok(Value::Object(arr_obj))
         }
         Expr::Function(name, params, body) => {
@@ -1115,6 +1107,8 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                         Ok(handle_number_static_method(method, &eval_args).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("JSON.") {
+                        Ok(handle_json_method(mc, method, &eval_args, env).map_err(EvalError::Js)?)
                     } else if let Some(method) = name.strip_prefix("Date.prototype.") {
                         if let Some(this_obj) = this_val {
                             Ok(handle_date_method(mc, &this_obj, method, &eval_args, env).map_err(EvalError::Js)?)

src/core/mod.rs

@@ -3,6 +3,7 @@ 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_json::initialize_json;
 use crate::js_math::initialize_math;
 use crate::js_number::initialize_number_module;
 use crate::js_regexp::initialize_regexp;
@@ -82,6 +83,7 @@ pub fn initialize_global_constructors<'gc>(mc: &MutationContext<'gc>, env: &JSOb
     // Initialize Date constructor and prototype
     initialize_date(mc, env)?;
     initialize_bigint(mc, env)?;
+    initialize_json(mc, env)?;
 
     env_set(mc, env, "undefined", Value::Undefined)?;
     env_set(mc, env, "NaN", Value::Number(f64::NAN))?;

src/js_json.rs

@@ -1,19 +1,33 @@
-use crate::core::{Collect, Gc, GcCell, GcPtr, MutationContext, Trace};
-use crate::core::{Expr, JSObjectDataPtr, PropertyKey, Value, evaluate_expr, get_own_property, new_js_object_data, obj_set_key_value};
+use crate::core::MutationContext;
+use crate::core::{JSObjectDataPtr, PropertyKey, Value, env_set, get_own_property, new_js_object_data, obj_set_key_value};
 use crate::error::JSError;
 use crate::js_array::{get_array_length, is_array, set_array_length};
 use crate::unicode::{utf8_to_utf16, utf16_to_utf8};
 
+pub fn initialize_json<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>) -> Result<(), JSError> {
+    let json_obj = new_js_object_data(mc);
+
+    obj_set_key_value(mc, &json_obj, &"parse".into(), Value::Function("JSON.parse".to_string()))?;
+    obj_set_key_value(mc, &json_obj, &"stringify".into(), Value::Function("JSON.stringify".to_string()))?;
+
+    // JSON object usually has [Symbol.toStringTag] = "JSON"
+    // obj_set_key_value(mc, &json_obj, &crate::core::PropertyKey::from("Symbol.toStringTag"), Value::String(utf8_to_utf16("JSON")))?;
+    // We can skip that for now if not strictly required, or add it if Symbol is supported.
+
+    env_set(mc, env, "JSON", Value::Object(json_obj))?;
+    Ok(())
+}
+
 pub fn handle_json_method<'gc>(
     mc: &MutationContext<'gc>,
     method: &str,
-    args: &[Expr],
+    args: &[Value<'gc>],
     env: &JSObjectDataPtr<'gc>,
 ) -> Result<Value<'gc>, JSError> {
     match method {
         "parse" => {
-            if args.len() == 1 {
-                let arg_val = evaluate_expr(mc, env, &args[0])?;
+            if args.len() >= 1 {
+                let arg_val = &args[0];
                 match arg_val {
                     Value::String(s) => {
                         let json_str = utf16_to_utf8(&s);
@@ -29,9 +43,9 @@ pub fn handle_json_method<'gc>(
             }
         }
         "stringify" => {
-            if args.len() == 1 {
-                let arg_val = evaluate_expr(mc, env, &args[0])?;
-                match js_value_to_json_value(mc, arg_val) {
+            if args.len() >= 1 {
+                let arg_val = &args[0];
+                match js_value_to_json_value(mc, arg_val.clone()) {
                     Some(json_value) => match serde_json::to_string(&json_value) {
                         Ok(json_str) => {
                             log::debug!("JSON.stringify produced: {}", json_str);

src/lib.rs

@@ -11,7 +11,7 @@ pub(crate) mod js_console;
 pub(crate) mod js_date;
 // pub(crate) mod js_function;
 // pub(crate) mod js_generator;
-// pub(crate) mod js_json;
+pub(crate) mod js_json;
 // pub(crate) mod js_map;
 pub(crate) mod js_math;
 pub(crate) mod js_module;