Foundation: support _getFileSystemRepresentation on Windows

Update the `_getFileSystemRepresentation` helper to return a UTF-16
Windows style path.  This enables us to properly model the file system
representation of the path and the URL representation of the path.

Author: compnerd

CoreFoundation/URL.subproj/CFURL.c

@@ -3965,10 +3965,15 @@ CF_EXPORT void __CFURLSetResourceInfoPtr(CFURLRef url, void *ptr) {
 /* HFSPath<->URLPath functions at the bottom of the file */
 static CFArrayRef WindowsPathToURLComponents(CFStringRef path, CFAllocatorRef alloc, Boolean isDir, Boolean isAbsolute) CF_RETURNS_RETAINED {
     CFArrayRef tmp;
+    CFMutableStringRef mutablePath;
     CFMutableArrayRef urlComponents = NULL;
     CFIndex i=0;
 
-    tmp = CFStringCreateArrayBySeparatingStrings(alloc, path, CFSTR("\\"));
+    // Since '/' is a valid Windows path separator, we convert '/' to '\' before splitting
+    mutablePath = CFStringCreateMutableCopy(alloc, 0, path);
+    CFStringFindAndReplace(mutablePath, CFSTR("/"), CFSTR("\\"), CFRangeMake(0, CFStringGetLength(mutablePath)), 0);
+    tmp = CFStringCreateArrayBySeparatingStrings(alloc, mutablePath, CFSTR("\\"));
+    CFRelease(mutablePath);
     urlComponents = CFArrayCreateMutableCopy(alloc, 0, tmp);
     CFRelease(tmp);
 

Foundation/FileManager+Win32.swift

@@ -175,22 +175,20 @@ extension FileManager {
             }
         }
 
-        var saAttributes: SECURITY_ATTRIBUTES =
-          SECURITY_ATTRIBUTES(nLength: DWORD(MemoryLayout<SECURITY_ATTRIBUTES>.size),
-                              lpSecurityDescriptor: nil,
-                              bInheritHandle: false)
-        let psaAttributes: UnsafeMutablePointer<SECURITY_ATTRIBUTES> =
-          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])
+        try FileManager.default._fileSystemRepresentation(withPath: path) { fsr in
+          var saAttributes: SECURITY_ATTRIBUTES =
+            SECURITY_ATTRIBUTES(nLength: DWORD(MemoryLayout<SECURITY_ATTRIBUTES>.size),
+                                lpSecurityDescriptor: nil,
+                                bInheritHandle: false)
+          try withUnsafeMutablePointer(to: &saAttributes) {
+            if !CreateDirectoryW(fsr, $0) {
+              throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
             }
-        }
-        if let attr = attributes {
+          }
+
+          if let attr = attributes {
             try self.setAttributes(attr, ofItemAtPath: path)
+          }
         }
     }
 
@@ -236,15 +234,15 @@ extension FileManager {
     }
 
     internal func windowsFileAttributes(atPath path: String) throws -> WIN32_FILE_ATTRIBUTE_DATA {
+      return try FileManager.default._fileSystemRepresentation(withPath: path) {
         var faAttributes: WIN32_FILE_ATTRIBUTE_DATA = WIN32_FILE_ATTRIBUTE_DATA()
-        return try path.withCString(encodedAs: UTF16.self) {
-            if !GetFileAttributesExW($0, GetFileExInfoStandard, &faAttributes) {
-                throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
-            }
-            return faAttributes
-        }
+          if !GetFileAttributesExW($0, GetFileExInfoStandard, &faAttributes) {
+            throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
+          }
+        return faAttributes
+      }
     }
-    
+
     internal func _attributesOfFileSystemIncludingBlockSize(forPath path: String) throws -> (attributes: [FileAttributeKey : Any], blockSize: UInt64?) {
         return (attributes: try _attributesOfFileSystem(forPath: path), blockSize: nil)
     }
