refactor path model

motivation: deprecate TSC, move to swift-system

changes:
* create AbsolutePath and RelativePath in SwiftPM, at this point just a wrapper for the TSC version. In next PR we will start refactoring them
* remove all direct imports of TSBasic and replace them with data type specific imports to help migration
* reduce sue of TSCTestSupport, stop exporting it from SPMTestSupport
* update all call sites and tests

Examples/package-info/Sources/package-info/example.swift

@@ -1,5 +1,4 @@
 import Basics
-import TSCBasic
 import Workspace
 
 @main

Sources/Basics/Archiver/Archiver.swift

@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 import _Concurrency
-import TSCBasic
 
 /// The `Archiver` protocol abstracts away the different operations surrounding archives.
 public protocol Archiver {

Sources/Basics/Archiver/TarArchiver.swift

@@ -12,8 +12,6 @@
 
 import class Dispatch.DispatchQueue
 import struct Dispatch.DispatchTime
-import struct TSCBasic.AbsolutePath
-import protocol TSCBasic.FileSystem
 import struct TSCBasic.FileSystemError
 import class TSCBasic.Process
 
@@ -53,11 +51,11 @@ public struct TarArchiver: Archiver {
     ) {
         do {
             guard self.fileSystem.exists(archivePath) else {
-                throw FileSystemError(.noEntry, archivePath)
+                throw FileSystemError(.noEntry, archivePath.underlying)
             }
 
             guard self.fileSystem.isDirectory(destinationPath) else {
-                throw FileSystemError(.notDirectory, destinationPath)
+                throw FileSystemError(.notDirectory, destinationPath.underlying)
             }
 
             let process = TSCBasic.Process(
@@ -90,12 +88,12 @@ public struct TarArchiver: Archiver {
     ) {
         do {
             guard self.fileSystem.isDirectory(directory) else {
-                throw FileSystemError(.notDirectory, directory)
+                throw FileSystemError(.notDirectory, directory.underlying)
             }
 
             let process = TSCBasic.Process(
                 arguments: [self.tarCommand, "acf", destinationPath.pathString, directory.basename],
-                workingDirectory: directory.parentDirectory
+                workingDirectory: directory.parentDirectory.underlying
             )
 
             guard let registrationKey = self.cancellator.register(process) else {
@@ -120,7 +118,7 @@ public struct TarArchiver: Archiver {
     public func validate(path: AbsolutePath, completion: @escaping (Result<Bool, Error>) -> Void) {
         do {
             guard self.fileSystem.exists(path) else {
-                throw FileSystemError(.noEntry, path)
+                throw FileSystemError(.noEntry, path.underlying)
             }
 
             let process = TSCBasic.Process(arguments: [self.tarCommand, "tf", path.pathString])

Sources/Basics/Archiver/UniversalArchiver.swift

@@ -10,9 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import struct TSCBasic.AbsolutePath
-import protocol TSCBasic.FileSystem
-
 /// An `Archiver` that handles multiple formats by delegating to other existing archivers each dedicated to its own
 /// format.
 public struct UniversalArchiver: Archiver {

Sources/Basics/Archiver/ZipArchiver.swift

@@ -10,8 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-import TSCBasic
 import Dispatch
+import struct TSCBasic.FileSystemError
+import class TSCBasic.Process
 
 /// An `Archiver` that handles ZIP archives using the command-line `zip` and `unzip` tools.
 public struct ZipArchiver: Archiver, Cancellable {
@@ -40,18 +41,20 @@ public struct ZipArchiver: Archiver, Cancellable {
     ) {
         do {
             guard self.fileSystem.exists(archivePath) else {
-                throw FileSystemError(.noEntry, archivePath)
+                throw FileSystemError(.noEntry, archivePath.underlying)
             }
 
             guard self.fileSystem.isDirectory(destinationPath) else {
-                throw FileSystemError(.notDirectory, destinationPath)
+                throw FileSystemError(.notDirectory, destinationPath.underlying)
             }
 
-#if os(Windows)
-            let process = TSCBasic.Process(arguments: ["tar.exe", "xf", archivePath.pathString, "-C", destinationPath.pathString])
-#else
-            let process = TSCBasic.Process(arguments: ["unzip", archivePath.pathString, "-d", destinationPath.pathString])
-#endif
+            #if os(Windows)
+            let process = TSCBasic
+                .Process(arguments: ["tar.exe", "xf", archivePath.pathString, "-C", destinationPath.pathString])
+            #else
+            let process = TSCBasic
+                .Process(arguments: ["unzip", archivePath.pathString, "-d", destinationPath.pathString])
+            #endif
             guard let registrationKey = self.cancellator.register(process) else {
                 throw CancellationError.failedToRegisterProcess(process)
             }
@@ -78,21 +81,21 @@ public struct ZipArchiver: Archiver, Cancellable {
     ) {
         do {
             guard self.fileSystem.isDirectory(directory) else {
-                throw FileSystemError(.notDirectory, directory)
+                throw FileSystemError(.notDirectory, directory.underlying)
             }
 
-#if os(Windows)
+            #if os(Windows)
             let process = TSCBasic.Process(
                 // FIXME: are these the right arguments?
                 arguments: ["tar.exe", "-a", "-c", "-f", destinationPath.pathString, directory.basename],
-                workingDirectory: directory.parentDirectory
+                workingDirectory: directory.parentDirectory.underlying
             )
-#else
+            #else
             let process = TSCBasic.Process(
                 arguments: ["zip", "-r", destinationPath.pathString, directory.basename],
-                workingDirectory: directory.parentDirectory
+                workingDirectory: directory.parentDirectory.underlying
             )
-#endif
+            #endif
 
             guard let registrationKey = self.cancellator.register(process) else {
                 throw CancellationError.failedToRegisterProcess(process)
@@ -116,14 +119,14 @@ public struct ZipArchiver: Archiver, Cancellable {
     public func validate(path: AbsolutePath, completion: @escaping (Result<Bool, Error>) -> Void) {
         do {
             guard self.fileSystem.exists(path) else {
-                throw FileSystemError(.noEntry, path)
+                throw FileSystemError(.noEntry, path.underlying)
             }
 
-#if os(Windows)
+            #if os(Windows)
             let process = TSCBasic.Process(arguments: ["tar.exe", "tf", path.pathString])
-#else
+            #else
             let process = TSCBasic.Process(arguments: ["unzip", "-t", path.pathString])
-#endif
+            #endif
             guard let registrationKey = self.cancellator.register(process) else {
                 throw CancellationError.failedToRegisterProcess(process)
             }

Sources/Basics/AuthorizationProvider.swift

@@ -16,8 +16,6 @@ import struct Foundation.URL
 import Security
 #endif
 
-import TSCBasic
-
 public protocol AuthorizationProvider {
     @Sendable
     func authentication(for url: URL) -> (user: String, password: String)?

Sources/Basics/ByteString+Extensions.swift

@@ -10,7 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-import TSCBasic
+import struct TSCBasic.ByteString
+import struct TSCBasic.SHA256
 
 extension ByteString {
     /// A lowercase, hexadecimal representation of the SHA256 hash
@@ -20,6 +21,6 @@ extension ByteString {
     /// Secure Hashing Algorithm 2 (SHA-2) hashing with a 256-bit digest, when available,
     /// falling back on a native implementation in Swift provided by TSCBasic.
     public var sha256Checksum: String {
-        return SHA256().hash(self).hexadecimalRepresentation
+        SHA256().hash(self).hexadecimalRepresentation
     }
 }

Sources/Basics/CMakeLists.txt

@@ -25,9 +25,11 @@ add_library(Basics
   DispatchTimeInterval+Extensions.swift
   EnvironmentVariables.swift
   Errors.swift
+  FileSystem/AbsolutePath.swift
   FileSystem/FileSystem+Extensions.swift
-  FileSystem/Path+Extensions.swift
+  FileSystem/RelativePath.swift
   FileSystem/TemporaryFile.swift
+  FileSystem/TSCAdapters.swift
   FileSystem/VFSOverlay.swift
   HTTPClient/HTTPClient.swift
   HTTPClient/HTTPClientConfiguration.swift
@@ -51,7 +53,7 @@ add_library(Basics
   String+Extensions.swift
   SwiftVersion.swift
   SQLiteBackedCache.swift
-  Triple.swift
+  Triple.swift  
   Version+Extensions.swift
   WritableByteStream+Extensions.swift)
 target_link_libraries(Basics PUBLIC

Sources/Basics/Cancellator.swift

@@ -12,8 +12,8 @@
 
 import Dispatch
 import Foundation
-import TSCBasic
-
+import class TSCBasic.Process
+import class TSCBasic.Thread
 #if canImport(WinSDK)
 import WinSDK
 #endif

Sources/Basics/Concurrency/SendableBox.swift

@@ -12,7 +12,7 @@
 
 import struct Foundation.Date
 
-/// A `Sendable` storage that allows access from concurrently running tasks in 
+/// A `Sendable` storage that allows access from concurrently running tasks in
 /// an `async` closure. This type serves as a replacement for `ThreadSafeBox`
 /// implemented with Swift Concurrency primitives.
 public actor SendableBox<Value: Sendable> {

Sources/Basics/Concurrency/ThreadSafeBox.swift

@@ -111,9 +111,9 @@ extension ThreadSafeBox where Value == String {
     public func append(_ value: String) {
         self.mutate { existingValue in
             if let existingValue {
-              return existingValue + value
+                return existingValue + value
             } else {
-              return value
+                return value
             }
         }
     }

Sources/Basics/Dictionary+Extensions.swift

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import TSCBasic
+import OrderedCollections
 
 extension Dictionary {
     @inlinable
@@ -37,12 +37,14 @@ extension Dictionary {
     }
 }
 
-extension OrderedDictionary {
-    public subscript(key: Key, `default` `default`: Value) -> Value {
-        set {
-            self[key] = newValue
-        } get {
-            self[key] ?? `default`
-        }
-    }
-}
+/*
+ extension OrderedDictionary {
+     public subscript(key: Key, `default` `default`: Value) -> Value {
+         set {
+             self[key] = newValue
+         } get {
+             self[key] ?? `default`
+         }
+     }
+ }
+ */

Sources/Basics/DispatchTimeInterval+Extensions.swift

@@ -79,17 +79,17 @@ extension DispatchTimeInterval {
         case .seconds(let value):
             return "\(value)s"
         case .milliseconds(let value):
-            return String(format: "%.2f", Double(value)/Double(1000)) + "s"
+            return String(format: "%.2f", Double(value) / Double(1000)) + "s"
         case .microseconds(let value):
-            return String(format: "%.2f", Double(value)/Double(1_000_000)) + "s"
+            return String(format: "%.2f", Double(value) / Double(1_000_000)) + "s"
         case .nanoseconds(let value):
-            return String(format: "%.2f", Double(value)/Double(1_000_000_000)) + "s"
+            return String(format: "%.2f", Double(value) / Double(1_000_000_000)) + "s"
         case .never:
             return "n/a"
-#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+        #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
         @unknown default:
             return "n/a"
-#endif
+        #endif
         }
     }
 }
@@ -100,9 +100,8 @@ extension DispatchTime {
     public func distance(to: DispatchTime) -> DispatchTimeInterval {
         let final = to.uptimeNanoseconds
         let point = self.uptimeNanoseconds
-        let duration: Int64 = Int64(bitPattern: final.subtractingReportingOverflow(point).partialValue)
+        let duration = Int64(bitPattern: final.subtractingReportingOverflow(point).partialValue)
         return .nanoseconds(duration >= Int.max ? Int.max : Int(duration))
     }
 }
 #endif
-

Sources/Basics/EnvironmentVariables.swift

@@ -10,19 +10,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-import TSCBasic
 import Foundation
 
 public typealias EnvironmentVariables = [String: String]
 
 extension EnvironmentVariables {
-
     public static func empty() -> EnvironmentVariables {
-        return [:]
+        [:]
     }
 
     public static func process() -> EnvironmentVariables {
-        return ProcessInfo.processInfo.environment
+        ProcessInfo.processInfo.environment
     }
 
     public mutating func prependPath(_ key: String, value: String) {
@@ -52,11 +50,11 @@ extension EnvironmentVariables {
 
     /// `PATH` variable in the process's environment (`Path` under Windows).
     public var path: String? {
-#if os(Windows)
+        #if os(Windows)
         let pathArg = "Path"
-#else
+        #else
         let pathArg = "PATH"
-#endif
+        #endif
         return self[pathArg]
     }
 }