Only fetch swiftc target info when needed. (#8992)

We added fetching of the swift compiler version using swiftc
-print-target-info in the init of UserToolchain so that it can be passed
to the PrebuiltsManager to calculate the manifest and prebuilts zip file
names.

However, there are cases where we pass in the triple for the current SDK
which was intended to avoid the call to swiftc. We now call it all the
time which causes an extra call to swiftc that isn't always needed.

To address this, we make the calculation of the target info lazy and
move the call to fetch the swift version to the point we need it in the
PrebuiltsManager. If prebuilts aren't required, the call is avoided.

To properly test this we need to run a test that calls out to swiftc.
However, we don't have integration tests yet for prebuilts since they
would take a long time to execute. I have instead manually tested this
using a staged version of the prebuilts.

Author: dschaefer2

Sources/PackageModel/UserToolchain.swift

@@ -43,7 +43,10 @@ public final class UserToolchain: Toolchain {
     public let librarySearchPaths: [AbsolutePath]
 
     /// An array of paths to use with binaries produced by this toolchain at run time.
-    public let runtimeLibraryPaths: [AbsolutePath]
+    public lazy var runtimeLibraryPaths: [AbsolutePath] = {
+        guard let targetInfo else { return [] }
+        return (try? Self.computeRuntimeLibraryPaths(targetInfo: targetInfo)) ?? []
+    }()
 
     /// Path containing Swift resources for dynamic linking.
     public var swiftResourcesPath: AbsolutePath? {
@@ -78,8 +81,17 @@ public final class UserToolchain: Toolchain {
 
     public let targetTriple: Basics.Triple
 
+    private let _targetInfo: JSON?
+    private lazy var targetInfo: JSON? = {
+        // Only call out to the swift compiler to fetch the target info when necessary
+        try? _targetInfo ?? Self.getTargetInfo(swiftCompiler: swiftCompilerPath)
+    }()
+
     // A version string that can be used to identify the swift compiler version
-    public let swiftCompilerVersion: String?
+    public lazy var swiftCompilerVersion: String? = {
+        guard let targetInfo else { return nil }
+        return Self.computeSwiftCompilerVersion(targetInfo: targetInfo)
+    }()
 
     /// The list of CPU architectures to build for.
     public let architectures: [String]?
@@ -721,17 +733,16 @@ public final class UserToolchain: Toolchain {
                 default: InstalledSwiftPMConfiguration.default)
         }
 
-        // targetInfo from the compiler
-        let targetInfo = try customTargetInfo ?? Self.getTargetInfo(swiftCompiler: swiftCompilers.compile)
-
-        // Get compiler version information from target info
-        self.swiftCompilerVersion = Self.computeSwiftCompilerVersion(targetInfo: targetInfo)
-
-        // Get the list of runtime libraries from the target info
-        self.runtimeLibraryPaths = try Self.computeRuntimeLibraryPaths(targetInfo: targetInfo)
-
-        // Use the triple from Swift SDK or compute the host triple from the target info
-        var triple = try swiftSDK.targetTriple ?? Self.getHostTriple(targetInfo: targetInfo)
+        var triple: Basics.Triple
+        if let targetTriple = swiftSDK.targetTriple {
+            self._targetInfo = nil
+            triple = targetTriple
+        } else {
+            // targetInfo from the compiler
+            let targetInfo = try customTargetInfo ?? Self.getTargetInfo(swiftCompiler: swiftCompilers.compile)
+            self._targetInfo = targetInfo
+            triple = try swiftSDK.targetTriple ?? Self.getHostTriple(targetInfo: targetInfo)
+        }
 
         // Change the triple to the specified arch if there's exactly one of them.
         // The Triple property is only looked at by the native build system currently.

Sources/Workspace/Workspace+Prebuilts.swift

@@ -165,7 +165,6 @@ extension Workspace {
         public typealias Delegate = PrebuiltsManagerDelegate
 
         private let fileSystem: FileSystem
-        private let swiftVersion: String
         private let authorizationProvider: AuthorizationProvider?
         private let httpClient: HTTPClient
         private let archiver: Archiver
@@ -175,15 +174,16 @@ extension Workspace {
         private let hashAlgorithm: HashAlgorithm = SHA256()
         private let prebuiltsDownloadURL: URL
         private let rootCertPath: AbsolutePath?
+        private let customSwiftCompilerVersion: String?
         let hostPlatform: PrebuiltsManifest.Platform
 
         init(
             fileSystem: FileSystem,
             hostPlatform: PrebuiltsManifest.Platform,
-            swiftCompilerVersion: String,
             authorizationProvider: AuthorizationProvider?,
             scratchPath: AbsolutePath,
             cachePath: AbsolutePath?,
+            customSwiftCompilerVersion: String?,
             customHTTPClient: HTTPClient?,
             customArchiver: Archiver?,
             delegate: Delegate?,
@@ -192,9 +192,9 @@ extension Workspace {
         ) {
             self.fileSystem = fileSystem
             self.hostPlatform = hostPlatform
-            self.swiftVersion = swiftCompilerVersion
             self.authorizationProvider = authorizationProvider
             self.httpClient = customHTTPClient ?? HTTPClient()
+            self.customSwiftCompilerVersion = customSwiftCompilerVersion
 
 #if os(Linux)
             self.archiver = customArchiver ?? TarArchiver(fileSystem: fileSystem)
@@ -276,10 +276,15 @@ extension Workspace {
         }
 
         func downloadManifest(
+            workspace: Workspace,
             package: PrebuiltPackage,
             version: Version,
             observabilityScope: ObservabilityScope
         ) async throws -> PrebuiltsManifest? {
+            guard let swiftVersion = customSwiftCompilerVersion ?? workspace.hostToolchain.swiftCompilerVersion else {
+                return nil
+            }
+
             let manifestFile = swiftVersion + "-manifest.json"
             let manifestPath = try RelativePath(validating: "\(package.identity)/\(version)/\(manifestFile)")
             let destination = scratchPath.appending(manifestPath)
@@ -418,12 +423,17 @@ extension Workspace {
         }
 
         func downloadPrebuilt(
+            workspace: Workspace,
             package: PrebuiltPackage,
             version: Version,
             library: PrebuiltsManifest.Library,
             artifact: PrebuiltsManifest.Library.Artifact,
             observabilityScope: ObservabilityScope
         ) async throws -> AbsolutePath? {
+            guard let swiftVersion = customSwiftCompilerVersion ?? workspace.hostToolchain.swiftCompilerVersion else {
+                return nil
+            }
+
             let artifactName = "\(swiftVersion)-\(library.name)-\(artifact.platform.rawValue)"
             let scratchDir = scratchPath.appending(components: package.identity.description, version.description)
 
@@ -597,6 +607,7 @@ extension Workspace {
                 let packageVersion = manifest.manifest.version,
                 let prebuiltManifest = try await prebuiltsManager
                     .downloadManifest(
+                        workspace: self,
                         package: prebuilt,
                         version: packageVersion,
                         observabilityScope: observabilityScope
@@ -611,6 +622,7 @@ extension Workspace {
                 for artifact in library.artifacts ?? [] where artifact.platform == hostPlatform {
                     if let path = try await prebuiltsManager
                         .downloadPrebuilt(
+                            workspace: self,
                             package: prebuilt,
                             version: packageVersion,
                             library: library,

Sources/Workspace/Workspace.swift

@@ -578,8 +578,7 @@ public class Workspace {
 
         var prebuiltsManager: PrebuiltsManager?
         if configuration.usePrebuilts,
-           let hostPlatform = customPrebuiltsManager?.hostPlatform ?? PrebuiltsManifest.Platform.hostPlatform,
-           let swiftCompilerVersion = hostToolchain.swiftCompilerVersion
+           let hostPlatform = customPrebuiltsManager?.hostPlatform ?? PrebuiltsManifest.Platform.hostPlatform
         {
             let rootCertPath: AbsolutePath?
             if let path = configuration.prebuiltsRootCertPath {
@@ -591,10 +590,10 @@ public class Workspace {
             let prebuiltsManagerObj = PrebuiltsManager(
                 fileSystem: fileSystem,
                 hostPlatform: hostPlatform,
-                swiftCompilerVersion: customPrebuiltsManager?.swiftVersion ?? swiftCompilerVersion,
                 authorizationProvider: authorizationProvider,
                 scratchPath: location.prebuiltsDirectory,
                 cachePath: customPrebuiltsManager?.useCache == false || !configuration.sharedDependenciesCacheEnabled ? .none : location.sharedPrebuiltsCacheDirectory,
+                customSwiftCompilerVersion: customPrebuiltsManager?.swiftVersion,
                 customHTTPClient: customPrebuiltsManager?.httpClient,
                 customArchiver: customPrebuiltsManager?.archiver,
                 delegate: delegate.map(WorkspacePrebuiltsManagerDelegate.init(workspaceDelegate:)),