Introduce DestinationsBundle to SPMBuildCore

Author: MaxDesiatov

Sources/Commands/DestinationTools/ListDestinations.swift

@@ -65,64 +65,21 @@ extension DestinationCommand {
                         rootPath: bundlePath
                     )
 
-                    try parsedManifest.printValidatedArtifactIDs(
+                    let destinationsBundle = try parsedManifest.validateDestinationsBundle(
                         bundlePath: bundlePath,
                         fileSystem: fileSystem,
                         observabilityScope: observabilityScope
                     )
-                } catch {
-                    observabilityScope.emit(
-                        .warning(
-                            "Couldn't parse `info.json` manifest of a destination bundle at \(bundlePath): \(error)"
-                        )
-                    )
-                }
-            }
-        }
-    }
-}
-
-private extension ArtifactsArchiveMetadata {
-    func printValidatedArtifactIDs(
-        bundlePath: AbsolutePath,
-        fileSystem: FileSystem,
-        observabilityScope: ObservabilityScope
-    ) throws {
-        for (artifactID, artifactMetadata) in artifacts
-        where artifactMetadata.type == .crossCompilationDestination {
-            for variant in artifactMetadata.variants {
-                let destinationJSONPath = try bundlePath
-                    .appending(RelativePath(validating: variant.path))
-                    .appending(component: "destination.json")
 
-                guard fileSystem.exists(destinationJSONPath) else {
-                    observabilityScope.emit(
-                        .warning(
-                            """
-                            Destination metadata file not found at \(
-                                destinationJSONPath
-                            ) for a variant of artifact \(artifactID)
-                            """
-                        )
-                    )
-
-                    continue
-                }
-
-                do {
-                    _ = try Destination(
-                        fromFile: destinationJSONPath, fileSystem: fileSystem
-                    )
+                    destinationsBundle.artifacts.keys.forEach { print($0) }
                 } catch {
                     observabilityScope.emit(
                         .warning(
-                            "Couldn't parse destination metadata at \(destinationJSONPath): \(error)"
+                            "Couldn't parse `info.json` manifest of a destination bundle at \(bundlePath): \(error)"
                         )
                     )
                 }
             }
-
-            print(artifactID)
         }
     }
 }

Sources/SPMBuildCore/ArtifactsArchiveMetadata.swift

@@ -27,9 +27,9 @@ public struct ArtifactsArchiveMetadata: Equatable {
     }
 
     public struct Artifact: Equatable {
-        public let type: ArtifactType
+        let type: ArtifactType
         let version: String
-        public let variants: [Variant]
+        let variants: [Variant]
 
         public init(type: ArtifactsArchiveMetadata.ArtifactType, version: String, variants: [Variant]) {
             self.type = type
@@ -47,7 +47,7 @@ public struct ArtifactsArchiveMetadata: Equatable {
     }
 
     public struct Variant: Equatable {
-        public let path: String
+        let path: String
         let supportedTriples: [Triple]
 
         public init(path: String, supportedTriples: [Triple]) {
@@ -73,11 +73,13 @@ extension ArtifactsArchiveMetadata {
                 usesLenientParsing: true
             )
 
-            guard version <= Version(1, 1, 0) else {
+            switch (version.major, version.minor) {
+            case (1, 1), (1, 0):
+                return decodedMetadata
+            default:
                 throw StringError("invalid `schemaVersion` of bundle manifest at `\(path)`: \(decodedMetadata.schemaVersion)")
             }
 
-            return decodedMetadata
         } 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
+  CrossCompilationDestinations.swift
   PluginContextSerializer.swift
   PluginInvocation.swift
   PluginMessages.swift

Sources/SPMBuildCore/DestinationsBundle.swift

@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 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 Basics
+import PackageModel
+import TSCBasic
+
+/// Represents an `.artifactbundle` on the filesystem that contains cross-compilation destinations.
+public struct DestinationsBundle {
+    public struct Variant {
+        let metadata: ArtifactsArchiveMetadata.Variant
+        let destination: Destination
+    }
+
+    let path: AbsolutePath
+
+    /// Mapping of artifact IDs to variants available for a corresponding artifact.
+    public fileprivate(set) var artifacts = [String: [Variant]]()
+}
+
+extension ArtifactsArchiveMetadata {
+    public func validateDestinationsBundle(
+        bundlePath: AbsolutePath,
+        fileSystem: FileSystem,
+        observabilityScope: ObservabilityScope
+    ) throws -> DestinationsBundle {
+        var result = DestinationsBundle(path: bundlePath)
+
+        for (artifactID, artifactMetadata) in artifacts
+        where artifactMetadata.type == .crossCompilationDestination {
+            var variants = [DestinationsBundle.Variant]()
+
+            for variant in artifactMetadata.variants {
+                let destinationJSONPath = try bundlePath
+                    .appending(RelativePath(validating: variant.path))
+                    .appending(component: "destination.json")
+
+                guard fileSystem.exists(destinationJSONPath) else {
+                    observabilityScope.emit(
+                        .warning(
+                            """
+                            Destination metadata file not found at \(
+                                destinationJSONPath
+                            ) for a variant of artifact \(artifactID)
+                            """
+                        )
+                    )
+
+                    continue
+                }
+
+                do {
+                    let destination = try Destination(
+                        fromFile: destinationJSONPath, fileSystem: fileSystem
+                    )
+
+                    variants.append(.init(metadata: variant, destination: destination))
+                } catch {
+                    observabilityScope.emit(
+                        .warning(
+                            "Couldn't parse destination metadata at \(destinationJSONPath): \(error)"
+                        )
+                    )
+                }
+            }
+
+            result.artifacts[artifactID] = variants
+        }
+
+        return result
+    }
+}