Fix a corner case where createDirectory would fail on windows

The //?/ prefix needs to be added to directories if the length is
> MAX_PATH - 12, however the PATHCCH_ALLOW_LONG_PATHS to
PathAllocCanonicalize would only do that if the path was > MAX_PATH.
This change uses PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH, which forces
it on all the time.  Just needed to remove the prefix in a few places
as it was making it way out into tests as this is suppose to be
transparent to the user.

Author: daveinglis

Sources/FoundationEssentials/FileManager/FileManager+Directories.swift

@@ -497,9 +497,14 @@ extension _FileManagerImpl {
         // This is solely to minimize the number of allocations and number of bytes allocated versus starting with a hardcoded value like MAX_PATH.
         // We should NOT early-return if this returns 0, in order to avoid TOCTOU issues.
         let dwSize = GetCurrentDirectoryW(0, nil)
-        return try? FillNullTerminatedWideStringBuffer(initialSize: dwSize >= 0 ? dwSize : DWORD(MAX_PATH), maxSize: DWORD(Int16.max)) {
+        let cwd = try? FillNullTerminatedWideStringBuffer(initialSize: dwSize >= 0 ? dwSize : DWORD(MAX_PATH), maxSize: DWORD(Int16.max)) {
             GetCurrentDirectoryW(DWORD($0.count), $0.baseAddress)
         }
+        
+        // Handle Windows NT object namespace prefix
+        // The \\??\ prefix is used by Windows NT for device paths and may appear
+        // in current working directory paths. We strip it to return a standard path.
+        return cwd?.removingNTObjectNamespacePrefix()
 #else
         withUnsafeTemporaryAllocation(of: CChar.self, capacity: FileManager.MAX_PATH_SIZE) { buffer in
             guard getcwd(buffer.baseAddress!, FileManager.MAX_PATH_SIZE) != nil else {

Sources/FoundationEssentials/FileManager/FileOperations.swift

@@ -139,6 +139,9 @@ extension FileManager {
     fileprivate func _shouldRemoveItemAtPath(_ path: String) -> Bool {
         var delegateResponse: Bool?
         if let delegate = self.safeDelegate {
+#if os(Windows)
+            let path = path.removingNTObjectNamespacePrefix()
+#endif
             #if FOUNDATION_FRAMEWORK
             delegateResponse = delegate.fileManager?(self, shouldRemoveItemAt: URL(fileURLWithPath: path))
 
@@ -393,7 +396,7 @@ enum _FileOperations {
                             } else {
                                 if entry.dwFileAttributes & FILE_ATTRIBUTE_READONLY == FILE_ATTRIBUTE_READONLY {
                                     guard SetFileAttributesW($0, entry.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY) else {
-                                        throw CocoaError.removeFileError(GetLastError(), ntpath)
+                                        throw CocoaError.removeFileError(GetLastError(), entry.fileName)
                                     }
                                 }
                                 if entry.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY == FILE_ATTRIBUTE_DIRECTORY {

Sources/FoundationEssentials/String/String+Internals.swift

@@ -66,7 +66,8 @@ extension String {
                 // 2. Canonicalize the path.
                 // This will add the \\?\ prefix if needed based on the path's length.
                 var pwszCanonicalPath: LPWSTR?
-                let flags: ULONG = PATHCCH_ALLOW_LONG_PATHS
+                // Alway add the long path prefix since we don't know if this is a directory.
+                let flags: ULONG =  PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH
                 let result = PathAllocCanonicalize(pwszFullPath.baseAddress, flags, &pwszCanonicalPath)
                 if let pwszCanonicalPath {
                     defer { LocalFree(pwszCanonicalPath) }
@@ -79,6 +80,32 @@ extension String {
             }
         }
     }
+    /// Removes the Windows NT object namespace prefix if present.
+    /// The \\??\ prefix is used by Windows NT for device paths and may appear
+    /// in paths returned by system APIs. This method provides a clean way to
+    /// normalize such paths to standard format.
+    ///
+    /// - Returns: A string with the NT object namespace prefix removed, or the original string if no prefix is found.
+    package func removingNTObjectNamespacePrefix() -> String {
+        // Use Windows API PathCchStripPrefix for robust prefix handling
+        return withCString(encodedAs: UTF16.self) { pwszPath in
+            // Calculate required buffer size (original path length should be sufficient)
+            let length = wcslen(pwszPath) + 1 // include null terminator
+            
+            return withUnsafeTemporaryAllocation(of: WCHAR.self, capacity: Int(length)) { buffer  in
+                // Copy the original path to the buffer
+                _ = buffer.initialize(from: UnsafeBufferPointer(start: pwszPath, count: Int(length)))
+
+                // Call PathCchStripPrefix (modifies buffer in place)
+                _ = PathCchStripPrefix(buffer.baseAddress, buffer.count)                
+
+                // Return the result regardless of success/failure
+                // PathCchStripPrefix modifies the buffer in-place and returns S_OK on success
+                // If it fails, the original path remains unchanged, which is the desired fallback
+                return String(decodingCString: buffer.baseAddress!, as: UTF16.self)
+            }
+        }
+    }
 }
 #endif
 

Sources/FoundationEssentials/String/String+Path.swift

@@ -741,15 +741,7 @@ extension String {
                 guard GetFinalPathNameByHandleW(hFile, $0.baseAddress, dwLength, VOLUME_NAME_DOS) == dwLength - 1 else {
                     return nil
                 }
-
-                let pathBaseAddress: UnsafePointer<WCHAR>
-                if Array($0.prefix(4)) == Array(#"\\?\"#.utf16) {
-                    // When using `VOLUME_NAME_DOS`, the returned path uses `\\?\`.
-                    pathBaseAddress = UnsafePointer($0.baseAddress!.advanced(by: 4))
-                } else {
-                    pathBaseAddress = UnsafePointer($0.baseAddress!)
-                }
-                return String(decodingCString: pathBaseAddress, as: UTF16.self)
+                return String(decodingCString: UnsafePointer($0.baseAddress!), as: UTF16.self).removingNTObjectNamespacePrefix()
             }
         }
         #else // os(Windows)

Sources/FoundationEssentials/WinSDK+Extensions.swift

@@ -229,6 +229,10 @@ package var PATHCCH_ALLOW_LONG_PATHS: ULONG {
     ULONG(WinSDK.PATHCCH_ALLOW_LONG_PATHS.rawValue)
 }
 
+package var PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH: ULONG {
+    ULONG(WinSDK.PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH.rawValue)
+}
+
 package var RRF_RT_REG_SZ: DWORD {
     DWORD(WinSDK.RRF_RT_REG_SZ)
 }

Tests/FoundationEssentialsTests/FileManager/FileManagerTests.swift

@@ -1133,6 +1133,12 @@ private struct FileManagerTests {
             let fileName = UUID().uuidString
             let cwd = fileManager.currentDirectoryPath
 
+            #expect(fileManager.changeCurrentDirectoryPath(cwd))
+            #expect(cwd == fileManager.currentDirectoryPath)
+
+            let nearLimitDir = cwd + "/" + String(repeating: "A", count: 255 - cwd.count)
+            #expect(throws: Never.self) { try fileManager.createDirectory(at: URL(fileURLWithPath: nearLimitDir), withIntermediateDirectories: false) }
+
             #expect(fileManager.createFile(atPath: dirName + "/" + fileName, contents: nil))
 
             let dirURL = URL(filePath: dirName, directoryHint: .checkFileSystem)

Tests/FoundationEssentialsTests/String/StringNTPathTests.swift

@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#if os(Windows)
+
+import Testing
+
+#if FOUNDATION_FRAMEWORK
+import Foundation
+#else
+import FoundationEssentials
+#endif
+
+@Suite("String NT Path Tests")
+struct StringNTPathTests {
+
+    @Test("Normal drive path, no prefix")
+    func noPrefix() {
+        let path = "C:\\Windows\\System32"
+        #expect(path.removingNTObjectNamespacePrefix() == "C:\\Windows\\System32")
+    }
+
+    @Test("Extended-length path prefix (\\\\?\\)")
+    func extendedPrefix() {
+        let path = #"\\?\C:\Windows\System32"#
+        #expect(path.removingNTObjectNamespacePrefix() == "C:\\Windows\\System32")
+    }
+
+    @Test("UNC path with extended prefix (\\\\?\\UNC\\)")
+    func uncExtendedPrefix() {
+        let path = #"\\?\UNC\Server\Share\Folder"#
+        #expect(path.removingNTObjectNamespacePrefix() == #"\\Server\Share\Folder"#)
+    }
+
+    @Test("UNC path without extended prefix")
+    func uncNormal() {
+        let path = #"\\Server\Share\Folder"#
+        #expect(path.removingNTObjectNamespacePrefix() == #"\\Server\Share\Folder"#)
+    }
+
+    @Test("Empty string should stay empty")
+    func emptyString() {
+        let path = ""
+        #expect(path.removingNTObjectNamespacePrefix() == "")
+    }
+
+    @Test("Path with only prefix should return empty")
+    func prefixOnly() {
+        let path = #"\\?\C:\"#
+        #expect(path.removingNTObjectNamespacePrefix() == #"C:\"#)
+    }
+
+    @Test("Path longer than MAX_PATH (260 chars)")
+    func longPathBeyondMaxPath() {
+        // Create a folder name repeated to exceed 260 chars
+        let longComponent = String(repeating: "A", count: 280)
+        let rawPath = #"\\?\C:\Test\"# + longComponent
+
+        // After stripping, it should drop the \\?\ prefix but keep the full long component
+        let expected = "C:\\Test\\" + longComponent
+
+        let stripped = rawPath.removingNTObjectNamespacePrefix()
+        #expect(stripped == expected)
+    }    
+}
+#endif