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

Tests/SourceKitLSPTests/ExecuteCommandTests.swift

@@ -252,7 +252,278 @@ 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()
+
+    var serverOptions = SourceKitLSPServer.Options.testDefault
+    serverOptions.experimentalFeatures.insert(.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 VariableDeclSyntax {
+          var isStoredProperty: Bool {
+            if bindings.count != 1 {
+              return false
+            }
+
+            let binding = bindings.first!
+            switch binding.accessorBlock?.accessors {
+            case .none:
+              return true
+
+            case .accessors(let accessors):
+              for accessor in accessors {
+                switch accessor.accessorSpecifier.tokenKind {
+                case .keyword(.willSet), .keyword(.didSet):
+                  // Observers can occur on a stored property.
+                  break
+
+                default:
+                  // Other accessors make it a computed property.
+                  return false
+                }
+              }
+
+              return true
+
+            case .getter:
+              return false
+            }
+          }
+        }
+
+        extension DictionaryStorageMacro: MemberAttributeMacro {
+          public static func expansion(
+            of node: AttributeSyntax,
+            attachedTo declaration: some DeclGroupSyntax,
+            providingAttributesFor member: some DeclSyntaxProtocol,
+            in context: some MacroExpansionContext
+          ) throws -> [AttributeSyntax] {
+            guard let property = member.as(VariableDeclSyntax.self),
+                  property.isStoredProperty
+            else {
+              return []
+            }
+
+            return [
+              AttributeSyntax(
+                leadingTrivia: [.newlines(1), .spaces(2)],
+                attributeName: IdentifierTypeSyntax(
+                  name: .identifier("DictionaryStorageProperty")
+                )
+              )
+            ]
+          }
+        }
+
+        enum CustomError: Error, CustomStringConvertible {
+          case message(String)
+
+          var description: String {
+            switch self {
+            case .message(let text):
+              return text
+            }
+          }
+        }
+
+        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 varDecl = declaration.as(VariableDeclSyntax.self),
+              let binding = varDecl.bindings.first,
+              let identifier = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier,
+              binding.accessorBlock == nil,
+              let type = binding.typeAnnotation?.type
+            else {
+              return []
+            }
+
+            // Ignore the "_storage" variable.
+            if identifier.text == "_storage" {
+              return []
+            }
+
+            guard let defaultValue = binding.initializer?.value else {
+              throw CustomError.message("stored property must have an initializer")
+            }
+
+            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
+        }
+
+        var point = Point()
+        print("Point storage begins as an empty dictionary: \(point)")
+        print("Default value for point.x: \(point.x)")
+        point.y = 17
+        print("Point storage contains only the value we set:  \(point)")
+        """#,
+      ],
+      manifest: SwiftPMTestProject.macroPackageManifest,
+      serverOptions: serverOptions
+    )
+    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 expectations = [
+        self.expectation(description: "Handle Show Document Request #1"),
+        self.expectation(description: "Handle Show Document Request #2"),
+        self.expectation(description: "Handle Show Document Request #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
+          expectations[i].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(expectations)
+
+      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)"
       )
     }