Refactor core statement structures and optimize evaluation stack usage

- Refactor evaluate_expr by extracting large match arms into helper functions to reduce stack frame size
- Refactor StatementKind to use boxed structs for complex statements (If, For, TryCatch)
- Update BigInt, Number, and String constructors and to_primitive to accept MutationContext
- Fix super property access to correctly invoke getters with the proper this receiver
- Fix BigInt prototype chain and ensure Object prototype methods are non-enumerable
- Update Array methods (sort, flatMap, findLast) to support closures wrapped in objects
- Preserve is_arrow flag in Function.prototype.bind
- Update generator yield replacement logic to match new statement structures

Author: ssrlive

src/core/eval.rs

@@ -8,6 +8,9 @@ pub fn trace_expr<'gc, T: GcTrace<'gc>>(context: &mut T, expr: &Expr) {
         match d {
             DestructuringElement::Variable(_, Some(e)) => trace_expr(cc, e),
             DestructuringElement::Property(_, inner) => trace_destructuring(cc, inner),
+            DestructuringElement::Variable(_, None) => {}
+            DestructuringElement::Rest(_) => {}
+            DestructuringElement::Empty => {}
             DestructuringElement::NestedArray(arr) => {
                 for a in arr {
                     trace_destructuring(cc, a);
@@ -18,7 +21,6 @@ pub fn trace_expr<'gc, T: GcTrace<'gc>>(context: &mut T, expr: &Expr) {
                     trace_destructuring(cc, e);
                 }
             }
-            _ => todo!(),
         }
     }
 
@@ -70,12 +72,12 @@ pub fn trace_expr<'gc, T: GcTrace<'gc>>(context: &mut T, expr: &Expr) {
                 trace_stmt(context, stmt);
             }
         }
-        _ => todo!(),
+        _ => {}
     }
 }
 
 pub fn trace_stmt<'gc, T: GcTrace<'gc>>(context: &mut T, stmt: &Statement) {
-    match &stmt.kind {
+    match &*stmt.kind {
         StatementKind::Expr(e) => trace_expr(context, e),
         StatementKind::Let(decls) | StatementKind::Var(decls) => {
             for (_, e_opt) in decls {
@@ -102,12 +104,13 @@ pub fn trace_stmt<'gc, T: GcTrace<'gc>>(context: &mut T, stmt: &Statement) {
                 trace_stmt(context, s);
             }
         }
-        StatementKind::If(c, t, e_opt) => {
-            trace_expr(context, c);
-            for s in t {
+        StatementKind::If(if_stmt) => {
+            let if_stmt = if_stmt.as_ref();
+            trace_expr(context, &if_stmt.condition);
+            for s in &if_stmt.then_body {
                 trace_stmt(context, s);
             }
-            if let Some(e) = e_opt {
+            if let Some(e) = &if_stmt.else_body {
                 for s in e {
                     trace_stmt(context, s);
                 }
@@ -118,21 +121,56 @@ pub fn trace_stmt<'gc, T: GcTrace<'gc>>(context: &mut T, stmt: &Statement) {
                 trace_stmt(context, s);
             }
         }
-        StatementKind::TryCatch(try_body, _, catch_body, finally_body) => {
-            for s in try_body {
+        StatementKind::TryCatch(tc_stmt) => {
+            let tc_stmt = tc_stmt.as_ref();
+            for s in &tc_stmt.try_body {
                 trace_stmt(context, s);
             }
-            if let Some(stmts) = catch_body {
+            if let Some(stmts) = &tc_stmt.catch_body {
                 for s in stmts {
                     trace_stmt(context, s);
                 }
             }
-            if let Some(stmts) = finally_body {
+            if let Some(stmts) = &tc_stmt.finally_body {
                 for s in stmts {
                     trace_stmt(context, s);
                 }
             }
         }
-        _ => todo!(),
+        StatementKind::For(for_stmt) => {
+            let for_stmt = for_stmt.as_ref();
+            if let Some(init) = &for_stmt.init {
+                trace_stmt(context, init);
+            }
+            if let Some(test) = &for_stmt.test {
+                trace_expr(context, test);
+            }
+            if let Some(update) = &for_stmt.update {
+                trace_stmt(context, update);
+            }
+            for s in &for_stmt.body {
+                trace_stmt(context, s);
+            }
+        }
+        StatementKind::Switch(sw_stmt) => {
+            let sw_stmt = sw_stmt.as_ref();
+            trace_expr(context, &sw_stmt.expr);
+            for case in &sw_stmt.cases {
+                match case {
+                    crate::core::SwitchCase::Case(e, stmts) => {
+                        trace_expr(context, e);
+                        for s in stmts {
+                            trace_stmt(context, s);
+                        }
+                    }
+                    crate::core::SwitchCase::Default(stmts) => {
+                        for s in stmts {
+                            trace_stmt(context, s);
+                        }
+                    }
+                }
+            }
+        }
+        _ => {}
     }
 }

src/core/gc.rs

@@ -90,6 +90,16 @@ pub fn initialize_global_constructors<'gc>(mc: &MutationContext<'gc>, env: &JSOb
     env_set(mc, env, "Infinity", Value::Number(f64::INFINITY))?;
     env_set(mc, env, "eval", Value::Function("eval".to_string()))?;
 
+    // Expose common global functions as callables
+    env_set(mc, env, "parseInt", Value::Function("parseInt".to_string()))?;
+    env_set(mc, env, "parseFloat", Value::Function("parseFloat".to_string()))?;
+    env_set(mc, env, "isNaN", Value::Function("isNaN".to_string()))?;
+    env_set(mc, env, "isFinite", Value::Function("isFinite".to_string()))?;
+    env_set(mc, env, "encodeURI", Value::Function("encodeURI".to_string()))?;
+    env_set(mc, env, "decodeURI", Value::Function("decodeURI".to_string()))?;
+    env_set(mc, env, "encodeURIComponent", Value::Function("encodeURIComponent".to_string()))?;
+    env_set(mc, env, "decodeURIComponent", Value::Function("decodeURIComponent".to_string()))?;
+
     #[cfg(feature = "os")]
     crate::js_os::initialize_os_module(mc, env)?;
 
@@ -201,7 +211,17 @@ pub fn set_internal_prototype_from_constructor<'gc>(
 ) -> Result<(), JSError> {
     if let Some(proto_obj) = get_constructor_prototype(mc, env, ctor_name)? {
         // set internal prototype pointer (store Weak to avoid cycles)
+        log::trace!("setting prototype for ctor='{}' proto_obj={:p}", ctor_name, Gc::as_ptr(proto_obj));
         obj.borrow_mut(mc).prototype = Some(proto_obj.clone());
+        // Also set the `__proto__` own property so `obj.__proto__` accesses match expectations
+        match obj_set_key_value(mc, obj, &"__proto__".into(), Value::Object(proto_obj.clone())) {
+            Ok(_) => {
+                // __proto__ should be non-enumerable
+                obj.borrow_mut(mc).set_non_enumerable(PropertyKey::from("__proto__"));
+                log::trace!("set_internal_prototype_from_constructor: set __proto__ own property");
+            }
+            Err(e) => log::trace!("set_internal_prototype_from_constructor: failed to set __proto__: {:?}", e),
+        }
     }
     Ok(())
 }