Fix git restore after deleting directory with nested subdirs

Add functional test to reproduce issue #1901: running 'git restore .'
after deleting a directory with nested subdirectories fails with
'fatal: cannot create directory: Directory not empty'.

Root cause: when git recreates a deleted directory, GVFS's
NotifyNewFileCreated handler calls MarkDirectoryAsPlaceholder(), which
causes ProjFS to immediately project all children back into the
directory. Git then fails when it tries to create subdirectories that
ProjFS has already auto-projected.

Fix: skip MarkDirectoryAsPlaceholder() for directories whose path (or a
parent path) is already in ModifiedPaths, indicating git/user has taken
ownership. The directory stays non-virtualized so git can populate it
directly without ProjFS interference.

Fixes #1901

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 2 people

GVFS/GVFS.FunctionalTests/Tests/GitCommands/CorruptionReproTests.cs

@@ -75,5 +75,24 @@ public void ReproCherryPickRestoreCorruption()
             this.ValidateGitCommand("restore -- .");
             this.FilesShouldMatchCheckoutOfSourceBranch();
         }
+
+        /// <summary>
+        /// Reproduction of a reported issue:
+        /// Restoring a file after its parent directory was deleted fails with
+        /// "fatal: could not unlink 'path\to\': Directory not empty"
+        ///
+        /// See https://github.com/microsoft/VFSForGit/issues/1901
+        /// </summary>
+        [TestCase]
+        public void RestoreAfterDeleteNesteredDirectory()
+        {
+            // Delete a directory with nested subdirectories and files.
+            this.ValidateNonGitCommand("cmd.exe", "/c \"rmdir /s /q GVFlt_DeleteFileTest\"");
+
+            // Restore the working directory.
+            this.ValidateGitCommand("restore .");
+
+            this.FilesShouldMatchCheckoutOfSourceBranch();
+        }
     }
 }

GVFS/GVFS.FunctionalTests/Tests/GitCommands/GitRepoTests.cs

@@ -269,6 +269,23 @@ protected void ValidateGitCommand(string command, params object[] args)
                 args);
         }
 
+        protected void ValidateNonGitCommand(string command, string args = "", bool ignoreErrors = false, bool checkStatus = true)
+        {
+            string controlRepoRoot = this.ControlGitRepo.RootPath;
+            string gvfsRepoRoot = this.Enlistment.RepoRoot;
+
+            ProcessResult expectedResult = ProcessHelper.Run(command, args, controlRepoRoot);
+            ProcessResult actualResult = ProcessHelper.Run(command, args, gvfsRepoRoot);
+            if (!ignoreErrors)
+            {
+                GitHelpers.ErrorsShouldMatch(command, expectedResult, actualResult);
+            }
+            if (checkStatus)
+            {
+                this.ValidateGitCommand("status");
+            }
+        }
+
         protected void ChangeMode(string filePath, ushort mode)
         {
             string virtualFile = Path.Combine(this.Enlistment.RepoRoot, filePath);

GVFS/GVFS.FunctionalTests/Tools/ProcessHelper.cs

@@ -6,6 +6,11 @@ namespace GVFS.FunctionalTests.Tools
     public static class ProcessHelper
     {
         public static ProcessResult Run(string fileName, string arguments)
+        {
+            return Run(fileName, arguments, null);
+        }
+
+        public static ProcessResult Run(string fileName, string arguments, string workingDirectory)
         {
             ProcessStartInfo startInfo = new ProcessStartInfo();
             startInfo.UseShellExecute = false;
@@ -14,6 +19,10 @@ public static ProcessResult Run(string fileName, string arguments)
             startInfo.CreateNoWindow = true;
             startInfo.FileName = fileName;
             startInfo.Arguments = arguments;
+            if (!string.IsNullOrEmpty(workingDirectory))
+            {
+                startInfo.WorkingDirectory = workingDirectory;
+            }
 
             return Run(startInfo);
         }

GVFS/GVFS.Platform.Windows/WindowsFileSystemVirtualizer.cs

@@ -1014,7 +1014,15 @@ private void NotifyNewFileCreatedHandler(
                         GitCommandLineParser gitCommand = new GitCommandLineParser(this.Context.Repository.GVFSLock.GetLockedGitCommand());
                         if (gitCommand.IsValidGitCommand)
                         {
-                            this.MarkDirectoryAsPlaceholder(virtualPath, triggeringProcessId, triggeringProcessImageFileName);
+                            // When git recreates a directory that was previously deleted (and is
+                            // tracked in ModifiedPaths), skip marking it as a ProjFS placeholder.
+                            // Otherwise ProjFS would immediately project all children into it,
+                            // conflicting with git's own attempt to populate the directory.
+                            // See https://github.com/microsoft/VFSForGit/issues/1901
+                            if (!this.FileSystemCallbacks.IsPathOrParentInModifiedPaths(virtualPath, isFolder: true))
+                            {
+                                this.MarkDirectoryAsPlaceholder(virtualPath, triggeringProcessId, triggeringProcessImageFileName);
+                            }
                         }
                         else
                         {

GVFS/GVFS.Virtualization/FileSystemCallbacks.cs

@@ -367,6 +367,17 @@ public IEnumerable<string> GetAllModifiedPaths()
             return this.modifiedPaths.GetAllModifiedPaths();
         }
 
+        /// <summary>
+        /// Checks whether the given folder path, or any of its parent folders,
+        /// is in the ModifiedPaths database. Used to determine if git/user has
+        /// taken ownership of a directory tree.
+        /// </summary>
+        public bool IsPathOrParentInModifiedPaths(string path, bool isFolder)
+        {
+            return this.modifiedPaths.Contains(path, isFolder) ||
+                   this.modifiedPaths.ContainsParentFolder(path, out _);
+        }
+
         /// <summary>
         /// Finds index entries that are staged (differ from HEAD) matching the given
         /// pathspec, and adds them to ModifiedPaths. This prepares for an unstage operation