Method fmt

wasmtime-jni/src/wasm_exception.rs:61–123

(&self, f: &mut fmt::Formatter)

impl<'l, 'j: 'l> fmt::Display for ReportJThrowable<'l, 'j> {
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        // just in case...
        if self.throwable.is_null() {
            write!(f, "null throwable thrown")?;
            return Ok(());
        }

        let cause = self
            .env
            .call_method(self.throwable, "getCause", "()Ljava/lang/Throwable;", &[])
            .map_err(|_| fmt::Error)?;

        let cause = cause.l().map_err(|_| fmt::Error)?;
        if !cause.is_null() {
            let reporter = ReportJThrowable::from(self.env, JThrowable::from(cause));
            write!(f, "cause: {}", reporter)?;
        }

        let clazz = wasm_value::get_class_name_obj(self.env, self.throwable.into())
            .map_err(|_| fmt::Error)?;

        let message =
            call_string_method(self.env, &self.throwable, "getMessage").map_err(|_| fmt::Error)?;

        if let Some(message) = message {
            writeln!(f, "{}: {}", clazz, Cow::from(&message))?;
        } else {
            writeln!(f, "{}", clazz)?;
        };

        let trace = self
            .env
            .call_method(
                self.throwable,
                "getStackTrace",
                "()[Ljava/lang/StackTraceElement;",
                &[],
            )
            .map_err(|_| fmt::Error)?
            .l()
            .map_err(|_| fmt::Error)?;

        if !trace.is_null() {
            let trace = *trace as jarray;
            let len = self.env.get_array_length(trace).map_err(|_| fmt::Error)?;

            for i in 0..len as usize {
                let stack_element = self
                    .env
                    .get_object_array_element(trace, i as i32)
                    .map_err(|_| fmt::Error)?;

                let stack_str = call_string_method(self.env, &stack_element, "toString")
                    .map_err(|_| fmt::Error)?;

                if let Some(stack_str) = stack_str {
                    writeln!(f, "\t{}", Cow::from(&stack_str))?;
                }