Merge pull request #424 from theseus-rs/fix-class-lookups

fix: lookup classes using existing thread context instead of vm

Author: brianheineman

ristretto_vm/src/instruction/array.rs

@@ -81,10 +81,9 @@ pub(crate) async fn multianewarray(
     dimensions: u8,
 ) -> Result<ExecutionResult> {
     let thread = frame.thread()?;
-    let vm = thread.vm()?;
     let constant_pool = frame.class().constant_pool();
     let class_name = constant_pool.try_get_class(index)?;
-    let class = vm.class(class_name).await?;
+    let class = thread.class(class_name).await?;
     let count = stack.pop_int()?;
     let count = usize::try_from(count)?;
 
@@ -112,7 +111,7 @@ pub(crate) async fn multianewarray(
         let count = stack.pop_int()?;
         let count = usize::try_from(count)?;
         type_class_name = format!("[{type_class_name}");
-        let type_class = vm.class(type_class_name.as_str()).await?;
+        let type_class = thread.class(type_class_name.as_str()).await?;
         let mut array_values = Vec::new();
         for _ in 0..count {
             array_values.push(Some(array.clone()));

ristretto_vm/src/instruction/exception.rs

@@ -26,7 +26,6 @@ pub(crate) async fn process_throwable(
     throwable: Object,
 ) -> Result<usize> {
     let thread = frame.thread()?;
-    let vm = thread.vm()?;
     let throwable_class = throwable.class();
     let class = frame.class();
     let constant_pool = class.constant_pool();
@@ -48,7 +47,7 @@ pub(crate) async fn process_throwable(
         } else {
             let exception_class_name =
                 constant_pool.try_get_class(exception_table_entry.catch_type)?;
-            let exception_class = vm.class(exception_class_name).await?;
+            let exception_class = thread.class(exception_class_name).await?;
             exception_class.is_assignable_from(throwable_class)?
         };
 

ristretto_vm/src/instruction/invokedynamic.rs

@@ -291,13 +291,17 @@ async fn resolve_method_handles_lookup(thread: &Thread) -> Result<Value> {
 /// that represents that type in the JVM. For primitive types and arrays, this returns the
 /// corresponding class objects (like `java.lang.Integer.TYPE` for `int`). For reference types, it
 /// loads the class for the specified type.
-async fn get_field_type_class(vm: &VM, field_type: Option<FieldType>) -> Result<Value> {
+async fn get_field_type_class(
+    vm: &VM,
+    thread: &Thread,
+    field_type: Option<FieldType>,
+) -> Result<Value> {
     let class_name = if let Some(field_type) = field_type {
         field_type.class_name()
     } else {
         "void".to_string()
     };
-    let class = vm.class(class_name).await?;
+    let class = thread.class(class_name).await?;
     class.to_object(vm).await
 }
 
@@ -313,7 +317,7 @@ async fn get_field_type_class(vm: &VM, field_type: Option<FieldType>) -> Result<
 /// `MethodType.methodType()` factory method to create a `MethodType` instance.
 async fn get_method_type(vm: &VM, thread: &Thread, method_descriptor: &str) -> Result<Value> {
     let (argument_types, return_type) = FieldType::parse_method_descriptor(method_descriptor)?;
-    let return_class = get_field_type_class(vm, return_type).await?;
+    let return_class = get_field_type_class(vm, thread, return_type).await?;
 
     let method_type_class = thread.class("java.lang.invoke.MethodType").await?;
     if argument_types.is_empty() {
@@ -326,14 +330,14 @@ async fn get_method_type(vm: &VM, thread: &Thread, method_descriptor: &str) -> R
             .await;
     }
 
-    let first_argument = get_field_type_class(vm, argument_types.first().cloned()).await?;
+    let first_argument = get_field_type_class(vm, thread, argument_types.first().cloned()).await?;
     let argument_classes = ConcurrentVec::from(Vec::with_capacity(argument_types.len() - 1));
     for argument_type in argument_types.iter().skip(1) {
-        let argument_class = get_field_type_class(vm, Some(argument_type.clone())).await?;
+        let argument_class = get_field_type_class(vm, thread, Some(argument_type.clone())).await?;
         let argument_reference: Reference = argument_class.try_into()?;
         argument_classes.push(Some(argument_reference))?;
     }
-    let class_array = vm.class("[Ljava/lang/Class;").await?;
+    let class_array = thread.class("[Ljava/lang/Class;").await?;
     let reference_array = Reference::Array(ObjectArray {
         class: class_array,
         elements: argument_classes,

ristretto_vm/src/intrinsic_methods/java/io/unixfilesystem.rs

@@ -531,7 +531,7 @@ pub(crate) async fn list_0(
         entries = path_entries;
     }
 
-    let class = vm.class("java.lang.String").await?;
+    let class = thread.class("java.lang.String").await?;
     let paths = Value::try_from((class, entries))?;
     Ok(Some(paths))
 }

ristretto_vm/src/intrinsic_methods/java/lang/class.rs

@@ -1139,7 +1139,7 @@ mod tests {
     #[tokio::test]
     async fn test_get_constant_pool_1() -> Result<()> {
         let (vm, thread) = crate::test::thread().await.expect("thread");
-        let class = vm.class("java.lang.String").await?;
+        let class = thread.class("java.lang.String").await?;
         let class_object = class.to_object(&vm).await?;
         let parameters = Parameters::new(vec![class_object]);
         let constant_pool: Object = get_constant_pool_1(thread, parameters)
@@ -1493,7 +1493,7 @@ mod tests {
     #[tokio::test]
     async fn test_get_raw_annotations() -> Result<()> {
         let (vm, thread) = crate::test::thread().await.expect("thread");
-        let class = vm.class("java.lang.String").await?;
+        let class = thread.class("java.lang.String").await?;
         let class_object = class.to_object(&vm).await?;
         let parameters = Parameters::new(vec![class_object]);
         let value = get_raw_annotations(thread, parameters)
@@ -1507,7 +1507,7 @@ mod tests {
     #[tokio::test]
     async fn test_get_raw_type_annotations() -> Result<()> {
         let (vm, thread) = crate::test::thread().await.expect("thread");
-        let class = vm.class("java.lang.String").await?;
+        let class = thread.class("java.lang.String").await?;
         let class_object = class.to_object(&vm).await?;
         let parameters = Parameters::new(vec![class_object]);
         let value = get_raw_type_annotations(thread, parameters)

ristretto_vm/src/intrinsic_methods/java/lang/classloader.rs

@@ -214,10 +214,10 @@ pub(crate) async fn find_bootstrap_class(
     mut parameters: Parameters,
 ) -> Result<Option<Value>> {
     let class_name: String = parameters.pop()?.try_into()?;
-    let vm = thread.vm()?;
-    let Ok(class) = vm.class(class_name).await else {
+    let Ok(class) = thread.class(class_name).await else {
         return Ok(Some(Value::Object(None)));
     };
+    let vm = thread.vm()?;
     let class = class.to_object(&vm).await?;
     Ok(Some(class))
 }
@@ -245,10 +245,10 @@ pub(crate) async fn find_loaded_class_0(
     mut parameters: Parameters,
 ) -> Result<Option<Value>> {
     let class_name: String = parameters.pop()?.try_into()?;
-    let vm = thread.vm()?;
-    let Ok(class) = vm.class(class_name).await else {
+    let Ok(class) = thread.class(class_name).await else {
         return Ok(Some(Value::Object(None)));
     };
+    let vm = thread.vm()?;
     let class = class.to_object(&vm).await?;
     Ok(Some(class))
 }

ristretto_vm/src/intrinsic_methods/java/lang/processenvironment.rs

@@ -18,8 +18,7 @@ pub(crate) async fn environ(thread: Arc<Thread>, _parameters: Parameters) -> Res
         let value = Some(Reference::from(mutf8::to_bytes(value)?));
         values.push(value);
     }
-    let vm = thread.vm()?;
-    let class = vm.class("[[B").await?;
+    let class = thread.class("[[B").await?;
     let result = Reference::from((class, values));
     Ok(Some(Value::Object(Some(result))))
 }

ristretto_vm/src/intrinsic_methods/jdk/internal/reflect/nativeconstructoraccessorimpl.rs

@@ -49,11 +49,11 @@ pub(crate) mod tests {
 
     pub(crate) async fn new_instance_test(new_instance: IntrinsicMethod) -> Result<()> {
         let (vm, thread) = crate::test::thread().await.expect("thread");
-        let integer_class = vm.class("java/lang/Integer").await?;
+        let integer_class = thread.class("java/lang/Integer").await?;
         let integer_class_object = integer_class.to_object(&vm).await?;
 
-        let class = vm.class("java/lang/Class").await?;
-        let string_class = vm.class("java/lang/String").await?;
+        let class = thread.class("java/lang/Class").await?;
+        let string_class = thread.class("java/lang/String").await?;
         let string_class_object = string_class.to_object(&vm).await?;
         let arguments = Value::try_from((class.clone(), vec![string_class_object]))?;
 

ristretto_vm/src/intrinsic_methods/jdk/internal/reflect/nativemethodaccessorimpl.rs

@@ -63,12 +63,12 @@ pub(crate) mod tests {
 
     pub(crate) async fn invoke_test(invoke: IntrinsicMethod) -> Result<()> {
         let (vm, thread) = crate::test::thread().await.expect("thread");
-        let integer_class = vm.class("java/lang/Integer").await?;
+        let integer_class = thread.class("java/lang/Integer").await?;
         let integer_class_object = integer_class.to_object(&vm).await?;
 
         let method_name = "valueOf".to_object(&vm).await?;
-        let class = vm.class("java/lang/Class").await?;
-        let string_class = vm.class("java/lang/String").await?;
+        let class = thread.class("java/lang/Class").await?;
+        let string_class = thread.class("java/lang/String").await?;
         let string_class_object = string_class.to_object(&vm).await?;
         let arguments = Value::try_from((class.clone(), vec![string_class_object]))?;