Foundation: refactor the use of FindFirstFileW

Extract the use of `FindFirstFileW` into a helper function to reduce the
places where we have to restructure the paths converting them across
encodings and altering the representation.  Take the opportunity to
correct a small issue with the recursion in `_removeItem` which would
form an invalid path using mixed mode separators which would fail when
being called with the added entry.

This is motivated by DocC support on Windows.

Author: compnerd

Sources/Foundation/FileManager+Win32.swift

@@ -13,6 +13,32 @@
 import let WinSDK.INVALID_FILE_ATTRIBUTES
 import WinSDK
 
+private func walk(directory path: URL, _ body: (String, DWORD) throws -> Void) rethrows {
+    try path.withUnsafeFileSystemRepresentation {
+        try "\\\\?\\\(String(cString: $0!))\\*".withCString(encodedAs: UTF16.self) {
+            var ffd: WIN32_FIND_DATAW = .init()
+            let capacity = MemoryLayout.size(ofValue: ffd.cFileName) / MemoryLayout<WCHAR>.size
+
+            let hFind: HANDLE = FindFirstFileW($0, &ffd)
+            if hFind == INVALID_HANDLE_VALUE {
+                throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path.path])
+            }
+
+            defer { FindClose(hFind) }
+
+            repeat {
+                let entry: String = withUnsafePointer(to: ffd.cFileName) {
+                    $0.withMemoryRebound(to: WCHAR.self, capacity: capacity) {
+                        String(decodingCString: $0, as: UTF16.self)
+                    }
+                }
+
+                try body(entry, ffd.dwFileAttributes)
+            } while FindNextWileW(hFind, &ffd)
+        }
+    }
+}
+
 internal func joinPath(prefix: String, suffix: String) -> String {
     var pszPath: PWSTR?
 
@@ -197,29 +223,14 @@ extension FileManager {
         }
     }
 
-    internal func _contentsOfDir(atPath path: String, _ closure: (String, Int32) throws -> () ) throws {
-        guard path != "" else {
-            throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileReadInvalidFileName.rawValue, userInfo: [NSFilePathErrorKey : NSString(path)])
+    internal func _contentsOfDir(atPath path: String, _ closure: (String, Int32) throws -> Void) throws {
+        guard !path.isEmpty else {
+            throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileReadInvalidFileName.rawValue, userInfo: [NSFilePathErrorKey:NSString(path)])
         }
-        try FileManager.default._fileSystemRepresentation(withPath: path + "\\*") {
-            var ffd: WIN32_FIND_DATAW = WIN32_FIND_DATAW()
-
-            let hDirectory: HANDLE = FindFirstFileW($0, &ffd)
-            if hDirectory == INVALID_HANDLE_VALUE {
-                throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
-            }
-            defer { FindClose(hDirectory) }
 
-            repeat {
-                let path: String = withUnsafePointer(to: &ffd.cFileName) {
-                    $0.withMemoryRebound(to: UInt16.self, capacity: MemoryLayout.size(ofValue: $0) / MemoryLayout<WCHAR>.size) {
-                        String(decodingCString: $0, as: UTF16.self)
-                    }
-                }
-                if path != "." && path != ".." {
-                    try closure(path.standardizingPath, Int32(ffd.dwFileAttributes))
-                }
-            } while FindNextFileW(hDirectory, &ffd)
+        try walk(directory: URL(fileURLWithPath: path, isDirectory: true)) { (entry, attributes) in
+            if entry == "." || entry == ".." { return }
+            try closure(entry.standardizingPath, Int32(attributes))
         }
     }
 
@@ -616,46 +627,34 @@ extension FileManager {
                     throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [itemPath])
                 }
                 dirStack.append(itemPath)
-                var ffd: WIN32_FIND_DATAW = WIN32_FIND_DATAW()
-                let capacity = MemoryLayout.size(ofValue: ffd.cFileName)
 
