Fix private field updates and implement Function.prototype.bind

- src/core/eval.rs: Use get_property_with_accessors in update expressions to support private accessors.
- src/core/eval.rs: Support bound_this in inline closure evaluation and call_closure.
- src/core/eval.rs: Add dispatch for Function.prototype.bind.
- src/js_function.rs: Implement bind method, preserving original binding if present.
- src/js_class.rs: Fix private method key generation and home object binding.
- src/core/mod.rs: Enable Function initialization.

Author: ssrlive

src/core/eval.rs

@@ -4,6 +4,7 @@ use crate::core::{Gc, GcCell, MutationContext};
 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_function::handle_function_prototype_method;
 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::{handle_string_method, string_from_char_code, string_from_code_point, string_raw};
@@ -1898,6 +1899,13 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                         } else {
                             Err(EvalError::Js(raise_eval_error!(format!("Unknown Set function: {}", name))))
                         }
+                    } else if name.starts_with("Function.") {
+                        if let Some(method) = name.strip_prefix("Function.prototype.") {
+                            let this_v = this_val.clone().unwrap_or(Value::Undefined);
+                            Ok(handle_function_prototype_method(mc, &this_v, method, &eval_args, env).map_err(EvalError::Js)?)
+                        } else {
+                            Err(EvalError::Js(raise_eval_error!(format!("Unknown Function method: {}", name))))
+                        }
                     } else {
                         Err(EvalError::Js(raise_eval_error!(format!("Unknown native function: {}", name))))
                     }
@@ -1909,7 +1917,13 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                                 let call_env = crate::core::new_js_object_data(mc);
                                 call_env.borrow_mut(mc).prototype = Some(cl.env);
                                 call_env.borrow_mut(mc).is_function_scope = true;
