Introduce the new binary target changes to the Manifest

Author: hartbit

Sources/Build/BuildPlan.swift

@@ -1219,7 +1219,7 @@ public class BuildPlan {
                     target: target,
                     buildParameters: buildParameters,
                     fileSystem: fileSystem))
-             case is SystemLibraryTarget:
+             case is SystemLibraryTarget, is BinaryTarget:
                  break
              default:
                  fatalError("unhandled \(target.underlyingTarget)")
@@ -1418,6 +1418,9 @@ public class BuildPlan {
                 // Add system target targets to system targets array.
                 case .systemModule:
                     systemModules.append(target)
+                case .binary:
+                    // TODO: Implement
+                    break
                 }
 
             case .product(let product):

Sources/PackageDescription/Target.swift

@@ -8,6 +8,8 @@
  See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 */
 
+import Foundation
+
 /// A target, the basic building block of a Swift package.
 ///
 /// Each target contains a set of source files that are compiled into a module or test suite.
@@ -24,6 +26,8 @@ public final class Target {
         case test
         /// A target that adapts a library on the system to work with Swift packages.
         case system
+        /// A target that references a binary artifact.
+        case _binary = "binary"
     }
 
     /// The different types of a target's dependency on another entity.
@@ -56,6 +60,13 @@ public final class Target {
     /// Do not escape the package root; that is, values like `../Foo` or `/Foo` are invalid.
     public var path: String?
 
+    /// The url of the binary target.
+    public var _url: String? {
+        get { __url }
+        set { __url = newValue }
+    }
+    public var __url: String?
+
     /// The source files in this target.
     ///
     /// If this property is `nil`, all valid source files in the target's path will be included and specified paths are relative to the target path.
@@ -136,11 +147,19 @@ public final class Target {
     }
     private var _linkerSettings: [LinkerSetting]?
 
+    /// The binary target's checksum.
+    public var _checksum: String? {
+        get { __checksum }
+        set { __checksum = newValue }
+    }
+    public var __checksum: String?
+
     /// Construct a target.
     private init(
         name: String,
         dependencies: [Dependency],
         path: String?,
+        _url: String? = nil,
         exclude: [String],
         sources: [String]?,
         resources: [Resource]? = nil,
@@ -151,11 +170,13 @@ public final class Target {
         cSettings: [CSetting]? = nil,
         cxxSettings: [CXXSetting]? = nil,
         swiftSettings: [SwiftSetting]? = nil,
-        linkerSettings: [LinkerSetting]? = nil
+        linkerSettings: [LinkerSetting]? = nil,
+        _checksum: String? = nil
     ) {
         self.name = name
         self.dependencies = dependencies
         self.path = path
+        self.__url = _url
         self.publicHeadersPath = publicHeadersPath
         self.sources = sources
         self._resources = resources
@@ -167,11 +188,44 @@ public final class Target {
         self._cxxSettings = cxxSettings
         self._swiftSettings = swiftSettings
         self._linkerSettings = linkerSettings
+        self.__checksum = _checksum
 
         switch type {
         case .regular, .test:
-            precondition(pkgConfig == nil && providers == nil)
-        case .system: break
+            precondition(
+                _url == nil &&
+                pkgConfig == nil &&
+                providers == nil &&
+                _checksum == nil
+            )
+        case .system:
+            precondition(
+                _url == nil &&
+                dependencies.isEmpty &&
+                exclude.isEmpty &&
+                sources == nil &&
+                resources == nil &&
+                publicHeadersPath == nil &&
+                cSettings == nil &&
+                cxxSettings == nil &&
+                swiftSettings == nil &&
+                linkerSettings == nil &&
+                _checksum == nil
+            )
+        case ._binary:
+            precondition(
+                dependencies.isEmpty &&
+                exclude.isEmpty &&
+                sources == nil &&
+                resources == nil &&
+                publicHeadersPath == nil &&
+                pkgConfig == nil &&
+                providers == nil &&
+                cSettings == nil &&
+                cxxSettings == nil &&
+                swiftSettings == nil &&
+                linkerSettings == nil
+            )
         }
     }
 
@@ -432,13 +486,65 @@ public final class Target {
             pkgConfig: pkgConfig,
             providers: providers)
     }
+
+    /// Create a binary target referencing a remote artifact.
+    ///
+    /// A binary target provides the url to a pre-built binary artifact for the target. Currently only supports
+    /// artifacts for Apple platforms.
+    ///
+    /// - Parameters:
+    ///   - name: The name of the target.
+    ///   - url: The URL to the binary artifact. Should point to a `zip` archive containing a `XCFramework`.
+    ///   - checksum: The checksum of the artifact archive for validation.
+    @available(_PackageDescription, introduced: 5.2)
+    public static func _binaryTarget(
+        name: String,
+        url: String,
+        checksum: String
+    ) -> Target {
+        return Target(
+            name: name,
+            dependencies: [],
+            path: nil,
+            _url: url,
+            exclude: [],
+            sources: nil,
+            publicHeadersPath: nil,
+            type: ._binary,
+            _checksum: checksum)
+    }
+
+    /// Create a binary target referencing an artifact on disk.
+    ///
+    /// A binary target provides the path to a pre-built binary artifact for the target. Currently only supports
+    /// artifacts for Apple platforms.
+    ///
+    /// - Parameters:
+    ///   - name: The name of the target.
+    ///   - path: The path to the binary artifact. Can point directly to a `XCFramework` or a zip containing the
+    ///       `XCFramework`.
+    @available(_PackageDescription, introduced: 5.2)
+    public static func _binaryTarget(
+        name: String,
+        path: String
+    ) -> Target {
+        return Target(
+            name: name,
+            dependencies: [],
+            path: path,
+            exclude: [],
+            sources: nil,
+            publicHeadersPath: nil,
+            type: ._binary)
+    }
   #endif
 }
 
 extension Target: Encodable {
     private enum CodingKeys: CodingKey {
         case name
         case path
+        case url
         case sources
         case resources
         case exclude
@@ -451,13 +557,15 @@ extension Target: Encodable {
         case cxxSettings
         case swiftSettings
         case linkerSettings
+        case checksum
     }
 
     public func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)
 
         try container.encode(name, forKey: .name)
         try container.encode(path, forKey: .path)
+        try container.encode(_url, forKey: .url)
         try container.encode(sources, forKey: .sources)
         try container.encode(_resources, forKey: .resources)
         try container.encode(exclude, forKey: .exclude)
@@ -466,6 +574,7 @@ extension Target: Encodable {
         try container.encode(type, forKey: .type)
         try container.encode(pkgConfig, forKey: .pkgConfig)
         try container.encode(providers, forKey: .providers)
+        try container.encode(_checksum, forKey: .checksum)
 
         if let cSettings = self._cSettings {
             try container.encode(cSettings, forKey: .cSettings)

Sources/PackageLoading/Diagnostics.swift

@@ -69,6 +69,10 @@ extension Diagnostic.Message {
     static func brokenSymlink(_ path: AbsolutePath) -> Diagnostic.Message {
         .warning("ignoring broken symlink \(path)")
     }
+
+    static func missingBinaryTargetArtifact(target: String) -> Diagnostic.Message {
+        .error("missing artifact for binary target '\(target)'")
+    }
 }
 
 public struct ManifestLoadingDiagnostic: DiagnosticData {

Sources/PackageLoading/ManifestLoader.swift

@@ -12,7 +12,7 @@ import TSCBasic
 import PackageModel
 import TSCUtility
 import SPMLLBuild
-import class Foundation.ProcessInfo
+import Foundation
 public typealias FileSystem = TSCBasic.FileSystem
 
 public enum ManifestParseError: Swift.Error {
@@ -28,6 +28,9 @@ public enum ManifestParseError: Swift.Error {
     /// The manifest contains a product that references a target that does not exist.
     case productTargetNotFound(productName: String, targetName: String)
 
+    /// The manifest contains a binary-only product of the wrong type.
+    case invalidBinaryProductType(productName: String)
+
     /// The manifest contains dependencies with the same URL.
     case duplicateDependencyURLs([[PackageDependencyDescription]])
 
@@ -39,6 +42,15 @@ public enum ManifestParseError: Swift.Error {
 
     /// The manifest contains target product dependencies that reference an unknown package.
     case unknownTargetDependencyPackage(targetName: String, packageName: String)
+
+    /// The manifest contains a binary target with an invalid artifact path/url.
+    case invalidBinaryLocation(targetName: String)
+
+    /// The manifest contains a binary target with an invalid arfiact url scheme.
+    case invalidBinaryURLScheme(targetName: String, validSchemes: [String])
+
+    /// The manifest contains a binary target with an invalid artifact extension.
+    case invalidBinaryLocationExtension(targetName: String, validExtensions: [String])
 }
 
 /// Resources required for manifest loading.
@@ -313,6 +325,7 @@ public final class ManifestLoader: ManifestLoaderProtocol {
         if toolsVersion >= .v5_2 {
             try validateDependencyNames(manifest)
             try validateTargetDependencyReferences(manifest)
+            try validateBinaryTargets(manifest)
         }
     }
 
@@ -329,6 +342,12 @@ public final class ManifestLoader: ManifestLoaderProtocol {
                     throw ManifestParseError.productTargetNotFound(productName: product.name, targetName: target)
                 }
             }
+
+            // Check that products that reference only binary targets don't define a type.
+            let areTargetsBinary = product.targets.allSatisfy({ manifest.targetMap[$0]!.type == .binary })
+            if areTargetsBinary && product.type != .library(.automatic) {
+                throw ManifestParseError.invalidBinaryProductType(productName: product.name)
+            }
         }
     }
 
@@ -355,6 +374,32 @@ public final class ManifestLoader: ManifestLoaderProtocol {
         }
     }
 
+    private func validateBinaryTargets(_ manifest: Manifest) throws {
+        // Check that binary targets point to the right file type.
+        for target in manifest.targets where target.type == .binary {
+            guard let location = URL(string: target.url ?? target.path!) else {
+                throw ManifestParseError.invalidBinaryLocation(targetName: target.name)
+            }
+
+            let isRemote = target.url != nil
+            let validSchemes = ["https"]
+            guard !isRemote || (location.scheme.map({ validSchemes.contains($0) }) ?? false) else {
+                throw ManifestParseError.invalidBinaryURLScheme(
+                    targetName: target.name,
+                    validSchemes: validSchemes
+                )
+            }
+
+            let validExtensions = isRemote ? ["zip"] : ["zip", "xcframework"]
+            guard validExtensions.contains(location.pathExtension) else {
+                throw ManifestParseError.invalidBinaryLocationExtension(
+                    targetName: target.name,
+                    validExtensions: validExtensions
+                )
+            }
+        }
+    }
+
     /// Validates that product target dependencies reference an existing package.
     private func validateTargetDependencyReferences(_ manifest: Manifest) throws {
         for target in manifest.targets {

Sources/PackageLoading/PackageDescription4Loader.swift

@@ -99,14 +99,16 @@ extension ManifestBuilder {
             name: try json.get("name"),
             dependencies: dependencies,
             path: json.get("path"),
+            url: json.get("url"),
             exclude: try json.get("exclude"),
             sources: try? json.get("sources"),
             resources: try parseResources(json),
             publicHeadersPath: json.get("publicHeadersPath"),
             type: try .init(v4: json.get("type")),
             pkgConfig: json.get("pkgConfig"),
             providers: providers,
-            settings: try parseBuildSettings(json)
+            settings: try parseBuildSettings(json),
+            checksum: json.get("checksum")
         )
     }
 
@@ -318,6 +320,8 @@ extension TargetDescription.TargetType {
             self = .test
         case "system":
             self = .system
+        case "binary":
+            self = .binary
         default:
             fatalError()
         }