WIP: swift-get-version

The changes in #6585 meant that we are no longer using LLBuild's built-in tracking of Swift compiler versions. We are lacking the infrastructure to really use that for the same purpose since we are now running the Swift compiler as a shell-tool, so this is adding a poor man's version of that.

We have a task that writes the output of `swift -version` for a particular Swift compiler path to the build directory and all Swift tasks that are using that compiler depend on that file as an input. This should give us the desired behavior of the tasks re-running if the Swift version changes.

This PR passes the existing test suite, but I need to add some tests for the particular scenario of re-running if the version changes.

rdar://114047018

Author: neonichu

Sources/Build/LLBuildManifestBuilder.swift

@@ -53,6 +53,9 @@ public class LLBuildManifestBuilder {
     var buildParameters: BuildParameters { self.plan.buildParameters }
     var buildEnvironment: BuildEnvironment { self.buildParameters.buildEnvironment }
 
+    /// Mapping from Swift compiler path to Swift get version files.
+    var swiftGetVersionFiles = [AbsolutePath: AbsolutePath]()
+
     /// Create a new builder with a build plan.
     public init(
         _ plan: BuildPlan,
@@ -71,6 +74,8 @@ public class LLBuildManifestBuilder {
     /// Generate manifest at the given path.
     @discardableResult
     public func generateManifest(at path: AbsolutePath) throws -> BuildManifest {
+        self.swiftGetVersionFiles.removeAll()
+
         self.manifest.createTarget(TargetKind.main.targetName)
         self.manifest.createTarget(TargetKind.test.targetName)
         self.manifest.defaultTarget = TargetKind.main.targetName
@@ -608,6 +613,9 @@ extension LLBuildManifestBuilder {
     ) throws -> [Node] {
         var inputs = target.sources.map(Node.file)
 
+        let swiftVersionFilePath = addSwiftGetVersionCommand(buildParameters: target.buildParameters)
+        inputs.append(.file(swiftVersionFilePath))
+
         // Add resources node as the input to the target. This isn't great because we
         // don't need to block building of a module until its resources are assembled but
         // we don't currently have a good way to express that resources should be built
@@ -733,6 +741,22 @@ extension LLBuildManifestBuilder {
             arguments: moduleWrapArgs
         )
     }
+
+    private func addSwiftGetVersionCommand(buildParameters: BuildParameters) -> AbsolutePath {
+        let swiftCompilerPath = buildParameters.toolchain.swiftCompilerPath
+
+        // If we are already tracking this compiler, we can re-use the existing command by just returning the tracking file.
+        if let swiftVersionFilePath = swiftGetVersionFiles[swiftCompilerPath] {
+            return swiftVersionFilePath
+        }
+
+        // Otherwise, come up with a path for the new file and generate a command to populate it.
+        let swiftCompilerPathHash = String(swiftCompilerPath.pathString.hash, radix: 16, uppercase: true)
+        let swiftVersionFilePath = buildParameters.buildPath.appending(component: "swift-version-\(swiftCompilerPathHash).txt")
+        self.manifest.addSwiftGetVersionCommand(swiftCompilerPath: swiftCompilerPath, swiftVersionFilePath: swiftVersionFilePath)
+        swiftGetVersionFiles[swiftCompilerPath] = swiftVersionFilePath
+        return swiftVersionFilePath
+    }
 }
 
 extension SwiftDriver.Job {

Sources/LLBuildManifest/BuildManifest.swift

@@ -12,14 +12,16 @@
 
 import Basics
 
+import class TSCBasic.Process
+
 public protocol AuxiliaryFileType {
     static var name: String { get }
 
     static func getFileContents(inputs: [Node]) throws -> String
 }
 
 public enum WriteAuxiliary {
-    public static let fileTypes: [AuxiliaryFileType.Type] = [LinkFileList.self, SourcesFileList.self]
+    public static let fileTypes: [AuxiliaryFileType.Type] = [LinkFileList.self, SourcesFileList.self, SwiftGetVersion.self]
 
     public struct LinkFileList: AuxiliaryFileType {
         public static let name = "link-file-list"
@@ -76,6 +78,28 @@ public enum WriteAuxiliary {
             return contents
         }
     }
+
+    public struct SwiftGetVersion: AuxiliaryFileType {
+        public static let name = "swift-get-version"
+
+        // TODO: Should be always-out-of-date
+
+        public static func computeInputs(swiftCompilerPath: AbsolutePath) -> [Node] {
+            return [.virtual(Self.name), .file(swiftCompilerPath)]
+        }
+
+        public static func getFileContents(inputs: [Node]) throws -> String {
+            guard let swiftCompilerPathString = inputs.first(where: { $0.kind == .file })?.name else {
+                throw Error.unknownSwiftCompilerPath
+            }
+            let swiftCompilerPath = try AbsolutePath(validating: swiftCompilerPathString)
+            return try TSCBasic.Process.checkNonZeroExit(args: swiftCompilerPath.pathString, "-version")
+        }
+
+        private enum Error: Swift.Error {
+            case unknownSwiftCompilerPath
+        }
+    }
 }
 
 public struct BuildManifest {
@@ -173,6 +197,16 @@ public struct BuildManifest {
         commands[name] = Command(name: name, tool: tool)
     }
 
+    public mutating func addSwiftGetVersionCommand(
+        swiftCompilerPath: AbsolutePath,
+        swiftVersionFilePath: AbsolutePath
+    ) {
+        let inputs = WriteAuxiliary.SwiftGetVersion.computeInputs(swiftCompilerPath: swiftCompilerPath)
+        let tool = WriteAuxiliaryFile(inputs: inputs, outputFilePath: swiftVersionFilePath)
+        let name = swiftVersionFilePath.pathString
+        commands[name] = Command(name: name, tool: tool)
+    }
+
     public mutating func addPkgStructureCmd(
         name: String,
         inputs: [Node],

Tests/BuildTests/BuildPlanTests.swift

@@ -867,8 +867,9 @@ final class BuildPlanTests: XCTestCase {
             let llbuild = LLBuildManifestBuilder(plan, fileSystem: fs, observabilityScope: observability.topScope)
             try llbuild.generateManifest(at: yaml)
             let contents: String = try fs.readFileContents(yaml)
+            let swiftGetVersionFilePath = try XCTUnwrap(llbuild.swiftGetVersionFiles.first?.value)
             XCTAssertMatch(contents, .contains("""
-                    inputs: ["\(Pkg.appending(components: "Sources", "exe", "main.swift").escapedPathString())","\(buildPath.appending(components: "PkgLib.swiftmodule").escapedPathString())","\(buildPath.appending(components: "exe.build", "sources").escapedPathString())"]
+                    inputs: ["\(Pkg.appending(components: "Sources", "exe", "main.swift").escapedPathString())","\(swiftGetVersionFilePath.escapedPathString())","\(buildPath.appending(components: "PkgLib.swiftmodule").escapedPathString())","\(buildPath.appending(components: "exe.build", "sources").escapedPathString())"]
                 """))
 
         }
@@ -896,8 +897,9 @@ final class BuildPlanTests: XCTestCase {
             try llbuild.generateManifest(at: yaml)
             let contents: String = try fs.readFileContents(yaml)
             let buildPath = plan.buildParameters.dataPath.appending(components: "debug")
+            let swiftGetVersionFilePath = try XCTUnwrap(llbuild.swiftGetVersionFiles.first?.value)
             XCTAssertMatch(contents, .contains("""
-                    inputs: ["\(Pkg.appending(components: "Sources", "exe", "main.swift").escapedPathString())","\(buildPath.appending(components: "exe.build", "sources").escapedPathString())"]
+                    inputs: ["\(Pkg.appending(components: "Sources", "exe", "main.swift").escapedPathString())","\(swiftGetVersionFilePath.escapedPathString())","\(buildPath.appending(components: "exe.build", "sources").escapedPathString())"]
                 """))
         }
     }
@@ -3894,14 +3896,15 @@ final class BuildPlanTests: XCTestCase {
         let llbuild = LLBuildManifestBuilder(plan, fileSystem: fs, observabilityScope: observability.topScope)
         try llbuild.generateManifest(at: yaml)
         let contents: String = try fs.readFileContents(yaml)
+        let swiftGetVersionFilePath = try XCTUnwrap(llbuild.swiftGetVersionFiles.first?.value)
 
 #if os(Windows)
         let suffix = ".exe"
 #else // FIXME(5472) - the suffix is dropped
         let suffix = ""
 #endif
         XCTAssertMatch(contents, .contains("""
-                inputs: ["\(PkgA.appending(components: "Sources", "swiftlib", "lib.swift").escapedPathString())","\(buildPath.appending(components: "exe\(suffix)").escapedPathString())","\(buildPath.appending(components: "swiftlib.build", "sources").escapedPathString())"]
+                inputs: ["\(PkgA.appending(components: "Sources", "swiftlib", "lib.swift").escapedPathString())","\(swiftGetVersionFilePath.escapedPathString())","\(buildPath.appending(components: "exe\(suffix)").escapedPathString())","\(buildPath.appending(components: "swiftlib.build", "sources").escapedPathString())"]
                 outputs: ["\(buildPath.appending(components: "swiftlib.build", "lib.swift.o").escapedPathString())","\(buildPath.escapedPathString())
             """))
     }
@@ -4804,10 +4807,11 @@ final class BuildPlanTests: XCTestCase {
         let yaml = buildPath.appending("release.yaml")
         let llbuild = LLBuildManifestBuilder(plan, fileSystem: fs, observabilityScope: observability.topScope)
         try llbuild.generateManifest(at: yaml)
+        let swiftGetVersionFilePath = try XCTUnwrap(llbuild.swiftGetVersionFiles.first?.value)
 
         let yamlContents: String = try fs.readFileContents(yaml)
         let inputs: SerializedJSON = """
-            inputs: ["\(AbsolutePath("/Pkg/Snippets/ASnippet.swift"))","\(AbsolutePath("/Pkg/.build/debug/Lib.swiftmodule"))"
+            inputs: ["\(AbsolutePath("/Pkg/Snippets/ASnippet.swift"))","\(swiftGetVersionFilePath.escapedPathString())","\(AbsolutePath("/Pkg/.build/debug/Lib.swiftmodule"))"
         """
         XCTAssertMatch(yamlContents, .contains(inputs.underlying))
     }