Implement Map and Set constructors with full API support

- Add JSMap and JSSet data structures to Value enum
- Implement Map constructor, set/get/has/delete/clear/size/keys/values/entries methods
- Implement Set constructor, add/has/delete/clear/size/values/keys/entries methods
- Add global Map and Set constructors to environment
- Update evaluation logic for property access (.size) and method calls
- Add console.log, toString, valueOf, and FFI support for Map/Set
- Add comprehensive test suite with 13 test cases

Author: ssrlive

examples/js.rs

@@ -67,6 +67,8 @@ fn print_eval_result(result: &Value) {
         Value::Promise(_) => println!("[object Promise]"),
         Value::Symbol(_) => println!("[object Symbol]"),
         Value::BigInt(s) => println!("{s}"),
+        Value::Map(_) => println!("[object Map]"),
+        Value::Set(_) => println!("[object Set]"),
     }
 }
 

src/core.rs

@@ -489,6 +489,18 @@ pub(crate) fn initialize_global_constructors(env: &JSObjectDataPtr) -> Result<()
         Rc::new(RefCell::new(Value::Function("Symbol".to_string()))),
     );
 
+    // Map constructor
+    env_borrow.insert(
+        PropertyKey::String("Map".to_string()),
+        Rc::new(RefCell::new(Value::Function("Map".to_string()))),
+    );
+
+    // Set constructor
+    env_borrow.insert(
+        PropertyKey::String("Set".to_string()),
+        Rc::new(RefCell::new(Value::Function("Set".to_string()))),
+    );
+
     // Create a few well-known symbols and store them in the well-known symbol registry
     WELL_KNOWN_SYMBOLS.with(|wk| {
         let mut map = wk.borrow_mut();

src/core/eval.rs

@@ -2731,6 +2731,8 @@ fn evaluate_typeof(env: &JSObjectDataPtr, expr: &Expr) -> Result<Value, JSError>
         Value::Property { .. } => "undefined",
         Value::Promise(_) => "object",
         Value::Symbol(_) => "symbol",
+        Value::Map(_) => "object",
+        Value::Set(_) => "object",
     };
     Ok(Value::String(utf8_to_utf16(type_str)))
 }
@@ -3647,6 +3649,8 @@ fn evaluate_property(env: &JSObjectDataPtr, obj: &Expr, prop: &str) -> Result<Va
         // coerce to a primitive wrapper or return undefined if not found. To
         // keep things simple, return undefined for boolean properties.
         Value::Boolean(_) => Ok(Value::Undefined),
+        Value::Map(map) if prop == "size" => Ok(Value::Number(map.borrow().entries.len() as f64)),
+        Value::Set(set) if prop == "size" => Ok(Value::Number(set.borrow().values.len() as f64)),
         _ => Err(raise_eval_error!(format!("Property not found for prop={prop}"))),
     }
 }
@@ -3778,6 +3782,8 @@ fn evaluate_call(env: &JSObjectDataPtr, func_expr: &Expr, args: &[Expr]) -> Resu
             // and Object.prototype functions act as fallbacks.
             (Value::Symbol(sd), "toString") => crate::js_object::handle_to_string_method(&Value::Symbol(sd.clone()), args),
             (Value::Symbol(sd), "valueOf") => crate::js_object::handle_value_of_method(&Value::Symbol(sd.clone()), args),
+            (Value::Map(map), method) => crate::js_map::handle_map_instance_method(&map, method, args, env),
+            (Value::Set(set), method) => crate::js_set::handle_set_instance_method(&set, method, args, env),
             (Value::Object(obj_map), method) => {
                 // Object prototype methods are supplied on `Object.prototype`.
                 // Lookups will find user-defined (own) methods before inherited

src/core/ffi.rs

@@ -943,6 +943,8 @@ pub unsafe fn JS_Eval(_ctx: *mut JSContext, input: *const i8, input_len: usize,
             Ok(Value::Promise(_)) => JS_UNDEFINED,            // For now
             Ok(Value::Symbol(_)) => JS_UNDEFINED,             // For now
             Ok(Value::BigInt(_)) => JS_UNDEFINED,
+            Ok(Value::Map(_)) => JS_UNDEFINED, // For now
+            Ok(Value::Set(_)) => JS_UNDEFINED, // For now
             Err(_) => JS_UNDEFINED,
         }
     }

src/core/value.rs

@@ -9,6 +9,16 @@ use crate::{
     raise_type_error,
 };
 
+#[derive(Clone, Debug)]
+pub struct JSMap {
+    pub entries: Vec<(Value, Value)>, // key-value pairs
+}
+
+#[derive(Clone, Debug)]
+pub struct JSSet {
+    pub values: Vec<Value>,
+}
+
 pub type JSObjectDataPtr = Rc<RefCell<JSObjectData>>;
 
 #[derive(Clone, Default)]
