tmp

Author: ssrlive

src/core/value.rs

@@ -1,22 +1,24 @@
-use crate::core::{ClassDefinition, DestructuringElement, Statement};
 use crate::core::{Collect, FunctionID, Gc, GcPtr, GcTrace};
 use crate::unicode::utf16_to_utf8;
 use indexmap::IndexMap;
 use num_bigint::BigInt;
+
 /// VM Map storage (simple Vec of key-value pairs).
 #[derive(Clone, Collect)]
 #[collect(no_drop)]
 pub struct VmMapData<'gc> {
     pub entries: Vec<(Value<'gc>, Value<'gc>)>,
     pub is_weak: bool,
 }
+
 /// VM Set storage (simple Vec of values).
 #[derive(Clone, Collect)]
 #[collect(no_drop)]
 pub struct VmSetData<'gc> {
     pub values: Vec<Value<'gc>>,
     pub is_weak: bool,
 }
+
 /// Array storage with optional named properties (e.g. `arr.foo = "bar"`).
 #[derive(Clone, Collect)]
 #[collect(no_drop)]
@@ -43,53 +45,6 @@ impl<'gc> std::ops::DerefMut for VmArrayData<'gc> {
         &mut self.elements
     }
 }
-use std::sync::{Arc, Mutex};
-
-#[derive(Clone, Debug, Collect, Default)]
-#[collect(require_static)]
-pub struct JSArrayBuffer {
-    pub data: Arc<Mutex<Vec<u8>>>,
-    pub detached: bool,
-    pub shared: bool,
-    pub max_byte_length: Option<usize>,
-    /// Whether this ArrayBuffer is immutable (frozen data, cannot be written to or transferred)
-    pub immutable: bool,
-}
-#[derive(Clone, Collect)]
-#[collect(no_drop)]
-pub struct JSDataView<'gc> {
-    pub buffer: GcPtr<'gc, JSArrayBuffer>,
-    pub byte_offset: usize,
-    pub byte_length: usize,
-    /// Whether this DataView was constructed without an explicit byteLength
-    /// (i.e. it tracks the buffer's current size minus offset).
-    pub length_tracking: bool,
-}
-#[derive(Clone, Debug, PartialEq, Collect)]
-#[collect(require_static)]
-pub enum TypedArrayKind {
-    Int8,
-    Uint8,
-    Uint8Clamped,
-    Int16,
-    Uint16,
-    Int32,
-    Uint32,
-    Float16,
-    Float32,
-    Float64,
-    BigInt64,
-    BigUint64,
-}
-#[derive(Clone, Collect)]
-#[collect(no_drop)]
-pub struct JSTypedArray<'gc> {
-    pub kind: TypedArrayKind,
-    pub buffer: GcPtr<'gc, JSArrayBuffer>,
-    pub byte_offset: usize,
-    pub length: usize,
-    pub length_tracking: bool,
-}
 
 #[derive(Clone, Debug, Collect)]
 #[collect(require_static)]
@@ -116,17 +71,6 @@ impl SymbolData {
         self.description.as_deref()
     }
 }
-#[derive(Clone, Collect)]
-#[collect(no_drop)]
-pub struct ClosureData<'gc> {
-    pub params: Vec<DestructuringElement>,
-    pub body: Vec<Statement>,
-    pub bound_this: Option<Value<'gc>>,
-    pub is_arrow: bool,
-    pub is_strict: bool,
-    pub native_target: Option<String>,
-    pub enforce_strictness_inheritance: bool,
-}
 
 #[derive(Clone)]
 pub enum Value<'gc> {
