Implement Class support & Fix variable scope resolution and Array prototype linking

- Integrate js_class module
- Update evaluate_var to traverse environment scope chain
- Correct argument order in create_array for prototype assignment
- Add dispatch for Array.prototype methods in evaluator
- Remove debug print statements from core modules
- Exclude unsupported function.bind test case

Author: ssrlive

src/core/eval.rs

@@ -76,6 +76,48 @@ pub fn initialize_error_constructor<'gc>(mc: &MutationContext<'gc>, env: &JSObje
     obj_set_key_value(mc, &error_proto, &"message".into(), Value::String(utf8_to_utf16("")))?;
 
     env_set(mc, env, "Error", Value::Object(error_ctor))?;
+
+    let error_ctor_val = Value::Object(error_ctor);
+    let error_proto_val = Value::Object(error_proto);
+
+    initialize_native_error(mc, env, "ReferenceError", error_ctor_val.clone(), error_proto_val.clone())?;
+    initialize_native_error(mc, env, "TypeError", error_ctor_val.clone(), error_proto_val.clone())?;
+    initialize_native_error(mc, env, "SyntaxError", error_ctor_val.clone(), error_proto_val.clone())?;
+    initialize_native_error(mc, env, "RangeError", error_ctor_val.clone(), error_proto_val.clone())?;
+
+    Ok(())
+}
+
+fn initialize_native_error<'gc>(
+    mc: &MutationContext<'gc>,
+    env: &JSObjectDataPtr<'gc>,
+    name: &str,
+    _parent_ctor: Value<'gc>,
+    parent_proto: Value<'gc>,
+) -> Result<(), JSError> {
+    let ctor = new_js_object_data(mc);
+    obj_set_key_value(mc, &ctor, &"__is_constructor".into(), Value::Boolean(true))?;
+    obj_set_key_value(mc, &ctor, &"__native_ctor".into(), Value::String(utf8_to_utf16(name)))?;
+
+    // Set prototype of constructor to parent constructor (Error) so strict inheritance works if checked
+    // However, usually Foo.__proto__ === Function.prototype.
+    // But in class inheritance: class Ref extends Error {} -> Ref.__proto__ === Error.
+    // Native errors behave like subclasses.
+
+    // For simplicity, let's just make sure the prototype property is set up correctly.
+
+    let proto = new_js_object_data(mc);
+    // ReferenceError.prototype.__proto__ === Error.prototype
+    if let Value::Object(parent_p_obj) = parent_proto {
+        proto.borrow_mut(mc).prototype = Some(parent_p_obj);
+    }
+
+    obj_set_key_value(mc, &ctor, &"prototype".into(), Value::Object(proto))?;
+    obj_set_key_value(mc, &proto, &"constructor".into(), Value::Object(ctor))?;
+    obj_set_key_value(mc, &proto, &"name".into(), Value::String(utf8_to_utf16(name)))?;
+    obj_set_key_value(mc, &proto, &"message".into(), Value::String(utf8_to_utf16("")))?;
+
+    env_set(mc, env, name, Value::Object(ctor))?;
     Ok(())
 }
 

src/core/js_error.rs

@@ -58,6 +58,12 @@ pub fn initialize_global_constructors<'gc>(mc: &MutationContext<'gc>, env: &JSOb
     let object_proto = new_js_object_data(mc);
     obj_set_key_value(mc, &object_ctor, &"prototype".into(), Value::Object(object_proto))?;
     obj_set_key_value(mc, &object_proto, &"constructor".into(), Value::Object(object_ctor))?;
+    obj_set_key_value(
+        mc,
+        &object_proto,
+        &"toString".into(),
+        Value::Function("Object.prototype.toString".to_string()),
+    )?;
 
     env_set(mc, env, "Object", Value::Object(object_ctor))?;
 
@@ -71,6 +77,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)?;
     initialize_regexp(mc, env)?;
     // Initialize Date constructor and prototype
     initialize_date(mc, env)?;
