Implement Proxy constructor with revocable support

- Add JSProxy struct and Value::Proxy variant
- Implement proxy wrapper objects with __proxy__ property
- Add Proxy constructor and Proxy.revocable static method
- Implement get and set traps for property access
- Add special handling for revoke function calls
- Update all relevant functions to handle Proxy values
- Add comprehensive tests for basic proxy and revocable functionality

Author: ssrlive

examples/js.rs

@@ -73,6 +73,7 @@ fn print_eval_result(result: &Value) {
         Value::WeakSet(_) => println!("[object WeakSet]"),
         Value::GeneratorFunction(_, _, _) => println!("[GeneratorFunction]"),
         Value::Generator(_) => println!("[object Generator]"),
+        Value::Proxy(_) => println!("[object Proxy]"),
     }
 }
 

src/core.rs

@@ -383,7 +383,7 @@ pub(crate) fn filter_input_script(script: &str) -> String {
 }
 
 /// Initialize global built-in constructors in the environment
-pub(crate) fn initialize_global_constructors(env: &JSObjectDataPtr) -> Result<(), JSError> {
+pub fn initialize_global_constructors(env: &JSObjectDataPtr) -> Result<(), JSError> {
     let mut env_borrow = env.borrow_mut();
 
     // Object constructor (object with static methods) and Object.prototype
@@ -504,6 +504,12 @@ pub(crate) fn initialize_global_constructors(env: &JSObjectDataPtr) -> Result<()
         Rc::new(RefCell::new(Value::Function("Set".to_string()))),
     );
 
+    // Proxy constructor
+    env_borrow.insert(
+        PropertyKey::String("Proxy".to_string()),
+        Rc::new(RefCell::new(Value::Function("Proxy".to_string()))),
+    );
+
     // WeakMap constructor
     env_borrow.insert(
         PropertyKey::String("WeakMap".to_string()),

src/core/eval.rs

@@ -2038,6 +2038,16 @@ fn evaluate_var(env: &JSObjectDataPtr, name: &str) -> Result<Value, JSError> {
         let v = Value::Function("Promise".to_string());
         log::trace!("evaluate_var - {} -> {:?}", name, v);
         Ok(v)
+    } else if name == "Proxy" {
+        // Return the Proxy constructor (we store it in the global environment)
+        if let Some(val_rc) = obj_get_value(env, &"Proxy".into())? {
+            let resolved = val_rc.borrow().clone();
+            log::trace!("evaluate_var - {} -> {:?}", name, resolved);
+            return Ok(resolved);
+        }
+        let v = Value::Function("Proxy".to_string());
+        log::trace!("evaluate_var - {} -> {:?}", name, v);
+        Ok(v)
     } else if name == "new" {
         let v = Value::Function("new".to_string());
         log::trace!("evaluate_var - {} -> {:?}", name, v);
@@ -2835,6 +2845,7 @@ fn evaluate_typeof(env: &JSObjectDataPtr, expr: &Expr) -> Result<Value, JSError>
         Value::WeakMap(_) => "object",
         Value::WeakSet(_) => "object",
         Value::Generator(_) => "object",
+        Value::Proxy(_) => "object",
     };
     Ok(Value::String(utf8_to_utf16(type_str)))
 }
@@ -2850,7 +2861,7 @@ fn evaluate_delete(env: &JSObjectDataPtr, expr: &Expr) -> Result<Value, JSError>
             let obj_val = evaluate_expr(env, obj)?;
             match obj_val {
                 Value::Object(obj_map) => {
-                    let deleted = obj_delete(&obj_map, &prop.into());
+                    let deleted = obj_delete(&obj_map, &prop.into())?;
                     Ok(Value::Boolean(deleted))
                 }
                 _ => Ok(Value::Boolean(false)),
@@ -2863,17 +2874,17 @@ fn evaluate_delete(env: &JSObjectDataPtr, expr: &Expr) -> Result<Value, JSError>
             match (obj_val, idx_val) {
                 (Value::Object(obj_map), Value::String(s)) => {
                     let key = PropertyKey::String(String::from_utf16_lossy(&s));
-                    let deleted = obj_delete(&obj_map, &key);
+                    let deleted = obj_delete(&obj_map, &key)?;
                     Ok(Value::Boolean(deleted))
                 }
                 (Value::Object(obj_map), Value::Number(n)) => {
                     let key = PropertyKey::String(n.to_string());
-                    let deleted = obj_delete(&obj_map, &key);
+                    let deleted = obj_delete(&obj_map, &key)?;
                     Ok(Value::Boolean(deleted))
                 }
                 (Value::Object(obj_map), Value::Symbol(sym)) => {
                     let key = PropertyKey::Symbol(Rc::new(RefCell::new(Value::Symbol(sym))));
-                    let deleted = obj_delete(&obj_map, &key);
+                    let deleted = obj_delete(&obj_map, &key)?;
                     Ok(Value::Boolean(deleted))
                 }
                 _ => Ok(Value::Boolean(false)),
@@ -3726,6 +3737,12 @@ fn evaluate_property(env: &JSObjectDataPtr, obj: &Expr, prop: &str) -> Result<Va
                 Ok(Value::Undefined)
             }
         }
+        // Special cases for wrapped Generator objects
+        Value::Object(obj_map)
+            if obj_map.borrow().contains_key(&"__generator__".into()) && (prop == "next" || prop == "return" || prop == "throw") =>
+        {
+            Ok(Value::Function(format!("Generator.prototype.{}", prop)))
+        }
         Value::Object(obj_map) => {
             // Special-case the `__proto__` accessor so property reads return the
             // object's current prototype object when present.
@@ -3762,6 +3779,8 @@ fn evaluate_property(env: &JSObjectDataPtr, obj: &Expr, prop: &str) -> Result<Va
                         "Property not found for Symbol constructor property: {prop}"
                     )))
                 });
