Add LSP support for showing @attached Macro Expansions

Author: lokesh-tr

Sources/SourceKitLSP/Swift/MacroExpansion.swift

@@ -95,7 +95,7 @@ extension SwiftLanguageService {
 
         // github permalink notation for position range
         let macroExpansionPositionRangeIndicator =
-          "L\(macroEdit.range.lowerBound.line)C\(macroEdit.range.lowerBound.utf16index)-L\(macroEdit.range.upperBound.line)C\(macroEdit.range.upperBound.utf16index)"
+          "L\(macroEdit.range.lowerBound.line + 1)C\(macroEdit.range.lowerBound.utf16index + 1)-L\(macroEdit.range.upperBound.line + 1)C\(macroEdit.range.upperBound.utf16index + 1)"
 
         let macroExpansionFilePath =
           macroExpansionBufferDirectoryURL
@@ -112,7 +112,7 @@ extension SwiftLanguageService {
         }
 
         Task {
-          let req = ShowDocumentRequest(uri: DocumentURI(macroExpansionFilePath), selection: macroEdit.range)
+          let req = ShowDocumentRequest(uri: DocumentURI(macroExpansionFilePath))
 
           let response = await orLog("Sending ShowDocumentRequest to Client") {
             try await sourceKitLSPServer.sendRequestToClient(req)

Tests/SourceKitLSPTests/ExecuteCommandTests.swift

@@ -252,7 +252,209 @@ final class ExecuteCommandTests: XCTestCase {
 
       XCTAssertEqual(
         url.lastPathComponent,
-        "MyMacroClient_L4C2-L4C19.swift",
+        "MyMacroClient_L5C3-L5C20.swift",
+        "Failed for position range between \(positionMarker.start) and \(positionMarker.end)"
+      )
+    }
+  }
+
+  func testAttachedMacroExpansion() async throws {
+    try await SkipUnless.canBuildMacroUsingSwiftSyntaxFromSourceKitLSPBuild()
+
+    let options = SourceKitLSPOptions.testDefault(experimentalFeatures: [.showMacroExpansions])
+
+    let project = try await SwiftPMTestProject(
+      files: [
+        "MyMacros/MyMacros.swift": #"""
+        import SwiftCompilerPlugin
+        import SwiftSyntax
+        import SwiftSyntaxBuilder
+        import SwiftSyntaxMacros
+
+        public struct DictionaryStorageMacro {}
+
+        extension DictionaryStorageMacro: MemberMacro {
+          public static func expansion(
+            of node: AttributeSyntax,
+            providingMembersOf declaration: some DeclGroupSyntax,
+            in context: some MacroExpansionContext
+          ) throws -> [DeclSyntax] {
+            return ["\n  var _storage: [String: Any] = [:]"]
+          }
+        }
+
+        extension DictionaryStorageMacro: MemberAttributeMacro {
+          public static func expansion(
+            of node: AttributeSyntax,
+            attachedTo declaration: some DeclGroupSyntax,
+            providingAttributesFor member: some DeclSyntaxProtocol,
+            in context: some MacroExpansionContext
+          ) throws -> [AttributeSyntax] {
+            return [
+              AttributeSyntax(
+                leadingTrivia: [.newlines(1), .spaces(2)],
+                attributeName: IdentifierTypeSyntax(
+                  name: .identifier("DictionaryStorageProperty")
+                )
+              )
+            ]
+          }
+        }
+
+        public struct DictionaryStoragePropertyMacro: AccessorMacro {
+          public static func expansion<
+            Context: MacroExpansionContext,
+            Declaration: DeclSyntaxProtocol
+          >(
+            of node: AttributeSyntax,
+            providingAccessorsOf declaration: Declaration,
+            in context: Context
+          ) throws -> [AccessorDeclSyntax] {
+            guard let binding = declaration.as(VariableDeclSyntax.self)?.bindings.first,
+              let identifier = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier,
+              binding.accessorBlock == nil,
+              let type = binding.typeAnnotation?.type,
+              let defaultValue = binding.initializer?.value,
+              identifier.text != "_storage"
+            else {
+              return []
+            }
+
+            return [
+              """
+              get {
+                _storage[\(literal: identifier.text), default: \(defaultValue)] as! \(type)
+              }
+              """,
+              """
+              set {
+                _storage[\(literal: identifier.text)] = newValue
+              }
+              """,
+            ]
+          }
+        }
+
+        @main
+        struct MyMacroPlugin: CompilerPlugin {
+          let providingMacros: [Macro.Type] = [
+            DictionaryStorageMacro.self,
+            DictionaryStoragePropertyMacro.self
+          ]
+        }
+        """#,
+        "MyMacroClient/MyMacroClient.swift": #"""
+        @attached(memberAttribute)
+        @attached(member, names: named(_storage))
+        public macro DictionaryStorage() = #externalMacro(module: "MyMacros", type: "DictionaryStorageMacro")
+
+        @attached(accessor)
+        public macro DictionaryStorageProperty() =
+          #externalMacro(module: "MyMacros", type: "DictionaryStoragePropertyMacro")
+
+        1️⃣@2️⃣DictionaryStorage3️⃣
+        struct Point {
+          var x: Int = 1
+          var y: Int = 2
+        }
+        """#,
+      ],
+      manifest: SwiftPMTestProject.macroPackageManifest,
+      options: options
+    )
+    try await SwiftPMTestProject.build(at: project.scratchDirectory)
+
+    let (uri, positions) = try project.openDocument("MyMacroClient.swift")
+
+    let positionMarkersToBeTested = [
+      (start: "1️⃣", end: "1️⃣"),
+      (start: "2️⃣", end: "2️⃣"),
+      (start: "1️⃣", end: "3️⃣"),
+      (start: "2️⃣", end: "3️⃣"),
+    ]
+
+    for positionMarker in positionMarkersToBeTested {
+      let args = ExpandMacroCommand(
+        positionRange: positions[positionMarker.start]..<positions[positionMarker.end],
+        textDocument: TextDocumentIdentifier(uri)
+      )
+
+      let metadata = SourceKitLSPCommandMetadata(textDocument: TextDocumentIdentifier(uri))
+
+      var command = args.asCommand()
+      command.arguments?.append(metadata.encodeToLSPAny())
+
+      let request = ExecuteCommandRequest(command: command.command, arguments: command.arguments)
+
+      let expectation = self.expectation(description: "Handle Show Document Requests")
+      expectation.expectedFulfillmentCount = 3
+
+      let showDocumentRequestURIs = ThreadSafeBox<[DocumentURI?]>(initialValue: [nil, nil, nil])
+
+      for i in 0...2 {
+        project.testClient.handleSingleRequest { (req: ShowDocumentRequest) in
+          showDocumentRequestURIs.value[i] = req.uri
+          expectation.fulfill()
+          return ShowDocumentResponse(success: true)
+        }
+      }
+
+      let result = try await project.testClient.send(request)
+
+      guard let resultArray: [RefactoringEdit] = Array(fromLSPArray: result ?? .null) else {
+        XCTFail(
+          "Result is not an array. Failed for position range between \(positionMarker.start) and \(positionMarker.end)"
+        )
+        return
+      }
+
+      XCTAssertEqual(
+        resultArray.count,
+        4,
+        "resultArray count is not equal to four. Failed for position range between \(positionMarker.start) and \(positionMarker.end)"
+      )
+
+      XCTAssertEqual(
+        resultArray.map { $0.newText }.sorted(),
+        [
+          "",
+          "@DictionaryStorageProperty",
+          "@DictionaryStorageProperty",
+          "var _storage: [String: Any] = [:]",
+        ].sorted(),
+        "Wrong macro expansion. Failed for position range between \(positionMarker.start) and \(positionMarker.end)"
+      )
+
+      try await fulfillmentOfOrThrow([expectation])
+
+      let urls = try showDocumentRequestURIs.value.map {
+        try XCTUnwrap(
+          $0?.fileURL,
+          "Failed for position range between \(positionMarker.start) and \(positionMarker.end)"
+        )
+      }
+
+      let filesContents = try urls.map {
+        try String(contentsOf: $0, encoding: .utf8)
+      }
+
+      XCTAssertEqual(
+        filesContents.sorted(),
+        [
+          "@DictionaryStorageProperty",
+          "@DictionaryStorageProperty",
+          "var _storage: [String: Any] = [:]",
+        ].sorted(),
+        "Files doesn't contain correct macro expansion. Failed for position range between \(positionMarker.start) and \(positionMarker.end)"
+      )
+
+      XCTAssertEqual(
+        urls.map { $0.lastPathComponent }.sorted(),
+        [
+          "MyMacroClient_L11C3-L11C3.swift",
+          "MyMacroClient_L12C3-L12C3.swift",
+          "MyMacroClient_L13C1-L13C1.swift",
+        ].sorted(),
         "Failed for position range between \(positionMarker.start) and \(positionMarker.end)"
       )
     }