Remove tree-walking legacy: Value::Object, JSObjectData, and related dead code

- Remove Value::Object variant and all match arms referencing it in vm.rs
- Delete JSObjectData struct, JSObjectDataPtr alias, and new_js_object_data fn
- Delete InternalSlot enum (~200 variants) and str_to_internal_slot function
- Remove PropertyKey::Internal variant and its From/PartialEq/Hash/Display impls
- Delete dead Value variants: Getter, Setter, Generator, AsyncGenerator, Promise, Map, Set, WeakMap, WeakSet, TypedArray
- Delete tree-walking types: JSGenerator, JSAsyncGenerator, GeneratorState, AsyncGeneratorRequest, GeneratorForAwaitState, GeneratorForOfState, AsyncForAwaitState, GeneratorPendingCompletion
- Delete tree-walking collection types: JSMap, JSSet, WeakKey, JSWeakMap, JSWeakSet
- Delete JSPromise, PromiseState, generate_unique_id (replaced by VM promise handling)
- Remove JSObjectData impl block (new, lookup_property, set_prototype, etc.)
- Clean ClosureData: remove env, home_object, captured_envs fields and new() impl
- Remove helper functions: object_get_key_value, object_set_key_value, env_set, slot_get, slot_get_chained, object_get_length
- Remove is_error function from js_error.rs
- Simplify EvalError-to-JSError conversion (drop Value::Object error mapping)
- Clean lib.rs re-exports: remove JSObjectData, new_js_object_data, env_set, object_get/set_key_value
- Remove stale commented-out InternalSlot usage in mod.rs
- Remove unused pub use js_error::* re-export

Author: ssrlive

src/core/js_error.rs

@@ -1,7 +1,6 @@
 use crate::{
     JSError,
-    core::{InternalSlot, PropertyKey, Value, value_to_string},
-    object_get_key_value, utf16_to_utf8,
+    core::{Value, value_to_string},
 };
 
 #[derive(Debug)]
@@ -22,36 +21,8 @@ impl<'gc> From<EvalError<'gc>> for JSError {
             EvalError::Js(j) => j,
             EvalError::Throw(v, line, column) => {
                 let msg = value_to_string(&v);
-                let mut mapped_kind = None;
-                if let Value::Object(obj) = &v
-                    && let Some(name_rc) = object_get_key_value(obj, "name")
-                    && let Value::String(name_u16) = &*name_rc.borrow()
-                {
-                    let name = utf16_to_utf8(name_u16);
-                    let message = if let Some(message_rc) = object_get_key_value(obj, "message") {
-                        match &*message_rc.borrow() {
-                            Value::String(m) => utf16_to_utf8(m),
-                            other => value_to_string(other),
-                        }
-                    } else {
-                        msg.clone()
-                    };
 
-                    mapped_kind = match name.as_str() {
-                        "TypeError" => Some(crate::error::JSErrorKind::TypeError { message }),
-                        "RangeError" => Some(crate::error::JSErrorKind::RangeError { message }),
-                        "SyntaxError" => Some(crate::error::JSErrorKind::SyntaxError { message }),
-                        "ReferenceError" => Some(crate::error::JSErrorKind::ReferenceError { message }),
-                        "EvalError" | "URIError" => Some(crate::error::JSErrorKind::EvaluationError { message }),
-                        _ => None,
-                    };
-                }
-
-                let mut e = if let Some(kind) = mapped_kind {
-                    crate::make_js_error!(kind)
-                } else {
-                    crate::make_js_error!(crate::error::JSErrorKind::Throw(msg))
-                };
+                let mut e = crate::make_js_error!(crate::error::JSErrorKind::Throw(msg));
                 e.inner.js_line = line;
                 e.inner.js_column = column;
                 e
@@ -68,13 +39,3 @@ impl<'gc> EvalError<'gc> {
         }
     }
 }
-
-/// Check if a value is an Error object.
-pub fn is_error<'gc>(val: &Value<'gc>) -> bool {
-    if let Value::Object(obj) = val
-        && let Ok(borrowed) = obj.try_borrow()
-    {
-        return borrowed.properties.contains_key(&PropertyKey::Internal(InternalSlot::IsError));
-    }
-    false
-}

src/core/mod.rs

