Filter out xcode toolchain from the output on non-macOS

Add a little documentation for the xcode toolchain selector

Add tests for the xcode toolchain selector and version

Author: cmcgee1024

Sources/Swiftly/Config.swift

@@ -51,8 +51,14 @@ public struct Config: Codable, Equatable {
     }
 
     public func listInstalledToolchains(selector: ToolchainSelector?) -> [ToolchainVersion] {
+#if os(macOS)
+        let systemToolchains: [ToolchainVersion] = [.xcodeVersion]
+#else
+        let systemToolchains = []
+#endif
+
         guard let selector else {
-            return Array(self.installedToolchains) + [.xcodeVersion]
+            return Array(self.installedToolchains) + systemToolchains
         }
 
         if case .latest = selector {
@@ -63,7 +69,7 @@ public struct Config: Codable, Equatable {
             return ts
         }
 
-        return (self.installedToolchains + [.xcodeVersion]).filter { toolchain in
+        return (self.installedToolchains + systemToolchains).filter { toolchain in
             selector.matches(toolchain: toolchain)
         }
     }

Sources/Swiftly/List.swift

@@ -98,8 +98,10 @@ struct List: SwiftlyCommand {
                 await printToolchain(toolchain)
             }
 
+#if os(macOS)
             await ctx.print("")
             await printToolchain(ToolchainVersion.xcode)
+#endif
         }
     }
 }

Sources/Swiftly/Uninstall.swift

@@ -68,10 +68,11 @@ struct Uninstall: SwiftlyCommand {
             toolchains = installedToolchains
         }
 
+        // Filter out the xcode toolchain here since it is not uninstallable
         toolchains.removeAll(where: { $0 == .xcodeVersion })
 
         guard !toolchains.isEmpty else {
-            await ctx.print("No toolchains matched \"\(self.toolchain)\"")
+            await ctx.print("No toolchains can be uninstalled that match \"\(self.toolchain)\"")
             return
         }
 

Sources/Swiftly/Use.swift

