Improve path normalization and judgment on Windows

Sources/TSCBasic/Path.swift

@@ -12,11 +12,7 @@ import Foundation
 import WinSDK
 #endif
 
-#if os(Windows)
-private typealias PathImpl = UNIXPath
-#else
 private typealias PathImpl = UNIXPath
-#endif
 
 /// Represents an absolute file system path, independently of what (or whether
 /// anything at all) exists at that path in the file system at any given time.
@@ -453,11 +449,12 @@ private struct UNIXPath: Path {
         defer { fsr.deallocate() }
 
         let path: String = String(cString: fsr)
-        return path.withCString(encodedAs: UTF16.self) {
+        let result: String = path.withCString(encodedAs: UTF16.self) {
             let data = UnsafeMutablePointer(mutating: $0)
             PathCchRemoveFileSpec(data, path.count)
             return String(decodingCString: data, as: UTF16.self)
         }
+        return result.isEmpty ? "." : result
 #else
         // FIXME: This method seems too complicated; it should be simplified,
         //        if possible, and certainly optimized (using UTF8View).
@@ -544,11 +541,13 @@ private struct UNIXPath: Path {
 
     init(normalizingAbsolutePath path: String) {
       #if os(Windows)
-        var buffer: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(MAX_PATH + 1))
+        var result: PWSTR?
+        defer { LocalFree(result) }
+
         _ = path.withCString(encodedAs: UTF16.self) {
-            PathCanonicalizeW(&buffer, $0)
+            PathAllocCanonicalize($0, ULONG(PATHCCH_ALLOW_LONG_PATHS.rawValue), &result)
         }
-        self.init(string: String(decodingCString: buffer, as: UTF16.self))
+        self.init(string: String(decodingCString: result!, as: UTF16.self))
       #else
         precondition(path.first == "/", "Failure normalizing \(path), absolute paths should start with '/'")
 
@@ -613,14 +612,14 @@ private struct UNIXPath: Path {
     }
 
     init(normalizingRelativePath path: String) {
-      #if os(Windows)
-        var buffer: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(MAX_PATH + 1))
-        _ = path.replacingOccurrences(of: "/", with: "\\").withCString(encodedAs: UTF16.self) {
-            PathCanonicalizeW(&buffer, $0)
-        }
-        self.init(string: String(decodingCString: buffer, as: UTF16.self))
-      #else
-        precondition(path.first != "/")
+        let pathSeparator: Character
+#if os(Windows)
+        pathSeparator = "\\"
+        let path = path.replacingOccurrences(of: "/", with: "\\")
+#else
+        pathSeparator = "/"
+#endif
+        precondition(path.first != pathSeparator)
 
         // FIXME: Here we should also keep track of whether anything actually has
         // to be changed in the string, and if not, just return the existing one.
@@ -630,7 +629,7 @@ private struct UNIXPath: Path {
         // the normalized string representation.
         var parts: [String] = []
         var capacity = 0
-        for part in path.split(separator: "/") {
+        for part in path.split(separator: pathSeparator) {
             switch part.count {
             case 0:
                 // Ignore empty path components.
@@ -669,7 +668,7 @@ private struct UNIXPath: Path {
         if let first = iter.next() {
             result.append(contentsOf: first)
             while let next = iter.next() {
-                result.append("/")
+                result.append(pathSeparator)
                 result.append(contentsOf: next)
             }
         }
@@ -680,11 +679,13 @@ private struct UNIXPath: Path {
 
         // If the result is empty, return `.`, otherwise we return it as a string.
         self.init(string: result.isEmpty ? "." : result)
-      #endif
     }
 
     init(validatingAbsolutePath path: String) throws {
-      #if os(Windows)
+#if os(Windows)
+        guard path != "" else {
+            throw PathValidationError.invalidAbsolutePath(path)
+        }
         let fsr: UnsafePointer<Int8> = path.fileSystemRepresentation
         defer { fsr.deallocate() }
 
@@ -693,7 +694,7 @@ private struct UNIXPath: Path {
             throw PathValidationError.invalidAbsolutePath(path)
         }
         self.init(normalizingAbsolutePath: path)
-      #else
+#else
         switch path.first {
         case "/":
             self.init(normalizingAbsolutePath: path)
@@ -702,11 +703,15 @@ private struct UNIXPath: Path {
         default:
             throw PathValidationError.invalidAbsolutePath(path)
         }
-      #endif
+#endif
     }
 
     init(validatingRelativePath path: String) throws {
-      #if os(Windows)
+#if os(Windows)
+        guard path != "" else {
+            self.init(normalizingRelativePath: path)
+            return
+        }
         let fsr: UnsafePointer<Int8> = path.fileSystemRepresentation
         defer { fsr.deallocate() }
 
@@ -715,14 +720,14 @@ private struct UNIXPath: Path {
             throw PathValidationError.invalidRelativePath(path)
         }
         self.init(normalizingRelativePath: path)
-      #else
+#else
         switch path.first {
         case "/", "~":
             throw PathValidationError.invalidRelativePath(path)
         default:
             self.init(normalizingRelativePath: path)
         }
-      #endif
+#endif
     }
 
     func suffix(withDot: Bool) -> String? {