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

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))"]
         }
     }
 

Sources/Build/BuildOperation.swift

@@ -543,7 +543,7 @@ public final class BuildOperation: PackageStructureDelegate, SPMBuildCore.BuildS
                 // TODO: We need to also use any working directory, but that support isn't yet available on all platforms at a lower level.
                 var commandLine = [command.configuration.executable.pathString] + command.configuration.arguments
                 if !self.disableSandboxForPluginCommands {
-                    commandLine = Sandbox.apply(command: commandLine, strictness: .writableTemporaryDirectory, writableDirectories: [pluginResult.pluginOutputDirectory])
+                    commandLine = try Sandbox.apply(command: commandLine, strictness: .writableTemporaryDirectory, writableDirectories: [pluginResult.pluginOutputDirectory])
                 }
                 let processResult = try TSCBasic.Process.popen(arguments: commandLine, environment: command.configuration.environment)
                 let output = try processResult.utf8Output() + processResult.utf8stderrOutput()

Sources/Build/BuildOperationBuildSystemDelegateHandler.swift

@@ -112,7 +112,7 @@ final class TestDiscoveryCommand: CustomLLBuildCommand, TestBuildCommand {
         let store = try IndexStore.open(store: index, api: api)
 
         // FIXME: We can speed this up by having one llbuild command per object file.
-        let tests = try store.listTests(in: tool.inputs.map{ AbsolutePath($0.name) })
+        let tests = try store.listTests(in: tool.inputs.map{ try AbsolutePath(validating: $0.name) })
 
         let outputs = tool.outputs.compactMap{ try? AbsolutePath(validating: $0.name) }
         let testsByModule = Dictionary(grouping: tests, by: { $0.module.spm_mangledToC99ExtendedIdentifier() })

Sources/Build/BuildPlan.swift

@@ -45,11 +45,11 @@ extension AbsolutePath {
 
 extension BuildParameters {
     /// Returns the directory to be used for module cache.
-    public var moduleCache: AbsolutePath {
+    public func moduleCache() throws -> AbsolutePath {
         // FIXME: We use this hack to let swiftpm's functional test use shared
         // cache so it doesn't become painfully slow.
         if let path = ProcessEnv.vars["SWIFTPM_TESTS_MODULECACHE"] {
-            return AbsolutePath(path)
+           return try AbsolutePath(validating: path)
         }
         return buildPath.appending(component: "ModuleCache")
     }
@@ -406,7 +406,7 @@ public final class ClangTargetBuildDescription {
         args += ["-I", clangTarget.includeDir.pathString]
         args += additionalFlags
         if enableModules {
-            args += moduleCacheArgs
+            args += try moduleCacheArgs()
         }
         args += buildParameters.sanitizers.compileCFlags()
 
@@ -477,8 +477,8 @@ public final class ClangTargetBuildDescription {
     }
 
     /// Module cache arguments.
-    private var moduleCacheArgs: [String] {
-        return ["-fmodules-cache-path=\(buildParameters.moduleCache.pathString)"]
+    private func moduleCacheArgs() throws -> [String] {
+        return try ["-fmodules-cache-path=\(buildParameters.moduleCache().pathString)"]
     }
 
     /// Generate the resource bundle accessor, if appropriate.
@@ -804,7 +804,7 @@ public final class SwiftTargetBuildDescription {
             // `/\(resourceBundleName)/\(resourcePath)`, which allows us to pass this path to JS APIs like `fetch` directly, or to
             // `<img src=` HTML attributes. The resources are loaded from the server, and we can't hardcode the host part in the URL.
             // Making URLs relative by starting them with `/\(resourceBundleName)` makes it work in the browser.
-            let mainPath = AbsolutePath(Bundle.main.bundlePath).appending(component: bundlePath.basename).pathString
+            let mainPath = try AbsolutePath(validating: Bundle.main.bundlePath).appending(component: bundlePath.basename).pathString
             mainPathSubstitution = #""\#(mainPath.asSwiftStringLiteralConstant)""#
         } else {
             mainPathSubstitution = #"Bundle.main.bundleURL.appendingPathComponent("\#(bundlePath.basename.asSwiftStringLiteralConstant)").path"#
@@ -874,7 +874,7 @@ public final class SwiftTargetBuildDescription {
         args += ["-j\(buildParameters.jobs)"]
         args += activeCompilationConditions
         args += additionalFlags
-        args += moduleCacheArgs
+        args += try moduleCacheArgs()
         args += stdlibArguments
         args += buildParameters.sanitizers.compileSwiftFlags()
         args += ["-parseable-output"]
@@ -1028,7 +1028,7 @@ public final class SwiftTargetBuildDescription {
         result += ["-j\(buildParameters.jobs)"]
         result += activeCompilationConditions
         result += additionalFlags
-        result += moduleCacheArgs
+        result += try moduleCacheArgs()
         result += stdlibArguments
         result += self.buildSettingsFlags()
 
@@ -1075,7 +1075,7 @@ public final class SwiftTargetBuildDescription {
         result += ["-j\(buildParameters.jobs)"]
         result += activeCompilationConditions
         result += additionalFlags
-        result += moduleCacheArgs
+        result += try moduleCacheArgs()
         result += stdlibArguments
         result += buildParameters.sanitizers.compileSwiftFlags()
         result += ["-parseable-output"]
@@ -1235,8 +1235,8 @@ public final class SwiftTargetBuildDescription {
     }
 
     /// Module cache arguments.
-    private var moduleCacheArgs: [String] {
-        return ["-module-cache-path", buildParameters.moduleCache.pathString]
+    private func moduleCacheArgs() throws -> [String] {
+        return try ["-module-cache-path", buildParameters.moduleCache().pathString]
     }
 
     private var stdlibArguments: [String] {

Sources/Build/LLBuildManifestBuilder.swift

@@ -621,7 +621,7 @@ extension LLBuildManifestBuilder {
                 let displayName = command.configuration.displayName ?? execPath.basename
                 var commandLine = [execPath.pathString] + command.configuration.arguments
                 if !self.disableSandboxForPluginCommands {
-                    commandLine = Sandbox.apply(command: commandLine, strictness: .writableTemporaryDirectory, writableDirectories: [result.pluginOutputDirectory])
+                    commandLine = try Sandbox.apply(command: commandLine, strictness: .writableTemporaryDirectory, writableDirectories: [result.pluginOutputDirectory])
                 }
                 manifest.addShellCmd(
                     name: displayName + "-" + ByteString(encodingAsUTF8: uniquedName).sha256Checksum,

Sources/Commands/SwiftPackageTool.swift

@@ -1654,7 +1654,7 @@ extension SwiftPackageTool.Config {
         let workspace = try swiftTool.getActiveWorkspace()
         return try .init(
             fileSystem: swiftTool.fileSystem,
-            localMirrorsFile: workspace.location.localMirrorsConfigurationFile,
+            localMirrorsFile: try workspace.location.localMirrorsConfigurationFile(),
             sharedMirrorsFile: workspace.location.sharedMirrorsConfigurationFile
         )
     }

Sources/Commands/Utilities/SymbolGraphExtract.swift

@@ -57,7 +57,7 @@ public struct SymbolGraphExtract {
         commandLine += ["-module-name", target.c99name]
         commandLine += try buildParameters.targetTripleArgs(for: target)
         commandLine += buildPlan.createAPIToolCommonArgs(includeLibrarySearchPaths: true)
-        commandLine += ["-module-cache-path", buildParameters.moduleCache.pathString]
+        commandLine += try ["-module-cache-path", buildParameters.moduleCache().pathString]
         if verboseOutput {
             commandLine += ["-v"]
         }

Sources/Commands/Utilities/TestingSupport.swift

@@ -83,7 +83,7 @@ enum TestingSupport {
             )
             // Add the sdk platform path if we have it. If this is not present, we
             // might always end up failing.
-            if let sdkPlatformFrameworksPath = Destination.sdkPlatformFrameworkPaths() {
+            if let sdkPlatformFrameworksPath = try Destination.sdkPlatformFrameworkPaths() {
                 // appending since we prefer the user setting (if set) to the one we inject
                 env.appendPath("DYLD_FRAMEWORK_PATH", value: sdkPlatformFrameworksPath.fwk.pathString)
                 env.appendPath("DYLD_LIBRARY_PATH", value: sdkPlatformFrameworksPath.lib.pathString)

Sources/PackageLoading/ManifestLoader.swift

@@ -631,7 +631,11 @@ public final class ManifestLoader: ManifestLoaderProtocol {
                         if self.isManifestSandboxEnabled {
                             let cacheDirectories = [self.databaseCacheDir, moduleCachePath].compactMap{ $0 }
                             let strictness: Sandbox.Strictness = toolsVersion < .v5_3 ? .manifest_pre_53 : .default
-                            cmd = Sandbox.apply(command: cmd, strictness: strictness, writableDirectories: cacheDirectories)
+                            do {
+                                cmd = try Sandbox.apply(command: cmd, strictness: strictness, writableDirectories: cacheDirectories)
+                            } catch {
+                                return completion(.failure(error))
+                            }
                         }
 
                         // Run the compiled manifest.
@@ -696,7 +700,9 @@ public final class ManifestLoader: ManifestLoaderProtocol {
         guard let sdkRoot = foundPath?.spm_chomp(), !sdkRoot.isEmpty else {
             return nil
         }
-        let path = AbsolutePath(sdkRoot)
+        guard let path = try? AbsolutePath(validating: sdkRoot) else {
+            return nil
+        }
         sdkRootPath = path
         self.sdkRootCache.put(path)
         #endif

Sources/PackageLoading/PkgConfig.swift

@@ -76,7 +76,7 @@ public struct PkgConfig {
             let pkgFileFinder = PCFileFinder(brewPrefix: brewPrefix)
             self.pcFile = try pkgFileFinder.locatePCFile(
                 name: name,
-                customSearchPaths: PkgConfig.envSearchPaths + additionalSearchPaths,
+                customSearchPaths: try PkgConfig.envSearchPaths() + additionalSearchPaths,
                 fileSystem: fileSystem,
                 observabilityScope: observabilityScope
             )
@@ -121,12 +121,12 @@ public struct PkgConfig {
         loadingContext.pkgConfigStack.removeLast();
     }
 
-    private static var envSearchPaths: [AbsolutePath] {
+    private static func envSearchPaths() throws -> [AbsolutePath] {
         if let configPath = ProcessEnv.vars["PKG_CONFIG_PATH"] {
 #if os(Windows)
-            return configPath.split(separator: ";").map({ AbsolutePath(String($0)) })
+            return try configPath.split(separator: ";").map({ try AbsolutePath(validating: String($0)) })
 #else
-            return configPath.split(separator: ":").map({ AbsolutePath(String($0)) })
+            return try configPath.split(separator: ":").map({ try AbsolutePath(validating: String($0)) })
 #endif
         }
         return []
@@ -397,9 +397,9 @@ internal struct PCFileFinder {
                 ).spm_chomp()
 
 #if os(Windows)
-                PCFileFinder.pkgConfigPaths = searchPaths.split(separator: ";").map({ AbsolutePath(String($0)) })
+                PCFileFinder.pkgConfigPaths = try searchPaths.split(separator: ";").map({ try AbsolutePath(validating: String($0)) })
 #else
-                PCFileFinder.pkgConfigPaths = searchPaths.split(separator: ":").map({ AbsolutePath(String($0)) })
+                PCFileFinder.pkgConfigPaths = try searchPaths.split(separator: ":").map({ try AbsolutePath(validating: String($0)) })
 #endif
             } catch {
                 PCFileFinder.shouldEmitPkgConfigPathsDiagnostic = true

Sources/PackageLoading/Target+PkgConfig.swift

@@ -182,7 +182,7 @@ extension SystemPackageProviderDescription {
                     return []
                 }
             }
-            return packages.map({ AbsolutePath(brewPrefix).appending(components: "opt", $0, "lib", "pkgconfig") })
+            return packages.compactMap({ (try? AbsolutePath(validating: brewPrefix))?.appending(components: "opt", $0, "lib", "pkgconfig") })
         case .apt:
             return []
         case .yum:

Sources/PackageModel/Destination.swift

@@ -129,7 +129,7 @@ public struct Destination: Encodable, Equatable {
             guard !sdkPathStr.isEmpty else {
                 throw DestinationError.invalidInstallation("default SDK not found")
             }
-            sdkPath = AbsolutePath(sdkPathStr)
+            sdkPath = try AbsolutePath(validating: sdkPathStr)
         }
 #else
         sdkPath = nil
@@ -139,7 +139,7 @@ public struct Destination: Encodable, Equatable {
         var extraCCFlags: [String] = []
         var extraSwiftCFlags: [String] = []
 #if os(macOS)
-        if let sdkPaths = Destination.sdkPlatformFrameworkPaths(environment: environment) {
+        if let sdkPaths = try Destination.sdkPlatformFrameworkPaths(environment: environment) {
             extraCCFlags += ["-F", sdkPaths.fwk.pathString]
             extraSwiftCFlags += ["-F", sdkPaths.fwk.pathString]
             extraSwiftCFlags += ["-I", sdkPaths.lib.pathString]
@@ -164,7 +164,7 @@ public struct Destination: Encodable, Equatable {
     /// Returns macosx sdk platform framework path.
     public static func sdkPlatformFrameworkPaths(
         environment: EnvironmentVariables = .process()
-    ) -> (fwk: AbsolutePath, lib: AbsolutePath)? {
+    ) throws -> (fwk: AbsolutePath, lib: AbsolutePath)? {
         if let path = _sdkPlatformFrameworkPath {
             return path
         }
@@ -174,11 +174,11 @@ public struct Destination: Encodable, Equatable {
 
         if let platformPath = platformPath, !platformPath.isEmpty {
             // For XCTest framework.
-            let fwk = AbsolutePath(platformPath).appending(
+            let fwk = try AbsolutePath(validating: platformPath).appending(
                 components: "Developer", "Library", "Frameworks")
 
             // For XCTest Swift library.
-            let lib = AbsolutePath(platformPath).appending(
+            let lib = try AbsolutePath(validating: platformPath).appending(
                 components: "Developer", "usr", "lib")
 
             _sdkPlatformFrameworkPath = (fwk, lib)

Sources/SPMTestSupport/MockRegistry.swift

@@ -352,7 +352,7 @@ private struct MockRegistryArchiver: Archiver {
                 if !self.fileSystem.exists(targetPath.parentDirectory) {
                     try self.fileSystem.createDirectory(targetPath.parentDirectory, recursive: true)
                 }
-                try self.fileSystem.copy(from: AbsolutePath(path), to: targetPath)
+                try self.fileSystem.copy(from: AbsolutePath(validating: path), to: targetPath)
             }
             completion(.success(()))
         } catch {

Sources/SPMTestSupport/Toolchain.swift

@@ -16,17 +16,17 @@ import Workspace
 import TSCBasic
 
 #if os(macOS)
-private func macOSBundleRoot() -> AbsolutePath {
+private func macOSBundleRoot() throws -> AbsolutePath {
     for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") {
-        return AbsolutePath(bundle.bundlePath).parentDirectory
+        return try AbsolutePath(validating: bundle.bundlePath).parentDirectory
     }
     fatalError()
 }
 #endif
 
-private func resolveBinDir() -> AbsolutePath {
+private func resolveBinDir() throws -> AbsolutePath {
 #if os(macOS)
-    return macOSBundleRoot()
+    return try macOSBundleRoot()
 #else
     return AbsolutePath(CommandLine.arguments[0], relativeTo: localFileSystem.currentWorkingDirectory!).parentDirectory
 #endif
@@ -35,8 +35,8 @@ private func resolveBinDir() -> AbsolutePath {
 extension UserToolchain {
 
 #if os(macOS)
-    public var sdkPlatformFrameworksPath: AbsolutePath {
-        return Destination.sdkPlatformFrameworkPaths()!.fwk
+    public func sdkPlatformFrameworksPath() throws -> AbsolutePath {
+        return try Destination.sdkPlatformFrameworkPaths()!.fwk
     }
 #endif
 
@@ -45,7 +45,7 @@ extension UserToolchain {
 extension Destination {
     public static var `default`: Self {
         get {
-            let binDir = resolveBinDir()
+            let binDir = try! resolveBinDir()
             return try! Destination.hostDestination(binDir)
         }
     }

Sources/Workspace/DefaultPluginScriptRunner.swift

@@ -386,7 +386,9 @@ public struct DefaultPluginScriptRunner: PluginScriptRunner, Cancellable {
         guard let sdkRoot = foundPath?.spm_chomp(), !sdkRoot.isEmpty else {
             return nil
         }
-        let path = AbsolutePath(sdkRoot)
+        guard let path = try? AbsolutePath(validating: sdkRoot) else {
+            return nil
+        }
         sdkRootPath = path
         self.sdkRootCache.put(path)
         #endif
@@ -416,7 +418,11 @@ public struct DefaultPluginScriptRunner: PluginScriptRunner, Cancellable {
 
         // Optionally wrap the command in a sandbox, which places some limits on what it can do. In particular, it blocks network access and restricts the paths to which the plugin can make file system changes. It does allow writing to temporary directories.
         if self.enableSandbox {
-            command = Sandbox.apply(command: command, strictness: .writableTemporaryDirectory, writableDirectories: writableDirectories + [self.cacheDir], readOnlyDirectories: readOnlyDirectories)
+            do {
+                command = try Sandbox.apply(command: command, strictness: .writableTemporaryDirectory, writableDirectories: writableDirectories + [self.cacheDir], readOnlyDirectories: readOnlyDirectories)
+            } catch {
+                print("error while preparing to send message to plugin: \(error)")
+            }
         }
 
         // Create and configure a Process. We set the working directory to the cache directory, so that relative paths end up there.

Sources/Workspace/Workspace+Configuration.swift

@@ -92,10 +92,10 @@ extension Workspace {
         // config locations
 
         /// Path to the local mirrors configuration.
-        public var localMirrorsConfigurationFile: AbsolutePath {
+        public func localMirrorsConfigurationFile() throws -> AbsolutePath {
             // backwards compatibility
             if let customPath = ProcessEnv.vars["SWIFTPM_MIRROR_CONFIG"] {
-                return AbsolutePath(customPath)
+                return try AbsolutePath(validating: customPath)
             }
             return DefaultLocations.mirrorsConfigurationFile(at: self.localConfigurationDirectory)
         }