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.
@@ -301,32 +303,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 hostOperatingSystem == .windows {
-                for dir in (try? localFS.listdir(platformsDir)) ?? [] {
-                    searchPaths.append(platformsDir.join(dir))
-                }
-            }
-        }
-        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)
@@ -388,6 +368,30 @@ 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 hostOperatingSystem == .windows {
+                for dir in (try? fs.listdir(platformsDir)) ?? [] {
+                    searchPaths.append(platformsDir.join(dir))
+                }
+            }
+        }
+        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]
 
@@ -54,7 +54,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

@@ -319,34 +319,34 @@ 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)
         }
 
-        for platformExtension in platformInfoExtensions() {
+        for platformExtension in await platformInfoExtensions() {
             for (path, data) in platformExtension.additionalPlatforms() {
-                registerPlatform(path, .plDict(data), fs)
+                await registerPlatform(path, .plDict(data), fs)
             }
         }
     }
 
-    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] {
@@ -413,7 +413,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)
 
@@ -431,14 +431,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(var items) = data else {
             delegate.error(path, "unexpected platform data")
@@ -613,7 +613,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
             }
@@ -623,8 +623,8 @@ public final class PlatformRegistry {
             path.join("usr").join("bin"),
         ]
 
-        for platformExtension in platformInfoExtensions() {
-            executableSearchPaths.append(contentsOf: platformExtension.additionalPlatformExecutableSearchPaths(platformName: name, platformPath: path))
+        for platformExtension in await platformInfoExtensions() {
+            await executableSearchPaths.append(contentsOf: platformExtension.additionalPlatformExecutableSearchPaths(platformName: name, platformPath: path, fs: localFS))
         }
 
         executableSearchPaths.append(contentsOf: [

Sources/SWBCore/Specs/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

@@ -17,6 +17,7 @@ import Foundation
 @PluginExtensionSystemActor public func initializePlugin(_ manager: PluginManager) {
     manager.register(WindowsPlatformSpecsExtension(), type: SpecificationsExtensionPoint.self)
     manager.register(WindowsEnvironmentExtension(), type: EnvironmentExtensionPoint.self)
+    manager.register(WindowsPlatformExtension(), type: PlatformInfoExtensionPoint.self)
 }
 
 struct WindowsPlatformSpecsExtension: SpecificationsExtension {
@@ -25,22 +26,42 @@ struct WindowsPlatformSpecsExtension: SpecificationsExtension {
     }
 }
 
+private func findLatestInstallDirectory(fs: any FSProxy) async throws -> Path? {
+    if try ProcessInfo.processInfo.hostOperatingSystem() == .windows {
+        let installations = try await VSInstallation.findInstallations(fs: fs)
+            .sorted(by: { $0.installationVersion > $1.installationVersion })
+        if let latest = installations.first {
+            let msvcDir = latest.installationPath.join("VC").join("Tools").join("MSVC")
+            let versions = try fs.listdir(msvcDir).map { try Version($0) }.sorted { $0 > $1 }
+            if let latestVersion = versions.first {
+                let dir = msvcDir.join(latestVersion.description).str
+                return Path(dir)
+            }
+        }
+    }
+    return nil
+}
+
 struct WindowsEnvironmentExtension: EnvironmentExtension {
     func additionalEnvironmentVariables(fs: any FSProxy) async throws -> [String: String] {
-        if try ProcessInfo.processInfo.hostOperatingSystem() == .windows {
-            // Add the environment variable for the MSVC toolset for Swift and Clang to find it
-            let vcToolsInstallDir = "VCToolsInstallDir"
-            let installations = try await VSInstallation.findInstallations(fs: fs)
-                .sorted(by: { $0.installationVersion > $1.installationVersion })
-            if let latest = installations.first {
-                let msvcDir = latest.installationPath.join("VC").join("Tools").join("MSVC")
-                let versions = try 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]
-                }
-            }
+        // Add the environment variable for the MSVC toolset for Swift and Clang to find it
+        let vcToolsInstallDir = "VCToolsInstallDir"
+        guard let dir = try? await findLatestInstallDirectory(fs: fs) else {
+            return [:]
+        }
+        return [vcToolsInstallDir: dir.str]
+    }
+}
+
+struct WindowsPlatformExtension: PlatformInfoExtension {
+    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")]
         }
-        return [:]
     }
 }