+            } else if func_name == "Proxy" && prop == "revocable" {
+                return Ok(Value::Function("Proxy.revocable".to_string()));
             }
 
             Err(raise_eval_error!(format!("Property not found for prop={prop}")))
@@ -3891,6 +3910,14 @@ fn evaluate_call(env: &JSObjectDataPtr, func_expr: &Expr, args: &[Expr]) -> Resu
             return handle_symbol_static_method(method_name, args, env);
         }
 
+        // Special case for Proxy static methods
+        if let Expr::Var(var_name) = &**obj_expr
+            && var_name == "Proxy"
+            && method_name == "revocable"
+        {
+            return crate::js_proxy::handle_proxy_revocable(args, env);
+        }
+
         let obj_val = evaluate_expr(env, obj_expr)?;
         log::trace!("evaluate_call - object evaluated");
         match (obj_val, method_name.as_str()) {
@@ -3926,6 +3953,15 @@ fn evaluate_call(env: &JSObjectDataPtr, func_expr: &Expr, args: &[Expr]) -> Resu
             (Value::WeakMap(weakmap), method) => crate::js_weakmap::handle_weakmap_instance_method(&weakmap, method, args, env),
             (Value::WeakSet(weakset), method) => crate::js_weakset::handle_weakset_instance_method(&weakset, method, args, env),
             (Value::Generator(generator), method) => crate::js_generator::handle_generator_instance_method(&generator, method, args, env),
+            (Value::Object(obj_map), method) if obj_map.borrow().contains_key(&"__generator__".into()) => {
+                if let Some(gen_val) = obj_map.borrow().get(&"__generator__".into())
+                    && let Value::Generator(generator) = &*gen_val.borrow()
+                {
+                    crate::js_generator::handle_generator_instance_method(generator, method, args, env)
+                } else {
+                    Err(raise_eval_error!("Invalid Generator object"))
+                }
+            }
             (Value::Object(obj_map), method) => {
                 // Object prototype methods are supplied on `Object.prototype`.
                 // Lookups will find user-defined (own) methods before inherited
@@ -4150,6 +4186,11 @@ fn evaluate_call(env: &JSObjectDataPtr, func_expr: &Expr, args: &[Expr]) -> Resu
         // Regular function call
         let func_val = evaluate_expr(env, func_expr)?;
         match func_val {
+            Value::Proxy(proxy) => {
+                // Special case: calling a proxy directly (assumed to be revoke function)
+                proxy.borrow_mut().revoked = true;
+                Ok(Value::Undefined)
+            }
             Value::Function(func_name) => crate::js_function::handle_global_function(&func_name, args, env),
             Value::GeneratorFunction(params, body, captured_env) => {
                 // Generator function call - return a generator object

src/core/ffi.rs

@@ -949,6 +949,7 @@ pub unsafe fn JS_Eval(_ctx: *mut JSContext, input: *const i8, input_len: usize,
             Ok(Value::WeakSet(_)) => JS_UNDEFINED,                 // For now
             Ok(Value::GeneratorFunction(_, _, _)) => JS_UNDEFINED, // For now
             Ok(Value::Generator(_)) => JS_UNDEFINED,               // For now
+            Ok(Value::Proxy(_)) => JS_UNDEFINED,                   // For now
             Err(_) => JS_UNDEFINED,
         }
     }

src/core/value.rs

@@ -6,7 +6,7 @@ use crate::{
     js_array::is_array,
     js_class::ClassDefinition,
     js_promise::JSPromise,
-    raise_type_error,
+    raise_eval_error, raise_type_error,
 };
 
 #[derive(Clone, Debug)]
@@ -37,6 +37,13 @@ pub struct JSGenerator {
     pub state: GeneratorState,
 }
 
+#[derive(Clone, Debug)]
+pub struct JSProxy {
+    pub target: Value,  // The target object being proxied
+    pub handler: Value, // The handler object with traps
+    pub revoked: bool,  // Whether this proxy has been revoked
+}
+
 #[derive(Clone, Debug)]
 pub enum GeneratorState {
     NotStarted,
@@ -136,6 +143,7 @@ pub enum Value {
     WeakMap(Rc<RefCell<JSWeakMap>>),     // WeakMap object
     WeakSet(Rc<RefCell<JSWeakSet>>),     // WeakSet object
     Generator(Rc<RefCell<JSGenerator>>), // Generator object
+    Proxy(Rc<RefCell<JSProxy>>),         // Proxy object
 }
 
 impl std::fmt::Debug for Value {
@@ -162,6 +170,7 @@ impl std::fmt::Debug for Value {
             Value::WeakMap(wm) => write!(f, "WeakMap({:p})", Rc::as_ptr(wm)),
             Value::WeakSet(ws) => write!(f, "WeakSet({:p})", Rc::as_ptr(ws)),
             Value::Generator(g) => write!(f, "Generator({:p})", Rc::as_ptr(g)),
+            Value::Proxy(p) => write!(f, "Proxy({:p})", Rc::as_ptr(p)),
         }
     }
 }
@@ -203,6 +212,7 @@ pub fn is_truthy(val: &Value) -> bool {
         Value::WeakMap(_) => true,
         Value::WeakSet(_) => true,
         Value::Generator(_) => true,
+        Value::Proxy(_) => true,
     }
 }
 
@@ -247,6 +257,7 @@ pub fn value_to_string(val: &Value) -> String {
         Value::WeakMap(_) => "[object WeakMap]".to_string(),
         Value::WeakSet(_) => "[object WeakSet]".to_string(),
         Value::Generator(_) => "[object Generator]".to_string(),
+        Value::Proxy(_) => "[object Proxy]".to_string(),
     }
 }
 
@@ -346,11 +357,19 @@ pub fn value_to_sort_string(val: &Value) -> String {
         Value::WeakMap(_) => "[object WeakMap]".to_string(),
         Value::WeakSet(_) => "[object WeakSet]".to_string(),
         Value::Generator(_) => "[object Generator]".to_string(),
+        Value::Proxy(_) => "[object Proxy]".to_string(),
     }
 }
 
 // Helper accessors for objects and environments
 pub fn obj_get_value(js_obj: &JSObjectDataPtr, key: &PropertyKey) -> Result<Option<Rc<RefCell<Value>>>, JSError> {
+    // Check if this object is a proxy wrapper
+    if let Some(proxy_val) = js_obj.borrow().get(&"__proxy__".into())
+        && let Value::Proxy(proxy) = &*proxy_val.borrow()
+    {
+        return crate::js_proxy::proxy_get_property(proxy, key);
+    }
+
     // Search own properties and then walk the prototype chain until we find
     // a matching property or run out of prototypes.
     let mut current: Option<JSObjectDataPtr> = Some(js_obj.clone());
@@ -690,6 +709,17 @@ pub fn obj_get_value(js_obj: &JSObjectDataPtr, key: &PropertyKey) -> Result<Opti
 }
 
 pub fn obj_set_value(js_obj: &JSObjectDataPtr, key: &PropertyKey, val: Value) -> Result<(), JSError> {
+    // Check if this object is a proxy wrapper
+    if let Some(proxy_val) = js_obj.borrow().get(&"__proxy__".into())
+        && let Value::Proxy(proxy) = &*proxy_val.borrow()
+    {
+        let success = crate::js_proxy::proxy_set_property(proxy, key, val)?;
+        if !success {
+            return Err(raise_eval_error!("Proxy set trap returned false"));
+        }
+        return Ok(());
+    }
+
     // Check if there's a setter for this property
     let existing_opt = js_obj.borrow().get(key);
     if let Some(existing) = existing_opt {
@@ -731,9 +761,16 @@ pub fn obj_set_rc(map: &JSObjectDataPtr, key: &PropertyKey, val_rc: Rc<RefCell<V
     map.borrow_mut().insert(key.clone(), val_rc);
 }
 
-pub fn obj_delete(map: &JSObjectDataPtr, key: &PropertyKey) -> bool {
+pub fn obj_delete(map: &JSObjectDataPtr, key: &PropertyKey) -> Result<bool, JSError> {
+    // Check if this object is a proxy wrapper
+    if let Some(proxy_val) = map.borrow().get(&"__proxy__".into())
+        && let Value::Proxy(proxy) = &*proxy_val.borrow()
+    {
+        return crate::js_proxy::proxy_delete_property(proxy, key);
+    }
+
     map.borrow_mut().remove(key);
-    true // In JavaScript, delete always returns true
+    Ok(true) // In JavaScript, delete always returns true
 }
 
 pub fn env_get<T: AsRef<str>>(env: &JSObjectDataPtr, key: T) -> Option<Rc<RefCell<Value>>> {

src/js_class.rs

@@ -170,6 +170,7 @@ pub(crate) fn evaluate_new(env: &JSObjectDataPtr, constructor: &Expr, args: &[Ex
                 }
                 "Map" => return crate::js_map::handle_map_constructor(args, env),
                 "Set" => return crate::js_set::handle_set_constructor(args, env),
+                "Proxy" => return crate::js_proxy::handle_proxy_constructor(args, env),
                 "WeakMap" => return crate::js_weakmap::handle_weakmap_constructor(args, env),
                 "WeakSet" => return crate::js_weakset::handle_weakset_constructor(args, env),
                 "MockIntlConstructor" => {
@@ -674,6 +675,7 @@ pub(crate) fn handle_string_constructor(args: &[Expr], env: &JSObjectDataPtr) ->
             Value::WeakSet(_) => utf8_to_utf16("[object WeakSet]"),
             Value::GeneratorFunction(_, _, _) => utf8_to_utf16("[GeneratorFunction]"),
             Value::Generator(_) => utf8_to_utf16("[object Generator]"),
+            Value::Proxy(_) => utf8_to_utf16("[object Proxy]"),
         }
     };
 

src/js_console.rs

@@ -111,6 +111,7 @@ pub fn handle_console_method(method: &str, args: &[Expr], env: &JSObjectDataPtr)
                     Value::WeakSet(_) => print!("[object WeakSet]"),
                     Value::GeneratorFunction(_, _, _) => print!("[GeneratorFunction]"),
                     Value::Generator(_) => print!("[object Generator]"),
+                    Value::Proxy(_) => print!("[object Proxy]"),
                 }
                 if i < count - 1 {
                     print!(" ");

src/js_function.rs

@@ -83,6 +83,7 @@ pub fn handle_global_function(func_name: &str, args: &[Expr], env: &JSObjectData
                     Value::WeakSet(_) => Ok(Value::String(utf8_to_utf16("[object WeakSet]"))),
                     Value::GeneratorFunction(_, _, _) => Ok(Value::String(utf8_to_utf16("[GeneratorFunction]"))),
                     Value::Generator(_) => Ok(Value::String(utf8_to_utf16("[object Generator]"))),
+                    Value::Proxy(_) => Ok(Value::String(utf8_to_utf16("[object Proxy]"))),
                 }
             } else {
                 Ok(Value::String(Vec::new())) // String() with no args returns empty string

src/js_generator.rs

@@ -28,7 +28,15 @@ pub fn handle_generator_function_call(
         state: crate::core::GeneratorState::NotStarted,
     }));
 
-    Ok(Value::Generator(generator))
+    // Create a wrapper object for the generator
+    let gen_obj = Rc::new(RefCell::new(crate::core::JSObjectData::new()));
+    // Store the actual generator data
+    gen_obj.borrow_mut().insert(
+        crate::core::PropertyKey::String("__generator__".to_string()),
+        Rc::new(RefCell::new(Value::Generator(generator))),
+    );
+
+    Ok(Value::Object(gen_obj))
 }
 
 /// Handle generator instance method calls (like `gen.next()`, `gen.return()`, etc.)

src/js_object.rs

@@ -299,6 +299,7 @@ pub(crate) fn handle_to_string_method(obj_val: &Value, args: &[Expr]) -> Result<
                 Value::WeakSet(_) => "WeakSet",
                 Value::GeneratorFunction(_, _, _) => "GeneratorFunction",
                 Value::Generator(_) => "Generator",
+                Value::Proxy(_) => "Proxy",
             },
             args.len()
         )));