-                                if let Some(tv) = &this_val {
+                                let effective_this = if let Some(bound) = &cl.bound_this {
+                                    Some(bound.clone())
+                                } else {
+                                    this_val.clone()
+                                };
+
+                                if let Some(tv) = &effective_this {
                                     obj_set_key_value(mc, &call_env, &"this".into(), tv.clone())?;
                                 }
 
@@ -2015,7 +2029,13 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                     let call_env = crate::core::new_js_object_data(mc);
                     call_env.borrow_mut(mc).prototype = Some(cl.env);
                     call_env.borrow_mut(mc).is_function_scope = true;
-                    if let Some(tv) = &this_val {
+                    let effective_this = if let Some(bound) = &cl.bound_this {
+                        Some(bound.clone())
+                    } else {
+                        this_val.clone()
+                    };
+
+                    if let Some(tv) = &effective_this {
                         obj_set_key_value(mc, &call_env, &"this".into(), tv.clone())?;
                     }
 
@@ -3004,7 +3024,16 @@ pub fn call_closure<'gc>(
     let call_env = crate::core::new_js_object_data(mc);
     call_env.borrow_mut(mc).prototype = Some(cl.env);
     call_env.borrow_mut(mc).is_function_scope = true;
-    if let Some(tv) = &this_val {
+
+    let this_val_for_log = this_val.clone();
+
+    let effective_this = if let Some(bound) = &cl.bound_this {
+        Some(bound.clone())
+    } else {
+        this_val
+    };
+
+    if let Some(tv) = effective_this {
         crate::core::obj_set_key_value(mc, &call_env, &"this".into(), tv.clone()).map_err(EvalError::Js)?;
     }
 
@@ -3055,11 +3084,8 @@ fn evaluate_update_expression<'gc>(
             let obj_val = evaluate_expr(mc, env, obj_expr)?;
             if let Value::Object(obj) = obj_val {
                 let key_val = PropertyKey::from(key.to_string());
-                let current = if let Some(some_cell) = obj_get_key_value(&obj, &key_val)? {
-                    some_cell.borrow().clone()
-                } else {
-                    Value::Undefined
-                };
+                // Use get_property_with_accessors so getters are invoked for reads
+                let current = get_property_with_accessors(mc, env, &obj, &key_val)?;
 
                 let current_num = match current {
                     Value::Number(n) => n,
@@ -3080,11 +3106,8 @@ fn evaluate_update_expression<'gc>(
             let key = PropertyKey::from(key_str);
 
             if let Value::Object(obj) = obj_val {
-                let current = if let Some(some_cell) = obj_get_key_value(&obj, &key)? {
-                    some_cell.borrow().clone()
-                } else {
-                    Value::Undefined
-                };
+                // Use get_property_with_accessors so getters are invoked for reads
+                let current = get_property_with_accessors(mc, env, &obj, &key)?;
 
                 let current_num = match current {
                     Value::Number(n) => n,

src/core/mod.rs

@@ -71,7 +71,7 @@ pub fn initialize_global_constructors<'gc>(mc: &MutationContext<'gc>, env: &JSOb
     initialize_math(mc, env)?;
     initialize_string(mc, env)?;
     initialize_array(mc, env)?;
-    // crate::js_function::initialize_function(mc, env)?;
+    crate::js_function::initialize_function(mc, env)?;
     initialize_regexp(mc, env)?;
     // Initialize Date constructor and prototype
     initialize_date(mc, env)?;

src/js_class.rs

@@ -752,10 +752,16 @@ pub(crate) fn create_class_object<'gc>(
                 // Instance private properties handled during instantiation
             }
             ClassMember::PrivateMethod(method_name, params, body) => {
-                // Add private method to prototype using the '#name' key
-                let closure_data = ClosureData::new(params, body, env, None);
+                // Create a closure for the private method
+                let final_key = if method_name.starts_with('#') {
+                    method_name.clone()
+                } else {
+                    format!("#{method_name}")
+                };
+
+                let closure_data = ClosureData::new(params, body, env, Some(prototype_obj.clone()));
                 let method_closure = Value::Closure(Gc::new(mc, closure_data));
-                obj_set_key_value(mc, &prototype_obj, &format!("#{}", method_name).into(), method_closure)?;
+                obj_set_key_value(mc, &prototype_obj, &final_key.into(), method_closure)?;
             }
             ClassMember::PrivateGetter(getter_name, body) => {
                 let key = format!("#{}", getter_name);

src/js_function.rs

@@ -1391,3 +1391,71 @@ pub fn initialize_function<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr
     crate::core::env_set(mc, env, "Function", Value::Object(func_ctor))?;
     Ok(())
 }
+
+pub fn handle_function_prototype_method<'gc>(
+    mc: &MutationContext<'gc>,
+    this_value: &Value<'gc>,
+    method: &str,
+    args: &[Value<'gc>],
+    _env: &JSObjectDataPtr<'gc>,
+) -> Result<Value<'gc>, JSError> {
+    match method {
+        "bind" => {
+            // function.bind(thisArg, ...args)
+            if let Value::Closure(closure_gc) = this_value {
+                let this_arg = args.get(0).cloned().unwrap_or(Value::Undefined);
+
+                let original = closure_gc;
+                // Check if already bound?
+                // logic: if already bound, subsequent binds (of this) are ignored?
+                // MDN: "The bind() method creates a new function that, when called, has its this keyword set to the provided value."
+                // "The new function has the same body as the original function. The this value is bound to the first argument of bind()."
+
+                // If original func is already bound, calling bind on it creates a NEW bound function.
+                // The new bound function calls the OLD bound function.
+                // But with our ClosureData implementation, if we just clone data and set bound_this, we are modifying the 'effective' this for the code.
+                // If 'original' has 'bound_this' set, 'call_closure' uses that.
+                // If we overwrite 'bound_this' in the clone:
+                //   Value::Closure(new_data { bound_this: new_this })
+                //   call_closure(new_data) -> uses new_this.
+                // This is WRONG if the original was already bound. The original binding should take precedence.
+                // But wait, if original was bound, 'call_closure' on original uses original.bound_this.
+                // If we clone 'original.body' etc, we are essentially copying the code.
+                // Does 'bound_this' stick to the code?
+
+                // Correct implementation of Bound Function creates a wrapper that calls TargetFunction.
+                // Since this engine simplifies things by using ClosureData, we have limits.
+                // If 'bound_this' is already set, we should probably NOT overwrite it with new access?
+                // Or rather, we can't easily implement "bound function calling bound function" without wrapper.
+
+                let effective_bound_this = if original.bound_this.is_some() {
+                    original.bound_this.clone()
+                } else {
+                    Some(this_arg)
+                };
+
+                // NOTE: Arguments binding is skipped for now as ClosureData doesn't support it.
+
+                let new_closure_data = ClosureData {
+                    params: original.params.clone(),
+                    body: original.body.clone(),
+                    env: original.env.clone(),
+                    home_object: original.home_object.clone(),
+                    captured_envs: original.captured_envs.clone(),
+                    bound_this: effective_bound_this,
+                };
+
+                Ok(Value::Closure(Gc::new(mc, new_closure_data)))
+            } else if let Value::Function(_) = this_value {
+                // Binding native function: not supported
+                // Return original for now or undefined? Returning original is wrong 'this'.
+                // Returning undefined throws error.
+                // Let's return the function itself (broken binding) or error.
+                Err(crate::raise_type_error!("Binding native functions not supported yet"))
+            } else {
+                Err(crate::raise_type_error!("Function.prototype.bind called on non-function"))
+            }
+        }
+        _ => Err(crate::raise_type_error!(format!("Unknown Function.prototype method: {method}"))),
+    }
+}