Implement SE-208 System Library Targets

<rdar://problem/39418939> [SR-7434]: Implement SE-208 Package Manager System Library Targets

Author: aciidgh

Sources/PackageDescription4/Package.swift

@@ -243,15 +243,22 @@ extension Package {
 
 extension Target {
     func toJSON() -> JSON {
-        return .dictionary([
+        var dict: [String: JSON] = [
             "name": .string(name),
-            "isTest": .bool(isTest),
+            "type": .string(type.rawValue),
             "publicHeadersPath": publicHeadersPath.map(JSON.string) ?? JSON.null,
             "dependencies": .array(dependencies.map({ $0.toJSON() })),
             "path": path.map(JSON.string) ?? JSON.null,
             "exclude": .array(exclude.map(JSON.string)),
             "sources": sources.map({ JSON.array($0.map(JSON.string)) }) ?? JSON.null,
-        ])
+        ]
+        if let pkgConfig = self.pkgConfig {
+            dict["pkgConfig"] = .string(pkgConfig)
+        }
+        if let providers = self.providers {
+            dict["providers"] = .array(providers.map({ $0.toJSON() }))
+        }
+        return .dictionary(dict)
     }
 }
 

Sources/PackageDescription4/Target.swift

@@ -11,6 +11,13 @@
 /// The description for an individual target.
 public final class Target {
 
+    /// The type of this target.
+    public enum TargetType: String {
+        case regular
+        case test
+        case system
+    }
+
     /// Represents a target's dependency on another entity.
     public enum Dependency {
 
@@ -51,7 +58,9 @@ public final class Target {
     public var exclude: [String]
 
     /// If this is a test target.
-    public var isTest: Bool
+    public var isTest: Bool {
+        return type == .test
+    }
 
     /// Dependencies on other entities inside or outside the package.
     public var dependencies: [Dependency]
@@ -61,6 +70,17 @@ public final class Target {
     /// If a value is not provided, the directory will be set to "include".
     public var publicHeadersPath: String?
 
+    /// The type of target.
+    public let type: TargetType
+
+    /// `pkgconfig` name to use for system library target. If present, swiftpm will try to
+    /// search for <name>.pc file to get the additional flags needed for the
+    /// system target.
+    public let pkgConfig: String?
+
+    /// Providers array for the System library target.
+    public let providers: [SystemPackageProvider]?
+
     /// Construct a target.
     init(
         name: String,
@@ -69,15 +89,25 @@ public final class Target {
         exclude: [String],
         sources: [String]?,
         publicHeadersPath: String?,
-        isTest: Bool
+        type: TargetType,
+        pkgConfig: String? = nil,
+        providers: [SystemPackageProvider]? = nil
     ) {
         self.name = name
         self.dependencies = dependencies
         self.path = path
         self.publicHeadersPath = publicHeadersPath
         self.sources = sources
         self.exclude = exclude
-        self.isTest = isTest
+        self.type = type
+        self.pkgConfig = pkgConfig
+        self.providers = providers
+
+        switch type {
+        case .regular, .test:
+            precondition(pkgConfig == nil && providers == nil)
+        case .system: break
+        }
     }
 
     public static func target(
@@ -95,7 +125,7 @@ public final class Target {
             exclude: exclude,
             sources: sources,
             publicHeadersPath: publicHeadersPath,
-            isTest: false)
+            type: .regular)
     }
 
     public static func testTarget(
@@ -112,8 +142,28 @@ public final class Target {
             exclude: exclude,
             sources: sources,
             publicHeadersPath: nil,
-            isTest: true)
+            type: .test)
+    }
+
+  #if !PACKAGE_DESCRIPTION_4
+    public static func systemLibrary(
+        name: String,
+        path: String? = nil,
+        pkgConfig: String? = nil,
+        providers: [SystemPackageProvider]? = nil
+    ) -> Target {
+        return Target(
+            name: name,
+            dependencies: [],
+            path: path,
+            exclude: [],
+            sources: nil,
+            publicHeadersPath: nil,
+            type: .system,
+            pkgConfig: pkgConfig,
+            providers: providers)
     }
+  #endif
 }
 
 extension Target.Dependency {

Sources/PackageGraph/PackageGraphLoader.swift

@@ -252,10 +252,15 @@ private func createResolvedPackages(
         // The diagnostics location for this package.
         let diagnosticLocation = { PackageLocation.Local(name: package.name, packagePath: package.path) }
 
-        // Get all the system module dependencies in this package.
-        let systemModulesDeps = packageBuilder.dependencies
+        // Get all implicit system library dependencies in this package.
+        let implicitSystemTargetDeps = packageBuilder.dependencies
             .flatMap({ $0.targets })
-            .filter({ $0.target.type == .systemModule })
+            .filter({
+                if case let systemLibrary as SystemLibraryTarget = $0.target {
+                    return systemLibrary.isImplicit
+                }
+                return false
+            })
 
         // Get all the products from dependencies of this package.
         let productDependencies = packageBuilder.dependencies
@@ -273,7 +278,7 @@ private func createResolvedPackages(
             allTargetNames.insert(targetName)
 
             // Directly add all the system module dependencies.
-            targetBuilder.dependencies += systemModulesDeps
+            targetBuilder.dependencies += implicitSystemTargetDeps
 
             // Establish product dependencies based on the type of manifest.
             switch package.manifest.package {

Sources/PackageLoading/Diagnostics.swift

@@ -76,4 +76,41 @@ public enum PackageBuilderDiagnostics {
 
         public let product: Product
     }
+
+    struct SystemPackageDeprecatedDiagnostic: DiagnosticData {
+        static let id = DiagnosticID(
+            type: SystemPackageDeprecatedDiagnostic.self,
+            name: "org.swift.diags.pkg-builder.sys-pkg-deprecated",
+            defaultBehavior: .warning,
+            description: {
+                $0 <<< "system packages are deprecated;"
+                $0 <<< "use system library targets instead"
+            }
+        )
+    }
+
+    struct SystemPackageDeclaresTargetsDiagnostic: DiagnosticData {
+        static let id = DiagnosticID(
+            type: SystemPackageDeclaresTargetsDiagnostic.self,
+            name: "org.swift.diags.pkg-builder.sys-pkg-decl-targets",
+            defaultBehavior: .warning,
+            description: {
+                $0 <<< "Ignoring declared target(s)" <<< { "'\($0.targets.joined(separator: ", "))'" } <<< "in the system package"
+            }
+        )
+
+        let targets: [String]
+    }
+
+    struct SystemPackageProductValidationDiagnostic: DiagnosticData {
+        static let id = DiagnosticID(
+            type: SystemPackageProductValidationDiagnostic.self,
+            name: "org.swift.diags.pkg-builder.sys-pkg-product-validatoin",
+            description: {
+                $0 <<< "system library product" <<< { $0.product } <<< "shouldn't have a type and contain only one target"
+            }
+        )
+
+        let product: String
+    }
 }

Sources/PackageLoading/PackageBuilder.swift

@@ -408,12 +408,32 @@ public final class PackageBuilder {
         // Check for a modulemap file, which indicates a system target.
         let moduleMapPath = packagePath.appending(component: moduleMapFilename)
         if fileSystem.isFile(moduleMapPath) {
+
+            // Warn about any declared targets.
+            let targets = manifest.package.targets
+            if !targets.isEmpty {
+                diagnostics.emit(
+                    data: PackageBuilderDiagnostics.SystemPackageDeclaresTargetsDiagnostic(targets: targets.map({ $0.name })),
+                    location: PackageLocation.Local(name: manifest.name, packagePath: packagePath)
+                )
+            }
+
+            // Emit deprecation notice.
+            switch manifest.manifestVersion {
+            case .v3, .v4: break
+            case .v4_2:
+                diagnostics.emit(
+                    data: PackageBuilderDiagnostics.SystemPackageDeprecatedDiagnostic(),
+                    location: PackageLocation.Local(name: manifest.name, packagePath: packagePath)
+                )
+            }
+
             // Package contains a modulemap at the top level, so we assuming
             // it's a system library target.
             return [
                 SystemLibraryTarget(
                     name: manifest.name,
-                    path: packagePath,
+                    path: packagePath, isImplicit: true,
                     pkgConfig: manifest.package.pkgConfig,
                     providers: manifest.package.providers)
             ]
@@ -493,7 +513,7 @@ public final class PackageBuilder {
         let potentialTargets: [PotentialModule]
         potentialTargets = try manifest.package.targets.map({ target in
             let path = try findPath(for: target)
-            return PotentialModule(name: target.name, path: path, isTest: target.isTest)
+            return PotentialModule(name: target.name, path: path, type: target.type)
         })
         return try createModules(potentialTargets)
     }
@@ -543,9 +563,9 @@ public final class PackageBuilder {
         if potentialModulePaths.isEmpty {
             // There are no directories that look like targets, so try to create a target for the source directory
             // itself (with the name coming from the name in the manifest).
-            potentialModules = [PotentialModule(name: manifest.name, path: srcDir, isTest: false)]
+            potentialModules = [PotentialModule(name: manifest.name, path: srcDir, type: .regular)]
         } else {
-            potentialModules = potentialModulePaths.map({ PotentialModule(name: $0.basename, path: $0, isTest: false) })
+            potentialModules = potentialModulePaths.map({ PotentialModule(name: $0.basename, path: $0, type: .regular) })
         }
         return try createModules(potentialModules + potentialTestModules())
     }
@@ -691,6 +711,19 @@ public final class PackageBuilder {
         productDeps: [(name: String, package: String?)]
     ) throws -> Target? {
 
+        // Create system library target.
+        if potentialModule.type == .system {
+            let moduleMapPath = potentialModule.path.appending(component: moduleMapFilename)
+            guard fileSystem.isFile(moduleMapPath) else {
+                return nil
+            }
+            return SystemLibraryTarget(
+                    name: potentialModule.name,
+                    path: potentialModule.path, isImplicit: false,
+                    pkgConfig: manifestTarget?.pkgConfig,
+                    providers: manifestTarget?.providers)
+        }
+
         // Compute the path to public headers directory.
         let publicHeaderComponent = manifestTarget?.publicHeadersPath ?? ClangTarget.defaultPublicHeadersComponent
         let publicHeadersPath = potentialModule.path.appending(RelativePath(publicHeaderComponent))
@@ -882,7 +915,7 @@ public final class PackageBuilder {
 
         return testsDirContents
             .filter(shouldConsiderDirectory)
-            .map({ PotentialModule(name: $0.basename, path: $0, isTest: true) })
+            .map({ PotentialModule(name: $0.basename, path: $0, type: .test) })
     }
 
     /// Find the linux main file for the package.
@@ -1054,6 +1087,19 @@ public final class PackageBuilder {
                     case nil: type = .library(.automatic)
                     }
                     let targets = try modulesFrom(targetNames: p.targets, product: p.name)
+
+                    // Peform special validations if this product is exporting
+                    // a system library target.
+                    if targets.contains(where: { $0 is SystemLibraryTarget }) {
+                        if type != .library(.automatic) || targets.count != 1 {
+                            diagnostics.emit(
+                                data: PackageBuilderDiagnostics.SystemPackageProductValidationDiagnostic(product: p.name),
+                                location: PackageLocation.Local(name: manifest.name, packagePath: packagePath)
+                            )
+                            continue
+                        }
+                    }
+
                     append(Product(name: p.name, type: type, targets: targets))
                 default:
                     fatalError("Unreachable")
@@ -1076,12 +1122,17 @@ private struct PotentialModule: Hashable {
     let path: AbsolutePath
 
     /// If this should be a test target.
-    let isTest: Bool
+    var isTest: Bool {
+        return type == .test
+    }
+
+    /// The target type.
+    let type: PackageDescription4.Target.TargetType
 
     /// The base prefix for the test target, used to associate with the target it tests.
     public var basename: String {
         guard isTest else {
-            fatalError("\(type(of: self)) should be a test target to access basename.")
+            fatalError("\(Swift.type(of: self)) should be a test target to access basename.")
         }
         precondition(name.hasSuffix(Target.testModuleNameSuffix))
         let endIndex = name.index(name.endIndex, offsetBy: -Target.testModuleNameSuffix.count)