@@ -120,10 +127,8 @@ where
         env_set(mc, &root.global_env, "globalThis", Value::Object(root.global_env))?;
         if let Some(p) = script_path.as_ref() {
             let p_str = p.as_ref().to_string_lossy().to_string();
-            // Store __filename
-            obj_set_key_value(mc, &root.global_env, &"__filename".into(), Value::String(utf8_to_utf16(&p_str)))?;
-            // Store __script_name for import resolution
-            obj_set_key_value(mc, &root.global_env, &"__script_name".into(), Value::String(utf8_to_utf16(&p_str)))?;
+            // Store __filepath
+            obj_set_key_value(mc, &root.global_env, &"__filepath".into(), Value::String(utf8_to_utf16(&p_str)))?;
         }
         match evaluate_statements(mc, &root.global_env, &mut statements) {
             Ok(result) => Ok(value_to_string(&result)),

src/core/mod.rs

@@ -26,7 +26,7 @@ pub enum StatementKind {
     LetDestructuringObject(Vec<ObjectDestructuringElement>, Expr), // object destructuring: let {a, b} = {a: 1, b: 2};
     VarDestructuringObject(Vec<ObjectDestructuringElement>, Expr), // object destructuring: var {a, b} = {a: 1, b: 2};
     ConstDestructuringObject(Vec<ObjectDestructuringElement>, Expr), // const {a, b} = {a: 1, b: 2};
-    Class(String, Option<Expr>, Vec<ClassMember>),                 // name, extends, members
+    Class(Box<ClassDefinition>),                                   // name, extends, members
     Assign(String, Expr),                                          // variable assignment
     For(Option<Box<Statement>>, Option<Expr>, Option<Box<Statement>>, Vec<Statement>), // init, condition, increment, body
     ForOf(String, Expr, Vec<Statement>),                           // variable, iterable, body
@@ -105,7 +105,7 @@ pub enum Expr {
     Yield(Option<Box<Expr>>),
     YieldStar(Box<Expr>),
     LogicalNot(Box<Expr>),
-    // Class(std::rc::Rc<crate::js_class::ClassDefinition>),
+    Class(Box<ClassDefinition>),
     New(Box<Expr>, Vec<Expr>),
     UnaryNeg(Box<Expr>),
     UnaryPlus(Box<Expr>),
@@ -181,7 +181,8 @@ pub enum ObjectDestructuringElement {
     Rest(String),                                          // ...rest
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Collect)]
+#[collect(require_static)]
 pub enum ClassMember {
     Constructor(Vec<DestructuringElement>, Vec<Statement>),           // parameters, body
     Method(String, Vec<DestructuringElement>, Vec<Statement>),        // name, parameters, body
@@ -203,8 +204,8 @@ pub enum ClassMember {
     StaticSetter(String, Vec<DestructuringElement>, Vec<Statement>),  // name, parameter, body
 }
 
-#[allow(dead_code)]
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Collect)]
+#[collect(require_static)]
 pub struct ClassDefinition {
     pub name: String,
     pub extends: Option<Expr>,

src/core/parser.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::collapsible_if, clippy::collapsible_match, dead_code)]
 
-use crate::core::{Collect, Gc, GcCell, GcPtr, GcTrace, GcWeak, MutationContext};
+use crate::core::{ClassDefinition, Collect, Gc, GcCell, GcPtr, GcTrace, GcWeak, MutationContext};
 use crate::unicode::utf16_to_utf8;
 use crate::{
     JSError,
@@ -320,7 +320,7 @@ pub enum Value<'gc> {
     Closure(Gc<'gc, ClosureData<'gc>>),
     AsyncClosure(Gc<'gc, ClosureData<'gc>>),
     GeneratorFunction(Option<String>, Gc<'gc, ClosureData<'gc>>),
-    ClassDefinition(Gc<'gc, ClosureData<'gc>>),
+    ClassDefinition(Gc<'gc, ClassDefinition>),
     // Getter/Setter legacy variants - keeping structures as implied by usage
     Getter(Vec<Statement>, JSObjectDataPtr<'gc>, Option<Box<Value<'gc>>>),
     Setter(

src/core/statement.rs

@@ -1614,12 +1614,11 @@ pub(crate) fn create_array<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr
         }
     }
     if let Some(root_env) = root_env_opt {
-        // // Try to set prototype to Array.prototype
-        // if crate::core::set_internal_prototype_from_constructor(mc, &arr, &root_env, "Array").is_err() {
-        //     // Fallback to Object.prototype
-        //     let _ = crate::core::set_internal_prototype_from_constructor(mc, &arr, &root_env, "Object");
-        // }
-        todo!("Set Array prototype properly");
+        // Try to set prototype to Array.prototype
+        if crate::core::set_internal_prototype_from_constructor(mc, &arr, &root_env, "Array").is_err() {
+            // Fallback to Object.prototype
+            let _ = crate::core::set_internal_prototype_from_constructor(mc, &arr, &root_env, "Object");
+        }
     }
 
     Ok(arr)