Fix arguments.callee in Function.prototype.call/apply

- src/core/eval.rs: Handle apply property access and forwarding of function objects to populate arguments.callee
- src/js_class.rs: Add callee parameter to create_arguments_object helper
- src/js_function.rs: Register call/apply on Function.prototype and update implementation to use helper
- js-scripts/function_arguments_callee.js: Add regression test script

Author: ssrlive

.github/workflows/rust.yml

@@ -60,6 +60,7 @@ jobs:
         cargo run --all-features --example js -- js-scripts/es6_module_test_02.js
         cargo run --all-features --example js -- js-scripts/es6_module_test_03.js
         cargo run --all-features --example js -- js-scripts/expressions_n_operators.js
+        cargo run --all-features --example js -- js-scripts/function_arguments_callee.js
         cargo run --all-features --example js -- js-scripts/function_object.js
         cargo run --all-features --example js -- js-scripts/globel_assert.js
         cargo run --all-features --example js -- js-scripts/indexed_collections.js

.github/workflows/test262.yml

@@ -28,7 +28,7 @@ jobs:
         env:
           FAIL_ON_FAILURE: 'true'
         run: |
-          bash ci/run_test262.sh --limit 10 --fail-on-failure --focus language
+          bash ci/run_test262.sh --limit 20 --fail-on-failure --focus language
 
       - name: Upload results
         if: ${{ !cancelled() }}

js-scripts/function_arguments_callee.js

@@ -0,0 +1,52 @@
+
+function testCallee() {
+    console.log("In testCallee, arguments.callee =", arguments.callee);
+    if (arguments.callee !== testCallee) {
+        throw new Error("arguments.callee is not the function itself");
+    }
+    return "ok";
+}
+
+console.log("=== Testing arguments.callee property ===");
+{
+    // Normal call
+    let v = testCallee();
+    console.log("Normal call: pass", v);
+
+    // Call via .call
+    testCallee.call(null);
+    console.log("Call via .call: pass");
+
+    // Call via .apply
+    testCallee.apply(null, []);
+    console.log("Call via .apply: pass");
+
+    // Closure call
+    var f = function() {
+        if (arguments.callee !== f) {
+            throw new Error("arguments.callee (closure) is not the function itself");
+        }
+        console.log("In closure f, arguments.callee =", arguments.callee);
+    };
+    f();
+    console.log("Closure call: pass");
+    f.call({});
+    console.log("Closure .call: pass");
+    f.apply({}, []);
+    console.log("Closure .apply: pass");
+}
+
+
+console.log("=== Checking existence of Function.prototype.call, apply, bind: ===");
+try {
+    console.log("Function.prototype.call: " + Function.prototype.call);
+    console.log("Function.prototype.apply: " + Function.prototype.apply);
+    console.log("Function.prototype.bind: " + Function.prototype.bind);
+    
+    var f = function() {};
+    console.log("f.call: " + f.call);
+    console.log("f.apply: " + f.apply);
+
+} catch (e) {
+    console.log("Error: " + e);
+}

src/core/eval.rs

@@ -4202,8 +4202,8 @@ fn evaluate_expr_call<'gc>(
             let f_val = if let Value::Object(obj) = &obj_val {
                 if let Some(val) = object_get_key_value(obj, key) {
                     val.borrow().clone()
-                } else if key.as_str() == "call" && object_get_key_value(obj, "__closure__").is_some() {
-                    Value::Function("call".to_string())
+                } else if (key.as_str() == "call" || key.as_str() == "apply") && object_get_key_value(obj, "__closure__").is_some() {
+                    Value::Function(key.to_string())
                 } else {
                     Value::Undefined
                 }
@@ -4214,9 +4214,9 @@ fn evaluate_expr_call<'gc>(
             } else if matches!(
                 obj_val,
                 Value::Closure(_) | Value::Function(_) | Value::AsyncClosure(_) | Value::GeneratorFunction(..)
-            ) && key == "call"
+            ) && (key == "call" || key == "apply")
             {
-                Value::Function("call".to_string())
+                Value::Function(key.to_string())
             } else {
                 get_primitive_prototype_property(mc, env, &obj_val, &key.as_str().into())?
             };
