Create a special Xcode selector for macOS

Documentation/SwiftlyDocs.docc/swiftly-cli-reference.md

@@ -230,6 +230,10 @@ Likewise, the latest snapshot associated with a given development branch can be
     $ 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
+
 
 **--version:**
 

Sources/MacOSPlatform/MacOS.swift

@@ -201,9 +201,16 @@ public struct MacOS: Platform {
         return "/bin/zsh"
     }
 
-    public func findToolchainLocation(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion) -> FilePath
+    public func findToolchainLocation(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion) async throws -> FilePath
     {
-        self.swiftlyToolchainsDir(ctx) / "\(toolchain.identifier).xctoolchain"
+        if toolchain == .xcodeVersion {
+            // Print the toolchain location with the help of xcrun
+            if let xcrunLocation = try? await self.runProgramOutput("/usr/bin/xcrun", "-f", "swift") {
+                return FilePath(xcrunLocation.replacingOccurrences(of: "\n", with: "")).removingLastComponent().removingLastComponent().removingLastComponent()
+            }
+        }
+
+        return self.swiftlyToolchainsDir(ctx) / "\(toolchain.identifier).xctoolchain"
     }
 
     public static let currentPlatform: any Platform = MacOS()

Sources/Swiftly/Config.swift

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

Sources/Swiftly/Init.swift

