Use Copy option

Author: iMostfa

Sources/SwiftLanguageService/CopyObjCSelector.swift

@@ -17,32 +17,35 @@ import SourceKitD
 import SourceKitLSP
 
 extension SwiftLanguageService {
-  /// Executes the direct SourceKitD request to fetch the Objective-C selector at the cursor position.
+  /// Executes the refactoring-based copy and extracts the selector string without applying edits.
   func copyObjCSelector(
     _ command: CopyObjCSelectorCommand
   ) async throws -> LSPAny {
-    let snapshot = try documentManager.latestSnapshot(command.textDocument.uri)
-    let compileCommand = await self.compileCommand(for: snapshot.uri, fallbackAfterTimeout: true)
-    let offset = snapshot.utf8Offset(of: command.positionRange.lowerBound)
+    let refactorCommand = SemanticRefactorCommand(
+      title: command.title,
+      actionString: command.actionString,
+      positionRange: command.positionRange,
+      textDocument: command.textDocument
+    )
 
-    let keys = self.keys
-    let skreq = sourcekitd.dictionary([
-        keys.offset: offset,
-        keys.sourceFile: snapshot.uri.sourcekitdSourceFile,
-      ])
+    let semanticRefactor = try await self.refactoring(refactorCommand)
 
-    if let primaryFile = snapshot.uri.primaryFile?.pseudoPath {
-      skreq.set(keys.primaryFile, to: primaryFile)
-    }
-    if let compilerArgs = compileCommand?.compilerArgs {
-      skreq.set(keys.compilerArgs, to: compilerArgs as [any SKDRequestValue])
+    guard let edit = semanticRefactor.edit.changes?.first?.value.first else {
+      throw ResponseError.unknown("No selector found at cursor position")
     }
 
-    let dict = try await send(sourcekitdRequest: \.objcSelector, skreq, snapshot: snapshot)
-    if let selectorText: String = dict[keys.text] {
-      return .string(selectorText)
+    let prefix = "// Objective-C Selector: "
+    if let range = edit.newText.range(of: prefix) {
+      let selector = String(edit.newText[range.upperBound...]).trimmingCharacters(in: .whitespacesAndNewlines)
+      if let sourceKitLSPServer {
+        // Send a simple notification; clients like noice can render this nicely.
+        sourceKitLSPServer.sendNotificationToClient(
+          ShowMessageNotification(type: .info, message: "Objective-C selector: \(selector)")
+        )
+      }
+      return .string(selector)
     }
 
-    throw ResponseError.unknown("No Objective-C selector found at cursor position")
+    throw ResponseError.unknown("Could not extract selector from refactoring result")
   }
 }

Sources/SwiftLanguageService/SwiftLanguageService.swift

@@ -965,13 +965,23 @@ extension SwiftLanguageService {
 
     var canInlineMacro = false
 
-    var refactorActions = cursorInfoResponse.refactorActions.compactMap {
-      let lspCommand = $0.asCommand()
+    var refactorActions: [CodeAction] = cursorInfoResponse.refactorActions.compactMap { action in
+      if action.actionString == "source.refactoring.kind.copy.objc.selector" {
+        let copyCommand = CopyObjCSelectorCommand(
+          title: "Copy Objective-C Selector",
+          actionString: action.actionString,
+          positionRange: params.range,
+          textDocument: params.textDocument
+        ).asCommand()
+        return CodeAction(title: "Copy Objective-C Selector", kind: .refactor, command: copyCommand)
+      }
+
+      let lspCommand = action.asCommand()
       if !canInlineMacro {
-        canInlineMacro = $0.actionString == "source.refactoring.kind.inline.macro"
+        canInlineMacro = action.actionString == "source.refactoring.kind.inline.macro"
       }
 
-      return CodeAction(title: $0.title, kind: .refactor, command: lspCommand)
+      return CodeAction(title: action.title, kind: .refactor, command: lspCommand)
     }
 
     if canInlineMacro {
@@ -981,51 +991,9 @@ extension SwiftLanguageService {
       refactorActions.append(CodeAction(title: expandMacroCommand.title, kind: .refactor, command: expandMacroCommand))
     }
 
-    if let copySelectorAction = await makeCopyObjCSelectorAction(
-      range: params.range,
-      textDocument: params.textDocument,
-      snapshot: snapshot
-    ) {
-      refactorActions.append(copySelectorAction)
-    }
-
     return refactorActions
   }
 
-  private func makeCopyObjCSelectorAction(
-    range: Range<Position>,
-    textDocument: LanguageServerProtocol.TextDocumentIdentifier,
-    snapshot: DocumentSnapshot
-  ) async -> CodeAction? {
-    let compileCommand = await self.compileCommand(for: snapshot.uri, fallbackAfterTimeout: true)
-    let offset = snapshot.utf8Offset(of: range.lowerBound)
-
-    let keys = self.keys
-    let primaryFile = snapshot.uri.primaryFile?.pseudoPath
-    let compilerArgs: [any SKDRequestValue] = compileCommand?.compilerArgs ?? []
-    let skreq = sourcekitd.dictionary([
-	      keys.offset: offset,
-	      keys.sourceFile: snapshot.uri.sourcekitdSourceFile,
-	      keys.primaryFile: primaryFile,
-	      keys.compilerArgs: compilerArgs
-	    ])
-
-    do {
-      let dict = try await send(sourcekitdRequest: \.objcSelector, skreq, snapshot: snapshot)
-      if dict[keys.text] as String? != nil {
-        let copyCommand = CopyObjCSelectorCommand(
-          positionRange: range,
-          textDocument: textDocument
-        ).asCommand()
-        return CodeAction(title: "Copy Objective-C Selector", kind: .refactor, command: copyCommand)
-      }
-    } catch {
-      logger.debug("CopyObjCSelector: applicability check failed: \(error.forLogging)")
-    }
-
-    return nil
-  }
-
   func retrieveQuickFixCodeActions(_ params: CodeActionRequest) async throws -> [CodeAction] {
     let snapshot = try await self.latestSnapshot(for: params.textDocument.uri)
     let buildSettings = await self.compileCommand(for: params.textDocument.uri, fallbackAfterTimeout: true)