Add back async versions until the ecosystem can adopt the async versions

Author: plemarquand

Sources/PackageModel/SwiftSDKs/SwiftSDK.swift

@@ -529,6 +529,22 @@ public struct SwiftSDK: Equatable {
         try await self.hostSwiftSDK(binDir, environment: environment)
     }
 
+    /// The Swift SDK for the host platform.
+    @available(*, deprecated, message: "Use the async alternative")
+    public static func hostSwiftSDK(
+        _ binDir: Basics.AbsolutePath? = nil,
+        environment: Environment = .current,
+        observabilityScope: ObservabilityScope? = nil,
+        fileSystem: any FileSystem = Basics.localFileSystem
+    ) throws -> SwiftSDK {
+        try self.systemSwiftSDK(
+            binDir,
+            environment: environment,
+            observabilityScope: observabilityScope,
+            fileSystem: fileSystem
+        )
+    }
+
     /// The Swift SDK for the host platform.
     public static func hostSwiftSDK(
         _ binDir: Basics.AbsolutePath? = nil,
@@ -544,6 +560,37 @@ public struct SwiftSDK: Equatable {
         )
     }
 
+    /// A default Swift SDK on the host.
+    ///
+    /// Equivalent to `hostSwiftSDK`, except on macOS, where passing a non-nil `darwinPlatformOverride`
+    /// will result in the SDK for the corresponding Darwin platform.
+    private static func systemSwiftSDK(
+        _ binDir: Basics.AbsolutePath? = nil,
+        environment: Environment = .current,
+        observabilityScope: ObservabilityScope? = nil,
+        fileSystem: any FileSystem = Basics.localFileSystem,
+        darwinPlatformOverride: DarwinPlatform? = nil
+    ) throws -> SwiftSDK {
+        #if os(macOS)
+        let darwinPlatform = darwinPlatformOverride ?? .macOS
+        let sdkPath = try Self.getSDKPath(
+            for: darwinPlatform,
+            environment: environment
+        )
+        let sdkPaths = try? SwiftSDK.sdkPlatformPaths(for: darwinPlatform, environment: environment)
+        #else
+        let sdkPath: Basics.AbsolutePath? = nil
+        let sdkPaths: PlatformPaths? = nil
+        #endif
+
+        return try Self.buildSwiftSDK(
+            binDir: binDir,
+            sdkPath: sdkPath,
+            sdkPaths: sdkPaths,
+            environment: environment,
+            fileSystem: fileSystem
+        )
+    }
 
     /// A default Swift SDK on the host.
     ///
@@ -577,6 +624,27 @@ public struct SwiftSDK: Equatable {
         )
     }
 
