Add Monitor, add doc comments, add is_same_object, fix ReferenceType generation

Author: wuwbobo2021

java-spaghetti-gen/src/emit_rust/structs.rs

@@ -118,21 +118,15 @@ impl Struct {
 
         let rust_name = &self.rust.struct_name;
         writeln!(out, "{attributes}{visibility} enum {rust_name}{{}}")?;
-        if !self.java.is_static() {
-            writeln!(
-                out,
-                "unsafe impl ::java_spaghetti::ReferenceType for {rust_name} {{\
-               \n    fn jni_get_class(__jni_env: ::java_spaghetti::Env) -> &'static ::java_spaghetti::JClass {{\
-               \n        Self::__class_global_ref(__jni_env)\
-               \n    }}\
-               \n}}",
-            )?;
-        }
+
         writeln!(
             out,
-            "unsafe impl ::java_spaghetti::JniType for {rust_name} {{\
-           \n    fn static_with_jni_type<R>(callback: impl FnOnce(&str) -> R) -> R {{\
-           \n        callback({})\
+            "unsafe impl ::java_spaghetti::ReferenceType for {rust_name} {{\
+           \n    fn jni_reference_type_name() -> ::std::borrow::Cow<'static, str> {{\
+           \n        ::std::borrow::Cow::Borrowed({})\
+           \n    }}\
+           \n    fn jni_get_class(__jni_env: ::java_spaghetti::Env) -> &'static ::java_spaghetti::JClass {{\
+           \n        Self::__class_global_ref(__jni_env)\
            \n    }}\
            \n}}",
             StrEmitter(self.java.path().as_str()),

java-spaghetti/src/array.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::HashMap;
 use std::marker::PhantomData;
 use std::ops::{Bound, RangeBounds};
@@ -6,12 +7,12 @@ use std::sync::{LazyLock, OnceLock, RwLock};
 
 use jni_sys::*;
 
-use crate::{AsArg, Env, JClass, JniType, Local, Ref, ReferenceType, ThrowableType};
+use crate::{AsArg, Env, JClass, Local, Ref, ReferenceType, ThrowableType};
 
 /// A Java Array of some POD-like type such as `bool`, `jbyte`, `jchar`, `jshort`, `jint`, `jlong`, `jfloat`, or `jdouble`.
 ///
 /// Thread safety of avoiding [race conditions](https://www.ibm.com/docs/en/sdk-java-technology/8?topic=jni-synchronization)
-/// is not guaranteed.
+/// is not guaranteed. JNI `GetPrimitiveArrayCritical` cannot ensure exclusive access to the array, so it is not used here.
 ///
 /// See also [ObjectArray] for arrays of reference types.
 ///
@@ -29,35 +30,35 @@ pub trait PrimitiveArray<T>: Sized + ReferenceType
 where
     T: Clone + Default,
 {
-    /// Uses JNI `New{Type}Array` to create a new java array containing "size" elements.
+    /// Uses JNI `New{Type}Array` to create a new Java array containing "size" elements.
     fn new<'env>(env: Env<'env>, size: usize) -> Local<'env, Self>;
 
-    /// Uses JNI `GetArrayLength` to get the length of the java array.
+    /// Uses JNI `GetArrayLength` to get the length of the Java array.
     fn len(self: &Ref<'_, Self>) -> usize;
 
-    /// Uses JNI `Get{Type}ArrayRegion` to read the contents of the java array within `[start .. start + elements.len()]`.
+    /// Uses JNI `Get{Type}ArrayRegion` to read the contents of the Java array within `[start .. start + elements.len()]`.
     ///
     /// Panics if the index is out of bound.
     fn get_region(self: &Ref<'_, Self>, start: usize, elements: &mut [T]);
 
-    /// Uses JNI `Set{Type}ArrayRegion` to set the contents of the java array within `[start .. start + elements.len()]`.
+    /// Uses JNI `Set{Type}ArrayRegion` to set the contents of the Java array within `[start .. start + elements.len()]`.
     ///
     /// Panics if the index is out of bound.
     fn set_region(self: &Ref<'_, Self>, start: usize, elements: &[T]);
 
-    /// Uses JNI `New{Type}Array` + `Set{Type}ArrayRegion` to create a new java array containing a copy of "elements".
+    /// Uses JNI `New{Type}Array` + `Set{Type}ArrayRegion` to create a new Java array containing a copy of "elements".
     fn new_from<'env>(env: Env<'env>, elements: &[T]) -> Local<'env, Self> {
         let array = Self::new(env, elements.len());
         array.set_region(0, elements);
         array
     }
 
-    /// Uses JNI `GetArrayLength` to get the length of the java array, returns `true` if it is 0.
+    /// Uses JNI `GetArrayLength` to get the length of the Java array, returns `true` if it is 0.
     fn is_empty(self: &Ref<'_, Self>) -> bool {
         self.len() == 0
     }
 
-    /// Uses JNI `GetArrayLength` + `Get{Type}ArrayRegion` to read the contents of the java array within given range
+    /// Uses JNI `GetArrayLength` + `Get{Type}ArrayRegion` to read the contents of the Java array within given range
     /// into a new `Vec`.
     ///
     /// Panics if the index is out of bound.
@@ -86,7 +87,7 @@ where
         vec
     }
 
-    /// Uses JNI `GetArrayLength` + `Get{Type}ArrayRegion` to read the contents of the entire java array into a new `Vec`.
+    /// Uses JNI `GetArrayLength` + `Get{Type}ArrayRegion` to read the contents of the entire Java array into a new `Vec`.
     fn as_vec(self: &Ref<'_, Self>) -> Vec<T> {
         self.get_region_as_vec(0..self.len())
     }
@@ -98,14 +99,12 @@ macro_rules! primitive_array {
         pub enum $name {}
 
         unsafe impl ReferenceType for $name {
+            fn jni_reference_type_name() -> Cow<'static, str> {
+                Cow::Borrowed($type_str)
+            }
             fn jni_get_class(env: Env) -> &'static JClass {
                 static CLASS_CACHE: OnceLock<JClass> = OnceLock::new();
-                CLASS_CACHE.get_or_init(|| Self::static_with_jni_type(|t| unsafe { env.require_class(t) }))
-            }
-        }
-        unsafe impl JniType for $name {
-            fn static_with_jni_type<R>(callback: impl FnOnce(&str) -> R) -> R {
-                callback($type_str)
+                CLASS_CACHE.get_or_init(|| unsafe { env.require_class(&Self::jni_reference_type_name()) })
             }
         }
 
@@ -116,8 +115,8 @@ macro_rules! primitive_array {
                 let jnienv = env.as_raw();
                 unsafe {
                     let object = ((**jnienv).v1_2.$new_array)(jnienv, size);
-                    let exception = ((**jnienv).v1_2.ExceptionOccurred)(jnienv);
-                    assert!(exception.is_null()); // Only sane exception here is an OOM exception
+                    assert!(!object.is_null(), "OOM");
+                    env.exception_check_raw().expect("OOM"); // Only sane exception here is an OOM exception
                     Local::from_raw(env, object)
                 }
             }
@@ -203,35 +202,32 @@ primitive_array! { DoubleArray,  "[D\0", jdouble { NewDoubleArray  SetDoubleArra
 /// See also [PrimitiveArray] for arrays of reference types.
 pub struct ObjectArray<T: ReferenceType, E: ThrowableType>(core::convert::Infallible, PhantomData<(T, E)>);
 
-// NOTE: This is a performance compromise for returning `&'static JClass`,
-// still faster than non-cached `require_class`.
+// NOTE: This is a performance compromise for returning `&'static JClass`, still faster than non-cached `FindClass`.
 static OBJ_ARR_CLASSES: LazyLock<RwLock<HashMap<String, &'static JClass>>> =
     LazyLock::new(|| RwLock::new(HashMap::new()));
 
 unsafe impl<T: ReferenceType, E: ThrowableType> ReferenceType for ObjectArray<T, E> {
-    fn jni_get_class(env: Env) -> &'static JClass {
-        Self::static_with_jni_type(|t| {
-            let class_map_reader = OBJ_ARR_CLASSES.read().unwrap();
-            if let Some(&class) = class_map_reader.get(t) {
-                class
-            } else {
-                drop(class_map_reader);
-                let class: &'static JClass = Box::leak(Box::new(unsafe { env.require_class(t) }));
-                let _ = OBJ_ARR_CLASSES.write().unwrap().insert(t.to_string(), class);
-                class
-            }
-        })
+    fn jni_reference_type_name() -> Cow<'static, str> {
+        let inner = T::jni_reference_type_name();
+        Cow::Owned(format!("[L{};\0", inner.trim_end_matches("\0")))
     }
-}
-
-unsafe impl<T: ReferenceType, E: ThrowableType> JniType for ObjectArray<T, E> {
-    fn static_with_jni_type<R>(callback: impl FnOnce(&str) -> R) -> R {
-        T::static_with_jni_type(|inner| callback(format!("[L{};\0", inner.trim_end_matches("\0")).as_str()))
+    fn jni_get_class(env: Env) -> &'static JClass {
+        let t = Self::jni_reference_type_name();
+        let class_map_reader = OBJ_ARR_CLASSES.read().unwrap();
+        if let Some(&class) = class_map_reader.get(t.as_ref()) {
+            class
+        } else {
+            drop(class_map_reader);
+            let class = unsafe { env.require_class(&t) };
+            let class_leaked: &'static JClass = Box::leak(Box::new(class));
+            let _ = OBJ_ARR_CLASSES.write().unwrap().insert(t.to_string(), class_leaked);
+            class_leaked
+        }
     }
 }
 
 impl<T: ReferenceType, E: ThrowableType> ObjectArray<T, E> {
-    /// Uses JNI `NewObjectArray` to create a new java object array.
+    /// Uses JNI `NewObjectArray` to create a new Java object array.
     pub fn new<'env>(env: Env<'env>, size: usize) -> Local<'env, Self> {
         assert!(size <= i32::MAX as usize); // jsize == jint == i32
         let class = T::jni_get_class(env).as_raw();
@@ -242,7 +238,7 @@ impl<T: ReferenceType, E: ThrowableType> ObjectArray<T, E> {
             let fill = null_mut();
             ((**env).v1_2.NewObjectArray)(env, size, class, fill)
         };
-        // Only sane exception here is an OOM exception
+        assert!(!object.is_null(), "OOM");
         env.exception_check::<E>().map_err(|_| "OOM").unwrap();
         unsafe { Local::from_raw(env, object) }
     }
@@ -256,7 +252,7 @@ impl<T: ReferenceType, E: ThrowableType> ObjectArray<T, E> {
         }
     }
 
