SWBCore: Resolve miscellaneous Swift 6 adoption issues

Author: owenv

Sources/SWBApplePlatform/InterfaceBuilderCompiler.swift

@@ -13,19 +13,20 @@
 import SWBUtil
 public import SWBCore
 public import SWBMacro
+import Synchronization
 
 public class IbtoolCompilerSpec : GenericCompilerSpec, IbtoolCompilerSupport, @unchecked Sendable {
     /// The info object collects information across the build phase so that an ibtool task doesn't try to produce a ~device output which is already being explicitly produced from another input.
-    private final class BuildPhaseInfo: BuildPhaseInfoForToolSpec {
-        var allInputFilenames = Set<String>()
+    private final class BuildPhaseInfo: BuildPhaseInfoForToolSpec, Sendable {
+        let allInputFilenames = SWBMutex<Set<String>>([])
 
         func addToContext(_ ftb: FileToBuild) {
             // Only collect info about files we want to match against.
             // FIXME: We should be using FileTypeSpec.conformsTo() here, but we don't have a good way in this context to look up the file type.
             guard ftb.fileType.identifier == "file.xib" else {
                 return
             }
-            allInputFilenames.insert(ftb.absolutePath.basenameWithoutSuffix)
+            allInputFilenames.withLock{ $0.insert(ftb.absolutePath.basenameWithoutSuffix) }
         }
 
         func filterOutputFiles(_ outputs: [any PlannedNode], inputs: [Path]) -> [any PlannedNode] {
@@ -40,7 +41,7 @@ public class IbtoolCompilerSpec : GenericCompilerSpec, IbtoolCompilerSupport, @u
                 }
 
                 // If this output filename is among any of the input filenames that *aren't* one of our own inputs, then we remove it.
-                let otherInputFilenames = allInputFilenames.subtracting(inputFilenames)
+                let otherInputFilenames = allInputFilenames.withLock({ $0.subtracting(inputFilenames) })
                 guard !otherInputFilenames.contains(outputFilename) else {
                     return false
                 }

Sources/SWBCore/Apple/DeviceFamily.swift

@@ -82,7 +82,7 @@ public struct DeviceFamily: Decodable, Hashable, Sendable {
     }
 }
 
-public struct DeviceFamilies: Hashable {
+public struct DeviceFamilies: Hashable, Sendable {
     @_spi(Testing) public let list: [DeviceFamily]
 
     /// Used for platforms where a numeric `UIDeviceFamily` value is not used, but a device family name must still be passed to asset processing tools via the `--target-device` flag. Mutually exclusive with `deviceFamiliesByIdentifier`.

Sources/SWBCore/Core.swift

@@ -116,6 +116,8 @@ public final class Core: Sendable {
             await core.initializeToolchainRegistry()
 
             // Force loading SDKs.
+            let sdkPaths = core.platformRegistry.platforms.flatMap { platform in platform.sdkSearchPaths.map { ($0, platform) } }
+            core._sdkRegistry.initialize(to: SDKRegistry(delegate: core.registryDelegate, searchPaths: sdkPaths, type: .builtin, hostOperatingSystem: hostOperatingSystem))
             let sdkRegistry = core.sdkRegistry
 
             struct Context: SDKRegistryExtensionAdditionalSDKsContext {
@@ -143,8 +145,8 @@ public final class Core: Sendable {
 
             // FIXME: <rdar://problem/36364112> We should also perform late binding of the toolchains' settings here.  Presently this is done when a Settings object which uses a toolchain is constructed.
 
-            // Force loading the CoreSettings (which can emit errors about missing required specs).
-            let _ = core.coreSettings
+            // Initialize the CoreSettings (which can emit errors about missing required specs).
+            core._coreSettings.initialize(to: CoreSettings(core))
 
             // If there were any loading errors, discard the core.
             if delegate.hasErrors {
@@ -308,9 +310,10 @@ public final class Core: Sendable {
     }
 
     /// The shared core settings object.
-    @_spi(Testing) public lazy var coreSettings: CoreSettings = {
-        return CoreSettings(self)
-    }()
+    let _coreSettings = UnsafeDelayedInitializationSendableWrapper<CoreSettings>()
+    @_spi(Testing) public var coreSettings: CoreSettings {
+        _coreSettings.value
+    }
 
     /// The list of plugin search paths.
     private static func pluginPaths(inferiorProductsPath: Path?, developerPath: DeveloperPath) -> [Path] {
@@ -361,13 +364,8 @@ public final class Core: Sendable {
         return result.map { $0.normalize() }
     }
 
-    /// The list of SDK search paths.
-    @_spi(Testing) public lazy var sdkPaths: [(Path, Platform?)] = {
-        return self.platformRegistry.platforms.flatMap { platform in platform.sdkSearchPaths.map { ($0, platform) } }
-    }()
-
     /// The list of toolchain search paths.
-    @_spi(Testing) public var toolchainPaths: [ToolchainRegistry.SearchPath]
+    @_spi(Testing) public let toolchainPaths: [ToolchainRegistry.SearchPath]
 
     /// The platform registry.
     let _platformRegistry: UnsafeDelayedInitializationSendableWrapper<PlatformRegistry> = .init()
@@ -380,12 +378,16 @@ public final class Core: Sendable {
     }
 
     /// The SDK registry for Xcode's builtin SDKs. Clients should generally use `WorkspaceContext.sdkRegistry` to include dynamically discovered SDKs.
-    public lazy var sdkRegistry: SDKRegistry = {
-        return SDKRegistry(delegate: self.registryDelegate, searchPaths: self.sdkPaths, type: .builtin, hostOperatingSystem: hostOperatingSystem)
-    }()
+    let _sdkRegistry = UnsafeDelayedInitializationSendableWrapper<SDKRegistry>()
+    public var sdkRegistry: SDKRegistry {
+        _sdkRegistry.value
+    }
 
     /// The toolchain registry.
-    public private(set) var toolchainRegistry: ToolchainRegistry! = nil
+    let _toolchainRegistry = UnsafeDelayedInitializationSendableWrapper<ToolchainRegistry>()
+    public var toolchainRegistry: ToolchainRegistry {
+        _toolchainRegistry.value
+    }
 
     private let libclangRegistry = Registry<Path, (Libclang?, Version?)>()
     private let stopAfterOpeningLibClang: Bool
@@ -427,16 +429,11 @@ public final class Core: Sendable {
     }
 
     /// The specification registry.
+    private let _specRegistry = UnsafeDelayedInitializationSendableWrapper<SpecRegistry>()
     public var specRegistry: SpecRegistry {
-        guard let specRegistry = _specRegistry else {
-            // FIXME: We should structure the initialization path better and remove reliance on `lazy var` so that this can be handled more cleanly.
-            preconditionFailure("Spec registry not initialized.")
-        }
-        return specRegistry
+        return _specRegistry.value
     }
 
-    private var _specRegistry: SpecRegistry?
-
     @_spi(Testing) public func initializePlatformRegistry() async {
         var searchPaths: [Path]
         let fs = localFS
@@ -466,19 +463,17 @@ public final class Core: Sendable {
 
 
     private func initializeToolchainRegistry() async {
-        self.toolchainRegistry = await ToolchainRegistry(delegate: self.registryDelegate, searchPaths: self.toolchainPaths, fs: localFS, hostOperatingSystem: hostOperatingSystem)
+        self._toolchainRegistry.initialize(to: await ToolchainRegistry(delegate: self.registryDelegate, searchPaths: self.toolchainPaths, fs: localFS, hostOperatingSystem: hostOperatingSystem))
     }
 
     @_spi(Testing) public func initializeSpecRegistry() async {
-        precondition(_specRegistry == nil)
-
         var domainInclusions: [String: [String]] = [:]
 
         // Compute the complete list of search paths (and default domains).
         var searchPaths = additionalContentPaths.map { ($0, "") }
 
         // Find all plugin provided specs.
-        for ext in await self.pluginManager.extensions(of: SpecificationsExtensionPoint.self) {
+        for ext in self.pluginManager.extensions(of: SpecificationsExtensionPoint.self) {
             if let bundle = ext.specificationFiles(resourceSearchPaths: resourceSearchPaths) {
                 for url in bundle.urls(forResourcesWithExtension: "xcspec", subdirectory: nil) ?? [] {
                     do {
@@ -498,7 +493,7 @@ public final class Core: Sendable {
             }
         }
 
-        _specRegistry = await SpecRegistry(self.pluginManager, self.registryDelegate, searchPaths, domainInclusions, [:])
+        _specRegistry.initialize(to: await SpecRegistry(self.pluginManager, self.registryDelegate, searchPaths, domainInclusions, [:]))
     }
 
     /// Force all specs to be loaded.

Sources/SWBCore/Extensions/SettingsBuilderExtension.swift

@@ -23,7 +23,7 @@ public struct SettingsBuilderExtensionPoint: ExtensionPoint {
     public init() {}
 }
 
-public protocol SettingsBuilderExtension {
+public protocol SettingsBuilderExtension: Sendable {
     /// Provides a table of additional build properties overrides
     func addOverrides(fromEnvironment: [String:String], parameters: BuildParameters) throws -> [String:String]
 

Sources/SWBCore/FileToBuild.swift

@@ -15,7 +15,7 @@ public import SWBProtocol
 public import SWBMacro
 
 /// Represents a file to be passed as input to some part of the build machinery.  May be a source file originally sent down with the PIF, or might be a temporary file.  Once a build rule action has been determined, it is assigned to the FileToBuild so it doesn’t have to be looked up again.  Note that the term “file” here is used in the loosest sense — the path can refer to any file system entity.
-public struct FileToBuild : Hashable {
+public struct FileToBuild : Hashable, Sendable {
     /// Absolute path of the referenced file.
     public let absolutePath: Path
 

Sources/SWBCore/LinkageDependencyResolver.swift

@@ -161,18 +161,19 @@ actor LinkageDependencyResolver {
 
         // Even though we do not want to include target dependencies in the graph, we still need to traverse them.
         let linkedTargets = linkageDependencies.map { $0.target.target }
-        let targetDependencies: [ResolvedTargetDependency] = await resolver.explicitDependencies(for: configuredTarget).asyncMap { target in
+        var targetDependencies: [ResolvedTargetDependency] = []
+        for target in resolver.explicitDependencies(for: configuredTarget) {
             guard !linkedTargets.contains(target) else {
-                return nil
+                continue
             }
             let buildParameters = resolver.buildParametersByTarget[target] ?? configuredTarget.parameters
-            if await !resolver.isTargetSuitableForPlatformForIndex(target, parameters: buildParameters, imposedParameters: imposedParameters) {
-                return nil
+            if !resolver.isTargetSuitableForPlatformForIndex(target, parameters: buildParameters, imposedParameters: imposedParameters) {
+                continue
             }
             let effectiveImposedParameters = imposedParameters?.effectiveParameters(target: configuredTarget, dependency: ConfiguredTarget(parameters: buildParameters, target: target), dependencyResolver: resolver)
             let configuredDependency = await resolver.lookupConfiguredTarget(target, parameters: buildParameters, imposedParameters: effectiveImposedParameters)
-            return ResolvedTargetDependency(target: configuredDependency, reason: .explicit)
-        }.compactMap { $0 }
+            targetDependencies.append(ResolvedTargetDependency(target: configuredDependency, reason: .explicit))
+        }
         let dependencies = linkageDependencies + targetDependencies
 
         // If we have no dependencies, we are done.
@@ -465,23 +466,23 @@ actor LinkageDependencyResolver {
     }
 
     private func implicitDependency(forModuleName moduleName: String, from configuredTarget: ConfiguredTarget, imposedParameters: SpecializationParameters?, source: ImplicitDependencySource) async -> ConfiguredTarget? {
-        let candidateConfiguredTargets = await (targetsByUnconfiguredModuleName[moduleName] ?? []).asyncMap { [self] candidateTarget -> ConfiguredTarget? in
+        var candidateConfiguredTargets: [ConfiguredTarget] = []
+        for candidateTarget in (targetsByUnconfiguredModuleName[moduleName] ?? []) {
             // Prefer overriding build parameters from the build request, if present.
-            let buildParameters = resolver.buildParametersByTarget[candidateTarget] ?? configuredTarget.parameters
+            let buildParameters = self.resolver.buildParametersByTarget[candidateTarget] ?? configuredTarget.parameters
 
             // Validate the module name using concrete parameters.
-            let configuredModuleName = buildRequestContext.getCachedSettings(buildParameters, target: candidateTarget).globalScope.evaluate(BuiltinMacros.PRODUCT_MODULE_NAME)
+            let configuredModuleName = self.resolver.buildRequestContext.getCachedSettings(buildParameters, target: candidateTarget).globalScope.evaluate(BuiltinMacros.PRODUCT_MODULE_NAME)
             if configuredModuleName != moduleName {
-                return nil
+                continue
             }
 
             // Get a configured target for this target, and use it as the implicit dependency.
-            if let candidateConfiguredTarget = await implicitDependency(candidate: candidateTarget, parameters: buildParameters, isValidFor: configuredTarget, imposedParameters: imposedParameters, resolver: resolver) {
-                return candidateConfiguredTarget
+            if let candidateConfiguredTarget = await self.implicitDependency(candidate: candidateTarget, parameters: buildParameters, isValidFor: configuredTarget, imposedParameters: imposedParameters, resolver: resolver) {
+                candidateConfiguredTargets.append(candidateConfiguredTarget)
             }
-
-            return nil
-        }.compactMap { $0 }.sorted()
+        }
+        candidateConfiguredTargets.sort()
 
         emitAmbiguousImplicitDependencyWarningIfNeeded(for: configuredTarget, dependencies: candidateConfiguredTargets, from: source)