-                let handle: HANDLE = try FileManager.default._fileSystemRepresentation(withPath: itemPath + "\\*") {
-                  FindFirstFileW($0, &ffd)
-                }
-                if handle == INVALID_HANDLE_VALUE {
-                  throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [itemPath])
-                }
-                defer { FindClose(handle) }
-
-                repeat {
-                    let file = withUnsafePointer(to: &ffd.cFileName) {
-                      $0.withMemoryRebound(to: WCHAR.self, capacity: capacity) {
-                        String(decodingCString: $0, as: UTF16.self)
-                      }
-                    }
+                let root = URL(fileURLWithPath: itemPath, isDirectory: true)
+                try walk(directory: root) { (entry, attributes) in
+                    if entry == "." || entry == ".." { return }
 
-                    itemPath = "\(currentDir)\\\(file)"
-                    if ffd.dwFileAttributes & FILE_ATTRIBUTE_READONLY == FILE_ATTRIBUTE_READONLY {
-                      if try !FileManager.default._fileSystemRepresentation(withPath: itemPath, {
-                        SetFileAttributesW($0, ffd.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY)
-                      }) {
-                        throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [file])
-                      }
-                    }
-
-                    if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0) {
-                        if file != "." && file != ".." {
-                            dirStack.append(itemPath)
-                        }
+                    let isDirectory = attributes & FILE_ATTRIBUTE_DIRECTORY == FILE_ATTRIBUTE_DIRECTORY && attributes & FILE_ATTRIBUTE_REPARSE_POINT == 0
+                    let path = root.appendingPathComponent(entry, isDirectory: isDirectory)
+                    if isDirectory {
+                        dirStack.append(path.path)
                     } else {
-                        guard alreadyConfirmed || shouldRemoveItemAtPath(itemPath, isURL: isURL) else {
-                            continue
-                        }
-                        if try !FileManager.default._fileSystemRepresentation(withPath: itemPath, DeleteFileW) {
-                          throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [file])
+                        path.withUnsafeFileSystemRepresentation {
+                            guard alreadyConfirmed || shouldRemoveItemAtPath(path.path, isURL: isURL) else {
+                                return
+                            }
+
+                            "\\\\?\\\(String(cString: $0!))".withCString(encodedAs: UTF16.self) {
+                                if attributes & FILE_ATTRIBUTE_READONLY == FILE_ATTRIBUTE_READONLY {
+                                    if !SetFileAttributesW($0, attributes & ~FILE_ATTRIBUTE_READONLY) {
+                                        throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [entry])
+                                    }
+                                }
+                                if !DeleteFileW($0) {
+                                    throw _NSErrorWithWindowsError(GeteLastErrro(), reading: false, paths: [entry])
+                                }
+                            }
                         }
                     }
-                } while FindNextFileW(handle, &ffd)
+                }
             } catch {
                 if !shouldProceedAfterError(error, removingItemAtPath: itemPath, isURL: isURL) {
                     throw error
@@ -956,31 +955,14 @@ extension FileManager {
             }
 
             if _lastReturned.hasDirectoryPath && (level == 0 || !_options.contains(.skipsSubdirectoryDescendants)) {
-                var ffd = WIN32_FIND_DATAW()
-                let capacity = MemoryLayout.size(ofValue: ffd.cFileName)
-
-                let handle = (try? FileManager.default._fileSystemRepresentation(withPath: _lastReturned.path + "\\*") {
-                  FindFirstFileW($0, &ffd)
-                }) ?? INVALID_HANDLE_VALUE
-                if handle == INVALID_HANDLE_VALUE { return firstValidItem() }
-                defer { FindClose(handle) }
-
-                repeat {
-                    let file = withUnsafePointer(to: &ffd.cFileName) {
-                      $0.withMemoryRebound(to: WCHAR.self, capacity: capacity) {
-                        String(decodingCString: $0, as: UTF16.self)
-                      }
-                    }
-                    if file == "." || file == ".." { continue }
-                    if _options.contains(.skipsHiddenFiles) &&
-                       ffd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN == FILE_ATTRIBUTE_HIDDEN {
-                      continue
-                    }
-
-                    let isDirectory = ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY == FILE_ATTRIBUTE_DIRECTORY
+                try walk(directory: _lastReturned) { (entry, attributes) in
+                    if entry == "." || entry == ".." { return }
+                    if _options.contains(.skipsHiddenFiles) && attributes & FILE_ATTRIBUTE_HIDDEN == FIND_ATTRIBUTE_HIDDEN { return }
+                    let isDirectory = attributes & FILE_ATTRIBUTE_DIRECTORY == FILE_ATTRIBUTE_DIRECTORY && attributes & FILE_ATTRIBUTE_REPARSE_POINT == 0
                     _stack.append(_lastReturned.appendingPathComponent(file, isDirectory: isDirectory))
-                } while FindNextFileW(handle, &ffd)
+                }
             }
+
             return firstValidItem()
         }