diff --git a/Sources/SWBApplePlatform/Plugin.swift b/Sources/SWBApplePlatform/Plugin.swift index 6be46f8e..2288a849 100644 --- a/Sources/SWBApplePlatform/Plugin.swift +++ b/Sources/SWBApplePlatform/Plugin.swift @@ -31,8 +31,8 @@ import SWBTaskConstruction } struct AppleDeveloperDirectoryExtension: DeveloperDirectoryExtension { - func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? { - try await hostOperatingSystem == .macOS ? Xcode.getActiveDeveloperDirectoryPath() : nil + func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Core.DeveloperPath? { + try await hostOperatingSystem == .macOS ? .xcode(Xcode.getActiveDeveloperDirectoryPath()) : nil } } diff --git a/Sources/SWBCore/Core.swift b/Sources/SWBCore/Core.swift index 4864e81c..238a2e92 100644 --- a/Sources/SWBCore/Core.swift +++ b/Sources/SWBCore/Core.swift @@ -70,14 +70,9 @@ public final class Core: Sendable { delegate.error("Could not determine path to developer directory because no extensions provided a fallback value") return nil case 1: - let path = values[0] - if path.str.hasSuffix(".app/Contents/Developer") { - resolvedDeveloperPath = .xcode(path) - } else { - resolvedDeveloperPath = .fallback(values[0]) - } + resolvedDeveloperPath = values[0] default: - delegate.error("Could not determine path to developer directory because multiple extensions provided conflicting fallback values: \(values.sorted().map { $0.str }.joined(separator: ", "))") + delegate.error("Could not determine path to developer directory because multiple extensions provided conflicting fallback values: \(values.map { $0.path.str }.sorted().joined(separator: ", "))") return nil } } @@ -181,12 +176,9 @@ public final class Core: Sendable { // A path to the root of a Swift toolchain, optionally paired with the developer path of an installed Xcode case swiftToolchain(Path, xcodeDeveloperPath: Path?) - // A fallback resolved path. - case fallback(Path) - public var path: Path { switch self { - case .xcode(let path), .swiftToolchain(let path, xcodeDeveloperPath: _), .fallback(let path): + case .xcode(let path), .swiftToolchain(let path, xcodeDeveloperPath: _): return path } } @@ -259,7 +251,7 @@ public final class Core: Sendable { self.xcodeProductBuildVersion = ProductBuildVersion(major: 99, train: "T", build: 999) self.xcodeProductBuildVersionString = xcodeProductBuildVersion.description } - case .swiftToolchain, .fallback: + case .swiftToolchain: // FIXME: Eliminate this requirment for Swift toolchains self.xcodeVersion = Version(99, 99, 99) self.xcodeProductBuildVersion = ProductBuildVersion(major: 99, train: "T", build: 999) @@ -277,12 +269,14 @@ public final class Core: Sendable { case .xcode(let path): toolchainPaths.append((path.join("Toolchains"), strict: path.str.hasSuffix(".app/Contents/Developer"))) case .swiftToolchain(let path, xcodeDeveloperPath: let xcodeDeveloperPath): - toolchainPaths.append((path, strict: true)) + if hostOperatingSystem == .windows { + toolchainPaths.append((path.join("Toolchains"), strict: true)) + } else { + toolchainPaths.append((path, strict: true)) + } if let xcodeDeveloperPath { toolchainPaths.append((xcodeDeveloperPath.join("Toolchains"), strict: xcodeDeveloperPath.str.hasSuffix(".app/Contents/Developer"))) } - case .fallback(let path): - toolchainPaths.append((path.join("Toolchains"), strict: false)) } // FIXME: We should support building the toolchain locally (for `inferiorProductsPath`). @@ -418,7 +412,7 @@ public final class Core: Sendable { let pluginPath = path.join("usr/lib/libToolchainCASPlugin.dylib") let plugin = try? ToolchainCASPlugin(dylib: pluginPath) casPlugin = plugin - case .swiftToolchain, .fallback: + case .swiftToolchain: // Unimplemented break } @@ -454,8 +448,6 @@ public final class Core: Sendable { } else { searchPaths = [] } - case .fallback: - searchPaths = [] } } if let additionalPlatformSearchPaths = getEnvironmentVariable("XCODE_EXTRA_PLATFORM_FOLDERS") { diff --git a/Sources/SWBCore/Extensions/DeveloperDirectoryExtension.swift b/Sources/SWBCore/Extensions/DeveloperDirectoryExtension.swift index 9dc0db37..3e69177c 100644 --- a/Sources/SWBCore/Extensions/DeveloperDirectoryExtension.swift +++ b/Sources/SWBCore/Extensions/DeveloperDirectoryExtension.swift @@ -21,5 +21,5 @@ public struct DeveloperDirectoryExtensionPoint: ExtensionPoint { } public protocol DeveloperDirectoryExtension: Sendable { - func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? + func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Core.DeveloperPath? } diff --git a/Sources/SWBCore/MacroConfigFileLoader.swift b/Sources/SWBCore/MacroConfigFileLoader.swift index 224e5e9f..2d5e4248 100644 --- a/Sources/SWBCore/MacroConfigFileLoader.swift +++ b/Sources/SWBCore/MacroConfigFileLoader.swift @@ -133,7 +133,7 @@ final class MacroConfigFileLoader: Sendable { // FIXME: Move this to its proper home, and support the other special cases Xcode has (PLATFORM_DIR and SDK_DIR). This should move to using a generic facility, e.g., source trees: Add search paths for .xcconfig macros to match what Xcode has if path.str.hasPrefix("") { switch developerPath { - case .xcode(let developerPath), .swiftToolchain(let developerPath, _), .fallback(let developerPath): + case .xcode(let developerPath), .swiftToolchain(let developerPath, _): path = Path(path.str.replacingOccurrences(of: "", with: developerPath.str)) } } diff --git a/Sources/SWBCore/Settings/Settings.swift b/Sources/SWBCore/Settings/Settings.swift index eb3b72cc..bc9b7e62 100644 --- a/Sources/SWBCore/Settings/Settings.swift +++ b/Sources/SWBCore/Settings/Settings.swift @@ -1026,7 +1026,7 @@ extension WorkspaceContext { // Add the standard search paths. switch core.developerPath { - case .xcode(let path), .fallback(let path): + case .xcode(let path): paths.append(path.join("usr").join("bin")) paths.append(path.join("usr").join("local").join("bin")) case .swiftToolchain(let path, let xcodeDeveloperPath): diff --git a/Sources/SWBGenericUnixPlatform/Plugin.swift b/Sources/SWBGenericUnixPlatform/Plugin.swift index e4679961..128fde75 100644 --- a/Sources/SWBGenericUnixPlatform/Plugin.swift +++ b/Sources/SWBGenericUnixPlatform/Plugin.swift @@ -23,13 +23,13 @@ import Foundation } struct GenericUnixDeveloperDirectoryExtension: DeveloperDirectoryExtension { - func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? { + func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Core.DeveloperPath? { if hostOperatingSystem == .windows || hostOperatingSystem == .macOS { // Handled by the Windows and Apple plugins return nil } - return .root + return .swiftToolchain(.root, xcodeDeveloperPath: nil) } } diff --git a/Sources/SWBTestSupport/CoreTestSupport.swift b/Sources/SWBTestSupport/CoreTestSupport.swift index 356345fa..e95da70f 100644 --- a/Sources/SWBTestSupport/CoreTestSupport.swift +++ b/Sources/SWBTestSupport/CoreTestSupport.swift @@ -38,7 +38,7 @@ extension Core { if hostOperatingSystem == .macOS { developerPath = .xcode(try await Xcode.getActiveDeveloperDirectoryPath()) } else { - developerPath = .fallback(Path.root) + developerPath = .swiftToolchain(.root, xcodeDeveloperPath: nil) } let delegate = TestingCoreDelegate() return await (try Core(delegate: delegate, hostOperatingSystem: hostOperatingSystem, pluginManager: PluginManager(skipLoadingPluginIdentifiers: []), developerPath: developerPath, resourceSearchPaths: [], inferiorProductsPath: nil, additionalContentPaths: [], environment: [:], buildServiceModTime: Date(), connectionMode: .inProcess), delegate.diagnostics) diff --git a/Sources/SWBTestSupport/DummyCommandProducer.swift b/Sources/SWBTestSupport/DummyCommandProducer.swift index de335df2..021ee8fd 100644 --- a/Sources/SWBTestSupport/DummyCommandProducer.swift +++ b/Sources/SWBTestSupport/DummyCommandProducer.swift @@ -60,7 +60,7 @@ package struct MockCommandProducer: CommandProducer, Sendable { paths.append(path) } switch core.developerPath { - case .xcode(let path), .fallback(let path): + case .xcode(let path): paths.append(path.join("usr").join("bin")) paths.append(path.join("usr").join("local").join("bin")) case .swiftToolchain(let path, xcodeDeveloperPath: let xcodeDeveloperPath): diff --git a/Sources/SWBWindowsPlatform/Plugin.swift b/Sources/SWBWindowsPlatform/Plugin.swift index 34037862..9a2c7e40 100644 --- a/Sources/SWBWindowsPlatform/Plugin.swift +++ b/Sources/SWBWindowsPlatform/Plugin.swift @@ -53,14 +53,14 @@ public final class WindowsPlugin: Sendable { } struct WindowsDeveloperDirectoryExtension: DeveloperDirectoryExtension { - func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? { + func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Core.DeveloperPath? { 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 + return .swiftToolchain(swiftPath, xcodeDeveloperPath: nil) } } @@ -94,15 +94,7 @@ struct WindowsPlatformExtension: PlatformInfoExtension { return [] } - let platformsPath: Path - switch context.developerPath { - case .xcode(let path): - platformsPath = path.join("Platforms") - case .swiftToolchain(let path, _): - platformsPath = path.join("Platforms") - case .fallback(let path): - platformsPath = path.join("Platforms") - } + let platformsPath = context.developerPath.path.join("Platforms") return try context.fs.listdir(platformsPath).compactMap { version in let versionedPlatformsPath = platformsPath.join(version) guard context.fs.isDirectory(versionedPlatformsPath) else { diff --git a/Tests/SWBCoreTests/CoreTests.swift b/Tests/SWBCoreTests/CoreTests.swift index b19b7a33..36fbd821 100644 --- a/Tests/SWBCoreTests/CoreTests.swift +++ b/Tests/SWBCoreTests/CoreTests.swift @@ -320,6 +320,7 @@ import SWBServiceCore // Validate that the core fails if there are loading errors. try await withTemporaryDirectory { tmpDirPath in let fakePlatformPath = tmpDirPath.join("Platforms/Fake.platform") + try localFS.createDirectory(tmpDirPath.join("Toolchains"), recursive: true) try localFS.createDirectory(fakePlatformPath, recursive: true) try await localFS.writePlist(fakePlatformPath.join("Info.plist"), .plDict([ "Description": .plString("Fake"), @@ -334,7 +335,7 @@ import SWBServiceCore let pluginManager = await PluginManager(skipLoadingPluginIdentifiers: []) await pluginManager.registerExtensionPoint(SpecificationsExtensionPoint()) await pluginManager.register(BuiltinSpecsExtension(), type: SpecificationsExtensionPoint.self) - let core = await Core.getInitializedCore(delegate, pluginManager: pluginManager, developerPath: .fallback(tmpDirPath), buildServiceModTime: Date(), connectionMode: .inProcess) + let core = await Core.getInitializedCore(delegate, pluginManager: pluginManager, developerPath: .swiftToolchain(tmpDirPath, xcodeDeveloperPath: nil), buildServiceModTime: Date(), connectionMode: .inProcess) #expect(core == nil) let results = CoreDelegateResults(delegate.diagnostics) @@ -346,69 +347,75 @@ import SWBServiceCore @Test(.skipIfEnvironmentVariableSet(key: .externalToolchainsDir)) func externalToolchainsDir() async throws { try await withTemporaryDirectory { tmpDir in + try localFS.createDirectory(tmpDir.join("Toolchains")) + let originalToolchain = try await toolchainPathsCount() - try await testExternalToolchainPath(withSetEnv: nil, expecting: [], originalToolchain) - try await testExternalToolchainPath(withSetEnv: tmpDir.join("tmp/Foobar/MyDir").str, expecting: [tmpDir.join("tmp/Foobar/MyDir").str], originalToolchain) - try await testExternalToolchainPath(withSetEnv: nil, expecting: [], originalToolchain) - try await testExternalToolchainPath(withSetEnv: [tmpDir.join("tmp/MetalToolchain1.0").str, tmpDir.join("tmp/MetalToolchain2.0").str, tmpDir.join("tmp/MetalToolchain3.0").str].joined(separator: String(Path.pathEnvironmentSeparator)), expecting: [ + try await testExternalToolchainPath(toolchainPath: tmpDir, withSetEnv: nil, expecting: [], originalToolchain) + try await testExternalToolchainPath(toolchainPath: tmpDir, withSetEnv: tmpDir.join("tmp/Foobar/MyDir").str, expecting: [tmpDir.join("tmp/Foobar/MyDir").str], originalToolchain) + try await testExternalToolchainPath(toolchainPath: tmpDir, withSetEnv: nil, expecting: [], originalToolchain) + try await testExternalToolchainPath(toolchainPath: tmpDir, withSetEnv: [tmpDir.join("tmp/MetalToolchain1.0").str, tmpDir.join("tmp/MetalToolchain2.0").str, tmpDir.join("tmp/MetalToolchain3.0").str].joined(separator: String(Path.pathEnvironmentSeparator)), expecting: [ tmpDir.join("tmp/MetalToolchain1.0").str, tmpDir.join("tmp/MetalToolchain2.0").str, tmpDir.join("tmp/MetalToolchain3.0").str, ], originalToolchain) - try await testExternalToolchainPath(withSetEnv: nil, expecting: [], originalToolchain) - try await testExternalToolchainPath(withSetEnv: "", expecting: [], originalToolchain) + try await testExternalToolchainPath(toolchainPath: tmpDir, withSetEnv: nil, expecting: [], originalToolchain) + try await testExternalToolchainPath(toolchainPath: tmpDir, withSetEnv: "", expecting: [], originalToolchain) // Environment overrides - try await testExternalToolchainPath(withSetEnv: nil, expecting: [], originalToolchain) // Clear + try await testExternalToolchainPath(toolchainPath: tmpDir, withSetEnv: nil, expecting: [], originalToolchain) // Clear - try await testExternalToolchainPath(environmentOverrides: ["Hello":"world"], expecting: [], originalToolchain) - try await testExternalToolchainPath(environmentOverrides: ["EXTERNAL_TOOLCHAINS_DIR": tmpDir.join("tmp/Foobar/MyDir").str], expecting: [tmpDir.join("tmp/Foobar/MyDir").str], originalToolchain) - try await testExternalToolchainPath(environmentOverrides: [:], expecting: [], originalToolchain) - try await testExternalToolchainPath(environmentOverrides: [ + try await testExternalToolchainPath(toolchainPath: tmpDir, environmentOverrides: ["Hello":"world"], expecting: [], originalToolchain) + try await testExternalToolchainPath(toolchainPath: tmpDir, environmentOverrides: ["EXTERNAL_TOOLCHAINS_DIR": tmpDir.join("tmp/Foobar/MyDir").str], expecting: [tmpDir.join("tmp/Foobar/MyDir").str], originalToolchain) + try await testExternalToolchainPath(toolchainPath: tmpDir, environmentOverrides: [:], expecting: [], originalToolchain) + try await testExternalToolchainPath(toolchainPath: tmpDir, environmentOverrides: [ "EXTERNAL_TOOLCHAINS_DIR" : [tmpDir.join("tmp/MetalToolchain1.0").str, tmpDir.join("tmp/MetalToolchain2.0").str, tmpDir.join("tmp/MetalToolchain3.0").str].joined(separator: String(Path.pathEnvironmentSeparator)), ], expecting: [ tmpDir.join("tmp/MetalToolchain1.0").str, tmpDir.join("tmp/MetalToolchain2.0").str, tmpDir.join("tmp/MetalToolchain3.0").str, ], originalToolchain) - try await testExternalToolchainPath(environmentOverrides: [:], expecting: [], originalToolchain) + try await testExternalToolchainPath(toolchainPath: tmpDir, environmentOverrides: [:], expecting: [], originalToolchain) } } 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 + try await withTemporaryDirectory { tmpDir in + try localFS.createDirectory(tmpDir.join("Toolchains")) + 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 { + let toolchainPath: Path + func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Core.DeveloperPath? { + .swiftToolchain(toolchainPath, xcodeDeveloperPath: nil) + } } - } - struct MockToolchainExtension: ToolchainRegistryExtension { - func additionalToolchains(context: any ToolchainRegistryExtensionAdditionalToolchainsContext) async throws -> [Toolchain] { - guard context.toolchainRegistry.lookup(ToolchainRegistry.defaultToolchainIdentifier) == nil else { - return [] + struct MockToolchainExtension: ToolchainRegistryExtension { + func additionalToolchains(context: any ToolchainRegistryExtensionAdditionalToolchainsContext) async throws -> [Toolchain] { + guard context.toolchainRegistry.lookup(ToolchainRegistry.defaultToolchainIdentifier) == nil else { + return [] + } + return [Toolchain(identifier: ToolchainRegistry.defaultToolchainIdentifier, displayName: "Mock", version: Version(), aliases: ["default"], path: .root, frameworkPaths: [], libraryPaths: [], defaultSettings: [:], overrideSettings: [:], defaultSettingsWhenPrimary: [:], executableSearchPaths: [], testingLibraryPlatformNames: [], fs: context.fs)] } - 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 { - if diagnostic.formatLocalizedDescription(.debug).hasPrefix("warning: found previously-unknown deployment target macro ") { - continue + await pluginManager.register(MockDeveloperDirectoryExtensionPoint(toolchainPath: tmpDir), 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 { + if diagnostic.formatLocalizedDescription(.debug).hasPrefix("warning: found previously-unknown deployment target macro ") { + continue + } + Issue.record("\(diagnostic.formatLocalizedDescription(.debug))") } - Issue.record("\(diagnostic.formatLocalizedDescription(.debug))") + return try #require(core?.toolchainPaths).count } - return try #require(core?.toolchainPaths).count } - func testExternalToolchainPath(withSetEnv externalToolchainPathsString: String?, expecting expectedPathStrings: [String], _ originalToolchainCount: Int) async throws { + func testExternalToolchainPath(toolchainPath: Path, withSetEnv externalToolchainPathsString: String?, expecting expectedPathStrings: [String], _ originalToolchainCount: Int) async throws { var env = Environment.current.filter { $0.key != .externalToolchainsDir } if let externalToolchainPathsString { env[.externalToolchainsDir] = externalToolchainPathsString @@ -417,11 +424,11 @@ import SWBServiceCore try await withEnvironment(env, clean: true) { #expect(getEnvironmentVariable(.externalToolchainsDir) == externalToolchainPathsString) - try await testExternalToolchainPath(environmentOverrides: [:], expecting: expectedPathStrings, originalToolchainCount) + try await testExternalToolchainPath(toolchainPath: toolchainPath, environmentOverrides: [:], expecting: expectedPathStrings, originalToolchainCount) } } - func testExternalToolchainPath(environmentOverrides: [String:String], expecting expectedPathStrings: [String], _ originalToolchainCount: Int) async throws { + func testExternalToolchainPath(toolchainPath: Path, environmentOverrides: [String:String], expecting expectedPathStrings: [String], _ originalToolchainCount: Int) async throws { let delegate = Delegate() let pluginManager = await PluginManager(skipLoadingPluginIdentifiers: []) await pluginManager.registerExtensionPoint(DeveloperDirectoryExtensionPoint()) @@ -429,8 +436,9 @@ import SWBServiceCore await pluginManager.registerExtensionPoint(ToolchainRegistryExtensionPoint()) await pluginManager.register(BuiltinSpecsExtension(), type: SpecificationsExtensionPoint.self) struct MockDeveloperDirectoryExtensionPoint: DeveloperDirectoryExtension { - func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? { - .root + let toolchainPath: Path + func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Core.DeveloperPath? { + .swiftToolchain(toolchainPath, xcodeDeveloperPath: nil) } } struct MockToolchainExtension: ToolchainRegistryExtension { @@ -441,7 +449,7 @@ import SWBServiceCore 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(MockDeveloperDirectoryExtensionPoint(toolchainPath: toolchainPath), 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/PlatformRegistryTests.swift b/Tests/SWBCoreTests/PlatformRegistryTests.swift index 88dafa57..ae74a237 100644 --- a/Tests/SWBCoreTests/PlatformRegistryTests.swift +++ b/Tests/SWBCoreTests/PlatformRegistryTests.swift @@ -49,7 +49,7 @@ import SWBMacro } var developerPath: Core.DeveloperPath { - .fallback(Path.temporaryDirectory) + .swiftToolchain(.temporaryDirectory, xcodeDeveloperPath: nil) } } diff --git a/Tests/SWBCoreTests/ToolchainRegistryTests.swift b/Tests/SWBCoreTests/ToolchainRegistryTests.swift index e8f8753d..60510119 100644 --- a/Tests/SWBCoreTests/ToolchainRegistryTests.swift +++ b/Tests/SWBCoreTests/ToolchainRegistryTests.swift @@ -30,7 +30,10 @@ import SWBServiceCore infoPlistName: String = "ToolchainInfo.plist", postProcess: (Path) throws -> Void = { _ in }, perform: (ToolchainRegistry, [(String, String)], [(String, String)]) throws -> Void) async throws { - try await withTemporaryDirectory { tmpDirPath in + try await withTemporaryDirectory { baseTmpDirPath in + let tmpDirPath = baseTmpDirPath.join("tmp") + try fs.createDirectory(tmpDirPath) + try fs.createDirectory(baseTmpDirPath.join("Swift").join("Toolchains"), recursive: true) for (name, dataOpt) in inputs { let itemPath = tmpDirPath.join(name).join(infoPlistName) @@ -76,8 +79,9 @@ import SWBServiceCore await pluginManager.registerExtensionPoint(ToolchainRegistryExtensionPoint()) await pluginManager.register(BuiltinSpecsExtension(), type: SpecificationsExtensionPoint.self) struct MockDeveloperDirectoryExtensionPoint: DeveloperDirectoryExtension { - func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? { - .root + let toolchainPath: Path + func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Core.DeveloperPath? { + .swiftToolchain(toolchainPath, xcodeDeveloperPath: nil) } } struct MockToolchainExtension: ToolchainRegistryExtension { @@ -88,7 +92,7 @@ import SWBServiceCore 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(MockDeveloperDirectoryExtensionPoint(toolchainPath: baseTmpDirPath.join("Swift")), type: DeveloperDirectoryExtensionPoint.self) await pluginManager.register(MockToolchainExtension(), type: ToolchainRegistryExtensionPoint.self) let coreDelegate = TestingCoreDelegate() let core = await Core.getInitializedCore(coreDelegate, pluginManager: pluginManager, inferiorProductsPath: Path.root.join("invalid"), environment: [:], buildServiceModTime: Date(), connectionMode: .inProcess) @@ -172,7 +176,7 @@ import SWBServiceCore ], infoPlistName: "Info.plist") { registry, _, errors in #expect(Set(registry.toolchainsByIdentifier.keys) == Set(["org.swift.3020161114a", "org.swift.3020161115a"] + additionalToolchains)) - #expect(errors.count == 0) + #expect(errors.count == 0, "\(errors)") #expect(registry.lookup("org.swift.3020161115a")?.identifier == "org.swift.3020161115a") #expect(registry.lookup("org.swift.3020161114a")?.identifier == "org.swift.3020161114a")