Merge branch 'main' of https://github.com/swiftlang/swiftly into macos_install_force_local

Author: cmcgee1024

Package.resolved

@@ -17,7 +17,7 @@ let package = Package(
         .package(url: "https://github.com/apple/swift-argument-parser", from: "1.3.0"),
         .package(url: "https://github.com/swift-server/async-http-client", from: "1.24.0"),
         .package(url: "https://github.com/swift-server/swift-openapi-async-http-client", from: "1.1.0"),
-        .package(url: "https://github.com/apple/swift-nio.git", from: "2.79.0"),
+        .package(url: "https://github.com/apple/swift-nio.git", from: "2.80.0"),
         .package(url: "https://github.com/apple/swift-tools-support-core.git", from: "0.7.2"),
         .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.3.0"),
         .package(url: "https://github.com/apple/swift-openapi-generator", from: "1.6.0"),

Package.swift

@@ -7,15 +7,15 @@ var swiftGPGKeysRefreshed = false
 /// This implementation can be reused for any supported Linux platform.
 /// TODO: replace dummy implementations
 public struct Linux: Platform {
-    let linuxPlatforms = [
-        PlatformDefinition.ubuntu2404,
-        PlatformDefinition.ubuntu2204,
-        PlatformDefinition.ubuntu2004,
-        PlatformDefinition.ubuntu1804,
-        PlatformDefinition.fedora39,
-        PlatformDefinition.rhel9,
-        PlatformDefinition.amazonlinux2,
-        PlatformDefinition.debian12,
+    let linuxPlatforms: [PlatformDefinition] = [
+        .ubuntu2404,
+        .ubuntu2204,
+        .ubuntu2004,
+        .ubuntu1804,
+        .fedora39,
+        .rhel9,
+        .amazonlinux2,
+        .debian12,
     ]
 
     public init() {}
@@ -376,19 +376,13 @@ public struct Linux: Platform {
         try self.runProgram(tmpDir.appendingPathComponent("swiftly").path, "init")
     }
 
-    public func uninstall(_ toolchain: ToolchainVersion) throws {
+    public func uninstall(_ toolchain: ToolchainVersion, verbose _: Bool) throws {
         let toolchainDir = self.swiftlyToolchainsDir.appendingPathComponent(toolchain.name)
         try FileManager.default.removeItem(at: toolchainDir)
     }
 
     public func getExecutableName() -> String {
-#if arch(x86_64)
-        let arch = "x86_64"
-#elseif arch(arm64)
-        let arch = "aarch64"
-#else
-        fatalError("Unsupported processor architecture")
-#endif
+        let arch = cpuArch
 
         return "swiftly-\(arch)-unknown-linux-gnu"
     }
@@ -516,7 +510,7 @@ public struct Linux: Platform {
                 return await self.manualSelectPlatform(platformPretty)
             }
 
-            return PlatformDefinition.amazonlinux2
+            return .amazonlinux2
         } else if (id + (idlike ?? "")).contains("rhel") {
             guard versionID.hasPrefix("9") else {
                 let message = "Unsupported version of RHEL"
@@ -528,7 +522,7 @@ public struct Linux: Platform {
                 return await self.manualSelectPlatform(platformPretty)
             }
 
-            return PlatformDefinition.rhel9
+            return .rhel9
         } else if let pd = [PlatformDefinition.ubuntu1804, .ubuntu2004, .ubuntu2204, .ubuntu2404, .debian12, .fedora39].first(where: { $0.name == id + versionID }) {
             return pd
         }

Sources/LinuxPlatform/Linux.swift

@@ -120,25 +120,25 @@ public struct MacOS: Platform {
         try self.runProgram(homeDir.appendingPathComponent("usr/local/bin/swiftly").path, "init")
     }
 
-    public func uninstall(_ toolchain: ToolchainVersion) throws {
+    public func uninstall(_ toolchain: ToolchainVersion, verbose: Bool) throws {
         SwiftlyCore.print("Uninstalling package in user home directory...")
 
         let toolchainDir = self.swiftlyToolchainsDir.appendingPathComponent("\(toolchain.identifier).xctoolchain", isDirectory: true)
 
         let decoder = PropertyListDecoder()
         let infoPlist = toolchainDir.appendingPathComponent("Info.plist")
         guard let data = try? Data(contentsOf: infoPlist) else {
-            throw SwiftlyError(message: "could not open \(infoPlist)")
+            throw SwiftlyError(message: "could not open \(infoPlist.path)")
         }
 
         guard let pkgInfo = try? decoder.decode(SwiftPkgInfo.self, from: data) else {
-            throw SwiftlyError(message: "could not decode plist at \(infoPlist)")
+            throw SwiftlyError(message: "could not decode plist at \(infoPlist.path)")
         }
 
         try FileManager.default.removeItem(at: toolchainDir)
 
         let homedir = ProcessInfo.processInfo.environment["HOME"]!
-        try? runProgram("pkgutil", "--volume", homedir, "--forget", pkgInfo.CFBundleIdentifier)
+        try? runProgram("pkgutil", "--volume", homedir, "--forget", pkgInfo.CFBundleIdentifier, quiet: !verbose)
     }
 
     public func getExecutableName() -> String {
@@ -156,7 +156,7 @@ public struct MacOS: Platform {
 
     public func detectPlatform(disableConfirmation _: Bool, platform _: String?) async -> PlatformDefinition {
         // No special detection required on macOS platform
-        PlatformDefinition.macOS
+        .macOS
     }
 
     public func getShell() async throws -> String {

Sources/MacOSPlatform/MacOS.swift

@@ -42,10 +42,18 @@ internal struct Init: SwiftlyCommand {
         if var config, !overwrite &&
             (
                 config.version == SwiftlyVersion(major: 0, minor: 4, patch: 0, suffix: "dev") ||
+<<<<<<< HEAD
                     config.version == SwiftlyVersion(major: 0, minor: 4, patch: 0)
             )
         {
             // This is a simple upgrade from the 0.4.0-dev pre-release, or 0.4.0 release
+=======
+                    config.version == SwiftlyVersion(major: 0, minor: 4, patch: 0) ||
+                    (config.version?.major == 1 && config.version?.minor == 0)
+            )
+        {
+            // This is a simple upgrade from the 0.4.0 pre-releases, or 1.x
+>>>>>>> 726ea90b9c304068d9649abc8718f8752169ce7b
 
             // Move our executable over to the correct place
             try Swiftly.currentPlatform.installSwiftlyBin()

Sources/Swiftly/Init.swift

@@ -297,11 +297,18 @@ 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 || config.inUse == nil {
-            // TODO: consider adding the global default option to this commands flags
+        if useInstalledToolchain {
             try await Use.execute(version, globalDefault: false, &config)
         }
 
+        // We always update the global default toolchain if there is none set. This could
+        //  be the only toolchain that is installed, which makes it the only choice.
+        if config.inUse == nil {
+            config.inUse = version
+            try config.save()
+            SwiftlyCore.print("The global default toolchain has been set to `\(version)`")
+        }
+
         SwiftlyCore.print("\(version) installed successfully!")
         return (postInstallScript, pathChanged)
     }

Sources/Swiftly/Install.swift

@@ -53,7 +53,7 @@ public enum Proxy {
             }
 
             guard let toolchain = toolchain else {
-                throw SwiftlyError(message: "No swift toolchain could be selected from either from a .swift-version file, or the default. You can try using `swiftly install <toolchain version>` to install one.")
+                throw SwiftlyError(message: "No installed swift toolchain is selected from either from a .swift-version file, or the default. You can try using one that's already installed with `swiftly use <toolchain version>` or install a new toolchain to use with `swiftly install --use <toolchain version>`.")
             }
 
             // Prevent circularities with a memento environment variable

Sources/Swiftly/Proxy.swift

@@ -86,7 +86,7 @@ internal struct Run: SwiftlyCommand {
         }
 
         guard let toolchain = toolchain else {
-            throw SwiftlyError(message: "No swift toolchain could be selected from either from a .swift-version file, or the default. You can try using `swiftly install <toolchain version>` to install one.")
+            throw SwiftlyError(message: "No installed swift toolchain is selected from either from a .swift-version file, or the default. You can try using one that's already installed with `swiftly use <toolchain version>` or install a new toolchain to use with `swiftly install --use <toolchain version>`.")
         }
 
         do {

Sources/Swiftly/Run.swift

@@ -56,7 +56,12 @@ struct Uninstall: SwiftlyCommand {
             }
         } else {
             let selector = try ToolchainSelector(parsing: self.toolchain)
-            toolchains = startingConfig.listInstalledToolchains(selector: selector)
+            var installedToolchains = startingConfig.listInstalledToolchains(selector: selector)
+            // This is in the unusual case that the inUse toolchain is not listed in the installed toolchains
+            if let inUse = startingConfig.inUse, selector.matches(toolchain: inUse) && !startingConfig.installedToolchains.contains(inUse) {
+                installedToolchains.append(inUse)
+            }
+            toolchains = installedToolchains
         }
 
         guard !toolchains.isEmpty else {
@@ -108,18 +113,23 @@ struct Uninstall: SwiftlyCommand {
                 }
             }
 
-            try await Self.execute(toolchain, &config)
+            try await Self.execute(toolchain, &config, verbose: self.root.verbose)
         }
 
         SwiftlyCore.print()
         SwiftlyCore.print("\(toolchains.count) toolchain(s) successfully uninstalled")
     }
 
-    static func execute(_ toolchain: ToolchainVersion, _ config: inout Config) async throws {
+    static func execute(_ toolchain: ToolchainVersion, _ config: inout Config, verbose: Bool) async throws {
         SwiftlyCore.print("Uninstalling \(toolchain)...", terminator: "")
-        try Swiftly.currentPlatform.uninstall(toolchain)
         config.installedToolchains.remove(toolchain)
+        // This is here to prevent the inUse from referencing a toolchain that is not installed
+        if config.inUse == toolchain {
+            config.inUse = nil
+        }
         try config.save()
+
+        try Swiftly.currentPlatform.uninstall(toolchain, verbose: verbose)
         SwiftlyCore.print("done")
     }
 }

Sources/Swiftly/Uninstall.swift

@@ -81,7 +81,7 @@ struct Update: SwiftlyCommand {
         try validateSwiftly()
         var config = try Config.load()
 
-        guard let parameters = try self.resolveUpdateParameters(config) else {
+        guard let parameters = try await self.resolveUpdateParameters(&config) else {
             if let toolchain = self.toolchain {
                 SwiftlyCore.print("No installed toolchain matched \"\(toolchain)\"")
             } else {
@@ -101,7 +101,7 @@ struct Update: SwiftlyCommand {
         }
 
         if !self.root.assumeYes {
-            SwiftlyCore.print("Update \(parameters.oldToolchain) ⟶ \(newToolchain)?")
+            SwiftlyCore.print("Update \(parameters.oldToolchain) -> \(newToolchain)?")
             guard SwiftlyCore.promptForConfirmation(defaultBehavior: true) else {
                 SwiftlyCore.print("Aborting")
                 return
@@ -117,7 +117,7 @@ struct Update: SwiftlyCommand {
             assumeYes: self.root.assumeYes
         )
 
-        try await Uninstall.execute(parameters.oldToolchain, &config)
+        try await Uninstall.execute(parameters.oldToolchain, &config, verbose: self.root.verbose)
         SwiftlyCore.print("Successfully updated \(parameters.oldToolchain) ⟶ \(newToolchain)")
 
         if let postInstallScript = postInstallScript {
@@ -152,7 +152,7 @@ struct Update: SwiftlyCommand {
     /// If the selector does not match an installed toolchain, this returns nil.
     /// If no selector is provided, the currently in-use toolchain will be used as the basis for the returned
     /// parameters.
-    private func resolveUpdateParameters(_ config: Config) throws -> UpdateParameters? {
+    private func resolveUpdateParameters(_ config: inout Config) async throws -> UpdateParameters? {
         let selector = try self.toolchain.map { try ToolchainSelector(parsing: $0) }
 
         let oldToolchain: ToolchainVersion?
@@ -163,7 +163,7 @@ struct Update: SwiftlyCommand {
             // 5.5.1 and 5.5.2 are installed (5.5.2 will be updated).
             oldToolchain = toolchains.max()
         } else {
-            oldToolchain = config.inUse
+            (oldToolchain, _) = try await selectToolchain(config: &config)
         }
 
         guard let oldToolchain else {