Optional xcframework support for Linux

Fixtures/Miscellaneous/LibraryEvolutionLinuxXCF/SwiftFramework/Package.swift

@@ -0,0 +1,16 @@
+// swift-tools-version:6.0
+
+import PackageDescription
+
+let package = Package(
+ name: "SwiftFramework",
+ products: [
+ .library(name: "SwiftFramework", type: .dynamic, targets: ["SwiftFramework"]),
+ ],
+ targets: [
+ .target(
+ name: "SwiftFramework",
+ swiftSettings: [.unsafeFlags(["-enable-library-evolution"])]
+ ),
+ ]
+)

Fixtures/Miscellaneous/LibraryEvolutionLinuxXCF/SwiftFramework/Sources/SwiftFramework/SwiftFramework.swift

@@ -0,0 +1,8 @@
+public enum SwiftFrameworkWithEvolution
+{
+ case v1
+ case v2
+
+ public
+ static var latest:Self { .v2 }
+}

Fixtures/Miscellaneous/LibraryEvolutionLinuxXCF/TestBinary/Package.swift

@@ -0,0 +1,17 @@
+// swift-tools-version:6.0
+
+import PackageDescription
+
+let package = Package(name: "TestBinary",
+ products: [
+ .executable(name: "TestBinary", targets: ["TestBinary"]),
+ ],
+ targets: [
+ .binaryTarget(name: "SwiftFramework", path: "SwiftFramework.xcframework"),
+ .executableTarget(name: "TestBinary",
+ dependencies: [
+ .target(name: "SwiftFramework"),
+ ]
+ ),
+ ]
+)

Fixtures/Miscellaneous/LibraryEvolutionLinuxXCF/TestBinary/Sources/TestBinary/Main.swift

@@ -0,0 +1,3 @@
+import SwiftFramework
+
+print("Latest Framework with LibraryEvolution version: \(SwiftFrameworkWithEvolution.latest)")

Sources/Build/BuildPlan/BuildPlan+Clang.swift

@@ -65,7 +65,11 @@ extension BuildPlan {
  clangTarget.libraryBinaryPaths.insert(library.libraryPath)
  }
  case .xcframework:
