Integrate trait handling into module loading

# Motivation
In my previous PR I landed the APIs for package traits. We now have to take this information into consideration when evaluating the module graph.

# Modification
This PR implements the various trait features in the module graph loading stage. Including resolving optional dependencies, enabled traits of dependencies, build settings based on traits and passing defines for traits.

This PR also contains an exhaustive test fixtures which we can use to check if all trait functionality is working as expected.

Author: FranzBusch

Sources/PackageDescription/PackageDependency.swift

@@ -53,7 +53,7 @@ extension Package {
         /// The dependencies traits configuration.
         @_spi(ExperimentalTraits)
         @available(_PackageDescription, introduced: 999.0)
-        public let traits: Set<Trait>?
+        public let traits: Set<Trait>
 
         /// The name of the dependency.
         ///
@@ -145,7 +145,7 @@ extension Package {
 
         init(kind: Kind, traits: Set<Trait>?) {
             self.kind = kind
-            self.traits = traits
+            self.traits = traits ?? [.defaults]
         }
 
         convenience init(

Sources/PackageDescription/PackageDescriptionSerializationConversion.swift

@@ -172,7 +172,7 @@ extension Serialization.PackageDependency {
     init(_ dependency: PackageDescription.Package.Dependency) {
         self.kind = .init(dependency.kind)
         self.moduleAliases = dependency.moduleAliases
-        self.traits = Set(dependency.traits?.map { Serialization.PackageDependency.Trait.init($0) } ?? [])
+        self.traits = Set(dependency.traits.map { Serialization.PackageDependency.Trait.init($0) })
     }
 }
 

Sources/PackageGraph/GraphLoadingNode.swift

@@ -29,10 +29,57 @@ public struct GraphLoadingNode: Equatable, Hashable {
     /// The product filter applied to the package.
     public let productFilter: ProductFilter
 
-    public init(identity: PackageIdentity, manifest: Manifest, productFilter: ProductFilter) {
+    /// The enabled traits for this package.
+    public var enabledTraits: Set<String>
+
+    public init(
+        identity: PackageIdentity,
+        manifest: Manifest,
+        productFilter: ProductFilter,
+        enabledTraits: Set<String>
+    ) throws {
         self.identity = identity
         self.manifest = manifest
         self.productFilter = productFilter
+
+        // We are going to calculate which traits are actually enabled for a node here. To do this
+        // we have to check if default traits should be used and then flatten all the enabled traits.
+        for trait in enabledTraits {
+            if trait == "defaults" {
+                // The defaults trait is valid for all packages.
+                continue
+            }
+            // Check if the enabled trait is a valid trait
+            if self.manifest.traits.first(where: { $0.name == trait }) == nil {
+                // The enabled trait is invalid
+                throw ModuleError.invalidTrait(package: identity, trait: trait)
+            }
+        }
+
+        // This the point where we flatten the enabled traits and resolve the recursive traits
+        var recursiveEnabledTraits = enabledTraits
+
+        // Add all default traits
+        if enabledTraits.contains("defaults") {
+            recursiveEnabledTraits.formUnion(self.manifest.traits.lazy.filter { $0.isDefault }.map { $0.name })
+        }
+
+        while true {
+            let flattendEnabledTraits = Set(self.manifest.traits
+                .lazy
+                .filter { recursiveEnabledTraits.contains($0.name) }
+                .map { $0.enabledTraits }
+                .joined()
+            )
+            let newRecursiveEnabledTraits = recursiveEnabledTraits.union(flattendEnabledTraits)
+            if newRecursiveEnabledTraits.count == recursiveEnabledTraits.count {
+                break
+            } else {
+                recursiveEnabledTraits = newRecursiveEnabledTraits
+            }
+        }
+
+        self.enabledTraits = recursiveEnabledTraits
     }
 
     /// Returns the dependencies required by this node.
@@ -51,7 +98,3 @@ extension GraphLoadingNode: CustomStringConvertible {
         }
     }
 }
-
-extension GraphLoadingNode: Identifiable {
-    public var id: PackageIdentity { self.identity }
-}

Sources/PackageGraph/ModulesGraph+Loading.swift

@@ -37,7 +37,6 @@ extension ModulesGraph {
         fileSystem: FileSystem,
         observabilityScope: ObservabilityScope
     ) throws -> ModulesGraph {
-
         let observabilityScope = observabilityScope.makeChildScope(description: "Loading Package Graph")
 
         // Create a map of the manifests, keyed by their identity.
@@ -51,43 +50,64 @@ extension ModulesGraph {
         let rootDependencies = Set(root.dependencies.compactMap{
             manifestMap[$0.identity]?.manifest
         })
-        let rootManifestNodes = root.packages.map { identity, package in
-            GraphLoadingNode(identity: identity, manifest: package.manifest, productFilter: .everything)
+
+        let rootManifestNodes = try root.packages.map { identity, package in
+            // We are going to enable all default traits of the root manifests.
+            // In a future PR we make this overridable by CLI options.
+            let enabledTraits = package.manifest.traits.lazy.filter { $0.isDefault }.map { $0.name }
+            return try GraphLoadingNode(
+                identity: identity,
+                manifest: package.manifest,
+                productFilter: .everything,
+                enabledTraits: Set(enabledTraits)
+            )
         }
-        let rootDependencyNodes = root.dependencies.lazy.compactMap { dependency in
-            manifestMap[dependency.identity].map {
-                GraphLoadingNode(
+        let rootDependencyNodes = try root.dependencies.lazy.compactMap { dependency in
+            try manifestMap[dependency.identity].map {
+                try GraphLoadingNode(
                     identity: dependency.identity,
                     manifest: $0.manifest,
-                    productFilter: dependency.productFilter
+                    productFilter: dependency.productFilter,
+                    enabledTraits: Set(dependency.traits.map { $0.name })
                 )
             }
         }
         let inputManifests = (rootManifestNodes + rootDependencyNodes).map {
-            KeyedPair($0, key: $0.id)
+            KeyedPair($0, key: $0.identity)
         }
 
         // Collect the manifests for which we are going to build packages.
-        var allNodes = [GraphLoadingNode]()
+        var allNodes = OrderedDictionary<PackageIdentity, GraphLoadingNode>()
 
         let nodeSuccessorProvider = { (node: KeyedPair<GraphLoadingNode, PackageIdentity>) in
-            node.item.requiredDependencies.compactMap { dependency in
-                manifestMap[dependency.identity].map { manifest, _ in
-                    KeyedPair(
-                        GraphLoadingNode(
-                            identity: dependency.identity,
-                            manifest: manifest,
-                            productFilter: dependency.productFilter
-                        ),
-                        key: dependency.identity
-                    )
+            return try node.item.requiredDependencies.compactMap { dependency in
+                return try manifestMap[dependency.identity].map { manifest, _ in
+                    // We are going to check the conditionally enabled traits here and enable them if
+                    // required. This checks the current node and then enables the conditional
+                    // dependencies of the dependency node.
+                    let enabledTraits = dependency.traits.filter {
+                        guard let conditionTraits = $0.condition?.traits else {
+                            return true
+                        }
+                        return !conditionTraits.intersection(node.item.enabledTraits).isEmpty
+                    }.map { $0.name }
+
+                    return try KeyedPair(
+                            GraphLoadingNode(
+                                identity: dependency.identity,
+                                manifest: manifest,
+                                productFilter: dependency.productFilter,
+                                enabledTraits: Set(enabledTraits)
+                            ),
+                            key: dependency.identity
+                        )
                 }
             }
         }
 
         // Package dependency cycles feature is gated on tools version 6.0.
         if !root.manifests.allSatisfy({ $1.toolsVersion >= .v6_0 }) {
-            if let cycle = findCycle(inputManifests, successors: nodeSuccessorProvider) {
+            if let cycle = try findCycle(inputManifests, successors: nodeSuccessorProvider) {
                 let path = (cycle.path + cycle.cycle).map(\.item.manifest)
                 observabilityScope.emit(PackageGraphError.dependencyCycleDetected(
                     path: path, cycle: cycle.cycle[0].item.manifest
@@ -104,18 +124,20 @@ extension ModulesGraph {
         }
 
         // Cycles in dependencies don't matter as long as there are no target cycles between packages.
-        depthFirstSearch(
+        try depthFirstSearch(
             inputManifests,
             successors: nodeSuccessorProvider
         ) {
-            allNodes.append($0.item)
-        } onDuplicate: { _,_ in
-            // no de-duplication is required.
+            allNodes[$0.key] = $0.item
+        } onDuplicate: { first, second in
+            // We are unifying the enabled traits on duplicate
+            print(first.item.identity, first.item.enabledTraits, second.item.enabledTraits)
+            allNodes[first.key]?.enabledTraits.formUnion(second.item.enabledTraits)
         }
 
         // Create the packages.
         var manifestToPackage: [Manifest: Package] = [:]
-        for node in allNodes {
+        for node in allNodes.values {
             let nodeObservabilityScope = observabilityScope.makeChildScope(
                 description: "loading package \(node.identity)",
                 metadata: .packageMetadata(identity: node.identity, kind: node.manifest.packageKind)
@@ -139,7 +161,8 @@ extension ModulesGraph {
                     testEntryPointPath: testEntryPointPath,
                     createREPLProduct: manifest.packageKind.isRoot ? createREPLProduct : false,
                     fileSystem: fileSystem,
-                    observabilityScope: nodeObservabilityScope
+                    observabilityScope: nodeObservabilityScope,
+                    enabledTraits: node.enabledTraits
                 )
                 let package = try builder.construct()
                 manifestToPackage[manifest] = package
@@ -162,7 +185,7 @@ extension ModulesGraph {
 
         // Resolve dependencies and create resolved packages.
         let resolvedPackages = try createResolvedPackages(
-            nodes: allNodes,
+            nodes: Array(allNodes.values),
             identityResolver: identityResolver,
             manifestToPackage: manifestToPackage,
             rootManifests: root.manifests,
@@ -273,7 +296,7 @@ private func createResolvedPackages(
 ) throws -> IdentifiableSet<ResolvedPackage> {
 
     // Create package builder objects from the input manifests.
-    let packageBuilders: [ResolvedPackageBuilder] = nodes.compactMap{ node in
+    let packageBuilders: [ResolvedPackageBuilder] = nodes.compactMap { node in
         guard let package = manifestToPackage[node.manifest] else {
             return nil
         }
@@ -283,6 +306,7 @@ private func createResolvedPackages(
         return ResolvedPackageBuilder(
             package,
             productFilter: node.productFilter,
+            enabledTraits: node.enabledTraits,
             isAllowedToVendUnsafeProducts: isAllowedToVendUnsafeProducts,
             allowedToOverride: allowedToOverride,
             platformVersionProvider: platformVersionProvider
@@ -315,8 +339,9 @@ private func createResolvedPackages(
         var dependenciesByNameForTargetDependencyResolution = [String: ResolvedPackageBuilder]()
         var dependencyNamesForTargetDependencyResolutionOnly = [PackageIdentity: String]()
 
-        // Establish the manifest-declared package dependencies.
-        package.manifest.dependenciesRequired(for: packageBuilder.productFilter).forEach { dependency in
+        package.manifest.dependenciesRequired(
+            for: packageBuilder.productFilter
+        ).forEach { dependency in
             let dependencyPackageRef = dependency.packageRef
 
             // Otherwise, look it up by its identity.
@@ -530,6 +555,13 @@ private func createResolvedPackages(
 
             // Establish product dependencies.
             for case .product(let productRef, let conditions) in targetBuilder.target.dependencies {
+                if let traitCondition = conditions.compactMap({ $0.traitCondition }).first {
+                    if packageBuilder.enabledTraits.intersection(traitCondition.traits).isEmpty {
+                        ///  If we land here non of the traits required to enable this depenendcy has been enabled.
+                        continue
+                    }
+                }
+
                 // Find the product in this package's dependency products.
                 // Look it up by ID if module aliasing is used, otherwise by name.
                 let product = lookupByProductIDs ? productDependencyMap[productRef.identity] : productDependencyMap[productRef.name]
@@ -1054,6 +1086,9 @@ private final class ResolvedPackageBuilder: ResolvedBuilder<ResolvedPackage> {
     /// The products in this package.
     var products: [ResolvedProductBuilder] = []
 
+    /// The enabled traits of this package.
+    var enabledTraits: Set<String> = []
+
     /// The dependencies of this package.
     var dependencies: [ResolvedPackageBuilder] = []
 
@@ -1074,12 +1109,14 @@ private final class ResolvedPackageBuilder: ResolvedBuilder<ResolvedPackage> {
     init(
         _ package: Package,
         productFilter: ProductFilter,
+        enabledTraits: Set<String>,
         isAllowedToVendUnsafeProducts: Bool,
         allowedToOverride: Bool,
         platformVersionProvider: PlatformVersionProvider
     ) {
         self.package = package
         self.productFilter = productFilter
+        self.enabledTraits = enabledTraits
         self.isAllowedToVendUnsafeProducts = isAllowedToVendUnsafeProducts
         self.allowedToOverride = allowedToOverride
         self.platformVersionProvider = platformVersionProvider
@@ -1095,6 +1132,7 @@ private final class ResolvedPackageBuilder: ResolvedBuilder<ResolvedPackage> {
             defaultLocalization: self.defaultLocalization,
             supportedPlatforms: self.supportedPlatforms,
             dependencies: self.dependencies.map { $0.package.identity },
+            enabledTraits: self.enabledTraits,
             targets: targets,
             products: products,
             registryMetadata: self.registryMetadata,

Sources/PackageGraph/Resolution/ResolvedPackage.swift

@@ -39,6 +39,9 @@ public struct ResolvedPackage {
     /// The products produced by the package.
     public let products: [ResolvedProduct]
 
+    /// The enabled traits of this package.
+    public let enabledTraits: Set<String>
+
     /// The dependencies of the package.
     public let dependencies: [PackageIdentity]
 
@@ -58,6 +61,7 @@ public struct ResolvedPackage {
         defaultLocalization: String?,
         supportedPlatforms: [SupportedPlatform],
         dependencies: [PackageIdentity],
+        enabledTraits: Set<String>,
         targets: IdentifiableSet<ResolvedModule>,
         products: [ResolvedProduct],
         registryMetadata: RegistryReleaseMetadata?,
@@ -71,6 +75,7 @@ public struct ResolvedPackage {
         self.supportedPlatforms = supportedPlatforms
         self.registryMetadata = registryMetadata
         self.platformVersionProvider = platformVersionProvider
+        self.enabledTraits = enabledTraits
     }
 
     public func getSupportedPlatform(for platform: Platform, usingXCTest: Bool) -> SupportedPlatform {