Remove async where applicable

Author: dlunch

Cargo.lock

@@ -13,7 +13,7 @@ async-trait = { version = "^0.1", default-features = false }
 bytemuck = { version = "^1.19", default-features = false, features = ["extern_crate_alloc"] }
 dyn-clone = { version = "^1.0", default-features = false }
 nom = { version = "^7.1", default-features = false, features = ["alloc"] }
-async-lock = { version = "^3.3", default-features = false }
+parking_lot = { version = "^0.12", default-features = false }
 tracing = { version = "^0.1", default-features = false, features = ["attributes"] }
 
 tokio = { version = "^1.41", features = ["macros"] }

Cargo.toml

@@ -8,9 +8,10 @@ license.workspace = true
 async-trait = { workspace = true }
 bytemuck = { workspace = true }
 dyn-clone = { workspace = true }
-async-lock = { workspace = true }
+parking_lot = { workspace = true }
 tracing = { workspace = true }
 
+async-lock = { version = "^3.4", default-features = false }
 encoding_rs = { version = "^0.8", features = ["alloc"], default-features = false }
 event-listener = { version = "^5.3", default-features = false }
 hashbrown = { version = "^0.14", features = ["ahash"], default-features = false }

java_runtime/Cargo.toml

@@ -2,9 +2,9 @@ use core::cmp::min;
 
 use alloc::{sync::Arc, vec};
 
-use async_lock::Mutex;
 use bytemuck::{cast_slice, cast_vec};
 use encoding_rs::{Decoder, EUC_KR, UTF_8};
+use parking_lot::Mutex;
 
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
 use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result};
