Use newtypes for cached method/field IDs

Author: wuwbobo2021

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

@@ -159,7 +159,8 @@ impl<'a> Field<'a> {
                 )?;
                 writeln!(
                     out,
-                    "{indent}    static __FIELD: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();"
+                    "{indent}    static __FIELD: ::std::sync::OnceLock<::java_spaghetti::JFieldID> \
+                        = ::std::sync::OnceLock::new();"
                 )?;
                 writeln!(out, "{indent}    unsafe {{")?;
                 if !self.java.is_static() {
@@ -172,9 +173,9 @@ impl<'a> Field<'a> {
                 writeln!(
                     out,
                     "{indent}        \
-                    let __jni_field = *__FIELD.get_or_init(|| \
-                        __jni_env.require_{}field(__jni_class, {}, {}).addr()\
-                    ) as ::java_spaghetti::sys::jfieldID;",
+                    let __jni_field = __FIELD.get_or_init(|| \
+                        ::java_spaghetti::JFieldID::from_raw(__jni_env.require_{}field(__jni_class, {}, {}))\
+                    ).as_raw();",
                     if self.java.is_static() { "static_" } else { "" },
                     StrEmitter(self.java.name()),
                     StrEmitter(FieldSigWriter(self.java.descriptor()))
@@ -213,7 +214,8 @@ impl<'a> Field<'a> {
                     )?;
                     writeln!(
                         out,
-                        "{indent}    static __FIELD: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();"
+                        "{indent}    static __FIELD: ::std::sync::OnceLock<::java_spaghetti::JFieldID> \
+                            = ::std::sync::OnceLock::new();"
                     )?;
                     writeln!(out, "{indent}    unsafe {{")?;
                     if !self.java.is_static() {
@@ -226,9 +228,9 @@ impl<'a> Field<'a> {
                     writeln!(
                         out,
                         "{indent}        \
-                        let __jni_field = *__FIELD.get_or_init(|| \
-                            __jni_env.require_{}field(__jni_class, {}, {}).addr()\
-                        ) as ::java_spaghetti::sys::jfieldID;",
+                        let __jni_field = __FIELD.get_or_init(|| \
+                            ::java_spaghetti::JFieldID::from_raw(__jni_env.require_{}field(__jni_class, {}, {}))\
+                        ).as_raw();",
                         if self.java.is_static() { "static_" } else { "" },
                         StrEmitter(self.java.name()),
                         StrEmitter(FieldSigWriter(self.java.descriptor()))

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

@@ -209,7 +209,8 @@ impl<'a> Method<'a> {
 
         writeln!(
             out,
-            "{indent}    static __METHOD: ::std::sync::OnceLock<usize> = ::std::sync::OnceLock::new();"
+            "{indent}    static __METHOD: ::std::sync::OnceLock<::java_spaghetti::JMethodID> \
+                = ::std::sync::OnceLock::new();"
         )?;
         writeln!(out, "{indent}    unsafe {{")?;
         writeln!(out, "{indent}        let __jni_args = [{params_array}];")?;
@@ -223,9 +224,9 @@ impl<'a> Method<'a> {
         writeln!(
             out,
             "{indent}        \
-            let __jni_method = *__METHOD.get_or_init(|| \
-                __jni_env.require_{}method(__jni_class, {}, {}).addr()\
-            ) as ::java_spaghetti::sys::jmethodID;",
+            let __jni_method = __METHOD.get_or_init(|| \
+                ::java_spaghetti::JMethodID::from_raw(__jni_env.require_{}method(__jni_class, {}, {}))\
+            ).as_raw();",
             if self.java.is_static() { "static_" } else { "" },
             StrEmitter(self.java.name()),
             StrEmitter(MethodSigWriter(self.java.descriptor()))

java-spaghetti/src/id_cache.rs

@@ -0,0 +1,62 @@
+//! New types for `jfieldID` and `jmethodID` that implement `Send` and `Sync`.
+//!
+//! Inspired by: <https://docs.rs/jni/0.21.1/jni/objects/struct.JMethodID.html>.
+//!
+//! According to the JNI spec field IDs may be invalidated when the corresponding class is unloaded:
+//! <https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/design.html#accessing_fields_and_methods>
+//!
+//! You should generally not be interacting with these types directly, but it must be public for codegen.
+
+use crate::sys::{jfieldID, jmethodID};
+
+#[doc(hidden)]
+#[repr(transparent)]
+pub struct JFieldID {
+    internal: jfieldID,
+}
+
+// Field IDs are valid across threads (not tied to a JNIEnv)
+unsafe impl Send for JFieldID {}
+unsafe impl Sync for JFieldID {}
+
+impl JFieldID {
+    /// Creates a [`JFieldID`] that wraps the given `raw` [`jfieldID`].
+    ///
+    /// # Safety
+    ///
+    /// Expects a valid, non-`null` ID.
+    pub unsafe fn from_raw(raw: jfieldID) -> Self {
+        debug_assert!(!raw.is_null(), "from_raw fieldID argument");
+        Self { internal: raw }
+    }
+
+    pub fn as_raw(&self) -> jfieldID {
+        self.internal
+    }
+}
+
+#[doc(hidden)]
+#[repr(transparent)]
+pub struct JMethodID {
+    internal: jmethodID,
+}
+
+// Method IDs are valid across threads (not tied to a JNIEnv)
+unsafe impl Send for JMethodID {}
+unsafe impl Sync for JMethodID {}
+
+impl JMethodID {
+    /// Creates a [`JMethodID`] that wraps the given `raw` [`jmethodID`].
+    ///
+    /// # Safety
+    ///
+    /// Expects a valid, non-`null` ID.
+    pub unsafe fn from_raw(raw: jmethodID) -> Self {
+        debug_assert!(!raw.is_null(), "from_raw methodID argument");
+        Self { internal: raw }
+    }
+
+    pub fn as_raw(&self) -> jmethodID {
+        self.internal
+    }
+}

java-spaghetti/src/lib.rs

@@ -29,13 +29,15 @@ mod refs {
 mod array;
 mod as_jvalue;
 mod env;
+mod id_cache;
 mod jni_type;
 mod string_chars;
 mod vm;
 
 pub use array::*;
 pub use as_jvalue::*;
 pub use env::*;
+pub use id_cache::*;
 pub use jni_type::JniType;
 pub use refs::*;
 pub use string_chars::*;