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)