@@ -115,7 +115,7 @@ impl InputStreamReader {
             let decoder: Arc<Mutex<Decoder>> = jvm.get_rust_object_field(&this, "decoder").await?;
 
             let mut decoded = vec![0; BUF_SIZE * 3];
-            let (_, read, wrote, _) = decoder.lock().await.decode_to_utf16(&cast_vec(read_buf_data), &mut decoded, false);
+            let (_, read, wrote, _) = decoder.lock().decode_to_utf16(&cast_vec(read_buf_data), &mut decoded, false);
 
             // advance readBuf
             let _: () = jvm

java_runtime/src/classes/java/io/input_stream_reader.rs

@@ -64,7 +64,7 @@ impl Class {
         let rust_class = JavaLangClass::to_rust_class(jvm, &this).await?;
         let other_rust_class = JavaLangClass::to_rust_class(jvm, &other).await?;
 
-        Ok(jvm.is_inherited_from(&*other_rust_class, &rust_class.name()).await)
+        Ok(jvm.is_inherited_from(&*other_rust_class, &rust_class.name()))
     }
 
     async fn get_resource_as_stream(
@@ -99,7 +99,7 @@ mod test {
     async fn test_class() -> Result<()> {
         let jvm = test_jvm().await?;
 
-        let java_class = jvm.resolve_class("java/lang/String").await?.java_class(&jvm).await?;
+        let java_class = jvm.resolve_class("java/lang/String").await?.java_class()?;
 
         let rust_class = JavaLangClass::to_rust_class(&jvm, &java_class).await?;
         assert_eq!(rust_class.name(), "java/lang/String");
@@ -115,15 +115,15 @@ mod test {
     async fn test_is_assignable_from() -> Result<()> {
         let jvm = test_jvm().await?;
 
-        let string_class = jvm.resolve_class("java/lang/String").await?.java_class(&jvm).await?;
-        let object_class = jvm.resolve_class("java/lang/Object").await?.java_class(&jvm).await?;
+        let string_class = jvm.resolve_class("java/lang/String").await?.java_class()?;
+        let object_class = jvm.resolve_class("java/lang/Object").await?.java_class()?;
 
         let result: bool = jvm
             .invoke_virtual(&object_class, "isAssignableFrom", "(Ljava/lang/Class;)Z", (string_class.clone(),))
             .await?;
         assert!(result);
 
-        let thread_class = jvm.resolve_class("java/lang/Thread").await?.java_class(&jvm).await?;
+        let thread_class = jvm.resolve_class("java/lang/Thread").await?.java_class()?;
 
         let result: bool = jvm
             .invoke_virtual(&string_class, "isAssignableFrom", "(Ljava/lang/Class;)Z", (thread_class,))

java_runtime/src/classes/java/lang/class.rs

@@ -203,13 +203,13 @@ impl ClassLoader {
         tracing::debug!("java.lang.ClassLoader::findLoadedClass({:?}, {:?})", &this, name);
 
         let rust_name = JavaLangString::to_rust_string(jvm, &name).await?;
-        if !jvm.has_class(&rust_name).await {
+        if !jvm.has_class(&rust_name) {
             return Ok(None.into());
         }
 
         let class = jvm.resolve_class(&rust_name).await?;
 
-        Ok(class.java_class(jvm).await?.into())
+        Ok(class.java_class()?.into())
     }
 
     async fn get_resource(

java_runtime/src/classes/java/lang/class_loader.rs

@@ -50,7 +50,7 @@ impl Object {
         let this: Box<dyn ClassInstance> = this.into();
         let class_name = this.class_definition().name();
 
-        let class = jvm.resolve_class(&class_name).await?.java_class(jvm).await?;
+        let class = jvm.resolve_class(&class_name).await?.java_class()?;
 
         Ok(class.into())
     }
@@ -218,13 +218,13 @@ mod test {
         #[async_trait::async_trait]
         impl SpawnCallback for Notifier {
             async fn call(&self) -> Result<()> {
-                self.jvm.attach_thread().await?;
+                self.jvm.attach_thread()?;
 
                 self.runtime.sleep(Duration::from_millis(100)).await;
                 self.notified.store(true, Ordering::Relaxed);
                 let _: () = self.jvm.invoke_virtual(&self.target, "notify", "()V", ()).await?;
 
-                self.jvm.detach_thread().await?;
+                self.jvm.detach_thread()?;
 
                 Ok(())
             }
@@ -265,13 +265,13 @@ mod test {
         #[async_trait::async_trait]
         impl SpawnCallback for Notifier {
             async fn call(&self) -> Result<()> {
-                self.jvm.attach_thread().await?;
+                self.jvm.attach_thread()?;
 
                 self.runtime.sleep(Duration::from_millis(1000)).await;
                 self.notified.store(true, Ordering::Relaxed);
                 let _: () = self.jvm.invoke_virtual(&self.target, "notify", "()V", ()).await?;
 
-                self.jvm.detach_thread().await?;
+                self.jvm.detach_thread()?;
 
                 Ok(())
             }

java_runtime/src/classes/java/lang/object.rs

@@ -93,11 +93,11 @@ impl Thread {
             async fn call(&self) -> Result<()> {
                 tracing::trace!("Thread start");
 
-                self.jvm.attach_thread().await?;
+                self.jvm.attach_thread()?;
 
                 let _: () = self.jvm.invoke_virtual(&self.this, "run", "()V", []).await?;
 
-                self.jvm.detach_thread().await?;
+                self.jvm.detach_thread()?;
 
                 self.join_event.notify(usize::MAX);
 

java_runtime/src/classes/java/lang/thread.rs

@@ -76,7 +76,7 @@ impl Throwable {
     async fn fill_in_stack_trace(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
         tracing::debug!("java.lang.Throwable::fillInStackTrace({:?})", &this);
 
-        let stack_trace = Arc::new(jvm.stack_trace().await);
+        let stack_trace = Arc::new(jvm.stack_trace());
 
         jvm.put_rust_object_field(&mut this, "stackTrace", stack_trace).await?;
 

java_runtime/src/classes/java/lang/throwable.rs

@@ -5,8 +5,8 @@ use core::iter;
 extern crate std;
 use std::io::{Cursor, Read};
 
-use async_lock::Mutex;
 use bytemuck::cast_vec;
+use parking_lot::Mutex;
 use zip::ZipArchive;
 
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
@@ -82,7 +82,7 @@ impl ZipFile {
         let name = JavaLangString::to_rust_string(jvm, &name).await?;
 
         let zip: JavaZipArchive = jvm.get_rust_object_field(&this, "zip").await?;
-        let file_size = zip.lock().await.by_name(&name).map(|x| x.size());
+        let file_size = zip.lock().by_name(&name).map(|x| x.size());
 
         if let Ok(x) = file_size {
             let _: () = jvm.invoke_virtual(&entry, "setSize", "(J)V", (x as i64,)).await?;
@@ -97,7 +97,7 @@ impl ZipFile {
         tracing::debug!("java.util.zip.ZipFile::entries({:?})", &this);
 
         let zip: JavaZipArchive = jvm.get_rust_object_field(&this, "zip").await?;
-        let names = zip.lock().await.file_names().map(|x| x.to_string()).collect::<Vec<_>>();
+        let names = zip.lock().file_names().map(|x| x.to_string()).collect::<Vec<_>>();
 
         let mut name_array = jvm.instantiate_array("Ljava/lang/String;", names.len() as _).await?;
         for (i, name) in names.iter().enumerate() {
@@ -130,7 +130,7 @@ impl ZipFile {
         let data = {
             let zip: JavaZipArchive = jvm.get_rust_object_field(&this, "zip").await?;
 
-            let mut zip = zip.lock().await;
+            let mut zip = zip.lock();
             let mut file = zip.by_name(&entry_name).unwrap();
 
             let mut buf = Vec::new();