Implement Map and MapIterator

- Enable `js_map` module and initialize `Map` global.
- Refactor `initialize_collection_from_iterable` to accept evaluated `Value`s.
- Implement `Map` constructor, instance methods, and `size` getter.
- Implement `MapIterator` for `keys()`, `values()`, and `entries()`.
- Add native function call hooks in `eval.rs` to support Map methods and accessors.
- Add `Expr::New` support for `Map`.

Author: ssrlive

js-scripts/map_tests.js

@@ -0,0 +1,40 @@
+let map = new Map();
+console.log(map.size); // should be 0
+map.set('a', 1);
+console.log(map.size); // should be 1
+console.log(map.get('a')); // 1
+console.log(map.has('a')); // true
+console.log(map.has('b')); // false
+map.set('a', 2);
+console.log(map.get('a')); // 2
+
+map.delete('a');
+console.log(map.size); // should be 0
+
+let map2 = new Map();
+console.log(map2.size); // 0
+
+var map3 = new Map([ ['x', 10], ['y', 20] ]);
+console.log("map3 size", map3.size); // 2
+console.log("map3 x", map3.get('x')); // 10
+console.log("map3 y", map3.get('y')); // 20
+console.log("map3 has x", map3.has('x')); // true
+
+const iterator = map3.keys();
+console.log(iterator.next().value); // 'x'
+console.log(iterator.next().value); // 'y'
+console.log(iterator.next().done); // true
+
+const entriesIterator = map3.entries();
+console.log(entriesIterator.next().value); // ['x', 10]
+console.log(entriesIterator.next().value); // ['y', 20]
+console.log(entriesIterator.next().done); // true
+
+const valuesIterator = map3.values();
+console.log(valuesIterator.next().value); // 10
+console.log(valuesIterator.next().value); // 20
+console.log(valuesIterator.next().done); // true
+
+console.log("All tests passed");
+
+true

src/core/eval.rs

@@ -1029,6 +1029,9 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
 
             match func_val {
                 Value::Function(name) => {
+                    if let Some(res) = call_native_function(mc, &name, this_val.clone(), &eval_args, env)? {
+                        return Ok(res);
+                    }
                     if name == "eval" {
                         let first_arg = eval_args.get(0).cloned().unwrap_or(Value::Undefined);
                         if let Value::String(script_str) = first_arg {
@@ -1178,6 +1181,33 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                             let method = &name[6..];
                             Ok(handle_array_static_method(mc, method, &eval_args, env)?)
                         }
+                    } else if name.starts_with("Map.") {
+                        if let Some(method) = name.strip_prefix("Map.prototype.") {
+                            let this_v = this_val.clone().unwrap_or(Value::Undefined);
+                            if let Value::Object(obj) = this_v {
+                                if let Some(map_val) = obj_get_key_value(&obj, &"__map__".into())? {
+                                    if let Value::Map(map_ptr) = &*map_val.borrow() {
+                                        Ok(crate::js_map::handle_map_instance_method(mc, map_ptr, method, &eval_args, env)?)
+                                    } else {
+                                        Err(EvalError::Js(raise_eval_error!(
+                                            "TypeError: Map.prototype method called on incompatible receiver"
+                                        )))
+                                    }
+                                } else {
+                                    Err(EvalError::Js(raise_eval_error!(
+                                        "TypeError: Map.prototype method called on incompatible receiver"
+                                    )))
+                                }
+                            } else if let Value::Map(map_ptr) = this_v {
+                                Ok(crate::js_map::handle_map_instance_method(mc, &map_ptr, method, &eval_args, env)?)
+                            } else {
+                                Err(EvalError::Js(raise_eval_error!(
+                                    "TypeError: Map.prototype method called on non-object receiver"
+                                )))
+                            }
+                        } else {
+                            Err(EvalError::Js(raise_eval_error!(format!("Unknown Map function: {}", name))))
+                        }
                     } else {
                         Err(EvalError::Js(raise_eval_error!(format!("Unknown native function: {}", name))))
                     }
@@ -1438,6 +1468,8 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                                     return Ok(Value::Object(new_obj));
                                 } else if name == &crate::unicode::utf8_to_utf16("Date") {
                                     return Ok(crate::js_date::handle_date_constructor(mc, &eval_args, env)?);
+                                } else if name == &crate::unicode::utf8_to_utf16("Map") {
+                                    return Ok(crate::js_map::handle_map_constructor(mc, &eval_args, env)?);
                                 }
                             }
                         }
@@ -1689,7 +1721,7 @@ fn evaluate_function_expression<'gc>(
 
 fn get_property_with_accessors<'gc>(
     mc: &MutationContext<'gc>,
-    _env: &JSObjectDataPtr<'gc>,
+    env: &JSObjectDataPtr<'gc>,
     obj: &JSObjectDataPtr<'gc>,
     key: &PropertyKey<'gc>,
 ) -> Result<Value<'gc>, EvalError<'gc>> {
@@ -1698,14 +1730,14 @@ fn get_property_with_accessors<'gc>(
         match val {
             Value::Property { getter, value, .. } => {
                 if let Some(g) = getter {
-                    return call_accessor(mc, obj, &*g);
+                    return call_accessor(mc, env, obj, &*g);
                 }
                 if let Some(v) = value {
                     return Ok(v.borrow().clone());
                 }
                 Ok(Value::Undefined)
             }
-            Value::Getter(..) => call_accessor(mc, obj, &val),
+            Value::Getter(..) => call_accessor(mc, env, obj, &val),
             _ => Ok(val),
         }
     } else {
@@ -1750,12 +1782,74 @@ fn set_property_with_accessors<'gc>(
     }
 }
 
