Introduce a MultiFileTestWorkspace that can store multiple files of arbitrary languages

This allows us to remove the `BasicCXX` test directory.

Author: ahoppen

Sources/SKTestSupport/INPUTS/BasicCXX/Object.h

@@ -30,7 +30,7 @@ public struct IndexedSingleSwiftFileWorkspace {
     _ markedText: String,
     testName: String = #function
   ) async throws {
-    let testWorkspaceDirectory = try testScratchDirName(testName)
+    let testWorkspaceDirectory = try testScratchDir(testName: testName)
 
     let testFileURL = testWorkspaceDirectory.appendingPathComponent("test.swift")
     let indexURL = testWorkspaceDirectory.appendingPathComponent("index")

Sources/SKTestSupport/INPUTS/BasicCXX/main.c

@@ -0,0 +1,121 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Foundation
+import LanguageServerProtocol
+import SKCore
+
+/// The location of a test file within test workspace.
+public struct RelativeFileLocation: Hashable, ExpressibleByStringLiteral {
+  /// The subdirectories in which the file is located.
+  fileprivate let directories: [String]
+
+  /// The file's name.
+  fileprivate let fileName: String
+
+  public init(directories: [String] = [], _ fileName: String) {
+    self.directories = directories
+    self.fileName = fileName
+  }
+
+  public init(stringLiteral value: String) {
+    self.init(value)
+  }
+}
+
+/// A workspace that writes multiple files to disk and opens a `TestSourceKitLSPClient` client with a workspace pointing
+/// to a temporary directory containing those files.
+///
+/// The temporary files will be deleted when the `TestSourceKitLSPClient` is destructed.
+public class MultiFileTestWorkspace {
+  /// Information necessary to open a file in the LSP server by its filename.
+  private struct FileData {
+    /// The URI at which the file is stored on disk.
+    let uri: DocumentURI
+
+    /// The contents of the file including location markers.
+    let markedText: String
+  }
+
+  public let testClient: TestSourceKitLSPClient
+
+  /// Information necessary to open a file in the LSP server by its filename.
+  private let fileData: [String: FileData]
+
+  enum Error: Swift.Error {
+    /// No file with the given filename is known to the `SwiftPMTestWorkspace`.
+    case fileNotFound
+  }
+
+  /// The directory in which the temporary files are being placed.
+  let scratchDirectory: URL
+
+  public init(
+    files: [RelativeFileLocation: String],
+    testName: String = #function
+  ) async throws {
+    scratchDirectory = try testScratchDir(testName: testName)
+    try FileManager.default.createDirectory(at: scratchDirectory, withIntermediateDirectories: true)
+
+    var fileData: [String: FileData] = [:]
+    for (fileLocation, markedText) in files {
+      var fileURL = scratchDirectory
+      for directory in fileLocation.directories {
+        fileURL = fileURL.appendingPathComponent(directory)
+      }
+      fileURL = fileURL.appendingPathComponent(fileLocation.fileName)
+      try FileManager.default.createDirectory(
+        at: fileURL.deletingLastPathComponent(),
+        withIntermediateDirectories: true
+      )
+      try extractMarkers(markedText).textWithoutMarkers.write(to: fileURL, atomically: false, encoding: .utf8)
+
+      precondition(
+        fileData[fileLocation.fileName] == nil,
+        "Files within a `MultiFileTestWorkspace` must have unique names"
+      )
+      fileData[fileLocation.fileName] = FileData(
+        uri: DocumentURI(fileURL),
+        markedText: markedText
+      )
+    }
+    self.fileData = fileData
+
+    self.testClient = try await TestSourceKitLSPClient(
+      workspaceFolders: [
+        WorkspaceFolder(uri: DocumentURI(scratchDirectory))
+      ],
+      cleanUp: { [scratchDirectory] in
+        try? FileManager.default.removeItem(at: scratchDirectory)
+      }
+    )
+  }
+
+  /// Opens the document with the given file name in the SourceKit-LSP server.
+  ///
+  /// - Returns: The URI for the opened document and the positions of the location markers.
+  public func openDocument(_ fileName: String) throws -> (uri: DocumentURI, positions: DocumentPositions) {
+    guard let fileData = self.fileData[fileName] else {
+      throw Error.fileNotFound
+    }
+    let positions = testClient.openDocument(fileData.markedText, uri: fileData.uri)
+    return (fileData.uri, positions)
+  }
+
+  /// Returns the URI of the file with the given name.
+  public func uri(for fileName: String) throws -> DocumentURI {
+    guard let fileData = self.fileData[fileName] else {
+      throw Error.fileNotFound
+    }
+    return fileData.uri
+  }
+}

Sources/SKTestSupport/INPUTS/BasicCXX/project.json

@@ -15,44 +15,12 @@ import LanguageServerProtocol
 import SKCore
 import TSCBasic
 
-public struct SwiftPMTestWorkspace {
-  /// The location of a file within a package, ie. its module and its filename.
-  public struct FileSpec: Hashable, ExpressibleByStringLiteral {
-    fileprivate let moduleName: String
-    fileprivate let fileName: String
-
-    public init(module: String = "MyLibrary", _ fileName: String) {
-      self.moduleName = module
-      self.fileName = fileName
-    }
-
-    public init(stringLiteral value: String) {
-      self.init(value)
-    }
-  }
-
-  /// Information necessary to open a file in the LSP server by its filename.
-  private struct FileData {
-    /// The URI at which the file is stored on disk.
-    let uri: DocumentURI
-
-    /// The contents of the file including location markers.
-    let markedText: String
-  }
-
+public class SwiftPMTestWorkspace: MultiFileTestWorkspace {
   enum Error: Swift.Error {
     /// The `swift` executable could not be found.
     case swiftNotFound
-
-    /// No file with the given filename is known to the `SwiftPMTestWorkspace`.
-    case fileNotFound
   }
 
-  public let testClient: TestSourceKitLSPClient
-
-  /// Information necessary to open a file in the LSP server by its filename.
-  private let fileData: [String: FileData]
-
   public static let defaultPackageManifest: String = """
     // swift-tools-version: 5.7
 
@@ -68,70 +36,29 @@ public struct SwiftPMTestWorkspace {
   ///
   /// If `index` is `true`, then the package will be built, indexing all modules within the package.
   public init(
-    files: [FileSpec: String],
-    manifest: String = Self.defaultPackageManifest,
+    files: [String: String],
+    manifest: String = SwiftPMTestWorkspace.defaultPackageManifest,
     index: Bool = false,
     testName: String = #function
   ) async throws {
-    let packageDirectory = try testScratchDirName(testName)
+    var filesByPath: [RelativeFileLocation: String] = [:]
+    for (fileName, contents) in files {
+      filesByPath[RelativeFileLocation(directories: ["Sources", "MyLibrary"], fileName)] = contents
+    }
+    filesByPath["Package.swift"] = manifest
+    try await super.init(
+      files: filesByPath,
+      testName: testName
+    )
 
     guard let swift = ToolchainRegistry.shared.default?.swift?.asURL else {
       throw Error.swiftNotFound
     }
 
-    var fileData: [String: FileData] = [:]
-    for (fileSpec, markedText) in files {
-      let fileURL =
-        packageDirectory
-        .appendingPathComponent("Sources")
-        .appendingPathComponent(fileSpec.moduleName)
-        .appendingPathComponent(fileSpec.fileName)
-      try FileManager.default.createDirectory(
-        at: fileURL.deletingLastPathComponent(),
-        withIntermediateDirectories: true
-      )
-      try extractMarkers(markedText).textWithoutMarkers.write(
-        to: fileURL,
-        atomically: false,
-        encoding: .utf8
-      )
-
-      fileData[fileSpec.fileName] = FileData(
-        uri: DocumentURI(fileURL),
-        markedText: markedText
-      )
-    }
-    self.fileData = fileData
-
-    try manifest.write(
-      to: packageDirectory.appendingPathComponent("Package.swift"),
-      atomically: false,
-      encoding: .utf8
-    )
-
     if index {
-      /// Running `swift build` might fail if the package contains syntax errors. That's intentional
-      try await Process.checkNonZeroExit(arguments: [swift.path, "build", "--package-path", packageDirectory.path])
+      try await Process.checkNonZeroExit(arguments: [swift.path, "build", "--package-path", scratchDirectory.path])
     }
-
-    self.testClient = try await TestSourceKitLSPClient(
-      workspaceFolders: [
-        WorkspaceFolder(uri: DocumentURI(packageDirectory))
-      ],
-      cleanUp: {
-        try? FileManager.default.removeItem(at: packageDirectory)
-      }
-    )
-
     // Wait for the indexstore-db to finish indexing
     _ = try await testClient.send(PollIndexRequest())
   }
-
-  public func openDocument(_ fileName: String) throws -> (uri: DocumentURI, positions: DocumentPositions) {
-    guard let fileData = self.fileData[fileName] else {
-      throw Error.fileNotFound
-    }
-    let positions = testClient.openDocument(fileData.markedText, uri: fileData.uri)
-    return (fileData.uri, positions)
-  }
 }

Sources/SKTestSupport/IndexedSingleSwiftFileWorkspace.swift

@@ -12,6 +12,7 @@
 
 import Foundation
 import LanguageServerProtocol
+import SKCore
 
 extension Language {
   var fileExtension: String {
@@ -44,7 +45,7 @@ extension DocumentURI {
 }
 
 /// An empty directory in which a test with `#function` name `testName` can store temporary data.
-func testScratchDirName(_ testName: String) throws -> URL {
+public func testScratchDir(testName: String = #function) throws -> URL {
   let testBaseName = testName.prefix(while: \.isLetter)
 
   let url = FileManager.default.temporaryDirectory
@@ -80,3 +81,5 @@ fileprivate extension URL {
     #endif
   }
 }
+
+public let hasClangd = ToolchainRegistry.shared.default?.clangd != nil

Sources/SKTestSupport/MultiFileTestWorkspace.swift

@@ -269,21 +269,27 @@ final class LocalClangTests: XCTestCase {
   }
 
   func testSemanticHighlighting() async throws {
-    guard haveClangd else { return }
-    guard let ws = try await staticSourceKitTibsWorkspace(name: "BasicCXX") else {
-      return
-    }
-    let mainLoc = ws.testLoc("Object:include:main")
+    try XCTSkipIf(!hasClangd)
 
-    try ws.openDocument(mainLoc.url, language: .c)
+    let testClient = try await TestSourceKitLSPClient()
+    let uri = DocumentURI.for(.c)
 
-    let diags = try await ws.testClient.nextDiagnosticsNotification()
+    testClient.openDocument(
+      """
+      int main(int argc, const char *argv[]) {
+      }
+      """,
+      uri: uri
+    )
+
+    let diags = try await testClient.nextDiagnosticsNotification()
     XCTAssertEqual(diags.diagnostics.count, 0)
 
-    let request = DocumentSemanticTokensRequest(textDocument: mainLoc.docIdentifier)
+    let request = DocumentSemanticTokensRequest(textDocument: TextDocumentIdentifier(uri))
     do {
-      let reply = try await ws.testClient.send(request)
-      XCTAssertNotNil(reply)
+      let reply = try await testClient.send(request)
+      let data = try XCTUnwrap(reply?.data)
+      XCTAssertGreaterThanOrEqual(data.count, 0)
     } catch let e {
       if let error = e as? ResponseError {
         try XCTSkipIf(
@@ -296,32 +302,49 @@ final class LocalClangTests: XCTestCase {
   }
 
   func testDocumentDependenciesUpdated() async throws {
-    let ws = try await mutableSourceKitTibsTestWorkspace(name: "BasicCXX")!
+    try XCTSkipIf(!hasClangd)
+
+    let ws = try await MultiFileTestWorkspace(files: [
+      "Object.h": """
+      struct Object {
+        int field;
+      };
+
+      struct Object * newObject();
+      """,
+      "main.c": """
+      #include "Object.h"
 
-    let cFileLoc = ws.testLoc("Object:ref:main")
+      int main(int argc, const char *argv[]) {
+        struct Object *obj = 1️⃣newObject();
+      }
+      """,
+      "compile_flags.txt": "",
+    ])
 
-    try ws.openDocument(cFileLoc.url, language: .cpp)
+    let (mainUri, _) = try ws.openDocument("main.c")
+    let headerUri = try ws.uri(for: "Object.h")
 
     // Initially the workspace should build fine.
     let initialDiags = try await ws.testClient.nextDiagnosticsNotification()
     XCTAssert(initialDiags.diagnostics.isEmpty)
 
     // We rename Object to MyObject in the header.
-    _ = try ws.sources.edit { builder in
-      let headerFilePath = ws.sources.rootDirectory.appendingPathComponent("Object.h")
-      var headerFile = try String(contentsOf: headerFilePath, encoding: .utf8)
-      let targetMarkerRange = headerFile.range(of: "/*Object*/")!
-      headerFile.replaceSubrange(targetMarkerRange, with: "My")
-      builder.write(headerFile, to: headerFilePath)
-    }
+    try """
+    struct MyObject {
+      int field;
+    };
+
+    struct MyObject * newObject();
+    """.write(to: headerUri.fileURL!, atomically: false, encoding: .utf8)
 
     let clangdServer = await ws.testClient.server._languageService(
-      for: cFileLoc.docUri,
-      .cpp,
-      in: ws.testClient.server.workspaceForDocument(uri: cFileLoc.docUri)!
+      for: mainUri,
+      .c,
+      in: ws.testClient.server.workspaceForDocument(uri: mainUri)!
     )!
 
-    await clangdServer.documentDependenciesUpdated(cFileLoc.docUri)
+    await clangdServer.documentDependenciesUpdated(mainUri)
 
     // Now we should get a diagnostic in main.c file because `Object` is no longer defined.
     let editedDiags = try await ws.testClient.nextDiagnosticsNotification()