Add new options that control whether host toolchain is included (#165)

This adds a new `--no-host-toolchain` flag to the `make-linux-sdk` sub-command, making it possible to generate an SDK for x86_64 or aarch64 with only the target sysroot and Swift libraries, like this:

```bash
# x86_64
swift run swift-sdk-generator make-linux-sdk --swift-version 6.0.3-RELEASE --target x86_64-unknown-linux-gnu --no-include-host-toolchain
# aarch64
swift run swift-sdk-generator make-linux-sdk --swift-version 6.0.3-RELEASE --target aarch64-unknown-linux-gnu --no-include-host-toolchain
```

I tested the generated SDKs on both Ubuntu 22.04 and macOS 15 and they work just fine.

Ubuntu x86_64 -> aarch64:

```bash
> swift build --swift-sdk 6.0.3-RELEASE_ubuntu_jammy_aarch64
Building for debugging...
warning: Could not read SDKSettings.json for SDK at: ~/.swiftpm/swift-sdks/6.0.3-RELEASE_ubuntu_jammy_aarch64.artifactbundle/6.0.3-RELEASE_ubuntu_jammy_aarch64/aarch64-unknown-linux-gnu/ubuntu-jammy.sdk
[485/485] Linking ConsumePublishServices
Build complete! (25.37s)
```

macOS arm64 -> x86_64:

```bash
>  swift build --swift-sdk 6.0.3-RELEASE_ubuntu_jammy_x86_64
Building for debugging...
warning: Could not read SDKSettings.json for SDK at: /Users/xtremek/Library/org.swift.swiftpm/swift-sdks/6.0.3-RELEASE_ubuntu_jammy_x86_64.artifactbundle/6.0.3-RELEASE_ubuntu_jammy_x86_64/x86_64-unknown-linux-gnu/ubuntu-jammy.sdk
<unknown>:0: warning: libc not found for 'x86_64-unknown-linux-gnu'; C stdlib may be unavailable
[1171/1171] Linking ConsumePublishServices
Build complete! (39.43s)
```

Author: xtremekforever

Sources/GeneratorCLI/GeneratorCLI.swift

@@ -107,6 +107,16 @@ extension GeneratorCLI {
     )
     var hostSwiftPackagePath: String? = nil
 
+    @Flag(
+      inversion: .prefixedNo,
+      help: """
+      Whether or not to include the host toolchain in the Swift SDK.
+      If the host toolchain is not included, this makes the Swift SDK compatible with any host, \
+      but requires exactly the same version of the swift.org toolchain to be installed for it to work.
+      """
+    )
+    var hostToolchain: Bool = true
+
     @Option(
       help: """
       Path to the Swift toolchain package containing the Swift standard library that runs on the target platform.
@@ -225,7 +235,8 @@ extension GeneratorCLI {
         withDocker: self.withDocker,
         fromContainerImage: self.fromContainerImage,
         hostSwiftPackagePath: self.generatorOptions.hostSwiftPackagePath,
-        targetSwiftPackagePath: self.generatorOptions.targetSwiftPackagePath
+        targetSwiftPackagePath: self.generatorOptions.targetSwiftPackagePath,
+        includeHostToolchain: self.generatorOptions.hostToolchain
       )
       try await GeneratorCLI.run(recipe: recipe, targetTriple: targetTriple, options: self.generatorOptions)
     }

Sources/Helpers/Vendor/Triple.swift

@@ -32,7 +32,7 @@
 ///
 /// This is a port of https://github.com/apple/swift-llvm/blob/stable/include/llvm/ADT/Triple.h
 @dynamicMemberLookup
-public struct Triple: Sendable {
+public struct Triple: Sendable, Equatable {
   /// `Triple` proxies predicates from `Triple.OS`, returning `false` for an unknown OS.
   public subscript(dynamicMember predicate: KeyPath<OS, Bool>) -> Bool {
     os?[keyPath: predicate] ?? false

Sources/SwiftSDKGenerator/Generator/SwiftSDKGenerator+Download.swift

@@ -109,8 +109,6 @@ extension SwiftSDKGenerator {
     }
 
     print("Downloading \(urls.count) Ubuntu packages...")
-    let pathsConfiguration = self.pathsConfiguration
-
     try await inTemporaryDirectory { fs, tmpDir in
       let downloadedFiles = try await self.downloadFiles(from: urls, to: tmpDir, client, engine)
       report(downloadedFiles: downloadedFiles)
@@ -119,8 +117,6 @@ extension SwiftSDKGenerator {
         try await fs.unpack(file: tmpDir.appending(fileName), into: sdkDirPath)
       }
     }
-
-    try createDirectoryIfNeeded(at: pathsConfiguration.toolchainBinDirPath)
   }
 
   func downloadFiles(

Sources/SwiftSDKGenerator/Generator/SwiftSDKGenerator+Entrypoint.swift

@@ -46,11 +46,10 @@ public extension SwiftSDKGenerator {
         }
 
         try await self.createDirectoryIfNeeded(at: pathsConfiguration.artifactsCachePath)
-        try await self.createDirectoryIfNeeded(at: pathsConfiguration.toolchainDirPath)
 
         let swiftSDKProduct = try await recipe.makeSwiftSDK(generator: self, engine: engine, httpClient: client)
 
-        let toolsetJSONPath = try await generateToolsetJSON(recipe: recipe)
+        let toolsetJSONPath = try await self.generateToolsetJSON(recipe: recipe)
 
         try await generateDestinationJSON(
           toolsetPath: toolsetJSONPath,

Sources/SwiftSDKGenerator/Generator/SwiftSDKGenerator+Unpack.swift

@@ -46,6 +46,8 @@ extension SwiftSDKGenerator {
     logGenerationStep("Unpacking and copying Swift binaries for the host triple...")
     let pathsConfiguration = self.pathsConfiguration
 
+    try self.createDirectoryIfNeeded(at: pathsConfiguration.toolchainDirPath)
+
     let excludes =
       unusedDarwinPlatforms.map { "--exclude usr/lib/swift/\($0)" } +
       unusedDarwinPlatforms.map { "--exclude usr/lib/swift_static/\($0)" } +

Sources/SwiftSDKGenerator/Generator/SwiftSDKGenerator.swift

@@ -70,7 +70,7 @@ public actor SwiftSDKGenerator {
     let darwinTriple = Triple("\(cpu)-apple-darwin\(darwinVersion)")
     return Triple("\(cpu)-apple-macos\(darwinTriple._macOSVersion?.description ?? "")")
     #elseif os(Linux)
-    return Triple("\(cpu)-unknown-linux")
+    return Triple("\(cpu)-unknown-linux-gnu")
     #else
     fatalError("Triple detection not implemented for the platform that this generator was built on.")
     #endif

Sources/SwiftSDKGenerator/Serialization/Toolset.swift

@@ -26,7 +26,7 @@ public struct Toolset: Encodable {
 
   /// Root path of the toolset, if present. When filling in ``Toolset.ToolProperties/path``, if a raw path string in
   /// ``DecodedToolset`` is inferred to be relative, it's resolved as absolute path relatively to `rootPath`.
-  let rootPath: String?
+  var rootPath: String?
 
   // MARK: Tools currently known and used by SwiftPM.
 

Sources/SwiftSDKGenerator/SwiftSDKRecipes/LinuxRecipe.swift

@@ -21,9 +21,10 @@ public struct LinuxRecipe: SwiftSDKRecipe {
     case remoteTarball
   }
 
-  public enum HostSwiftSource: Sendable {
+  public enum HostSwiftSource: Sendable, Equatable {
     case localPackage(FilePath)
     case remoteTarball
+    case preinstalled
   }
 
   let mainTargetTriple: Triple
@@ -50,7 +51,8 @@ public struct LinuxRecipe: SwiftSDKRecipe {
     withDocker: Bool,
     fromContainerImage: String?,
     hostSwiftPackagePath: String?,
-    targetSwiftPackagePath: String?
+    targetSwiftPackagePath: String?,
+    includeHostToolchain: Bool = false
   ) throws {
     let versionsConfiguration = try VersionsConfiguration(
       swiftVersion: swiftVersion,
@@ -72,7 +74,9 @@ public struct LinuxRecipe: SwiftSDKRecipe {
       }
     }
     let hostSwiftSource: HostSwiftSource
-    if let hostSwiftPackagePath {
+    if includeHostToolchain == false {
+      hostSwiftSource = .preinstalled
+    } else if let hostSwiftPackagePath {
       hostSwiftSource = .localPackage(FilePath(hostSwiftPackagePath))
     } else {
       hostSwiftSource = .remoteTarball
@@ -105,6 +109,10 @@ public struct LinuxRecipe: SwiftSDKRecipe {
   }
 
   public func applyPlatformOptions(toolset: inout Toolset, targetTriple: Triple) {
+    if self.hostSwiftSource == .preinstalled {
+      toolset.rootPath = nil
+    }
+
     var swiftCompilerOptions = ["-Xlinker", "-R/usr/lib/swift/linux/"]
 
     // Swift 5.9 does not handle the `-use-ld` option properly:
@@ -113,7 +121,10 @@ public struct LinuxRecipe: SwiftSDKRecipe {
       swiftCompilerOptions += ["-Xclang-linker", "--ld-path=ld.lld"]
     } else {
       swiftCompilerOptions.append("-use-ld=lld")
-      toolset.linker = Toolset.ToolProperties(path: "ld.lld")
+
+      if self.hostSwiftSource != .preinstalled {
+        toolset.linker = Toolset.ToolProperties(path: "ld.lld")
+      }
     }
 
     toolset.swiftCompiler = Toolset.ToolProperties(extraCLIOptions: swiftCompilerOptions)
@@ -151,6 +162,48 @@ public struct LinuxRecipe: SwiftSDKRecipe {
       .appending("\(self.linuxDistribution.name.rawValue)-\(self.linuxDistribution.release).sdk")
   }
 
+  func itemsToDownload(from artifacts: DownloadableArtifacts) -> [DownloadableArtifacts.Item] {
+    var items: [DownloadableArtifacts.Item] = []
+    if self.hostSwiftSource != .preinstalled && !self.versionsConfiguration.swiftVersion.hasPrefix("6.0") {
+      items.append(artifacts.hostLLVM)
+    }
+
+    switch self.targetSwiftSource {
+    case .remoteTarball:
+      items.append(artifacts.targetSwift)
+    case .docker, .localPackage: break
+    }
+
+    switch self.hostSwiftSource {
+    case .remoteTarball:
+      items.append(artifacts.hostSwift)
+    case .localPackage: break
+    case .preinstalled: break
+    }
+    return items
+  }
+
+  var hostTriples: [Triple]? {
+    if self.hostSwiftSource == .preinstalled {
+      // Swift 5.9 and 5.10 require `supportedTriples` to be set in info.json.
+      // FIXME: This can be removed once the SDK generator does not support 5.9/5.10 any more.
+      if self.versionsConfiguration.swiftVersion.hasPrefix("5.9")
+          || self.versionsConfiguration.swiftVersion.hasPrefix("5.10") {
+        return [
+          Triple("x86_64-unknown-linux-gnu"),
+          Triple("aarch64-unknown-linux-gnu"),
+          Triple("x86_64-apple-macos"),
+          Triple("arm64-apple-macos"),
+        ]
+      }
+
+      // Swift 6.0 and later can set `supportedTriples` to nil
+      return nil
+    }
+
+    return [self.mainHostTriple]
+  }
+
   public func makeSwiftSDK(
     generator: SwiftSDKGenerator,
     engine: QueryEngine,
@@ -173,26 +226,7 @@ public struct LinuxRecipe: SwiftSDKRecipe {
       client,
       engine,
       downloadableArtifacts: &downloadableArtifacts,
-      itemsToDownload: { artifacts in
-        var items: [DownloadableArtifacts.Item] = []
-
-        if !self.versionsConfiguration.swiftVersion.hasPrefix("6.0") {
-          items.append(artifacts.hostLLVM)
-        }
-
-        switch self.targetSwiftSource {
-        case .remoteTarball:
-          items.append(artifacts.targetSwift)
-        case .docker, .localPackage: break
-        }
-
-        switch self.hostSwiftSource {
-        case .remoteTarball:
-          items.append(artifacts.hostSwift)
-        case .localPackage: break
-        }
-        return items
-      }
+      itemsToDownload: { artifacts in itemsToDownload(from: artifacts) }
     )
 
     if !self.shouldUseDocker {
@@ -219,6 +253,8 @@ public struct LinuxRecipe: SwiftSDKRecipe {
       try await generator.unpackHostSwift(
         hostSwiftPackagePath: downloadableArtifacts.hostSwift.localPath
       )
+    case .preinstalled:
+      break
     }
 
     switch self.targetSwiftSource {
@@ -240,24 +276,26 @@ public struct LinuxRecipe: SwiftSDKRecipe {
       )
     }
 
-    if !self.versionsConfiguration.swiftVersion.hasPrefix("6.0") {
-      try await generator.prepareLLDLinker(engine, llvmArtifact: downloadableArtifacts.hostLLVM)
-    }
-
     try await generator.fixAbsoluteSymlinks(sdkDirPath: sdkDirPath)
 
-    if self.versionsConfiguration.swiftVersion.hasPrefix("5.9") ||
-        self.versionsConfiguration.swiftVersion .hasPrefix("5.10") {
-      try await generator.symlinkClangHeaders()
-    }
+    if self.hostSwiftSource != .preinstalled {
+      if !self.versionsConfiguration.swiftVersion.hasPrefix("6.0") {
+        try await generator.prepareLLDLinker(engine, llvmArtifact: downloadableArtifacts.hostLLVM)
+      }
 
-    let autolinkExtractPath = generator.pathsConfiguration.toolchainBinDirPath.appending("swift-autolink-extract")
+      if self.versionsConfiguration.swiftVersion.hasPrefix("5.9") ||
+          self.versionsConfiguration.swiftVersion .hasPrefix("5.10") {
+        try await generator.symlinkClangHeaders()
+      }
+
+      let autolinkExtractPath = generator.pathsConfiguration.toolchainBinDirPath.appending("swift-autolink-extract")
 
-    if await !generator.doesFileExist(at: autolinkExtractPath) {
-      logGenerationStep("Fixing `swift-autolink-extract` symlink...")
-      try await generator.createSymlink(at: autolinkExtractPath, pointingTo: "swift")
+      if await !generator.doesFileExist(at: autolinkExtractPath) {
+        logGenerationStep("Fixing `swift-autolink-extract` symlink...")
+        try await generator.createSymlink(at: autolinkExtractPath, pointingTo: "swift")
+      }
     }
 
-    return SwiftSDKProduct(sdkDirPath: sdkDirPath, hostTriples: [self.mainHostTriple])
+    return SwiftSDKProduct(sdkDirPath: sdkDirPath, hostTriples: self.hostTriples)
   }
 }