@@ -375,6 +376,7 @@ pub(crate) fn handle_to_string_method(obj_val: &Value, args: &[Expr]) -> Result<
         Value::WeakSet(_) => Ok(Value::String(utf8_to_utf16("[object WeakSet]"))),
         Value::GeneratorFunction(_, _, _) => Ok(Value::String(utf8_to_utf16("[GeneratorFunction]"))),
         Value::Generator(_) => Ok(Value::String(utf8_to_utf16("[object Generator]"))),
+        Value::Proxy(_) => Ok(Value::String(utf8_to_utf16("[object Proxy]"))),
     }
 }
 
@@ -403,6 +405,7 @@ pub(crate) fn handle_value_of_method(obj_val: &Value, args: &[Expr]) -> Result<V
                 Value::WeakSet(_) => "WeakSet",
                 &Value::GeneratorFunction(_, _, _) => "GeneratorFunction",
                 &Value::Generator(_) => "Generator",
+                &Value::Proxy(_) => "Proxy",
             },
             args.len()
         )));
@@ -445,5 +448,6 @@ pub(crate) fn handle_value_of_method(obj_val: &Value, args: &[Expr]) -> Result<V
         Value::WeakSet(weakset) => Ok(Value::WeakSet(weakset.clone())),
         Value::GeneratorFunction(params, body, env) => Ok(Value::GeneratorFunction(params.clone(), body.clone(), env.clone())),
         Value::Generator(generator) => Ok(Value::Generator(generator.clone())),
+        Value::Proxy(proxy) => Ok(Value::Proxy(proxy.clone())),
     }
 }