@@ -94,6 +104,8 @@ pub enum Value {
     },
     Promise(Rc<RefCell<JSPromise>>), // Promise object
     Symbol(Rc<SymbolData>),          // Symbol primitive with description
+    Map(Rc<RefCell<JSMap>>),         // Map object
+    Set(Rc<RefCell<JSSet>>),         // Set object
 }
 
 impl std::fmt::Debug for Value {
@@ -114,6 +126,8 @@ impl std::fmt::Debug for Value {
             Value::Property { .. } => write!(f, "Property"),
             Value::Promise(p) => write!(f, "Promise({:p})", Rc::as_ptr(p)),
             Value::Symbol(_) => write!(f, "Symbol"),
+            Value::Map(m) => write!(f, "Map({:p})", Rc::as_ptr(m)),
+            Value::Set(s) => write!(f, "Set({:p})", Rc::as_ptr(s)),
         }
     }
 }
@@ -149,6 +163,8 @@ pub fn is_truthy(val: &Value) -> bool {
         Value::Property { .. } => true,
         Value::Promise(_) => true,
         Value::Symbol(_) => true,
+        Value::Map(_) => true,
+        Value::Set(_) => true,
     }
 }
 
@@ -187,6 +203,8 @@ pub fn value_to_string(val: &Value) -> String {
             Some(d) => format!("Symbol({})", d),
             None => "Symbol()".to_string(),
         },
+        Value::Map(_) => "[object Map]".to_string(),
+        Value::Set(_) => "[object Set]".to_string(),
     }
 }
 
@@ -281,6 +299,8 @@ pub fn value_to_sort_string(val: &Value) -> String {
         Value::Property { .. } => "[property]".to_string(),
         Value::Promise(_) => "[object Promise]".to_string(),
         Value::Symbol(_) => "[object Symbol]".to_string(),
+        Value::Map(_) => "[object Map]".to_string(),
+        Value::Set(_) => "[object Set]".to_string(),
     }
 }
 

src/js_class.rs

