[Windows] Replace uses of withCString with getFSR

This ensures that paths are normalized before being handed off to win32
functions.

Author: gmittert

Foundation/FileHandle.swift

@@ -427,7 +427,9 @@ open class FileHandle : NSObject {
     }
 
     internal convenience init?(path: String, flags: Int32, createMode: Int) {
-      let fd = _CFOpenFileWithMode(path, flags, mode_t(createMode))
+      let fsr = FileManager.default.fileSystemRepresentation(withPath: path)
+      defer { fsr.deallocate() }
+      let fd = _CFOpenFileWithMode(fsr, flags, mode_t(createMode))
       guard fd > 0 else { return nil }
       self.init(fileDescriptor: fd, closeOnDealloc: true)
       if _handle == INVALID_HANDLE_VALUE { return nil }
@@ -453,14 +455,7 @@ open class FileHandle : NSObject {
 #endif
 
     internal convenience init?(fileSystemRepresentation: UnsafePointer<Int8>, flags: Int32, createMode: Int) {
-#if os(Windows)
-        var fd: Int32 = -1
-        if let path = String(cString: fileSystemRepresentation).cString(using: .utf16) {
-            fd = _CFOpenFileWithMode(path, flags, mode_t(createMode))
-        }
-#else
         let fd = _CFOpenFileWithMode(fileSystemRepresentation, flags, mode_t(createMode))
-#endif
         guard fd > 0 else { return nil }
         self.init(fileDescriptor: fd, closeOnDealloc: true)
     }

Foundation/FileManager+Win32.swift

@@ -10,12 +10,13 @@
 import CoreFoundation
 
 #if os(Windows)
-internal func joinPath(prefix: String, suffix: String) -> String {
+
+internal func joinPath(prefix: String, suffix: String) throws -> String {
     var pszPath: PWSTR?
-    _ = prefix.withCString(encodedAs: UTF16.self) { prefix in
-        _ = suffix.withCString(encodedAs: UTF16.self) { suffix in
-            PathAllocCombine(prefix, suffix, ULONG(PATHCCH_ALLOW_LONG_PATHS.rawValue), &pszPath)
-        }
+    guard S_OK == (try FileManager.default._fileSystemRepresentation(withPath: prefix, andPath: suffix) {
+        PathAllocCombine($0, $1, ULONG(PATHCCH_ALLOW_LONG_PATHS.rawValue), &pszPath)
+    }) else {
+        throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [prefix])
     }
 
     let path: String = String(decodingCString: pszPath!, as: UTF16.self)
@@ -177,11 +178,8 @@ extension FileManager {
           UnsafeMutablePointer<SECURITY_ATTRIBUTES>(&saAttributes)
 
 
-        try path.withCString(encodedAs: UTF16.self) {
-            if !CreateDirectoryW($0, psaAttributes) {
-                // FIXME(compnerd) pass along path
-                throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
-            }
+        guard try _fileSystemRepresentation(withPath: path, { CreateDirectoryW($0, psaAttributes) }) else {
+            throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
         }
         if let attr = attributes {
             try self.setAttributes(attr, ofItemAtPath: path)
@@ -192,7 +190,7 @@ extension FileManager {
         guard path != "" else {
             throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileReadInvalidFileName.rawValue, userInfo: [NSFilePathErrorKey : NSString(path)])
         }
-        try (path + "\\*").withCString(encodedAs: UTF16.self) {
+        try _fileSystemRepresentation(withPath: path + "\\*") {
             var ffd: WIN32_FIND_DATAW = WIN32_FIND_DATAW()
 
             let hDirectory: HANDLE = FindFirstFileW($0, &ffd)
@@ -220,17 +218,17 @@ extension FileManager {
         try _contentsOfDir(atPath: path, { (entryName, entryType) throws in
             contents.append(entryName)
             if entryType & FILE_ATTRIBUTE_DIRECTORY == FILE_ATTRIBUTE_DIRECTORY {
-                let subPath: String = joinPath(prefix: path, suffix: entryName)
+                let subPath: String = try joinPath(prefix: path, suffix: entryName)
                 let entries = try subpathsOfDirectory(atPath: subPath)
-                contents.append(contentsOf: entries.map { joinPath(prefix: entryName, suffix: $0).standardizingPath })
+                contents.append(contentsOf: try entries.map { try joinPath(prefix: entryName, suffix: $0).standardizingPath })
             }
         })
         return contents
     }
 
     internal func windowsFileAttributes(atPath path: String) throws -> WIN32_FILE_ATTRIBUTE_DATA {
         var faAttributes: WIN32_FILE_ATTRIBUTE_DATA = WIN32_FILE_ATTRIBUTE_DATA()
-        return try path.withCString(encodedAs: UTF16.self) {
+        return try _fileSystemRepresentation(withPath: path) {
             if !GetFileAttributesExW($0, GetFileExInfoStandard, &faAttributes) {
                 throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
             }
@@ -245,7 +243,7 @@ extension FileManager {
     internal func _attributesOfFileSystem(forPath path: String) throws -> [FileAttributeKey : Any] {
         var result: [FileAttributeKey:Any] = [:]
 
-        try path.withCString(encodedAs: UTF16.self) {
+        try _fileSystemRepresentation(withPath: path) {
             let dwLength: DWORD = GetFullPathNameW($0, 0, nil, nil)
             guard dwLength != 0 else {
                 throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
@@ -291,18 +289,14 @@ extension FileManager {
             dwFlags |= DWORD(SYMBOLIC_LINK_FLAG_DIRECTORY)
         }
 
-        try path.withCString(encodedAs: UTF16.self) { name in
-            try destPath.withCString(encodedAs: UTF16.self) { dest in
-                guard CreateSymbolicLinkW(name, dest, dwFlags) != 0 else {
-                    throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path, destPath])
-                }
-            }
+        guard try _fileSystemRepresentation(withPath: path, andPath: destPath, { CreateSymbolicLinkW($0, $1, dwFlags) != 0 }) else {
+            throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path, destPath])
         }
     }
 
     internal func _destinationOfSymbolicLink(atPath path: String) throws -> String {
-        let handle = path.withCString(encodedAs: UTF16.self) { symlink in
-            CreateFileW(symlink,
+        let handle = try _fileSystemRepresentation(withPath: path) {
+            CreateFileW($0,
                 GENERIC_READ,
                 DWORD(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE),
                 nil,
@@ -355,16 +349,15 @@ extension FileManager {
     }
 
     internal func _canonicalizedPath(toFileAtPath path: String) throws -> String {
-        var hFile: HANDLE = INVALID_HANDLE_VALUE
-        path.withCString(encodedAs: UTF16.self) { link in
-          // BACKUP_SEMANTICS are (confusingly) required in order to receive a
-          // handle to a directory
-          hFile = CreateFileW(link, 0, DWORD(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE),
-                              nil, DWORD(OPEN_EXISTING), DWORD(FILE_FLAG_BACKUP_SEMANTICS),
-                              nil)
+        var hFile: HANDLE = try _fileSystemRepresentation(withPath: path) {
+            // BACKUP_SEMANTICS are (confusingly) required in order to receive a
+            // handle to a directory
+            CreateFileW($0, 0, DWORD(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE),
+                        nil, DWORD(OPEN_EXISTING), DWORD(FILE_FLAG_BACKUP_SEMANTICS),
+                        nil)
         }
         guard hFile != INVALID_HANDLE_VALUE else {
-            return try path.withCString(encodedAs: UTF16.self) {
+            return try _fileSystemRepresentation(withPath: path) {
                 var dwLength = GetFullPathNameW($0, 0, nil, nil)
                 var szPath = Array<WCHAR>(repeating: 0, count: Int(dwLength + 1))
                 dwLength = GetFullPathNameW($0, DWORD(szPath.count), &szPath, nil)
@@ -384,12 +377,8 @@ extension FileManager {
     }
 
     internal func _copyRegularFile(atPath srcPath: String, toPath dstPath: String, variant: String = "Copy") throws {
-        try srcPath.withCString(encodedAs: UTF16.self) { src in
-            try dstPath.withCString(encodedAs: UTF16.self) { dst in
-                if !CopyFileW(src, dst, false) {
-                    throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [srcPath, dstPath])
-                }
-            }
+        guard try _fileSystemRepresentation(withPath: srcPath, andPath: dstPath, { CopyFileW($0, $1, false) }) else {
+            throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [srcPath, dstPath])
         }
     }
 
@@ -420,8 +409,8 @@ extension FileManager {
           }
 
           while let item = enumerator.nextObject() as? String {
-            let src = joinPath(prefix: srcPath, suffix: item)
-            let dst = joinPath(prefix: dstPath, suffix: item)
+            let src = try joinPath(prefix: srcPath, suffix: item)
+            let dst = try joinPath(prefix: dstPath, suffix: item)
 
             let faAttributes = try windowsFileAttributes(atPath: src)
             fileType = FileAttributeType(attributes: faAttributes, atPath: srcPath)
@@ -445,12 +434,10 @@ extension FileManager {
             throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileWriteFileExists.rawValue, userInfo: [NSFilePathErrorKey : NSString(dstPath)])
         }
 
-        try srcPath.withCString(encodedAs: UTF16.self) { src in
-            try dstPath.withCString(encodedAs: UTF16.self) { dst in
-                if !MoveFileExW(src, dst, DWORD(MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH)) {
-                    throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [srcPath, dstPath])
-                }
-            }
+        guard try _fileSystemRepresentation(withPath: srcPath, andPath: dstPath, {
+            MoveFileExW($0, $1, DWORD(MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH))
+        }) else {
+            throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [srcPath, dstPath])
         }
     }
 
@@ -463,12 +450,8 @@ extension FileManager {
             do {
                 switch fileType {
                 case .typeRegular:
-                    try srcPath.withCString(encodedAs: UTF16.self) { src in
-                        try dstPath.withCString(encodedAs: UTF16.self) { dst in
-                            if !CreateHardLinkW(dst, src, nil) {
-                                throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [srcPath, dstPath])
-                            }
-                        }
+                    guard try _fileSystemRepresentation(withPath: srcPath, andPath: dstPath, { CreateHardLinkW($1, $0, nil) }) else {
+                        throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [srcPath, dstPath])
                     }
                 case .typeSymbolicLink:
                     try _copySymlink(atPath: srcPath, toPath: dstPath)
@@ -488,50 +471,37 @@ extension FileManager {
             return
         }
 
-        guard path != "" else {
-            throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileReadInvalidFileName.rawValue, userInfo: [NSFilePathErrorKey : NSString(path)])
-        }
-
-        let url = URL(fileURLWithPath: path)
-        var fsrBuf: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(MAX_PATH))
-        _CFURLGetWideFileSystemRepresentation(url._cfObject, false, &fsrBuf, Int(MAX_PATH))
-        let length = wcsnlen_s(&fsrBuf, fsrBuf.count)
-        let fsrPath = String(utf16CodeUnits: &fsrBuf, count: length)
-
-        let faAttributes = try windowsFileAttributes(atPath: fsrPath)
-
+        let faAttributes = try windowsFileAttributes(atPath: path)
         if faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_READONLY) == FILE_ATTRIBUTE_READONLY {
         let readableAttributes = faAttributes.dwFileAttributes & DWORD(bitPattern: ~FILE_ATTRIBUTE_READONLY)
-            guard fsrPath.withCString(encodedAs: UTF16.self, { SetFileAttributesW($0, readableAttributes) }) else {
+            guard try _fileSystemRepresentation(withPath: path, { SetFileAttributesW($0, readableAttributes) }) else {
                 throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
             }
         }
 
         if faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY) == 0 {
-            if !fsrPath.withCString(encodedAs: UTF16.self, DeleteFileW) {
+            guard try _fileSystemRepresentation(withPath: path, DeleteFileW) else {
                 throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
             }
             return
         }
-        var dirStack = [fsrPath]
+        var dirStack = [path]
         var itemPath = ""
         while let currentDir = dirStack.popLast() {
             do {
                 itemPath = currentDir
                 guard alreadyConfirmed || shouldRemoveItemAtPath(itemPath, isURL: isURL) else {
                     continue
                 }
-                guard !itemPath.withCString(encodedAs: UTF16.self, RemoveDirectoryW) else {
+                guard !(try _fileSystemRepresentation(withPath: itemPath, RemoveDirectoryW)) else {
                     continue
                 }
                 guard GetLastError() == ERROR_DIR_NOT_EMPTY else {
                     throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [itemPath])
                 }
                 dirStack.append(itemPath)
                 var ffd: WIN32_FIND_DATAW = WIN32_FIND_DATAW()
-                let h: HANDLE = (itemPath + "\\*").withCString(encodedAs: UTF16.self, {
-                    FindFirstFileW($0, &ffd)
-                })
+                let h: HANDLE = try _fileSystemRepresentation(withPath: itemPath + "\\*", { FindFirstFileW($0, &ffd) })
                 guard h != INVALID_HANDLE_VALUE else {
                     throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [itemPath])
                 }
@@ -546,7 +516,7 @@ extension FileManager {
 
                     if ffd.dwFileAttributes & DWORD(FILE_ATTRIBUTE_READONLY) == FILE_ATTRIBUTE_READONLY {
                         let readableAttributes = ffd.dwFileAttributes & DWORD(bitPattern: ~FILE_ATTRIBUTE_READONLY)
-                        guard file.withCString(encodedAs: UTF16.self, { SetFileAttributesW($0, readableAttributes) }) else {
+                        guard try _fileSystemRepresentation(withPath: file, { SetFileAttributesW($0, readableAttributes) }) else {
                             throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [file])
                         }
                     }
@@ -559,7 +529,7 @@ extension FileManager {
                         guard alreadyConfirmed || shouldRemoveItemAtPath(itemPath, isURL: isURL) else {
                             continue
                         }
-                        if !itemPath.withCString(encodedAs: UTF16.self, DeleteFileW) {
+                        guard try _fileSystemRepresentation(withPath: itemPath, DeleteFileW) else {
                             throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [file])
                         }
                     }
@@ -582,7 +552,7 @@ extension FileManager {
 
     @discardableResult
     internal func _changeCurrentDirectoryPath(_ path: String) -> Bool {
-        return path.withCString(encodedAs: UTF16.self) { SetCurrentDirectoryW($0) }
+        return (try? _fileSystemRepresentation(withPath: path, SetCurrentDirectoryW)) ?? false
     }
 
     internal func _fileExists(atPath path: String, isDirectory: UnsafeMutablePointer<ObjCBool>?) -> Bool {
@@ -775,11 +745,11 @@ extension FileManager {
 
             if isDir.boolValue && (level == 0 || !_options.contains(.skipsSubdirectoryDescendants)) {
                 var ffd = WIN32_FIND_DATAW()
-                let dirPath = joinPath(prefix: _lastReturned.path, suffix: "*")
-                let handle = dirPath.withCString(encodedAs: UTF16.self) {
-                  FindFirstFileW($0, &ffd)
+                guard let dirPath = try? joinPath(prefix: _lastReturned.path, suffix: "*"),
+                      let handle = try? FileManager.default._fileSystemRepresentation(withPath: dirPath, { FindFirstFileW($0, &ffd) }),
+                      handle != INVALID_HANDLE_VALUE else {
+                    return firstValidItem()
                 }
-                guard handle != INVALID_HANDLE_VALUE else { return firstValidItem() }
                 defer { FindClose(handle) }
 
                 repeat {

Foundation/FileManager.swift

@@ -436,7 +436,7 @@ open class FileManager : NSObject {
                     let hiddenAttrs = isHidden
                         ? attrs | DWORD(FILE_ATTRIBUTE_HIDDEN)
                         : attrs & DWORD(bitPattern: ~FILE_ATTRIBUTE_HIDDEN)
-                    guard path.withCString(encodedAs: UTF16.self, { SetFileAttributesW($0, hiddenAttrs) }) else {
+                    guard try _fileSystemRepresentation(withPath: path, { SetFileAttributesW($0, hiddenAttrs) }) else {
                         fatalError("Couldn't set \(path) to be hidden")
                     }
 #else
@@ -1264,24 +1264,28 @@ public struct FileAttributeType : RawRepresentable, Equatable, Hashable {
         self = .typeCharacterSpecial
       } else if attributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_REPARSE_POINT) == DWORD(FILE_ATTRIBUTE_REPARSE_POINT) {
         // A reparse point may or may not actually be a symbolic link, we need to read the reparse tag
-        let fileHandle = path.withCString(encodedAs: UTF16.self) {
+        let fileHandle = try? FileManager.default._fileSystemRepresentation(withPath: path) {
           CreateFileW(/*lpFileName=*/$0,
                       /*dwDesiredAccess=*/DWORD(0),
                       /*dwShareMode=*/DWORD(FILE_SHARE_READ | FILE_SHARE_WRITE),
                       /*lpSecurityAttributes=*/nil,
                       /*dwCreationDisposition=*/DWORD(OPEN_EXISTING),
                       /*dwFlagsAndAttributes=*/DWORD(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS),
                       /*hTemplateFile=*/nil)
+        } ?? INVALID_HANDLE_VALUE
+        guard fileHandle != INVALID_HANDLE_VALUE else {
+            self = .typeUnknown
+            return
         }
         defer { CloseHandle(fileHandle) }
         var tagInfo = FILE_ATTRIBUTE_TAG_INFO()
         guard GetFileInformationByHandleEx(fileHandle, FileAttributeTagInfo, &tagInfo, DWORD(MemoryLayout<FILE_ATTRIBUTE_TAG_INFO>.size)) else {
-          self = .typeUnknown
-          return
+            self = .typeUnknown
+            return
         }
         self = tagInfo.ReparseTag == IO_REPARSE_TAG_SYMLINK ? .typeSymbolicLink : .typeRegular
       } else {
-        self = .typeRegular
+          self = .typeRegular
       }
     }
 #else