Commands: add experimental-destination command

Package.swift

@@ -368,6 +368,18 @@ let package = Package(
             exclude: ["CMakeLists.txt", "README.md"]
         ),
 
+        .target(
+            /** Interacts with cross-compilation destinations */
+            name: "CrossCompilationDestinationsTool",
+            dependencies: [
+                .product(name: "ArgumentParser", package: "swift-argument-parser"),
+                "Basics",
+                "CoreCommands",
+                "SPMBuildCore",
+                "PackageModel",
+            ]
+        ),
+
         .target(
             /** Interacts with package collections */
             name: "PackageCollectionsTool",
@@ -417,6 +429,11 @@ let package = Package(
             dependencies: ["CoreCommands"],
             exclude: ["CMakeLists.txt"]
         ),
+        .executableTarget(
+            /** Interacts with cross-compilation destinations */
+            name: "swift-experimental-destination",
+            dependencies: ["Commands", "CrossCompilationDestinationsTool"]
+        ),
         .executableTarget(
             /** Runs package tests */
             name: "swift-test",
@@ -437,7 +454,13 @@ let package = Package(
         .executableTarget(
             /** Multi-tool entry point for SwiftPM. */
             name: "swift-package-manager",
-            dependencies: ["Commands", "Basics", "PackageCollectionsTool", "PackageRegistryTool"]
+            dependencies: [
+                "Basics",
+                "Commands",
+                "CrossCompilationDestinationsTool",
+                "PackageCollectionsTool",
+                "PackageRegistryTool"
+            ]
         ),
         .executableTarget(
             /** Interact with package registry */

Sources/Basics/FileSystem+Extensions.swift

@@ -224,26 +224,65 @@ extension FileSystem {
     }
 }
 
-// MARK: - cross-compilation SDKs
+// MARK: - cross-compilation destinations
 
 private let crossCompilationDestinationsDirectoryName = "destinations"
 
 extension FileSystem {
     /// SwiftPM cross-compilation destinations directory (if exists)
     public var swiftPMCrossCompilationDestinationsDirectory: AbsolutePath {
         get throws {
-            if let path = try self.idiomaticSwiftPMDirectory {
+            if let path = try idiomaticSwiftPMDirectory {
                 return path.appending(component: crossCompilationDestinationsDirectoryName)
             } else {
-                return try self.dotSwiftPMCrossCompilationDestinationsDirectory
+                return try dotSwiftPMCrossCompilationDestinationsDirectory
             }
         }
     }
 
     fileprivate var dotSwiftPMCrossCompilationDestinationsDirectory: AbsolutePath {
         get throws {
-            return try self.dotSwiftPM.appending(component: crossCompilationDestinationsDirectoryName)
+            return try dotSwiftPM.appending(component: crossCompilationDestinationsDirectoryName)
+        }
+    }
+
+    public func getSharedCrossCompilationDestinationsDirectory(
+        explicitDirectory: AbsolutePath?
+    ) throws -> AbsolutePath? {
+        if let explicitDestinationsDirectory = explicitDirectory {
+            // Create the explicit SDKs path if necessary
+            if !exists(explicitDestinationsDirectory) {
+                try createDirectory(explicitDestinationsDirectory, recursive: true)
+            }
+            return explicitDestinationsDirectory
+        } else {
+            return try swiftPMCrossCompilationDestinationsDirectory
+        }
+    }
+
+    public func getOrCreateSwiftPMCrossCompilationDestinationsDirectory() throws -> AbsolutePath {
+        let idiomaticDestinationsDirectory = try swiftPMCrossCompilationDestinationsDirectory
+
+        // Create idiomatic if necessary
+        if !exists(idiomaticDestinationsDirectory) {
+            try createDirectory(idiomaticDestinationsDirectory, recursive: true)
+        }
+        // Create ~/.swiftpm if necessary
+        if !exists(try dotSwiftPM) {
+            try createDirectory(dotSwiftPM, recursive: true)
+        }
+        // Create ~/.swiftpm/destinations symlink if necessary
+        // locking ~/.swiftpm to protect from concurrent access
+        try withLock(on: dotSwiftPM, type: .exclusive) {
+            if !exists(try dotSwiftPMCrossCompilationDestinationsDirectory, followSymlink: false) {
+                try createSymbolicLink(
+                    dotSwiftPMCrossCompilationDestinationsDirectory,
+                    pointingAt: idiomaticDestinationsDirectory,
+                    relative: false
+                )
+            }
         }
+        return idiomaticDestinationsDirectory
     }
 }
 

Sources/CoreCommands/Options.swift

@@ -85,7 +85,7 @@ public struct LocationOptions: ParsableArguments {
     public var customCompileDestination: AbsolutePath?
 
     @Option(name: .customLong("experimental-destinations-path"), help: .hidden, completion: .directory)
-    var crossCompilationDestinationsDirectory: AbsolutePath?
+    public var crossCompilationDestinationsDirectory: AbsolutePath?
 }
 
 public struct CachingOptions: ParsableArguments {

Sources/CoreCommands/SwiftTool.swift

@@ -150,7 +150,7 @@ public final class SwiftTool {
     /// Path to the shared configuration directory
     public let sharedConfigurationDirectory: AbsolutePath?
 
-    /// Path to the cross-compilation SDK directory.
+    /// Path to the cross-compilation destinations directory.
     public let sharedCrossCompilationDestinationsDirectory: AbsolutePath?
 
     /// Cancellator to handle cancellation of outstanding work when handling SIGINT
@@ -299,7 +299,9 @@ public final class SwiftTool {
         self.sharedSecurityDirectory = try getSharedSecurityDirectory(options: self.options, fileSystem: fileSystem)
         self.sharedConfigurationDirectory = try getSharedConfigurationDirectory(options: self.options, fileSystem: fileSystem)
         self.sharedCacheDirectory = try getSharedCacheDirectory(options: self.options, fileSystem: fileSystem)
-        self.sharedCrossCompilationDestinationsDirectory = try getSharedCrossCompilationDestinationsDirectory(options: self.options, fileSystem: fileSystem)
+        self.sharedCrossCompilationDestinationsDirectory = try fileSystem.getSharedCrossCompilationDestinationsDirectory(
+            explicitDirectory: self.options.locations.crossCompilationDestinationsDirectory
+        )
 
         // set global process logging handler
         Process.loggingHandler = { self.observabilityScope.emit(debug: $0) }
@@ -772,21 +774,6 @@ private func getSharedCacheDirectory(options: GlobalOptions, fileSystem: FileSys
     }
 }
 
-private func getSharedCrossCompilationDestinationsDirectory(
-    options: GlobalOptions,
-    fileSystem: FileSystem
-) throws -> AbsolutePath? {
-    if let explicitDestinationsDirectory = options.locations.crossCompilationDestinationsDirectory {
-        // Create the explicit destinations path if necessary
-        if !fileSystem.exists(explicitDestinationsDirectory) {
-            try fileSystem.createDirectory(explicitDestinationsDirectory, recursive: true)
-        }
-        return explicitDestinationsDirectory
-    } else {
-        return try fileSystem.swiftPMCrossCompilationDestinationsDirectory
-    }
-}
-
 extension Basics.Diagnostic {
     static func unsupportedFlag(_ flag: String) -> Self {
         .warning("\(flag) is an *unsupported* option which can be removed at any time; do not rely on it")

Sources/CrossCompilationDestinationsTool/ListDestinations.swift

@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2014-2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import ArgumentParser
+import Basics
+import CoreCommands
+import SPMBuildCore
+import PackageModel
+import TSCBasic
+
+struct ListDestinations: ParsableCommand {
+    static let configuration = CommandConfiguration(
+        commandName: "list",
+        abstract:
+            """
+            Print a list of IDs of available cross-compilation destinations available on the filesystem.
+            """
+    )
+
+    @OptionGroup()
+    var locations: LocationOptions
+
+    func run() throws {
+        let fileSystem = localFileSystem
+        let observabilitySystem = ObservabilitySystem(
+            SwiftToolObservabilityHandler(outputStream: stdoutStream, logLevel: .warning)
+        )
+        let observabilityScope = observabilitySystem.topScope
+
+        guard var destinationsDirectory = try fileSystem.getSharedCrossCompilationDestinationsDirectory(
+            explicitDirectory: locations.crossCompilationDestinationsDirectory
+        ) else {
+            let expectedPath = try fileSystem.swiftPMCrossCompilationDestinationsDirectory
+            throw StringError(
+                "Couldn't find or create a directory where cross-compilation destinations are stored: \(expectedPath)"
+            )
+        }
+
+        if !fileSystem.exists(destinationsDirectory) {
+            destinationsDirectory = try fileSystem.getOrCreateSwiftPMCrossCompilationDestinationsDirectory()
+        }
+
+        // Get absolute paths to available destination bundles.
+        let destinationBundles = try fileSystem.getDirectoryContents(destinationsDirectory).filter {
+            $0.hasSuffix(BinaryTarget.Kind.artifactsArchive.fileExtension)
+        }.map {
+            destinationsDirectory.appending(components: [$0])
+        }
+
+        // Enumerate available bundles and parse manifests for each of them, then validate supplied destinations.
+        for bundlePath in destinationBundles {
+            do {
+                let destinationsBundle = try DestinationsBundle.parseAndValidate(
+                    bundlePath: bundlePath,
+                    fileSystem: fileSystem,
+                    observabilityScope: observabilityScope
+                )
+
+                destinationsBundle.artifacts.keys.forEach { print($0) }
+            } catch {
+                observabilityScope.emit(
+                    .warning(
+                        "Couldn't parse `info.json` manifest of a destination bundle at \(bundlePath): \(error)"
+                    )
+                )
+            }
+        }
+    }
+}

Sources/CrossCompilationDestinationsTool/SwiftDestinationCommand.swift

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2014-2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import ArgumentParser
+import Basics
+
+public struct SwiftDestinationTool: ParsableCommand {
+    public static let configuration = CommandConfiguration(
+        commandName: "experimental-destination",
+        _superCommandName: "swift",
+        abstract: "Perform operations on Swift cross-compilation destinations.",
+        version: SwiftVersion.current.completeDisplayString,
+        subcommands: [
+            ListDestinations.self,
+        ],
+        helpNames: [.short, .long, .customLong("help", withSingleDash: true)])
+
+    public init() {}
+}

Sources/SPMBuildCore/ArtifactsArchiveMetadata.swift

@@ -15,6 +15,7 @@ import PackageModel
 import TSCBasic
 
 import struct TSCUtility.Triple
+import struct TSCUtility.Version
 
 public struct ArtifactsArchiveMetadata: Equatable {
     public let schemaVersion: String
@@ -42,6 +43,7 @@ public struct ArtifactsArchiveMetadata: Equatable {
     // This can also support resource-only artifacts as well. For example, 3d models along with associated textures, or fonts, etc.
     public enum ArtifactType: String, RawRepresentable, Decodable {
         case executable
+        case crossCompilationDestination
     }
 
     public struct Variant: Equatable {
@@ -65,7 +67,19 @@ extension ArtifactsArchiveMetadata {
         do {
             let data: Data = try fileSystem.readFileContents(path)
             let decoder = JSONDecoder.makeWithDefaults()
-            return try decoder.decode(ArtifactsArchiveMetadata.self, from: data)
+            let decodedMetadata = try decoder.decode(ArtifactsArchiveMetadata.self, from: data)
+            let version = try Version(
+                versionString: decodedMetadata.schemaVersion,
+                usesLenientParsing: true
+            )
+
+            switch (version.major, version.minor) {
+            case (1, 1), (1, 0):
+                return decodedMetadata
+            default:
+                throw StringError("invalid `schemaVersion` of bundle manifest at `\(path)`: \(decodedMetadata.schemaVersion)")
+            }
+
         } catch {
             throw StringError("failed parsing ArtifactsArchive info.json at '\(path)': \(error)")
         }

Sources/SPMBuildCore/CMakeLists.txt

@@ -14,6 +14,7 @@ add_library(SPMBuildCore
   BuildSystemCommand.swift
   BuildSystemDelegate.swift
   BuiltTestProduct.swift
+  DestinationsBundle.swift
   PluginContextSerializer.swift
   PluginInvocation.swift
   PluginMessages.swift