Store java.lang.Class name as byte array and resolve ClassDefinition on demand

Author: dlunch

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

@@ -42,7 +42,9 @@ impl Class {
                 ),
             ],
             fields: vec![
-                JavaFieldProto::new("raw", "[B", Default::default()), // raw rust pointer of Box<dyn Class>
+                // Stored as raw bytes instead of java/lang/String to avoid circular dependency:
+                // from_rust_class -> JavaLangString::from_rust_string -> new_class("java/lang/String") -> from_rust_class -> stack overflow
+                JavaFieldProto::new("nameBytes", "[B", Default::default()),
                 JavaFieldProto::new("classLoader", "Ljava/lang/ClassLoader;", Default::default()),
             ],
             access_flags: Default::default(),

jvm/src/runtime/java_lang_class.rs

@@ -1,15 +1,23 @@
-use alloc::boxed::Box;
+use alloc::{boxed::Box, string::String, vec::Vec};
 
-use crate::{Result, class_definition::ClassDefinition, class_instance::ClassInstance, jvm::Jvm};
+use bytemuck::cast_vec;
+
+use crate::{Array, ClassInstanceRef, Result, class_definition::ClassDefinition, class_instance::ClassInstance, jvm::Jvm};
 
 pub struct JavaLangClass;
 
 impl JavaLangClass {
     #[allow(clippy::borrowed_box)]
     pub async fn to_rust_class(jvm: &Jvm, this: &Box<dyn ClassInstance>) -> Result<Box<dyn ClassDefinition>> {
-        let rust_class = jvm.get_rust_object_field(this, "raw").await?;
-
-        Ok(rust_class)
+        let name_bytes: ClassInstanceRef<Array<i8>> = jvm.get_field(this, "nameBytes", "[B").await?;
+        let len = jvm.array_length(&name_bytes).await?;
+        let name_bytes_vec: Vec<i8> = jvm.load_array(&name_bytes, 0, len).await?;
+        let class_name = String::from_utf8(cast_vec(name_bytes_vec)).unwrap_or_default();
+        if let Some(class) = jvm.get_class(&class_name) {
+            Ok(class.definition)
+        } else {
+            Err(jvm.exception("java/lang/NoClassDefFoundError", &class_name).await)
+        }
     }
 
     pub async fn from_rust_class(
@@ -19,7 +27,12 @@ impl JavaLangClass {
     ) -> Result<Box<dyn ClassInstance>> {
         let mut java_class = jvm.new_class("java/lang/Class", "()V", ()).await?;
 
-        jvm.put_rust_object_field(&mut java_class, "raw", rust_class).await?;
+        let class_name = rust_class.name();
+        let mut name_bytes = jvm.instantiate_array("B", class_name.len()).await?;
+        let bytes: Vec<i8> = cast_vec(class_name.into_bytes());
+        jvm.store_array(&mut name_bytes, 0, bytes).await?;
+        jvm.put_field(&mut java_class, "nameBytes", "[B", name_bytes).await?;
+
         jvm.put_field(&mut java_class, "classLoader", "Ljava/lang/ClassLoader;", class_loader)
             .await?;