+fn call_native_function<'gc>(
+    mc: &MutationContext<'gc>,
+    name: &str,
+    this_val: Option<Value<'gc>>,
+    args: &[Value<'gc>],
+    env: &JSObjectDataPtr<'gc>,
+) -> Result<Option<Value<'gc>>, EvalError<'gc>> {
+    if name == "MapIterator.prototype.next" {
+        let this_v = this_val.clone().unwrap_or(Value::Undefined);
+        if let Value::Object(obj) = this_v {
+            return Ok(Some(crate::js_map::handle_map_iterator_next(mc, &obj, env).map_err(EvalError::Js)?));
+        } else {
+            return Err(EvalError::Js(raise_eval_error!(
+                "TypeError: MapIterator.prototype.next called on non-object"
+            )));
+        }
+    }
+
+    if name.starts_with("Map.") {
+        if let Some(method) = name.strip_prefix("Map.prototype.") {
+            let this_v = this_val.clone().unwrap_or(Value::Undefined);
+            if let Value::Object(obj) = this_v {
+                if let Some(map_val) = crate::core::obj_get_key_value(&obj, &"__map__".into()).map_err(EvalError::Js)? {
+                    if let Value::Map(map_ptr) = &*map_val.borrow() {
+                        return Ok(Some(
+                            crate::js_map::handle_map_instance_method(mc, map_ptr, method, args, env).map_err(EvalError::Js)?,
+                        ));
+                    } else {
+                        return Err(EvalError::Js(raise_eval_error!(
+                            "TypeError: Map.prototype method called on incompatible receiver"
+                        )));
+                    }
+                } else {
+                    return Err(EvalError::Js(raise_eval_error!(
+                        "TypeError: Map.prototype method called on incompatible receiver"
+                    )));
+                }
+            } else if let Value::Map(map_ptr) = this_v {
+                return Ok(Some(
+                    crate::js_map::handle_map_instance_method(mc, &map_ptr, method, args, env).map_err(EvalError::Js)?,
+                ));
+            } else {
+                return Err(EvalError::Js(raise_eval_error!(
+                    "TypeError: Map.prototype method called on non-object receiver"
+                )));
+            }
+        }
+    }
+    Ok(None)
+}
+
 fn call_accessor<'gc>(
     mc: &MutationContext<'gc>,
+    env: &JSObjectDataPtr<'gc>,
     receiver: &JSObjectDataPtr<'gc>,
     accessor: &Value<'gc>,
 ) -> Result<Value<'gc>, EvalError<'gc>> {
     match accessor {
+        Value::Function(name) => {
+            if let Some(res) = call_native_function(mc, name, Some(Value::Object(*receiver)), &[], env)? {
+                Ok(res)
+            } else {
+                Err(EvalError::Js(crate::raise_type_error!(format!(
+                    "Accessor function {} not supported",
+                    name
+                ))))
+            }
+        }
         Value::Getter(body, captured_env, _) => {
             let call_env = crate::core::new_js_object_data(mc);
             call_env.borrow_mut(mc).prototype = Some(*captured_env);

src/core/mod.rs

@@ -4,6 +4,7 @@ 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_map::initialize_map;
 use crate::js_math::initialize_math;
 use crate::js_number::initialize_number_module;
 use crate::js_regexp::initialize_regexp;
@@ -84,6 +85,7 @@ pub fn initialize_global_constructors<'gc>(mc: &MutationContext<'gc>, env: &JSOb
     initialize_date(mc, env)?;
     initialize_bigint(mc, env)?;
     initialize_json(mc, env)?;
+    initialize_map(mc, env)?;
 
     env_set(mc, env, "undefined", Value::Undefined)?;
     env_set(mc, env, "NaN", Value::Number(f64::NAN))?;
@@ -208,14 +210,7 @@ pub fn set_internal_prototype_from_constructor<'gc>(
 
 // Helper to initialize a collection from an iterable argument.
 // Used by Map, Set, WeakMap, WeakSet constructors.
-#[allow(dead_code)]
-pub fn initialize_collection_from_iterable<'gc, F>(
-    mc: &MutationContext<'gc>,
-    args: &[Expr],
-    env: &JSObjectDataPtr<'gc>,
-    constructor_name: &str,
-    mut process_item: F,
-) -> Result<(), JSError>
+pub fn initialize_collection_from_iterable<'gc, F>(args: &[Value<'gc>], constructor_name: &str, mut process_item: F) -> Result<(), JSError>
 where
     F: FnMut(Value<'gc>) -> Result<(), JSError>,
 {
@@ -226,12 +221,7 @@ where
         let msg = format!("{constructor_name} constructor takes at most one argument",);
         return Err(raise_eval_error!(msg));
     }
-    let iterable = evaluate_expr(mc, env, &args[0]).map_err(|e| match e {
-        crate::core::js_error::EvalError::Js(e) => e,
-        crate::core::js_error::EvalError::Throw(val, _, _) => {
-            crate::raise_eval_error!(format!("Uncaught exception: {:?}", val))
-        }
-    })?;
+    let iterable = args[0].clone();
     match iterable {
         Value::Object(obj) => {
             let mut i = 0;