Refactor memory management in Java runtime handling and update build configuration for Windows 7

Assisted-by: codex:gpt-5.4

Author: Glavo

.cargo/config.toml

@@ -3,19 +3,12 @@ include = [{ path = "local.toml", optional = true }]
 [build]
 target = "i686-win7-windows-msvc"
 
-[target.i686-win7-windows-gnu]
-# MinGW uses -municode so the CRT dispatches to wWinMain.
-rustflags = ["-C", "link-arg=-municode"]
-
 [target.i686-win7-windows-msvc]
 # Match the legacy CMake /MT build so Windows 7 does not need the VC++ CRT/UCRT
-# installed separately, while still using the wide GUI entrypoint.
-rustflags = [
-    "-C",
-    "link-arg=/ENTRY:wWinMainCRTStartup",
-    "-C",
-    "target-feature=+crt-static",
-]
+# installed separately while letting Rust's normal `std` entrypoint own process
+# startup.
+rustflags = ["-C", "target-feature=+crt-static"]
 
 [unstable]
-build-std = ["core", "compiler_builtins"]
+build-std = ["std", "panic_abort"]
+panic-abort-tests = true

Cargo.toml

@@ -12,7 +12,6 @@ windows-sys = { version = "0.59.0", features = [
     "Win32_System_Console",
     "Win32_System_Environment",
     "Win32_System_LibraryLoader",
-    "Win32_System_Memory",
     "Win32_System_Registry",
     "Win32_System_SystemInformation",
     "Win32_System_Threading",

src/heap.rs

@@ -17,7 +17,6 @@ use windows_sys::core::{PCWSTR, w};
 
 use crate::HMCL_EXPECTED_JAVA_MAJOR_VERSION;
 use crate::debug::{log_fmt, log_verbose_fmt};
-use crate::heap::{HeapVec, alloc_bytes, free_bytes};
 use crate::platform::is_regular_file;
 use crate::wide::{
     WideDisplay, WideString, is_dot_or_dot_dot, trim_wide_whitespace, wide_contains,
@@ -55,43 +54,31 @@ impl JavaVersion {
             return Self::invalid();
         }
 
-        let data = unsafe { alloc_bytes(size as usize) };
-        if data.is_null() {
-            return Self::invalid();
-        }
-
-        let result = unsafe { GetFileVersionInfoW(path.as_pcwstr(), 0, size, data.cast()) };
+        let mut data = vec![0u8; size as usize];
+        let result =
+            unsafe { GetFileVersionInfoW(path.as_pcwstr(), 0, size, data.as_mut_ptr().cast()) };
         if result == 0 {
-            unsafe {
-                free_bytes(data);
-            }
             return Self::invalid();
         }
 
         // Query the root `VS_FIXEDFILEINFO` block to extract the four numeric
         // version components in the same format as the upstream launcher.
         let mut info_ptr = ptr::null_mut();
         let mut info_len = 0u32;
-        let result = unsafe { VerQueryValueW(data.cast(), w!("\\"), &mut info_ptr, &mut info_len) };
+        let result = unsafe {
+            VerQueryValueW(data.as_ptr().cast(), w!("\\"), &mut info_ptr, &mut info_len)
+        };
         if result == 0 || info_ptr.is_null() || info_len < size_of::<VS_FIXEDFILEINFO>() as u32 {
-            unsafe {
-                free_bytes(data);
-            }
             return Self::invalid();
         }
 
         let info = unsafe { &*(info_ptr as *const VS_FIXEDFILEINFO) };
-        let version = Self {
+        Self {
             major: ((info.dwFileVersionMS >> 16) & 0xFFFF) as u16,
             minor: (info.dwFileVersionMS & 0xFFFF) as u16,
             build: ((info.dwFileVersionLS >> 16) & 0xFFFF) as u16,
             revision: (info.dwFileVersionLS & 0xFFFF) as u16,
-        };
-
-        unsafe {
-            free_bytes(data);
         }
-        version
     }
 
     #[cfg(test)]
@@ -159,14 +146,14 @@ pub struct JavaRuntime {
 
 /// Own the set of discovered Java runtimes before launch selection.
 pub struct JavaList {
-    pub runtimes: HeapVec<JavaRuntime>,
+    pub runtimes: Vec<JavaRuntime>,
 }
 
 impl JavaList {
     /// Create an empty runtime list.
     pub fn new() -> Self {
         Self {
-            runtimes: HeapVec::new(),
+            runtimes: Vec::new(),
         }
     }
 
@@ -208,14 +195,14 @@ impl JavaList {
         self.runtimes.push(JavaRuntime {
             version,
             executable_path: java_executable,
-        })
+        });
+        true
     }
 
     /// Sort runtimes from lowest to highest version so callers can try the best
     /// match last-to-first.
     pub fn sort_by_version(&mut self) {
-        self.runtimes
-            .sort_by(|left, right| left.version.cmp(&right.version));
+        self.runtimes.sort_by(|left, right| left.version.cmp(&right.version));
     }
 }
 

src/java.rs

@@ -1,22 +1,15 @@
-#![no_std]
 #![allow(non_snake_case)]
 
 #[cfg(not(target_os = "windows"))]
 compile_error!("This crate only works on Windows");
 
-#[cfg(test)]
-extern crate std;
-
 mod debug;
-mod heap;
 mod i18n;
 mod java;
 mod launcher;
 pub mod platform;
 mod wide;
 
-use windows_sys::Win32::System::Threading::ExitProcess;
-
 /// Mirror HMCL's current minimum required Java major version.
 pub(crate) const HMCL_EXPECTED_JAVA_MAJOR_VERSION: u16 = 17;
 /// Expose the build-script-generated launcher version string to the runtime.
@@ -26,9 +19,3 @@ pub(crate) const HMCL_LAUNCHER_VERSION: &str = env!("HMCL_LAUNCHER_VERSION");
 pub fn run() -> i32 {
     launcher::run()
 }
-
-/// Terminate the process without unwinding because the binary uses
-/// `panic = "abort"` and no Rust runtime.
-pub fn abort(exit_code: u32) -> ! {
-    unsafe { ExitProcess(exit_code) }
-}