@@ -281,18 +281,8 @@ struct Init: SwiftlyCommand {
             """)
         }
 
-        // Fish doesn't have path caching, so this might only be needed for bash/zsh
-        if pathChanged && !quietShellFollowup && !shell.hasSuffix("fish") {
-            await ctx.message("""
-            Your shell caches items on your path for better performance. Swiftly has added
-            items to your path that may not get picked up right away. You can update your
-            shell's environment by running
-
-            hash -r
-
-            or restarting your shell.
-
-            """)
+        if pathChanged && !quietShellFollowup {
+            try await Self.handlePathChange(ctx)
         }
 
         if let postInstall {

Sources/Swiftly/Install.swift

@@ -121,26 +121,8 @@ struct Install: SwiftlyCommand {
             progressFile: self.progressFile
         )
 
-        let shell =
-            if let s = ProcessInfo.processInfo.environment["SHELL"]
-        {
-            s
-        } else {
-            try await Swiftly.currentPlatform.getShell()
-        }
-
-        // Fish doesn't cache its path, so this instruction is not necessary.
-        if pathChanged && !shell.hasSuffix("fish") {
-            await ctx.message(
-                """
-                NOTE: Swiftly has updated some elements in your path and your shell may not yet be
-                aware of the changes. You can update your shell's environment by running
-
-                hash -r
-
-                or restarting your shell.
-
-                """)
+        if pathChanged {
+            try await Self.handlePathChange(ctx)
         }
 
         if let postInstallScript {
@@ -176,7 +158,7 @@ struct Install: SwiftlyCommand {
             let swiftlyBinDir = Swiftly.currentPlatform.swiftlyBinDir(ctx)
             let swiftlyBinDirContents =
                 (try? await fs.ls(atPath: swiftlyBinDir)) ?? [String]()
-            let toolchainBinDir = Swiftly.currentPlatform.findToolchainBinDir(ctx, version)
+            let toolchainBinDir = try await Swiftly.currentPlatform.findToolchainBinDir(ctx, version)
             let toolchainBinDirContents = try await fs.ls(atPath: toolchainBinDir)
 
             var existingProxies: [String] = []
@@ -316,6 +298,8 @@ struct Install: SwiftlyCommand {
                 case .main:
                     category = "development"
                 }
+            case .xcode:
+                fatalError("unreachable: xcode toolchain cannot be installed with swiftly")
             }
 
             let animation: ProgressReporterProtocol? =
@@ -408,7 +392,7 @@ struct Install: SwiftlyCommand {
                     verbose: verbose
                 )
 
-                let pathChanged = try await Self.setupProxies(
+                var pathChanged = try await Self.setupProxies(
                     ctx,
                     version: version,
                     verbose: verbose,
@@ -422,7 +406,8 @@ struct Install: SwiftlyCommand {
                 // If this is the first installed toolchain, mark it as in-use regardless of whether the
                 // --use argument was provided.
                 if useInstalledToolchain {
-                    try await Use.execute(ctx, version, globalDefault: false, &config)
+                    let pc = try await Use.execute(ctx, version, globalDefault: false, verbose: verbose, &config)
+                    pathChanged = pathChanged || pc
                 }
 
                 // We always update the global default toolchain if there is none set. This could
@@ -523,6 +508,8 @@ struct Install: SwiftlyCommand {
             }
 
             return .snapshot(firstSnapshot)
+        case .xcode:
+            throw SwiftlyError(message: "xcode toolchains are not available from swift.org")
         }
     }
 }

Sources/Swiftly/List.swift

@@ -55,7 +55,7 @@ struct List: SwiftlyCommand {
         let toolchains = config.listInstalledToolchains(selector: selector).sorted { $0 > $1 }
         let (inUse, _) = try await selectToolchain(ctx, config: &config)
 
-        let installedToolchainInfos = toolchains.compactMap { toolchain -> InstallToolchainInfo? in
+        var installedToolchainInfos = toolchains.compactMap { toolchain -> InstallToolchainInfo? in
             InstallToolchainInfo(
                 version: toolchain,
                 inUse: inUse == toolchain,

Sources/Swiftly/OutputSchema.swift

@@ -125,6 +125,8 @@ struct AvailableToolchainInfo: OutputData {
                 try versionContainer.encode(major, forKey: .major)
                 try versionContainer.encode(minor, forKey: .minor)
             }
+        case .xcode:
+            try versionContainer.encode("system", forKey: .type)
         }
     }
 }
@@ -233,6 +235,8 @@ struct InstallToolchainInfo: OutputData {
                 try versionContainer.encode(major, forKey: .major)
                 try versionContainer.encode(minor, forKey: .minor)
             }
+        case .xcode:
+            try versionContainer.encode("system", forKey: .type)
         }
     }
 
@@ -279,6 +283,9 @@ struct InstallToolchainInfo: OutputData {
                     branch: branch,
                     date: date
                 ))
+        case "system":
+            // The only system toolchain that exists at the moment is the xcode version
+            self.version = .xcode
         default:
             throw DecodingError.dataCorruptedError(
                 forKey: ToolchainVersionCodingKeys.type,
@@ -314,6 +321,8 @@ struct InstalledToolchainsListInfo: OutputData {
                 "main development snapshot"
             case let .snapshot(.release(major, minor), nil):
                 "\(major).\(minor) development snapshot"
+            case .xcode:
+                "xcode"
             default:
                 "matching"
             }
@@ -334,6 +343,13 @@ struct InstalledToolchainsListInfo: OutputData {
             lines.append("Installed snapshot toolchains")
             lines.append("-----------------------------")
             lines.append(contentsOf: snapshotToolchains.map(\.description))
+
+#if os(macOS)
+            lines.append("")
+            lines.append("Available system toolchains")
+            lines.append("---------------------------")
+            lines.append(ToolchainVersion.xcode.description)
+#endif
         }
 
         return lines.joined(separator: "\n")

Sources/Swiftly/Swiftly.swift

@@ -132,4 +132,28 @@ extension SwiftlyCommand {
             }
         }
     }
+
+    public static func handlePathChange(_ ctx: SwiftlyCoreContext) async throws {
+        let shell =
+            if let s = ProcessInfo.processInfo.environment["SHELL"]
+        {
+            s
+        } else {
+            try await Swiftly.currentPlatform.getShell()
+        }
+
+        // Fish doesn't cache its path, so this instruction is not necessary.
+        if !shell.hasSuffix("fish") {
+            await ctx.message(
+                """
+                NOTE: Swiftly has updated some elements in your path and your shell may not yet be
+                aware of the changes. You can update your shell's environment by running
+
+                hash -r
+
+                or restarting your shell.
+
+                """)
+        }
+    }
 }

Sources/Swiftly/Uninstall.swift

@@ -55,7 +55,7 @@ struct Uninstall: SwiftlyCommand {
 
         let startingConfig = try await Config.load(ctx)
 
-        let toolchains: [ToolchainVersion]
+        var toolchains: [ToolchainVersion]
         if self.toolchain == "all" {
             // Sort the uninstalled toolchains such that the in-use toolchain will be uninstalled last.
             // This avoids printing any unnecessary output from using new toolchains while the uninstall is in progress.
@@ -72,8 +72,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.message("No toolchains matched \"\(self.toolchain)\"")
+            await ctx.message("No toolchains can be uninstalled that match \"\(self.toolchain)\"")
             return
         }
 
@@ -105,6 +108,9 @@ struct Uninstall: SwiftlyCommand {
                 case let .snapshot(s):
                     // If a snapshot was previously in use, switch to the latest snapshot associated with that branch.
                     selector = .snapshot(branch: s.branch, date: nil)
+                case .xcode:
+                    // Xcode will not be in the list of installed toolchains, so this is only here for completeness
+                    selector = .xcode
                 }
 
                 if let toUse = config.listInstalledToolchains(selector: selector)
@@ -113,7 +119,10 @@ struct Uninstall: SwiftlyCommand {
                     ?? config.listInstalledToolchains(selector: .latest).filter({ !toolchains.contains($0) }).max()
                     ?? config.installedToolchains.filter({ !toolchains.contains($0) }).max()
                 {
-                    try await Use.execute(ctx, toUse, globalDefault: true, &config)
+                    let pathChanged = try await Use.execute(ctx, toUse, globalDefault: true, verbose: self.root.verbose, &config)
+                    if pathChanged {
+                        try await Self.handlePathChange(ctx)
+                    }
                 } else {
                     // If there are no more toolchains installed, just unuse the currently active toolchain.
                     config.inUse = nil

Sources/Swiftly/Update.swift

@@ -192,6 +192,8 @@ struct Update: SwiftlyCommand {
             default:
                 fatalError("unreachable")
             }
+        case let .xcode:
+            throw SwiftlyError(message: "xcode cannot be updated from swiftly")
         }
     }
 

Sources/Swiftly/Use.swift

@@ -54,6 +54,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?
@@ -87,7 +93,7 @@ struct Use: SwiftlyCommand {
             }
 
             if self.printLocation {
-                let location = LocationInfo(path: "\(Swiftly.currentPlatform.findToolchainLocation(ctx, selectedVersion))")
+                let location = LocationInfo(path: "\(try await Swiftly.currentPlatform.findToolchainLocation(ctx, selectedVersion))")
                 try await ctx.output(location)
                 return
             }
@@ -115,11 +121,14 @@ struct Use: SwiftlyCommand {
             throw SwiftlyError(message: "No installed toolchains match \"\(toolchain)\"")
         }
 
-        try await Self.execute(ctx, toolchain, globalDefault: self.globalDefault, assumeYes: self.root.assumeYes, &config)
+        let pathChanged = try await Self.execute(ctx, toolchain, globalDefault: self.globalDefault, verbose: self.root.verbose, assumeYes: self.root.assumeYes, &config)
+        if pathChanged {
+            try await Self.handlePathChange(ctx)
+        }
     }
 
     /// Use a toolchain. This method can modify and save the input config and also create/modify a `.swift-version` file.
-    static func execute(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion, globalDefault: Bool, assumeYes: Bool = true, _ config: inout Config) async throws {
+    static func execute(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion, globalDefault: Bool, verbose: Bool, assumeYes: Bool = true, _ config: inout Config) async throws -> Bool {
         let (selectedVersion, result) = try await selectToolchain(ctx, config: &config, globalDefault: globalDefault)
 
         let isGlobal: Bool
@@ -136,7 +145,7 @@ struct Use: SwiftlyCommand {
 
                 guard await ctx.promptForConfirmation(defaultBehavior: true) else {
                     await ctx.message("Aborting setting in-use toolchain")
-                    return
+                    return false
                 }
             }
 
@@ -150,12 +159,21 @@ struct Use: SwiftlyCommand {
             configFile = nil
         }
 
+        let pathChanged = try await Install.setupProxies(
+            ctx,
+            version: toolchain,
+            verbose: verbose,
+            assumeYes: assumeYes
+        )
+
         try await ctx.output(ToolchainSetInfo(
             version: toolchain,
             previousVersion: selectedVersion,
             isGlobal: isGlobal,
             versionFile: configFile
         ))
+
+        return pathChanged
     }
 
     static func findNewVersionFile(_ ctx: SwiftlyCoreContext) async throws -> FilePath? {
@@ -251,7 +269,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)
     }