Fix some cases where AbsolutePath::relative(to: AbsolutePath) would assert

- there where a couple case where relative(to:) would assert on windows
  when a path was long (>206) and when tailing slashes where not removed
  in some cases.

Author: daveinglis

Sources/TSCBasic/FileSystem.swift

@@ -533,7 +533,7 @@ private struct LocalFileSystem: FileSystem {
         let fsr: UnsafePointer<Int8> = cwdStr.fileSystemRepresentation
         defer { fsr.deallocate() }
 
-        return try? AbsolutePath(String(cString: fsr))
+        return try? AbsolutePath(validating: String(cString: fsr))
 #endif
     }
 

Sources/TSCBasic/Path.swift

@@ -88,7 +88,7 @@ public struct AbsolutePath: Hashable, Sendable {
             }
             defer { LocalFree(pwszResult) }
 
-            self.init(String(decodingCString: pwszResult, as: UTF16.self))
+            try self.init(validating: String(decodingCString: pwszResult, as: UTF16.self))
 #else
             try self.init(basePath, RelativePath(validating: str))
 #endif
@@ -515,12 +515,27 @@ private struct WindowsPath: Path, Sendable {
     }
 
     init(string: String) {
-        if string.first?.isASCII ?? false, string.first?.isLetter ?? false, string.first?.isLowercase ?? false,
+        let path: String
+        let hasDrive: Bool
+        if string.first?.isASCII ?? false, string.first?.isLetter ?? false,
            string.count > 1, string[string.index(string.startIndex, offsetBy: 1)] == ":"
         {
-            self.string = "\(string.first!.uppercased())\(string.dropFirst(1))"
+            hasDrive = true
+            path = "\(string.first!.uppercased())\(string.dropFirst(1))"
         } else {
-            self.string = string
+            hasDrive = false
+            path = string
+        }
+        // There seems to be many assumptions around paths and trailing '\'
+        var substring = path[path.startIndex..<path.endIndex]
+        while substring.count > 1 && substring.utf8.last == UInt8(ascii: "\\") {
+            substring = substring.dropLast()
+        }
+        // Don't use stripped substring is we only have <drive>: left
+        if hasDrive && substring.count == 2 {
+            self.string = Self.repr(path)
+        } else {
+            self.string = Self.repr(String(substring))
         }
     }
 
@@ -544,7 +559,7 @@ private struct WindowsPath: Path, Sendable {
             self.init(string: ".")
         } else {
             let realpath: String = Self.repr(path)
-            // Treat a relative path as an invalid relative path...
+            // Treat an absolute path as an invalid relative path
             if Self.isAbsolutePath(realpath) || realpath.first == "\\" {
                 throw PathValidationError.invalidRelativePath(path)
             }
@@ -568,6 +583,7 @@ private struct WindowsPath: Path, Sendable {
         _ = string.withCString(encodedAs: UTF16.self) { root in
             name.withCString(encodedAs: UTF16.self) { path in
                 PathAllocCombine(root, path, ULONG(PATHCCH_ALLOW_LONG_PATHS.rawValue), &result)
+                _ = PathCchStripPrefix(result, wcslen(result))      
             }
         }
         defer { LocalFree(result) }
@@ -579,6 +595,7 @@ private struct WindowsPath: Path, Sendable {
         _ = string.withCString(encodedAs: UTF16.self) { root in
             relativePath.string.withCString(encodedAs: UTF16.self) { path in
                 PathAllocCombine(root, path, ULONG(PATHCCH_ALLOW_LONG_PATHS.rawValue), &result)
+                _ = PathCchStripPrefix(result, wcslen(result))      
             }
         }
         defer { LocalFree(result) }
@@ -965,8 +982,7 @@ extension AbsolutePath {
                 preconditionFailure("invalid relative path computed from \(pathString)")
             }
         }
-
-        assert(AbsolutePath(base, result) == self)
+        assert(AbsolutePath(base, result) == self, "\(AbsolutePath(base, result)) != \(self)")
         return result
     }
 

Sources/TSCBasic/PathShims.swift

@@ -44,7 +44,7 @@ public func resolveSymlinks(_ path: AbsolutePath) throws -> AbsolutePath {
         } else {
             pathBaseAddress = UnsafePointer($0.baseAddress!)
         }
-        return try AbsolutePath(String(decodingCString: pathBaseAddress, as: UTF16.self))
+        return try AbsolutePath(validating: String(decodingCString: pathBaseAddress, as: UTF16.self))
     }
 #else
     let pathStr = path.pathString

Sources/TSCUtility/FSWatch.swift

@@ -250,8 +250,9 @@ public final class RDCWatcher {
                     }
 
                     if !GetOverlappedResult(watch.hDirectory, &watch.overlapped, &dwBytesReturned, false) {
+                        guard let path = try? AbsolutePath(validating: watch.path) else { continue }
                         queue.async {
-                            delegate?.pathsDidReceiveEvent([AbsolutePath(watch.path)])
+                            delegate?.pathsDidReceiveEvent([path])
                         }
                         return
                     }
@@ -272,7 +273,8 @@ public final class RDCWatcher {
                                     String(utf16CodeUnitsNoCopy: &pNotify.pointee.FileName,
                                            count: Int(pNotify.pointee.FileNameLength) / MemoryLayout<WCHAR>.stride,
                                            freeWhenDone: false)
-                            paths.append(AbsolutePath(file))
+                            guard let path = try? AbsolutePath(validating: file) else { continue }
+                            paths.append(path)
 
                             pNotify = (UnsafeMutableRawPointer(pNotify) + Int(pNotify.pointee.NextEntryOffset))
                                             .assumingMemoryBound(to: FILE_NOTIFY_INFORMATION.self)