Address review feedback on WindowsDirectory/NativeUnixDirectory port (#1342)

Per NightOwl888's review of #1346:

- Surface IOException.HResult on the native-error paths so NativeFSLock (which
  inspects HResult to detect share/lock violations) keeps working:
  - errno-derived throws (NativePosixUtil.NewIOException/posix_fadvise;
    NativeUnixDirectory PWrite/FTruncate/FileSize) pass errno into the
    IOException(message, hresult) ctor. On Unix the BCL surfaces the raw errno
    as HResult (a FileStream share violation gives HResult == EWOULDBLOCK), so
    errno-as-HResult matches the convention.
  - Win32-derived throws (WindowsDirectory OpenFile/Read/Length) use
    Marshal.GetHRForLastWin32Error().
  - Exception-wrap sites (WindowsDirectory.ReadInternal; NativeUnixDirectory
    Refill/Length/Clone) preserve the original HResult. Uses the
    IOException(message, hresult) ctor where possible because the HResult setter
    is protected on net462/netstandard2.0; the RuntimeException wrappers guard
    the setter with #if for those TFMs.

- Implement NativeUnixIndexOutput.Checksum via a running CRC32 (like
  FSIndexOutput) instead of throwing NotSupportedException. The base-suite
  TestChecksum now passes against NativeUnixDirectory.

- Move the LuceneNetSpecific test files into the Support folder:
  Store/Test{NativeUnix,Windows}Directory.cs -> Support/Store/...

Not changed: the optional Put/Get micro-optimizations (Unsafe.CopyBlockUnaligned
/ ref byte), which the reviewer flagged as "benchmark to be sure it is worth
it"; the current Span.CopyTo already lowers to memmove.

Verified: builds on net10/net8/netstandard2.0/net462; TestNativeUnix/TestWindows
pass 24/24 on macOS arm64 and 23/23 on Linux aarch64.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: paulirwin

src/Lucene.Net.Misc/Store/NativePosixUtil.cs

@@ -159,7 +159,9 @@ public static void Advise(SafeFileHandle fd, long offset, long len, int advise)
             if (code != 0)
             {
                 // LUCENENET: upstream throws RuntimeException; we use IOException as this is an I/O failure.
-                throw new IOException("posix_fadvise failed code=" + code);
+                // posix_fadvise returns the error number directly (it does not set errno); surface it as
+                // the HResult to match the errno-as-HResult convention used elsewhere here.
+                throw new IOException("posix_fadvise failed code=" + code, code);
             }
         }
 
@@ -188,7 +190,10 @@ private static IOException NewIOException(string operation, string filename, int
             string where = filename is null ? operation : $"{operation} {filename}";
             // On Unix with SetLastError, GetLastWin32Error() returns errno. Win32Exception's message
             // is not meaningful on Unix, so include the raw errno for diagnosis.
-            return new IOException($"{where} failed (errno {errno})");
+            // LUCENENET: surface the errno as the IOException's HResult. On Unix the BCL sets HResult to
+            // the raw errno (e.g. a FileStream share violation surfaces HResult == EWOULDBLOCK), and
+            // NativeFSLock inspects IOException.HResult, so we match that convention here.
+            return new IOException($"{where} failed (errno {errno})", errno);
         }
 
         internal static void EnsureUnix()

src/Lucene.Net.Misc/Store/NativeUnixDirectory.cs

@@ -1,3 +1,4 @@
+using Lucene.Net.Support;
 using Lucene.Net.Util;
 using Microsoft.Win32.SafeHandles;
 using System;
