Add infrastructure to write tests for Swift macros

Add a default package manifest that defines two targets:
 - A macro target named `MyMacro`
 - And executable target named `MyMacroClient`

It builds the macro using the swift-syntax that was already built as part of the SourceKit-LSP build.
Re-using the SwiftSyntax modules that are already built is significantly faster than building swift-syntax in each test case run and does not require internet access.

Author: ahoppen

Package.swift

@@ -381,6 +381,10 @@ let package = Package(
         .product(name: "SwiftParser", package: "swift-syntax"),
         .product(name: "SwiftSyntax", package: "swift-syntax"),
         .product(name: "SwiftToolsSupport-auto", package: "swift-tools-support-core"),
+        // Depend on `SwiftCompilerPlugin` and `SwiftSyntaxMacros` so the modules are built before running tests and can
+        // be used by test cases that test macros (see `SwiftPMTestProject.macroPackageManifest`).
+        .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
       ]
     ),
   ]

Sources/SKTestSupport/SwiftPMTestProject.swift

@@ -33,6 +33,87 @@ public class SwiftPMTestProject: MultiFileTestProject {
     )
     """
 
+  /// A manifest that defines two targets:
+  ///  - A macro target named `MyMacro`
+  ///  - And executable target named `MyMacroClient`
+  ///
+  /// It builds the macro using the swift-syntax that was already built as part of the SourceKit-LSP build.
+  /// Re-using the SwiftSyntax modules that are already built is significantly faster than building swift-syntax in
+  /// each test case run and does not require internet access.
+  public static var macroPackageManifest: String {
+    get async throws {
+      // build directory is `.build/debug/arm64-apple-macosx` or the platform-specific equivalent
+      let buildDirectory = testBundle.bundleURL.deletingLastPathComponent()
+
+      let swiftSyntaxModulesToLink = [
+        "SwiftBasicFormat",
+        "SwiftCompilerPlugin",
+        "SwiftCompilerPluginMessageHandling",
+        "SwiftDiagnostics",
+        "SwiftOperators",
+        "SwiftParser",
+        "SwiftParserDiagnostics",
+        "SwiftSyntax",
+        "SwiftSyntaxBuilder",
+        "SwiftSyntaxMacroExpansion",
+        "SwiftSyntaxMacros",
+      ]
+
+      var objectFiles: [String] = []
+      for moduleName in swiftSyntaxModulesToLink {
+        let dir = buildDirectory.appendingPathComponent("\(moduleName).build")
+        let enumerator = FileManager.default.enumerator(at: dir, includingPropertiesForKeys: nil)
+        while let file = enumerator?.nextObject() as? URL {
+          if file.pathExtension == "o" {
+            objectFiles.append(file.path)
+          }
+        }
+      }
+
+      let linkerFlags = objectFiles.map {
+        """
+        "-l", "\($0)",
+        """
+      }.joined(separator: "\n")
+
+      let moduleSearchPath: String
+      if let toolchainVersion = try await ToolchainRegistry.forTesting.default?.swiftVersion,
+        toolchainVersion < SwiftVersion(6, 0)
+      {
+        moduleSearchPath = buildDirectory.path
+      } else {
+        moduleSearchPath = "\(buildDirectory.path)/Modules"
+      }
+
+      return """
+        // swift-tools-version: 5.10
+
+        import PackageDescription
+        import CompilerPluginSupport
+
+        let package = Package(
+          name: "MyMacro",
+          platforms: [.macOS(.v10_15)],
+          targets: [
+            .macro(
+              name: "MyMacros",
+              swiftSettings: [.unsafeFlags([
+                "-I", "\(moduleSearchPath)",
+                "-Xcc", "-fmodule-map-file=\(buildDirectory.path)/../../checkouts/swift-syntax/Sources/_SwiftSyntaxCShims/include/module.modulemap"
+              ])],
+              linkerSettings: [
+                .unsafeFlags([
+                  \(linkerFlags)
+                ])
+              ]
+            ),
+            .executableTarget(name: "MyMacroClient", dependencies: ["MyMacros"]),
+          ]
+        )
+        """
+    }
+  }
+
   /// Create a new SwiftPM package with the given files.
   ///
   /// If `index` is `true`, then the package will be built, indexing all modules within the package.

Sources/SKTestSupport/TestBundle.swift

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 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
+
+/// The bundle of the currently executing test.
+public let testBundle: Bundle = {
+  #if os(macOS)
+  if let bundle = Bundle.allBundles.first(where: { $0.bundlePath.hasSuffix(".xctest") }) {
+    return bundle
+  }
+  fatalError("couldn't find the test bundle")
+  #else
+  return Bundle.main
+  #endif
+}()

Tests/SKCoreTests/BuildServerBuildSystemTests.swift

@@ -20,18 +20,6 @@ import SKTestSupport
 import TSCBasic
 import XCTest
 
-/// The bundle of the currently executing test.
-private let testBundle: Bundle = {
-  #if os(macOS)
-  if let bundle = Bundle.allBundles.first(where: { $0.bundlePath.hasSuffix(".xctest") }) {
-    return bundle
-  }
-  fatalError("couldn't find the test bundle")
-  #else
-  return Bundle.main
-  #endif
-}()
-
 /// The path to the built products directory.
 private let productsDirectory: URL = {
   #if os(macOS)

Tests/SKSwiftPMWorkspaceTests/SwiftPMBuildSystemTests.swift

@@ -772,6 +772,52 @@ final class SwiftPMBuildSystemTests: XCTestCase {
       assertArgumentsContain(aswift.pathString, arguments: arguments)
     }
   }
+
+  func testBuildMacro() async throws {
+    // This test is just a dummy to show how to create a `SwiftPMTestProject` that builds a macro using the SwiftSyntax
+    // modules that were already built during the build of SourceKit-LSP.
+    // It should be removed once we have a real test that tests macros (like macro expansion).
+    _ = try await SwiftPMTestProject(
+      files: [
+        "MyMacros/MyMacros.swift": #"""
+        import SwiftCompilerPlugin
+        import SwiftSyntax
+        import SwiftSyntaxBuilder
+        import SwiftSyntaxMacros
+
+        public struct StringifyMacro: ExpressionMacro {
+          public static func expansion(
+            of node: some FreestandingMacroExpansionSyntax,
+            in context: some MacroExpansionContext
+          ) -> ExprSyntax {
+            guard let argument = node.argumentList.first?.expression else {
+              fatalError("compiler bug: the macro does not have any arguments")
+            }
+
+            return "(\(argument), \(literal: argument.description))"
+          }
+        }
+
+        @main
+        struct MyMacroPlugin: CompilerPlugin {
+            let providingMacros: [Macro.Type] = [
+                StringifyMacro.self,
+            ]
+        }
+        """#,
+        "MyMacroClient/MyMacroClient.swift": """
+        @freestanding(expression)
+        public macro stringify<T>(_ value: T) -> (T, String) = #externalMacro(module: "MyMacros", type: "StringifyMacro")
+
+        func test() {
+          #stringify(1 + 2)
+        }
+        """,
+      ],
+      manifest: SwiftPMTestProject.macroPackageManifest,
+      build: true
+    )
+  }
 }
 
 private func assertArgumentsDoNotContain(