refactor toolchain SwiftPM libraries path

motivation: improve logic in how Manifest and Plugin APIs locations are derived

changes:
* rename fields on ToolchainConfiguration to better articulate their meaning
* change logic in UserToolchain to derive the SwiftPM libraries path more clearly and reliably
* adjust call-sites and test

Author: tomerd

Sources/Commands/SwiftRunTool.swift

@@ -136,7 +136,7 @@ public struct SwiftRunTool: SwiftCommand {
             let arguments = buildOp.buildPlan!.createREPLArguments()
             print("Launching Swift REPL with arguments: \(arguments.joined(separator: " "))")
             try run(
-                swiftTool.getToolchain().swiftInterpreter,
+                swiftTool.getToolchain().swiftInterpreterPath,
                 originalWorkingDirectory: swiftTool.originalWorkingDirectory,
                 arguments: arguments)
 
@@ -171,7 +171,7 @@ public struct SwiftRunTool: SwiftCommand {
             if let executable = options.executable, isValidSwiftFilePath(executable) {
                 swiftTool.diagnostics.emit(.runFileDeprecation)
                 // Redirect execution to the toolchain's swift executable.
-                let swiftInterpreterPath = try swiftTool.getToolchain().swiftInterpreter
+                let swiftInterpreterPath = try swiftTool.getToolchain().swiftInterpreterPath
                 // Prepend the script to interpret to the arguments.
                 let arguments = [executable] + options.arguments
                 try run(

Sources/PackageLoading/ManifestLoader.swift

@@ -689,14 +689,14 @@ public final class ManifestLoader: ManifestLoaderProtocol {
         let moduleCachePath = (ProcessEnv.vars["SWIFTPM_MODULECACHE_OVERRIDE"] ?? ProcessEnv.vars["SWIFTPM_TESTS_MODULECACHE"]).flatMap{ AbsolutePath.init($0) }
 
         var cmd: [String] = []
-        cmd += [self.toolchain.swiftCompiler.pathString]
+        cmd += [self.toolchain.swiftCompilerPath.pathString]
         cmd += verbosity.ccArgs
 
         let macOSPackageDescriptionPath: AbsolutePath
-        // If we got the binDir that means we could be developing SwiftPM in Xcode
+        // If we got the swiftPMBinaryPath that means we could be developing SwiftPM in Xcode
         // which produces a framework for dynamic package products.
         let packageFrameworkPath = runtimePath.appending(component: "PackageFrameworks")
-        if self.toolchain.binDir != nil, localFileSystem.exists(packageFrameworkPath)  {
+        if localFileSystem.exists(packageFrameworkPath)  {
             cmd += [
                 "-F", packageFrameworkPath.pathString,
                 "-framework", "PackageDescription",
@@ -722,7 +722,7 @@ public final class ManifestLoader: ManifestLoaderProtocol {
         // Use the same minimum deployment target as the PackageDescription library (with a fallback of 10.15).
 #if os(macOS)
         let triple = Self._hostTriple.memoize {
-            Triple.getHostTriple(usingSwiftCompiler: self.toolchain.swiftCompiler)
+            Triple.getHostTriple(usingSwiftCompiler: self.toolchain.swiftCompilerPath)
         }
 
         let version = try Self._packageDescriptionMinimumDeploymentTarget.memoize {
@@ -855,7 +855,7 @@ public final class ManifestLoader: ManifestLoaderProtocol {
         cmd += ["-swift-version", toolsVersion.swiftLanguageVersion.rawValue]
         cmd += ["-I", runtimePath.pathString]
       #if os(macOS)
-        if let sdkRoot = self.toolchain.sdkRoot ?? self.sdkRoot() {
+        if let sdkRoot = self.toolchain.sdkRootPath ?? self.sdkRoot() {
             cmd += ["-sdk", sdkRoot.pathString]
         }
       #endif
@@ -865,19 +865,13 @@ public final class ManifestLoader: ManifestLoaderProtocol {
 
     /// Returns the runtime path given the manifest version and path to libDir.
     private func runtimePath(for version: ToolsVersion) -> AbsolutePath {
-        // Bin dir will be set when developing swiftpm without building all of the runtimes.
-        if let binDir = self.toolchain.binDir {
-            return binDir
-        }
-        
-        // Otherwise we use the standard location of the manifest API in the toolchain, if it exists.
-        let manifestAPIDir = self.toolchain.libDir.appending(component: "ManifestAPI")
+        let manifestAPIDir = self.toolchain.swiftPMLibrariesLocation.manifestAPI
         if localFileSystem.exists(manifestAPIDir) {
             return manifestAPIDir
         }
 
-        // Otherwise, fall back on the old location (this would indicate that we're using an old toolchain).
-        return self.toolchain.libDir.appending(version.runtimeSubpath)
+        // Fall back on the old location (this would indicate that we're using an old toolchain).
+        return self.toolchain.swiftPMLibrariesLocation.root.appending(version.runtimeSubpath)
     }
 
     /// Returns path to the manifest database inside the given cache directory.

Sources/PackageModel/ToolchainConfiguration.swift

@@ -16,34 +16,54 @@ import TSCBasic
 /// using the package manager with alternate toolchains in the future.
 public struct ToolchainConfiguration {
     /// The path of the swift compiler.
-    public let swiftCompiler: AbsolutePath
+    public let swiftCompilerPath: AbsolutePath
 
     /// Extra flags to pass the Swift compiler.
     public let swiftCompilerFlags: [String]
 
-    /// The path of the library resources.
-    public let libDir: AbsolutePath
+    /// SwiftPM library paths.
+    public let swiftPMLibrariesLocation: SwiftPMLibrariesLocation
 
-    /// The bin directory.
-    public let binDir: AbsolutePath?
+    /// The swiftpm binary directory.
+    //public let swiftPMBinaryPath: AbsolutePath?
 
     /// The path to SDK root.
     ///
     /// If provided, it will be passed to the swift interpreter.
-    public let sdkRoot: AbsolutePath?
+    public let sdkRootPath: AbsolutePath?
 
     /// XCTest Location
-    public let xctestLocation: AbsolutePath?
+    public let xctestPath: AbsolutePath?
 
     /// Creates the set of manifest resources associated with a `swiftc` executable.
     ///
     /// - Parameters:
-    ///     - swiftCompiler: The absolute path of the associated `swiftc` executable.
+    ///     - swiftCompilerPath: The absolute path of the associated `swiftc` executable.
     ///     - swiftCompilerFlags: Extra flags to pass the Swift compiler.: Extra flags to pass the Swift compiler.
-    ///     - libDir: The path of the library resources.
-    ///     - binDir: The bin directory.
-    ///     - sdkRoot: The path to SDK root.
-    ///     - xctestLocation: XCTest Location
+    ///     - swiftPMLibrariesRootPath: Custom path for SwiftPM libraries.
+    ///     - sdkRootPath: The path to SDK root.
+    ///     - xctestPath: XCTest Location
+    public init(
+        swiftCompilerPath: AbsolutePath,
+        swiftCompilerFlags: [String] = [],
+        swiftPMLibrariesLocation: SwiftPMLibrariesLocation? = nil,
+        sdkRootPath: AbsolutePath? = nil,
+        xctestPath: AbsolutePath? = nil
+    ) {
+        let swiftPMLibrariesLocation = swiftPMLibrariesLocation ?? {
+            let rootPath = Self.swiftPMLibrariesPath(from: swiftCompilerPath.parentDirectory.parentDirectory)
+            return .init(root: rootPath)
+        }()
+
+        self.swiftCompilerPath = swiftCompilerPath
+        self.swiftCompilerFlags = swiftCompilerFlags
+        self.swiftPMLibrariesLocation = swiftPMLibrariesLocation
+        self.sdkRootPath = sdkRootPath
+        self.xctestPath = xctestPath
+    }
+
+    // deprecated 8/2021
+    @available(*, deprecated, message: "use non-deprecated initializer instead")
     public init(
         swiftCompiler: AbsolutePath,
         swiftCompilerFlags: [String] = [],
@@ -52,15 +72,36 @@ public struct ToolchainConfiguration {
         sdkRoot: AbsolutePath? = nil,
         xctestLocation: AbsolutePath? = nil
     ) {
-        self.swiftCompiler = swiftCompiler
-        self.swiftCompilerFlags = swiftCompilerFlags
-        self.libDir = libDir ?? Self.libDir(forBinDir: swiftCompiler.parentDirectory)
-        self.binDir = binDir
-        self.sdkRoot = sdkRoot
-        self.xctestLocation = xctestLocation
+        self.init(
+            swiftCompilerPath: swiftCompiler,
+            swiftCompilerFlags: swiftCompilerFlags,
+            swiftPMLibrariesLocation: libDir.map { .init(root: $0) },
+            sdkRootPath: sdkRoot,
+            xctestPath: xctestLocation
+        )
+    }
+
+    public static func swiftPMLibrariesPath(from rootPath: AbsolutePath) -> AbsolutePath {
+        return rootPath.appending(components: "lib", "swift", "pm")
     }
 
-    public static func libDir(forBinDir binDir: AbsolutePath) -> AbsolutePath {
-        return binDir.parentDirectory.appending(components: "lib", "swift", "pm")
+    public struct SwiftPMLibrariesLocation {
+        public var root: AbsolutePath
+        public var manifestAPI: AbsolutePath
+        public var pluginsAPI: AbsolutePath
+
+        public init(root: AbsolutePath, manifestAPI: AbsolutePath, pluginsAPI: AbsolutePath) {
+            self.root = root
+            self.manifestAPI = manifestAPI
+            self.pluginsAPI = pluginsAPI
+        }
+
+        public init(root: AbsolutePath) {
+            self.init(
+                root: root,
+                manifestAPI: root.appending(component: "ManifestAPI"),
+                pluginsAPI: root.appending(component: "PluginsAPI")
+            )
+        }
     }
 }

Sources/SPMTestSupport/Toolchain.swift

@@ -35,10 +35,9 @@ extension ToolchainConfiguration {
         get {
             let toolchain = UserToolchain.default
             return .init(
-                swiftCompiler: toolchain.configuration.swiftCompiler,
+                swiftCompilerPath: toolchain.configuration.swiftCompilerPath,
                 swiftCompilerFlags: [],
-                libDir: toolchain.configuration.libDir,
-                binDir: toolchain.configuration.binDir
+                swiftPMLibrariesLocation: toolchain.configuration.swiftPMLibrariesLocation
             )
         }
     }

Sources/Workspace/DefaultPluginScriptRunner.swift

@@ -40,30 +40,29 @@ public struct DefaultPluginScriptRunner: PluginScriptRunner {
 
     public var hostTriple: Triple {
         return Self._hostTriple.memoize {
-            Triple.getHostTriple(usingSwiftCompiler: self.toolchain.swiftCompiler)
+            Triple.getHostTriple(usingSwiftCompiler: self.toolchain.swiftCompilerPath)
         }
     }
 
     /// Helper function that compiles a plugin script as an executable and returns the path to it.
     fileprivate func compile(sources: Sources, toolsVersion: ToolsVersion, cacheDir: AbsolutePath) throws -> AbsolutePath {
         // FIXME: Much of this is copied from the ManifestLoader and should be consolidated.
 
-        // Bin dir will be set when developing swiftpm without building all of the runtimes.
-        let runtimePath = self.toolchain.binDir ?? self.toolchain.libDir.appending(component: "PluginAPI")
+        let runtimePath = self.toolchain.swiftPMLibrariesLocation.pluginsAPI
 
         // Compile the package plugin script.
-        var command = [self.toolchain.swiftCompiler.pathString]
+        var command = [self.toolchain.swiftCompilerPath.pathString]
 
         // FIXME: Workaround for the module cache bug that's been haunting Swift CI
         // <rdar://problem/48443680>
         let moduleCachePath = ProcessEnv.vars["SWIFTPM_MODULECACHE_OVERRIDE"] ?? ProcessEnv.vars["SWIFTPM_TESTS_MODULECACHE"]
 
-        // If we got the binDir that means we could be developing SwiftPM in Xcode
+        // If we got the swiftPMBinaryPath that means we could be developing SwiftPM in Xcode
         // which produces a framework for dynamic package products.
         let packageFrameworkPath = runtimePath.appending(component: "PackageFrameworks")
 
         let macOSPackageDescriptionPath: AbsolutePath
-        if self.toolchain.binDir != nil, localFileSystem.exists(packageFrameworkPath) {
+        if localFileSystem.exists(packageFrameworkPath) {
             command += [
                 "-F", packageFrameworkPath.pathString,
                 "-framework", "PackagePlugin",
@@ -101,7 +100,7 @@ public struct DefaultPluginScriptRunner: PluginScriptRunner {
         command += ["-swift-version", toolsVersion.swiftLanguageVersion.rawValue]
         command += ["-I", runtimePath.pathString]
         #if os(macOS)
-        if let sdkRoot = self.toolchain.sdkRoot ?? self.sdkRoot() {
+        if let sdkRoot = self.toolchain.sdkRootPath ?? self.sdkRoot() {
             command += ["-sdk", sdkRoot.pathString]
         }
         #endif