Make stripRawPathPrefix and removeTrailingBackslash use temporary buffer.

- Move stripRawPathPrefix and removeTrailingBackslash to use a
mutable temporary buffer to call PathCchStripPrefix and PathCchRemoveBackslash
    - Could not use buffer.withMemoryRebound and getCstring() as
      on Windows this seem to produce corrupt data.
- Add more tests for unParsed '\\?\' and device '\\.\' paths
- Remove the PATHCCH_CANONICALIZE_SLASHES flag as it is not
  needed.

Author: kcieplak

Sources/TSCBasic/Path.swift

@@ -458,36 +458,6 @@ private struct WindowsPath: Path, Sendable {
         return !path.withCString(encodedAs: UTF16.self, PathIsRelativeW)
     }
 
-    /// When this function returns successfully, the same path string will have had the prefix removed,
-    /// if the prefix was present. If no prefix was present, the string will be unchanged.
-    static func stripPrefix(_ path: String) -> String {
-        return path.withCString(encodedAs: UTF16.self) { cStringPtr in
-            let mutableCStringPtr = UnsafeMutablePointer(mutating: cStringPtr)
-            let result = PathCchStripPrefix(mutableCStringPtr, path.utf16.count + 1)
-            if result == S_OK {
-                return String(decodingCString: mutableCStringPtr, as: UTF16.self)
-            }
-            return path
-        }
-    }
-
-    /// Remove a trailing backslash from a path if the following conditions
-    /// are true:
-    ///   * Path is not a root path
-    ///   * Pash has a trailing backslash
-    /// If conditions are not met then the string is returned unchanged.
-    static func removeTrailingBackslash(_ path: String) -> String {
-        return path.withCString(encodedAs: UTF16.self) { cStringPtr in
-            let mutableCStringPtr = UnsafeMutablePointer(mutating: cStringPtr)
-            let result = PathCchRemoveBackslash(mutableCStringPtr, path.utf16.count + 1)
-
-            if result == S_OK {
-                return String(decodingCString: mutableCStringPtr, as: UTF16.self)
-            }
-            return path
-        }
-    }
-
     /// Create a canonicalized path representation for Windows.
     /// Returns a potentially `\\?\`-prefixed version of the path,
     /// to ensure long paths greater than MAX_PATH (260) characters are handled correctly.
@@ -517,7 +487,7 @@ private struct WindowsPath: Path, Sendable {
                 // 2. Canonicalize the path.
                 // This will add the \\?\ prefix if needed based on the path's length.
                 var pwszCanonicalPath: LPWSTR?
-                let flags: ULONG = numericCast(PATHCCH_ALLOW_LONG_PATHS.rawValue) | numericCast(PATHCCH_CANONICALIZE_SLASHES.rawValue)
+                let flags: ULONG = numericCast(PATHCCH_ALLOW_LONG_PATHS.rawValue)
                 let result = PathAllocCanonicalize(pwszFullPath.baseAddress, flags, &pwszCanonicalPath)
                 if let pwszCanonicalPath {
                     defer { LocalFree(pwszCanonicalPath) }
@@ -581,15 +551,20 @@ private struct WindowsPath: Path, Sendable {
         let normalized: UnsafePointer<Int8> = string.fileSystemRepresentation
         defer { normalized.deallocate() }
         // Remove prefix from the components, allowing for comparison across normalized paths.
-        return Self.stripPrefix(String(cString: normalized)).components(separatedBy: #"\"#).filter { !$0.isEmpty }
+        var prefixStrippedPath = PathCchStripPrefix(String(cString: normalized))
+        // The '\\.\'' prefix is not removed by PathCchStripPrefix do this manually.
+        if prefixStrippedPath.starts(with: #"\\.\"#) {
+            prefixStrippedPath = String(prefixStrippedPath.dropFirst(4))
+        }
+        return prefixStrippedPath.components(separatedBy: #"\"#).filter { !$0.isEmpty }
     }
 
     var parentDirectory: Self {
         return self == .root ? self : Self(string: dirname)
     }
 
     init(string: String) {
-        let noPrefixPath = Self.stripPrefix(string)
+        let noPrefixPath = PathCchStripPrefix(string)
         let prefix = string.replacingOccurrences(of: noPrefixPath, with: "") // Just the prefix or empty
 
         // Perform drive designator normalization i.e. 'c:\' to 'C:\' on string.
@@ -616,7 +591,7 @@ private struct WindowsPath: Path, Sendable {
         }
         do {
             let canonicalizedPath = try Self.canonicalPathRepresentation(realpath)
-            let normalizedPath = Self.removeTrailingBackslash(canonicalizedPath) // AbsolutePath states paths have no trailing separator.
+            let normalizedPath = PathCchRemoveBackslash(canonicalizedPath) // AbsolutePath states paths have no trailing separator.
             self.init(string: normalizedPath)
         } catch {
             throw PathValidationError.invalidAbsolutePath("\(path): \(error)")
@@ -703,6 +678,40 @@ fileprivate func WIN32_FROM_HRESULT(_ hr: HRESULT) -> DWORD {
     return DWORD(hr)
 }
 
+/// Removes the "\\?\" prefix, if present, from a file path. When this function returns successfully,
+/// the same path string will have the prefix removed,if the prefix was present.
+/// If no prefix was present,the string will be unchanged.
+func PathCchStripPrefix(_ path: String) -> String {
+    return path.withCString(encodedAs: UTF16.self) { cStringPtr in
+        withUnsafeTemporaryAllocation(of: WCHAR.self, capacity: path.utf16.count + 1) { buffer in
+            buffer.initialize(from: UnsafeBufferPointer(start: cStringPtr, count: path.utf16.count + 1))
+            let result = PathCchStripPrefix(buffer.baseAddress!, buffer.count)
+            if result == S_OK {
+                return String(decodingCString: buffer.baseAddress!, as: UTF16.self)
+            }
+            return path
+        }
+    }
+}
+
+/// Remove a trailing backslash from a path if the following conditions
+/// are true:
+///   * Path is not a root path
+///   * Pash has a trailing backslash
+/// If conditions are not met then the string is returned unchanged.
+func PathCchRemoveBackslash(_ path: String) -> String {
+    return path.withCString(encodedAs: UTF16.self) { cStringPtr in
+        return withUnsafeTemporaryAllocation(of: WCHAR.self, capacity: path.utf16.count + 1) { buffer in
+            buffer.initialize(from: UnsafeBufferPointer(start: cStringPtr, count: path.utf16.count + 1))
+            let result = PathCchRemoveBackslash(buffer.baseAddress!, path.utf16.count + 1)
+            if result == S_OK {
+                return String(decodingCString: buffer.baseAddress!, as: UTF16.self)
+            }
+            return path
+        }
+        return path
+    }
+}
 #else
 private struct UNIXPath: Path, Sendable {
     let string: String