@@ -292,9 +290,10 @@ extension FileManager {
             case .some(false):
                 break;
             case .none:
-                let resolvedDest = destPath.isAbsolutePath
-                    ? destPath
-                    : try joinPath(prefix: path.deletingLastPathComponent, suffix: destPath)
+                let resolvedDest =
+                  destPath.isAbsolutePath ? destPath
+                                          : joinPath(prefix: path.deletingLastPathComponent,
+                                                     suffix: destPath)
                 guard let faAttributes = try? windowsFileAttributes(atPath: resolvedDest) else {
                     // Note: windowsfileAttributes will throw if the destPath is not found.
                     // Since on Windows, you are required to know the type of the symlink
@@ -309,12 +308,10 @@ extension FileManager {
                 }
         }
 
-        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])
-                }
-            }
+        try FileManager.default._fileSystemRepresentation(withPath: path, andPath: destPath) {
+          guard CreateSymbolicLinkW($0, $1, dwFlags) != 0 else {
+            throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path, destPath])
+          }
         }
     }
 
@@ -494,12 +491,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])
-                }
-            }
+        try FileManager.default._fileSystemRepresentation(withPath: srcPath, andPath: dstPath) {
+          if !MoveFileExW($0, $1, DWORD(MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH)) {
+            throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [srcPath, dstPath])
+          }
         }
     }
 
@@ -512,12 +507,10 @@ 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])
-                            }
-                        }
+                    try FileManager.default._fileSystemRepresentation(withPath: srcPath, andPath: dstPath) {
+                      if !CreateHardLinkW($1, $0, nil) {
+                        throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [srcPath, dstPath])
+                      }
                     }
                 case .typeSymbolicLink:
                     try _copySymlink(atPath: srcPath, toPath: dstPath)
@@ -637,12 +630,14 @@ extension FileManager {
         var szDirectory: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(dwLength + 1))
 
         GetCurrentDirectoryW(dwLength, &szDirectory)