@@ -50,6 +50,12 @@ struct Use: SwiftlyCommand {
 
             $ swiftly use 5.7-snapshot
             $ swiftly use main-snapshot
+
+        macOS ONLY: There is a special selector for swiftly to use your Xcode toolchain. \
+        If there are multiple versions of Xcode then swiftly will use the currently selected \
+        toolchain from xcode-select.
+
+            $ swiftly use xcode
         """
     ))
     var toolchain: String?
@@ -240,7 +246,7 @@ public func selectToolchain(_ ctx: SwiftlyCoreContext, config: inout Config, glo
 
     // Check to ensure that the global default in use toolchain matches one of the installed toolchains, and return
     // no selected toolchain if it doesn't.
-    guard let defaultInUse = config.inUse, config.installedToolchains.contains(defaultInUse) else {
+    guard let defaultInUse = config.inUse, config.listInstalledToolchains(selector: nil).contains(defaultInUse) else {
         return (nil, .globalDefault)
     }
 

Sources/SwiftlyCore/ToolchainVersion.swift

@@ -243,6 +243,10 @@ extension ToolchainVersion: Comparable {
         case (.stable, .snapshot):
             return !(rhs < lhs)
         case (.xcode, .xcode):
+            return false
+        case (.xcode, _):
+            return false
+        case (_, .xcode):
             return true
         default:
             return false

Tests/SwiftlyTests/InstallTests.swift

@@ -262,4 +262,11 @@ import Testing
         try await SwiftlyTests.installMockedToolchain(selector: ToolchainVersion.newStable.name, args: ["--use"])
         try await SwiftlyTests.validateInUse(expected: .newStable)
     }
+
+    /// Verify that xcode can't be installed like regular toolchains
+    @Test(.testHomeMockedToolchain()) func installXcode() async throws {
+        try await #expect(throws: SwiftlyError.self) {
+            try await SwiftlyTests.runCommand(Install.self, ["install", "xcode", "--post-install-file=\(Swiftly.currentPlatform.getTempFilePath().path)"])
+        }
+    }
 }

Tests/SwiftlyTests/ListTests.swift

@@ -44,13 +44,19 @@ import Testing
         let output = try await SwiftlyTests.runWithMockedIO(List.self, args)
 
         let parsedToolchains = output.compactMap { outputLine in
+#if !os(macOS)
             Set<ToolchainVersion>.allToolchains().first {
                 outputLine.contains(String(describing: $0))
             }
+#else
+            (Set<ToolchainVersion>.allToolchains() + [.xcodeVersion]).first {
+                outputLine.contains(String(describing: $0))
+            }
+#endif
         }
 
         // Ensure extra toolchains weren't accidentally included in the output.
-        guard parsedToolchains.count == output.filter({ $0.hasPrefix("Swift") || $0.contains("-snapshot") }).count else {
+        guard parsedToolchains.count == output.filter({ $0.hasPrefix("Swift") || $0.contains("-snapshot") || $0.contains("xcode") }).count else {
             throw SwiftlyTestError(message: "unexpected listed toolchains in \(output)")
         }
 
@@ -62,7 +68,11 @@ import Testing
     @Test func list() async throws {
         try await self.runListTest {
             let toolchains = try await self.runList(selector: nil)
+#if !os(macOS)
             #expect(toolchains == Self.sortedReleaseToolchains + Self.sortedSnapshotToolchains)
+#else
+            #expect(toolchains == Self.sortedReleaseToolchains + Self.sortedSnapshotToolchains + [.xcodeVersion])
+#endif
         }
     }
 
@@ -155,8 +165,14 @@ import Testing
 
     /// Tests that `list` properly handles the case where no toolchains have been installed yet.
     @Test(.testHome(Self.homeName)) func listEmpty() async throws {
+#if !os(macOS)
+        let systemToolchains: [ToolchainVersion] = []
+#else
+        let systemToolchains: [ToolchainVersion] = [.xcodeVersion]
+#endif
+
         var toolchains = try await self.runList(selector: nil)
-        #expect(toolchains == [])
+        #expect(toolchains == systemToolchains)
 
         toolchains = try await self.runList(selector: "5")
         #expect(toolchains == [])

Tests/SwiftlyTests/PlatformTests.swift

@@ -85,4 +85,19 @@ import Testing
         toolchains = try FileManager.default.contentsOfDirectory(at: Swiftly.currentPlatform.swiftlyToolchainsDir(SwiftlyTests.ctx), includingPropertiesForKeys: nil)
         #expect(0 == toolchains.count)
     }
+
+#if os(macOS)
+    @Test(.testHome()) func findXcodeToolchainLocation() async throws {
+        // GIVEN: the xcode toolchain
+        // AND there is xcode installed
+        guard let xcodeLocation = try? await Swiftly.currentPlatform.runProgramOutput("xcode-select", "-p"), xcodeLocation != "" else {
+            return
+        }
+
+        // WHEN: the location of the xcode toolchain can be found
+        let toolchainLocation = try await Swiftly.currentPlatform.findToolchainLocation(SwiftlyTests.ctx, .xcodeVersion)
+
+        #expect(toolchainLocation.path.hasPrefix(xcodeLocation.replacingOccurrences(of: "\n", with: "")))
+    }
+#endif
 }

Tests/SwiftlyTests/UninstallTests.swift

@@ -280,4 +280,9 @@ import Testing
             description: "uninstall did not uninstall all toolchains"
         )
     }
+
+    @Test(.mockHomeToolchains(Self.homeName, toolchains: [])) func uninstallXcode() async throws {
+        let output = try await SwiftlyTests.runWithMockedIO(Uninstall.self, ["uninstall", "-y", ToolchainVersion.xcodeVersion.name])
+        #expect(!output.filter { $0.contains("No toolchains can be uninstalled that match \"xcode\"") }.isEmpty)
+    }
 }

Tests/SwiftlyTests/UseTests.swift

@@ -148,6 +148,13 @@ import Testing
         )
     }
 
+#if os(macOS)
+    /// Tests that the xcode toolchain can be used on macOS
+    @Test(.mockHomeToolchains()) func useXcode() async throws {
+        try await self.useAndValidate(argument: ToolchainVersion.xcodeVersion.name, expectedVersion: .xcode)
+    }
+#endif
+
     /// Tests that the `use` command gracefully exits when executed before any toolchains have been installed.
     @Test(.mockHomeToolchains(toolchains: [])) func useNoInstalledToolchains() async throws {
         try await SwiftlyTests.runCommand(Use.self, ["use", "-g", "latest"])
@@ -209,6 +216,15 @@ import Testing
         }
     }
 
+#if os(macOS)
+    /// Tests that running a use command without an argument prints the xcode toolchain when it is in use.
+    @Test(.mockHomeToolchains()) func printInUseXcode() async throws {
+        try await SwiftlyTests.runCommand(Use.self, ["use", "-g", "xcode"])
+        var output = try await SwiftlyTests.runWithMockedIO(Use.self, ["use", "-g"])
+        #expect(output.contains(where: { $0.contains("xcode") }))
+    }
+#endif
+
     /// Tests in-use toolchain selected by the .swift-version file.
     @Test func swiftVersionFile() async throws {
         let toolchains = [