Add useful panic messages on missing classes, methods, fields.

Author: Dirbaio

java-spaghetti/src/env.rs

@@ -162,8 +162,9 @@ impl<'env> Env<'env> {
         static METHOD_GET_MESSAGE: OnceLock<usize> = OnceLock::new();
         let throwable_get_message = *METHOD_GET_MESSAGE.get_or_init(|| {
             // use JNI FindClass to avoid infinte recursion.
-            let throwable_class = self.require_class_jni(c"java/lang/Throwable");
-            let method = self.require_method(throwable_class, c"getMessage", c"()Ljava/lang/String;");
+            let class_name = c"java/lang/Throwable";
+            let throwable_class = self.require_class_jni(class_name);
+            let method = self.require_method(throwable_class, class_name, c"getMessage", c"()Ljava/lang/String;");
             ((**self.env).v1_2.DeleteLocalRef)(self.env, throwable_class);
             method.addr()
         }) as jmethodID; // it is a global ID
@@ -206,8 +207,14 @@ impl<'env> Env<'env> {
             let cl_method = *CL_METHOD.get_or_init(|| {
                 // We still use JNI FindClass for this, to avoid a chicken-and-egg situation.
                 // If the system class loader cannot find java.lang.ClassLoader, things are pretty broken!
-                let cl_class = self.require_class_jni(c"java/lang/ClassLoader");
-                let cl_method = self.require_method(cl_class, c"loadClass", c"(Ljava/lang/String;)Ljava/lang/Class;");
+                let class_name = c"java/lang/ClassLoader";
+                let cl_class = self.require_class_jni(class_name);
+                let cl_method = self.require_method(
+                    cl_class,
+                    class_name,
+                    c"loadClass",
+                    c"(Ljava/lang/String;)Ljava/lang/Class;",
+                );
                 ((**self.env).v1_2.DeleteLocalRef)(self.env, cl_class);
                 cl_method.addr()
             }) as jmethodID; // it is a global ID
@@ -237,65 +244,100 @@ impl<'env> Env<'env> {
 
     unsafe fn require_class_jni(self, class: &CStr) -> jclass {
         let class = ((**self.env).v1_2.FindClass)(self.env, class.as_ptr());
-        assert!(!class.is_null());
+        assert!(!class.is_null(), "could not find class {class:?}");
         class
     }
 
-    pub unsafe fn require_method(self, class: jclass, method: &CStr, descriptor: &CStr) -> jmethodID {
+    pub unsafe fn require_method(
+        self,
+        class: jclass,
+        class_name: &CStr,
+        method: &CStr,
+        descriptor: &CStr,
+    ) -> jmethodID {
         let method = ((**self.env).v1_2.GetMethodID)(self.env, class, method.as_ptr(), descriptor.as_ptr());
-        assert!(!method.is_null());
+        assert!(
+            !method.is_null(),
+            "could not find method {method:?} {descriptor:?} on class {class_name:?}"
+        );
         method
     }
 
-    pub unsafe fn require_static_method(self, class: jclass, method: &CStr, descriptor: &CStr) -> jmethodID {
+    pub unsafe fn require_static_method(
+        self,
+        class: jclass,
+        class_name: &CStr,
+        method: &CStr,
+        descriptor: &CStr,
+    ) -> jmethodID {
         let method = ((**self.env).v1_2.GetStaticMethodID)(self.env, class, method.as_ptr(), descriptor.as_ptr());
-        assert!(!method.is_null());
+        assert!(
+            !method.is_null(),
+            "could not find static method {method:?} {descriptor:?} on class {class_name:?}"
+        );
         method
     }
 
-    pub unsafe fn require_field(self, class: jclass, field: &CStr, descriptor: &CStr) -> jfieldID {
+    pub unsafe fn require_field(self, class: jclass, class_name: &CStr, field: &CStr, descriptor: &CStr) -> jfieldID {
         let field = ((**self.env).v1_2.GetFieldID)(self.env, class, field.as_ptr(), descriptor.as_ptr());
-        assert!(!field.is_null());
+        assert!(
+            !field.is_null(),
+            "could not find field {field:?} {descriptor:?} on class {class_name:?}"
+        );
         field
     }
 
-    pub unsafe fn require_static_field(self, class: jclass, field: &CStr, descriptor: &CStr) -> jfieldID {
+    pub unsafe fn require_static_field(
+        self,
+        class: jclass,
+        class_name: &CStr,
+        field: &CStr,
+        descriptor: &CStr,
+    ) -> jfieldID {
         let field = ((**self.env).v1_2.GetStaticFieldID)(self.env, class, field.as_ptr(), descriptor.as_ptr());
-        assert!(!field.is_null());
+        assert!(
+            !field.is_null(),
+            "could not find static field {field:?} {descriptor:?} on class {class_name:?}"
+        );
         field
     }
 
     // Multi-Query Methods
     // XXX: Remove these unused functions.
 
-    pub unsafe fn require_class_method(self, class: &CStr, method: &CStr, descriptor: &CStr) -> (jclass, jmethodID) {
-        let class = self.require_class(class);
-        (class, self.require_method(class, method, descriptor))
+    pub unsafe fn require_class_method(
+        self,
+        class_name: &CStr,
+        method: &CStr,
+        descriptor: &CStr,
+    ) -> (jclass, jmethodID) {
+        let class = self.require_class(class_name);
+        (class, self.require_method(class, class_name, method, descriptor))
     }
 
     pub unsafe fn require_class_static_method(
         self,
-        class: &CStr,
+        class_name: &CStr,
         method: &CStr,
         descriptor: &CStr,
     ) -> (jclass, jmethodID) {
-        let class = self.require_class(class);
-        (class, self.require_static_method(class, method, descriptor))
+        let class = self.require_class(class_name);
+        (class, self.require_static_method(class, class_name, method, descriptor))
     }
 
-    pub unsafe fn require_class_field(self, class: &CStr, method: &CStr, descriptor: &CStr) -> (jclass, jfieldID) {
-        let class = self.require_class(class);
-        (class, self.require_field(class, method, descriptor))
+    pub unsafe fn require_class_field(self, class_name: &CStr, method: &CStr, descriptor: &CStr) -> (jclass, jfieldID) {
+        let class = self.require_class(class_name);
+        (class, self.require_field(class, class_name, method, descriptor))
     }
 
     pub unsafe fn require_class_static_field(
         self,
-        class: &CStr,
+        class_name: &CStr,
         method: &CStr,
         descriptor: &CStr,
     ) -> (jclass, jfieldID) {
-        let class = self.require_class(class);
-        (class, self.require_static_field(class, method, descriptor))
+        let class = self.require_class(class_name);
+        (class, self.require_static_field(class, class_name, method, descriptor))
     }
 
     // Constructor Methods