Refactor Java options and paths to use WidePathBuf for improved path handling

Assisted-by: codex:gpt-5.4

Author: Glavo

src/java.rs

@@ -22,11 +22,12 @@ use crate::wide::{
     WideDisplay, WideString, is_dot_or_dot_dot, trim_wide_whitespace, wide_contains,
     wide_slice_from_ptr,
 };
+use crate::wide_path::WidePathBuf;
 
 /// Collect the filesystem and JVM options needed to launch HMCL.
 pub struct JavaOptions {
-    pub workdir: WideString,
-    pub jar_path: WideString,
+    pub workdir: WidePathBuf,
+    pub jar_path: WidePathBuf,
     pub jvm_options: Option<WideString>,
 }
 
@@ -46,7 +47,7 @@ impl JavaVersion {
     }
 
     /// Read the PE version resource from a Java executable.
-    pub fn from_executable(path: &WideString) -> Self {
+    pub fn from_executable(path: &WidePathBuf) -> Self {
         // Match the C++ launcher and read the executable's version resource
         // instead of spawning `java -version`.
         let size = unsafe { GetFileVersionInfoSizeW(path.as_pcwstr(), ptr::null_mut()) };
@@ -65,9 +66,8 @@ impl JavaVersion {
         // 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.as_ptr().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 {
             return Self::invalid();
         }
@@ -141,7 +141,7 @@ impl Display for JavaVersion {
 /// Pair a Java executable path with the version discovered from its metadata.
 pub struct JavaRuntime {
     pub version: JavaVersion,
-    pub executable_path: WideString,
+    pub executable_path: WidePathBuf,
 }
 
 /// Own the set of discovered Java runtimes before launch selection.
@@ -158,7 +158,7 @@ impl JavaList {
     }
 
     /// Add one candidate runtime when it exists, is unique, and is new enough.
-    pub fn try_add(&mut self, java_executable: WideString) -> bool {
+    pub fn try_add(&mut self, java_executable: WidePathBuf) -> bool {
         if !is_regular_file(&java_executable) {
             return false;
         }
@@ -202,12 +202,13 @@ impl JavaList {
     /// 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));
     }
 }
 
 /// Launch HMCL with a specific Java executable.
-pub fn launch_jvm(java_executable_path: &WideString, options: &JavaOptions) -> bool {
+pub fn launch_jvm(java_executable_path: &WidePathBuf, options: &JavaOptions) -> bool {
     let mut command = WideString::new();
     if !command.push_char('"')
         || !command.push_slice(java_executable_path.as_slice())
@@ -279,7 +280,11 @@ pub fn launch_jvm(java_executable_path: &WideString, options: &JavaOptions) -> b
 }
 
 /// Search one directory for subdirectories that look like Java homes.
-pub fn search_java_in_dir(result: &mut JavaList, basedir: &WideString, java_executable_name: &str) {
+pub fn search_java_in_dir(
+    result: &mut JavaList,
+    basedir: &WidePathBuf,
+    java_executable_name: &str,
+) {
     log_verbose_fmt(format_args!(
         "Searching in directory: {}",
         WideDisplay(basedir.as_slice())
@@ -325,7 +330,7 @@ pub fn search_java_in_dir(result: &mut JavaList, basedir: &WideString, java_exec
 /// Probe the common vendor directories under Program Files.
 pub fn search_java_in_program_files(
     result: &mut JavaList,
-    program_files: &WideString,
+    program_files: &WidePathBuf,
     java_executable_name: &str,
 ) {
     // Search the same vendor folders as the upstream launcher.
@@ -441,7 +446,7 @@ pub fn search_java_in_registry(result: &mut JavaList, sub_key: PCWSTR, java_exec
             units -= 1;
         }
 
-        if let Some(mut executable) = WideString::from_utf16(&java_home[..units]) {
+        if let Some(mut executable) = WidePathBuf::from_utf16(&java_home[..units]) {
             if executable.push_path_component_str("bin")
                 && executable.push_path_component_str(java_executable_name)
             {
@@ -469,7 +474,7 @@ pub fn search_java_in_path(result: &mut JavaList, path: &[u16], java_executable_
 
         let entry = trim_wide_whitespace(&path[start..end]);
         if !entry.is_empty() {
-            if let Some(mut java_executable) = WideString::from_utf16(entry) {
+            if let Some(mut java_executable) = WidePathBuf::from_utf16(entry) {
                 if java_executable.push_path_component_str(java_executable_name) {
                     if wide_contains(java_executable.as_slice(), oracle_java) {
                         // Keep the upstream exclusion for Oracle's shared shim

src/lib.rs

@@ -9,6 +9,7 @@ mod java;
 mod launcher;
 pub mod platform;
 mod wide;
+mod wide_path;
 
 /// The minimum required Java major version.
 pub(crate) const HMCL_EXPECTED_JAVA_MAJOR_VERSION: u16 = 17;

src/platform.rs

@@ -19,12 +19,13 @@ use windows_sys::Win32::System::Threading::GetCurrentProcess;
 use windows_sys::core::{PCWSTR, s, w};
 
 use crate::wide::WideString;
+use crate::wide_path::WidePathBuf;
 
 /// Hold the launcher's working directory and the file name passed to
 /// `java -jar`.
 pub struct SelfPath {
-    pub workdir: WideString,
-    pub jar_path: WideString,
+    pub workdir: WidePathBuf,
+    pub jar_path: WidePathBuf,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -159,8 +160,8 @@ pub fn get_self_path() -> Option<SelfPath> {
     }
 
     Some(SelfPath {
-        workdir: WideString::from_utf16(&path[..slash])?,
-        jar_path: WideString::from_utf16(&path[slash + 1..])?,
+        workdir: WidePathBuf::from_utf16(&path[..slash])?,
+        jar_path: WidePathBuf::from_utf16(&path[slash + 1..])?,
     })
 }
 
@@ -203,12 +204,12 @@ pub fn get_env_var(name: PCWSTR) -> Option<WideString> {
 }
 
 /// Read an environment variable that represents a filesystem path.
-pub fn get_env_path(name: PCWSTR) -> Option<WideString> {
-    get_env_var(name)
+pub fn get_env_path(name: PCWSTR) -> Option<WidePathBuf> {
+    Some(WidePathBuf::from_wide_string(get_env_var(name)?))
 }
 
 /// Treat only ordinary filesystem files as valid launcher targets.
-pub fn is_regular_file(path: &WideString) -> bool {
+pub fn is_regular_file(path: &WidePathBuf) -> bool {
     let attributes = unsafe { GetFileAttributesW(path.as_pcwstr()) };
     attributes != INVALID_FILE_ATTRIBUTES
         && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0

src/wide.rs

@@ -183,36 +183,6 @@ impl WideString {
         self.data[self.len] = 0;
         true
     }
-
-    /// Append `\` when the current path does not already end with a separator.
-    pub fn push_path_separator(&mut self) -> bool {
-        if self.is_empty() {
-            return true;
-        }
-
-        let last = self.as_slice()[self.len - 1];
-        if last == b'\\' as u16 || last == b'/' as u16 {
-            true
-        } else {
-            self.push_char('\\')
-        }
-    }
-
-    /// Append one UTF-16 path component, inserting a separator if required.
-    pub fn push_path_component(&mut self, value: &[u16]) -> bool {
-        if value.is_empty() {
-            return true;
-        }
-        self.push_path_separator() && self.push_slice(value)
-    }
-
-    /// Append one UTF-8 path component, inserting a separator if required.
-    pub fn push_path_component_str(&mut self, value: &str) -> bool {
-        if value.is_empty() {
-            return true;
-        }
-        self.push_path_separator() && self.push_str(value)
-    }
 }
 
 impl Write for WideString {
@@ -311,7 +281,7 @@ fn wide_is_whitespace(value: u16) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use super::{WideString, trim_wide_whitespace, wide_contains};
+    use super::{WideString, trim_wide_whitespace};
 
     #[test]
     /// Trim surrounding whitespace while keeping the inner contents unchanged.
@@ -323,12 +293,4 @@ mod tests {
             "hello".encode_utf16().collect::<std::vec::Vec<_>>()
         );
     }
-
-    #[test]
-    /// Find a path fragment inside a UTF-16 path string.
-    fn substring_search() {
-        let value = WideString::from_str("C:\\Common Files\\Oracle\\Java\\bin").unwrap();
-        let needle = WideString::from_str("\\Common Files\\Oracle\\Java\\").unwrap();
-        assert!(wide_contains(value.as_slice(), needle.as_slice()));
-    }
 }

src/wide_path.rs

@@ -0,0 +1,112 @@
+use windows_sys::core::PCWSTR;
+
+use crate::wide::WideString;
+
+/// Owned UTF-16 storage for filesystem paths.
+pub struct WidePathBuf {
+    inner: WideString,
+}
+
+impl WidePathBuf {
+    /// Create an empty path buffer with no heap allocation.
+    pub const fn new() -> Self {
+        Self {
+            inner: WideString::new(),
+        }
+    }
+
+    /// Build a UTF-16 path by encoding UTF-8 input.
+    pub fn from_str(value: &str) -> Option<Self> {
+        Some(Self {
+            inner: WideString::from_str(value)?,
+        })
+    }
+
+    /// Copy an existing UTF-16 path into owned storage.
+    pub fn from_utf16(value: &[u16]) -> Option<Self> {
+        Some(Self {
+            inner: WideString::from_utf16(value)?,
+        })
+    }
+
+    /// Wrap an existing UTF-16 string whose contents represent a path.
+    pub fn from_wide_string(value: WideString) -> Self {
+        Self { inner: value }
+    }
+
+    /// Report whether the path is empty.
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
+    /// Borrow the initialized UTF-16 contents without the trailing terminator.
+    pub fn as_slice(&self) -> &[u16] {
+        self.inner.as_slice()
+    }
+
+    /// Expose the path buffer as a Win32 `PCWSTR`.
+    pub fn as_pcwstr(&self) -> PCWSTR {
+        self.inner.as_pcwstr()
+    }
+
+    /// Clone the path into a second heap-backed buffer.
+    pub fn try_clone(&self) -> Option<Self> {
+        Some(Self {
+            inner: self.inner.try_clone()?,
+        })
+    }
+
+    /// Append `\` when the current path does not already end with a separator.
+    pub fn push_path_separator(&mut self) -> bool {
+        let Some(&last) = self.inner.as_slice().last() else {
+            return true;
+        };
+
+        if last == b'\\' as u16 || last == b'/' as u16 {
+            true
+        } else {
+            self.inner.push_char('\\')
+        }
+    }
+
+    /// Append one UTF-16 path component, inserting a separator if required.
+    pub fn push_path_component(&mut self, value: &[u16]) -> bool {
+        if value.is_empty() {
+            return true;
+        }
+        self.push_path_separator() && self.inner.push_slice(value)
+    }
+
+    /// Append one UTF-8 path component, inserting a separator if required.
+    pub fn push_path_component_str(&mut self, value: &str) -> bool {
+        if value.is_empty() {
+            return true;
+        }
+        self.push_path_separator() && self.inner.push_str(value)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::WidePathBuf;
+    use crate::wide::wide_contains;
+
+    /// Find a path fragment inside a UTF-16 path string.
+    #[test]
+    fn substring_search() {
+        let value = WidePathBuf::from_str("C:\\Common Files\\Oracle\\Java\\bin").unwrap();
+        let needle = WidePathBuf::from_str("\\Common Files\\Oracle\\Java\\").unwrap();
+        assert!(wide_contains(value.as_slice(), needle.as_slice()));
+    }
+
+    /// Join path components without duplicating separators.
+    #[test]
+    fn push_path_component() {
+        let mut value = WidePathBuf::from_str("C:\\Java").unwrap();
+        assert!(value.push_path_component_str("bin"));
+        assert_eq!(
+            value.as_slice(),
+            "C:\\Java\\bin".encode_utf16().collect::<std::vec::Vec<_>>()
+        );
+    }
+}