@@ -186,15 +187,20 @@ private static void PWrite(SafeFileHandle fd, IntPtr buffer, int length, long po
             long written = (long)NativeMethods.pwrite(Fd(fd), buffer, (nuint)length, pos);
             if (written < 0)
             {
-                throw new IOException($"pwrite failed (errno {Marshal.GetLastWin32Error()})");
+                int errno = Marshal.GetLastWin32Error();
+                // LUCENENET: surface errno as the HResult (see NativePosixUtil.NewIOException) so callers
+                // such as NativeFSLock, which inspect IOException.HResult, still see the underlying error.
+                throw new IOException($"pwrite failed (errno {errno})", errno);
             }
         }
 
         private static void FTruncate(SafeFileHandle fd, long length)
         {
             if (NativeMethods.ftruncate(Fd(fd), length) < 0)
             {
-                throw new IOException($"ftruncate failed (errno {Marshal.GetLastWin32Error()})");
+                int errno = Marshal.GetLastWin32Error();
+                // LUCENENET: surface errno as the HResult (see PWrite).
+                throw new IOException($"ftruncate failed (errno {errno})", errno);
             }
         }
 
@@ -205,7 +211,9 @@ private static long FileSize(SafeFileHandle fd)
             long size = NativeMethods.lseek(Fd(fd), 0, NativeMethods.SEEK_END);
             if (size < 0)
             {
-                throw new IOException($"lseek failed (errno {Marshal.GetLastWin32Error()})");
+                int errno = Marshal.GetLastWin32Error();
+                // LUCENENET: surface errno as the HResult (see PWrite).
+                throw new IOException($"lseek failed (errno {errno})", errno);
             }
             return size;
         }
@@ -286,6 +294,9 @@ private sealed class NativeUnixIndexOutput : IndexOutput
             private readonly AlignedByteBuffer buffer;
             private readonly SafeFileHandle fd;
             private readonly int bufferSize;
+            // LUCENENET specific: track a running CRC32 over the bytes written (in logical order), so
+            // Checksum can return it like FSIndexOutput does. Upstream left getChecksum() unsupported.
+            private readonly CRC32 crc = new CRC32();
 
             private int bufferPos;
             private long filePos;
@@ -302,6 +313,7 @@ public NativeUnixIndexOutput(string path, int bufferSize)
 
             public override void WriteByte(byte b)
             {
+                crc.Update(b);
                 buffer.Put(b);
                 if (++bufferPos == bufferSize)
                 {
@@ -311,6 +323,7 @@ public override void WriteByte(byte b)
 
             public override void WriteBytes(ReadOnlySpan<byte> source)
             {
+                crc.Update(source);
                 int offset = 0;
                 int toWrite = source.Length;
                 while (true)
@@ -393,7 +406,9 @@ public override long Length
                 set { /* not supported: length is managed internally */ }
             }
 
-            public override long Checksum => throw new NotSupportedException("this directory currently does not work at all!");
+            // LUCENENET specific: upstream left getChecksum() unsupported; we maintain a running CRC32
+            // over the written bytes (like FSIndexOutput) so the checksum footer can be written.
+            public override long Checksum => crc.Value;
 
             protected override void Dispose(bool disposing)
             {
@@ -494,7 +509,16 @@ public override long Length
                     }
                     catch (Exception ioe) when (ioe.IsIOException())
                     {
-                        throw RuntimeException.Create("IOException during Length: " + this, ioe);
+                        // LUCENENET: upstream wraps in a RuntimeException here (IndexInput.Length cannot
+                        // throw a checked IOException in Java). Preserve the original HResult so callers
+                        // that inspect it (e.g. NativeFSLock) still see the underlying error. The HResult
+                        // setter is only public on modern TFMs; on net462/netstandard2.0 it is protected,
+                        // so the detail is retained in the message there instead.
+                        Exception wrapped = RuntimeException.Create("IOException during Length: " + this, ioe);
+#if !(NETSTANDARD2_0 || NET462)
+                        wrapped.HResult = ioe.HResult;
+#endif
+                        throw wrapped;
                     }
                 }
             }