-    /// Uses JNI `NewObjectArray` to create a new java object array of the exact size, then sets its items
+    /// Uses JNI `NewObjectArray` to create a new Java object array of the exact size, then sets its items
     /// with the iterator of JNI (null?) references.
     pub fn new_from<'env>(env: Env<'env>, elements: impl ExactSizeIterator<Item = impl AsArg<T>>) -> Local<'env, Self> {
         let size = elements.len();
@@ -269,13 +265,13 @@ impl<T: ReferenceType, E: ThrowableType> ObjectArray<T, E> {
         array
     }
 
-    /// Uses JNI `GetArrayLength` to get the length of the java array.
+    /// Uses JNI `GetArrayLength` to get the length of the Java array.
     pub fn len(self: &Ref<'_, Self>) -> usize {
         let env = self.env().as_raw();
         unsafe { ((**env).v1_2.GetArrayLength)(env, self.as_raw()) as usize }
     }
 
-    /// Uses JNI `GetArrayLength` to get the length of the java array, returns `true` if it is 0.
+    /// Uses JNI `GetArrayLength` to get the length of the Java array, returns `true` if it is 0.
     pub fn is_empty(self: &Ref<'_, Self>) -> bool {
         self.len() == 0
     }

java-spaghetti/src/env.rs

@@ -140,22 +140,31 @@ impl<'env> Env<'env> {
         CLASS_LOADER.store(classloader, Ordering::Relaxed);
     }
 
