Return the same Thread object from Thread.currentThread() (#175)

Every attached thread now owns its java/lang/Thread instance: attach
takes the instance for threads started via Thread.start (so
currentThread() inside run() is the started Thread object) and creates
one otherwise (bootstrap, external attachers). currentThread() returns
the stored instance, and the GC roots it per thread.

Also parse unrecognized classfile attributes as an opaque Unknown
variant instead of failing — JVMS 4.7.1 requires silently ignoring
them, and the anonymous-class fixture carries EnclosingMethod and
Signature attributes the parser rejected.

Expected output for the fixture is generated by a real JVM.

Author: dlunch

classfile/src/attribute.rs

@@ -146,6 +146,7 @@ pub enum AttributeInfo {
     MethodParameters(Vec<u8>), // TODO
     NestMembers(Vec<u8>),      // TODO
     NestHost(Vec<u8>),         // TODO
+    Unknown(Arc<String>, Vec<u8>),
 }
 
 impl AttributeInfo {
@@ -170,7 +171,8 @@ impl AttributeInfo {
                     "MethodParameters" => AttributeInfo::MethodParameters(info.to_vec()),
                     "NestMembers" => AttributeInfo::NestMembers(info.to_vec()),
                     "NestHost" => AttributeInfo::NestHost(info.to_vec()),
-                    _ => return Err(nom::Err::Error(nom::error_position!(info, nom::error::ErrorKind::Switch))),
+                    // unrecognized attributes must be silently ignored (JVMS 4.7.1)
+                    _ => AttributeInfo::Unknown(name.clone(), info.to_vec()),
                 })
             },
         )

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

@@ -91,7 +91,7 @@ impl Thread {
             async fn call(&self) -> Result<()> {
                 tracing::trace!("Thread start");
 
-                self.jvm.attach_thread()?;
+                self.jvm.attach_thread(self.this.instance.clone()).await?;
 
                 let result: Result<()> = self.jvm.invoke_virtual(&self.this, "run", "()V", []).await;
 
@@ -202,10 +202,8 @@ impl Thread {
     }
 
     async fn current_thread(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
-        tracing::warn!("stub java.lang.Thread::currentThread()");
+        tracing::debug!("java.lang.Thread::currentThread()");
 
-        let thread = jvm.new_class("java/lang/Thread", "(Z)V", (true,)).await?;
-
-        Ok(thread.into())
+        Ok(jvm.current_java_thread().into())
     }
 }

java_runtime/tests/classes/java/lang/test_object.rs

@@ -30,7 +30,7 @@ async fn test_wait() -> Result<()> {
     #[async_trait::async_trait]
     impl SpawnCallback for Notifier {
         async fn call(&self) -> Result<()> {
-            self.jvm.attach_thread()?;
+            self.jvm.attach_thread(None).await?;
 
             self.runtime.sleep(Duration::from_millis(100)).await;
             self.notified.store(true, Ordering::Relaxed);
@@ -77,7 +77,7 @@ async fn test_wait_timeout() -> Result<()> {
     #[async_trait::async_trait]
     impl SpawnCallback for Notifier {
         async fn call(&self) -> Result<()> {
-            self.jvm.attach_thread()?;
+            self.jvm.attach_thread(None).await?;
 
             self.runtime.sleep(Duration::from_millis(1000)).await;
             self.notified.store(true, Ordering::Relaxed);

jvm/src/garbage_collector.rs

@@ -26,6 +26,10 @@ pub fn determine_garbage(
             find_reachable_objects(jvm, x, &mut reachable_objects);
         });
 
+    threads.values().filter_map(|thread| thread.java_thread()).for_each(|x| {
+        find_reachable_objects(jvm, x, &mut reachable_objects);
+    });
+
     interned_strings.iter().for_each(|x| {
         find_reachable_objects(jvm, x, &mut reachable_objects);
     });

jvm/src/jvm.rs

@@ -79,7 +79,7 @@ impl Jvm {
         }
 
         // init startup thread
-        jvm.attach_thread()?;
+        jvm.attach_thread(None).await?;
 
         // set java class for bootstrap classes
         let classes = jvm.inner.classes.read().values().cloned().collect::<Vec<_>>();
@@ -822,11 +822,19 @@ impl Jvm {
         Ok(())
     }
 
-    pub fn attach_thread(&self) -> Result<()> {
+    // every attached thread owns a java/lang/Thread instance; pass the instance for threads
+    // started from java (Thread.start), or None to create one
+    pub async fn attach_thread(&self, java_thread: Option<Box<dyn ClassInstance>>) -> Result<()> {
         let thread_id = (self.inner.get_current_thread_id)();
         self.inner.threads.write().insert(thread_id, JvmThread::new());
         self.push_native_frame();
 
+        let java_thread = match java_thread {
+            Some(x) => x,
+            None => self.new_class("java/lang/Thread", "(Z)V", (true,)).await?,
+        };
+        self.inner.threads.write().get_mut(&thread_id).unwrap().set_java_thread(java_thread);
+
         Ok(())
     }
 
@@ -837,6 +845,11 @@ impl Jvm {
         Ok(())
     }
 
+    pub fn current_java_thread(&self) -> Box<dyn ClassInstance> {
+        let thread_id = (self.inner.get_current_thread_id)();
+        self.inner.threads.read().get(&thread_id).unwrap().java_thread().unwrap().clone()
+    }
+
     // TODO we need safe, ergonomic api..
     pub fn push_native_frame(&self) {
         let thread_id = (self.inner.get_current_thread_id)();

jvm/src/thread.rs

@@ -29,11 +29,24 @@ impl StackFrame {
 
 pub struct JvmThread {
     stack: Vec<StackFrame>,
+    java_thread: Option<Box<dyn ClassInstance>>,
 }
 
 impl JvmThread {
     pub fn new() -> Self {
-        Self { stack: Vec::new() }
+        Self {
+            stack: Vec::new(),
+            java_thread: None,
+        }
+    }
+
+    #[allow(clippy::borrowed_box)] // same as jvm.rs; callers pass it to &Box-taking apis
+    pub fn java_thread(&self) -> Option<&Box<dyn ClassInstance>> {
+        self.java_thread.as_ref()
+    }
+
+    pub fn set_java_thread(&mut self, java_thread: Box<dyn ClassInstance>) {
+        self.java_thread = Some(java_thread);
     }
 
     pub fn push_java_frame(&mut self, class: &Class, class_instance: Option<Box<dyn ClassInstance>>, method: &str) {

test_data/CurrentThread$1.class

@@ -0,0 +1,3 @@
+true
+true
+false

test_data/CurrentThread.class

@@ -0,0 +1,18 @@
+public class CurrentThread {
+    public static void main(String[] args) throws Exception {
+        Thread a = Thread.currentThread();
+        Thread b = Thread.currentThread();
+        System.out.println(a == b);
+
+        final Thread[] seen = new Thread[1];
+        Thread t = new Thread(new Runnable() {
+            public void run() {
+                seen[0] = Thread.currentThread();
+            }
+        });
+        t.start();
+        t.join();
+        System.out.println(seen[0] == t);
+        System.out.println(seen[0] == a);
+    }
+}