Open the file with FileShare.ReadWrite | Delete on Windows for delete-while-mapped

The path-based MemoryMappedFile.CreateFromFile overload internally
opens the file with FileShare.Read. On Windows that blocks any
subsequent open-for-write or open-for-delete on the same file while
we hold the mapping. Callers like FreeTextSuggester build a temp
index, dispose the directory, and then recursively delete the
directory; on Windows that recursive delete fails with
"The process cannot access the file ... because it is being used by
another process" because Windows requires FILE_SHARE_DELETE on the
existing handle for a delete to proceed against an open file.

Switch back to opening our own FileStream so we control the share
flags. We use FileShare.ReadWrite | FileShare.Delete to match the
prior behavior (other writers/deleters can proceed; Windows will
defer the actual unlink until our last close, which is the standard
Unix-like semantic the rest of the framework expects). We still
pass capacity: 0 to CreateFromFile so the framework does its own
size stat — the #1090 race window stays closed. leaveOpen: false
hands the FileStream's lifetime to the MMF, so we don't have to
track it as a SharedMapping field.

Zero-length files are handled up front rather than letting
CreateViewAccessor reject the empty view: we dispose the FileStream
eagerly and return an empty SharedMapping.

Caught by Windows CI: TestFreeTextSuggester.TestBasic and siblings
failed with InvalidOperationException("failed to remove ...") wrapped
around IOException("write.lock ... being used by another process")
on net8.0 / net472 / net48 Windows runners. Linux passed because
Linux's "delete while open" semantics don't depend on the open
handle's share mode.

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

Author: paulirwin

src/Lucene.Net/Store/MMapDirectory.cs

@@ -765,44 +765,70 @@ private SharedMapping(MemoryMappedFile? mmf, Chunk[] chunks, long length)
 
             internal static SharedMapping Create(string file, int chunkSizePower)
             {
-                // We don't track a separate FileStream: the path-based
-                // CreateFromFile overload opens its own handle and
-                // disposes it with the MemoryMappedFile. We capture the
-                // file length once via FileInfo for our own snapshot
-                // (used as the slice/range upper bound). Any divergence
-                // between this snapshot and the framework's internal
-                // stat — e.g. the file growing in between, formerly the
-                // #1090 race — is harmless: the mmap itself is sized by
-                // the framework's own stat, and our `length` is treated
-                // as a snapshot at open time (matching upstream Java's
-                // fc.size() snapshot semantics).
-                long length = new FileInfo(file).Length;
-                if (length == 0)
-                {
-                    return new SharedMapping(mmf: null, chunks: Array.Empty<Chunk>(), length: 0);
-                }
-
+                // We open our own FileStream so we control the FileShare
+                // flags. The path-based CreateFromFile overload internally
+                // opens with FileShare.Read, which on Windows blocks
+                // attempts to delete or write to this file while we have
+                // it mapped — breaking callers (e.g. FreeTextSuggester)
+                // that build a temp index, dispose the directory, and
+                // immediately recursively delete the directory. We need
+                // FileShare.Delete in particular: on Windows, a delete
+                // attempt against an open file fails unless the open
+                // share-mode permits FILE_SHARE_DELETE.
+                //
+                // bufferSize: 1 because MemoryMappedFile uses only the
+                // file handle and bypasses the FileStream buffer, so a
+                // 4 KiB default buffer would just be allocated and
+                // immediately discarded.
+                FileStream fs = new FileStream(file, FileMode.Open, FileAccess.Read,
+                    FileShare.ReadWrite | FileShare.Delete,
+                    bufferSize: 1, FileOptions.RandomAccess);
                 MemoryMappedFile? mmf = null;
                 Chunk[]? chunks = null;
                 try
                 {
+                    long length = fs.Length;
+                    if (length == 0)
+                    {
+                        // CreateViewAccessor rejects zero-length views and
+                        // CreateFromFile rejects capacity 0 on an empty file,
+                        // so handle this edge case ourselves. Dispose the
+                        // FileStream eagerly since there's no MMF to own it.
+                        fs.Dispose();
+                        return new SharedMapping(mmf: null, chunks: Array.Empty<Chunk>(), length: 0);
+                    }
+
                     // capacity: 0 -> the framework uses the file's
                     // current size on disk, atomically with mapping
                     // creation. This eliminates the #1090 race window
                     // we previously had to retry around.
+                    // leaveOpen: false -> the MMF takes ownership of the
+                    // FileStream and disposes it on its own Dispose, so
+                    // we don't need to track it ourselves.
                     mmf = MemoryMappedFile.CreateFromFile(
-                        path: file,
-                        mode: FileMode.Open,
+                        fileStream: fs,
                         mapName: null,
                         capacity: 0,
-                        access: MemoryMappedFileAccess.Read);
+                        access: MemoryMappedFileAccess.Read,
+#if FEATURE_MEMORYMAPPEDFILESECURITY
+                        memoryMappedFileSecurity: null,
+#endif
+                        inheritability: HandleInheritability.None,
+                        leaveOpen: false);
                     chunks = MapChunks(mmf, 0, length, chunkSizePower);
                     return new SharedMapping(mmf, chunks, length);
                 }
                 catch
                 {
                     DisposeChunks(chunks);
-                    mmf?.Dispose();
+                    if (mmf != null)
+                    {
+                        mmf.Dispose(); // disposes fs (leaveOpen: false)
+                    }
+                    else
+                    {
+                        IOUtils.DisposeWhileHandlingException(fs);
+                    }
                     throw;
                 }
             }