Move Swift compiler version parsing from SkipUnless.swift to Toolchain

This allows us to inspect the Swift version and fix up compiler arguments from SwiftPM to account for an older version of SwiftPM being invoked using `swift build` than the one that’s bundled in-process with SourceKit-LSP.

Author: ahoppen

Sources/SKCore/Toolchain.swift

@@ -12,13 +12,51 @@
 
 import LSPLogging
 import LanguageServerProtocol
+import RegexBuilder
 import SKSupport
 
 import enum PackageLoading.Platform
 import struct TSCBasic.AbsolutePath
 import protocol TSCBasic.FileSystem
+import class TSCBasic.Process
 import var TSCBasic.localFileSystem
 
+/// A Swift version consisting of the major and minor component.
+public struct SwiftVersion: Sendable, Comparable, CustomStringConvertible {
+  public let major: Int
+  public let minor: Int
+
+  public static func < (lhs: SwiftVersion, rhs: SwiftVersion) -> Bool {
+    return (lhs.major, lhs.minor) < (rhs.major, rhs.minor)
+  }
+
+  public init(_ major: Int, _ minor: Int) {
+    self.major = major
+    self.minor = minor
+  }
+
+  public var description: String {
+    return "\(major).\(minor)"
+  }
+}
+
+fileprivate enum SwiftVersionParsingError: Error, CustomStringConvertible {
+  case failedToFindSwiftc
+  case failedToParseOutput(output: String?)
+
+  var description: String {
+    switch self {
+    case .failedToFindSwiftc:
+      return "Default toolchain does not contain a swiftc executable"
+    case .failedToParseOutput(let output):
+      return """
+        Failed to parse Swift version. Output of swift --version:
+        \(output ?? "<empty>")
+        """
+    }
+  }
+}
+
 /// A Toolchain is a collection of related compilers and libraries meant to be used together to
 /// build and edit source code.
 ///
@@ -63,6 +101,47 @@ public final class Toolchain: Sendable {
   /// The path to the indexstore library if available.
   public let libIndexStore: AbsolutePath?
 
+  private let swiftVersionTask = ThreadSafeBox<Task<SwiftVersion, any Error>?>(initialValue: nil)
+
+  /// The Swift version installed in the toolchain. Throws an error if the version could not be parsed or if no Swift
+  /// compiler is installed in the toolchain.
+  public var swiftVersion: SwiftVersion {
+    get async throws {
+      let task = swiftVersionTask.withLock { task in
+        if let task {
+          return task
+        }
+        let newTask = Task { () -> SwiftVersion in
+          guard let swiftc else {
+            throw SwiftVersionParsingError.failedToFindSwiftc
+          }
+
+          let process = Process(args: swiftc.pathString, "--version")
+          try process.launch()
+          let result = try await process.waitUntilExit()
+          let output = String(bytes: try result.output.get(), encoding: .utf8)
+          let regex = Regex {
+            "Swift version "
+            Capture { OneOrMore(.digit) }
+            "."
+            Capture { OneOrMore(.digit) }
+          }
+          guard let match = output?.firstMatch(of: regex) else {
+            throw SwiftVersionParsingError.failedToParseOutput(output: output)
+          }
+          guard let major = Int(match.1), let minor = Int(match.2) else {
+            throw SwiftVersionParsingError.failedToParseOutput(output: output)
+          }
+          return SwiftVersion(major, minor)
+        }
+        task = newTask
+        return newTask
+      }
+
+      return try await task.value
+    }
+  }
+
   public init(
     identifier: String,
     displayName: String,

Sources/SKTestSupport/SkipUnless.swift

@@ -65,11 +65,7 @@ public actor SkipUnless {
       // Never skip tests in CI. Toolchain should be up-to-date
       checkResult = .featureSupported
     } else {
-      guard let swiftc = await ToolchainRegistry.forTesting.default?.swiftc else {
-        throw SwiftVersionParsingError.failedToFindSwiftc
-      }
-
-      let toolchainSwiftVersion = try await getSwiftVersion(swiftc)
+      let toolchainSwiftVersion = try await unwrap(ToolchainRegistry.forTesting.default).swiftVersion
       let requiredSwiftVersion = SwiftVersion(swiftVersion.major, swiftVersion.minor)
       if toolchainSwiftVersion < requiredSwiftVersion {
         checkResult = .featureUnsupported(
@@ -297,60 +293,3 @@ fileprivate extension String {
     }
   }
 }
-
-/// A Swift version consisting of the major and minor component.
-fileprivate struct SwiftVersion: Comparable, CustomStringConvertible {
-  let major: Int
-  let minor: Int
-
-  static func < (lhs: SwiftVersion, rhs: SwiftVersion) -> Bool {
-    return (lhs.major, lhs.minor) < (rhs.major, rhs.minor)
-  }
-
-  init(_ major: Int, _ minor: Int) {
-    self.major = major
-    self.minor = minor
-  }
-
-  var description: String {
-    return "\(major).\(minor)"
-  }
-}
-
-fileprivate enum SwiftVersionParsingError: Error, CustomStringConvertible {
-  case failedToFindSwiftc
-  case failedToParseOutput(output: String?)
-
-  var description: String {
-    switch self {
-    case .failedToFindSwiftc:
-      return "Default toolchain does not contain a swiftc executable"
-    case .failedToParseOutput(let output):
-      return """
-        Failed to parse Swift version. Output of swift --version:
-        \(output ?? "<empty>")
-        """
-    }
-  }
-}
-
-/// Return the major and minor version of Swift for a `swiftc` compiler at `swiftcPath`.
-private func getSwiftVersion(_ swiftcPath: AbsolutePath) async throws -> SwiftVersion {
-  let process = Process(args: swiftcPath.pathString, "--version")
-  try process.launch()
-  let result = try await process.waitUntilExit()
-  let output = String(bytes: try result.output.get(), encoding: .utf8)
-  let regex = Regex {
-    "Swift version "
-    Capture { OneOrMore(.digit) }
-    "."
-    Capture { OneOrMore(.digit) }
-  }
-  guard let match = output?.firstMatch(of: regex) else {
-    throw SwiftVersionParsingError.failedToParseOutput(output: output)
-  }
-  guard let major = Int(match.1), let minor = Int(match.2) else {
-    throw SwiftVersionParsingError.failedToParseOutput(output: output)
-  }
-  return SwiftVersion(major, minor)
-}