Foundation: further adjust the _removeItem for large paths

This function explicitly requires to be iterative to ensure that we do
not stack overflow on large directories.  Rewrite the logic for avoiding
some unnecessary re-encodings and disk IOs.  The failure in the removal
was identified by DocC.

Author: compnerd

Diff for: Sources/Foundation/FileManager+Win32.swift

@@ -582,83 +582,77 @@ extension FileManager {
             return
         }
 
-        let faAttributes: WIN32_FILE_ATTRIBUTE_DATA
-        do {
-            faAttributes = try windowsFileAttributes(atPath: path)
-        } catch {
-            // removeItem on POSIX throws fileNoSuchFile rather than
-            // fileReadNoSuchFile that windowsFileAttributes will
-            // throw if it doesn't find the file.
-            if (error as NSError).code == CocoaError.fileReadNoSuchFile.rawValue {
-                throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
-            } else {
-                throw error
-            }
-        }
-
-        if faAttributes.dwFileAttributes & FILE_ATTRIBUTE_READONLY == FILE_ATTRIBUTE_READONLY {
-          if try !FileManager.default._fileSystemRepresentation(withPath: path, {
-            SetFileAttributesW($0, faAttributes.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY)
-          }) {
-            throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
-          }
-        }
+        try URL(fileURLWithPath: path).withUnsafeFileSystemRepresentation {
+            "\\\\?\\\(String(cString: $0!))".withCString(encodedAs: UTF16.self) {
+                var faAttributes: WIN32_FILE_ATTRIBUTE_DATA = .init()
+                if !GetFileAttributesExW($0, GetFileExInfoStandard, &faAttributes) {
+                    throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
+                }
 
-        if faAttributes.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY == 0 {
-          if try !FileManager.default._fileSystemRepresentation(withPath: path, DeleteFileW) {
-            throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
-          }
-          return
-        }
+                guard faAttributes.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY == FILE_ATTRIBUTE_DIRECTORY else {
+                    if faAttributes.dwFileAttributes & FILE_ATTRIBUTE_READONLY == FILE_ATTRIBUTE_READONLY {
+                        if !SetFileAttributesW($0, faAttributes.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY) {
+                            throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
+                        }
+                    }
 
-        var dirStack = [path]
-        var itemPath = ""
-        while let currentDir = dirStack.popLast() {
-            do {
-                itemPath = currentDir
-                guard alreadyConfirmed || shouldRemoveItemAtPath(itemPath, isURL: isURL) else {
-                    continue
-                }
+                    if !DeleteFileW($0) {
+                        throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
+                    }
 
-                if try FileManager.default._fileSystemRepresentation(withPath: itemPath, RemoveDirectoryW) {
-                  continue
+                    return
                 }
-                guard GetLastError() == ERROR_DIR_NOT_EMPTY else {
-                    throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [itemPath])
-                }
-                dirStack.append(itemPath)
 
-                let root = URL(fileURLWithPath: itemPath, isDirectory: true)
-                try walk(directory: root) { (entry, attributes) in
-                    if entry == "." || entry == ".." { return }
-
-                    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 {
-                        path.withUnsafeFileSystemRepresentation {
-                            guard alreadyConfirmed || shouldRemoveItemAtPath(path.path, isURL: isURL) else {
-                                return
-                            }
+                var stack: [String] = [path]
+                while let directory = stack.popLast() {
+                    do {
+                        guard alreadyConfirmed || shouldRemoveItemAtPath(directory, isURL: isURL) else {
+                            continue
+                        }
 
-                            "\\\\?\\\(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])
-                                    }
+                        let root = URL(fileURLWithPath: directory, isDirectory: true)
+                        try root.withUnsafeFileSystemRepresentation {
+                            try "\\\\?\\\(String(cString: $0!))".withCString(encodedAs: UTF16.self) {
+                                if !RemoveDirectoryW($0) { continue }
+                                guard GetLastError() == ERROR_DIR_NOT_EMPTY else {
+                                    throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [directory])
                                 }
-                                if !DeleteFileW($0) {
-                                    throw _NSErrorWithWindowsError(GeteLastErrro(), reading: false, paths: [entry])
+                                stack.append(root.path)
+
+                                try walk(directory: root) { (entry, attributes) in
+                                    if entry == "." || entry == ".." { return }
+
+                                    let isDirectory = attributes & FILE_ATTRIBUTE_DIRECTORY == FILE_ATTRIBUTE_DIRECTORY && attributes & FILE_ATTRIBUTE_REPARSE_POINT == 0
+                                    let path = root.appendingPathComponent(entry, isDirectory: isDirectory)
+                                    if isDirectory {
+                                        stack.append(path.path)
+                                    } else {
+                                        guard alreadyConfirmed || shouldRemoveItemAtPath(path.path, isURL: isURL) else {
+                                            return
+                                        }
+
+                                        path.withUnsafeFileSystemRepresentation {
+                                            "\\\\?\\\(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])
+                                                }
+                                            }
+                                        }
+                                    }
                                 }
                             }
                         }
+                    } catch let error {
+                        if !shouldProceedAfterError(error, removingItemAtPath: directory, isURL: isURL) {
+                            throw error
+                        }
                     }
                 }
-            } catch {
-                if !shouldProceedAfterError(error, removingItemAtPath: itemPath, isURL: isURL) {
-                    throw error
-                }
             }
         }
     }