@@ -168,6 +168,8 @@ pub(crate) fn evaluate_new(env: &JSObjectDataPtr, constructor: &Expr, args: &[Ex
                 "Promise" => {
                     return crate::js_promise::handle_promise_constructor(args, env);
                 }
+                "Map" => return crate::js_map::handle_map_constructor(args, env),
+                "Set" => return crate::js_set::handle_set_constructor(args, env),
                 "MockIntlConstructor" => {
                     // Handle mock Intl constructor for testing
                     let locale_arg = if !args.is_empty() {
@@ -664,6 +666,8 @@ pub(crate) fn handle_string_constructor(args: &[Expr], env: &JSObjectDataPtr) ->
             Value::Promise(_) => utf8_to_utf16("[object Promise]"),
             Value::Symbol(_) => utf8_to_utf16("[object Symbol]"),
             Value::BigInt(s) => utf8_to_utf16(&s),
+            Value::Map(_) => utf8_to_utf16("[object Map]"),
+            Value::Set(_) => utf8_to_utf16("[object Set]"),
         }
     };
 

src/js_console.rs

@@ -105,6 +105,8 @@ pub fn handle_console_method(method: &str, args: &[Expr], env: &JSObjectDataPtr)
                     }
                     Value::Promise(_) => print!("[object Promise]"),
                     Value::Symbol(_) => print!("[object Symbol]"),
+                    Value::Map(_) => print!("[object Map]"),
+                    Value::Set(_) => print!("[object Set]"),
                 }
                 if i < count - 1 {
                     print!(" ");

src/js_function.rs

@@ -77,6 +77,8 @@ pub fn handle_global_function(func_name: &str, args: &[Expr], env: &JSObjectData
                         None => Ok(Value::String(utf8_to_utf16("Symbol()"))),
                     },
                     Value::BigInt(s) => Ok(Value::String(utf8_to_utf16(&s))),
+                    Value::Map(_) => Ok(Value::String(utf8_to_utf16("[object Map]"))),
+                    Value::Set(_) => Ok(Value::String(utf8_to_utf16("[object Set]"))),
                 }
             } else {
                 Ok(Value::String(Vec::new())) // String() with no args returns empty string

src/js_map.rs

@@ -0,0 +1,193 @@
+use crate::{
+    core::{Expr, JSObjectData, JSObjectDataPtr, PropertyKey, Value, evaluate_expr, obj_set_value},
+    error::JSError,
+    raise_eval_error,
+};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use crate::core::JSMap;
+
+/// Handle Map constructor calls
+pub(crate) fn handle_map_constructor(args: &[Expr], env: &JSObjectDataPtr) -> Result<Value, JSError> {
+    let map = Rc::new(RefCell::new(JSMap { entries: Vec::new() }));
+
+    if !args.is_empty() {
+        if args.len() == 1 {
+            // Map(iterable)
+            let iterable = evaluate_expr(env, &args[0])?;
+            match iterable {
+                Value::Object(obj) => {
+                    // Try to iterate over the object
+                    // For now, assume it's an array-like or has entries
+                    // TODO: Implement proper iteration protocol
+                    let mut i = 0;
+                    loop {
+                        let key = format!("{}", i);
+                        if let Some(entry_val) = obj_get_value(&obj, &key.into())? {
+                            let entry = entry_val.borrow().clone();
+                            if let Value::Object(entry_obj) = entry
+                                && let (Some(key_val), Some(value_val)) =
+                                    (obj_get_value(&entry_obj, &"0".into())?, obj_get_value(&entry_obj, &"1".into())?)
+                            {
+                                map.borrow_mut()
+                                    .entries
+                                    .push((key_val.borrow().clone(), value_val.borrow().clone()));
+                            }
+                        } else {
+                            break;
+                        }
+                        i += 1;
+                    }
+                }
+                _ => {
+                    return Err(raise_eval_error!("Map constructor requires an iterable"));
+                }
+            }
+        } else {
+            return Err(raise_eval_error!("Map constructor takes at most one argument"));
+        }
+    }
+
+    Ok(Value::Map(map))
+}
+
+/// Handle Map instance method calls
+pub(crate) fn handle_map_instance_method(
+    map: &Rc<RefCell<JSMap>>,
+    method: &str,
+    args: &[Expr],
+    env: &JSObjectDataPtr,
+) -> Result<Value, JSError> {
+    match method {
+        "set" => {
+            if args.len() != 2 {
+                return Err(raise_eval_error!("Map.prototype.set requires exactly two arguments"));
+            }
+            let key = evaluate_expr(env, &args[0])?;
+            let value = evaluate_expr(env, &args[1])?;
+
+            // Remove existing entry with same key
+            map.borrow_mut().entries.retain(|(k, _)| !values_equal(k, &key));
+            // Add new entry
+            map.borrow_mut().entries.push((key, value));
+
+            Ok(Value::Map(map.clone()))
+        }
+        "get" => {
+            if args.len() != 1 {
+                return Err(raise_eval_error!("Map.prototype.get requires exactly one argument"));
+            }
+            let key = evaluate_expr(env, &args[0])?;
+
+            for (k, v) in &map.borrow().entries {
+                if values_equal(k, &key) {
+                    return Ok(v.clone());
+                }
+            }
+            Ok(Value::Undefined)
+        }
+        "has" => {
+            if args.len() != 1 {
+                return Err(raise_eval_error!("Map.prototype.has requires exactly one argument"));
+            }
+            let key = evaluate_expr(env, &args[0])?;
+
+            let has_key = map.borrow().entries.iter().any(|(k, _)| values_equal(k, &key));
+            Ok(Value::Boolean(has_key))
+        }
+        "delete" => {
+            if args.len() != 1 {
+                return Err(raise_eval_error!("Map.prototype.delete requires exactly one argument"));
+            }
+            let key = evaluate_expr(env, &args[0])?;
+
+            let initial_len = map.borrow().entries.len();
+            map.borrow_mut().entries.retain(|(k, _)| !values_equal(k, &key));
+            let deleted = map.borrow().entries.len() < initial_len;
+
+            Ok(Value::Boolean(deleted))
+        }
+        "clear" => {
+            if !args.is_empty() {
+                return Err(raise_eval_error!("Map.prototype.clear takes no arguments"));
+            }
+            map.borrow_mut().entries.clear();
+            Ok(Value::Undefined)
+        }
+        "size" => {
+            if !args.is_empty() {
+                return Err(raise_eval_error!("Map.prototype.size is a getter"));
+            }
+            Ok(Value::Number(map.borrow().entries.len() as f64))
+        }
+        "keys" => {
+            if !args.is_empty() {
+                return Err(raise_eval_error!("Map.prototype.keys takes no arguments"));
+            }
+            // Create an array of keys
+            let keys_array = Rc::new(RefCell::new(JSObjectData::new()));
+            for (i, (key, _)) in map.borrow().entries.iter().enumerate() {
+                obj_set_value(&keys_array, &i.to_string().into(), key.clone())?;
+            }
+            // Set length
+            obj_set_value(&keys_array, &"length".into(), Value::Number(map.borrow().entries.len() as f64))?;
+            Ok(Value::Object(keys_array))
+        }
+        "values" => {
+            if !args.is_empty() {
+                return Err(raise_eval_error!("Map.prototype.values takes no arguments"));
+            }
+            // Create an array of values
+            let values_array = Rc::new(RefCell::new(JSObjectData::new()));
+            for (i, (_, value)) in map.borrow().entries.iter().enumerate() {
+                obj_set_value(&values_array, &i.to_string().into(), value.clone())?;
+            }
+            // Set length
+            obj_set_value(&values_array, &"length".into(), Value::Number(map.borrow().entries.len() as f64))?;
+            Ok(Value::Object(values_array))
+        }
+        "entries" => {
+            if !args.is_empty() {
+                return Err(raise_eval_error!("Map.prototype.entries takes no arguments"));
+            }
+            // Create an array of [key, value] pairs
+            let entries_array = Rc::new(RefCell::new(JSObjectData::new()));
+            for (i, (key, value)) in map.borrow().entries.iter().enumerate() {
+                let entry_array = Rc::new(RefCell::new(JSObjectData::new()));
+                obj_set_value(&entry_array, &"0".into(), key.clone())?;
+                obj_set_value(&entry_array, &"1".into(), value.clone())?;
+                obj_set_value(&entry_array, &"length".into(), Value::Number(2.0))?;
+                obj_set_value(&entries_array, &i.to_string().into(), Value::Object(entry_array))?;
+            }
+            // Set length
+            obj_set_value(&entries_array, &"length".into(), Value::Number(map.borrow().entries.len() as f64))?;
+            Ok(Value::Object(entries_array))
+        }
+        _ => Err(raise_eval_error!(format!("Map.prototype.{} is not implemented", method))),
+    }
+}
+
+// Helper function to compare two values for equality (simplified version)
+fn values_equal(a: &Value, b: &Value) -> bool {
+    match (a, b) {
+        (Value::Number(na), Value::Number(nb)) => na == nb,
+        (Value::String(sa), Value::String(sb)) => sa == sb,
+        (Value::Boolean(ba), Value::Boolean(bb)) => ba == bb,
+        (Value::Undefined, Value::Undefined) => true,
+        (Value::Symbol(sa), Value::Symbol(sb)) => Rc::ptr_eq(sa, sb),
+        _ => false, // For objects, we use reference equality
+    }
+}
+
+// Helper function to get object property value
+fn obj_get_value(js_obj: &JSObjectDataPtr, key: &PropertyKey) -> Result<Option<Rc<RefCell<Value>>>, JSError> {
+    let mut current: Option<JSObjectDataPtr> = Some(js_obj.clone());
+    while let Some(cur) = current {
+        if let Some(val) = cur.borrow().properties.get(key) {
+            return Ok(Some(val.clone()));
+        }
+        current = cur.borrow().prototype.clone();
+    }
+    Ok(None)
+}

src/js_object.rs

@@ -293,6 +293,8 @@ pub(crate) fn handle_to_string_method(obj_val: &Value, args: &[Expr]) -> Result<
                 Value::Property { .. } => "Property",
                 Value::Promise(_) => "Promise",
                 Value::Symbol(_) => "Symbol",
+                Value::Map(_) => "Map",
+                Value::Set(_) => "Set",
             },
             args.len()
         )));
