Add support for traits in manifest code generation (#9173)

Add support for traits in manifest code generation

### Motivation:

Currently, manifest code generation does not support the trait feature.
This results in incomplete or incorrect generated manifests whenever
traits are involved. To ensure manifests accurately reflect the package
definition, trait-related constructs need to be supported.

### Modifications:

This patch implements trait support in manifest code generation.
Specifically, it adds support for three syntactic forms:

- Defining package traits
- Declaring trait conditions on package dependencies
- Declaring trait conditions on target dependencies

### Result:

Manifest code generation will correctly emit trait-related constructs.
Packages that define traits, or that depend on other packages/targets
conditionally based on traits, will now be represented accurately in the
generated manifest.

Author: omochi

Sources/PackageModel/Manifest/PackageDependencyDescription.swift

@@ -24,7 +24,7 @@ public enum PackageDependency: Equatable, Hashable, Sendable {
         /// A condition that limits the application of a dependencies trait.
         package struct Condition: Hashable, Sendable, Codable {
             /// The set of traits of this package that enable the dependency's trait.
-            private let traits: Set<String>?
+            package let traits: Set<String>?
 
             public init(traits: Set<String>?) {
                 self.traits = traits
@@ -73,6 +73,11 @@ public enum PackageDependency: Equatable, Hashable, Sendable {
                 condition: condition
             )
         }
+
+        // represents `.defaults`
+        public var isDefaultsCase: Bool {
+            name == "default" && condition == nil
+        }
     }
 
     case fileSystem(FileSystem)

Sources/PackageModel/ManifestSourceGeneration.swift

@@ -102,6 +102,11 @@ fileprivate extension SourceCodeFragment {
             params.append(SourceCodeFragment(key: "products", subnodes: nodes))
         }
 
+        if !manifest.traits.isEmpty {
+            let nodes = manifest.traits.map { SourceCodeFragment(from: $0) }
+            params.append(SourceCodeFragment(key: "traits", subnodes: nodes))
+        }
+
         if !manifest.dependencies.isEmpty {
             let nodes = manifest.dependencies.map{ SourceCodeFragment(from: $0, pathAnchor: packageDirectory) }
             params.append(SourceCodeFragment(key: "dependencies", subnodes: nodes))
@@ -192,9 +197,68 @@ fileprivate extension SourceCodeFragment {
                 params.append(SourceCodeFragment("\"\(range.lowerBound)\"..<\"\(range.upperBound)\""))
             }
         }
+
+        if let traits = dependency.traits {
+            // If only `.defaults` is specified, do not output `traits:` .
+            // This is because `traits:` is not available in toolchains earlier than 6.1.
+            let isDefault = traits.count == 1 &&
+                traits.allSatisfy(\.isDefaultsCase)
+
+            if !isDefault {
+                let traits = traits.sorted { a, b in
+                    PackageDependency.Trait.precedes(a, b)
+                }
+                params.append(
+                    SourceCodeFragment(
+                        key: "traits",
+                        subnodes: traits.map { SourceCodeFragment(from: $0) }
+                    )
+                )
+            }
+        }
+
         self.init(enum: "package", subnodes: params)
     }
-    
+
+    init(from trait: PackageDependency.Trait) {
+        if trait.isDefaultsCase {
+            self.init(enum: "defaults")
+            return
+        }
+
+        guard let condition = trait.condition else {
+            self.init(string: trait.name)
+            return
+        }
+
+        let conditionNode = SourceCodeFragment(
+            key: "condition",
+            subnode: SourceCodeFragment(from: condition)
+        )
+
+        self.init(enum: "trait", subnodes: [
+            SourceCodeFragment(key: "name", string: trait.name),
+            conditionNode
+        ])
+    }
+
+    init(from condition: PackageDependency.Trait.Condition) {
+        var params: [SourceCodeFragment] = []
+
+        if let trait = condition.traits {
+            params.append(
+                SourceCodeFragment(
+                    key: "traits",
+                    subnodes: trait.sorted().map {
+                        SourceCodeFragment(string: $0)
+                    }
+                )
+            )
+        }
+
+        self.init(enum: "when", subnodes: params)
+    }
+
     /// Instantiates a SourceCodeFragment to represent a single product. If there's a custom product generator, it gets
     /// a chance to generate the source code fragments before checking the default types.
     init(from product: ProductDescription, customProductTypeSourceGenerator: ManifestCustomProductTypeSourceGenerator?, toolsVersion: ToolsVersion) rethrows {
@@ -261,6 +325,41 @@ fileprivate extension SourceCodeFragment {
         }
     }
 
+    init(from trait: TraitDescription) {
+        let enabledTraitsNode = SourceCodeFragment(
+            key: "enabledTraits",
+            subnodes: trait.enabledTraits.sorted().map {
+                SourceCodeFragment(string: $0)
+            }
+        )
+
+        if trait.isDefault {
+            self.init(enum: "default", subnodes: [enabledTraitsNode])
+            return
+        }
+
+        if trait.description == nil, trait.enabledTraits.isEmpty {
+            self.init(string: trait.name)
+            return
+        }
+
+        var params: [SourceCodeFragment] = [
+            SourceCodeFragment(key: "name", string: trait.name)
+        ]
+
+        if let description = trait.description {
+            params.append(
+                SourceCodeFragment(key: "description", string: description)
+            )
+        }
+
+        if !trait.enabledTraits.isEmpty {
+            params.append(enabledTraitsNode)
+        }
+
+        self.init(enum: "trait", subnodes: params)
+    }
+
     /// Instantiates a SourceCodeFragment to represent a single target.
     init(from target: TargetDescription) {
         var params: [SourceCodeFragment] = []
@@ -428,6 +527,13 @@ fileprivate extension SourceCodeFragment {
         if let configName = condition.config {
             params.append(SourceCodeFragment(key: "configuration", enum: configName))
         }
+        if let traits = condition.traits {
+            params.append(
+                SourceCodeFragment(key: "traits", subnodes: traits.sorted().map { trait in
+                    SourceCodeFragment(string: trait)
+                })
+            )
+        }
         self.init(enum: "when", subnodes: params)
     }
 
@@ -1035,6 +1141,47 @@ public struct SourceCodeFragment {
     }
 }
 
+extension Optional {
+    fileprivate static func precedes(
+        _ a: Wrapped?, _ b: Wrapped?,
+        compareWrapped: (Wrapped, Wrapped) -> Bool
+    ) -> Bool {
+        switch (a, b) {
+        case (.none, .none): return false
+        case (.none, .some): return true
+        case (.some, .none): return false
+        case (.some(let a), .some(let b)):
+            return compareWrapped(a, b)
+        }
+    }
+}
+
+extension PackageDependency.Trait {
+    fileprivate static func precedes(_ a: PackageDependency.Trait, _ b: PackageDependency.Trait) -> Bool {
+        if a.name != b.name { return a.name < b.name }
+
+        if a.condition != b.condition {
+            return Optional.precedes(a.condition, b.condition) { a, b in
+                PackageDependency.Trait.Condition.precedes(a, b)
+            }
+        }
+
+        return false
+    }
+}
+
+extension PackageDependency.Trait.Condition {
+    fileprivate static func precedes(_ a: PackageDependency.Trait.Condition, _ b: PackageDependency.Trait.Condition) -> Bool {
+        if a.traits != b.traits {
+            return Optional.precedes(a.traits, b.traits) { a, b in
+                a.sorted().lexicographicallyPrecedes(b.sorted())
+            }
+        }
+
+        return false
+    }
+}
+
 extension TargetBuildSettingDescription.Kind {
     fileprivate var name: String {
         switch self {

Sources/_InternalTestSupport/XCTAssertHelpers.swift

@@ -123,11 +123,19 @@ public func XCTRequires(
     }
 }
 
+public func XCTSkipIfCompilerLessThan6_1() throws {
+    swiftTestingTestCalledAnXCTestAPI()
+    #if compiler(>=6.1)
+    #else
+        throw XCTSkip("Skipping as compiler version is less than 6.1")
+    #endif
+}
+
 public func XCTSkipIfCompilerLessThan6_2() throws {
     swiftTestingTestCalledAnXCTestAPI()
     #if compiler(>=6.2)
     #else
-        throw XCTSkip("Skipping as compiler version is less thann 6.2")
+        throw XCTSkip("Skipping as compiler version is less than 6.2")
     #endif
 }
 

Tests/WorkspaceTests/ManifestSourceGenerationTests.swift

@@ -107,6 +107,7 @@ final class ManifestSourceGenerationTests: XCTestCase {
             XCTAssertEqual(newManifest.pkgConfig, manifest.pkgConfig, "pkgConfig not as expected" + failureDetails, file: file, line: line)
             XCTAssertEqual(newManifest.providers, manifest.providers, "providers not as expected" + failureDetails, file: file, line: line)
             XCTAssertEqual(newManifest.products, manifest.products, "products not as expected" + failureDetails, file: file, line: line)
+            XCTAssertEqual(newManifest.traits, manifest.traits, "traits not as expected" + failureDetails, file: file, line: line)
             XCTAssertEqual(newManifest.dependencies, manifest.dependencies, "dependencies not as expected" + failureDetails, file: file, line: line)
             XCTAssertEqual(newManifest.targets, manifest.targets, "targets not as expected" + failureDetails, file: file, line: line)
             XCTAssertEqual(newManifest.swiftLanguageVersions, manifest.swiftLanguageVersions, "swiftLanguageVersions not as expected" + failureDetails, file: file, line: line)
@@ -949,4 +950,58 @@ final class ManifestSourceGenerationTests: XCTestCase {
         let contents = try manifest.generateManifestFileContents(packageDirectory: manifest.path.parentDirectory)
         try await testManifestWritingRoundTrip(manifestContents: contents, toolsVersion: .v6_2)
     }
+
+    func testTraits() async throws {
+        try XCTSkipIfCompilerLessThan6_1()
+
+        let manifestContents = """
+            // swift-tools-version: 6.1
+            import PackageDescription
+
+            let package = Package(
+                name: "TraitExample",
+                traits: [
+                    "Foo",
+                    .trait(
+                        name: "Bar",
+                        enabledTraits: [
+                            "Foo",
+                        ]
+                    ),
+                    .trait(
+                        name: "FooBar",
+                        enabledTraits: [
+                            "Foo",
+                            "Bar",
+                        ]
+                    ),
+                    .default(enabledTraits: ["Foo"]),
+                ],
+                dependencies: [
+                    .package(
+                        url: "https://github.com/Org/SomePackage.git",
+                        from: "1.0.0",
+                        traits: [
+                            .defaults,
+                            "SomeTrait",
+                            .trait(name: "SomeOtherTrait", condition: .when(traits: ["Foo"])),
+                        ]
+                    ),
+                ],
+                targets: [
+                    .target(
+                        name: "SomeTarget",
+                        dependencies: [
+                            .product(
+                                name: "SomeProduct",
+                                package: "SomePackage",
+                                condition: .when(traits: ["Foo"])
+                            ),
+                        ]
+                    )
+                ]
+            )
+            """
+        try await testManifestWritingRoundTrip(manifestContents: manifestContents, toolsVersion: .v6_1)
+    }
 }