@@ -144,13 +88,6 @@ pub enum Value<'gc> {
     VmNativeFunction(FunctionID),
     VmMap(crate::core::VmMapHandle<'gc>),
     VmSet(crate::core::VmSetHandle<'gc>),
-    AsyncClosure(Gc<'gc, ClosureData<'gc>>),
-    GeneratorFunction(Option<String>, Gc<'gc, ClosureData<'gc>>),
-    AsyncGeneratorFunction(Option<String>, Gc<'gc, ClosureData<'gc>>),
-    ClassDefinition(Gc<'gc, ClassDefinition>),
-    ArrayBuffer(GcPtr<'gc, JSArrayBuffer>),
-    DataView(Gc<'gc, JSDataView<'gc>>),
-    PrivateName(String, u32),
     /// Internal property representation stored in an object's `properties` map.
     /// Contains either a concrete `value` or accessor `getter`/`setter` functions.
     /// Note: a `Value::Property` is not the same as a JS descriptor object
@@ -207,12 +144,6 @@ impl From<&String> for Value<'_> {
 unsafe impl<'gc> Collect<'gc> for Value<'gc> {
     fn trace<T: GcTrace<'gc>>(&self, cc: &mut T) {
         match self {
-            Value::AsyncClosure(cl) => cl.trace(cc),
-            Value::GeneratorFunction(_, cl) => cl.trace(cc),
-            Value::AsyncGeneratorFunction(_, cl) => cl.trace(cc),
-            Value::ClassDefinition(cl) => cl.trace(cc),
-            Value::ArrayBuffer(b) => b.trace(cc),
-            Value::DataView(d) => d.trace(cc),
             Value::Property { value, getter, setter } => {
                 if let Some(v) = value {
                     v.trace(cc);
@@ -295,17 +226,6 @@ pub fn value_to_string<'gc>(val: &Value<'gc>) -> String {
                 format!("function [{name}]() {{ [native code] }}")
             }
         }
-        Value::AsyncClosure(..) => "async function".to_string(),
-        Value::GeneratorFunction(name, ..) => {
-            format!("function* {}", name.as_deref().unwrap_or(""))
-        }
-        Value::AsyncGeneratorFunction(name, ..) => {
-            format!("async function* {}", name.as_deref().unwrap_or(""))
-        }
-        Value::ClassDefinition(..) => "class".to_string(),
-        Value::PrivateName(n, _) => format!("#{n}"),
-        Value::ArrayBuffer(_) => "[object ArrayBuffer]".to_string(),
-        Value::DataView(_) => "[object DataView]".to_string(),
         Value::Property { .. } => "[Property]".to_string(),
         Value::Symbol(sym) => {
             if let Some(desc) = &sym.description {

src/core/vm.rs

@@ -24113,9 +24113,7 @@ impl<'gc> VM<'gc> {
 
     fn is_value_callable(&self, value: &Value<'gc>) -> bool {
         match value {
-            Value::VmFunction(..) | Value::VmClosure(..) | Value::VmNativeFunction(..) | Value::Function(..) | Value::AsyncClosure(..) => {
-                true
-            }
+            Value::VmFunction(..) | Value::VmClosure(..) | Value::VmNativeFunction(..) | Value::Function(..) => true,
             Value::VmObject(map) => {
                 let b = map.borrow();
                 if let Some(target) = b.get("__proxy_target__") {

src/lib.rs

@@ -13,11 +13,8 @@ pub(crate) mod repl;
 pub(crate) mod unicode;
 
 pub use crate::core::{Token, TokenData};
-pub use core::{
-    JSArrayBuffer, JSDataView, JSTypedArray, TypedArrayKind, parse_object_destructuring_pattern, parse_simple_expression, parse_statement,
-    parse_statements, read_script_file,
-};
 pub use core::{PropertyKey, Value, evaluate_script_with_vm, format_js_number, tokenize};
+pub use core::{parse_object_destructuring_pattern, parse_simple_expression, parse_statement, parse_statements, read_script_file};
 pub use error::{JSError, JSErrorKind};
 // pub use js_promise::set_short_timer_threshold_ms;
 // pub use js_promise::set_wait_for_active_handles;

tests/typedarray_tests.rs

@@ -1,79 +1,10 @@
 use javascript::*;
-use std::cell::RefCell;
-use std::rc::Rc;
-use std::sync::{Arc, Mutex};
 
 #[ctor::ctor]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
 
-#[test]
-fn test_jsarraybuffer_creation_and_access() {
-    // Test creating a new ArrayBuffer
-    let mut buffer = JSArrayBuffer {
-        data: Arc::new(Mutex::new(vec![0; 16])),
-        ..JSArrayBuffer::default()
-    };
-
-    assert_eq!(buffer.data.lock().unwrap().len(), 16);
-    assert!(!buffer.detached);
-
-    // Test data access and modification
-    buffer.data.lock().unwrap()[0] = 42;
-    buffer.data.lock().unwrap()[15] = 255;
-    assert_eq!(buffer.data.lock().unwrap()[0], 42);
-    assert_eq!(buffer.data.lock().unwrap()[15], 255);
-
-    // Test detachment
-    buffer.detached = true;
-    assert!(buffer.detached);
-}
-
-#[test]
-fn test_arraybuffer_detachment() {
-    // Create an ArrayBuffer
-    let buffer = Rc::new(RefCell::new(JSArrayBuffer {
-        data: Arc::new(Mutex::new(vec![1, 2, 3, 4])),
-        ..JSArrayBuffer::default()
-    }));
-
-    assert!(!buffer.borrow().detached);
-    assert_eq!(buffer.borrow().data.lock().unwrap().len(), 4);
-
-    // Detach the buffer
-    buffer.borrow_mut().detached = true;
-
-    assert!(buffer.borrow().detached);
-    // Note: In a real implementation, detached buffers might clear their data
-    // For this test, we just check the flag
-}
-
-#[test]
-fn test_typedarray_kind_properties() {
-    // Test that all TypedArray kinds are properly defined
-    let all_kinds = vec![
-        TypedArrayKind::Int8,
-        TypedArrayKind::Uint8,
-        TypedArrayKind::Uint8Clamped,
-        TypedArrayKind::Int16,
-        TypedArrayKind::Uint16,
-        TypedArrayKind::Int32,
-        TypedArrayKind::Uint32,
-        TypedArrayKind::Float32,
-        TypedArrayKind::Float64,
-        TypedArrayKind::BigInt64,
-        TypedArrayKind::BigUint64,
-    ];
-
-    assert_eq!(all_kinds.len(), 11);
-
-    // Test Debug formatting
-    assert_eq!(format!("{:?}", TypedArrayKind::Int8), "Int8");
-    assert_eq!(format!("{:?}", TypedArrayKind::Float64), "Float64");
-    assert_eq!(format!("{:?}", TypedArrayKind::BigInt64), "BigInt64");
-}
-
 #[test]
 fn test_js_arraybuffer_constructor_via_script() {
     // Test ArrayBuffer constructor through JavaScript