Test Android cross compilation on Windows

This also fixes the Android support to recognize an NDK even when an SDK is not present, which might be the case for some installations not driven through Android Studio (for example, NDK as installed by the chocolatey package manager on Windows, or installed manually into some directory).

Author: jakepetroules

.github/scripts/windows_pre_build.ps1

@@ -30,7 +30,7 @@ if ($InstallCMake) {
 }
 
 if (-not $SkipAndroid) {
-    choco install android-ndk
+    choco install -y android-ndk
 
     Import-Module $env:ChocolateyInstall\helpers\chocolateyProfile.psm1
     refreshenv

.github/workflows/pull_request.yml

@@ -17,6 +17,7 @@ jobs:
       linux_pre_build_command: ./.github/scripts/linux_pre_build.sh
       linux_build_command: 'swift test --no-parallel'
       linux_swift_versions: '["nightly-main", "nightly-6.2"]'
+      windows_pre_build_command: 'Invoke-Program .\.github\scripts\windows_pre_build.ps1'
       windows_swift_versions: '["nightly-main"]'
       windows_build_command: 'Invoke-Program swift test --no-parallel'
       enable_linux_static_sdk_build: true

Sources/SWBAndroidPlatform/AndroidSDK.swift

@@ -266,16 +266,16 @@ public import Foundation
     }
 }
 
