[WIP] Static versus exporting symbols for Windows

For Windows triples only, creates a parallel build graph for Swift
modules, one for static linking using -static, and one for
exporting linking which is the default. DLL products consume their
direct target dependencies as exporting. All other dependencies
use the static versions to eliminate unnecessary symbol exports.

The bulk of this is managed by the SwiftModuleBuildDescription
which will create a duplicate of itself for the exporting case
and set it's own type to static linking. Both modules are fed to
the planner to create llbuild swift command tasks. Code is added
for dynamic libraries to hook up the correct inputs for exporting
the symbols in the libraries targets.

Author: dschaefer2

Sources/Build/BuildDescription/SwiftModuleBuildDescription.swift

@@ -127,7 +127,11 @@ public final class SwiftModuleBuildDescription {
 
     var modulesPath: AbsolutePath {
         let suffix = self.buildParameters.suffix
-        return self.buildParameters.buildPath.appending(component: "Modules\(suffix)")
+        var path = self.buildParameters.buildPath.appending(component: "Modules\(suffix)")
+        if self.windowsTargetType == .exporting {
+            path = path.appending("exporting")
+        }
+        return path
     }
 
     /// The path to the swiftmodule file after compilation.
@@ -264,6 +268,18 @@ public final class SwiftModuleBuildDescription {
     /// Whether to disable sandboxing (e.g. for macros).
     private let shouldDisableSandbox: Bool
 
+    /// For Windows we default to static objects and create copies for objects
+    /// That export symbols. This will allow consumers to select which one they want.
+    public enum WindowsTargetType {
+        case `static`
+        case exporting
+    }
+    /// The target type. Leave nil for non-Windows behavior.
+    public let windowsTargetType: WindowsTargetType?
+
+    /// The corresponding target symbols exporting (not -static)
+    public private(set) var windowsExportTarget: SwiftModuleBuildDescription? = nil
+
     /// Create a new target description with target and build parameters.
     init(
         package: ResolvedPackage,
@@ -319,6 +335,14 @@ public final class SwiftModuleBuildDescription {
             observabilityScope: observabilityScope
         )
 
+        if buildParameters.triple.isWindows() {
+            // Default to static and add another target for DLLs
+            self.windowsTargetType = .static
+            self.windowsExportTarget = .init(windowsExportFor: self)
+        } else {
+            self.windowsTargetType = nil
+        }
+
         if self.shouldEmitObjCCompatibilityHeader {
             self.moduleMap = try self.generateModuleMap()
         }
@@ -340,6 +364,31 @@ public final class SwiftModuleBuildDescription {
         try self.generateTestObservation()
     }
 
+    /// Private init to set up exporting version of this module
+    private init(windowsExportFor parent: SwiftModuleBuildDescription) {
+        self.windowsTargetType = .exporting
+        self.windowsExportTarget = nil
+        self.tempsPath = parent.tempsPath.appending("exporting")
+
+        // The rest of these are just copied from the parent
+        self.package = parent.package
+        self.target = parent.target
+        self.swiftTarget = parent.swiftTarget
+        self.toolsVersion = parent.toolsVersion
+        self.buildParameters = parent.buildParameters
+        self.macroBuildParameters = parent.macroBuildParameters
+        self.derivedSources = parent.derivedSources
+        self.pluginDerivedSources = parent.pluginDerivedSources
+        self.pluginDerivedResources = parent.pluginDerivedResources
+        self.testTargetRole = parent.testTargetRole
+        self.fileSystem = parent.fileSystem
+        self.buildToolPluginInvocationResults = parent.buildToolPluginInvocationResults
+        self.prebuildCommandResults = parent.prebuildCommandResults
+        self.observabilityScope = parent.observabilityScope
+        self.shouldGenerateTestObservation = parent.shouldGenerateTestObservation
+        self.shouldDisableSandbox = parent.shouldDisableSandbox
+    }
+
     private func generateTestObservation() throws {
         guard target.type == .test else {
             return
@@ -519,6 +568,18 @@ public final class SwiftModuleBuildDescription {
             args += ["-parse-as-library"]
         }
 
+        switch self.windowsTargetType {
+            case .static:
+                // Static on Windows
+                args += ["-static"]
+            case .exporting:
+                // Add the static versions to the include path
+                // FIXME: need to be much more deliberate about what we're including
+                args += ["-I", self.modulesPath.parentDirectory.pathString]
+            case .none:
+                break
+        }
+
         // Only add the build path to the framework search path if there are binary frameworks to link against.
         if !self.libraryBinaryPaths.isEmpty {
             args += ["-F", self.buildParameters.buildPath.pathString]

Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift

@@ -53,6 +53,16 @@ extension LLBuildManifestBuilder {
             )
         } else {
             try self.addCmdWithBuiltinSwiftTool(target, inputs: inputs, cmdOutputs: cmdOutputs)
+            if let exportTarget = target.windowsExportTarget {
+                // Generate dynamic module for Windows
+                let inputs = try self.computeSwiftCompileCmdInputs(exportTarget)
+                let objectNodes = exportTarget.buildParameters.prepareForIndexing == .off ? try exportTarget.objects.map(Node.file) : []
+                let moduleNode = Node.file(exportTarget.moduleOutputPath)
+                let cmdOutputs = objectNodes + [moduleNode]
+                try self.addCmdWithBuiltinSwiftTool(exportTarget, inputs: inputs, cmdOutputs: cmdOutputs)
+                self.addTargetCmd(exportTarget, cmdOutputs: cmdOutputs)
+                try self.addModuleWrapCmd(exportTarget)
+            }
         }
 
         self.addTargetCmd(target, cmdOutputs: cmdOutputs)
@@ -529,7 +539,7 @@ extension LLBuildManifestBuilder {
             inputs: cmdOutputs,
             outputs: [targetOutput]
         )
-        if self.plan.graph.isInRootPackages(target.target, satisfying: target.buildParameters.buildEnvironment) {
+        if self.plan.graph.isInRootPackages(target.target, satisfying: target.buildParameters.buildEnvironment), target.windowsTargetType != .exporting {
             if !target.isTestTarget {
                 self.addNode(targetOutput, toTarget: .main)
             }
@@ -633,6 +643,11 @@ extension SwiftModuleBuildDescription {
     }
 
     public func getLLBuildTargetName() -> String {
-        self.target.getLLBuildTargetName(buildParameters: self.buildParameters)
+        let name = self.target.getLLBuildTargetName(buildParameters: self.buildParameters)
+        if self.windowsTargetType == .exporting {
+            return "export." + name
+        } else {
+            return name
+        }
     }
 }

Sources/Build/BuildPlan/BuildPlan+Product.swift

@@ -101,7 +101,18 @@ extension BuildPlan {
 
         buildProduct.staticTargets = dependencies.staticTargets.map(\.module)
         buildProduct.dylibs = dependencies.dylibs
-        buildProduct.objects += try dependencies.staticTargets.flatMap { try $0.objects }
+        buildProduct.objects += try dependencies.staticTargets.flatMap {
+            if buildProduct.product.type == .library(.dynamic),
+                case let .swift(swiftModule) = $0,
+                let exporting = swiftModule.windowsExportTarget,
+                buildProduct.product.modules.contains(id: swiftModule.target.id)
+            {
+                // On Windows, export symbols from the direct swift targets of the DLL product
+                return try exporting.objects
+            } else {
+                return try $0.objects
+            }
+        }
         buildProduct.libraryBinaryPaths = dependencies.libraryBinaryPaths
         buildProduct.availableTools = dependencies.availableTools
     }

Sources/Build/BuildPlan/BuildPlan.swift

@@ -537,6 +537,9 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
             switch buildTarget {
             case .swift(let target):
                 try self.plan(swiftTarget: target)
+                if let exportTarget = target.windowsExportTarget {
+                    try self.plan(swiftTarget: exportTarget)
+                }
             case .clang(let target):
                 try self.plan(clangTarget: target)
             }