Updates to get executables building and running on windows (#9130)

- the also changes the source modules on Windows to be a static lib
since pre-linked .o is not supported.

depends on: swiftlang/swift-build#795

Author: daveinglis

Sources/SwiftBuildSupport/PackagePIFBuilder+Helpers.swift

@@ -1001,18 +1001,16 @@ extension ProjectModel.BuildSettings {
     mutating func configureDynamicSettings(
         productName: String,
         targetName: String,
-        executableName: String,
         packageIdentity: PackageIdentity,
         packageName: String?,
         createDylibForDynamicProducts: Bool,
         installPath: String,
-        delegate: PackagePIFBuilder.BuildDelegate
+        delegate: PackagePIFBuilder.BuildDelegate,
     ) {
         self[.TARGET_NAME] = targetName
-        self[.PRODUCT_NAME] = createDylibForDynamicProducts ? productName : executableName
+        self[.PRODUCT_NAME] = productName
         self[.PRODUCT_MODULE_NAME] = productName
         self[.PRODUCT_BUNDLE_IDENTIFIER] = "\(packageIdentity).\(productName)".spm_mangledToBundleIdentifier()
-        self[.EXECUTABLE_NAME] = executableName
         self[.CLANG_ENABLE_MODULES] = "YES"
         self[.SWIFT_PACKAGE_NAME] = packageName ?? nil
 

Sources/SwiftBuildSupport/PackagePIFProjectBuilder+Modules.swift

@@ -237,31 +237,25 @@ extension PackagePIFProjectBuilder {
     ) throws -> (PackagePIFBuilder.ModuleOrProduct, resourceBundleName: String?) {
         precondition(sourceModule.isSourceModule)
 
-        let pifProductName: String
-        let executableName: String
         let productType: ProjectModel.Target.ProductType
 
         switch desiredModuleType {
         case .dynamicLibrary:
             // We are re-using this default for dynamic targets as well.
             if pifBuilder.createDylibForDynamicProducts {
-                pifProductName = "lib\(sourceModule.name).dylib"
-                executableName = pifProductName
                 productType = .dynamicLibrary
             } else {
-                pifProductName = sourceModule.name + ".framework"
-                executableName = sourceModule.name
                 productType = .framework
             }
 
         case .staticLibrary, .executable:
-            pifProductName = "\(sourceModule.name).o"
-            executableName = pifProductName
+            #if os(Windows) // Temporary until we get a new productType in swift-build
+            productType = .staticArchive
+            #else
             productType = .objectFile
+            #endif
 
         case .macro:
-            pifProductName = sourceModule.name
-            executableName = pifProductName
             productType = .hostBuildTool
         }
 
@@ -280,8 +274,8 @@ extension PackagePIFProjectBuilder {
             ProjectModel.Target(
                 id: sourceModule.pifTargetGUID(suffix: targetSuffix),
                 productType: productType,
-                name: "\(sourceModule.name)",
-                productName: pifProductName,
+                name: sourceModule.name,
+                productName: "$(EXECUTABLE_NAME)",
                 approvedByUser: approvedByUser
             )
         }
@@ -407,35 +401,22 @@ extension PackagePIFProjectBuilder {
             settings.configureDynamicSettings(
                 productName: sourceModule.name,
                 targetName: sourceModule.name,
-                executableName: executableName,
                 packageIdentity: package.identity,
                 packageName: sourceModule.packageName,
                 createDylibForDynamicProducts: pifBuilder.createDylibForDynamicProducts,
                 installPath: "/usr/local/lib",
-                delegate: pifBuilder.delegate
+                delegate: pifBuilder.delegate,
             )
         } else {
             settings[.TARGET_NAME] = sourceModule.name
             settings[.PRODUCT_NAME] = "$(TARGET_NAME)"
             settings[.PRODUCT_MODULE_NAME] = sourceModule.c99name
             settings[.PRODUCT_BUNDLE_IDENTIFIER] = "\(self.package.identity).\(sourceModule.name)"
                 .spm_mangledToBundleIdentifier()
-            settings[.EXECUTABLE_NAME] = executableName
             settings[.CLANG_ENABLE_MODULES] = "YES"
             settings[.GENERATE_PRELINK_OBJECT_FILE] = "NO"
             settings[.STRIP_INSTALLED_PRODUCT] = "NO"
 
-            // Macros build as executables, so they need slightly different
-            // build settings from other module types which build a "*.o".
-            if desiredModuleType == .macro {
-                settings[.MACH_O_TYPE] = "mh_execute"
-            } else {
-                settings[.MACH_O_TYPE] = "mh_object"
-                // Disable code coverage linker flags since we're producing .o files.
-                // Otherwise, we will run into duplicated symbols when there are more than one targets that produce .o
-                // as their product.
-                settings[.CLANG_COVERAGE_MAPPING_LINKER_ARGS] = "NO"
-            }
             settings[.SWIFT_PACKAGE_NAME] = sourceModule.packageName
 
             if desiredModuleType == .executable {

Sources/SwiftBuildSupport/PackagePIFProjectBuilder+Products.swift

@@ -78,7 +78,7 @@ extension PackagePIFProjectBuilder {
                 id: product.pifTargetGUID,
                 productType: pifProductType,
                 name: product.targetName(),
-                productName: product.name
+                productName: "$(EXECUTABLE_NAME)"
             )
         }
         do {
@@ -116,7 +116,6 @@ extension PackagePIFProjectBuilder {
         settings[.PRODUCT_MODULE_NAME] = product.c99name
         settings[.PRODUCT_BUNDLE_IDENTIFIER] = "\(self.package.identity).\(product.name)"
             .spm_mangledToBundleIdentifier()
-        settings[.EXECUTABLE_NAME] = product.name
         settings[.CLANG_ENABLE_MODULES] = "YES"
         settings[.SWIFT_PACKAGE_NAME] = mainModule.packageName
 
@@ -608,35 +607,15 @@ extension PackagePIFProjectBuilder {
 
         // FIXME: Cleanup this mess with <rdar://56889224>
 
-        let pifProductName: String
-        let executableName: String
         let productType: ProjectModel.Target.ProductType
 
         if desiredProductType == .dynamic {
             if pifBuilder.createDylibForDynamicProducts {
-                pifProductName = "lib\(product.name).dylib"
-                executableName = pifProductName
                 productType = .dynamicLibrary
             } else {
-                // If a product is explicitly declared dynamic, we preserve its name,
-                // otherwise we will compute an automatic one.
-                if product.libraryType == .dynamic {
-                    if let customExecutableName = pifBuilder.delegate
-                        .customExecutableName(product: product.underlying)
-                    {
-                        executableName = customExecutableName
-                    } else {
-                        executableName = product.name
-                    }
-                } else {
-                    executableName = PackagePIFBuilder.computePackageProductFrameworkName(productName: product.name)
-                }
-                pifProductName = "\(executableName).framework"
                 productType = .framework
             }
         } else {
-            pifProductName = "lib\(product.name).a"
-            executableName = pifProductName
             productType = .packageProduct
         }
 
@@ -649,7 +628,7 @@ extension PackagePIFProjectBuilder {
                 id: product.pifTargetGUID(suffix: targetSuffix),
                 productType: productType,
                 name: product.targetName(suffix: targetSuffix),
-                productName: pifProductName
+                productName: product.name
             )
         }
         do {
@@ -718,7 +697,6 @@ extension PackagePIFProjectBuilder {
             settings.configureDynamicSettings(
                 productName: product.name,
                 targetName: product.targetName(),
-                executableName: executableName,
                 packageIdentity: package.identity,
                 packageName: package.identity.c99name,
                 createDylibForDynamicProducts: pifBuilder.createDylibForDynamicProducts,
@@ -1049,7 +1027,6 @@ extension PackagePIFProjectBuilder {
         settings[.PRODUCT_MODULE_NAME] = moduleName
         settings[.PRODUCT_BUNDLE_IDENTIFIER] = "\(self.package.identity).\(name)"
             .spm_mangledToBundleIdentifier()
-        settings[.EXECUTABLE_NAME] = name
         settings[.SKIP_INSTALL] = "NO"
         settings[.SWIFT_VERSION] = "5.0"
         // This should eventually be set universally for all package targets/products.

Sources/SwiftBuildSupport/PackagePIFProjectBuilder.swift

@@ -211,7 +211,6 @@ struct PackagePIFProjectBuilder {
         settings[.PRODUCT_MODULE_NAME] = bundleName
         settings[.PRODUCT_BUNDLE_IDENTIFIER] = "\(self.package.identity).\(module.name).resources"
             .spm_mangledToBundleIdentifier()
-        settings[.EXECUTABLE_NAME] = ""
         settings[.GENERATE_INFOPLIST_FILE] = "YES"
         settings[.PACKAGE_RESOURCE_TARGET_KIND] = "resource"
 

Sources/SwiftBuildSupport/SwiftBuildSystem.swift

@@ -727,16 +727,19 @@ public final class SwiftBuildSystem: SPMBuildCore.BuildSystem {
 
         settings["LIBRARY_SEARCH_PATHS"] = try "$(inherited) \(buildParameters.toolchain.toolchainLibDir.pathString)"
         settings["OTHER_CFLAGS"] = (
+            verboseFlag +
             ["$(inherited)"]
                 + buildParameters.toolchain.extraFlags.cCompilerFlags.map { $0.shellEscaped() }
                 + buildParameters.flags.cCompilerFlags.map { $0.shellEscaped() }
         ).joined(separator: " ")
         settings["OTHER_CPLUSPLUSFLAGS"] = (
+            verboseFlag +
             ["$(inherited)"]
                 + buildParameters.toolchain.extraFlags.cxxCompilerFlags.map { $0.shellEscaped() }
                 + buildParameters.flags.cxxCompilerFlags.map { $0.shellEscaped() }
         ).joined(separator: " ")
         settings["OTHER_SWIFT_FLAGS"] = (
+            verboseFlag +
             ["$(inherited)"]
                 + buildParameters.toolchain.extraFlags.swiftCompilerFlags.map { $0.shellEscaped() }
                 + buildParameters.flags.swiftCompilerFlags.map { $0.shellEscaped() }

Tests/CommandsTests/BuildCommandTests.swift

@@ -554,19 +554,14 @@ struct BuildCommandTestCases {
     func nonReachableProductsAndTargetsFunctional(
         buildSystem: BuildSystemProvider.Kind,
     ) async throws {
-        // skipped on Xcode
-        try await withKnownIssue {
-            try await fixture(name: "Miscellaneous/UnreachableTargets") { fixturePath in
-                let aPath = fixturePath.appending("A")
-
-                let result = try await build([], packagePath: aPath, buildSystem: buildSystem)
-                #expect(!result.binContents.contains("bexec"))
-                #expect(!result.binContents.contains("BTarget2.build"))
-                #expect(!result.binContents.contains("cexec"))
-                #expect(!result.binContents.contains("CTarget.build"))
-            }
-        } when: {
-            buildSystem == .swiftbuild && ProcessInfo.hostOperatingSystem == .windows
+        try await fixture(name: "Miscellaneous/UnreachableTargets") { fixturePath in
+            let aPath = fixturePath.appending("A")
+
+            let result = try await build([], packagePath: aPath, buildSystem: buildSystem)
+            #expect(!result.binContents.contains("bexec"))
+            #expect(!result.binContents.contains("BTarget2.build"))
+            #expect(!result.binContents.contains("cexec"))
+            #expect(!result.binContents.contains("CTarget.build"))
         }
     }