Simplify fallback developer directory calculation

jakepetroules · jakepetroules · commit be93573d5f90 · 2025-05-29T11:14:19.000-07:00
Have the fallback logic specify the type of developer directory as well as just the location, and eliminate the initialization distinction on whether a Core was initialized with a "fallback" path vs one explicitly given, since it shouldn't matter.
diff --git 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
@@ -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
@@ -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
@@ -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: <rdar://problem/23576831> Add search paths for .xcconfig macros to match what Xcode has
                 if path.str.hasPrefix("<DEVELOPER_DIR>") {
                     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: "<DEVELOPER_DIR>", with: developerPath.str))
                     }
                 }
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
diff --git a/Tests/SWBCoreTests/PlatformRegistryTests.swift b/Tests/SWBCoreTests/PlatformRegistryTests.swift
diff --git a/Tests/SWBCoreTests/ToolchainRegistryTests.swift b/Tests/SWBCoreTests/ToolchainRegistryTests.swift

Original file line number	Diff line number	Diff line change
`@@ -31,8 +31,8 @@ import SWBTaskConstruction`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`struct AppleDeveloperDirectoryExtension: DeveloperDirectoryExtension {`
`34`		`- func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? {`
`35`		`- try await hostOperatingSystem == .macOS ? Xcode.getActiveDeveloperDirectoryPath() : nil`
	`34`	`+ func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Core.DeveloperPath? {`
	`35`	`+ try await hostOperatingSystem == .macOS ? .xcode(Xcode.getActiveDeveloperDirectoryPath()) : nil`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
Original file line number	Diff line number	Diff line change
`@@ -21,5 +21,5 @@ public struct DeveloperDirectoryExtensionPoint: ExtensionPoint {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`public protocol DeveloperDirectoryExtension: Sendable {`
`24`		`- func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path?`
	`24`	`+ func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Core.DeveloperPath?`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ final class MacroConfigFileLoader: Sendable {`
`133`	`133`	`// 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: <rdar://problem/23576831> Add search paths for .xcconfig macros to match what Xcode has`
`134`	`134`	`if path.str.hasPrefix("<DEVELOPER_DIR>") {`
`135`	`135`	`switch developerPath {`
`136`		`- case .xcode(let developerPath), .swiftToolchain(let developerPath, _), .fallback(let developerPath):`
	`136`	`+ case .xcode(let developerPath), .swiftToolchain(let developerPath, _):`
`137`	`137`	`path = Path(path.str.replacingOccurrences(of: "<DEVELOPER_DIR>", with: developerPath.str))`
`138`	`138`	`}`
`139`	`139`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,13 +23,13 @@ import Foundation`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`struct GenericUnixDeveloperDirectoryExtension: DeveloperDirectoryExtension {`
`26`		`- func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? {`
	`26`	`+ func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Core.DeveloperPath? {`
`27`	`27`	`if hostOperatingSystem == .windows \|\| hostOperatingSystem == .macOS {`
`28`	`28`	`// Handled by the Windows and Apple plugins`
`29`	`29`	`return nil`
`30`	`30`	`}`
`31`	`31`
`32`		`- return .root`
	`32`	`+ return .swiftToolchain(.root, xcodeDeveloperPath: nil)`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ extension Core {`
`38`	`38`	`if hostOperatingSystem == .macOS {`
`39`	`39`	`developerPath = .xcode(try await Xcode.getActiveDeveloperDirectoryPath())`
`40`	`40`	`} else {`
`41`		`- developerPath = .fallback(Path.root)`
	`41`	`+ developerPath = .swiftToolchain(.root, xcodeDeveloperPath: nil)`
`42`	`42`	`}`
`43`	`43`	`let delegate = TestingCoreDelegate()`
`44`	`44`	`return await (try Core(delegate: delegate, hostOperatingSystem: hostOperatingSystem, pluginManager: PluginManager(skipLoadingPluginIdentifiers: []), developerPath: developerPath, resourceSearchPaths: [], inferiorProductsPath: nil, additionalContentPaths: [], environment: [:], buildServiceModTime: Date(), connectionMode: .inProcess), delegate.diagnostics)`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ package struct MockCommandProducer: CommandProducer, Sendable {`
`60`	`60`	`paths.append(path)`
`61`	`61`	`}`
`62`	`62`	`switch core.developerPath {`
`63`		`- case .xcode(let path), .fallback(let path):`
	`63`	`+ case .xcode(let path):`
`64`	`64`	`paths.append(path.join("usr").join("bin"))`
`65`	`65`	`paths.append(path.join("usr").join("local").join("bin"))`
`66`	`66`	`case .swiftToolchain(let path, xcodeDeveloperPath: let xcodeDeveloperPath):`
Original file line number	Diff line number	Diff line change
`@@ -53,14 +53,14 @@ public final class WindowsPlugin: Sendable {`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`struct WindowsDeveloperDirectoryExtension: DeveloperDirectoryExtension {`
`56`		`- func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Path? {`
	`56`	`+ func fallbackDeveloperDirectory(hostOperatingSystem: OperatingSystem) async throws -> Core.DeveloperPath? {`
`57`	`57`	`guard hostOperatingSystem == .windows else {`
`58`	`58`	`return nil`
`59`	`59`	`}`
`60`	`60`	`guard let userProgramFiles = URL.userProgramFiles, let swiftPath = try? userProgramFiles.appending(component: "Swift").filePath else {`
`61`	`61`	`throw StubError.error("Could not determine path to user program files")`
`62`	`62`	`}`
`63`		`- return swiftPath`
	`63`	`+ return .swiftToolchain(swiftPath, xcodeDeveloperPath: nil)`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
`@@ -94,15 +94,7 @@ struct WindowsPlatformExtension: PlatformInfoExtension {`
`94`	`94`	`return []`
`95`	`95`	`}`
`96`	`96`
`97`		`- let platformsPath: Path`
`98`		`- switch context.developerPath {`
`99`		`- case .xcode(let path):`
`100`		`- platformsPath = path.join("Platforms")`
`101`		`- case .swiftToolchain(let path, _):`
`102`		`- platformsPath = path.join("Platforms")`
`103`		`- case .fallback(let path):`
`104`		`- platformsPath = path.join("Platforms")`
`105`		`- }`
	`97`	`+ let platformsPath = context.developerPath.path.join("Platforms")`
`106`	`98`	`return try context.fs.listdir(platformsPath).compactMap { version in`
`107`	`99`	`let versionedPlatformsPath = platformsPath.join(version)`
`108`	`100`	`guard context.fs.isDirectory(versionedPlatformsPath) else {`