@@ -363,6 +365,8 @@ pub(crate) fn handle_to_string_method(obj_val: &Value, args: &[Expr]) -> Result<
             let desc_str = symbol_data.description.as_deref().unwrap_or("");
             Ok(Value::String(utf8_to_utf16(&format!("Symbol({})", desc_str))))
         }
+        Value::Map(_) => Ok(Value::String(utf8_to_utf16("[object Map]"))),
+        Value::Set(_) => Ok(Value::String(utf8_to_utf16("[object Set]"))),
     }
 }
 
@@ -385,6 +389,8 @@ pub(crate) fn handle_value_of_method(obj_val: &Value, args: &[Expr]) -> Result<V
                 &Value::Promise(_) => "Promise",
                 Value::BigInt(_) => "BigInt",
                 Value::Symbol(_) => "Symbol",
+                Value::Map(_) => "Map",
+                Value::Set(_) => "Set",
             },
             args.len()
         )));
@@ -421,5 +427,7 @@ pub(crate) fn handle_value_of_method(obj_val: &Value, args: &[Expr]) -> Result<V
         }),
         Value::Promise(promise) => Ok(Value::Promise(promise.clone())),
         Value::Symbol(symbol_data) => Ok(Value::Symbol(symbol_data.clone())),
+        Value::Map(map) => Ok(Value::Map(map.clone())),
+        Value::Set(set) => Ok(Value::Set(set.clone())),
     }
 }