Move fallback developer directory determination into the plugin system

jakepetroules · jakepetroules · commit 677320cbd98b · 2025-04-03T23:28:58.000-07:00
This moves some Windows and macOS specific code out of core.
diff --git a/Sources/SWBApplePlatform/Plugin.swift b/Sources/SWBApplePlatform/Plugin.swift
@@ -18,6 +18,7 @@ import Foundation
 import SWBTaskConstruction
 
 @PluginExtensionSystemActor public func initializePlugin(_ manager: PluginManager) {
+    manager.register(AppleDeveloperDirectoryExtension(), type: DeveloperDirectoryExtensionPoint.self)
     manager.register(ApplePlatformSpecsExtension(), type: SpecificationsExtensionPoint.self)
     manager.register(ActoolInputFileGroupingStrategyExtension(), type: InputFileGroupingStrategyExtensionPoint.self)
     manager.register(ImageScaleFactorsInputFileGroupingStrategyExtension(), type: InputFileGroupingStrategyExtensionPoint.self)
@@ -29,6 +30,12 @@ import SWBTaskConstruction
     manager.register(AppleSettingsBuilderExtension(), type: SettingsBuilderExtensionPoint.self)
 }
 
+struct AppleDeveloperDirectoryExtension: DeveloperDirectoryExtension {
+    func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? {
+        try await hostOperatingSystem == .macOS ? Xcode.getActiveDeveloperDirectoryPath() : nil
+    }
+}
+
 struct TaskProducersExtension: TaskProducerExtension {
 
     func createPreSetupTaskProducers(_ context: TaskProducerContext) -> [any TaskProducer] {
diff --git a/Sources/SWBBuildService/BuildServiceEntryPoint.swift b/Sources/SWBBuildService/BuildServiceEntryPoint.swift
@@ -110,6 +110,7 @@ extension BuildService {
             pluginManager.registerExtensionPoint(EnvironmentExtensionPoint())
             pluginManager.registerExtensionPoint(InputFileGroupingStrategyExtensionPoint())
             pluginManager.registerExtensionPoint(TaskProducerExtensionPoint())
+            pluginManager.registerExtensionPoint(DeveloperDirectoryExtensionPoint())
             pluginManager.registerExtensionPoint(DiagnosticToolingExtensionPoint())
             pluginManager.registerExtensionPoint(SDKVariantInfoExtensionPoint())
             pluginManager.registerExtensionPoint(FeatureAvailabilityExtensionPoint())
diff --git a/Sources/SWBCore/CMakeLists.txt b/Sources/SWBCore/CMakeLists.txt
@@ -59,6 +59,7 @@ add_library(SWBCore
   DiagnosticSupport.swift
   EnvironmentBindings.swift
   ExecutableTask.swift
+  Extensions/DeveloperDirectoryExtension.swift
   Extensions/DiagnosticToolingExtension.swift
   Extensions/EnvironmentExtension.swift
   Extensions/FeatureAvailabilityExtension.swift
@@ -71,7 +72,6 @@ add_library(SWBCore
   Extensions/ToolchainRegistryExtension.swift
   FileSystemSignatureBasedCache.swift
   FileToBuild.swift
-  KnownFolders.swift
   LibclangVendored/ArrayExtensions.swift
   LibclangVendored/CStringArray.swift
   LibclangVendored/Libclang.swift
diff --git a/Sources/SWBCore/Core.swift b/Sources/SWBCore/Core.swift
@@ -51,20 +51,30 @@ public final class Core: Sendable {
                 return nil
             }
 
+            #if USE_STATIC_PLUGIN_INITIALIZATION
+            // In a package context, plugins are statically linked into the build system.
+            // Load specs from service plugins if requested since we don't have a Service in certain tests
+            // Here we don't have access to `core.pluginPaths` like we do in the call below,
+            // but it doesn't matter because it will return an empty array when USE_STATIC_PLUGIN_INITIALIZATION is defined.
+            await extraPluginRegistration([])
+            #endif
+
             let resolvedDeveloperPath: String
             do {
                 if let resolved = developerPath?.nilIfEmpty?.str {
                     resolvedDeveloperPath = resolved
-                } else if hostOperatingSystem == .macOS {
-                    resolvedDeveloperPath = try await Xcode.getActiveDeveloperDirectoryPath().str
-                } else if hostOperatingSystem == .windows {
-                    guard let userProgramFiles = URL.userProgramFiles, let swiftPath = try? userProgramFiles.appending(component: "Swift").filePath else {
-                        delegate.error("Could not determine path to user program files")
+                } else {
+                    let values = try await Set(pluginManager.extensions(of: DeveloperDirectoryExtensionPoint.self).asyncMap { try await $0.fallbackDeveloperDirectory(hostOperatingSystem: hostOperatingSystem) }).compactMap { $0 }
+                    switch values.count {
+                    case 0:
+                        delegate.error("Could not determine path to developer directory because no extensions provided a fallback value")
+                        return nil
+                    case 1:
+                        resolvedDeveloperPath = values[0].str
+                    default:
+                        delegate.error("Could not determine path to developer directory because multiple extensions provided conflicting fallback values: \(values.sorted().map { $0.str }.joined(separator: ", "))")
                         return nil
                     }
-                    resolvedDeveloperPath = swiftPath.str
-                } else {
-                    resolvedDeveloperPath = "/"
                 }
             } catch {
                 delegate.error("Could not determine path to developer directory: \(error)")
@@ -93,8 +103,11 @@ public final class Core: Sendable {
                 }
             }
 
+            #if !USE_STATIC_PLUGIN_INITIALIZATION
+            // In a package context, plugins are statically linked into the build system.
             // Load specs from service plugins if requested since we don't have a Service in certain tests
             await extraPluginRegistration(core.pluginPaths)
+            #endif
 
             await core.initializeSpecRegistry()
 
diff --git a/Sources/SWBCore/Extensions/DeveloperDirectoryExtension.swift b/Sources/SWBCore/Extensions/DeveloperDirectoryExtension.swift
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+public import SWBUtil
+
+public struct DeveloperDirectoryExtensionPoint: ExtensionPoint {
+    public typealias ExtensionProtocol = DeveloperDirectoryExtension
+
+    public static let name = "DeveloperDirectoryExtensionPoint"
+
+    public init() {}
+}
+
+public protocol DeveloperDirectoryExtension: Sendable {
+    func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path?
+}
diff --git a/Sources/SWBCore/KnownFolders.swift b/Sources/SWBCore/KnownFolders.swift
diff --git a/Sources/SWBGenericUnixPlatform/Plugin.swift b/Sources/SWBGenericUnixPlatform/Plugin.swift
@@ -15,12 +15,24 @@ import SWBCore
 import Foundation
 
 @PluginExtensionSystemActor public func initializePlugin(_ manager: PluginManager) {
+    manager.register(GenericUnixDeveloperDirectoryExtension(), type: DeveloperDirectoryExtensionPoint.self)
     manager.register(GenericUnixPlatformSpecsExtension(), type: SpecificationsExtensionPoint.self)
     manager.register(GenericUnixPlatformInfoExtension(), type: PlatformInfoExtensionPoint.self)
     manager.register(GenericUnixSDKRegistryExtension(), type: SDKRegistryExtensionPoint.self)
     manager.register(GenericUnixToolchainRegistryExtension(), type: ToolchainRegistryExtensionPoint.self)
 }
 
+struct GenericUnixDeveloperDirectoryExtension: DeveloperDirectoryExtension {
+    func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? {
+        if hostOperatingSystem == .windows || hostOperatingSystem == .macOS {
+            // Handled by the Windows and Apple plugins
+            return nil
+        }
+
+        return .root
+    }
+}
+
 struct GenericUnixPlatformSpecsExtension: SpecificationsExtension {
     func specificationFiles(resourceSearchPaths: [Path]) -> Bundle? {
         findResourceBundle(nameWhenInstalledInToolchain: "SwiftBuild_SWBGenericUnixPlatform", resourceSearchPaths: resourceSearchPaths, defaultBundle: Bundle.module)
diff --git a/Sources/SWBTestSupport/CoreTestSupport.swift b/Sources/SWBTestSupport/CoreTestSupport.swift
@@ -89,6 +89,7 @@ extension Core {
             pluginManager.registerExtensionPoint(EnvironmentExtensionPoint())
             pluginManager.registerExtensionPoint(InputFileGroupingStrategyExtensionPoint())
             pluginManager.registerExtensionPoint(TaskProducerExtensionPoint())
+            pluginManager.registerExtensionPoint(DeveloperDirectoryExtensionPoint())
             pluginManager.registerExtensionPoint(DiagnosticToolingExtensionPoint())
             pluginManager.registerExtensionPoint(SDKVariantInfoExtensionPoint())
             pluginManager.registerExtensionPoint(FeatureAvailabilityExtensionPoint())
diff --git a/Sources/SWBWindowsPlatform/Plugin.swift b/Sources/SWBWindowsPlatform/Plugin.swift
@@ -16,6 +16,7 @@ import Foundation
 
 @PluginExtensionSystemActor public func initializePlugin(_ manager: PluginManager) {
     let plugin = WindowsPlugin()
+    manager.register(WindowsDeveloperDirectoryExtension(), type: DeveloperDirectoryExtensionPoint.self)
     manager.register(WindowsPlatformSpecsExtension(), type: SpecificationsExtensionPoint.self)
     manager.register(WindowsEnvironmentExtension(plugin: plugin), type: EnvironmentExtensionPoint.self)
     manager.register(WindowsPlatformExtension(plugin: plugin), type: PlatformInfoExtensionPoint.self)
@@ -51,6 +52,18 @@ public final class WindowsPlugin: Sendable {
     }
 }
 
+struct WindowsDeveloperDirectoryExtension: DeveloperDirectoryExtension {
+    func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? {
+        guard hostOperatingSystem == .windows else {
+            return nil
+        }
+        guard let userProgramFiles = URL.userProgramFiles, let swiftPath = try? userProgramFiles.appending(component: "Swift").filePath else {
+            throw StubError.error("Could not determine path to user program files")
+        }
+        return swiftPath
+    }
+}
+
 struct WindowsPlatformSpecsExtension: SpecificationsExtension {
     func specificationFiles(resourceSearchPaths: [Path]) -> Bundle? {
         findResourceBundle(nameWhenInstalledInToolchain: "SwiftBuild_SWBWindowsPlatform", resourceSearchPaths: resourceSearchPaths, defaultBundle: Bundle.module)
diff --git a/Tests/SWBCoreTests/CoreTests.swift b/Tests/SWBCoreTests/CoreTests.swift
@@ -378,9 +378,15 @@ import Foundation
     func toolchainPathsCount() async throws -> Int {
         let delegate = Delegate()
         let pluginManager = await PluginManager(skipLoadingPluginIdentifiers: [])
+        await pluginManager.registerExtensionPoint(DeveloperDirectoryExtensionPoint())
         await pluginManager.registerExtensionPoint(SpecificationsExtensionPoint())
         await pluginManager.registerExtensionPoint(ToolchainRegistryExtensionPoint())
         await pluginManager.register(BuiltinSpecsExtension(), type: SpecificationsExtensionPoint.self)
+        struct MockDeveloperDirectoryExtensionPoint: DeveloperDirectoryExtension {
+            func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? {
+                .root
+            }
+        }
         struct MockToolchainExtension: ToolchainRegistryExtension {
             func additionalToolchains(context: any ToolchainRegistryExtensionAdditionalToolchainsContext) async throws -> [Toolchain] {
                 guard context.toolchainRegistry.lookup(ToolchainRegistry.defaultToolchainIdentifier) == nil else {
@@ -389,6 +395,7 @@ import Foundation
                 return [Toolchain(identifier: ToolchainRegistry.defaultToolchainIdentifier, displayName: "Mock", version: Version(), aliases: ["default"], path: .root, frameworkPaths: [], libraryPaths: [], defaultSettings: [:], overrideSettings: [:], defaultSettingsWhenPrimary: [:], executableSearchPaths: [], testingLibraryPlatformNames: [], fs: context.fs)]
             }
         }
+        await pluginManager.register(MockDeveloperDirectoryExtensionPoint(), type: DeveloperDirectoryExtensionPoint.self)
         await pluginManager.register(MockToolchainExtension(), type: ToolchainRegistryExtensionPoint.self)
         let core = await Core.getInitializedCore(delegate, pluginManager: pluginManager, inferiorProductsPath: Path.root.join("invalid"), environment: [:], buildServiceModTime: Date(), connectionMode: .inProcess)
         for diagnostic in delegate.diagnostics {
@@ -416,9 +423,15 @@ import Foundation
     func testExternalToolchainPath(environmentOverrides: [String:String], expecting expectedPathStrings: [String], _ originalToolchainCount: Int) async throws {
         let delegate = Delegate()
         let pluginManager = await PluginManager(skipLoadingPluginIdentifiers: [])
+        await pluginManager.registerExtensionPoint(DeveloperDirectoryExtensionPoint())
         await pluginManager.registerExtensionPoint(SpecificationsExtensionPoint())
         await pluginManager.registerExtensionPoint(ToolchainRegistryExtensionPoint())
         await pluginManager.register(BuiltinSpecsExtension(), type: SpecificationsExtensionPoint.self)
+        struct MockDeveloperDirectoryExtensionPoint: DeveloperDirectoryExtension {
+            func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? {
+                .root
+            }
+        }
         struct MockToolchainExtension: ToolchainRegistryExtension {
             func additionalToolchains(context: any ToolchainRegistryExtensionAdditionalToolchainsContext) async throws -> [Toolchain] {
                 guard context.toolchainRegistry.lookup(ToolchainRegistry.defaultToolchainIdentifier) == nil else {
@@ -427,6 +440,7 @@ import Foundation
                 return [Toolchain(identifier: ToolchainRegistry.defaultToolchainIdentifier, displayName: "Mock", version: Version(), aliases: ["default"], path: .root, frameworkPaths: [], libraryPaths: [], defaultSettings: [:], overrideSettings: [:], defaultSettingsWhenPrimary: [:], executableSearchPaths: [], testingLibraryPlatformNames: [], fs: context.fs)]
             }
         }
+        await pluginManager.register(MockDeveloperDirectoryExtensionPoint(), type: DeveloperDirectoryExtensionPoint.self)
         await pluginManager.register(MockToolchainExtension(), type: ToolchainRegistryExtensionPoint.self)
         let core = await Core.getInitializedCore(delegate, pluginManager: pluginManager, inferiorProductsPath: Path.root.join("invalid"), environment: environmentOverrides, buildServiceModTime: Date(), connectionMode: .inProcess)
         for diagnostic in delegate.diagnostics {
diff --git a/Tests/SWBCoreTests/ToolchainRegistryTests.swift b/Tests/SWBCoreTests/ToolchainRegistryTests.swift
@@ -70,9 +70,15 @@ import SWBUtil
             }
 
             let pluginManager = await PluginManager(skipLoadingPluginIdentifiers: [])
+            await pluginManager.registerExtensionPoint(DeveloperDirectoryExtensionPoint())
             await pluginManager.registerExtensionPoint(SpecificationsExtensionPoint())
             await pluginManager.registerExtensionPoint(ToolchainRegistryExtensionPoint())
             await pluginManager.register(BuiltinSpecsExtension(), type: SpecificationsExtensionPoint.self)
+            struct MockDeveloperDirectoryExtensionPoint: DeveloperDirectoryExtension {
+                func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? {
+                    .root
+                }
+            }
             struct MockToolchainExtension: ToolchainRegistryExtension {
                 func additionalToolchains(context: any ToolchainRegistryExtensionAdditionalToolchainsContext) async throws -> [Toolchain] {
                     guard context.toolchainRegistry.lookup(ToolchainRegistry.defaultToolchainIdentifier) == nil else {
@@ -81,8 +87,20 @@ import SWBUtil
                     return [Toolchain(identifier: ToolchainRegistry.defaultToolchainIdentifier, displayName: "Mock", version: Version(), aliases: ["default"], path: .root, frameworkPaths: [], libraryPaths: [], defaultSettings: [:], overrideSettings: [:], defaultSettingsWhenPrimary: [:], executableSearchPaths: [], testingLibraryPlatformNames: [], fs: context.fs)]
                 }
             }
+            await pluginManager.register(MockDeveloperDirectoryExtensionPoint(), type: DeveloperDirectoryExtensionPoint.self)
             await pluginManager.register(MockToolchainExtension(), type: ToolchainRegistryExtensionPoint.self)
-            let core = try #require(await Core.getInitializedCore(TestingCoreDelegate(), pluginManager: pluginManager, inferiorProductsPath: Path.root.join("invalid"), environment: [:], buildServiceModTime: Date(), connectionMode: .inProcess))
+            let coreDelegate = TestingCoreDelegate()
+            let core = await Core.getInitializedCore(coreDelegate, pluginManager: pluginManager, inferiorProductsPath: Path.root.join("invalid"), environment: [:], buildServiceModTime: Date(), connectionMode: .inProcess)
+            guard let core else {
+                let errors = coreDelegate.diagnostics.filter { $0.behavior == .error }
+                for error in errors {
+                    Issue.record(Comment(rawValue: error.formatLocalizedDescription(.debugWithoutBehavior)))
+                }
+                if errors.isEmpty {
+                    Issue.record("Failed to initialize core but no errors were provided")
+                }
+                return
+            }
             let delegate = TestDataDelegate(pluginManager: core.pluginManager)
             let registry = await ToolchainRegistry(delegate: delegate, searchPaths: [(tmpDirPath, strict: strict)], fs: fs, hostOperatingSystem: core.hostOperatingSystem)
             try perform(registry, delegate.warnings, delegate.errors)