@@ -4253,8 +4253,8 @@ fn evaluate_expr_call<'gc>(
             let f_val = if let Value::Object(obj) = &obj_val {
                 if let Some(val) = object_get_key_value(obj, key) {
                     val.borrow().clone()
-                } else if key.as_str() == "call" && object_get_key_value(obj, "__closure__").is_some() {
-                    Value::Function("call".to_string())
+                } else if (key.as_str() == "call" || key.as_str() == "apply") && object_get_key_value(obj, "__closure__").is_some() {
+                    Value::Function(key.to_string())
                 } else {
                     Value::Undefined
                 }
@@ -4267,9 +4267,9 @@ fn evaluate_expr_call<'gc>(
             } else if matches!(
                 obj_val,
                 Value::Closure(_) | Value::Function(_) | Value::AsyncClosure(_) | Value::GeneratorFunction(..)
-            ) && key == "call"
+            ) && (key == "call" || key == "apply")
             {
-                Value::Function("call".to_string())
+                Value::Function(key.to_string())
             } else {
                 get_primitive_prototype_property(mc, env, &obj_val, &key.as_str().into())?
             };
@@ -5995,10 +5995,10 @@ pub fn call_native_function<'gc>(
     args: &[Value<'gc>],
     env: &JSObjectDataPtr<'gc>,
 ) -> Result<Option<Value<'gc>>, EvalError<'gc>> {
-    if name == "call" {
+    if name == "call" || name == "Function.prototype.call" {
         let this = this_val.ok_or_else(|| EvalError::Js(raise_eval_error!("Cannot call call without this")))?;
         let new_this = args.first().cloned().unwrap_or(Value::Undefined);
-        let rest_args = &args[1..];
+        let rest_args = if args.is_empty() { &[] } else { &args[1..] };
         return match this {
             Value::Closure(cl) => Ok(Some(call_closure(mc, &cl, Some(new_this), rest_args, env, None)?)),
 
@@ -6019,7 +6019,7 @@ pub fn call_native_function<'gc>(
             Value::Object(obj) => {
                 if let Some(cl_ptr) = object_get_key_value(&obj, "__closure__") {
                     match &*cl_ptr.borrow() {
-                        Value::Closure(cl) => Ok(Some(call_closure(mc, cl, Some(new_this), rest_args, env, None)?)),
+                        Value::Closure(cl) => Ok(Some(call_closure(mc, cl, Some(new_this), rest_args, env, Some(obj))?)),
 
                         _ => Err(EvalError::Js(raise_eval_error!("Not a function"))),
                     }
@@ -6031,6 +6031,54 @@ pub fn call_native_function<'gc>(
         };
     }
 
+    if name == "apply" || name == "Function.prototype.apply" {
+        let this = this_val.ok_or_else(|| EvalError::Js(raise_eval_error!("Cannot call apply without this")))?;
+        log::debug!("call_native_function: apply called on this={:?}", this);
+        let new_this = args.first().cloned().unwrap_or(Value::Undefined);
+        let arg_array = args.get(1).cloned().unwrap_or(Value::Undefined);
+
+        let mut rest_args = Vec::new();
+        if let Value::Object(obj) = arg_array
+            && is_array(mc, &obj)
+        {
+            let len_val = object_get_key_value(&obj, "length").unwrap_or(Gc::new(mc, GcCell::new(Value::Undefined)));
+            let len = if let Value::Number(n) = *len_val.borrow() { n as usize } else { 0 };
+            for k in 0..len {
+                let item = object_get_key_value(&obj, k).unwrap_or(Gc::new(mc, GcCell::new(Value::Undefined)));
+                rest_args.push(item.borrow().clone());
+            }
+        }
+
+        return match this {
+            Value::Closure(cl) => Ok(Some(call_closure(mc, &cl, Some(new_this), &rest_args, env, None)?)),
+            Value::Function(func_name) => {
+                if let Some(res) = call_native_function(mc, &func_name, Some(new_this.clone()), &rest_args, env)? {
+                    Ok(Some(res))
+                } else {
+                    let call_env = crate::core::new_js_object_data(mc);
+                    call_env.borrow_mut(mc).prototype = Some(*env);
+                    call_env.borrow_mut(mc).is_function_scope = true;
+                    object_set_key_value(mc, &call_env, "this", new_this.clone()).map_err(EvalError::Js)?;
+                    match crate::js_function::handle_global_function(mc, &func_name, &rest_args, &call_env) {
+                        Ok(res) => Ok(Some(res)),
+                        Err(e) => Err(EvalError::Js(e)),
+                    }
+                }
+            }
+            Value::Object(obj) => {
+                if let Some(cl_ptr) = object_get_key_value(&obj, "__closure__") {
+                    match &*cl_ptr.borrow() {
+                        Value::Closure(cl) => Ok(Some(call_closure(mc, cl, Some(new_this), &rest_args, env, Some(obj))?)),
+                        _ => Err(EvalError::Js(raise_eval_error!("Not a function"))),
+                    }
+                } else {
+                    Err(EvalError::Js(raise_eval_error!("Not a function")))
+                }
+            }
+            _ => Err(EvalError::Js(raise_eval_error!("Not a function"))),
+        };
+    }
+
     if name == "toString" {
         let this = this_val.unwrap_or(Value::Undefined);
         let tag = match &this {
@@ -6584,6 +6632,11 @@ pub fn call_closure<'gc>(
 
         // Minimal arguments object: expose numeric properties and length
         object_set_length(mc, &args_obj, args.len())?;
+
+        if let Some(fn_ptr) = fn_obj {
+            object_set_key_value(mc, &args_obj, "callee", Value::Object(fn_ptr)).map_err(EvalError::Js)?;
+        }
+
         env_set(mc, &call_env, "arguments", Value::Object(args_obj)).map_err(EvalError::Js)?;
     }
 
@@ -7097,7 +7150,7 @@ fn evaluate_expr_new<'gc>(
                             }
                         }
 
-                        crate::js_class::create_arguments_object(mc, &call_env, &eval_args)?;
+                        crate::js_class::create_arguments_object(mc, &call_env, &eval_args, None)?;
 
                         let body_clone = cl.body.clone();
                         match evaluate_statements_with_labels(mc, &call_env, &body_clone, &[], &[])? {

src/js_class.rs

@@ -94,12 +94,20 @@ pub fn create_arguments_object<'gc>(
     mc: &MutationContext<'gc>,
     func_env: &JSObjectDataPtr<'gc>,
     evaluated_args: &[Value<'gc>],
+    callee: Option<Value<'gc>>,
 ) -> Result<(), JSError> {
+    // log::debug!("create_arguments_object called with callee={:?}", callee.is_some());
     let arguments_obj = crate::js_array::create_array(mc, func_env)?;
     crate::js_array::set_array_length(mc, &arguments_obj, evaluated_args.len())?;
     for (i, arg) in evaluated_args.iter().enumerate() {
         object_set_key_value(mc, &arguments_obj, i, arg.clone())?;
     }
+    if let Some(c) = callee {
+        // log::debug!("Setting arguments.callee");
+        object_set_key_value(mc, &arguments_obj, "callee", c)?;
+    } else {
+        // log::debug!("create_arguments_object: callee is None");
+    }
     object_set_key_value(mc, func_env, "arguments", Value::Object(arguments_obj))?;
     Ok(())
 }
@@ -182,7 +190,7 @@ pub(crate) fn evaluate_new<'gc>(
                     )?;
 
                     // Create the arguments object
-                    create_arguments_object(mc, &func_env, evaluated_args)?;
+                    create_arguments_object(mc, &func_env, evaluated_args, None)?;
 
                     // Execute constructor body
                     evaluate_statements(mc, &func_env, body)?;
@@ -469,7 +477,7 @@ pub(crate) fn evaluate_new<'gc>(
                 Some(env),
             )?;
 
-            create_arguments_object(mc, &func_env, evaluated_args)?;
+            create_arguments_object(mc, &func_env, evaluated_args, None)?;
 
             // Execute function body
             evaluate_statements(mc, &func_env, body)?;

src/js_function.rs

@@ -318,6 +318,7 @@ pub fn handle_global_function<'gc>(
         "Function.prototype.call" => {
             if let Some(this_rc) = crate::core::env_get(env, "this") {
                 let this_val = this_rc.borrow().clone();
+                let callee_for_arguments = this_val.clone(); // The function object being called
                 match this_val {
                     Value::Function(func_name) => {
                         if func_name.starts_with("Object.prototype.") || func_name.starts_with("Array.prototype.") {
@@ -354,22 +355,25 @@ pub fn handle_global_function<'gc>(
                             Some(env),
                         )?;
 
-                        let arguments_obj = crate::js_array::create_array(mc, &func_env)?;
-                        crate::js_array::set_array_length(mc, &arguments_obj, evaluated_args.len())?;
-                        for (i, arg) in evaluated_args.iter().enumerate() {
-                            object_set_key_value(mc, &arguments_obj, i, arg.clone())?;
-                        }
-                        object_set_key_value(mc, &func_env, "arguments", Value::Object(arguments_obj))?;
+                        // For raw closures (without wrapper object), we don't have a stable object identity for 'callee'.
+                        // But we can check if there's a reference to the function object in the `this` binding? No.
+                        // However, Function.prototype.call is usually called as `func.call(...)`.
+                        // The `this_val` here IS the function object (or closure).
+                        // So `callee_for_arguments` holds the correct Value::Closure or Value::Object.
+
+                        crate::js_class::create_arguments_object(mc, &func_env, &evaluated_args, Some(callee_for_arguments))?;
 
                         return Ok(crate::core::evaluate_statements(mc, &func_env, body)?);
                     }
                     Value::Object(object) => {
+                        log::debug!("Function.prototype.call on Value::Object");
                         if let Some(cl_rc) = object_get_key_value(&object, "__closure__")
                             && let Value::Closure(data) = &*cl_rc.borrow()
                         {
                             if args.is_empty() {
                                 return Err(raise_eval_error!("call requires a receiver"));
                             }
+                            log::debug!("Function.prototype.call calling closure with callee={:?}", callee_for_arguments);
                             let receiver_val = args[0].clone();
                             let forwarded = args[1..].to_vec();
                             let evaluated_args = forwarded.to_vec();
@@ -386,12 +390,7 @@ pub fn handle_global_function<'gc>(
                                 Some(env),
                             )?;
 
-                            let arguments_obj = crate::js_array::create_array(mc, &func_env)?;
-                            crate::js_array::set_array_length(mc, &arguments_obj, evaluated_args.len())?;
-                            for (i, arg) in evaluated_args.iter().enumerate() {
-                                object_set_key_value(mc, &arguments_obj, i, arg.clone())?;
-                            }
-                            object_set_key_value(mc, &func_env, "arguments", Value::Object(arguments_obj))?;
+                            crate::js_class::create_arguments_object(mc, &func_env, &evaluated_args, Some(callee_for_arguments))?;
 
                             return Ok(crate::core::evaluate_statements(mc, &func_env, body)?);
                         }
@@ -407,6 +406,7 @@ pub fn handle_global_function<'gc>(
         "Function.prototype.apply" => {
             if let Some(this_rc) = crate::core::env_get(env, "this") {
                 let this_val = this_rc.borrow().clone();
+                let callee_for_arguments = this_val.clone(); // The function object being called
                 match this_val {
                     Value::Function(func_name) => {
                         if func_name.starts_with("Object.prototype.") || func_name.starts_with("Array.prototype.") {
@@ -476,12 +476,7 @@ pub fn handle_global_function<'gc>(
                             Some(env),
                         )?;
 
-                        let arguments_obj = crate::js_array::create_array(mc, &func_env)?;
-                        crate::js_array::set_array_length(mc, &arguments_obj, evaluated_args.len())?;
-                        for (i, arg) in evaluated_args.iter().enumerate() {
-                            object_set_key_value(mc, &arguments_obj, i, arg.clone())?;
-                        }
-                        object_set_key_value(mc, &func_env, "arguments", Value::Object(arguments_obj))?;
+                        crate::js_class::create_arguments_object(mc, &func_env, &evaluated_args, Some(callee_for_arguments))?;
 
                         return Ok(crate::core::evaluate_statements(mc, &func_env, body)?);
                     }
@@ -524,12 +519,7 @@ pub fn handle_global_function<'gc>(
                                 Some(env),
                             )?;
 
-                            let arguments_obj = crate::js_array::create_array(mc, &func_env)?;
-                            crate::js_array::set_array_length(mc, &arguments_obj, evaluated_args.len())?;
-                            for (i, arg) in evaluated_args.iter().enumerate() {
-                                object_set_key_value(mc, &arguments_obj, i, arg.clone())?;
-                            }
-                            object_set_key_value(mc, &func_env, "arguments", Value::Object(arguments_obj))?;
+                            crate::js_class::create_arguments_object(mc, &func_env, &evaluated_args, Some(Value::Object(object)))?;
 
                             return Ok(crate::core::evaluate_statements(mc, &func_env, body)?);
                         }
@@ -1574,6 +1564,17 @@ pub fn initialize_function<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr
     // Function.prototype.bind
     object_set_key_value(mc, &func_proto, "bind", Value::Function("Function.prototype.bind".to_string()))?;
     func_proto.borrow_mut(mc).set_non_enumerable(crate::core::PropertyKey::from("bind"));
+
+    // Function.prototype.call
+    object_set_key_value(mc, &func_proto, "call", Value::Function("Function.prototype.call".to_string()))?;
+    func_proto.borrow_mut(mc).set_non_enumerable(crate::core::PropertyKey::from("call"));
+
+    // Function.prototype.apply
+    object_set_key_value(mc, &func_proto, "apply", Value::Function("Function.prototype.apply".to_string()))?;
+    func_proto
+        .borrow_mut(mc)
+        .set_non_enumerable(crate::core::PropertyKey::from("apply"));
+
     func_proto
         .borrow_mut(mc)
         .set_non_enumerable(crate::core::PropertyKey::from("constructor"));