rustjava-runtime 0.4.0

A Java standard library implementation for RustJava
Documentation
use alloc::{boxed::Box, format, vec, vec::Vec};

use jvm::{Array, ClassInstance, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};

use crate::{
    RuntimeClassProto, RuntimeContext,
    classes::java::{
        io::{PrintStream, PrintWriter},
        lang::String,
    },
};

// class java.lang.Throwable
pub struct Throwable;

impl Throwable {
    pub fn as_proto() -> RuntimeClassProto {
        RuntimeClassProto {
            name: "java/lang/Throwable",
            parent_class: Some("java/lang/Object"),
            interfaces: vec!["java/io/Serializable"],
            methods: vec![
                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_message, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("<init>", "(Ljava/lang/Throwable;)V", Self::init_with_cause, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new(
                    "<init>",
                    "(Ljava/lang/String;Ljava/lang/Throwable;)V",
                    Self::init_with_message_and_cause,
                    MethodAccessFlags::PUBLIC,
                ),
                JavaMethodProto::new(
                    "getCause",
                    "()Ljava/lang/Throwable;",
                    Self::get_cause,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
                ),
                JavaMethodProto::new("getMessage", "()Ljava/lang/String;", Self::get_message, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new(
                    "getLocalizedMessage",
                    "()Ljava/lang/String;",
                    Self::get_localized_message,
                    MethodAccessFlags::PUBLIC,
                ),
                JavaMethodProto::new(
                    "initCause",
                    "(Ljava/lang/Throwable;)Ljava/lang/Throwable;",
                    Self::init_cause,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
                ),
                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new(
                    "fillInStackTrace",
                    "()Ljava/lang/Throwable;",
                    Self::fill_in_stack_trace,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
                ),
                JavaMethodProto::new("printStackTrace", "()V", Self::print_stack_trace, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new(
                    "printStackTrace",
                    "(Ljava/io/PrintStream;)V",
                    Self::print_stack_trace_to_print_stream,
                    MethodAccessFlags::PUBLIC,
                ),
                JavaMethodProto::new(
                    "printStackTrace",
                    "(Ljava/io/PrintWriter;)V",
                    Self::print_stack_trace_to_print_writer,
                    MethodAccessFlags::PUBLIC,
                ),
            ],
            fields: vec![
                JavaFieldProto::new("detailMessage", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
                JavaFieldProto::new("cause", "Ljava/lang/Throwable;", FieldAccessFlags::PRIVATE),
                JavaFieldProto::new("stackTrace", "[Ljava/lang/String;", FieldAccessFlags::PRIVATE),
            ],
            access_flags: ClassAccessFlags::PUBLIC,
        }
    }

    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
        tracing::debug!("java.lang.Throwable::<init>({this:?})");

        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;

        let _: ClassInstanceRef<Self> = jvm
            .invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
            .await?;

        Ok(())
    }

    async fn init_with_message(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
        tracing::debug!("java.lang.Throwable::<init>({this:?}, {message:?})");

        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;

        jvm.put_field(&mut this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;", message)
            .await?;

        let _: ClassInstanceRef<Self> = jvm
            .invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
            .await?;

        Ok(())
    }

    async fn init_with_cause(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, cause: ClassInstanceRef<Self>) -> Result<()> {
        tracing::debug!("java.lang.Throwable::<init>({this:?}, {cause:?})");

        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;

        let message: ClassInstanceRef<String> = if cause.is_null() {
            None.into()
        } else {
            jvm.invoke_virtual(&cause, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
                .await?
        };
        jvm.put_field(&mut this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;", message)
            .await?;
        jvm.put_field(&mut this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;", cause)
            .await?;

        let _: ClassInstanceRef<Self> = jvm
            .invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
            .await?;

        Ok(())
    }

    async fn init_with_message_and_cause(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        mut this: ClassInstanceRef<Self>,
        message: ClassInstanceRef<String>,
        cause: ClassInstanceRef<Self>,
    ) -> Result<()> {
        tracing::debug!("java.lang.Throwable::<init>({this:?}, {message:?}, {cause:?})");

        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;

        jvm.put_field(&mut this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;", message)
            .await?;
        jvm.put_field(&mut this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;", cause)
            .await?;

        let _: ClassInstanceRef<Self> = jvm
            .invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
            .await?;

        Ok(())
    }

    async fn get_cause(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
        tracing::debug!("java.lang.Throwable::getCause({this:?})");

        jvm.get_field(&this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;").await
    }

    async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
        tracing::debug!("java.lang.Throwable::getMessage({this:?})");

        jvm.get_field(&this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;").await
    }

    async fn get_localized_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
        tracing::debug!("java.lang.Throwable::getLocalizedMessage({this:?})");

        jvm.invoke_virtual(&this, "java/lang/Throwable", "getMessage", "()Ljava/lang/String;", ())
            .await
    }

    async fn init_cause(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        mut this: ClassInstanceRef<Self>,
        cause: ClassInstanceRef<Self>,
    ) -> Result<ClassInstanceRef<Self>> {
        tracing::debug!("java.lang.Throwable::initCause({this:?}, {cause:?})");

        jvm.put_field(&mut this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;", cause)
            .await?;

        Ok(this)
    }

    async fn fill_in_stack_trace(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
        tracing::debug!("java.lang.Throwable::fillInStackTrace({this:?})");

        let stack_trace = jvm.stack_trace();
        let mut stack_trace_array = jvm.instantiate_array("Ljava/lang/String;", stack_trace.len()).await?;
        for (i, line) in stack_trace.iter().enumerate() {
            let java_line = JavaLangString::from_rust_string(jvm, line).await?;
            jvm.store_array(&mut stack_trace_array, i, core::iter::once(java_line)).await?;
        }
        jvm.put_field(&mut this, "java/lang/Throwable", "stackTrace", "[Ljava/lang/String;", stack_trace_array)
            .await?;

        Ok(this)
    }

    async fn print_stack_trace(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
        tracing::debug!("java.lang.Throwable::printStackTrace({this:?})");

        let err: ClassInstanceRef<PrintStream> = jvm.get_static_field("java/lang/System", "err", "Ljava/io/PrintStream;").await?;

        let _: () = jvm
            .invoke_virtual(&this, "java/lang/Throwable", "printStackTrace", "(Ljava/io/PrintStream;)V", (err,))
            .await?;

        Ok(())
    }

    async fn print_stack_trace_to_print_stream(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        this: ClassInstanceRef<Self>,
        stream: ClassInstanceRef<PrintStream>,
    ) -> Result<()> {
        tracing::debug!("java.lang.Throwable::printStackTrace({this:?}, {stream:?})");

        if stream.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "stream is null").await);
        }

        Self::do_print_stack_trace(jvm, this, stream.into()).await?;

        Ok(())
    }

    async fn print_stack_trace_to_print_writer(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        this: ClassInstanceRef<Self>,
        writer: ClassInstanceRef<PrintWriter>,
    ) -> Result<()> {
        tracing::debug!("java.lang.Throwable::printStackTrace({this:?}, {writer:?})");

        if writer.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "writer is null").await);
        }

        Self::do_print_stack_trace(jvm, this, writer.into()).await?;

        Ok(())
    }

    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
        tracing::debug!("java.lang.Throwable::toString({this:?})");

        let class = jvm
            .invoke_virtual(&this, "java/lang/Object", "getClass", "()Ljava/lang/Class;", ())
            .await?;
        let class_name = jvm
            .invoke_virtual(&class, "java/lang/Class", "getName", "()Ljava/lang/String;", ())
            .await?;

        let message: ClassInstanceRef<String> = jvm.get_field(&this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;").await?;

        let class_name = JavaLangString::to_rust_string(jvm, &class_name).await?;
        let message = if message.is_null() {
            class_name
        } else {
            let message = JavaLangString::to_rust_string(jvm, &message).await?;
            if message.is_empty() {
                class_name
            } else {
                format!("{class_name}: {message}")
            }
        };

        let message = JavaLangString::from_rust_string(jvm, &message).await?;

        Ok(message.into())
    }

    async fn do_print_stack_trace(jvm: &Jvm, this: ClassInstanceRef<Self>, stream_or_writer: Box<dyn ClassInstance>) -> Result<()> {
        let mut current: ClassInstanceRef<Self> = this;
        let mut header: Option<&str> = None;

        // a malformed initCause could create a cycle, so cap the depth
        for _ in 0..32 {
            let string: ClassInstanceRef<String> = jvm
                .invoke_virtual(&current, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
                .await?;
            let prefix: ClassInstanceRef<String> = match header {
                Some(x) => {
                    let string = JavaLangString::to_rust_string(jvm, &string).await?;
                    JavaLangString::from_rust_string(jvm, &format!("{x}{string}")).await?.into()
                }
                None => string,
            };
            let _: () = jvm
                .invoke_virtual(
                    &stream_or_writer,
                    &stream_or_writer.class_definition().name(),
                    "println",
                    "(Ljava/lang/String;)V",
                    (prefix,),
                )
                .await?;

            let stack_trace: ClassInstanceRef<Array<ClassInstanceRef<String>>> = jvm
                .get_field(&current, "java/lang/Throwable", "stackTrace", "[Ljava/lang/String;")
                .await?;
            if !stack_trace.is_null() {
                let length = jvm.array_length(&stack_trace).await?;
                let lines: Vec<ClassInstanceRef<String>> = jvm.load_array(&stack_trace, 0, length).await?;
                for line_ref in lines {
                    let line = JavaLangString::to_rust_string(jvm, &line_ref).await?;
                    let line = format!("\tat {line}");
                    let line = JavaLangString::from_rust_string(jvm, &line).await?;
                    let _: () = jvm
                        .invoke_virtual(
                            &stream_or_writer,
                            &stream_or_writer.class_definition().name(),
                            "println",
                            "(Ljava/lang/String;)V",
                            (line,),
                        )
                        .await?;
                }
            }

            let cause: ClassInstanceRef<Self> = jvm
                .invoke_virtual(&current, "java/lang/Throwable", "getCause", "()Ljava/lang/Throwable;", ())
                .await?;
            if cause.is_null() {
                break;
            }
            current = cause;
            header = Some("Caused by: ");
        }

        Ok(())
    }
}