Enable Windows linker discovery

* Make Platform Registry initialization async
* Change the function signature of
  additionalPlatformExecutableSearchPaths to allow
  passing of a filesystem for discovery. Plugins
  will need to be updated to match new signatures
* Add the visual studio install directory to
  platform search paths for executables.
* Enable Windows linker discovery to get link.exe
  type and version
* Add Windows platform plugin extension to get
  install directory
* Add test for discovery of windows linker
* Paths in the clang ouput have double slashes
  so this needs to be handled.

Author: kcieplak

Sources/SWBCore/Core.swift

@@ -98,6 +98,8 @@ public final class Core: Sendable {
 
             await core.initializeSpecRegistry()
 
+            await core.initializePlatformRegistry()
+
             await core.initializeToolchainRegistry()
 
             // Force loading SDKs.
@@ -315,27 +317,10 @@ public final class Core: Sendable {
     @_spi(Testing) public var toolchainPaths: [(Path, strict: Bool)]
 
     /// The platform registry.
-    public lazy var platformRegistry: PlatformRegistry = {
-        // FIXME: We should support building the platforms (with symlinks) locally (for `inferiorProductsPath`).
-
-        // Search the default location first (unless directed not to), then search any extra locations we've been passed.
-        var searchPaths: [Path]
-        let fs = localFS
-        if let onlySearchAdditionalPlatformPaths = getEnvironmentVariable("XCODE_ONLY_EXTRA_PLATFORM_FOLDERS"), onlySearchAdditionalPlatformPaths.boolValue {
-            searchPaths = []
-        }
-        else {
-            let platformsDir = self.developerPath.join("Platforms")
-            searchPaths = [platformsDir]
-        }
-        if let additionalPlatformSearchPaths = getEnvironmentVariable("XCODE_EXTRA_PLATFORM_FOLDERS") {
-            for searchPath in additionalPlatformSearchPaths.split(separator: ":") {
-                searchPaths.append(Path(searchPath))
-            }
-        }
-        searchPaths += UserDefaults.additionalPlatformSearchPaths
-        return PlatformRegistry(delegate: self.registryDelegate, searchPaths: searchPaths, hostOperatingSystem: hostOperatingSystem, fs: fs)
-    }()
+    let _platformRegistry: UnsafeDelayedInitializationSendableWrapper<PlatformRegistry> = .init()
+    public var platformRegistry: PlatformRegistry {
+        _platformRegistry.value
+    }
 
     @PluginExtensionSystemActor public var loadedPluginPaths: [Path] {
         pluginManager.pluginsByIdentifier.values.map(\.path)
@@ -397,6 +382,25 @@ public final class Core: Sendable {
 
     private var _specRegistry: SpecRegistry?
 
+    private func initializePlatformRegistry() async {
+        var searchPaths: [Path]
+        let fs = localFS
+        if let onlySearchAdditionalPlatformPaths = getEnvironmentVariable("XCODE_ONLY_EXTRA_PLATFORM_FOLDERS"), onlySearchAdditionalPlatformPaths.boolValue {
+            searchPaths = []
+        } else {
+            let platformsDir = self.developerPath.join("Platforms")
+            searchPaths = [platformsDir]
+        }
+        if let additionalPlatformSearchPaths = getEnvironmentVariable("XCODE_EXTRA_PLATFORM_FOLDERS") {
+            for searchPath in additionalPlatformSearchPaths.split(separator: Path.pathEnvironmentSeparator) {
+                searchPaths.append(Path(searchPath))
+            }
+        }
+        searchPaths += UserDefaults.additionalPlatformSearchPaths
+        _platformRegistry.initialize(to: await PlatformRegistry(delegate: self.registryDelegate, searchPaths: searchPaths, hostOperatingSystem: hostOperatingSystem, fs: fs))
+    }
+
+
     private func initializeToolchainRegistry() async {
         self.toolchainRegistry = await ToolchainRegistry(delegate: self.registryDelegate, searchPaths: self.toolchainPaths, fs: localFS, hostOperatingSystem: hostOperatingSystem)
     }

Sources/SWBCore/Extensions/PlatformInfoExtension.swift

@@ -30,7 +30,7 @@ public protocol PlatformInfoExtension: Sendable {
 
     func additionalKnownTestLibraryPathSuffixes() -> [Path]
 
-    func additionalPlatformExecutableSearchPaths(platformName: String, platformPath: Path) -> [Path]
+    func additionalPlatformExecutableSearchPaths(platformName: String, platformPath: Path, fs: any FSProxy) async -> [Path]
 
     func additionalToolchainExecutableSearchPaths(toolchainIdentifier: String, toolchainPath: Path) -> [Path]
 
@@ -56,7 +56,7 @@ extension PlatformInfoExtension {
         []
     }
 
-    public func additionalPlatformExecutableSearchPaths(platformName: String, platformPath: Path) -> [Path] {
+    public func additionalPlatformExecutableSearchPaths(platformName: String, platformPath: Path, fs: any FSProxy) async -> [Path] {
         []
     }
 

Sources/SWBCore/PlatformRegistry.swift

@@ -324,23 +324,23 @@ public final class PlatformRegistry {
             })
     }
 
-    @_spi(Testing) public init(delegate: any PlatformRegistryDelegate, searchPaths: [Path], hostOperatingSystem: OperatingSystem, fs: any FSProxy) {
+    @_spi(Testing) public init(delegate: any PlatformRegistryDelegate, searchPaths: [Path], hostOperatingSystem: OperatingSystem, fs: any FSProxy) async {
         self.delegate = delegate
 
         for path in searchPaths {
-            registerPlatformsInDirectory(path, fs)
+            await registerPlatformsInDirectory(path, fs)
         }
 
         do {
             if hostOperatingSystem.createFallbackSystemToolchain {
-                try registerFallbackSystemPlatform(operatingSystem: hostOperatingSystem, fs: fs)
+                try await registerFallbackSystemPlatform(operatingSystem: hostOperatingSystem, fs: fs)
             }
         } catch {
             delegate.error(error)
         }
 
-        @preconcurrency @PluginExtensionSystemActor func platformInfoExtensions() -> [any PlatformInfoExtensionPoint.ExtensionProtocol] {
-            delegate.pluginManager.extensions(of: PlatformInfoExtensionPoint.self)
+        @preconcurrency @PluginExtensionSystemActor func platformInfoExtensions() async -> [any PlatformInfoExtensionPoint.ExtensionProtocol] {
+            return await delegate.pluginManager.extensions(of: PlatformInfoExtensionPoint.self)
         }
 
         struct Context: PlatformInfoExtensionAdditionalPlatformsContext {
@@ -352,16 +352,17 @@ public final class PlatformRegistry {
         for platformExtension in platformInfoExtensions() {
             do {
                 for (path, data) in try platformExtension.additionalPlatforms(context: Context(hostOperatingSystem: hostOperatingSystem, developerPath: delegate.developerPath, fs: fs)) {
-                    registerPlatform(path, .plDict(data), fs)
+                    await registerPlatform(path, .plDict(data), fs)
                 }
             } catch {
                 delegate.error(error)
+
             }
         }
     }
 
-    private func registerFallbackSystemPlatform(operatingSystem: OperatingSystem, fs: any FSProxy) throws {
-        try registerPlatform(Path("/"), .plDict(fallbackSystemPlatformSettings(operatingSystem: operatingSystem)), fs)
+    private func registerFallbackSystemPlatform(operatingSystem: OperatingSystem, fs: any FSProxy) async throws {
+        try await registerPlatform(Path("/"), .plDict(fallbackSystemPlatformSettings(operatingSystem: operatingSystem)), fs)
     }
 
     private func fallbackSystemPlatformSettings(operatingSystem: OperatingSystem) throws -> [String: PropertyListItem] {
@@ -428,7 +429,7 @@ public final class PlatformRegistry {
     }
 
     /// Register all platforms in the given directory.
-    private func registerPlatformsInDirectory(_ path: Path, _ fs: any FSProxy) {
+    private func registerPlatformsInDirectory(_ path: Path, _ fs: any FSProxy) async {
         for item in (try? localFS.listdir(path))?.sorted(by: <) ?? [] {
             let itemPath = path.join(item)
 
@@ -446,14 +447,14 @@ public final class PlatformRegistry {
                     // Silently skip loading the platform if it does not have an Info.plist at all.  (We will still error below if it has an Info.plist which is malformed.)
                     continue
                 }
-                registerPlatform(itemPath, infoPlist, fs)
+                await registerPlatform(itemPath, infoPlist, fs)
             } catch let err {
                 delegate.error(itemPath, "unable to load platform: 'Info.plist' was malformed: \(err)")
             }
         }
     }
 
-    private func registerPlatform(_ path: Path, _ data: PropertyListItem, _ fs: any FSProxy) {
+    private func registerPlatform(_ path: Path, _ data: PropertyListItem, _ fs: any FSProxy) async {
         // The data should always be a dictionary.
         guard case .plDict(let items) = data else {
             delegate.error(path, "unexpected platform data")
@@ -617,7 +618,7 @@ public final class PlatformRegistry {
             delegate.pluginManager.extensions(of: PlatformInfoExtensionPoint.self)
         }
 
-        for platformExtension in platformInfoExtensions() {
+        for platformExtension in await platformInfoExtensions() {
             if let value = platformExtension.preferredArchValue(for: name) {
                 preferredArchValue = value
             }
@@ -632,9 +633,10 @@ public final class PlatformRegistry {
         ]
 
         for platformExtension in platformInfoExtensions() {
-            executableSearchPaths.append(contentsOf: platformExtension.additionalPlatformExecutableSearchPaths(platformName: name, platformPath: path))
+            await executableSearchPaths.append(contentsOf: platformExtension.additionalPlatformExecutableSearchPaths(platformName: name, platformPath: path))
 
             platformExtension.adjustPlatformSDKSearchPaths(platformName: name, platformPath: path, sdkSearchPaths: &sdkSearchPaths)
+
         }
 
         executableSearchPaths.append(contentsOf: [

Sources/SWBCore/SpecImplementations/Tools/LinkerTools.swift

@@ -1309,15 +1309,14 @@ public final class LdLinkerSpec : GenericLinkerSpec, SpecIdentifierType, @unchec
         //
         // Note: On Linux you cannot invoke the llvm linker by the direct name for determining the version,
         // you need to use ld.<ALTERNATE_LINKER>
-        var linkerPath = Path("ld")
+        var linkerPath = producer.hostOperatingSystem == .windows ? Path("link") : Path("ld")
         if alternateLinker != "" && alternateLinker != "ld" {
             linkerPath = Path(producer.hostOperatingSystem.imageFormat.executableName(basename: "ld.\(alternateLinker)"))
         }
-        // Create the cache key.  This is just the path to the linker we would invoke if we were invoking the linker directly.
-        guard let toolPath = producer.executableSearchPaths.lookup(linkerPath) else {
+        guard let toolPath = producer.executableSearchPaths.findExecutable(operatingSystem: producer.hostOperatingSystem, basename: linkerPath.str) else {
             return nil
         }
-
+        // Create the cache key.  This is just the path to the linker we would invoke if we were invoking the linker directly.
         return await discoveredLinkerToolsInfo(producer, delegate, at: toolPath)
     }
 }
@@ -1638,10 +1637,19 @@ public func discoveredLinkerToolsInfo(_ producer: any CommandProducer, _ delegat
                     #/GNU gold \(GNU Binutils.*\) (?<version>[\d.]+)/#, // Ubuntu "GNU gold (GNU Binutils for Ubuntu 2.38) 1.16", Debian "GNU gold (GNU Binutils for Debian 2.40) 1.16"
                     #/GNU gold \(version .*\) (?<version>[\d.]+)/#,     // Fedora "GNU gold (version 2.40-14.fc39) 1.16", RHEL "GNU gold (version 2.35.2-54.el9) 1.16", Amazon "GNU gold (version 2.29.1-31.amzn2.0.1) 1.14"
                 ]
+
                 if let match = try goLD.compactMap({ try $0.firstMatch(in: String(decoding: executionResult.stdout, as: UTF8.self)) }).first {
                     return DiscoveredLdLinkerToolSpecInfo(linker: .gold, toolPath: toolPath, toolVersion: try Version(String(match.output.version)), architectures: Set())
                 }
 
+                // link.exe has no option to simply dump the version, running, the program will no arguments or an invalid one will dump a header that contains the version.
+                let linkExe = [
+                    #/Microsoft \(R\) Incremental Linker Version (?<version>[\d.]+)/#
+                ]
+                if let match = try linkExe.compactMap({ try $0.firstMatch(in: String(decoding: executionResult.stdout, as: UTF8.self)) }).first {
+                    return DiscoveredLdLinkerToolSpecInfo(linker: .linkExe, toolPath: toolPath, toolVersion: try Version(String(match.output.version)), architectures: Set())
+                }
+
                 struct LDVersionDetails: Decodable {
                     let version: Version
                     let architectures: Set<String>

Sources/SWBWindowsPlatform/Plugin.swift

@@ -44,23 +44,29 @@ struct WindowsPlatformSpecsExtension: SpecificationsExtension {
 
     @_spi(Testing) public func additionalEnvironmentVariables(context: any EnvironmentExtensionAdditionalEnvironmentVariablesContext) async throws -> [String: String] {
         if context.hostOperatingSystem == .windows {
-            // Add the environment variable for the MSVC toolset for Swift and Clang to find it
             let vcToolsInstallDir = "VCToolsInstallDir"
-            let installations = try await plugin.cachedVSInstallations()
-                .sorted(by: { $0.installationVersion > $1.installationVersion })
-            if let latest = installations.first {
-                let msvcDir = latest.installationPath.join("VC").join("Tools").join("MSVC")
-                if context.fs.exists(msvcDir) {
-                    let versions = try context.fs.listdir(msvcDir).map { try Version($0) }.sorted { $0 > $1 }
-                    if let latestVersion = versions.first {
-                        let dir = msvcDir.join(latestVersion.description).str
-                        return [vcToolsInstallDir: dir]
-                    }
-                }
+            guard let dir = try? await findLatestInstallDirectory(fs: context.fs) else {
+                return [:]
             }
+            return [vcToolsInstallDir: dir.str]
         }
-        return [:]
     }
+
+     @_spi(Testing)public func findLatestInstallDirectory(fs: any FSProxy) async throws -> Path? {
+    let plugin: WindowsPlugin
+    let installations = try await plugin.cachedVSInstallations()
+        .sorted(by: { $0.installationVersion > $1.installationVersion })
+    if let latest = installations.first {
+        let msvcDir = latest.installationPath.join("VC").join("Tools").join("MSVC")
+        if fs.exists(msvcDir) {
+            let versions = try fs.listdir(msvcDir).map { try Version($0) }.sorted { $0 > $1 }
+            if let latestVersion = versions.first {
+                return msvcDir.join(latestVersion.description)
+            }
+        }
+    }
+    return nil
+}
 }
 
 struct WindowsPlatformExtension: PlatformInfoExtension {
@@ -107,6 +113,17 @@ struct WindowsPlatformExtension: PlatformInfoExtension {
             sdkSearchPaths = []
         }
     }
+
+    public func additionalPlatformExecutableSearchPaths(platformName: String, platformPath: Path, fs: any FSProxy) async -> [Path] {
+        guard let dir = try? await findLatestInstallDirectory(fs: fs) else {
+            return []
+        }
+        if Architecture.hostStringValue == "aarch64" {
+            return [dir.join("bin/Hostarm64/arm64")]
+        } else {
+            return [dir.join("bin/Hostx64/x64")]
+        }
+    }
 }
 
 struct WindowsSDKRegistryExtension: SDKRegistryExtension {