runtime: improve UnsupportedClassVersionError message

Author: Serial-ATA

runtime/src/classpath/loader/mod.rs

@@ -488,7 +488,12 @@ impl ClassLoader {
 		//  2.2. Otherwise, if the purported representation is not of a supported major or
 		//       minor version (§4.1), derivation throws an UnsupportedClassVersionError.
 		if !SUPPORTED_MAJOR_VERSION_RANGE.contains(&(classfile.major_version as u1)) {
-			throw!(@DEFER UnsupportedClassVersionError);
+			throw!(@DEFER UnsupportedClassVersionError,
+				"{name_str} has been compiled by a more recent version of the Java Runtime (class file version {}.{}), this version of the Java Runtime only recognizes class file versions up to {}.0",
+				classfile.major_version,
+				classfile.minor_version,
+				SUPPORTED_MAJOR_VERSION_RANGE.end()
+			);
 		}
 
 		//  2.3. Otherwise, if the purported representation does not actually represent a class or

runtime/src/initialization.rs

@@ -7,7 +7,7 @@ use crate::objects::instance::class::ClassInstance;
 use crate::objects::reference::Reference;
 use crate::options::JvmOptions;
 use crate::symbols::sym;
-use crate::thread::exceptions::Throws;
+use crate::thread::exceptions::{Exception, Throws};
 use crate::thread::{JavaThread, JavaThreadBuilder};
 use crate::{classes, java_call};
 
@@ -17,28 +17,32 @@ use jni::error::JniError;
 use jni::java_vm::JavaVm;
 use jni::sys::{JNI_OK, JavaVMInitArgs, jint};
 
+/// Errors that can occur during VM initialization.
+pub enum InitializationError {
+	/// An exception was thrown before its class and/or the main thread were initialized.
+	///
+	/// This exception can *not* be thrown normally. The VM is not in a valid state to continue
+	/// executing Java code.
+	EarlyExceptionThrown(Exception),
+	/// Some other error occurred.
+	///
+	/// In the case of [`JniError::ExceptionThrown`], the thread will be available to print the
+	/// exception if necessary.
+	Other(JniError),
+}
+
 /// Creates and initializes the Java VM
 ///
 /// # Errors
 ///
-/// Errors come in the form ([`JniError`], Option<[`Reference`]>), where the [`Reference`] is the exception thrown.
-///
-/// There are two error cases:
-///
-/// * **Before** the creation of the main thread, in which case the exception will be `None` since the
-///   VM will not be able to throw any exception.
-/// * **After** the creation of the main thread, where the exception *should* be `Some`. In this case,
-///   the caller should print the contents of the exception.
-pub fn create_java_vm(
-	args: Option<&JavaVMInitArgs>,
-) -> Result<JavaVm, (JniError, Option<Reference>)> {
+/// See [`InitializationError`].
+pub fn create_java_vm(args: Option<&JavaVMInitArgs>) -> Result<JavaVm, InitializationError> {
 	let _span = tracing::debug_span!("initialization").entered();
 	tracing::debug!("Creating Java VM");
 
 	let options = match args {
-		Some(args) => {
-			unsafe { JvmOptions::load(args) }.map_err(|_| (JniError::InvalidArguments, None))?
-		},
+		Some(args) => unsafe { JvmOptions::load(args) }
+			.map_err(|_| InitializationError::Other(JniError::InvalidArguments))?,
 		None => JvmOptions::default(),
 	};
 
@@ -52,18 +56,7 @@ pub fn create_java_vm(
 		JavaThread::set_current_thread(thread);
 	}
 
-	if let Err((e, thread_available)) = initialize_thread(JavaThread::current(), true) {
-		if !thread_available {
-			return Err((e, None));
-		}
-
-		let Some(exception) = JavaThread::current().take_pending_exception() else {
-			tracing::warn!("Exception thrown but not set?");
-			return Err((e, None));
-		};
-
-		return Err((e, Some(exception)));
-	}
+	initialize_thread(JavaThread::current(), true)?;
 
 	Ok(unsafe { main_java_vm() })
 }
@@ -88,28 +81,26 @@ pub fn create_java_vm(
 pub(crate) fn initialize_thread(
 	thread: &'static JavaThread,
 	do_java_lang_system_init: bool,
-) -> Result<(), (JniError, bool)> {
+) -> Result<(), InitializationError> {
 	crate::modules::with_module_lock(Module::create_java_base);
 
 	// Load some important classes
-	if let Throws::Exception(_) = load_global_classes() {
-		return Err((JniError::ExceptionThrown, false));
+	if let Throws::Exception(exception) = load_global_classes() {
+		return Err(InitializationError::EarlyExceptionThrown(exception));
 	}
 
 	init_field_offsets();
 
 	// Init some important classes
-	if let Throws::Exception(_) = initialize_global_classes(thread) {
-		// An exception was thrown while initializing classes, no thread exists to handle it.
-		return Err((JniError::ExceptionThrown, false));
+	if let Throws::Exception(exception) = initialize_global_classes(thread) {
+		return Err(InitializationError::EarlyExceptionThrown(exception));
 	}
 
 	if !create_thread_object(thread) {
-		// An exception was thrown, this thread is NOT safe to use.
-		return Err((JniError::ExceptionThrown, false));
+		return Err(InitializationError::Other(JniError::ExceptionThrown));
 	}
 
-	// SAFETY: Preconditions filled in `init_field_offsets` & `initialize_global_classes`
+	// SAFETY: Preconditions filled in `init_field_offsets` && `initialize_global_classes`
 	unsafe {
 		misc::UnsafeConstants::init();
 	}
@@ -118,9 +109,9 @@ pub(crate) fn initialize_thread(
 	classes::java::lang::invoke::MethodHandle::init_entry_points();
 
 	if do_java_lang_system_init {
-		init_phase_1(thread).map_err(|e| (e, true))?;
-		init_phase_2(thread).map_err(|e| (e, true))?;
-		init_phase_3(thread).map_err(|e| (e, true))?;
+		init_phase_1(thread).map_err(InitializationError::Other)?;
+		init_phase_2(thread).map_err(InitializationError::Other)?;
+		init_phase_3(thread).map_err(InitializationError::Other)?;
 	}
 
 	Ok(())

runtime/src/native/jni/invocation_api/mod.rs

@@ -2,6 +2,7 @@
 //!
 //! Vendors can deliver Java-enabled applications without having to link with the Java VM source code.
 
+use crate::initialization::InitializationError;
 use crate::thread::{JavaThread, JavaThreadBuilder};
 use crate::{classes, initialization};
 
@@ -98,21 +99,31 @@ pub unsafe extern "system" fn JNI_CreateJavaVM(
 	let vm;
 	match initialization::create_java_vm(Some(args)) {
 		Ok(java_vm) => vm = java_vm,
-		Err((e, exception)) => {
-			if let JniError::ExceptionThrown = e {
-				eprintln!("Error occurred during initialization of VM");
-				if let Some(exception) = exception {
-					classes::java::lang::Throwable::print_stack_trace_without_java_system(
-						exception,
-						JavaThread::current(),
-					);
-
-					// If a VM was created and initialized to the point that an exception was thrown,
-					// the entire process just gets aborted like Hotspot.
-					std::process::abort();
-				}
+		// A manually constructed exception was thrown. We can expect that either the exception
+		// classes aren't loaded or the thread isn't initialized. Either way, we just print the
+		// little information we have.
+		Err(InitializationError::EarlyExceptionThrown(exception)) => {
+			eprintln!("Error occurred during initialization of VM");
+			eprintln!("{exception}");
+
+			// If a VM was created and initialized to the point that an exception was thrown,
+			// the entire process just gets aborted like Hotspot.
+			std::process::abort();
+		},
+		// Same as above, except we actually have an initialized thread and some classes loaded
+		Err(InitializationError::Other(JniError::ExceptionThrown)) => {
+			eprintln!("Error occurred during initialization of VM");
+
+			let thread = JavaThread::current();
+			if let Some(exception) = thread.take_pending_exception() {
+				classes::java::lang::Throwable::print_stack_trace_without_java_system(
+					exception, thread,
+				);
 			}
 
+			std::process::abort();
+		},
+		Err(InitializationError::Other(e)) => {
 			// Otherwise, the error can just be returned to the caller
 			return e.as_jint();
 		},

runtime/src/native/mod.rs

@@ -54,34 +54,34 @@ pub(crate) fn lib_java() -> &'static Library {
 
 pub(crate) mod java {
 	pub(crate) mod io {
-		pub(crate) mod FileDescriptor;
 		pub(crate) mod FileInputStream;
-		pub(crate) mod FileOutputStream;
-		pub(crate) mod FileSystem;
 		pub(crate) mod UnixFileSystem;
+		pub(crate) mod FileDescriptor;
+		pub(crate) mod FileSystem;
+		pub(crate) mod FileOutputStream;
 	}
 	pub(crate) mod lang {
 		pub(crate) mod invoke {
-			pub(crate) mod MethodHandle;
 			pub(crate) mod MethodHandleNatives;
+			pub(crate) mod MethodHandle;
 		}
 		pub(crate) mod r#ref {
-			pub(crate) mod Finalizer;
 			pub(crate) mod PhantomReference;
 			pub(crate) mod Reference;
+			pub(crate) mod Finalizer;
 		}
 		pub(crate) mod reflect {
 			pub(crate) mod Array;
 		}
-		pub(crate) mod Class;
-		pub(crate) mod ClassLoader;
-		pub(crate) mod Module;
-		pub(crate) mod Runtime;
-		pub(crate) mod String;
 		pub(crate) mod StringBuilder;
+		pub(crate) mod Runtime;
 		pub(crate) mod StringUTF16;
-		pub(crate) mod Thread;
+		pub(crate) mod Module;
+		pub(crate) mod ClassLoader;
 		pub(crate) mod Throwable;
+		pub(crate) mod Thread;
+		pub(crate) mod String;
+		pub(crate) mod Class;
 	}
 	pub(crate) mod security {
 		pub(crate) mod AccessController;
@@ -91,18 +91,18 @@ pub(crate) mod java {
 pub(crate) mod jdk {
 	pub(crate) mod internal {
 		pub(crate) mod misc {
-			pub(crate) mod CDS;
 			pub(crate) mod ScopedMemoryAccess;
-			pub(crate) mod Signal;
-			pub(crate) mod Unsafe;
+			pub(crate) mod CDS;
 			pub(crate) mod VM;
+			pub(crate) mod Unsafe;
+			pub(crate) mod Signal;
 		}
 		pub(crate) mod util {
 			pub(crate) mod SystemProps;
 		}
 		pub(crate) mod loader {
-			pub(crate) mod BootLoader;
 			pub(crate) mod NativeLibraries;
+			pub(crate) mod BootLoader;
 			pub(crate) mod NativeLibrary;
 		}
 		pub(crate) mod reflect {
@@ -112,3 +112,4 @@ pub(crate) mod jdk {
 		}
 	}
 }
+

runtime/src/objects/class/ptr.rs

@@ -166,7 +166,7 @@ impl ClassPtr {
 				}
 			},
 			Throws::Exception(e) => {
-				if e.kind().class() == classes::java_lang_VirtualMachineError() {
+				if e.kind().class()? == classes::java_lang_VirtualMachineError() {
 					return Throws::PENDING_EXCEPTION;
 				}
 

runtime/src/thread/exceptions.rs

@@ -7,6 +7,7 @@ use crate::objects::instance::class::ClassInstance;
 use crate::objects::reference::Reference;
 use crate::symbols::{Symbol, sym};
 
+use std::fmt::Display;
 use std::ops::{ControlFlow, FromResidual, Try};
 
 use classfile::accessflags::MethodAccessFlags;
@@ -228,19 +229,17 @@ impl ExceptionKind {
 		}
 	}
 
-	pub fn class(&self) -> ClassPtr {
+	pub fn class(&self) -> Throws<ClassPtr> {
 		if *self == ExceptionKind::PendingException {
 			let Some(exception) = JavaThread::current().pending_exception() else {
 				panic!("Thread has no pending exception");
 			};
 
-			return exception.extract_target_class();
+			return Throws::Ok(exception.extract_target_class());
 		}
 
 		let class_name = self.class_name();
-		ClassLoader::bootstrap()
-			.load(class_name)
-			.expect("exception class should exist")
+		ClassLoader::bootstrap().load(class_name)
 	}
 }
 
@@ -279,7 +278,9 @@ impl Exception {
 			return;
 		}
 
-		let this = Reference::class(ClassInstance::new(self.kind.class()));
+		let this = Reference::class(ClassInstance::new(
+			self.kind.class().expect("class should be loaded"),
+		));
 
 		match self.message {
 			Some(message) => {
@@ -318,6 +319,15 @@ impl Exception {
 	}
 }
 
+impl Display for Exception {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match &self.message {
+			Some(message) => write!(f, "{:?}: {message}", self.kind),
+			None => write!(f, "{:?}", self.kind),
+		}
+	}
+}
+
 // TODO: Document, maybe also have a second private macro to hide construction patterns
 macro_rules! throw {
 	($thread:expr, $($tt:tt)*) => {{