Resolve inherited static fields and methods

getstatic/putstatic/invokestatic referencing a subclass or implementing
class now walk the hierarchy per JVMS 5.4.3.2/5.4.3.3: static fields
search the class, its superinterfaces, then its superclass; static
methods search the class then its superclass. The resolved member is
read, written, and executed on its declaring class, and initialization
triggers that declaring class (not the referencing subclass).

Author: dlunch

jvm/src/jvm.rs

@@ -178,11 +178,10 @@ impl Jvm {
 
         let class = self.resolve_class(class_name).await?;
 
-        let field = class.definition.field(name, descriptor, true);
-        if let Some(field) = field {
-            self.ensure_initialized(&class).await?;
+        if let Some((declaring_class, field)) = self.resolve_static_field(&class, name, descriptor) {
+            self.ensure_initialized(&declaring_class).await?;
 
-            Ok(class.definition.get_static_field(&*field)?.into())
+            Ok(declaring_class.definition.get_static_field(&*field)?.into())
         } else {
             Err(self
                 .exception("java/lang/NoSuchFieldError", &format!("{class_name}.{name}:{descriptor}"))
@@ -196,14 +195,12 @@ impl Jvm {
     {
         tracing::trace!("Put static field {}.{}:{} = {:?}", class_name, name, descriptor, value);
 
-        let mut class = self.resolve_class(class_name).await?;
-
-        let field = class.definition.field(name, descriptor, true);
+        let class = self.resolve_class(class_name).await?;
 
-        if let Some(field) = field {
-            self.ensure_initialized(&class).await?;
+        if let Some((mut declaring_class, field)) = self.resolve_static_field(&class, name, descriptor) {
+            self.ensure_initialized(&declaring_class).await?;
 
-            class.definition.put_static_field(&*field, value.into())
+            declaring_class.definition.put_static_field(&*field, value.into())
         } else {
             Err(self
                 .exception("java/lang/NoSuchFieldError", &format!("{class_name}.{name}:{descriptor}"))
@@ -262,18 +259,10 @@ impl Jvm {
 
         let class = self.resolve_class(class_name).await?;
 
-        let method = class.definition.method(name, descriptor, true);
-
-        if let Some(method) = method {
-            if !method.access_flags().contains(MethodAccessFlags::STATIC) {
-                return Err(self
-                    .exception("java/lang/IncompatibleClassChangeError", &format!("{class_name}.{name}:{descriptor}"))
-                    .await);
-            }
-
-            self.ensure_initialized(&class).await?;
+        if let Some((declaring_class, method)) = self.resolve_static_method(&class, name, descriptor) {
+            self.ensure_initialized(&declaring_class).await?;
 
-            Ok(self.execute_method(&class, None, &method, args).await?.into())
+            Ok(self.execute_method(&declaring_class, None, &method, args).await?.into())
         } else {
             tracing::error!("No such method: {}.{}:{}", class_name, name, descriptor);
 
@@ -815,6 +804,34 @@ impl Jvm {
         monitors.entry(key).or_insert_with(|| Arc::new(Event::new())).clone()
     }
 
+    // JVMS 5.4.3.2 field resolution: search the class, then its superinterfaces, then its superclass
+    fn resolve_static_field(&self, class: &Class, name: &str, descriptor: &str) -> Option<(Class, Box<dyn Field>)> {
+        if let Some(field) = class.definition.field(name, descriptor, true) {
+            return Some((class.clone(), field));
+        }
+
+        for interface in class.definition.interface_names() {
+            if let Some(interface_class) = self.get_class(&interface)
+                && let Some(found) = self.resolve_static_field(&interface_class, name, descriptor)
+            {
+                return Some(found);
+            }
+        }
+
+        let super_class = self.get_class(&class.definition.super_class_name()?)?;
+        self.resolve_static_field(&super_class, name, descriptor)
+    }
+
+    // JVMS 5.4.3.3 method resolution for static methods; interfaces have no static methods in this runtime
+    fn resolve_static_method(&self, class: &Class, name: &str, descriptor: &str) -> Option<(Class, Box<dyn Method>)> {
+        if let Some(method) = class.definition.method(name, descriptor, true) {
+            return Some((class.clone(), method));
+        }
+
+        let super_class = self.get_class(&class.definition.super_class_name()?)?;
+        self.resolve_static_method(&super_class, name, descriptor)
+    }
+
     pub(crate) fn find_field(&self, class: &dyn ClassDefinition, name: &str, descriptor: &str) -> Result<Option<Box<dyn Field>>> {
         let field = class.field(name, descriptor, false);
 

test_data/StaticInherit$Base.class

@@ -0,0 +1,3 @@
+7
+9
+11