Support array covariance and ArrayStoreException (#168)

* Support array covariance and ArrayStoreException

is_instance now follows JVMS 4.10.3 array subtyping via a new
is_assignable helper: an array is a subtype of Object, Cloneable, and
Serializable, and S[] is a subtype of T[] when S is a subtype of T
(primitive component arrays only match exactly). This fixes
instanceof/checkcast on covariant array types. aastore checks the
stored reference against the array's component type and throws
ArrayStoreException (new runtime class) on a mismatch; null is always
allowed.

* Address review: check aastore bounds before the store type check

JVMS orders aastore checks as NullPointer, then ArrayIndexOutOfBounds,
then ArrayStore. The component-type check now runs after an explicit
upper-bound check, so an out-of-bounds store of an incompatible value
throws ArrayIndexOutOfBoundsException rather than ArrayStoreException.

* Express array subtyping with JavaType instead of string slicing

is_assignable now parses names into JavaType and recurses structurally
(Array/Class) rather than manipulating descriptor strings, which makes
the array-covariance and Object/Cloneable/Serializable rules clearer.
Behavior is unchanged.

* Move array/class name parsing into JavaType::from_class_name

The CONSTANT_Class_info name form (binary name for classes, descriptor
for arrays; JVMS 4.4.1) to JavaType conversion now lives on JavaType as
a named constructor, and is_instance calls is_type_assignable directly,
dropping the str-based is_assignable helper.

Author: dlunch

java_runtime/src/classes/java/lang.rs

@@ -1,6 +1,7 @@
 mod abstract_method_error;
 mod arithmetic_exception;
 mod array_index_out_of_bounds_exception;
+mod array_store_exception;
 mod class;
 mod class_cast_exception;
 mod class_loader;
@@ -39,14 +40,15 @@ mod unsupported_operation_exception;
 
 pub use self::{
     abstract_method_error::AbstractMethodError, arithmetic_exception::ArithmeticException,
-    array_index_out_of_bounds_exception::ArrayIndexOutOfBoundsException, class::Class, class_cast_exception::ClassCastException,
-    class_loader::ClassLoader, clone_not_supported_exception::CloneNotSupportedException, cloneable::Cloneable, comparable::Comparable, error::Error,
-    exception::Exception, exception_in_initializer_error::ExceptionInInitializerError, illegal_argument_exception::IllegalArgumentException,
-    incompatible_class_change_error::IncompatibleClassChangeError, index_out_of_bounds_exception::IndexOutOfBoundsException,
-    instantiation_error::InstantiationError, integer::Integer, interrupted_exception::InterruptedException, linkage_error::LinkageError, math::Math,
-    negative_array_size_exception::NegativeArraySizeException, no_class_def_found_error::NoClassDefFoundError, no_such_field_error::NoSuchFieldError,
-    no_such_method_error::NoSuchMethodError, null_pointer_exception::NullPointerException, number_format_exception::NumberFormatException,
-    object::Object, runnable::Runnable, runtime::Runtime, runtime_exception::RuntimeException, security_exception::SecurityException, string::String,
-    string_buffer::StringBuffer, string_index_out_of_bounds_exception::StringIndexOutOfBoundsException, system::System, thread::Thread,
-    throwable::Throwable, unsupported_operation_exception::UnsupportedOperationException,
+    array_index_out_of_bounds_exception::ArrayIndexOutOfBoundsException, array_store_exception::ArrayStoreException, class::Class,
+    class_cast_exception::ClassCastException, class_loader::ClassLoader, clone_not_supported_exception::CloneNotSupportedException,
+    cloneable::Cloneable, comparable::Comparable, error::Error, exception::Exception, exception_in_initializer_error::ExceptionInInitializerError,
+    illegal_argument_exception::IllegalArgumentException, incompatible_class_change_error::IncompatibleClassChangeError,
+    index_out_of_bounds_exception::IndexOutOfBoundsException, instantiation_error::InstantiationError, integer::Integer,
+    interrupted_exception::InterruptedException, linkage_error::LinkageError, math::Math, negative_array_size_exception::NegativeArraySizeException,
+    no_class_def_found_error::NoClassDefFoundError, no_such_field_error::NoSuchFieldError, no_such_method_error::NoSuchMethodError,
+    null_pointer_exception::NullPointerException, number_format_exception::NumberFormatException, object::Object, runnable::Runnable,
+    runtime::Runtime, runtime_exception::RuntimeException, security_exception::SecurityException, string::String, string_buffer::StringBuffer,
+    string_index_out_of_bounds_exception::StringIndexOutOfBoundsException, system::System, thread::Thread, throwable::Throwable,
+    unsupported_operation_exception::UnsupportedOperationException,
 };

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

@@ -0,0 +1,43 @@
+use alloc::vec;
+
+use java_class_proto::JavaMethodProto;
+use jvm::{ClassInstanceRef, Jvm, Result};
+
+use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::String};
+
+// class java.lang.ArrayStoreException
+pub struct ArrayStoreException;
+
+impl ArrayStoreException {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "java/lang/ArrayStoreException",
+            parent_class: Some("java/lang/RuntimeException"),
+            interfaces: vec![],
+            methods: vec![
+                JavaMethodProto::new("<init>", "()V", Self::init, Default::default()),
+                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_message, Default::default()),
+            ],
+            fields: vec![],
+            access_flags: Default::default(),
+        }
+    }
+
+    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
+        tracing::debug!("java.lang.ArrayStoreException::<init>({:?})", &this);
+
+        let _: () = jvm.invoke_special(&this, "java/lang/RuntimeException", "<init>", "()V", ()).await?;
+
+        Ok(())
+    }
+
+    async fn init_with_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
+        tracing::debug!("java.lang.ArrayStoreException::<init>({:?}, {:?})", &this, &message);
+
+        let _: () = jvm
+            .invoke_special(&this, "java/lang/RuntimeException", "<init>", "(Ljava/lang/String;)V", (message,))
+            .await?;
+
+        Ok(())
+    }
+}

