fix(fspy): handle null ObjectName and Buffer in UNICODE_STRING on Windows (#91)

## Summary

- Fix crash when running oxlint with `--type-aware` flag on Windows
- The crash occurred in `fspy_preload_windows` at `winapi_utils.rs:33`
due to null pointer in `slice::from_raw_parts`
- Root cause: `ObjectName` or its `Buffer` field in `UNICODE_STRING` can
be null when tsgolint is spawned

## Changes

- `convert.rs`: Check for null `ObjectName` before dereferencing
- `winapi_utils.rs`: Handle null/empty `Buffer` by returning empty
slice, fix `Length` interpretation (bytes, not u16 count)
- Added `oxlint_type_aware` test to verify the fix
- Added `oxlint-tsgolint` to test_bins for the test

## Test plan

- [x] `cargo test -p fspy oxlint_type_aware` passes
- [x] Test verifies that `--type-aware` flag works without crashing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: branchseer

crates/fspy/tests/oxlint.rs

@@ -1,28 +1,47 @@
 mod test_utils;
 
-use std::{env::vars_os, process::Stdio};
+use std::{env::vars_os, ffi::OsString};
 
 use fspy::{AccessMode, PathAccessIterable};
 use test_log::test;
 
-/// Find the oxlint executable in test_bins
-fn find_oxlint() -> std::path::PathBuf {
-    let test_bins_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+/// Get the test_bins/.bin directory path
+fn test_bins_bin_dir() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
         .parent()
         .unwrap()
         .join("vite_task_bin")
         .join("test_bins")
         .join("node_modules")
-        .join(".bin");
+        .join(".bin")
+}
 
+/// Find the oxlint executable in test_bins
+fn find_oxlint() -> std::path::PathBuf {
+    let test_bins_dir = test_bins_bin_dir();
     which::which_in("oxlint", Some(&test_bins_dir), std::env::current_dir().unwrap())
         .expect("oxlint not found in test_bins/node_modules/.bin")
 }
 
 async fn track_oxlint(dir: &std::path::Path, args: &[&str]) -> anyhow::Result<PathAccessIterable> {
     let oxlint_path = find_oxlint();
     let mut command = fspy::Command::new(&oxlint_path);
-    command.args(args).stdout(Stdio::null()).stderr(Stdio::null()).envs(vars_os()).current_dir(dir);
+
+    // Build PATH with test_bins/.bin prepended so oxlint can find tsgolint
+    let test_bins_dir = test_bins_bin_dir();
+    let new_path = if let Some(existing_path) = std::env::var_os("PATH") {
+        let mut paths = vec![test_bins_dir.as_os_str().to_owned()];
+        paths.extend(std::env::split_paths(&existing_path).map(|p| p.into_os_string()));
+        std::env::join_paths(paths)?
+    } else {
+        OsString::from(&test_bins_dir)
+    };
+
+    command
+        .args(args)
+        .envs(vars_os().filter(|(k, _)| !k.eq_ignore_ascii_case("PATH")))
+        .env("PATH", new_path)
+        .current_dir(dir);
 
     let child = command.spawn().await?;
     let termination = child.wait_handle.await?;
@@ -54,13 +73,44 @@ async fn oxlint_reads_directory() -> anyhow::Result<()> {
     // on macOS, tmpdir.path() may be a symlink, so we need to canonicalize it
     let tmpdir_path = std::fs::canonicalize(tmpdir.path())?;
 
-    let js_file = tmpdir.path().join("test.js");
-    std::fs::write(&js_file, "console.log('hello');")?;
-
     let accesses = track_oxlint(&tmpdir_path, &[]).await?;
 
     // Check that oxlint read the directory to find JS files
     // This is the key check - if READ_DIR is not tracked, cache won't detect new files
     test_utils::assert_contains(&accesses, &tmpdir_path, AccessMode::READ_DIR);
     Ok(())
 }
+
+#[test(tokio::test)]
+async fn oxlint_type_aware() -> anyhow::Result<()> {
+    let tmpdir = tempfile::tempdir()?;
+    // on macOS, tmpdir.path() may be a symlink, so we need to canonicalize it
+    let tmpdir_path = std::fs::canonicalize(tmpdir.path())?;
+
+    // Create a simple TypeScript file
+    let ts_file = tmpdir_path.join("index.ts");
+    std::fs::write(
+        &ts_file,
+        r#"
+import type { Foo } from './types';
+declare const _foo: Foo;
+"#,
+    )?;
+
+    // Run oxlint without --type-aware first
+    let accesses = track_oxlint(&tmpdir_path, &[""]).await?;
+    let access_to_types_ts = accesses.iter().find(|access| {
+        let os_str = access.path.to_cow_os_str();
+        os_str.as_encoded_bytes().ends_with(b"\\types.ts")
+            || os_str.as_encoded_bytes().ends_with(b"/types.ts")
+    });
+    assert_eq!(access_to_types_ts, None, "oxlint should not read types.ts without --type-aware");
+
+    // Run oxlint with --type-aware to enable type-aware linting
+    let accesses = track_oxlint(&tmpdir_path, &["--type-aware"]).await?;
+
+    // Check that oxlint read types.ts
+    test_utils::assert_contains(&accesses, &tmpdir_path.join("types.ts"), AccessMode::READ);
+
+    Ok(())
+}

crates/fspy/tests/rust_std.rs

@@ -37,11 +37,25 @@ async fn open_write() -> anyhow::Result<()> {
 
 #[test(tokio::test)]
 async fn readdir() -> anyhow::Result<()> {
-    let accesses = track_child!((), |(): ()| {
+    let tmpdir = tempfile::tempdir()?;
+    let tmpdir_path = std::fs::canonicalize(tmpdir.path())?;
+    // Reading a non-existent directory results in different tracked accesses on different platforms:
+    // - Windows: READ, because the NT APIs open the directory as handle just like files (NtCreateFile/NtOpenFile),
+    //   and if that fails, not read dir call (NtQueryDirectoryFile/NtQueryDirectoryFileEx) is made.
+    // - macOS/Linux:
+    //   - opendir results in a read_dir access. This call is directly made without trying to open the directory as a fd first.
+    //   - open + fopendir results in READ access, because open would fail with ENOENT, and fopendir is not called.
+    //
+    // This difference is acceptable because both will result in a "not found" fingerprint in vite-task.
+    // To keep the test consistent across platforms, we create the directory first.
+    std::fs::create_dir(tmpdir.path().join("hello_dir"))?;
+
+    let accesses = track_child!(tmpdir_path.to_str().unwrap().to_owned(), |tmpdir_path: String| {
+        std::env::set_current_dir(tmpdir_path).unwrap();
         let _ = std::fs::read_dir("hello_dir");
     })
     .await?;
-    assert_contains(&accesses, current_dir()?.join("hello_dir").as_path(), AccessMode::READ_DIR);
+    assert_contains(&accesses, tmpdir_path.join("hello_dir").as_path(), AccessMode::READ_DIR);
 
     Ok(())
 }

crates/fspy/tests/rust_tokio.rs

@@ -42,15 +42,21 @@ async fn open_write() -> anyhow::Result<()> {
 
 #[test(tokio::test)]
 async fn readdir() -> anyhow::Result<()> {
-    let accesses = track_child!((), |(): ()| {
+    let tmpdir = tempfile::tempdir()?;
+    let tmpdir_path = std::fs::canonicalize(tmpdir.path())?;
+
+    std::fs::create_dir(tmpdir.path().join("hello_dir"))?;
+
+    let accesses = track_child!(tmpdir_path.to_str().unwrap().to_owned(), |tmpdir_path: String| {
+        std::env::set_current_dir(tmpdir_path).unwrap();
         tokio::runtime::Builder::new_current_thread().enable_io().build().unwrap().block_on(
             async {
                 let _ = tokio::fs::read_dir("hello_dir").await;
             },
         );
     })
     .await?;
-    assert_contains(&accesses, current_dir()?.join("hello_dir").as_path(), AccessMode::READ_DIR);
+    assert_contains(&accesses, tmpdir_path.join("hello_dir").as_path(), AccessMode::READ_DIR);
 
     Ok(())
 }

crates/fspy_preload_windows/src/windows/convert.rs

@@ -50,16 +50,24 @@ impl ToAbsolutePath for POBJECT_ATTRIBUTES {
         self,
         f: F,
     ) -> winsafe::SysResult<R> {
-        let filename_str = unsafe { get_u16_str(&*(*self).ObjectName) };
+        let filename_str = if let Some(object_name) = unsafe { (*self).ObjectName.as_ref() } {
+            unsafe { get_u16_str(object_name) }
+        } else {
+            U16Str::from_slice(&[])
+        };
         let filename_slice = filename_str.as_slice();
-        let is_absolute = (filename_slice.get(0) == Some(&b'\\'.into())
-        && filename_slice.get(1) == Some(&b'\\'.into())) // \\...
+        let is_absolute = filename_slice.get(0) == Some(&b'\\'.into()) // \...
         || filename_slice.get(1) == Some(&b':'.into()); // C:...
 
-        if is_absolute {
+        if !is_absolute {
             let Ok(mut root_dir) = (unsafe { get_path_name((*self).RootDirectory) }) else {
                 return f(None);
             };
+            // If filename is empty, just use root_dir directly
+            if filename_str.is_empty() {
+                let root_dir_str = U16Str::from_slice(&root_dir);
+                return f(Some(root_dir_str));
+            }
             let root_dir_cstr = {
                 root_dir.push(0);
                 unsafe { U16CStr::from_ptr_str(root_dir.as_ptr()) }

crates/fspy_preload_windows/src/windows/detour.rs

@@ -21,7 +21,6 @@ impl<T: Copy> Detour<T> {
         Detour { symbol_name, target: UnsafeCell::new(unsafe { transmute_copy(&target) }), new }
     }
 
-    #[expect(dead_code)]
     pub const unsafe fn dynamic(symbol_name: &'static CStr, new: T) -> Self {
         Detour { symbol_name, target: UnsafeCell::new(null_mut()), new }
     }
@@ -52,15 +51,18 @@ pub struct DetourAny {
 pub struct AttachContext {
     kernelbase: HMODULE,
     kernel32: HMODULE,
+    ntdll: HMODULE,
 }
 
 impl AttachContext {
     pub fn new() -> Self {
         let kernelbase = unsafe { LoadLibraryA(c"kernelbase".as_ptr()) };
         let kernel32 = unsafe { LoadLibraryA(c"kernel32".as_ptr()) };
+        let ntdll = unsafe { LoadLibraryA(c"ntdll".as_ptr()) };
         assert_ne!(kernelbase, null_mut());
         assert_ne!(kernel32, null_mut());
-        Self { kernelbase, kernel32 }
+        assert_ne!(ntdll, null_mut());
+        Self { kernelbase, kernel32, ntdll }
     }
 }
 
@@ -74,9 +76,14 @@ impl DetourAny {
             unsafe { *self.target = symbol_in_kernelbase.cast() };
         } else {
             if unsafe { *self.target }.is_null() {
-                // dynamic symbol
+                // dynamic symbol - look up from kernel32 or ntdll
                 let symbol_in_kernel32 = unsafe { GetProcAddress(ctx.kernel32, symbol_name) };
-                unsafe { *self.target = symbol_in_kernel32.cast() };
+                if !symbol_in_kernel32.is_null() {
+                    unsafe { *self.target = symbol_in_kernel32.cast() };
+                } else {
+                    let symbol_in_ntdll = unsafe { GetProcAddress(ctx.ntdll, symbol_name) };
+                    unsafe { *self.target = symbol_in_ntdll.cast() };
+                }
             }
         }
         if unsafe { *self.target }.is_null() {

crates/fspy_preload_windows/src/windows/detours/nt.rs

@@ -286,6 +286,55 @@ static DETOUR_NT_QUERY_DIRECTORY_FILE: Detour<
     })
 };
 
+// NtQueryDirectoryFileEx is not in ntapi crate, so we define it here.
+// https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/nf-ntifs-ntquerydirectoryfileex
+type NtQueryDirectoryFileExFn = unsafe extern "system" fn(
+    file_handle: HANDLE,
+    event: HANDLE,
+    apc_routine: PIO_APC_ROUTINE,
+    apc_context: PVOID,
+    io_status_block: PIO_STATUS_BLOCK,
+    file_information: PVOID,
+    length: ULONG,
+    file_information_class: FILE_INFORMATION_CLASS,
+    query_flags: ULONG,
+    file_name: PUNICODE_STRING,
+) -> NTSTATUS;
+
+static DETOUR_NT_QUERY_DIRECTORY_FILE_EX: Detour<NtQueryDirectoryFileExFn> = unsafe {
+    Detour::dynamic(c"NtQueryDirectoryFileEx", {
+        unsafe extern "system" fn new_fn(
+            file_handle: HANDLE,
+            event: HANDLE,
+            apc_routine: PIO_APC_ROUTINE,
+            apc_context: PVOID,
+            io_status_block: PIO_STATUS_BLOCK,
+            file_information: PVOID,
+            length: ULONG,
+            file_information_class: FILE_INFORMATION_CLASS,
+            query_flags: ULONG,
+            file_name: PUNICODE_STRING,
+        ) -> NTSTATUS {
+            unsafe { handle_open(AccessMode::READ_DIR, file_handle) };
+            unsafe {
+                (DETOUR_NT_QUERY_DIRECTORY_FILE_EX.real())(
+                    file_handle,
+                    event,
+                    apc_routine,
+                    apc_context,
+                    io_status_block,
+                    file_information,
+                    length,
+                    file_information_class,
+                    query_flags,
+                    file_name,
+                )
+            }
+        }
+        new_fn
+    })
+};
+
 pub const DETOURS: &[DetourAny] = &[
     DETOUR_NT_CREATE_FILE.as_any(),
     DETOUR_NT_OPEN_FILE.as_any(),
@@ -294,4 +343,5 @@ pub const DETOURS: &[DetourAny] = &[
     DETOUR_NT_OPEN_SYMBOLIC_LINK_OBJECT.as_any(),
     DETOUR_NT_QUERY_INFORMATION_BY_NAME.as_any(),
     DETOUR_NT_QUERY_DIRECTORY_FILE.as_any(),
+    DETOUR_NT_QUERY_DIRECTORY_FILE_EX.as_any(),
 ];

crates/fspy_preload_windows/src/windows/winapi_utils.rs

@@ -29,8 +29,16 @@ pub fn ck_long(val: c_long) -> winsafe::SysResult<()> {
 }
 
 pub unsafe fn get_u16_str(ustring: &UNICODE_STRING) -> &U16Str {
-    let chars =
-        unsafe { slice::from_raw_parts((*ustring).Buffer, (*ustring).Length.try_into().unwrap()) };
+    // https://learn.microsoft.com/en-us/windows/win32/api/subauth/ns-subauth-unicode_string
+    // UNICODE_STRING.Length is in bytes
+    let u16_count = ustring.Length / 2;
+    let chars: &[u16] = if u16_count == 0 {
+        // If length is zero, we can't use slice::from_raw_parts as it requires a non-null pointer but
+        // Buffer may be null in that case.
+        &[]
+    } else {
+        unsafe { slice::from_raw_parts((*ustring).Buffer, u16_count.try_into().unwrap()) }
+    };
     match U16CStr::from_slice_truncate(chars) {
         Ok(ok) => ok.as_ustr(),
         Err(_) => chars.into(),

crates/fspy_shared/src/ipc/mod.rs

@@ -32,7 +32,7 @@ impl Debug for AccessMode {
     }
 }
 
-#[derive(Encode, BorrowDecode, Debug, Clone, Copy)]
+#[derive(Encode, BorrowDecode, Debug, Clone, Copy, PartialEq, Eq)]
 pub struct PathAccess<'a> {
     pub mode: AccessMode,
     pub path: &'a NativeStr,

crates/vite_task_bin/test_bins/package.json

@@ -12,6 +12,7 @@
     "@yarnpkg/shell": "catalog:",
     "cross-env": "^10.1.0",
     "oxlint": "catalog:",
+    "oxlint-tsgolint": "catalog:",
     "vite-task-test-bins": "link:"
   }
 }

crates/vite_task_bin/tests/test_snapshots/main.rs

@@ -13,7 +13,7 @@ use std::{
 use copy_dir::copy_dir;
 use redact::{redact_e2e_output, redact_snapshot};
 use tokio::runtime::Runtime;
-use vite_path::{AbsolutePath, RelativePathBuf};
+use vite_path::{AbsolutePath, AbsolutePathBuf, RelativePathBuf};
 use vite_str::Str;
 use vite_task::{CLIArgs, Session};
 use vite_task_bin::CustomTaskSubcommand;
@@ -209,13 +209,13 @@ fn run_case(runtime: &Runtime, tmpdir: &AbsolutePath, fixture_path: &Path) {
 fn test_snapshots() {
     let tokio_runtime = Runtime::new().unwrap();
     let tmp_dir = tempfile::tempdir().unwrap();
-    let tmp_dir_path = AbsolutePath::new(tmp_dir.path()).unwrap();
+    let tmp_dir_path = AbsolutePathBuf::new(tmp_dir.path().canonicalize().unwrap()).unwrap();
 
     let tests_dir = std::env::current_dir().unwrap().join("tests");
 
     insta::glob!(tests_dir, "test_snapshots/fixtures/*", |case_path| run_case(
         &tokio_runtime,
-        tmp_dir_path,
+        &tmp_dir_path,
         case_path
     ));
 }