+    /// Checks if an exception has occurred; if occurred, it clears the exception to make the next
+    /// JNI call possible, then it returns the exception as an `Err`.
+    ///
     /// XXX: Make this method public after making sure that it has a proper name.
     /// Note that there is `ExceptionCheck` in JNI functions, which does not create a
     /// local reference to the exception object.
     pub(crate) fn exception_check<E: ThrowableType>(self) -> Result<(), Local<'env, E>> {
+        self.exception_check_raw()
+            .map_err(|throwable| unsafe { Local::from_raw(self, throwable) })
+    }
+
+    /// The same as `exception_check`, except that it may return a raw local reference of the exception.
+    pub(crate) fn exception_check_raw(self) -> Result<(), jthrowable> {
         unsafe {
             let exception = ((**self.env).v1_2.ExceptionOccurred)(self.env);
             if exception.is_null() {
                 Ok(())
             } else {
                 ((**self.env).v1_2.ExceptionClear)(self.env);
-                Err(Local::from_raw(self, exception))
+                Err(exception as jthrowable)
             }
         }
     }
 
-    unsafe fn exception_to_string(self, exception: jobject) -> String {
+    pub(crate) unsafe fn raw_exception_to_string(self, exception: jthrowable) -> String {
         static METHOD_GET_MESSAGE: OnceLock<JMethodID> = OnceLock::new();
         let throwable_get_message = *METHOD_GET_MESSAGE.get_or_init(|| {
             // use JNI FindClass to avoid infinte recursion.
@@ -165,12 +174,8 @@ impl<'env> Env<'env> {
 
         let message =
             ((**self.env).v1_2.CallObjectMethodA)(self.env, exception, throwable_get_message.as_raw(), ptr::null_mut());
-        let e2: *mut _jobject = ((**self.env).v1_2.ExceptionOccurred)(self.env);
-        if !e2.is_null() {
-            ((**self.env).v1_2.ExceptionClear)(self.env);
-            panic!("exception happened calling Throwable.getMessage()");
-        }
-
+        self.exception_check_raw()
+            .expect("exception happened calling Throwable.getMessage()");
         StringChars::from_env_jstring(self, message).to_string_lossy()
     }
 
@@ -201,12 +206,10 @@ impl<'env> Env<'env> {
             let args = [jvalue { l: string }];
             let result: *mut _jobject =
                 ((**self.env).v1_2.CallObjectMethodA)(self.env, classloader, cl_method.as_raw(), args.as_ptr());
-            let exception: *mut _jobject = ((**self.env).v1_2.ExceptionOccurred)(self.env);
-            if !exception.is_null() {
-                ((**self.env).v1_2.ExceptionClear)(self.env);
+            if let Err(exception) = self.exception_check_raw() {
                 panic!(
                     "exception happened calling loadClass(): {}",
-                    self.exception_to_string(exception)
+                    self.raw_exception_to_string(exception)
                 );
             } else if result.is_null() {
                 panic!("loadClass() returned null");
@@ -224,11 +227,7 @@ impl<'env> Env<'env> {
     unsafe fn require_class_jni(self, class: &str) -> Option<JClass> {
         assert!(class.ends_with('\0'));
         let cls = ((**self.env).v1_2.FindClass)(self.env, class.as_ptr() as *const c_char);
-        let exception: *mut _jobject = ((**self.env).v1_2.ExceptionOccurred)(self.env);
-        if !exception.is_null() {
-            ((**self.env).v1_2.ExceptionClear)(self.env);
-            return None;
-        }
+        self.exception_check_raw().ok()?;
         if cls.is_null() {
             return None;
         }