-        return String(decodingCString: &szDirectory, as: UTF16.self)
+        return String(decodingCString: &szDirectory, as: UTF16.self).standardizingPath
     }
 
     @discardableResult
     internal func _changeCurrentDirectoryPath(_ path: String) -> Bool {
-        return path.withCString(encodedAs: UTF16.self) { SetCurrentDirectoryW($0) }
+        return try! FileManager.default._fileSystemRepresentation(withPath: path) {
+          SetCurrentDirectoryW($0)
+        }
     }
 
     internal func _fileExists(atPath path: String, isDirectory: UnsafeMutablePointer<ObjCBool>?) -> Bool {
@@ -701,8 +696,8 @@ extension FileManager {
         return true
     }
 
-    internal func _lstatFile(atPath path: String, withFileSystemRepresentation fsRep: UnsafePointer<Int8>? = nil) throws -> stat {
-        let _fsRep: UnsafePointer<Int8>
+    internal func _lstatFile(atPath path: String, withFileSystemRepresentation fsRep: UnsafePointer<NativeFSRCharType>? = nil) throws -> stat {
+        let _fsRep: UnsafePointer<NativeFSRCharType>
         if fsRep == nil {
             _fsRep = try __fileSystemRepresentation(withPath: path)
         } else {
@@ -714,20 +709,20 @@ extension FileManager {
         }
 
         var statInfo = stat()
-        let h = path.withCString(encodedAs: UTF16.self) {
-            CreateFileW(/*lpFileName=*/$0,
-                        /*dwDesiredAccess=*/DWORD(0),
-                        /*dwShareMode=*/DWORD(FILE_SHARE_READ),
-                        /*lpSecurityAttributes=*/nil,
-                        /*dwCreationDisposition=*/DWORD(OPEN_EXISTING),
-                        /*dwFlagsAndAttributes=*/DWORD(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS),
+        let handle =
+            CreateFileW(_fsRep, /*dwDesiredAccess=*/DWORD(0),
+                        DWORD(FILE_SHARE_READ), /*lpSecurityAttributes=*/nil,
+                        DWORD(OPEN_EXISTING),
+                        DWORD(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS),
                         /*hTemplateFile=*/nil)
-        }
-        if h == INVALID_HANDLE_VALUE {
+        if handle == INVALID_HANDLE_VALUE {
             throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
         }
+        defer { CloseHandle(handle) }
+
         var info: BY_HANDLE_FILE_INFORMATION = BY_HANDLE_FILE_INFORMATION()
-        GetFileInformationByHandle(h, &info)
+        GetFileInformationByHandle(handle, &info)
+
         // Group id is always 0 on Windows
         statInfo.st_gid = 0
         statInfo.st_atime = info.ftLastAccessTime.time_t
@@ -751,13 +746,12 @@ extension FileManager {
 
         statInfo.st_mtime = info.ftLastWriteTime.time_t
         statInfo.st_nlink = Int16(info.nNumberOfLinks)
-        if info.nFileSizeHigh != 0 {
+        guard info.nFileSizeHigh == 0 else {
             throw _NSErrorWithErrno(EOVERFLOW, reading: true, path: path)
         }
         statInfo.st_size = Int32(info.nFileSizeLow)
         // Uid is always 0 on Windows systems
         statInfo.st_uid = 0
-        CloseHandle(h)
         return statInfo
     }
 
@@ -858,7 +852,7 @@ extension FileManager {
     }
 
     internal func _updateTimes(atPath path: String,
-                               withFileSystemRepresentation fsr: UnsafePointer<Int8>,
+                               withFileSystemRepresentation fsr: UnsafePointer<NativeFSRCharType>,
                                creationTime: Date? = nil,
                                accessTime: Date? = nil,
                                modificationTime: Date? = nil) throws {
@@ -869,10 +863,9 @@ extension FileManager {
       var mtime: FILETIME =
           FILETIME(from: time_t((modificationTime ?? stat.lastModificationDate).timeIntervalSince1970))
 
-      let hFile: HANDLE = String(utf8String: fsr)!.withCString(encodedAs: UTF16.self) {
-        CreateFileW($0, DWORD(GENERIC_WRITE), DWORD(FILE_SHARE_WRITE),
+      let hFile: HANDLE =
+        CreateFileW(fsr, DWORD(GENERIC_WRITE), DWORD(FILE_SHARE_WRITE),
                     nil, DWORD(OPEN_EXISTING), 0, nil)
-      }
       if hFile == INVALID_HANDLE_VALUE {
           throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
       }
@@ -927,10 +920,10 @@ extension FileManager {
             if isDir && (level == 0 || !_options.contains(.skipsSubdirectoryDescendants)) {
                 var ffd = WIN32_FIND_DATAW()
                 let dirPath = joinPath(prefix: _lastReturned.path, suffix: "*")
-                let handle = dirPath.withCString(encodedAs: UTF16.self) {
+                let handle = try? FileManager.default._fileSystemRepresentation(withPath: dirPath) {
                   FindFirstFileW($0, &ffd)
                 }
-                guard handle != INVALID_HANDLE_VALUE else { return firstValidItem() }
+                if handle == INVALID_HANDLE_VALUE { return firstValidItem() }
                 defer { FindClose(handle) }
 
                 repeat {

Foundation/FileManager.swift

@@ -20,6 +20,14 @@ import CoreFoundation
 import MSVCRT
 #endif
 
+#if os(Windows)
+internal typealias NativeFSRCharType = WCHAR
+internal let NativeFSREncoding = String.Encoding.utf16LittleEndian.rawValue
+#else
+internal typealias NativeFSRCharType = CChar
+internal let NativeFSREncoding = String.Encoding.utf8.rawValue
+#endif
+
 open class FileManager : NSObject {
 
     /* Returns the default singleton instance.
@@ -352,7 +360,7 @@ open class FileManager : NSObject {
             attributes.formIntersection(FileAttributeKey.allPublicKeys)
         }
 
-        try _fileSystemRepresentation(withPath: path, { fsRep in
+        try _fileSystemRepresentation(withPath: path) { fsRep in
             var flagsToSet: UInt32 = 0
             var flagsToUnset: UInt32 = 0
 
@@ -383,7 +391,12 @@ open class FileManager : NSObject {
                     #elseif os(Linux) || os(Android) || os(Windows)
                         let modeT = number.uint32Value
                     #endif
-                    guard chmod(fsRep, mode_t(modeT)) == 0 else {
+#if os(Windows)
+                    let result = _wchmod(fsRep, mode_t(modeT))
+#else
+                    let result = chmod(fsRep, mode_t(modeT))
+#endif
+                    guard result == 0 else {
                         throw _NSErrorWithErrno(errno, reading: false, path: path)
                     }
 
@@ -423,8 +436,8 @@ 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 {
-                        fatalError("Couldn't set \(path) to be hidden")
+                    guard SetFileAttributesW(fsRep, hiddenAttrs) else {
+                      throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
                     }
 #else
                     prepareToSetOrUnsetFlag(UF_HIDDEN)
@@ -465,7 +478,7 @@ open class FileManager : NSObject {
               // Set dates as the very last step, to avoid other operations overwriting these values:
               try _updateTimes(atPath: path, withFileSystemRepresentation: fsRep, accessTime: newAccessDate, modificationTime: newModificationDate)
             }
-        })
+        }
     }
 
     /* createDirectoryAtPath:withIntermediateDirectories:attributes:error: creates a directory at the specified path. If you pass 'NO' for createIntermediates, the directory must not exist at the time this call is made. Passing 'YES' for 'createIntermediates' will create any necessary intermediate directories. This method returns YES if all directories specified in 'path' were created and attributes were set. Directories are created with attributes specified by the dictionary passed to 'attributes'. If no dictionary is supplied, directories are created according to the umask of the process. This method returns NO if a failure occurs at any stage of the operation. If an error parameter was provided, a presentable NSError will be returned by reference.
@@ -1021,15 +1034,29 @@ open class FileManager : NSObject {
      */
     open func fileSystemRepresentation(withPath path: String) -> UnsafePointer<Int8> {
         precondition(path != "", "Empty path argument")
+#if os(Windows)
+        // On Windows, the internal _fileSystemRepresentation returns UTF16
+        // encoded data, so we need to re-encode the result as UTF-8 before
+        // returning.
+        return try! _fileSystemRepresentation(withPath: path) {
+            String(decodingCString: $0, as: UTF16.self).withCString() {
+                let size = strnlen($0, Int(MAX_PATH))
+                let buffer = UnsafeMutablePointer<Int8>.allocate(capacity: size + 1)
+                buffer.initialize(from: $0, count: size + 1)
+                return UnsafePointer(buffer)
+            }
+        }
+#else
         return try! __fileSystemRepresentation(withPath: path)
+#endif
     }
 
-    internal func __fileSystemRepresentation(withPath path: String) throws -> UnsafePointer<Int8> {
+    internal func __fileSystemRepresentation(withPath path: String) throws -> UnsafePointer<NativeFSRCharType> {
         let len = CFStringGetMaximumSizeOfFileSystemRepresentation(path._cfObject)
         if len != kCFNotFound {
-            let buf = UnsafeMutablePointer<Int8>.allocate(capacity: len)
+            let buf = UnsafeMutablePointer<NativeFSRCharType>.allocate(capacity: len)
             buf.initialize(repeating: 0, count: len)
-            if path._nsObject.getFileSystemRepresentation(buf, maxLength: len) {
+            if path._nsObject._getFileSystemRepresentation(buf, maxLength: len) {
                 return UnsafePointer(buf)
             }
             buf.deinitialize(count: len)
@@ -1038,13 +1065,13 @@ open class FileManager : NSObject {
         throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileReadInvalidFileName.rawValue, userInfo: [NSFilePathErrorKey: path])
     }
 
-    internal func _fileSystemRepresentation<ResultType>(withPath path: String, _ body: (UnsafePointer<Int8>) throws -> ResultType) throws -> ResultType {
+    internal func _fileSystemRepresentation<ResultType>(withPath path: String, _ body: (UnsafePointer<NativeFSRCharType>) throws -> ResultType) throws -> ResultType {
         let fsRep = try __fileSystemRepresentation(withPath: path)
         defer { fsRep.deallocate() }
         return try body(fsRep)
     }
 
-    internal func _fileSystemRepresentation<ResultType>(withPath path1: String, andPath path2: String, _ body: (UnsafePointer<Int8>, UnsafePointer<Int8>) throws -> ResultType) throws -> ResultType {
+    internal func _fileSystemRepresentation<ResultType>(withPath path1: String, andPath path2: String, _ body: (UnsafePointer<NativeFSRCharType>, UnsafePointer<NativeFSRCharType>) throws -> ResultType) throws -> ResultType {
         let fsRep1 = try __fileSystemRepresentation(withPath: path1)
         defer { fsRep1.deallocate() }
         let fsRep2 = try __fileSystemRepresentation(withPath: path2)
@@ -1058,7 +1085,7 @@ open class FileManager : NSObject {
     open func string(withFileSystemRepresentation str: UnsafePointer<Int8>, length len: Int) -> String {
         return NSString(bytes: str, length: len, encoding: String.Encoding.utf8.rawValue)!._swiftObject
     }
-    
+
     /* -replaceItemAtURL:withItemAtURL:backupItemName:options:resultingItemURL:error: is for developers who wish to perform a safe-save without using the full NSDocument machinery that is available in the AppKit.
 
         The `originalItemURL` is the item being replaced.