Reduce use of AbsolutePath with precondition failure

Since it comes up regularly as a perceived user facing crash, we should reduce our use of the plain `AbsolutePath` initializer. I actually don't think it makes sense to even provide a non-throwing initializer that takes anything but a `StaticString` and even that's debatable.

This doesn't resolve all possible uses and specifically excludes uses in tests, but does fix several user facing issues, e.g.

```
❯ export SWIFTPM_TESTS_MODULECACHE=blah
❯ swift test
zsh: illegal hardware instruction  swift test
```

Author: neonichu

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

@@ -16,7 +16,7 @@ struct Example {
 
         // We need a package to work with.
         // This computes the path of this package root based on the file location
-        let packagePath = AbsolutePath(#file).parentDirectory.parentDirectory.parentDirectory
+        let packagePath = try AbsolutePath(validating: #file).parentDirectory.parentDirectory.parentDirectory
 
         // LOADING
         // =======

Sources/Basics/FileSystem+Extensions.swift

@@ -21,11 +21,15 @@ import TSCBasic
 extension FileSystem {
     /// SwiftPM directory under user's home directory (~/.swiftpm)
     public var dotSwiftPM: AbsolutePath {
-        self.homeDirectory.appending(component: ".swiftpm")
+        get throws {
+            return try self.homeDirectory.appending(component: ".swiftpm")
+        }
     }
 
     fileprivate var idiomaticSwiftPMDirectory: AbsolutePath? {
-        return FileManager.default.urls(for: .libraryDirectory, in: .userDomainMask).first.flatMap { AbsolutePath($0.path) }?.appending(component: "org.swift.swiftpm")
+        get throws {
+            return try FileManager.default.urls(for: .libraryDirectory, in: .userDomainMask).first.flatMap { try AbsolutePath(validating: $0.path) }?.appending(component: "org.swift.swiftpm")
+        }
     }
 }
 
@@ -39,33 +43,37 @@ extension FileSystem {
 
     /// SwiftPM cache directory under user's caches directory (if exists)
     public var swiftPMCacheDirectory: AbsolutePath {
-        if let path = self.idiomaticUserCacheDirectory {
-            return path.appending(component: "org.swift.swiftpm")
-        } else {
-            return self.dotSwiftPMCachesDirectory
+        get throws {
+            if let path = self.idiomaticUserCacheDirectory {
+                return path.appending(component: "org.swift.swiftpm")
+            } else {
+                return try self.dotSwiftPMCachesDirectory
+            }
         }
     }
 
     fileprivate var dotSwiftPMCachesDirectory: AbsolutePath {
-        return self.dotSwiftPM.appending(component: "cache")
+        get throws {
+            return try self.dotSwiftPM.appending(component: "cache")
+        }
     }
 }
 
 extension FileSystem {
     public func getOrCreateSwiftPMCacheDirectory() throws -> AbsolutePath {
-        let idiomaticCacheDirectory = self.swiftPMCacheDirectory
+        let idiomaticCacheDirectory = try self.swiftPMCacheDirectory
         // Create idiomatic if necessary
         if !self.exists(idiomaticCacheDirectory) {
             try self.createDirectory(idiomaticCacheDirectory, recursive: true)
         }
         // Create ~/.swiftpm if necessary
-        if !self.exists(self.dotSwiftPM) {
+        if !self.exists(try self.dotSwiftPM) {
             try self.createDirectory(self.dotSwiftPM, recursive: true)
         }
         // Create ~/.swiftpm/cache symlink if necessary
         // locking ~/.swiftpm to protect from concurrent access
         try self.withLock(on: self.dotSwiftPM, type: .exclusive) {
-            if !self.exists(self.dotSwiftPMCachesDirectory, followSymlink: false) {
+            if !self.exists(try self.dotSwiftPMCachesDirectory, followSymlink: false) {
                 try self.createSymbolicLink(dotSwiftPMCachesDirectory, pointingAt: idiomaticCacheDirectory, relative: false)
             }
         }
@@ -78,21 +86,25 @@ extension FileSystem {
 extension FileSystem {
     /// SwiftPM config directory under user's config directory (if exists)
     public var swiftPMConfigurationDirectory: AbsolutePath {
-        if let path = self.idiomaticSwiftPMDirectory {
-            return path.appending(component: "configuration")
-        } else {
-            return self.dotSwiftPMConfigurationDirectory
+        get throws {
+            if let path = try self.idiomaticSwiftPMDirectory {
+                return path.appending(component: "configuration")
+            } else {
+                return try self.dotSwiftPMConfigurationDirectory
+            }
         }
     }
 
     fileprivate var dotSwiftPMConfigurationDirectory: AbsolutePath {
-        return self.dotSwiftPM.appending(component: "configuration")
+        get throws {
+            return try self.dotSwiftPM.appending(component: "configuration")
+        }
     }
 }
 
 extension FileSystem {
     public func getOrCreateSwiftPMConfigurationDirectory(warningHandler: @escaping (String) -> Void) throws -> AbsolutePath {
-        let idiomaticConfigurationDirectory = self.swiftPMConfigurationDirectory
+        let idiomaticConfigurationDirectory = try self.swiftPMConfigurationDirectory
 
         // temporary 5.6, remove on next version: transition from previous configuration location
         if !self.exists(idiomaticConfigurationDirectory) {
@@ -116,7 +128,7 @@ extension FileSystem {
         }
 
         // in the case where ~/.swiftpm/configuration is not the idiomatic location (eg on macOS where its /Users/<user>/Library/org.swift.swiftpm/configuration)
-        if idiomaticConfigurationDirectory != self.dotSwiftPMConfigurationDirectory {
+        if try idiomaticConfigurationDirectory != self.dotSwiftPMConfigurationDirectory {
             // copy the configuration files from old location (eg /Users/<user>/Library/org.swift.swiftpm) to new one (eg /Users/<user>/Library/org.swift.swiftpm/configuration)
             // but leave them there for backwards compatibility (eg older xcode)
             let oldConfigDirectory = idiomaticConfigurationDirectory.parentDirectory
@@ -130,7 +142,7 @@ extension FileSystem {
         } else {
             // copy the configuration files from old location (~/.swiftpm/config) to new one (~/.swiftpm/configuration)
             // but leave them there for backwards compatibility (eg older toolchain)
-            let oldConfigDirectory = self.dotSwiftPM.appending(component: "config")
+            let oldConfigDirectory = try self.dotSwiftPM.appending(component: "config")
             if self.exists(oldConfigDirectory, followSymlink: false) && self.isDirectory(oldConfigDirectory) {
                 let configurationFiles = try self.getDirectoryContents(oldConfigDirectory)
                     .map{ oldConfigDirectory.appending(component: $0) }
@@ -145,13 +157,13 @@ extension FileSystem {
             try self.createDirectory(idiomaticConfigurationDirectory, recursive: true)
         }
         // Create ~/.swiftpm if necessary
-        if !self.exists(self.dotSwiftPM) {
+        if !self.exists(try self.dotSwiftPM) {
             try self.createDirectory(self.dotSwiftPM, recursive: true)
         }
         // Create ~/.swiftpm/configuration symlink if necessary
         // locking ~/.swiftpm to protect from concurrent access
         try self.withLock(on: self.dotSwiftPM, type: .exclusive) {
-            if !self.exists(self.dotSwiftPMConfigurationDirectory, followSymlink: false) {
+            if !self.exists(try self.dotSwiftPMConfigurationDirectory, followSymlink: false) {
                 try self.createSymbolicLink(dotSwiftPMConfigurationDirectory, pointingAt: idiomaticConfigurationDirectory, relative: false)
             }
         }
@@ -165,26 +177,30 @@ extension FileSystem {
 extension FileSystem {
     /// SwiftPM security directory under user's security directory (if exists)
     public var swiftPMSecurityDirectory: AbsolutePath {
-        if let path = self.idiomaticSwiftPMDirectory {
-            return path.appending(component: "security")
-        } else {
-            return self.dotSwiftPMSecurityDirectory
+        get throws {
+            if let path = try self.idiomaticSwiftPMDirectory {
+                return path.appending(component: "security")
+            } else {
+                return try self.dotSwiftPMSecurityDirectory
+            }
         }
     }
 
     fileprivate var dotSwiftPMSecurityDirectory: AbsolutePath {
-        return self.dotSwiftPM.appending(component: "security")
+        get throws {
+            return try self.dotSwiftPM.appending(component: "security")
+        }
     }
 }
 
 extension FileSystem {
     public func getOrCreateSwiftPMSecurityDirectory() throws -> AbsolutePath {
-        let idiomaticSecurityDirectory = self.swiftPMSecurityDirectory
+        let idiomaticSecurityDirectory = try self.swiftPMSecurityDirectory
 
         // temporary 5.6, remove on next version: transition from ~/.swiftpm/security to idiomatic location + symbolic link
-        if idiomaticSecurityDirectory != self.dotSwiftPMSecurityDirectory &&
-            self.exists(self.dotSwiftPMSecurityDirectory) &&
-            self.isDirectory(self.dotSwiftPMSecurityDirectory) {
+        if try idiomaticSecurityDirectory != self.dotSwiftPMSecurityDirectory &&
+            self.exists(try self.dotSwiftPMSecurityDirectory) &&
+            self.isDirectory(try self.dotSwiftPMSecurityDirectory) {
             try self.removeFileTree(self.dotSwiftPMSecurityDirectory)
         }
         // ~temporary 5.6 migration
@@ -194,13 +210,13 @@ extension FileSystem {
             try self.createDirectory(idiomaticSecurityDirectory, recursive: true)
         }
         // Create ~/.swiftpm if necessary
-        if !self.exists(self.dotSwiftPM) {
+        if !self.exists(try self.dotSwiftPM) {
             try self.createDirectory(self.dotSwiftPM, recursive: true)
         }
         // Create ~/.swiftpm/security symlink if necessary
         // locking ~/.swiftpm to protect from concurrent access
         try self.withLock(on: self.dotSwiftPM, type: .exclusive) {
-            if !self.exists(self.dotSwiftPMSecurityDirectory, followSymlink: false) {
+            if !self.exists(try self.dotSwiftPMSecurityDirectory, followSymlink: false) {
                 try self.createSymbolicLink(dotSwiftPMSecurityDirectory, pointingAt: idiomaticSecurityDirectory, relative: false)
             }
         }

Sources/Basics/HTPClient+URLSession.swift

@@ -179,7 +179,7 @@ private class DownloadTaskManager: NSObject, URLSessionDownloadDelegate {
         }
 
         do {
-            try task.fileSystem.move(from: AbsolutePath(location.path), to: task.destination)
+            try task.fileSystem.move(from: AbsolutePath(validating: location.path), to: task.destination)
         } catch {
             task.moveFileError = error
         }

Sources/Basics/Sandbox.swift

@@ -31,9 +31,9 @@ public enum Sandbox {
         strictness: Strictness = .default,
         writableDirectories: [AbsolutePath] = [],
         readOnlyDirectories: [AbsolutePath] = []
-    ) -> [String] {
+    ) throws -> [String] {
         #if os(macOS)
-        let profile = macOSSandboxProfile(strictness: strictness, writableDirectories: writableDirectories, readOnlyDirectories: readOnlyDirectories)
+        let profile = try macOSSandboxProfile(strictness: strictness, writableDirectories: writableDirectories, readOnlyDirectories: readOnlyDirectories)
         return ["/usr/bin/sandbox-exec", "-p", profile] + command
         #else
         // rdar://40235432, rdar://75636874 tracks implementing sandboxes for other platforms.
@@ -59,7 +59,7 @@ fileprivate func macOSSandboxProfile(
     strictness: Sandbox.Strictness,
     writableDirectories: [AbsolutePath],
     readOnlyDirectories: [AbsolutePath]
-) -> String {
+) throws -> String {
     var contents = "(version 1)\n"
 
     // Deny everything by default.
@@ -94,7 +94,7 @@ fileprivate func macOSSandboxProfile(
     else if strictness == .writableTemporaryDirectory {
         // Add `subpath` expressions for the regular and the Foundation temporary directories.
         for tmpDir in ["/tmp", NSTemporaryDirectory()] {
-            writableDirectoriesExpression += ["(subpath \(resolveSymlinks(AbsolutePath(tmpDir)).quotedAsSubpathForSandboxProfile))"]
+            writableDirectoriesExpression += try ["(subpath \(resolveSymlinks(AbsolutePath(validating: tmpDir)).quotedAsSubpathForSandboxProfile))"]
         }
     }
 
@@ -111,7 +111,7 @@ fileprivate func macOSSandboxProfile(
     if readOnlyDirectories.count > 0 {
         contents += "(deny file-write*\n"
         for path in readOnlyDirectories {
-            contents += "    (subpath \(resolveSymlinks(path).quotedAsSubpathForSandboxProfile))\n"
+            contents += "    (subpath \(try resolveSymlinks(path).quotedAsSubpathForSandboxProfile))\n"
         }
         contents += ")\n"
     }
@@ -120,7 +120,7 @@ fileprivate func macOSSandboxProfile(
     if writableDirectories.count > 0 {
         contents += "(allow file-write*\n"
         for path in writableDirectories {
-            contents += "    (subpath \(resolveSymlinks(path).quotedAsSubpathForSandboxProfile))\n"
+            contents += "    (subpath \(try resolveSymlinks(path).quotedAsSubpathForSandboxProfile))\n"
         }
         contents += ")\n"
     }
@@ -139,6 +139,6 @@ fileprivate extension AbsolutePath {
 }
 
 extension TSCUtility.Platform {
-    fileprivate static let threadSafeDarwinCacheDirectories = ThreadSafeArrayStore<AbsolutePath>(Self.darwinCacheDirectories())
+    fileprivate static let threadSafeDarwinCacheDirectories = ThreadSafeArrayStore<AbsolutePath>((try? Self.darwinCacheDirectories()) ?? [])
 }
 #endif

Sources/Basics/TemporaryFile.swift

@@ -93,13 +93,13 @@ private func createTemporaryDirectory(fileSystem: FileSystem, dir: AbsolutePath?
 
     let randomSuffix = String((0..<6).map { _ in letters.randomElement()! })
 
-    let tempDirectory = dir ?? fileSystem.tempDirectory
+    let tempDirectory = try dir ?? fileSystem.tempDirectory
     guard fileSystem.isDirectory(tempDirectory) else {
         throw TempFileError.couldNotFindTmpDir(tempDirectory.pathString)
     }
 
     // Construct path to the temporary directory.
-    let templatePath = AbsolutePath(prefix + ".\(randomSuffix)", relativeTo: tempDirectory)
+    let templatePath = try AbsolutePath(validating: prefix + ".\(randomSuffix)", relativeTo: tempDirectory)
 
     try fileSystem.createDirectory(templatePath, recursive: true)
     return templatePath

Sources/PackageCollections/PackageIndex+Configuration.swift

@@ -33,7 +33,7 @@ public struct PackageIndexConfiguration: Equatable {
     ) {
         self.url = url
         self.searchResultMaxItemsCount = searchResultMaxItemsCount ?? 50
-        self.cacheDirectory = cacheDirectory.map(resolveSymlinks) ?? localFileSystem.swiftPMCacheDirectory.appending(components: "package-metadata")
+        self.cacheDirectory = (try? cacheDirectory.map(resolveSymlinks)) ?? (try? localFileSystem.swiftPMCacheDirectory.appending(components: "package-metadata")) ?? .root
         self.cacheTTLInSeconds = disableCache ? -1 : (cacheTTLInSeconds ?? 3600)
         self.cacheMaxSizeInMegabytes = cacheMaxSizeInMegabytes ?? 10
     }

Sources/PackageCollections/Providers/GitHubPackageMetadataProvider.swift

@@ -299,7 +299,7 @@ struct GitHubPackageMetadataProvider: PackageMetadataProvider, Closable {
         ) {
             self.authTokens = authTokens
             self.apiLimitWarningThreshold = apiLimitWarningThreshold ?? 5
-            self.cacheDir = cacheDir.map(resolveSymlinks) ?? localFileSystem.swiftPMCacheDirectory.appending(components: "package-metadata")
+            self.cacheDir = (try? cacheDir.map(resolveSymlinks)) ?? (try? localFileSystem.swiftPMCacheDirectory.appending(components: "package-metadata")) ?? .root
             self.cacheTTLInSeconds = disableCache ? -1 : (cacheTTLInSeconds ?? 3600)
             self.cacheSizeInMegabytes = cacheSizeInMegabytes ?? 10
         }

Sources/PackageCollections/Providers/JSONPackageCollectionProvider.swift

@@ -60,7 +60,7 @@ struct JSONPackageCollectionProvider: PackageCollectionProvider {
         self.observabilityScope = observabilityScope
         self.httpClient = customHTTPClient ?? Self.makeDefaultHTTPClient()
         self.signatureValidator = customSignatureValidator ?? PackageCollectionSigning(
-            trustedRootCertsDir: configuration.trustedRootCertsDir ?? fileSystem.swiftPMConfigurationDirectory.appending(component: "trust-root-certs").asURL,
+            trustedRootCertsDir: configuration.trustedRootCertsDir ?? (try? fileSystem.swiftPMConfigurationDirectory.appending(component: "trust-root-certs").asURL) ?? AbsolutePath.root.asURL,
             additionalTrustedRootCerts: sourceCertPolicy.allRootCerts.map { Array($0) },
             observabilityScope: observabilityScope,
             callbackQueue: .sharedConcurrent

Sources/PackageCollections/Storage/FilePackageCollectionsSourcesStorage.swift

@@ -28,7 +28,7 @@ struct FilePackageCollectionsSourcesStorage: PackageCollectionsSourcesStorage {
     init(fileSystem: FileSystem, path: AbsolutePath? = nil) {
         self.fileSystem = fileSystem
 
-        self.path = path ?? fileSystem.swiftPMConfigurationDirectory.appending(component: "collections.json")
+        self.path = path ?? (try? fileSystem.swiftPMConfigurationDirectory.appending(component: "collections.json")) ?? .root
         self.encoder = JSONEncoder.makeWithDefaults()
         self.decoder = JSONDecoder.makeWithDefaults()
     }

Sources/PackageCollections/Storage/SQLitePackageCollectionsStorage.swift

@@ -53,7 +53,7 @@ final class SQLitePackageCollectionsStorage: PackageCollectionsStorage, Closable
     private let populateTargetTrieLock = NSLock()
 
     init(location: SQLite.Location? = nil, configuration: Configuration = .init(), observabilityScope: ObservabilityScope) {
-        self.location = location ?? .path(localFileSystem.swiftPMCacheDirectory.appending(components: "package-collection.db"))
+        self.location = location ?? (try? .path(localFileSystem.swiftPMCacheDirectory.appending(components: "package-collection.db"))) ?? .memory
         switch self.location {
         case .path, .temporary:
             self.fileSystem = localFileSystem

Sources/PackageLoading/ManifestJSONParser.swift

@@ -215,7 +215,7 @@ enum ManifestJSONParser {
     private static func sanitizeDependencyLocation(fileSystem: TSCBasic.FileSystem, packageKind: PackageReference.Kind, dependencyLocation: String) throws -> String {
         if dependencyLocation.hasPrefix("~/") {
             // If the dependency URL starts with '~/', try to expand it.
-            return AbsolutePath(String(dependencyLocation.dropFirst(2)), relativeTo: fileSystem.homeDirectory).pathString
+            return try AbsolutePath(validating: String(dependencyLocation.dropFirst(2)), relativeTo: fileSystem.homeDirectory).pathString
         } else if dependencyLocation.hasPrefix(filePrefix) {
             // FIXME: SwiftPM can't handle file locations with file:// scheme so we need to
             // strip that. We need to design a Location data structure for SwiftPM.
@@ -236,7 +236,7 @@ enum ManifestJSONParser {
             // If the URL has no scheme, we treat it as a path (either absolute or relative to the base URL).
             switch packageKind {
             case .root(let packagePath), .fileSystem(let packagePath), .localSourceControl(let packagePath):
-                return AbsolutePath(dependencyLocation, relativeTo: packagePath).pathString
+                return try AbsolutePath(validating: dependencyLocation, relativeTo: packagePath).pathString
             case .remoteSourceControl, .registry:
                 // nothing to "fix"
                 return dependencyLocation