-fileprivate extension AndroidSDK.NDK {
+extension AndroidSDK.NDK {
     /// The location of the Android NDK based on the `ANDROID_NDK_ROOT` environment variable (falling back to the deprecated but well known `ANDROID_NDK_HOME`).
     /// - seealso: [Configuring NDK Path](https://github.com/android/ndk-samples/wiki/Configure-NDK-Path#terminologies)
-    static var environmentOverrideLocation: AbsolutePath? {
+    internal static var environmentOverrideLocation: AbsolutePath? {
         (getEnvironmentVariable("ANDROID_NDK_ROOT") ?? getEnvironmentVariable("ANDROID_NDK_HOME"))?.nilIfEmpty.map { AbsolutePath($0) } ?? nil
     }
 
     /// Location of the Android NDK installed by the `google-android-ndk-*-installer` family of packages available in Debian 13 "Trixie" and Ubuntu 24.04 "Noble".
     /// These packages are available in non-free / multiverse and multiple versions can be installed simultaneously.
-    static var defaultDebianLocation: AbsolutePath? {
+    fileprivate static var defaultDebianLocation: AbsolutePath? {
         AbsolutePath("/usr/lib/android-ndk")
     }
 }

Sources/SWBAndroidPlatform/Plugin.swift

@@ -26,6 +26,7 @@ public let initializePlugin: PluginInitializationFunction = { manager in
 
 @_spi(Testing) public final class AndroidPlugin: Sendable {
     private let androidSDKInstallations = AsyncCache<OperatingSystem, [AndroidSDK]>()
+    private let androidOverrideNDKInstallation = AsyncCache<OperatingSystem, AndroidSDK.NDK?>()
 
     func cachedAndroidSDKInstallations(host: OperatingSystem) async throws -> [AndroidSDK] {
         try await androidSDKInstallations.value(forKey: host) {
@@ -34,8 +35,22 @@ public let initializePlugin: PluginInitializationFunction = { manager in
         }
     }
 
-    @_spi(Testing) public func effectiveInstallation(host: OperatingSystem) async throws -> (sdk: AndroidSDK, ndk: AndroidSDK.NDK)? {
+    func cachedAndroidOverrideNDKInstallation(host: OperatingSystem) async throws -> AndroidSDK.NDK? {
+        try await androidOverrideNDKInstallation.value(forKey: host) {
+            if let overridePath = AndroidSDK.NDK.environmentOverrideLocation {
+                return try AndroidSDK.NDK(host: host, path: overridePath, fs: localFS)
+            }
+            return nil
+        }
+    }
+
+    @_spi(Testing) public func effectiveInstallation(host: OperatingSystem) async throws -> (sdk: AndroidSDK?, ndk: AndroidSDK.NDK)? {
         guard let androidSdk = try? await cachedAndroidSDKInstallations(host: host).first else {
+            // No SDK, but we might still have a standalone NDK from the env var override
+            if let overrideNDK = try? await cachedAndroidOverrideNDKInstallation(host: host) {
+                return (nil, overrideNDK)
+            }
+
             return nil
         }
 
@@ -63,9 +78,9 @@ struct AndroidEnvironmentExtension: EnvironmentExtension {
     func additionalEnvironmentVariables(context: any EnvironmentExtensionAdditionalEnvironmentVariablesContext) async throws -> [String: String] {
         switch context.hostOperatingSystem {
         case .windows, .macOS, .linux:
-            if let latest = try? await plugin.cachedAndroidSDKInstallations(host: context.hostOperatingSystem).first {
-                let sdkPath = latest.path.path.str
-                let ndkPath = latest.preferredNDK?.path.path.str
+            if let (sdk, ndk) = try? await plugin.effectiveInstallation(host: context.hostOperatingSystem) {
+                let sdkPath = sdk?.path.path.str
+                let ndkPath = ndk.path.path.str
                 return [
                     "ANDROID_HOME": sdkPath,
                     "ANDROID_SDK_ROOT": sdkPath,
@@ -220,7 +235,7 @@ struct AndroidToolchainRegistryExtension: ToolchainRegistryExtension {
     let plugin: AndroidPlugin
 
     func additionalToolchains(context: any ToolchainRegistryExtensionAdditionalToolchainsContext) async throws -> [Toolchain] {
-        guard let toolchainPath = try? await plugin.cachedAndroidSDKInstallations(host: context.hostOperatingSystem).first?.preferredNDK?.toolchainPath else {
+        guard let toolchainPath = try? await plugin.effectiveInstallation(host: context.hostOperatingSystem)?.ndk.toolchainPath else {
             return []
         }
 

Sources/SWBCore/Core.swift

@@ -269,35 +269,35 @@ public final class Core: Sendable {
         self.stopAfterOpeningLibClang = UserDefaults.stopAfterOpeningLibClang
 
         self.toolchainPaths = {
-            var toolchainPaths = [(Path, strict: Bool)]()
+            var toolchainPaths = [ToolchainRegistry.SearchPath]()
 
             switch developerPath {
             case .xcode(let path):
-                toolchainPaths.append((path.join("Toolchains"), strict: path.str.hasSuffix(".app/Contents/Developer")))
+                toolchainPaths.append(.init(path: path.join("Toolchains"), strict: path.str.hasSuffix(".app/Contents/Developer")))
             case .swiftToolchain(let path, xcodeDeveloperPath: let xcodeDeveloperPath):
                 if hostOperatingSystem == .windows {
-                    toolchainPaths.append((path.join("Toolchains"), strict: true))
+                    toolchainPaths.append(.init(path: path.join("Toolchains"), strict: true, aliases: ["default"]))
                 } else {
-                    toolchainPaths.append((path, strict: true))
+                    toolchainPaths.append(.init(path: path, strict: true))
                 }
                 if let xcodeDeveloperPath {
-                    toolchainPaths.append((xcodeDeveloperPath.join("Toolchains"), strict: xcodeDeveloperPath.str.hasSuffix(".app/Contents/Developer")))
+                    toolchainPaths.append(.init(path: xcodeDeveloperPath.join("Toolchains"), strict: xcodeDeveloperPath.str.hasSuffix(".app/Contents/Developer")))
                 }
             }
 
             // FIXME: We should support building the toolchain locally (for `inferiorProductsPath`).
 
-            toolchainPaths.append((Path("/Library/Developer/Toolchains"), strict: false))
+            toolchainPaths.append(.init(path: Path("/Library/Developer/Toolchains"), strict: false))
 
             if let homeString = getEnvironmentVariable("HOME")?.nilIfEmpty {
                 let userToolchainsPath = Path(homeString).join("Library/Developer/Toolchains")
-                toolchainPaths.append((userToolchainsPath, strict: false))
+                toolchainPaths.append(.init(path: userToolchainsPath, strict: false))
             }
 
             if let externalToolchainDirs = getEnvironmentVariable("EXTERNAL_TOOLCHAINS_DIR") ?? environment["EXTERNAL_TOOLCHAINS_DIR"] {
                 let envPaths = externalToolchainDirs.split(separator: Path.pathEnvironmentSeparator)
                 for envPath in envPaths {
-                    toolchainPaths.append((Path(envPath), strict: false))
+                    toolchainPaths.append(.init(path: Path(envPath), strict: false))
                 }
             }
 
@@ -367,7 +367,7 @@ public final class Core: Sendable {
     }()
 
     /// The list of toolchain search paths.
-    @_spi(Testing) public var toolchainPaths: [(Path, strict: Bool)]
+    @_spi(Testing) public var toolchainPaths: [ToolchainRegistry.SearchPath]
 
     /// The platform registry.
     let _platformRegistry: UnsafeDelayedInitializationSendableWrapper<PlatformRegistry> = .init()

Sources/SWBCore/Settings/Settings.swift

@@ -48,7 +48,7 @@ fileprivate struct PreOverridesSettings {
         if let toolchain = core.toolchainRegistry.lookup("default") {
             self.defaultToolchain = toolchain
         } else {
-            core.delegate.error("missing required default toolchain")
+            core.delegate.error("missing required default toolchain (\(core.toolchainRegistry.toolchains.count) loaded toolchain(s): \(core.toolchainRegistry.toolchains.map { $0.identifier }.joined(separator: " "))")
             self.defaultToolchain = nil
         }
 

Sources/SWBCore/ToolchainRegistry.swift

@@ -105,7 +105,7 @@ public final class Toolchain: Hashable, Sendable {
         self.testingLibraryPlatformNames = testingLibraryPlatformNames
     }
 
-    convenience init(path: Path, operatingSystem: OperatingSystem, fs: any FSProxy, pluginManager: any PluginManager, platformRegistry: PlatformRegistry?) async throws {
+    convenience init(path: Path, operatingSystem: OperatingSystem, aliases additionalAliases: Set<String>, fs: any FSProxy, pluginManager: any PluginManager, platformRegistry: PlatformRegistry?) async throws {
         let data: PropertyListItem
 
         do {
@@ -216,6 +216,8 @@ public final class Toolchain: Hashable, Sendable {
             aliases = Toolchain.deriveAliases(path: path, identifier: identifier)
         }
 
+        aliases.formUnion(additionalAliases)
+
         // Framework Search Paths
         var frameworkSearchPaths = Array<String>()
         if let infoFrameworkSearchPaths = items["FallbackFrameworkSearchPaths"] {
@@ -414,6 +416,18 @@ extension Array where Element == Toolchain {
 
 /// The ToolchainRegistry manages the set of registered toolchains.
 public final class ToolchainRegistry: @unchecked Sendable {
+    @_spi(Testing) public struct SearchPath: Sendable {
+        public var path: Path
+        public var strict: Bool
+        public var aliases: Set<String> = []
+
+        public init(path: Path, strict: Bool, aliases: Set<String> = []) {
+            self.path = path
+            self.strict = strict
+            self.aliases = aliases
+        }
+    }
+
     let fs: any FSProxy
     let hostOperatingSystem: OperatingSystem
 
@@ -427,17 +441,19 @@ public final class ToolchainRegistry: @unchecked Sendable {
 
     public static let appleToolchainIdentifierPrefix: String = "com.apple.dt.toolchain."
 
-    @_spi(Testing) public init(delegate: any ToolchainRegistryDelegate, searchPaths: [(Path, strict: Bool)], fs: any FSProxy, hostOperatingSystem: OperatingSystem) async {
+    @_spi(Testing) public init(delegate: any ToolchainRegistryDelegate, searchPaths: [SearchPath], fs: any FSProxy, hostOperatingSystem: OperatingSystem) async {
         self.fs = fs
         self.hostOperatingSystem = hostOperatingSystem
 
-        for (path, strict) in searchPaths {
+        for searchPath in searchPaths {
+            let path = searchPath.path
+            let strict = searchPath.strict
             if !strict && !fs.exists(path) {
                 continue
             }
 
             do {
-                try await registerToolchainsInDirectory(path, strict: strict, operatingSystem: hostOperatingSystem, delegate: delegate)
+                try await registerToolchainsInDirectory(path, strict: strict, aliases: searchPath.aliases, operatingSystem: hostOperatingSystem, delegate: delegate)
             }
             catch let err {
                 delegate.issue(strict: strict, path, "failed to load toolchains in \(path.str): \(err)")
@@ -462,7 +478,7 @@ public final class ToolchainRegistry: @unchecked Sendable {
     }
 
     /// Register all the toolchains in the given directory.
-    private func registerToolchainsInDirectory(_ path: Path, strict: Bool, operatingSystem: OperatingSystem, delegate: any ToolchainRegistryDelegate) async throws {
+    private func registerToolchainsInDirectory(_ path: Path, strict: Bool, aliases: Set<String>, operatingSystem: OperatingSystem, delegate: any ToolchainRegistryDelegate) async throws {
         let toolchainPaths: [Path] = try fs.listdir(path)
             .sorted()
             .map { path.join($0) }
@@ -475,7 +491,7 @@ public final class ToolchainRegistry: @unchecked Sendable {
             guard toolchainPath.basenameWithoutSuffix != "swift-latest" else { continue }
 
             do {
-                let toolchain = try await Toolchain(path: toolchainPath, operatingSystem: operatingSystem, fs: fs, pluginManager: delegate.pluginManager, platformRegistry: delegate.platformRegistry)
+                let toolchain = try await Toolchain(path: toolchainPath, operatingSystem: operatingSystem, aliases: aliases, fs: fs, pluginManager: delegate.pluginManager, platformRegistry: delegate.platformRegistry)
                 try register(toolchain)
             } catch let err {
                 delegate.issue(strict: strict, toolchainPath, "failed to load toolchain: \(err)")
@@ -505,19 +521,10 @@ public final class ToolchainRegistry: @unchecked Sendable {
     /// Look up the toolchain with the given identifier.
     public func lookup(_ identifier: String) -> Toolchain? {
         let lowercasedIdentifier = identifier.lowercased()
-        if hostOperatingSystem == .macOS {
-            if ["default", "xcode"].contains(lowercasedIdentifier) {
-                return toolchainsByIdentifier[ToolchainRegistry.defaultToolchainIdentifier] ?? toolchainsByAlias[lowercasedIdentifier]
-            } else {
-                return toolchainsByIdentifier[identifier] ?? toolchainsByAlias[lowercasedIdentifier]
-            }
+        if ["default", "xcode"].contains(lowercasedIdentifier) {
+            return toolchainsByIdentifier[ToolchainRegistry.defaultToolchainIdentifier] ?? toolchainsByAlias[lowercasedIdentifier]
         } else {
-            // On non-Darwin, assume if there is only one registered toolchain, it is the default.
-            if ["default", "xcode"].contains(lowercasedIdentifier) || identifier == ToolchainRegistry.defaultToolchainIdentifier {
-                return toolchainsByIdentifier[ToolchainRegistry.defaultToolchainIdentifier] ?? toolchainsByAlias[lowercasedIdentifier] ?? toolchainsByIdentifier.values.only
-            } else {
-                return toolchainsByIdentifier[identifier] ?? toolchainsByAlias[lowercasedIdentifier]
-            }
+            return toolchainsByIdentifier[identifier] ?? toolchainsByAlias[lowercasedIdentifier]
         }
     }
 

Tests/SWBAndroidPlatformTests/AndroidSDKTests.swift

@@ -13,7 +13,7 @@
 import Foundation
 @_spi(Testing) import SWBAndroidPlatform
 import SWBTestSupport
-import SWBUtil
+@_spi(Testing) import SWBUtil
 import Testing
 
 @Suite
@@ -415,7 +415,11 @@ fileprivate struct AndroidSDKTests {
             return ndkVersionPath
         }
         let host = try ProcessInfo.processInfo.hostOperatingSystem()
-        try await block(host, fs, sdkPath, ndkVersionPaths.map { try AbsolutePath(validating: $0) })
+
+        // Clear the environment to avoid influence from Android SDK/NDK environment overrides
+        try await withEnvironment([:], clean: true) {
+            try await block(host, fs, sdkPath, ndkVersionPaths.map { try AbsolutePath(validating: $0) })
+        }
     }
 
     private func withNDKVersion(fs: PseudoFS = PseudoFS(), sdkPath: AbsolutePath = .root, version: Version, _ block: (OperatingSystem, any FSProxy, AbsolutePath, AbsolutePath) async throws -> ()) async throws {

Tests/SWBCoreTests/CoreTests.swift

@@ -460,8 +460,8 @@ import SWBServiceCore
         }
         let toolchainPaths = try #require(core?.toolchainPaths)
         for expectedPathString in expectedPathStrings {
-            #expect(toolchainPaths.contains(where: { paths in
-                paths.0 == Path(expectedPathString) && paths.strict == false
+            #expect(toolchainPaths.contains(where: { searchPath in
+                searchPath.path == Path(expectedPathString) && searchPath.strict == false
             }), "Unable to find \(expectedPathString)")
         }
 

Tests/SWBCoreTests/ToolchainRegistryTests.swift

@@ -107,7 +107,7 @@ import SWBServiceCore
                 return
             }
             let delegate = TestDataDelegate(pluginManager: core.pluginManager)
-            let registry = await ToolchainRegistry(delegate: delegate, searchPaths: [(tmpDirPath, strict: strict)], fs: fs, hostOperatingSystem: core.hostOperatingSystem)
+            let registry = await ToolchainRegistry(delegate: delegate, searchPaths: [.init(path: tmpDirPath, strict: strict)], fs: fs, hostOperatingSystem: core.hostOperatingSystem)
             try perform(registry, delegate.warnings, delegate.errors)
         }
     }