Assure trait-guarded dependencies are not included in resolution; precompute enabled traits before resolution (#8852)

Trait-guarded dependencies were still being considered during dependency
resolution, when they should be excluded if they aren't being used in
any other scenario. Additionally, enabled traits should be pre-computed
before entering the resolution stage in order to avoid possible race
conditions when navigating through the dependency graph nodes.

### Modifications:

Since we have the `--experimental-prune-unused-dependencies` feature
behind an experimental flag, we'll now consider an alternate path that
will prune trait-guarded package dependencies from the dependency graph
**_if and only if_** said dependency is not used in any other unguarded
context.

A dictionary wrapper titled `EnabledTraitsMap` is used to store the
enabled traits per package for the package graph and is stored as a
property within the `Workspace`, with some additional behaviour to
return a `["default"]` set of traits if the package has not yet been
stored in the dictionary, rather than returning `nil`.

Following this behaviour, when passing a set of traits to methods that
require them (e.g. for dependency computation, enabled trait
computation, etc.) we now require that it is not Optional, since the
checks done on a `nil` set of traits were redundant.

SwiftCommandState now also stores a `TraitConfiguration`, since we'll
want access to this across multiple `SwiftCommand`s, and it is
essentially a part of the state anyhow. `TraitOptions` is now included
in the `GlobalOptions` for `SwiftCommand`s to supplement this, so that
when a `SwiftCommandState` is created we will have access to the
user-passed enabled traits. These options, as entitled, are available
globally across all the swift package commands, so previous properties
that declared `TraitOptions` in these commands has been removed in
favour of using it straight from the `GlobalOptions`.

### Result:

Trait-guarded dependencies are excluded from dependency resolution, and
since traits are pre-computed there should no longer be an issue with
race conditions for traits in resolution as well.

Author: bripeticca

Sources/Commands/PackageCommands/APIDiff.swift

@@ -72,9 +72,6 @@ struct APIDiff: AsyncSwiftCommand {
             help: "One or more targets to include in the API comparison. If present, only the specified targets (and any products specified using `--products`) will be compared.")
     var targets: [String] = []
 
-    @OptionGroup(visibility: .hidden)
-    package var traits: TraitOptions
-
     @Option(name: .customLong("baseline-dir"),
             help: "The path to a directory used to store API baseline files. If unspecified, a temporary directory will be used.")
     var overrideBaselineDir: Basics.AbsolutePath?
@@ -106,7 +103,6 @@ struct APIDiff: AsyncSwiftCommand {
             )
         } else {
             let buildSystem = try await swiftCommandState.createBuildSystem(
-                traitConfiguration: .init(traitOptions: self.traits),
                 cacheBuildManifest: false,
             )
             try await runWithSwiftPMCoordinatedDiffing(
@@ -210,7 +206,6 @@ struct APIDiff: AsyncSwiftCommand {
         )
         let delegate = DiagnosticsCapturingBuildSystemDelegate()
         let buildSystem = try await swiftCommandState.createBuildSystem(
-            traitConfiguration: .init(traitOptions: self.traits),
             cacheBuildManifest: false,
             productsBuildParameters: productsBuildParameters,
             delegate: delegate
@@ -319,7 +314,6 @@ struct APIDiff: AsyncSwiftCommand {
         // Build the baseline module.
         // FIXME: We need to implement the build tool invocation closure here so that build tool plugins work with the APIDigester. rdar://86112934
         let buildSystem = try await swiftCommandState.createBuildSystem(
-            traitConfiguration: .init(),
             cacheBuildManifest: false,
             productsBuildParameters: productsBuildParameters,
             packageGraphLoader: { graph }

Sources/Commands/PackageCommands/DumpCommands.swift

@@ -53,7 +53,7 @@ struct DumpSymbolGraph: AsyncSwiftCommand {
         // We turn build manifest caching off because we need the build plan.
         let buildSystem = try await swiftCommandState.createBuildSystem(
             // We are enabling all traits for dumping the symbol graph.
-            traitConfiguration: .init(enableAllTraits: true),
+            enableAllTraits: true,
             cacheBuildManifest: false
         )
         // TODO pass along the various flags as associated values to the symbol graph build output (e.g. includeSPISymbols)

Sources/Commands/PackageCommands/Install.swift

@@ -88,7 +88,7 @@ extension SwiftPackageCommand {
                 commandState.preferredBuildConfiguration = .release
             }
 
-            try await commandState.createBuildSystem(explicitProduct: productToInstall.name, traitConfiguration: .init())
+            try await commandState.createBuildSystem(explicitProduct: productToInstall.name)
                 .build(subset: .product(productToInstall.name), buildOutputs: [])
 
             let binPath = try commandState.productsBuildParameters.buildPath.appending(component: productToInstall.name)

Sources/Commands/PackageCommands/Migrate.swift

@@ -196,7 +196,6 @@ extension SwiftPackageCommand {
             }
 
             return try await swiftCommandState.createBuildSystem(
-                traitConfiguration: .init(),
                 // Don't attempt to cache manifests with temporary
                 // feature flags added just for migration purposes.
                 cacheBuildManifest: false,

Sources/Commands/PackageCommands/PluginCommand.swift

@@ -338,7 +338,6 @@ struct PluginCommand: AsyncSwiftCommand {
         // Build or bring up-to-date any executable host-side tools on which this plugin depends. Add them and any binary dependencies to the tool-names-to-path map.
         let buildSystem = try await swiftCommandState.createBuildSystem(
             explicitBuildSystem: buildSystemKind,
-            traitConfiguration: .init(),
             cacheBuildManifest: false,
             productsBuildParameters: swiftCommandState.productsBuildParameters,
             toolsBuildParameters: buildParameters,

Sources/Commands/PackageCommands/Resolve.swift

@@ -31,10 +31,6 @@ extension SwiftPackageCommand {
 
         @Argument(help: "The name of the package to resolve.")
         var packageName: String?
-
-        /// Specifies the traits to build.
-        @OptionGroup(visibility: .hidden)
-        package var traits: TraitOptions
     }
 
     struct Resolve: AsyncSwiftCommand {
@@ -50,10 +46,10 @@ extension SwiftPackageCommand {
         func run(_ swiftCommandState: SwiftCommandState) async throws {
             // If a package is provided, use that to resolve the dependencies.
             if let packageName = resolveOptions.packageName {
-                let workspace = try swiftCommandState.getActiveWorkspace(traitConfiguration: .init(traitOptions: resolveOptions.traits))
+                let workspace = try swiftCommandState.getActiveWorkspace()
                 try await workspace.resolve(
                     packageName: packageName,
-                    root: swiftCommandState.getWorkspaceRoot(traitConfiguration: .init(traitOptions: resolveOptions.traits)),
+                    root: swiftCommandState.getWorkspaceRoot(),
                     version: resolveOptions.version,
                     branch: resolveOptions.branch,
                     revision: resolveOptions.revision,
@@ -64,7 +60,7 @@ extension SwiftPackageCommand {
                 }
             } else {
                 // Otherwise, run a normal resolve.
-                try await swiftCommandState.resolve(.init(traitOptions: resolveOptions.traits))
+                try await swiftCommandState.resolve()
             }
         }
     }

Sources/Commands/Snippets/Cards/SnippetCard.swift

@@ -112,7 +112,7 @@ struct SnippetCard: Card {
 
     func runExample() async throws {
         print("Building '\(snippet.path)'\n")
-        let buildSystem = try await swiftCommandState.createBuildSystem(explicitProduct: snippet.name, traitConfiguration: .init())
+        let buildSystem = try await swiftCommandState.createBuildSystem(explicitProduct: snippet.name)
         try await buildSystem.build(subset: .product(snippet.name), buildOutputs: [])
         let executablePath = try swiftCommandState.productsBuildParameters.buildPath.appending(component: snippet.name)
         if let exampleTarget = try await buildSystem.getPackageGraph().module(for: snippet.name) {

Sources/Commands/SwiftBuildCommand.swift

@@ -110,10 +110,6 @@ struct BuildCommandOptions: ParsableArguments {
     @OptionGroup(visibility: .private)
     var testLibraryOptions: TestLibraryOptions
 
-    /// Specifies the traits to build.
-    @OptionGroup(visibility: .hidden)
-    package var traits: TraitOptions
-
     /// If should link the Swift stdlib statically.
     @Flag(name: .customLong("static-swift-stdlib"), inversion: .prefixedNo, help: "Link Swift stdlib statically.")
     public var shouldLinkStaticSwiftStdlib: Bool = false
@@ -144,7 +140,6 @@ public struct SwiftBuildCommand: AsyncSwiftCommand {
             // FIXME: Doesn't seem ideal that we need an explicit build operation, but this concretely uses the `LLBuildManifest`.
             guard let buildOperation = try await swiftCommandState.createBuildSystem(
                 explicitBuildSystem: .native,
-                traitConfiguration: .init(traitOptions: self.options.traits)
             ) as? BuildOperation else {
                 throw StringError("asked for native build system but did not get it")
             }
@@ -194,7 +189,6 @@ public struct SwiftBuildCommand: AsyncSwiftCommand {
     ) async throws {
         let buildSystem = try await swiftCommandState.createBuildSystem(
             explicitProduct: options.product,
-            traitConfiguration: .init(traitOptions: self.options.traits),
             shouldLinkStaticSwiftStdlib: options.shouldLinkStaticSwiftStdlib,
             productsBuildParameters: productsBuildParameters,
             toolsBuildParameters: toolsBuildParameters,

Sources/Commands/SwiftRunCommand.swift

@@ -88,10 +88,6 @@ struct RunCommandOptions: ParsableArguments {
     @Argument(help: "The executable to run.", completion: .shellCommand("swift package completion-tool list-executables"))
     var executable: String?
 
-    /// Specifies the traits to build the product with.
-    @OptionGroup(visibility: .hidden)
-    package var traits: TraitOptions
-
     /// The arguments to pass to the executable.
     @Argument(parsing: .captureForPassthrough,
               help: "The arguments to pass to the executable.")
@@ -139,7 +135,6 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
             // FIXME: We need to implement the build tool invocation closure here so that build tool plugins work with the REPL. rdar://86112934
             let buildSystem = try await swiftCommandState.createBuildSystem(
                 explicitBuildSystem: .native,
-                traitConfiguration: .init(traitOptions: self.options.traits),
                 cacheBuildManifest: false,
                 packageGraphLoader: asyncUnsafeGraphLoader
             )
@@ -164,7 +159,6 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
             do {
                 let buildSystem = try await swiftCommandState.createBuildSystem(
                     explicitProduct: options.executable,
-                    traitConfiguration: .init(traitOptions: self.options.traits)
                 )
                 let productName = try await findProductName(in: buildSystem.getPackageGraph())
                 if options.shouldBuildTests {
@@ -220,9 +214,9 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
             do {
                 let buildSystem = try await swiftCommandState.createBuildSystem(
                     explicitProduct: options.executable,
-                    traitConfiguration: .init(traitOptions: self.options.traits)
                 )
-                let productName = try await findProductName(in: buildSystem.getPackageGraph())
+                let modulesGraph = try await buildSystem.getPackageGraph()
+                let productName = try findProductName(in: modulesGraph)
                 if options.shouldBuildTests {
                     try await buildSystem.build(subset: .allIncludingTests, buildOutputs: [])
                 } else if options.shouldBuild {

Sources/Commands/SwiftTestCommand.swift

@@ -220,9 +220,6 @@ struct TestCommandOptions: ParsableArguments {
     var enableExperimentalTestOutput: Bool {
         return testOutput == .experimentalSummary
     }
-
-    @OptionGroup(visibility: .hidden)
-    package var traits: TraitOptions
 }
 
 /// Tests filtering specifier, which is used to filter tests to run.
@@ -659,7 +656,7 @@ public struct SwiftTestCommand: AsyncSwiftCommand {
             productsBuildParameters: productsBuildParameters,
             toolsBuildParameters: toolsBuildParameters,
             testProduct: self.options.sharedOptions.testProduct,
-            traitConfiguration: .init(traitOptions: self.options.traits)
+            traitConfiguration: .init(traitOptions: self.globalOptions.traits)
         )
     }
 
@@ -741,9 +738,6 @@ extension SwiftTestCommand {
         @OptionGroup()
         var testEventStreamOptions: TestEventStreamOptions
 
-        @OptionGroup(visibility: .hidden)
-        package var traits: TraitOptions
-
         // for deprecated passthrough from SwiftTestTool (parse will fail otherwise)
         @Flag(name: [.customLong("list-tests"), .customShort("l")], help: .hidden)
         var _deprecated_passthrough: Bool = false
@@ -850,7 +844,7 @@ extension SwiftTestCommand {
                 productsBuildParameters: productsBuildParameters,
                 toolsBuildParameters: toolsBuildParameters,
                 testProduct: self.sharedOptions.testProduct,
-                traitConfiguration: .init(traitOptions: self.traits)
+                traitConfiguration: .init(traitOptions: self.globalOptions.traits)
             )
         }
     }
@@ -1561,7 +1555,6 @@ private func buildTestsIfNeeded(
     traitConfiguration: TraitConfiguration
 ) async throws -> [BuiltTestProduct] {
     let buildSystem = try await swiftCommandState.createBuildSystem(
-        traitConfiguration: traitConfiguration,
         productsBuildParameters: productsBuildParameters,
         toolsBuildParameters: toolsBuildParameters
     )