Merge branch 'main' into topics/async-platform-registry-and-windows-link-discovery

Author: kcieplak

Sources/SWBAndroidPlatform/Plugin.swift

@@ -16,11 +16,23 @@ import SWBMacro
 import Foundation
 
 @PluginExtensionSystemActor public func initializePlugin(_ manager: PluginManager) {
+    let plugin = AndroidPlugin()
     manager.register(AndroidPlatformSpecsExtension(), type: SpecificationsExtensionPoint.self)
-    manager.register(AndroidEnvironmentExtension(), type: EnvironmentExtensionPoint.self)
+    manager.register(AndroidEnvironmentExtension(plugin: plugin), type: EnvironmentExtensionPoint.self)
     manager.register(AndroidPlatformExtension(), type: PlatformInfoExtensionPoint.self)
-    manager.register(AndroidSDKRegistryExtension(), type: SDKRegistryExtensionPoint.self)
-    manager.register(AndroidToolchainRegistryExtension(), type: ToolchainRegistryExtensionPoint.self)
+    manager.register(AndroidSDKRegistryExtension(plugin: plugin), type: SDKRegistryExtensionPoint.self)
+    manager.register(AndroidToolchainRegistryExtension(plugin: plugin), type: ToolchainRegistryExtensionPoint.self)
+}
+
+final class AndroidPlugin: Sendable {
+    private let androidSDKInstallations = AsyncCache<OperatingSystem, [AndroidSDK]>()
+
+    func cachedAndroidSDKInstallations(host: OperatingSystem) async throws -> [AndroidSDK] {
+        try await androidSDKInstallations.value(forKey: host) {
+            // Always pass localFS because this will be cached, and executes a process on the host system so there's no reason to pass in any proxy.
+            try await AndroidSDK.findInstallations(host: host, fs: localFS)
+        }
+    }
 }
 
 struct AndroidPlatformSpecsExtension: SpecificationsExtension {
@@ -34,10 +46,12 @@ struct AndroidPlatformSpecsExtension: SpecificationsExtension {
 }
 
 struct AndroidEnvironmentExtension: EnvironmentExtension {
+    let plugin: AndroidPlugin
+
     func additionalEnvironmentVariables(context: any EnvironmentExtensionAdditionalEnvironmentVariablesContext) async throws -> [String: String] {
         switch context.hostOperatingSystem {
         case .windows, .macOS, .linux:
-            if let latest = try? await AndroidSDK.findInstallations(host: context.hostOperatingSystem, fs: context.fs).first {
+            if let latest = try? await plugin.cachedAndroidSDKInstallations(host: context.hostOperatingSystem).first {
                 return [
                     "ANDROID_SDK_ROOT": latest.path.str,
                     "ANDROID_NDK_ROOT": latest.ndkPath?.str,
@@ -71,6 +85,8 @@ struct AndroidPlatformExtension: PlatformInfoExtension {
 }
 
 struct AndroidSDKRegistryExtension: SDKRegistryExtension {
+    let plugin: AndroidPlugin
+
     func additionalSDKs(context: any SDKRegistryExtensionAdditionalSDKsContext) async throws -> [(path: Path, platform: SWBCore.Platform?, data: [String: PropertyListItem])] {
         let host = context.hostOperatingSystem
         guard let androidPlatform = context.platformRegistry.lookup(name: "android") else {
@@ -96,7 +112,7 @@ struct AndroidSDKRegistryExtension: SDKRegistryExtension {
             "AR": .plString(host.imageFormat.executableName(basename: "llvm-ar")),
         ]
 
-        guard let androidSdk = try? await AndroidSDK.findInstallations(host: host, fs: context.fs).first else {
+        guard let androidSdk = try? await plugin.cachedAndroidSDKInstallations(host: host).first else {
             return []
         }
 
@@ -138,8 +154,10 @@ struct AndroidSDKRegistryExtension: SDKRegistryExtension {
 }
 
 struct AndroidToolchainRegistryExtension: ToolchainRegistryExtension {
+    let plugin: AndroidPlugin
+
     func additionalToolchains(context: any ToolchainRegistryExtensionAdditionalToolchainsContext) async -> [Toolchain] {
-        guard let toolchainPath = try? await AndroidSDK.findInstallations(host: context.hostOperatingSystem, fs: context.fs).first?.toolchainPath else {
+        guard let toolchainPath = try? await plugin.cachedAndroidSDKInstallations(host: context.hostOperatingSystem).first?.toolchainPath else {
             return []
         }
 

Sources/SWBQNXPlatform/Plugin.swift

@@ -16,11 +16,23 @@ import SWBMacro
 import Foundation
 
 @PluginExtensionSystemActor public func initializePlugin(_ manager: PluginManager) {
+    let plugin = QNXPlugin()
     manager.register(QNXPlatformSpecsExtension(), type: SpecificationsExtensionPoint.self)
-    manager.register(QNXEnvironmentExtension(), type: EnvironmentExtensionPoint.self)
+    manager.register(QNXEnvironmentExtension(plugin: plugin), type: EnvironmentExtensionPoint.self)
     manager.register(QNXPlatformExtension(), type: PlatformInfoExtensionPoint.self)
-    manager.register(QNXSDKRegistryExtension(), type: SDKRegistryExtensionPoint.self)
-    manager.register(QNXToolchainRegistryExtension(), type: ToolchainRegistryExtensionPoint.self)
+    manager.register(QNXSDKRegistryExtension(plugin: plugin), type: SDKRegistryExtensionPoint.self)
+    manager.register(QNXToolchainRegistryExtension(plugin: plugin), type: ToolchainRegistryExtensionPoint.self)
+}
+
+final class QNXPlugin: Sendable {
+    private let qnxInstallations = AsyncCache<OperatingSystem, [QNXSDP]>()
+
+    func cachedQNXSDPInstallations(host: OperatingSystem) async throws -> [QNXSDP] {
+        try await qnxInstallations.value(forKey: host) {
+            // Always pass localFS because this will be cached, and executes a process on the host system so there's no reason to pass in any proxy.
+            try await QNXSDP.findInstallations(host: host, fs: localFS)
+        }
+    }
 }
 
 struct QNXPlatformSpecsExtension: SpecificationsExtension {
@@ -30,8 +42,10 @@ struct QNXPlatformSpecsExtension: SpecificationsExtension {
 }
 
 struct QNXEnvironmentExtension: EnvironmentExtension {
+    let plugin: QNXPlugin
+
     func additionalEnvironmentVariables(context: any EnvironmentExtensionAdditionalEnvironmentVariablesContext) async throws -> [String : String] {
-        if let latest = try await QNXSDP.findInstallations(host: context.hostOperatingSystem, fs: context.fs).first {
+        if let latest = try await plugin.cachedQNXSDPInstallations(host: context.hostOperatingSystem).first {
             return latest.environment
         }
         return [:]
@@ -59,12 +73,14 @@ struct QNXPlatformExtension: PlatformInfoExtension {
 }
 
 struct QNXSDKRegistryExtension: SDKRegistryExtension {
+    let plugin: QNXPlugin
+
     func additionalSDKs(context: any SDKRegistryExtensionAdditionalSDKsContext) async throws -> [(path: Path, platform: SWBCore.Platform?, data: [String : PropertyListItem])] {
         guard let qnxPlatform = context.platformRegistry.lookup(name: "qnx") else {
             return []
         }
 
-        guard let qnxSdk = try? await QNXSDP.findInstallations(host: context.hostOperatingSystem, fs: context.fs).first else {
+        guard let qnxSdk = try? await plugin.cachedQNXSDPInstallations(host: context.hostOperatingSystem).first else {
             return []
         }
 
@@ -123,8 +139,10 @@ struct QNXSDKRegistryExtension: SDKRegistryExtension {
 }
 
 struct QNXToolchainRegistryExtension: ToolchainRegistryExtension {
+    let plugin: QNXPlugin
+
     func additionalToolchains(context: any ToolchainRegistryExtensionAdditionalToolchainsContext) async -> [Toolchain] {
-        guard let toolchainPath = try? await QNXSDP.findInstallations(host: context.hostOperatingSystem, fs: context.fs).first?.hostPath else {
+        guard let toolchainPath = try? await plugin.cachedQNXSDPInstallations(host: context.hostOperatingSystem).first?.hostPath else {
             return []
         }
 

Sources/SWBWindowsPlatform/Plugin.swift

@@ -15,11 +15,24 @@ import SWBCore
 import Foundation
 
 @PluginExtensionSystemActor public func initializePlugin(_ manager: PluginManager) {
+    let plugin = WindowsPlugin()
     manager.register(WindowsPlatformSpecsExtension(), type: SpecificationsExtensionPoint.self)
-    manager.register(WindowsEnvironmentExtension(), type: EnvironmentExtensionPoint.self)
+    manager.register(WindowsEnvironmentExtension(plugin: plugin), type: EnvironmentExtensionPoint.self)
     manager.register(WindowsPlatformExtension(), type: PlatformInfoExtensionPoint.self)
     manager.register(WindowsSDKRegistryExtension(), type: SDKRegistryExtensionPoint.self)
 }
+
+final class WindowsPlugin: Sendable {
+    private let vsInstallations = AsyncSingleValueCache<[VSInstallation], any Error>()
+
+    func cachedVSInstallations() async throws -> [VSInstallation] {
+        try await vsInstallations.value {
+            // Always pass localFS because this will be cached, and executes a process on the host system so there's no reason to pass in any proxy.
+            try await VSInstallation.findInstallations(fs: localFS)
+        }
+    }
+}
+
 struct WindowsPlatformSpecsExtension: SpecificationsExtension {
     func specificationFiles(resourceSearchPaths: [Path]) -> Bundle? {
         findResourceBundle(nameWhenInstalledInToolchain: "SwiftBuild_SWBWindowsPlatform", resourceSearchPaths: resourceSearchPaths, defaultBundle: Bundle.module)
@@ -41,6 +54,8 @@ private func findLatestInstallDirectory(fs: any FSProxy) async throws -> Path? {
 }
 
 struct WindowsEnvironmentExtension: EnvironmentExtension {
+    let plugin: WindowsPlugin
+
     func additionalEnvironmentVariables(context: any EnvironmentExtensionAdditionalEnvironmentVariablesContext) async throws -> [String: String] {
         guard context.hostOperatingSystem == .windows else {
             return [:]

Tests/SWBTaskExecutionTests/PBXCpTests.swift

@@ -555,22 +555,19 @@ fileprivate struct PBXCpTests: CoreBasedTests {
             #expect(result.success == true)
             #expect(result.output == "copying src...\n 9 bytes\n")
             #expect(try fs.read(dst) == "contents1")
-            let modificationDate = try fs.getFileInfo(dst).modificationDate
 
             try await Task.sleep(for: .milliseconds(500))
             let result2 = await pbxcp(["builtin-copy", "-skip-copy-if-contents-equal", "-rename", "-v", src.str, dst.str], cwd: Path("/"))
             #expect(result2.success == true)
             #expect(result2.output == "note: skipping copy of '\(src.str)' because it has the same contents as '\(dst.str)'\n")
             #expect(try fs.read(dst) == "contents1")
-            #expect(try fs.getFileInfo(dst).modificationDate == modificationDate)
 
             try await Task.sleep(for: .milliseconds(500))
             try fs.write(src, contents: "contents2")
             let result3 = await pbxcp(["builtin-copy", "-skip-copy-if-contents-equal", "-rename", "-v", src.str, dst.str], cwd: Path("/"))
             #expect(result3.success == true)
             #expect(result3.output == "copying src...\n 9 bytes\n")
             #expect(try fs.read(dst) == "contents2")
-            #expect(try fs.getFileInfo(dst).modificationDate != modificationDate)
         }
 
         try await withTemporaryDirectory { tmp in
@@ -587,22 +584,19 @@ fileprivate struct PBXCpTests: CoreBasedTests {
             #expect(result.success == true)
             #expect(result.output == "copying file...\n 9 bytes\n")
             #expect(try fs.read(dstFile) == "contents1")
-            let modificationDate = try fs.getFileInfo(dstFile).modificationDate
 
             try await Task.sleep(for: .milliseconds(500))
             let result2 = await pbxcp(["builtin-copy", "-skip-copy-if-contents-equal", "-rename", "-v", src.str, dst.str], cwd: Path("/"))
             #expect(result2.success == true)
             #expect(result2.output == "note: skipping copy of '\(src.str)' because it has the same contents as '\(dst.str)'\n")
             #expect(try fs.read(dstFile) == "contents1")
-            #expect(try fs.getFileInfo(dstFile).modificationDate == modificationDate)
 
             try await Task.sleep(for: .milliseconds(500))
             try fs.write(srcFile, contents: "contents2")
             let result3 = await pbxcp(["builtin-copy", "-skip-copy-if-contents-equal", "-rename", "-v", src.str, dst.str], cwd: Path("/"))
             #expect(result3.success == true)
             #expect(result3.output == "copying src/...\n")
             #expect(try fs.read(dstFile) == "contents2")
-            #expect(try fs.getFileInfo(dstFile).modificationDate != modificationDate)
         }
     }
 

Tests/SWBUtilTests/FSProxyTests.swift

@@ -260,14 +260,14 @@ import SWBTestSupport
         }
     }
 
-    @Test(.skipHostOS(.linux)) // flaky on Linux because timestamps have been observed to vary by 0.001s after copying
+    @Test
     func localCopyFile() throws {
         try withTemporaryDirectory { tmpDir in
             try _testCopyFile(localFS, basePath: tmpDir)
         }
     }
 
-    @Test(.skipHostOS(.linux)) // flaky on Linux because timestamps have been observed to vary by 0.001s after copying
+    @Test
     func localCopyTree() throws {
         try withTemporaryDirectory { tmpDir in
             try _testCopyTree(localFS, basePath: tmpDir)
@@ -1111,7 +1111,10 @@ import SWBTestSupport
         if try ProcessInfo.processInfo.hostOperatingSystem() != .windows {
             #expect(try fs.getFilePermissions(testDataPathDst) == permissions)
         }
-        #expect(try fs.getFileInfo(testDataPath).modificationDate == fs.getFileInfo(testDataPathDst).modificationDate)
+        if fs is PseudoFS {
+            // There is no guarantee that the implementation of copy() will preserve the modification timestamp on either files and/or directories, on any real filesystem, so only make this assertion for the pseudo filesystem which we wholly control.
+            #expect(try fs.getFileInfo(testDataPath).modificationDate == fs.getFileInfo(testDataPathDst).modificationDate)
+        }
         #expect(try ByteString(testData) == fs.read(testDataPathDst))
     }
 
@@ -1121,7 +1124,10 @@ import SWBTestSupport
             #expect(lhs.isDirectory == rhs.isDirectory, sourceLocation: sourceLocation)
             #expect(lhs.isExecutable == rhs.isExecutable, sourceLocation: sourceLocation)
             #expect(lhs.isSymlink == rhs.isSymlink, sourceLocation: sourceLocation)
-            #expect(lhs.modificationDate == rhs.modificationDate, sourceLocation: sourceLocation)
+            if fs is PseudoFS {
+                // There is no guarantee that the implementation of copy() will preserve the modification timestamp on either files and/or directories, on any real filesystem, so only make this assertion for the pseudo filesystem which we wholly control.
+                #expect(lhs.modificationDate == rhs.modificationDate, sourceLocation: sourceLocation)
+            }
             #expect(lhs.owner == rhs.owner, sourceLocation: sourceLocation)
             #expect(lhs.permissions == rhs.permissions, sourceLocation: sourceLocation)
         }