@@ -524,7 +548,10 @@ private void Refill()
                 }
                 catch (Exception ioe) when (ioe.IsIOException())
                 {
-                    throw new IOException(ioe.Message + ": " + this, ioe);
+                    // LUCENENET: surface the original HResult (via the ctor that accepts it, which is
+                    // public on all target frameworks) so callers such as NativeFSLock still see the
+                    // underlying error. The inner detail is retained in the message.
+                    throw new IOException(ioe.Message + ": " + this, ioe.HResult);
                 }
                 // Upstream used FileChannel.read(), which returns -1 at EOF. Here Pread() wraps libc
                 // pread(), which returns 0 at EOF (a genuine error already threw above), so a refill that
@@ -567,7 +594,14 @@ public override object Clone()
                 }
                 catch (Exception ioe) when (ioe.IsIOException())
                 {
-                    throw RuntimeException.Create("IOException during clone: " + this, ioe);
+                    // LUCENENET: as in Length above, upstream wraps in a RuntimeException (Clone cannot
+                    // throw a checked IOException in Java). Preserve the original HResult where the setter
+                    // is public (modern TFMs); on net462/netstandard2.0 the detail stays in the message.
+                    Exception wrapped = RuntimeException.Create("IOException during clone: " + this, ioe);
+#if !(NETSTANDARD2_0 || NET462)
+                    wrapped.HResult = ioe.HResult;
+#endif
+                    throw wrapped;
                 }
             }
 

src/Lucene.Net.Misc/Store/WindowsDirectory.cs

@@ -157,7 +157,11 @@ protected override void ReadInternal(Span<byte> b)
                 }
                 catch (Exception ioe) when (ioe.IsIOException())
                 {
-                    throw new IOException(ioe.Message + ": " + this, ioe);
+                    // LUCENENET: surface the original HResult (via the ctor that accepts it, which is
+                    // public on all target frameworks) so callers such as NativeFSLock, which inspect
+                    // IOException.HResult, still see the underlying error. The inner detail is retained
+                    // in the message.
+                    throw new IOException(ioe.Message + ": " + this, ioe.HResult);
                 }
 
                 if (bytesRead != b.Length)
@@ -208,10 +212,13 @@ private static SafeFileHandle OpenFile(string filename)
                 NativeMethods.FILE_FLAG_RANDOM_ACCESS,
                 IntPtr.Zero);
             int lastError = Marshal.GetLastWin32Error();
+            // LUCENENET: surface the Win32 error as the IOException's HResult (matching what the BCL
+            // sets on a FileStream IOException) so callers such as NativeFSLock can recognize it.
+            int hresult = Marshal.GetHRForLastWin32Error();
 
             if (handle == NativeMethods.INVALID_HANDLE_VALUE)
             {
-                throw new IOException("Could not open file " + filename + ": " + new Win32Exception(lastError).Message);
+                throw new IOException("Could not open file " + filename + ": " + new Win32Exception(lastError).Message, hresult);
             }
 
             return new SafeFileHandle(handle, ownsHandle: true);
@@ -239,7 +246,9 @@ private static unsafe int Read(SafeFileHandle fd, Span<byte> bytes, long pos)
 
             if (!success)
             {
-                throw new IOException(new Win32Exception(Marshal.GetLastWin32Error()).Message);
+                int lastError = Marshal.GetLastWin32Error();
+                // LUCENENET: surface the Win32 error as the IOException's HResult (see OpenFile).
+                throw new IOException(new Win32Exception(lastError).Message, Marshal.GetHRForLastWin32Error());
             }
 
             return numRead;
@@ -251,7 +260,9 @@ private static long Length(SafeFileHandle fd)
         {
             if (!NativeMethods.GetFileInformationByHandle(fd, out NativeMethods.BY_HANDLE_FILE_INFORMATION info))
             {
-                throw new IOException(new Win32Exception(Marshal.GetLastWin32Error()).Message);
+                int lastError = Marshal.GetLastWin32Error();
+                // LUCENENET: surface the Win32 error as the IOException's HResult (see OpenFile).
+                throw new IOException(new Win32Exception(lastError).Message, Marshal.GetHRForLastWin32Error());
             }
 
             return ((long)info.nFileSizeHigh << 0x20) | info.nFileSizeLow;