Add sentinal file in scratchpath

Add a sentinal file (one for each build configuration) in the scratch
path that contains the contents of the last build system used to build
said configuration.

Relates to: swiftlang/sourcekit-lsp#2576

Author: bkhouri

Sources/CoreCommands/SwiftCommandState.swift

@@ -130,6 +130,11 @@ extension SwiftCommand {
         )
         defer {
             _ = createCacheDirFile(inDirectory: swiftCommandState.scratchDirectory)
+            _ = createBuildSystemFile(
+                inDirectory: swiftCommandState.scratchDirectory,
+                for: swiftCommandState.options.build.configuration ?? swiftCommandState.preferredBuildConfiguration,
+                buildSystem: swiftCommandState.options.build.buildSystem,
+            )
         }
 
         // We use this to attempt to catch misuse of the locking APIs since we only release the lock from here.
@@ -164,7 +169,8 @@ extension SwiftCommand {
 
 package func createCacheDirFile(
     inDirectory directory: AbsolutePath,
-    _ fileSystem: FileSystem = localFileSystem) -> AbsolutePath? {
+    _ fileSystem: FileSystem = localFileSystem,
+) -> AbsolutePath? {
     // https://bford.info/cachedir/
     let path = directory.appending("CACHEDIR.TAG")
     do {
@@ -181,8 +187,25 @@ package func createCacheDirFile(
         // Don't error out if we fail to create the CACHEDIR.TAG file, as this is not critical to the functioning of the tool.
         return nil
     }
+}
 
+package func createBuildSystemFile(
+    inDirectory directory: AbsolutePath,
+    for configuration: BuildConfiguration,
+    buildSystem: BuildSystemProvider.Kind,
+    fileSystem fs: FileSystem = localFileSystem,
+) -> AbsolutePath? {
+    let path = directory.appending(".buildSystem_\(configuration)")
+    do {
+        try fs.createDirectory(path.parentDirectory, recursive: true)
+        try fs.writeFileContents(path, string: "\(buildSystem)")
+        return path
+    } catch {
+        // Don't error out if we fail to create the CACHEDIR.TAG file, as this is not critical to the functioning of the tool.
+        return nil
+    }
 }
+
 public protocol AsyncSwiftCommand: AsyncParsableCommand, _SwiftCommand {
     func run(_ swiftCommandState: SwiftCommandState) async throws
     var addCacheDirTagFile: Bool { get }
@@ -206,6 +229,11 @@ extension AsyncSwiftCommand {
             if self.addCacheDirTagFile {
                 _ = createCacheDirFile(inDirectory: swiftCommandState.scratchDirectory)
             }
+            _ = createBuildSystemFile(
+                inDirectory: swiftCommandState.scratchDirectory,
+                for: swiftCommandState.options.build.configuration ?? swiftCommandState.preferredBuildConfiguration,
+                buildSystem: swiftCommandState.options.build.buildSystem,
+            )
         }
 
         // We use this to attempt to catch misuse of the locking APIs since we only release the lock from here.

Sources/_InternalTestSupport/SwiftTesting+Helpers.swift

@@ -17,6 +17,7 @@ import Testing
 fileprivate func fileErrorMessage(
     at path: AbsolutePath,
     prefix: Comment?,
+    fileSystem fs: FileSystem = localFileSystem,
     comment: Comment,
 ) -> Comment {
     let commentPrefix =
@@ -29,22 +30,24 @@ fileprivate func fileErrorMessage(
     let commentSuffix: String
     do {
         let parentDir = path.parentDirectory
-        commentSuffix = try " Directory contents of \(parentDir) : \(localFileSystem.getDirectoryContents(parentDir))."
+        commentSuffix = try " Directory contents of \(parentDir) : \(fs.getDirectoryContents(parentDir))."
     } catch {
         commentSuffix = ""
     }
-    return Comment("\(commentPrefix)\(comment) \(commentSuffix).")
+    return Comment("\(commentPrefix)\(comment)\(commentSuffix)")
 }
 public func expectFileExists(
     at path: AbsolutePath,
     _ comment: Comment? = nil,
+    fileSystem fs: FileSystem = localFileSystem,
     sourceLocation: SourceLocation = #_sourceLocation,
 ) {
     #expect(
-        localFileSystem.exists(path),
+        fs.exists(path),
         fileErrorMessage(
             at: path,
             prefix: comment,
+            fileSystem: fs,
             comment: "File '\(path)' does not exist.",
         ),
         sourceLocation: sourceLocation,
@@ -54,13 +57,15 @@ public func expectFileExists(
 public func requireFileExists(
     at path: AbsolutePath,
     _ comment: Comment? = nil,
+    fileSystem fs: FileSystem = localFileSystem,
     sourceLocation: SourceLocation = #_sourceLocation,
 ) throws {
     try #require(
-        localFileSystem.exists(path),
+        fs.exists(path),
         fileErrorMessage(
             at: path,
             prefix: comment,
+            fileSystem: fs,
             comment: "File '\(path)' does not exist.",
         ),
         sourceLocation: sourceLocation,
@@ -70,13 +75,15 @@ public func requireFileExists(
 public func expectFileDoesNotExists(
     at path: AbsolutePath,
     _ comment: Comment? = nil,
+    fileSystem fs: FileSystem = localFileSystem,
     sourceLocation: SourceLocation = #_sourceLocation,
 ) {
     #expect(
-        !localFileSystem.exists(path),
+        !fs.exists(path),
         fileErrorMessage(
             at: path,
             prefix: comment,
+            fileSystem: fs,
             comment: "File: '\(path)' was not expected to exist, but does.",
         ),
         sourceLocation: sourceLocation,
@@ -85,13 +92,15 @@ public func expectFileDoesNotExists(
 public func requireFileDoesNotExists(
     at path: AbsolutePath,
     _ comment: Comment? = nil,
+    fileSystem fs: FileSystem = localFileSystem,
     sourceLocation: SourceLocation = #_sourceLocation,
 ) throws {
     try #require(
-        !localFileSystem.exists(path),
+        !fs.exists(path),
         fileErrorMessage(
             at: path,
             prefix: comment,
+            fileSystem: fs,
             comment: "File: '\(path)' was not expected to exist, but does.",
         ),
         sourceLocation: sourceLocation,
@@ -101,6 +110,7 @@ public func requireFileDoesNotExists(
 public func expectFileIsExecutable(
     at fixturePath: AbsolutePath,
     _ comment: Comment? = nil,
+    fileSystem fs: FileSystem = localFileSystem,
     sourceLocation: SourceLocation = #_sourceLocation,
 ) {
     let commentPrefix =
@@ -110,15 +120,16 @@ public func expectFileIsExecutable(
             ""
         }
     #expect(
-        localFileSystem.isExecutableFile(fixturePath),
+        fs.isExecutableFile(fixturePath),
         "\(commentPrefix)File '\(fixturePath)' expected to be executable, but is not.",
         sourceLocation: sourceLocation,
     )
 }
 
 private func directoryExistsErrorMessage(
     for path: AbsolutePath,
-    comment: Comment?
+    comment: Comment?,
+    fileSystem fs: FileSystem = localFileSystem,
 ) -> Comment {
     let commentPrefix =
         if let comment {
@@ -128,7 +139,7 @@ private func directoryExistsErrorMessage(
         }
     let msgSuffix: String
     do {
-        msgSuffix = try "Directory contents: \(localFileSystem.getDirectoryContents(path))"
+        msgSuffix = try "Directory contents: \(fs.getDirectoryContents(path))"
     } catch {
         msgSuffix = ""
     }
@@ -138,40 +149,76 @@ private func directoryExistsErrorMessage(
 public func requireDirectoryExists(
     at path: AbsolutePath,
     _ comment: Comment? = nil,
-    fileSystem: FileSystem = localFileSystem,
+    fileSystem fs: FileSystem = localFileSystem,
     sourceLocation: SourceLocation = #_sourceLocation,
 ) throws {
     try #require(
-        localFileSystem.isDirectory(path),
+        fs.isDirectory(path),
         directoryExistsErrorMessage(for: path, comment: comment),
         sourceLocation: sourceLocation,
     )
 }
 
+@available(*, deprecated, message: "use `expectDirectoryExist` instead.")
 public func expectDirectoryExists(
     at path: AbsolutePath,
     _ comment: Comment? = nil,
+    fileSystem fs: FileSystem = localFileSystem,
+    sourceLocation: SourceLocation = #_sourceLocation,
+) {
+    expectDirectoryExists(
+        at: path,
+        comment,
+        fileSystem: fs,
+        sourceLocation: sourceLocation,
+    )
+}
+
+public func expectDirectoryExist(
+    at path: AbsolutePath,
+    _ comment: Comment? = nil,
+    fileSystem fs: FileSystem = localFileSystem,
     sourceLocation: SourceLocation = #_sourceLocation,
 ) {
     #expect(
-        localFileSystem.isDirectory(path),
-        directoryExistsErrorMessage(for: path, comment: comment),
+        fs.isDirectory(path),
+        directoryExistsErrorMessage(for: path, comment: comment, fileSystem: fs),
+        sourceLocation: sourceLocation,
+    )
+}
+
+public func requireDirectoryDoesNotExist(
+    at path: AbsolutePath,
+    fileSystem fs: FileSystem = localFileSystem,
+    sourceLocation: SourceLocation = #_sourceLocation,
+) throws {
+    let msgSuffix: String
+    do {
+        msgSuffix = try "Directory contents: \(fs.getDirectoryContents(path))"
+    } catch {
+        msgSuffix = ""
+    }
+    try #require(
+        !fs.isDirectory(path),
+        "Directory exists unexpectedly: '\(path)'.\(msgSuffix)",
         sourceLocation: sourceLocation,
     )
 }
 
+
 public func expectDirectoryDoesNotExist(
     at path: AbsolutePath,
+    fileSystem fs: FileSystem = localFileSystem,
     sourceLocation: SourceLocation = #_sourceLocation,
 ) {
     let msgSuffix: String
     do {
-        msgSuffix = try "Directory contents: \(localFileSystem.getDirectoryContents(path))"
+        msgSuffix = try "Directory contents: \(fs.getDirectoryContents(path))"
     } catch {
         msgSuffix = ""
     }
     #expect(
-        !localFileSystem.isDirectory(path),
+        !fs.isDirectory(path),
         "Directory exists unexpectedly: '\(path)'.\(msgSuffix)",
         sourceLocation: sourceLocation,
     )
@@ -181,10 +228,11 @@ public func expectDirectoryDoesNotExist(
 package func expectDirectoryContainsFile(
     dir: AbsolutePath,
     filename: String,
+    fileSystem fs: FileSystem = localFileSystem,
     sourceLocation: SourceLocation = #_sourceLocation,
 ) {
     do {
-        for entry in try walk(dir) {
+        for entry in try walk(dir, fileSystem: fs) {
             if entry.basename == filename { return }
         }
     } catch {

Tests/CommandsTests/SwiftCommandStateTests.swift

@@ -15,6 +15,7 @@
 @testable import Commands
 @testable import CoreCommands
 
+import struct SPMBuildCore.BuildSystemProvider
 @_spi(DontAdoptOutsideOfSwiftPMExposedForBenchmarksAndTestsOnly)
 import func PackageGraph.loadModulesGraph
 
@@ -55,6 +56,46 @@ struct SwiftCommandStateTestSuites {
         try #require(contentArray.isEmpty == false, "Content array is empty, when it shouldn't be. Content is: \(contents)")
         #expect(contentArray[0] == "Signature: 8a477f597d28d172789f06886806bc55")
     }
+
+    @Test(
+        // arguments: getBuildData(for: BuildSystemProvider.Kind.allCases)
+    ) func createBuildSystemFileContainsExpectedContents(
+        // buildData: BuildData,
+    ) async throws {
+        let buildData = BuildData(
+            buildSystem: BuildSystemProvider.Kind.swiftbuild,
+            config: BuildConfiguration.debug,
+        )
+
+        let fs = InMemoryFileSystem()
+        let dir = AbsolutePath.root.appending(components: "tmp", "output", "build")
+        let buildSystemDefinitionFile = dir.appending(".buildSystem_\(buildData.config)")
+
+        try requireFileDoesNotExists(
+            at: buildSystemDefinitionFile,
+            fileSystem: fs,
+        )
+        let actualBuildSystemDefinition = try #require(
+            createBuildSystemFile(
+                inDirectory: dir,
+                for: buildData.config,
+                buildSystem: buildData.buildSystem,
+                fileSystem: fs,
+            )
+        )
+
+        // Assert
+        try #require(actualBuildSystemDefinition == buildSystemDefinitionFile)
+        try requireFileExists(
+            at: actualBuildSystemDefinition,
+            fileSystem: fs
+        )
+        let contents = try fs.readFileContents(actualBuildSystemDefinition).description
+        #expect(
+            contents == "\(buildData.buildSystem)",
+            "Actual is not as expected",
+        )
+    }
 }
 
 final class SwiftCommandStateTests: XCTestCase {