- let libraries = try self.parseXCFramework(for: target, triple: clangTarget.buildParameters.triple)
+ let libraries = try self.parseXCFramework(
+ for: target,
+ triple: clangTarget.buildParameters.triple,
+ enableXCFrameworksOnLinux: clangTarget.buildParameters.enableXCFrameworksOnLinux
+ )
  for library in libraries {
  library.headersPaths.forEach {
  clangTarget.additionalFlags += ["-I", $0.pathString]

Sources/Build/BuildPlan/BuildPlan+Product.swift

@@ -298,7 +298,8 @@ extension BuildPlan {
  case .xcframework:
  let libraries = try self.parseXCFramework(
  for: binaryTarget,
- triple: productDescription.buildParameters.triple
+ triple: productDescription.buildParameters.triple,
+ enableXCFrameworksOnLinux: productDescription.buildParameters.enableXCFrameworksOnLinux
  )
  for library in libraries {
  libraryBinaryPaths.insert(library.libraryPath)

Sources/Build/BuildPlan/BuildPlan+Swift.swift

@@ -61,7 +61,11 @@ extension BuildPlan {
  swiftTarget.libraryBinaryPaths.insert(library.libraryPath)
  }
  case .xcframework:
- let libraries = try self.parseXCFramework(for: target, triple: swiftTarget.buildParameters.triple)
+ let libraries = try self.parseXCFramework(
+ for: target,
+ triple: swiftTarget.buildParameters.triple,
+ enableXCFrameworksOnLinux: swiftTarget.buildParameters.enableXCFrameworksOnLinux
+ )
  for library in libraries {
  library.headersPaths.forEach {
  swiftTarget.additionalFlags += ["-I", $0.pathString, "-Xcc", "-I", "-Xcc", $0.pathString]

Sources/Build/BuildPlan/BuildPlan.swift

@@ -653,9 +653,12 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
  }
 
  /// Extracts the library information from an XCFramework.
- func parseXCFramework(for binaryTarget: BinaryModule, triple: Basics.Triple) throws -> [LibraryInfo] {
+ func parseXCFramework(for binaryTarget: BinaryModule, triple: Basics.Triple, enableXCFrameworksOnLinux: Bool) throws -> [LibraryInfo] {
  try self.externalLibrariesCache.memoize(key: binaryTarget) {
- try binaryTarget.parseXCFrameworks(for: triple, fileSystem: self.fileSystem)
+ if !enableXCFrameworksOnLinux && triple.os == .linux {
+ return []
+ }
+ return try binaryTarget.parseXCFrameworks(for: triple, fileSystem: self.fileSystem)
  }
  }
 

Sources/CoreCommands/Options.swift

@@ -515,6 +515,13 @@ public struct BuildOptions: ParsableArguments {
  @Flag(name: .customLong("experimental-prepare-for-indexing-no-lazy"), help: .hidden)
  var prepareForIndexingNoLazy: Bool = false
 
+ /// Hidden option to allow XCFrameworks on Linux
+ @Flag(
+ name: .customLong("experimental-xcframeworks-on-linux"),
+ help: .hidden
+ )
+ public var enableXCFrameworksOnLinux: Bool = false
+
  /// Whether to enable generation of `.swiftinterface`s alongside `.swiftmodule`s.
  @Flag(name: .customLong("enable-parseable-module-interfaces"))
  public var shouldEnableParseableModuleInterfaces: Bool = false

Sources/CoreCommands/SwiftCommandState.swift

@@ -920,6 +920,7 @@ public final class SwiftCommandState {
  sanitizers: options.build.enabledSanitizers,
  indexStoreMode: options.build.indexStoreMode.buildParameter,
  prepareForIndexing: prepareForIndexingMode,
+ enableXCFrameworksOnLinux: options.build.enableXCFrameworksOnLinux,
  debuggingParameters: .init(
  debugInfoFormat: self.options.build.debugInfoFormat.buildParameter,
  triple: triple,

Sources/SPMBuildCore/BinaryTarget+Extensions.swift

@@ -45,7 +45,7 @@ extension BinaryModule {
  let metadata = try XCFrameworkMetadata.parse(fileSystem: fileSystem, rootPath: self.artifactPath)
  // Filter the libraries that are relevant to the triple.
  guard let library = metadata.libraries.first(where: {
- $0.platform == triple.os?.asXCFrameworkPlatformString &&
+ $0.platform == triple.asXCFrameworkPlatformString &&
  $0.variant == triple.environment?.asXCFrameworkPlatformVariantString &&
  $0.architectures.contains(triple.archName)
  }) else {
@@ -117,13 +117,11 @@ extension Triple {
  return self
  }
  }
-}
 
-extension Triple.OS {
  /// Returns a representation of the receiver that can be compared with platform strings declared in an XCFramework.
  fileprivate var asXCFrameworkPlatformString: String? {
- switch self {
- case .darwin, .linux, .wasi, .win32, .openbsd, .freebsd, .noneOS:
+ switch self.os {
+ case .darwin, .wasi, .win32, .openbsd, .freebsd, .noneOS:
  return nil // XCFrameworks do not support any of these platforms today.
  case .macosx:
  return "macos"
@@ -133,6 +131,11 @@ extension Triple.OS {
  return "tvos"
  case .watchos:
  return "watchos"
+ case .linux:
+ if environment == .android {
+ return nil
+ }
+ return "linux" // Only if --experimental-xcframeworks-on-linux has been passed
  default:
  return nil // XCFrameworks do not support any of these platforms today.
  }

Sources/SPMBuildCore/BuildParameters/BuildParameters.swift

@@ -132,6 +132,9 @@ public struct BuildParameters: Encodable {
  /// Do minimal build to prepare for indexing
  public var prepareForIndexing: PrepareForIndexingMode
 
+ /// Support Experimental XCF on Linux
+ public var enableXCFrameworksOnLinux: Bool
+
  /// Build parameters related to debugging.
  public var debuggingParameters: Debugging
 
@@ -166,6 +169,7 @@ public struct BuildParameters: Encodable {
  indexStoreMode: IndexStoreMode = .auto,
  shouldSkipBuilding: Bool = false,
  prepareForIndexing: PrepareForIndexingMode = .off,
+ enableXCFrameworksOnLinux: Bool = false,
  debuggingParameters: Debugging? = nil,
  driverParameters: Driver = .init(),
  linkingParameters: Linking = .init(),
@@ -229,6 +233,7 @@ public struct BuildParameters: Encodable {
  self.indexStoreMode = indexStoreMode
  self.shouldSkipBuilding = shouldSkipBuilding
  self.prepareForIndexing = prepareForIndexing
+ self.enableXCFrameworksOnLinux = enableXCFrameworksOnLinux
  self.driverParameters = driverParameters
  self.linkingParameters = linkingParameters
  self.outputParameters = outputParameters

Sources/_InternalBuildTestSupport/MockBuildTestHelper.swift

@@ -66,6 +66,7 @@ public func mockBuildPlan(
  commonFlags: PackageModel.BuildFlags = .init(),
  indexStoreMode: BuildParameters.IndexStoreMode = .off,
  omitFramePointers: Bool? = nil,
+ enableXCFrameworksOnLinux: Bool = false,
  driverParameters: BuildParameters.Driver = .init(),
  linkingParameters: BuildParameters.Linking = .init(),
  targetSanitizers: EnabledSanitizers = .init(),
@@ -105,7 +106,8 @@ public func mockBuildPlan(
  toolchain: toolchain,
  flags: commonFlags,
  triple: inferredTriple,
- indexStoreMode: indexStoreMode
+ indexStoreMode: indexStoreMode,
+ enableXCFrameworksOnLinux: enableXCFrameworksOnLinux
  )
  destinationParameters.debuggingParameters = commonDebuggingParameters
  destinationParameters.driverParameters = driverParameters
@@ -119,7 +121,8 @@ public func mockBuildPlan(
  toolchain: toolchain,
  flags: commonFlags,
  triple: inferredTriple,
- indexStoreMode: indexStoreMode
+ indexStoreMode: indexStoreMode,
+ enableXCFrameworksOnLinux: enableXCFrameworksOnLinux
  )
  hostParameters.debuggingParameters = commonDebuggingParameters
  hostParameters.driverParameters = driverParameters

Sources/_InternalTestSupport/MockBuildTestHelper.swift

@@ -91,6 +91,7 @@ public func mockBuildParameters(
  linkerDeadStrip: Bool = true,
  linkTimeOptimizationMode: BuildParameters.LinkTimeOptimizationMode? = nil,
  omitFramePointers: Bool? = nil,
+ enableXCFrameworksOnLinux: Bool = false,
  prepareForIndexing: BuildParameters.PrepareForIndexingMode = .off
 ) -> BuildParameters {
  try! BuildParameters(
@@ -105,6 +106,7 @@ public func mockBuildParameters(
  workers: 3,
  indexStoreMode: indexStoreMode,
  prepareForIndexing: prepareForIndexing,
+ enableXCFrameworksOnLinux: enableXCFrameworksOnLinux,
  debuggingParameters: .init(
  triple: triple,
  shouldEnableDebuggingEntitlement: config == .debug,

Tests/BuildTests/BuildPlanTests.swift

@@ -6807,6 +6807,114 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
  XCTAssertMatch(dynamicLibraryPathExtension, "dylib")
  }
 
+ func testXCFrameworkBinaryTargetsLinux(platform: String = "linux", arch: String, targetTriple: Basics.Triple) async throws {
+ let Pkg: AbsolutePath = "/Pkg"
+
+ let fs = InMemoryFileSystem(
+ emptyFiles:
+ Pkg.appending(components: "Sources", "exe", "main.swift").pathString,
+ Pkg.appending(components: "Sources", "Library", "Library.swift").pathString
+ )
+
+ try! fs.createDirectory("/Pkg/Framework.xcframework", recursive: true)
+ try! fs.writeFileContents(
+ "/Pkg/Framework.xcframework/Info.plist",
+ string: """
+ <?xml version="1.0" encoding="UTF-8"?>
+ <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+ <plist version="1.0">
+ <dict>
+ <key>AvailableLibraries</key>
+ <array>
+ <dict>
+ <key>LibraryIdentifier</key>
+ <string>\(platform)-\(arch)</string>
+ <key>LibraryPath</key>
+ <string>Framework.framework</string>
+ <key>SupportedArchitectures</key>
+ <array>
+ <string>\(arch)</string>
+ </array>
+ <key>SupportedPlatform</key>
+ <string>\(platform)</string>
+ </dict>
+ </array>
+ <key>CFBundlePackageType</key>
+ <string>XFWK</string>
+ <key>XCFrameworkFormatVersion</key>
+ <string>1.0</string>
+ </dict>
+ </plist>
+ """
+ )
+
+ let observability = ObservabilitySystem.makeForTesting()
+
+ let graph = try loadModulesGraph(
+ fileSystem: fs,
+ manifests: [
+ Manifest.createRootManifest(
+ displayName: "Pkg",
+ path: .init(validating: Pkg.pathString),
+ products: [
+ ProductDescription(name: "exe", type: .executable, targets: ["exe"]),
+ ProductDescription(name: "Library", type: .library(.dynamic), targets: ["Library"]),
+ ],
+ targets: [
+ TargetDescription(name: "exe", dependencies: ["Library"]),
+ TargetDescription(name: "Library", dependencies: ["Framework"]),
+ TargetDescription(name: "Framework", path: "Framework.xcframework", type: .binary),
+ ]
+ ),
+ ],
+ binaryArtifacts: [
+ .plain("pkg"): [
+ "Framework": .init(kind: .xcframework, originURL: nil, path: "/Pkg/Framework.xcframework"),
+ ],
+ ],
+ observabilityScope: observability.topScope
+ )
+ XCTAssertNoDiagnostics(observability.diagnostics)
+
+ let result = try await BuildPlanResult(plan: mockBuildPlan(
+ triple: targetTriple,
+ graph: graph,
+ enableXCFrameworksOnLinux: true,
+ fileSystem: fs,
+ observabilityScope: observability.topScope
+ ))
+ XCTAssertNoDiagnostics(observability.diagnostics)
+
+ result.checkProductsCount(2)
+ result.checkTargetsCount(2)
+
+ let buildPath = result.plan.productsBuildPath
+
+ let libraryBasicArguments = try result.moduleBuildDescription(for: "Library").swift().compileArguments()
+ XCTAssertMatch(
+ libraryBasicArguments,
+ [.anySequence, "-I", "\(Pkg.appending(components: "Framework.xcframework", "\(platform)-\(arch)"))", .anySequence]
+ )
+
+ let libraryLinkArguments = try result.buildProduct(for: "Library").linkArguments()
+ XCTAssertMatch(libraryLinkArguments, [.anySequence, "-L", "\(buildPath)", .anySequence])
+
+ let exeCompileArguments = try result.moduleBuildDescription(for: "exe").swift().compileArguments()
+ XCTAssertMatch(
+ exeCompileArguments,
+ [.anySequence, "-I", "\(Pkg.appending(components: "Framework.xcframework", "\(platform)-\(arch)"))", .anySequence]
+ )
+
+ let exeLinkArguments = try result.buildProduct(for: "exe").linkArguments()
+ XCTAssertMatch(exeLinkArguments, [.anySequence, "-L", "\(buildPath)", .anySequence])
+
+ let executablePathExtension = try result.buildProduct(for: "exe").binaryPath.extension ?? ""
+ XCTAssertMatch(executablePathExtension, "")
+
+ let dynamicLibraryPathExtension = try result.buildProduct(for: "Library").binaryPath.extension
+ XCTAssertMatch(dynamicLibraryPathExtension, "so")
+ }
+
  func testXCFrameworkBinaryTargets() async throws {
  try await self.testXCFrameworkBinaryTargets(platform: "macos", arch: "x86_64", targetTriple: .x86_64MacOS)
 
@@ -6815,6 +6923,12 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
 
  let arm64eTriple = try Basics.Triple("arm64e-apple-macosx")
  try await self.testXCFrameworkBinaryTargets(platform: "macos", arch: "arm64e", targetTriple: arm64eTriple)
+
+ let x86_64Linux = try Basics.Triple("x86_64-unknown-linux-gnu")
+ try await self.testXCFrameworkBinaryTargetsLinux(arch: "x86_64", targetTriple: x86_64Linux)
+
+ let aarch64Linux = try Basics.Triple("aarch64-unknown-linux-gnu")
+ try await self.testXCFrameworkBinaryTargetsLinux(arch: "aarch64", targetTriple: aarch64Linux)
  }
 
  func testArtifactsArchiveBinaryTargets(