Merge pull request #282 from theseus-rs/encapsulate-concurrentvec

refactor: encapsulate use of ConcurrentVec

Author: brianheineman

Cargo.lock

@@ -49,7 +49,7 @@ sys-locale = "0.3.1"
 tar = "0.4.44"
 tempfile = "3.17.1"
 thiserror = "2.0.12"
-tokio = { version = "1.43.0", default-features = false, features = ["macros", "rt", "sync"] }
+tokio = { version = "1.44.0", default-features = false, features = ["macros", "rt", "sync"] }
 tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
 walkdir = "2.5.0"

Cargo.toml

@@ -13,13 +13,7 @@ impl<T: Clone + Debug + PartialEq> ConcurrentVec<T> {
     /// Create a new concurrent vector.
     #[must_use]
     pub fn new() -> Self {
-        Self::with_capacity(0)
-    }
-
-    /// Create a new concurrent vector with the defined capacity.
-    #[must_use]
-    pub fn with_capacity(capacity: usize) -> Self {
-        Self::from(Vec::with_capacity(capacity))
+        Self::from(Vec::new())
     }
 
     /// Create a new concurrent vector from a vector.
@@ -291,15 +285,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn test_capacity() -> Result<()> {
-        let vec: ConcurrentVec<u8> = ConcurrentVec::new();
-        assert_eq!(vec.capacity()?, 0);
-        let vec: ConcurrentVec<u8> = ConcurrentVec::with_capacity(10);
-        assert_eq!(vec.capacity()?, 10);
-        Ok(())
-    }
-
     #[test]
     fn test_remove() -> Result<()> {
         let vec = ConcurrentVec::new();

ristretto_classloader/src/concurrent_vec.rs

@@ -506,8 +506,7 @@ impl TryInto<Arc<Class>> for Object {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::Reference::IntArray;
-    use crate::{ConcurrentVec, runtime};
+    use crate::runtime;
 
     async fn java8_string_class() -> Result<Arc<Class>> {
         let (_java_home, _java_version, class_loader) =
@@ -940,7 +939,7 @@ mod tests {
     async fn test_try_into_string_java8_invalid_byte_array_value() -> Result<()> {
         let class = java8_string_class().await?;
         let object = Object::new(class)?;
-        let string_value = Value::Object(Some(IntArray(ConcurrentVec::from(vec![]))));
+        let string_value = Value::from(Vec::<i32>::new());
         object.set_value("value", string_value)?;
         let result: Result<String> = object.try_into();
         assert!(matches!(result, Err(InvalidValueType(_))));
@@ -981,7 +980,7 @@ mod tests {
     async fn test_try_into_string_invalid_char_array_value() -> Result<()> {
         let class = string_class().await?;
         let object = Object::new(class)?;
-        let string_value = Value::Object(Some(IntArray(ConcurrentVec::from(vec![]))));
+        let string_value = Value::from(Vec::<i32>::new());
         object.set_value("value", string_value)?;
         let result: Result<String> = object.try_into();
         assert!(matches!(result, Err(InvalidValueType(_))));

ristretto_classloader/src/object.rs

@@ -174,16 +174,15 @@ impl Reference {
             Reference::DoubleArray(value) => Reference::DoubleArray(value.deep_clone()?),
             Reference::Array(class, value) => {
                 let values = value.to_vec()?;
-                let array: ConcurrentVec<Option<Reference>> =
-                    ConcurrentVec::with_capacity(values.len());
+                let mut cloned_values = Vec::with_capacity(values.len());
                 for value in values {
                     if let Some(reference) = value {
-                        array.push(Some(reference.deep_clone()?))?;
+                        cloned_values.push(Value::from(reference.deep_clone()?));
                     } else {
-                        array.push(None)?;
+                        cloned_values.push(Value::Object(None));
                     }
                 }
-                Reference::Array(class.clone(), array)
+                Reference::try_from((class.clone(), cloned_values))?
             }
             Reference::Object(value) => Reference::Object(value.deep_clone()?),
         };
@@ -871,7 +870,7 @@ mod tests {
     #[test]
     fn test_display_reference_array() -> Result<()> {
         let class = Class::new_named("[Ljava/lang/Object;")?;
-        let reference = Reference::Array(class, ConcurrentVec::from(vec![None]));
+        let reference = Reference::from((class, vec![None]));
         assert_eq!(reference.class_name(), "[Ljava/lang/Object;");
         assert_eq!(reference.class()?.name(), "[Ljava/lang/Object;");
         assert_eq!(reference.to_string(), "java/lang/Object[1]");
@@ -1125,7 +1124,7 @@ mod tests {
     #[test]
     fn test_clone_reference_array() -> Result<()> {
         let class = minimum_class()?;
-        let reference = Reference::Array(class.clone(), ConcurrentVec::from(vec![None]));
+        let reference = Reference::from((class.clone(), vec![None]));
         let clone = reference.clone();
         assert_eq!(reference, clone);
 
@@ -1140,7 +1139,7 @@ mod tests {
     #[test]
     fn test_deep_clone_reference_array() -> Result<()> {
         let class = minimum_class()?;
-        let reference = Reference::Array(class.clone(), ConcurrentVec::from(vec![None]));
+        let reference = Reference::from((class.clone(), vec![None]));
         let clone = reference.deep_clone()?;
         assert_eq!(reference, clone);
 
@@ -1191,27 +1190,27 @@ mod tests {
     #[test]
     fn test_array_eq() -> Result<()> {
         let class = minimum_class()?;
-        let ref1 = Reference::Array(class.clone(), ConcurrentVec::from(vec![]));
-        let ref2 = Reference::Array(class, ConcurrentVec::from(vec![]));
+        let ref1 = Reference::from((class.clone(), vec![]));
+        let ref2 = Reference::from((class, vec![]));
         assert_eq!(ref1, ref2);
         Ok(())
     }
 
     #[test]
     fn test_array_eq_class_ne() -> Result<()> {
         let minimum_class = minimum_class()?;
-        let ref1 = Reference::Array(minimum_class, ConcurrentVec::from(vec![]));
+        let ref1 = Reference::from((minimum_class, vec![]));
         let simple_class = simple_class()?;
-        let ref2 = Reference::Array(simple_class, ConcurrentVec::from(vec![]));
+        let ref2 = Reference::from((simple_class, vec![]));
         assert_ne!(ref1, ref2);
         Ok(())
     }
 
     #[test]
     fn test_array_eq_value_ne() -> Result<()> {
         let minimum_class = minimum_class()?;
-        let ref1 = Reference::Array(minimum_class.clone(), ConcurrentVec::from(vec![]));
-        let ref2 = Reference::Array(minimum_class, ConcurrentVec::from(vec![None]));
+        let ref1 = Reference::from((minimum_class.clone(), vec![]));
+        let ref2 = Reference::from((minimum_class, vec![None]));
         assert_ne!(ref1, ref2);
         Ok(())
     }

ristretto_classloader/src/reference.rs

@@ -6,7 +6,7 @@ use crate::frame::{ExecutionResult, Frame};
 use crate::operand_stack::OperandStack;
 use ristretto_classfile::BaseType;
 use ristretto_classfile::attributes::ArrayType;
-use ristretto_classloader::{ConcurrentVec, Reference};
+use ristretto_classloader::Reference;
 
 /// See: <https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-6.html#jvms-6.5.newarray>
 #[inline]
@@ -43,7 +43,7 @@ pub(crate) async fn anewarray(
     let class = thread.class(array_class_name.as_str()).await?;
     let count = stack.pop_int()?;
     let count = usize::try_from(count)?;
-    let array = Reference::Array(class, ConcurrentVec::from(vec![None; count]));
+    let array = Reference::from((class, vec![None; count]));
     stack.push_object(Some(array))?;
     Ok(Continue)
 }
@@ -105,7 +105,7 @@ pub(crate) async fn multianewarray(
     } else {
         type_class_name = format!("[L{type_class_name};");
         let type_class = thread.class(type_class_name.as_str()).await?;
-        Reference::Array(type_class, ConcurrentVec::from(vec![None; count]))
+        Reference::from((type_class, vec![None; count]))
     };
 
     for _ in 1..dimensions {
@@ -117,7 +117,7 @@ pub(crate) async fn multianewarray(
         for _ in 0..count {
             array_values.push(Some(array.clone()));
         }
-        array = Reference::Array(type_class, ConcurrentVec::from(array_values));
+        array = Reference::from((type_class, array_values));
     }
 
     stack.push_object(Some(array))?;