Get run and test working against Swift Build.

Cleans up handling of the new build system. It's close to the old
xcode build system but with a couple of differences. Gets rid
of the boolean isXcodeBuild and pass in the actual Kind so we can
do different things based on which one is selected. Selects the
build output path for binaries based on the selection.

Also cleans up code with a missing wait for the build service to
complete and with with the file descriptor close before swift
run execs the process.

Author: dschaefer2

Sources/Commands/SwiftRunCommand.swift

@@ -350,10 +350,10 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
         #else
         let number_fds = getdtablesize()
         #endif /* os(Android) */
-        
-        // 2. close all file descriptors.
+
+        // 2. set to close all file descriptors on exec
         for i in 3..<number_fds {
-            close(i)
+            _ = fcntl(i, F_SETFD, FD_CLOEXEC)
         }
         #endif /* os(FreeBSD) || os(OpenBSD) */
         #endif

Sources/CoreCommands/SwiftCommandState.swift

@@ -441,7 +441,6 @@ public final class SwiftCommandState {
             self.observabilityHandler.progress,
             self.observabilityHandler.prompt
         )
-        let isXcodeBuildSystemEnabled = self.options.build.buildSystem.usesXcodeBuildEngine
         let workspace = try Workspace(
             fileSystem: self.fileSystem,
             location: .init(
@@ -459,9 +458,9 @@ public final class SwiftCommandState {
             configuration: .init(
                 skipDependenciesUpdates: options.resolver.skipDependencyUpdate,
                 prefetchBasedOnResolvedFile: options.resolver.shouldEnableResolverPrefetching,
-                shouldCreateMultipleTestProducts: toolWorkspaceConfiguration.wantsMultipleTestProducts || options.build.buildSystem.usesXcodeBuildEngine,
+                shouldCreateMultipleTestProducts: toolWorkspaceConfiguration.wantsMultipleTestProducts || options.build.buildSystem.shouldCreateMultipleTestProducts,
                 createREPLProduct: toolWorkspaceConfiguration.wantsREPLProduct,
-                additionalFileRules: isXcodeBuildSystemEnabled ? FileRuleDescription.xcbuildFileTypes : FileRuleDescription.swiftpmFileTypes,
+                additionalFileRules: options.build.buildSystem.additionalFileRules,
                 sharedDependenciesCacheEnabled: self.options.caching.useDependenciesCache,
                 fingerprintCheckingMode: self.options.security.fingerprintCheckingMode,
                 signingEntityCheckingMode: self.options.security.signingEntityCheckingMode,
@@ -790,12 +789,12 @@ public final class SwiftCommandState {
             toolchain: toolchain,
             triple: triple,
             flags: options.build.buildFlags,
+            buildSystemKind: options.build.buildSystem,
             pkgConfigDirectories: options.locations.pkgConfigDirectories,
             architectures: options.build.architectures,
             workers: options.build.jobs ?? UInt32(ProcessInfo.processInfo.activeProcessorCount),
             sanitizers: options.build.enabledSanitizers,
             indexStoreMode: options.build.indexStoreMode.buildParameter,
-            isXcodeBuildSystemEnabled: options.build.buildSystem.usesXcodeBuildEngine,
             prepareForIndexing: prepareForIndexingMode,
             debuggingParameters: .init(
                 debugInfoFormat: options.build.debugInfoFormat.buildParameter,
@@ -1020,6 +1019,26 @@ public final class SwiftCommandState {
     }
 }
 
+extension BuildSystemProvider.Kind {
+    fileprivate var shouldCreateMultipleTestProducts: Bool {
+        switch self {
+        case .xcode, .swiftbuild:
+            return true
+        case .native:
+            return false
+        }
+    }
+    
+    fileprivate var additionalFileRules: [FileRuleDescription] {
+        switch self {
+        case .xcode, .swiftbuild:
+            return FileRuleDescription.xcbuildFileTypes
+        case .native:
+            return FileRuleDescription.swiftpmFileTypes
+        }
+    }
+}
+
 /// Returns path of the nearest directory containing the manifest file w.r.t
 /// current working directory.
 private func findPackageRoot(fileSystem: FileSystem) -> AbsolutePath? {
@@ -1187,3 +1206,4 @@ extension Basics.Diagnostic {
         .error(arguments.map { "'\($0)'" }.spm_localizedJoin(type: .conjunction) + " are mutually exclusive")
     }
 }
+

Sources/SPMBuildCore/BuildParameters/BuildParameters.swift

@@ -120,8 +120,7 @@ public struct BuildParameters: Encodable {
         }
     }
 
-    /// Whether the Xcode build system is used.
-    public var isXcodeBuildSystemEnabled: Bool
+    public var buildSystemKind: BuildSystemProvider.Kind
 
     public var shouldSkipBuilding: Bool
 
@@ -150,13 +149,13 @@ public struct BuildParameters: Encodable {
         toolchain: Toolchain,
         triple: Triple? = nil,
         flags: BuildFlags,
+        buildSystemKind: BuildSystemProvider.Kind,
         pkgConfigDirectories: [AbsolutePath] = [],
         architectures: [String]? = nil,
         workers: UInt32 = UInt32(ProcessInfo.processInfo.activeProcessorCount),
         shouldCreateDylibForDynamicProducts: Bool = true,
         sanitizers: EnabledSanitizers = EnabledSanitizers(),
         indexStoreMode: IndexStoreMode = .auto,
-        isXcodeBuildSystemEnabled: Bool = false,
         shouldSkipBuilding: Bool = false,
         prepareForIndexing: PrepareForIndexingMode = .off,
         debuggingParameters: Debugging? = nil,
@@ -177,6 +176,7 @@ public struct BuildParameters: Encodable {
         self.configuration = configuration
         self._toolchain = _Toolchain(toolchain: toolchain)
         self.triple = triple
+        self.buildSystemKind = buildSystemKind
         switch self.debuggingParameters.debugInfoFormat {
         case .dwarf:
             var flags = flags
@@ -212,7 +212,6 @@ public struct BuildParameters: Encodable {
         self.shouldCreateDylibForDynamicProducts = shouldCreateDylibForDynamicProducts
         self.sanitizers = sanitizers
         self.indexStoreMode = indexStoreMode
-        self.isXcodeBuildSystemEnabled = isXcodeBuildSystemEnabled
         self.shouldSkipBuilding = shouldSkipBuilding
         self.prepareForIndexing = prepareForIndexing
         self.driverParameters = driverParameters
@@ -223,9 +222,10 @@ public struct BuildParameters: Encodable {
 
     /// The path to the build directory (inside the data directory).
     public var buildPath: AbsolutePath {
-        if isXcodeBuildSystemEnabled {
+        switch buildSystemKind {
+        case .xcode, .swiftbuild:
             return dataPath.appending(components: "Products", configuration.dirname.capitalized)
-        } else {
+        case .native:
             return dataPath.appending(component: configuration.dirname)
         }
     }

Sources/SPMBuildCore/BuildSystem/BuildSystem.swift

@@ -128,7 +128,7 @@ public protocol BuildSystemFactory {
 
 public struct BuildSystemProvider {
     // TODO: In the future, we may want this to be about specific capabilities of a build system rather than choosing a concrete one.
-    public enum Kind: String, CaseIterable {
+    public enum Kind: String, Codable, CaseIterable {
         case native
         case swiftbuild
         case xcode
@@ -169,15 +169,6 @@ public struct BuildSystemProvider {
     }
 }
 
-extension BuildSystemProvider.Kind {
-    public var usesXcodeBuildEngine: Bool {
-        switch self {
-            case .native: return false
-            case .swiftbuild: return false
-            case .xcode: return true
-        }
-    }
-}
 private enum Errors: Swift.Error {
     case buildSystemProviderNotRegistered(kind: BuildSystemProvider.Kind)
 }

Sources/SPMBuildCore/Triple+Extensions.swift

@@ -24,9 +24,14 @@ extension Triple {
 
 extension Triple {
     public func platformBuildPathComponent(buildSystem: BuildSystemProvider.Kind) -> String {
-        // Use "apple" as the subdirectory because in theory Xcode build system
-        // can be used to build for any Apple platform and it has its own
-        // conventions for build subpaths based on platforms.
-        buildSystem.usesXcodeBuildEngine ? "apple" : self.platformBuildPathComponent
+        switch buildSystem {
+        case .xcode:
+            // Use "apple" as the subdirectory because in theory Xcode build system
+            // can be used to build for any Apple platform and it has its own
+            // conventions for build subpaths based on platforms.
+            return "apple"
+        case .swiftbuild, .native:
+            return self.platformBuildPathComponent
+        }
     }
 }

Sources/SwiftBuildSupport/SwiftBuildSystem.swift

@@ -385,6 +385,8 @@ public final class SwiftBuildSystem: SPMBuildCore.BuildSystem {
         } catch {
             throw error
         }
+
+        await service.close()
     }
 
     func makeBuildParameters() throws -> SwiftBuild.SWBBuildParameters {

Sources/_InternalTestSupport/MockBuildTestHelper.swift

@@ -82,6 +82,7 @@ public func mockBuildParameters(
     config: BuildConfiguration = .debug,
     toolchain: PackageModel.Toolchain = MockToolchain(),
     flags: PackageModel.BuildFlags = PackageModel.BuildFlags(),
+    buildSystemKind: BuildSystemProvider.Kind = .native,
     shouldLinkStaticSwiftStdlib: Bool = false,
     shouldDisableLocalRpath: Bool = false,
     canRenameEntrypointFunctionName: Bool = false,
@@ -100,6 +101,7 @@ public func mockBuildParameters(
         toolchain: toolchain,
         triple: triple,
         flags: flags,
+        buildSystemKind: buildSystemKind,
         pkgConfigDirectories: [],
         workers: 3,
         indexStoreMode: indexStoreMode,

Sources/swift-bootstrap/main.swift

@@ -281,8 +281,6 @@ struct SwiftBootstrapBuildTool: AsyncParsableCommand {
             shouldDisableLocalRpath: Bool,
             logLevel: Basics.Diagnostic.Severity
         ) throws -> BuildSystem {
-            var buildFlags = buildFlags
-
             let dataPath = scratchDirectory.appending(
                 component: self.targetToolchain.targetTriple.platformBuildPathComponent(buildSystem: buildSystem)
             )
@@ -294,8 +292,8 @@ struct SwiftBootstrapBuildTool: AsyncParsableCommand {
                 toolchain: self.targetToolchain,
                 triple: self.hostToolchain.targetTriple,
                 flags: buildFlags,
+                buildSystemKind: buildSystem,
                 architectures: architectures,
-                isXcodeBuildSystemEnabled: buildSystem.usesXcodeBuildEngine,
                 driverParameters: .init(
                     explicitTargetDependencyImportCheckingMode: explicitTargetDependencyImportCheck == .error ? .error : .none,
                     useIntegratedSwiftDriver: useIntegratedSwiftDriver,