@@ -30,7 +30,6 @@ mod parser;
 pub use parser::*;
 
 pub mod js_error;
-pub use js_error::*;
 
 pub mod opcode;
 pub use opcode::*;
@@ -148,7 +147,7 @@ pub fn evaluate_script_with_vm<T: AsRef<str>, P: AsRef<std::path::Path>>(
             if run_as_module && let Some(injected_path) = extract_injected_module_filepath(script_str) {
                 p_str = injected_path;
             }
-            // slot_set(ctx, &root.global_env, InternalSlot::Filepath, &Value::String(utf8_to_utf16(&p_str)));
+
             Some(std::path::PathBuf::from(p_str))
         } else {
             None

src/core/property_key.rs

@@ -1,14 +1,11 @@
 use crate::core::{Collect, Gc};
-use crate::core::{InternalSlot, SymbolData, Value};
+use crate::core::{SymbolData, Value};
 #[derive(Clone, Debug, Collect)]
 #[collect(no_drop)]
 pub enum PropertyKey<'gc> {
     String(String),
     Symbol(Gc<'gc, SymbolData>),
     Private(String, u32),
-    /// Engine-internal slot key. JS code can never produce this variant,
-    /// guaranteeing zero collision with user-defined properties.
-    Internal(InternalSlot),
 }
 impl<'gc> From<&Gc<'gc, SymbolData>> for PropertyKey<'gc> {
     fn from(s: &Gc<'gc, SymbolData>) -> Self {
@@ -31,7 +28,6 @@ impl<'gc> From<&PropertyKey<'gc>> for PropertyKey<'gc> {
             PropertyKey::String(s) => PropertyKey::String(s.clone()),
             PropertyKey::Symbol(sym) => PropertyKey::Symbol(*sym),
             PropertyKey::Private(s, id) => PropertyKey::Private(s.clone(), *id),
-            PropertyKey::Internal(slot) => PropertyKey::Internal(slot.clone()),
         }
     }
 }
@@ -45,11 +41,6 @@ impl<'gc> From<String> for PropertyKey<'gc> {
         PropertyKey::String(s)
     }
 }
-impl<'gc> From<InternalSlot> for PropertyKey<'gc> {
-    fn from(slot: InternalSlot) -> Self {
-        PropertyKey::Internal(slot)
-    }
-}
 impl<'gc> From<&String> for PropertyKey<'gc> {
     fn from(s: &String) -> Self {
         PropertyKey::String(s.clone())
@@ -74,7 +65,6 @@ impl<'gc> PartialEq for PropertyKey<'gc> {
             (PropertyKey::String(s1), PropertyKey::String(s2)) => s1 == s2,
             (PropertyKey::Symbol(sym1), PropertyKey::Symbol(sym2)) => Gc::ptr_eq(*sym1, *sym2),
             (PropertyKey::Private(s1, id1), PropertyKey::Private(s2, id2)) => s1 == s2 && id1 == id2,
-            (PropertyKey::Internal(a), PropertyKey::Internal(b)) => a == b,
             _ => false,
         }
     }
@@ -96,10 +86,6 @@ impl<'gc> std::hash::Hash for PropertyKey<'gc> {
                 s.hash(state);
                 id.hash(state);
             }
-            PropertyKey::Internal(slot) => {
-                3u8.hash(state);
-                slot.hash(state);
-            }
         }
     }
 }
@@ -109,7 +95,6 @@ impl<'gc> std::fmt::Display for PropertyKey<'gc> {
             PropertyKey::String(s) => write!(f, "{s}"),
             PropertyKey::Symbol(sym) => write!(f, "[symbol {:p}]", Gc::as_ptr(*sym)),
             PropertyKey::Private(s, _) => write!(f, "#{s}"),
-            PropertyKey::Internal(slot) => write!(f, "[internal {slot:?}]"),
         }
     }
 }
@@ -119,7 +104,6 @@ impl<'gc> AsRef<str> for PropertyKey<'gc> {
             PropertyKey::String(s) => s,
             PropertyKey::Symbol(_sym) => todo!("Cannot convert Symbol to &str"),
             PropertyKey::Private(s, _) => s,
-            PropertyKey::Internal(_) => todo!("Cannot convert Internal slot to &str"),
         }
     }
 }