Create test case testFreestandingMacroExpansion

Author: lokesh-tr

Tests/SourceKitLSPTests/ExecuteCommandTests.swift

@@ -136,6 +136,95 @@ final class ExecuteCommandTests: XCTestCase {
     )
   }
 
+  func testFreestandingMacroExpansion() async throws {
+    try await SkipUnless.canBuildMacroUsingSwiftSyntaxFromSourceKitLSPBuild()
+
+    let project = 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() {
+           1️⃣#stringify2️⃣(1 + 2)
+        }
+        """,
+      ],
+      manifest: SwiftPMTestProject.macroPackageManifest
+    )
+    try await SwiftPMTestProject.build(at: project.scratchDirectory)
+
+    let (uri, positions) = try project.openDocument("MyMacroClient.swift")
+
+    let args = ExpandMacroCommand(
+      positionRange: positions["1️⃣"]..<positions["2️⃣"],
+      textDocument: TextDocumentIdentifier(uri)
+    )
+
+    let metadata = SourceKitLSPCommandMetadata(textDocument: TextDocumentIdentifier(uri))
+
+    var command = try args.asCommand()
+    command.arguments?.append(metadata.encodeToLSPAny())
+
+    let request = ExecuteCommandRequest(command: command.command, arguments: command.arguments)
+
+    project.testClient.handleSingleRequest { (req: ShowDocumentRequest) -> ShowDocumentResponse in
+      return ShowDocumentResponse(success: true)
+    }
+
+    let result = try await project.testClient.send(request)
+
+    guard let resultArray: [MacroExpansionEdit] = Array(fromLSPArray: result ?? .null) else {
+      XCTFail("Result is not an array.")
+      return
+    }
+
+    XCTAssertEqual(resultArray.count, 1)
+    XCTAssertEqual(resultArray[0].newText, "(1 + 2, \"1 + 2\")")
+
+    let generatedMacroExpansionsPath = SourceKitLSPServer.Options.testDefault.generatedMacroExpansionsPath
+
+    XCTAssert(
+      (try? generatedMacroExpansionsPath.appending(component: resultArray[0].bufferName).asURL
+        .checkResourceIsReachable()) ?? false
+    )
+
+    let fileContents = try XCTUnwrap(
+      try? String(
+        contentsOf: generatedMacroExpansionsPath.appending(component: resultArray[0].bufferName).asURL,
+        encoding: .utf8
+      )
+    )
+
+    XCTAssertTrue(fileContents.contains("(1 + 2, \"1 + 2\")"))
+  }
+
   func testLSPCommandMetadataRetrieval() {
     var req = ExecuteCommandRequest(command: "", arguments: nil)
     XCTAssertNil(req.metadata)