+    /// Helper to get the SDK path for a Darwin platform (async version).
+    private static func getSDKPath(
+        for darwinPlatform: DarwinPlatform,
+        environment: Environment
+    ) throws -> Basics.AbsolutePath {
+        if let value = environment["SDKROOT"] {
+            return try AbsolutePath(validating: value)
+        } else if let value = environment[EnvironmentKey("SWIFTPM_SDKROOT_\(darwinPlatform.xcrunName)")] {
+            return try AbsolutePath(validating: value)
+        } else {
+            let sdkPathStr = try AsyncProcess.checkNonZeroExit(
+                arguments: ["/usr/bin/xcrun", "--sdk", darwinPlatform.xcrunName, "--show-sdk-path"],
+                environment: environment
+            ).spm_chomp()
+            guard !sdkPathStr.isEmpty else {
+                throw SwiftSDKError.invalidInstallation("default SDK not found")
+            }
+            return try AbsolutePath(validating: sdkPathStr)
+        }
+    }
+
     /// Helper to get the SDK path for a Darwin platform (async version).
     private static func getSDKPath(
         for darwinPlatform: DarwinPlatform,
@@ -674,6 +742,46 @@ public struct SwiftSDK: Equatable {
         return (fwk: frameworkPath, lib: libraryPath)
     }
 
+    /// Returns ``SwiftSDK/PlatformPaths`` for the provided Darwin platform.
+    public static func sdkPlatformPaths(
+        for darwinPlatform: DarwinPlatform,
+        environment: Environment = .current
+    ) throws -> PlatformPaths {
+        if let path = _sdkPlatformFrameworkPath[darwinPlatform] {
+            return path
+        }
+        let platformPath: String
+        if let envValue = environment[EnvironmentKey("SWIFTPM_PLATFORM_PATH_\(darwinPlatform.xcrunName)")] {
+            platformPath = envValue
+        } else {
+            platformPath = try AsyncProcess.checkNonZeroExit(
+                arguments: ["/usr/bin/xcrun", "--sdk", darwinPlatform.xcrunName, "--show-sdk-platform-path"],
+                environment: environment
+            ).spm_chomp()
+        }
+
+        guard !platformPath.isEmpty else {
+            throw StringError("could not determine SDK platform path")
+        }
+
+        // For testing frameworks.
+        let frameworksPath = try Basics.AbsolutePath(validating: platformPath).appending(
+            components: "Developer", "Library", "Frameworks"
+        )
+        let privateFrameworksPath = try Basics.AbsolutePath(validating: platformPath).appending(
+            components: "Developer", "Library", "PrivateFrameworks"
+        )
+
+        // For testing libraries.
+        let librariesPath = try Basics.AbsolutePath(validating: platformPath).appending(
+            components: "Developer", "usr", "lib"
+        )
+
+        let sdkPlatformFrameworkPath = PlatformPaths(frameworks: [frameworksPath, privateFrameworksPath], libraries: [librariesPath])
+        _sdkPlatformFrameworkPath[darwinPlatform] = sdkPlatformFrameworkPath
+        return sdkPlatformFrameworkPath
+    }
+
     /// Returns ``SwiftSDK/PlatformPaths`` for the provided Darwin platform.
     public static func sdkPlatformPaths(
         for darwinPlatform: DarwinPlatform,

Sources/PackageModel/UserToolchain.swift

@@ -175,6 +175,27 @@ public final class UserToolchain: Toolchain {
         return try getTool(name, binDirectories: envSearchPaths, fileSystem: fileSystem)
     }
 
+    private static func getTargetInfo(swiftCompiler: AbsolutePath) throws -> JSON {
+        // Call the compiler to get the target info JSON.
+        let compilerOutput: String
+        do {
+            let result = try AsyncProcess.popen(args: swiftCompiler.pathString, "-print-target-info")
+            compilerOutput = try result.utf8Output().spm_chomp()
+        } catch {
+            throw InternalError(
+                "Failed to load target info (\(error.interpolationDescription))"
+            )
+        }
+        // Parse the compiler's JSON output.
+        do {
+            return try JSON(string: compilerOutput)
+        } catch {
+            throw InternalError(
+                "Failed to parse target info (\(error.interpolationDescription)).\nRaw compiler output: \(compilerOutput)"
+            )
+        }
+    }
+
     private static func getTargetInfo(swiftCompiler: AbsolutePath) async throws -> JSON {
         // Call the compiler to get the target info JSON.
         let compilerOutput: String
@@ -666,6 +687,218 @@ public final class UserToolchain: Toolchain {
         case custom(searchPaths: [AbsolutePath], useXcrun: Bool = true)
     }
 
+    @available(*, deprecated, message: "Use the async alternative")
+    public init(
+        swiftSDK: SwiftSDK,
+        environment: Environment = .current,
+        searchStrategy: SearchStrategy = .default,
+        customTargetInfo: JSON? = nil,
+        customLibrariesLocation: ToolchainConfiguration.SwiftPMLibrariesLocation? = nil,
+        customInstalledSwiftPMConfiguration: InstalledSwiftPMConfiguration? = nil,
+        fileSystem: any FileSystem = localFileSystem
+    ) throws {
+        self.swiftSDK = swiftSDK
+        self.environment = environment
+
+        switch searchStrategy {
+        case .default:
+            // Get the search paths from PATH.
+            self.envSearchPaths = getEnvSearchPaths(
+                pathString: environment[.path],
+                currentWorkingDirectory: fileSystem.currentWorkingDirectory
+            )
+            self.useXcrun = !(fileSystem is InMemoryFileSystem)
+        case .custom(let searchPaths, let useXcrun):
+            self.envSearchPaths = searchPaths
+            self.useXcrun = useXcrun
+        }
+
+        let swiftCompilers = try UserToolchain.determineSwiftCompilers(
+            binDirectories: swiftSDK.toolset.rootPaths,
+            useXcrun: self.useXcrun,
+            environment: environment,
+            searchPaths: self.envSearchPaths,
+            fileSystem: fileSystem
+        )
+        self.swiftCompilerPath = swiftCompilers.compile
+        self.architectures = swiftSDK.architectures
+
+        if let customInstalledSwiftPMConfiguration {
+            self.installedSwiftPMConfiguration = customInstalledSwiftPMConfiguration
+        } else {
+            let path = swiftCompilerPath.parentDirectory.parentDirectory.appending(components: [
+                "share", "pm", "config.json",
+            ])
+            self.installedSwiftPMConfiguration = try Self.loadJSONResource(
+                config: path,
+                type: InstalledSwiftPMConfiguration.self,
+                default: InstalledSwiftPMConfiguration.default)
+        }
+
+        var triple: Basics.Triple
+        if let targetTriple = swiftSDK.targetTriple {
+            self.targetInfo = nil
+            triple = targetTriple
+        } else {
+            // targetInfo from the compiler
+            let targetInfo: JSON
+            if let customTargetInfo {
+                targetInfo = customTargetInfo
+            } else {
+                targetInfo = try Self.getTargetInfo(swiftCompiler: swiftCompilers.compile)
+            }
+            self.targetInfo = targetInfo
+            triple = try swiftSDK.targetTriple ?? Self.getHostTriple(targetInfo: targetInfo, versioned: false)
+        }
+
+        // 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.
+        if let architectures = self.architectures, architectures.count == 1 {
+            let components = triple.tripleString.drop(while: { $0 != "-" })
+            triple = try Triple(architectures[0] + components)
+        }
+
+        self.targetTriple = triple
+
+        var swiftCompilerFlags: [String] = []
+        var extraLinkerFlags: [String] = []
+
+        let swiftTestingPath: AbsolutePath? = try Self.deriveSwiftTestingPath(
+            derivedSwiftCompiler: swiftCompilers.compile,
+            swiftSDK: self.swiftSDK,
+            triple: triple,
+            environment: environment,
+            fileSystem: fileSystem
+        )
+
+        if triple.isMacOSX, let swiftTestingPath {
+            // Swift Testing is a framework (e.g. from CommandLineTools) so use -F.
+            if swiftTestingPath.extension == "framework" {
+                swiftCompilerFlags += ["-F", swiftTestingPath.pathString]
+
+            // Otherwise Swift Testing is assumed to be a swiftmodule + library, so use -I and -L.
+            } else {
+                swiftCompilerFlags += [
+                    "-I", swiftTestingPath.pathString,
+                    "-L", swiftTestingPath.pathString,
+                ]
+            }
+        }
+
+        // Specify the plugin path for Swift Testing's macro plugin if such a
+        // path exists in this toolchain.
+        if let swiftTestingPluginPath = Self.deriveSwiftTestingPluginPath(
+            derivedSwiftCompiler: swiftCompilers.compile,
+            fileSystem: fileSystem
+        ) {
+            swiftCompilerFlags += ["-plugin-path", swiftTestingPluginPath.pathString]
+        }
+
+        swiftCompilerFlags += try Self.deriveSwiftCFlags(
+            triple: triple,
+            swiftSDK: swiftSDK,
+            environment: environment,
+            fileSystem: fileSystem
+        )
+
+        extraLinkerFlags += swiftSDK.toolset.knownTools[.linker]?.extraCLIOptions ?? []
+
+        self.extraFlags = BuildFlags(
+            cCompilerFlags: swiftSDK.toolset.knownTools[.cCompiler]?.extraCLIOptions ?? [],
+            cxxCompilerFlags: swiftSDK.toolset.knownTools[.cxxCompiler]?.extraCLIOptions ?? [],
+            swiftCompilerFlags: swiftCompilerFlags,
+            linkerFlags: extraLinkerFlags,
+            xcbuildFlags: swiftSDK.toolset.knownTools[.xcbuild]?.extraCLIOptions ?? [])
+
+        self.includeSearchPaths = swiftSDK.pathsConfiguration.includeSearchPaths ?? []
+        self.librarySearchPaths = swiftSDK.pathsConfiguration.includeSearchPaths ?? []
+
+        self.librarianPath = try swiftSDK.toolset.knownTools[.librarian]?.path ?? UserToolchain.determineLibrarian(
+            triple: triple,
+            binDirectories: swiftSDK.toolset.rootPaths,
+            useXcrun: useXcrun,
+            environment: environment,
+            searchPaths: envSearchPaths,
+            extraSwiftFlags: self.extraFlags.swiftCompilerFlags,
+            fileSystem: fileSystem
+        )
+
+        if let sdkDir = swiftSDK.pathsConfiguration.sdkRootPath {
+            let sysrootFlags = [triple.isDarwin() ? "-isysroot" : "--sysroot", sdkDir.pathString]
+            self.extraFlags.cCompilerFlags.insert(contentsOf: sysrootFlags, at: 0)
+        }
+
+        if triple.isWindows() {
+            if let root = environment.windowsSDKRoot {
+                if let settings = WindowsSDKSettings(
+                    reading: root.appending("SDKSettings.plist"),
+                    observabilityScope: nil,
+                    filesystem: fileSystem
+                ) {
+                    switch settings.defaults.runtime {
+                    case .multithreadedDebugDLL:
+                        // Defines _DEBUG, _MT, and _DLL
+                        // Linker uses MSVCRTD.lib
+                        self.extraFlags.cCompilerFlags += [
+                            "-D_DEBUG",
+                            "-D_MT",
+                            "-D_DLL",
+                            "-Xclang",
+                            "--dependent-lib=msvcrtd",
+                        ]
+
+                    case .multithreadedDLL:
+                        // Defines _MT, and _DLL
+                        // Linker uses MSVCRT.lib
+                        self.extraFlags.cCompilerFlags += ["-D_MT", "-D_DLL", "-Xclang", "--dependent-lib=msvcrt"]
+
+                    case .multithreadedDebug:
+                        // Defines _DEBUG, and _MT
+                        // Linker uses LIBCMTD.lib
+                        self.extraFlags.cCompilerFlags += ["-D_DEBUG", "-D_MT", "-Xclang", "--dependent-lib=libcmtd"]
+
+                    case .multithreaded:
+                        // Defines _MT
+                        // Linker uses LIBCMT.lib
+                        self.extraFlags.cCompilerFlags += ["-D_MT", "-Xclang", "--dependent-lib=libcmt"]
+                    }
+                }
+            }
+        }
+
+        let swiftPMLibrariesLocation = try customLibrariesLocation ?? Self.deriveSwiftPMLibrariesLocation(
+            swiftCompilerPath: swiftCompilerPath,
+            swiftSDK: swiftSDK,
+            environment: environment,
+            fileSystem: fileSystem
+        )
+
+        let xctestPath: AbsolutePath?
+        if case .custom(_, let useXcrun) = searchStrategy, !useXcrun {
+            xctestPath = nil
+        } else {
+            xctestPath = try Self.deriveXCTestPath(
+                swiftSDK: self.swiftSDK,
+                triple: triple,
+                environment: environment,
+                fileSystem: fileSystem
+            )
+        }
+
+        self.configuration = .init(
+            librarianPath: librarianPath,
+            swiftCompilerPath: swiftCompilers.manifest,
+            swiftCompilerFlags: self.extraFlags.swiftCompilerFlags,
+            swiftCompilerEnvironment: environment,
+            swiftPMLibrariesLocation: swiftPMLibrariesLocation,
+            sdkRootPath: self.swiftSDK.pathsConfiguration.sdkRootPath,
+            xctestPath: xctestPath,
+            swiftTestingPath: swiftTestingPath
+        )
+
+        self.fileSystem = fileSystem
+    }
+
     public init(
         swiftSDK: SwiftSDK,
         environment: Environment = .current,