java_runtime/src/loader.rs

@@ -35,6 +35,7 @@ pub fn get_runtime_class_proto(name: &str) -> Option<RuntimeClassProto> {
         crate::classes::java::lang::AbstractMethodError::as_proto(),
         crate::classes::java::lang::ArithmeticException::as_proto(),
         crate::classes::java::lang::ArrayIndexOutOfBoundsException::as_proto(),
+        crate::classes::java::lang::ArrayStoreException::as_proto(),
         crate::classes::java::lang::Class::as_proto(),
         crate::classes::java::lang::ClassCastException::as_proto(),
         crate::classes::java::lang::ClassLoader::as_proto(),

jvm/src/jvm.rs

@@ -621,9 +621,43 @@ impl Jvm {
     }
 
     pub fn is_instance(&self, instance: &dyn ClassInstance, class_name: &str) -> bool {
-        let class = instance.class_definition();
+        self.is_type_assignable(
+            &JavaType::from_class_name(&instance.class_definition().name()),
+            &JavaType::from_class_name(class_name),
+        )
+    }
+
+    // aastore: whether value may be stored into array (JVMS 6.5 aastore)
+    pub fn array_store_allowed(&self, array: &dyn ClassInstance, value: &dyn ClassInstance) -> bool {
+        let JavaType::Array(component) = JavaType::parse(&array.class_definition().name()) else {
+            return true;
+        };
+
+        self.is_type_assignable(&JavaType::from_class_name(&value.class_definition().name()), &component)
+    }
 
-        self.is_inherited_from(&*class, class_name)
+    // JVMS 4.10.3 subtyping, including array covariance
+    fn is_type_assignable(&self, source: &JavaType, target: &JavaType) -> bool {
+        if source == target {
+            return true;
+        }
+
+        match (source, target) {
+            (JavaType::Array(source_component), JavaType::Array(target_component)) => self.is_type_assignable(source_component, target_component),
+            // every array type is a subtype of Object, Cloneable, and java.io.Serializable (JLS 4.10.3)
+            (JavaType::Array(_), JavaType::Class(name)) => {
+                name == "java/lang/Object" || name == "java/lang/Cloneable" || name == "java/io/Serializable"
+            }
+            (JavaType::Class(source), JavaType::Class(target)) => self.is_class_assignable(source, target),
+            _ => false,
+        }
+    }
+
+    fn is_class_assignable(&self, source: &str, target: &str) -> bool {
+        match self.get_class(source) {
+            Some(class) => self.is_inherited_from(&*class.definition, target),
+            None => false,
+        }
     }
 
     pub fn is_inherited_from(&self, class: &dyn ClassDefinition, class_name: &str) -> bool {

jvm/src/type.rs

@@ -52,6 +52,16 @@ impl JavaType {
         Self::parse_type(descriptor).unwrap().1
     }
 
+    // a CONSTANT_Class_info name (JVMS 4.4.1): a class binary name in internal form (java/lang/String)
+    // or an array type descriptor ([Ljava/lang/String;, [I)
+    pub fn from_class_name(name: &str) -> Self {
+        if name.starts_with('[') {
+            Self::parse(name)
+        } else {
+            Self::Class(name.to_string())
+        }
+    }
+
     pub fn as_method(&self) -> (&[Self], &Self) {
         if let Self::Method(params, return_type) = self {
             (params, return_type)

jvm/tests/test_is_instance.rs

@@ -30,3 +30,31 @@ async fn test_is_instance_interface() -> JvmResult<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_is_instance_array_covariance() -> JvmResult<()> {
+    let jvm = test_jvm().await?;
+
+    let string_array = jvm.instantiate_array("Ljava/lang/String;", 1).await?;
+    assert!(jvm.is_instance(&*string_array, "[Ljava/lang/Object;"));
+    assert!(jvm.is_instance(&*string_array, "java/lang/Object"));
+    assert!(jvm.is_instance(&*string_array, "java/lang/Cloneable"));
+    assert!(jvm.is_instance(&*string_array, "java/io/Serializable"));
+    assert!(jvm.is_instance(&*string_array, "[Ljava/lang/String;"));
+    assert!(!jvm.is_instance(&*string_array, "[Ljava/lang/Integer;"));
+
+    let int_array = jvm.instantiate_array("I", 1).await?;
+    assert!(jvm.is_instance(&*int_array, "java/lang/Object"));
+    assert!(!jvm.is_instance(&*int_array, "[Ljava/lang/Object;"));
+    assert!(!jvm.is_instance(&*int_array, "[J"));
+
+    let nested = jvm.instantiate_array("[Ljava/lang/String;", 1).await?;
+    assert!(jvm.is_instance(&*nested, "[Ljava/lang/Object;"));
+    assert!(jvm.is_instance(&*nested, "[[Ljava/lang/Object;"));
+    assert!(jvm.is_instance(&*nested, "[[Ljava/lang/String;"));
+
+    let object_array = jvm.instantiate_array("Ljava/lang/Object;", 1).await?;
+    assert!(!jvm.is_instance(&*object_array, "[Ljava/lang/String;"));
+
+    Ok(())
+}

jvm_rust/src/interpreter.rs

@@ -106,6 +106,12 @@ impl Interpreter {
                     return Err(jvm.exception("java/lang/NullPointerException", "Array is null").await);
                 }
 
+                // JVMS: aastore reports an out-of-bounds index before any ArrayStoreException type check
+                let length = jvm.array_length(array.as_ref().unwrap()).await?;
+                if index as usize >= length {
+                    return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{}", index)).await);
+                }
+
                 let element_type = jvm.array_element_type(array.as_ref().unwrap()).await?;
 
                 // operand stack has only integer, so convert it to the correct type
@@ -118,6 +124,15 @@ impl Interpreter {
                     _ => value,
                 };
 
+                if matches!(opcode, Opcode::Aastore) {
+                    let stored: &Option<Box<dyn ClassInstance>> = (&value).into();
+                    if let Some(stored) = stored
+                        && !jvm.array_store_allowed(&**array.as_ref().unwrap(), &**stored)
+                    {
+                        return Err(jvm.exception("java/lang/ArrayStoreException", &stored.class_definition().name()).await);
+                    }
+                }
+
                 jvm.store_array(array.as_mut().unwrap(), index as usize, [value]).await?;
             }
             Opcode::AconstNull => stack_frame.operand_stack.push(JavaValue::Object(None)),

test_data/ArrayCovariance.class

@@ -0,0 +1,11 @@
+true
+true
+true
+true
+true
+false
+true
+true
+true
+true
+cce