Address code review and add "Add product to export this target" action

Author: DougGregor

Sources/LanguageServerProtocol/SupportTypes/TextDocumentEdit.swift

@@ -52,31 +52,4 @@ public struct TextDocumentEdit: Hashable, Codable, Sendable {
     self.textDocument = textDocument
     self.edits = edits
   }
-
-  public enum CodingKeys: String, CodingKey {
-    case kind
-    case textDocument
-    case edits
-  }
-
-  public func encode(to encoder: Encoder) throws {
-    var container = encoder.container(keyedBy: CodingKeys.self)
-    try container.encode("textDocumentEdit", forKey: .kind)
-    try container.encode(self.textDocument, forKey: .textDocument)
-    try container.encode(self.edits, forKey: .edits)
-  }
-
-  public init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: CodingKeys.self)
-    let kind = try container.decode(String.self, forKey: .kind)
-    guard kind == "textDocumentEdit" else {
-      throw DecodingError.dataCorruptedError(
-        forKey: .kind,
-        in: container,
-        debugDescription: "Kind of TextDocumentEdit is not 'textDocumentEdit'"
-      )
-    }
-    self.textDocument = try container.decode(OptionalVersionedTextDocumentIdentifier.self, forKey: .textDocument)
-    self.edits = try container.decode([Edit].self, forKey: .edits)
-  }
 }

Sources/SourceKitLSP/Swift/CodeActions/PackageManifestEdits.swift

@@ -19,40 +19,112 @@ import SwiftSyntax
 /// Syntactic code action provider to provide refactoring actions that
 /// edit a package manifest.
 struct PackageManifestEdits: SyntaxCodeActionProvider {
-  static func codeActions(in scope: SyntaxCodeActionScope) -> [CodeAction] {
-    guard
-      let token = scope.firstToken,
-      let call = token.findEnclosingCall()
-    else {
-      return []
+    static func codeActions(in scope: SyntaxCodeActionScope) -> [CodeAction] {
+        guard let token = scope.firstToken,
+              let call = token.findEnclosingCall()
+        else {
+            return []
+        }
+
+        var actions = [CodeAction]()
+
+        // Add test target(s)
+        actions.append(
+            contentsOf: maybeAddTestTargetActions(call: call, in: scope)
+        )
+
+        // Add product(s).
+        actions.append(
+            contentsOf: maybeAddProductActions(call: call, in: scope)
+        )
+
+        return actions
     }
 
-    var actions = [CodeAction]()
+    /// Produce code actions to add test target(s) if we are currently on
+    /// a target for which we know how to create a test.
+    static func maybeAddTestTargetActions(
+        call: FunctionCallExprSyntax,
+        in scope: SyntaxCodeActionScope
+    ) -> [CodeAction] {
+        guard let calledMember = call.findMemberAccessCallee(),
+              targetsThatAllowTests.contains(calledMember),
+              let targetName = call.findStringArgument(label: "name")
+        else {
+            return []
+        }
 
-    // If there's a target name, offer to create a test target derived from it.
-    if let targetName = call.findStringArgument(label: "name") {
         do {
+            // Describe the target we are going to create.
             let target = try TargetDescription(
                 name: "\(targetName)Tests",
                 dependencies: [ .byName(name: targetName, condition: nil) ],
                 type: .test
             )
 
             let edits = try AddTarget.addTarget(target, to: scope.file)
-            actions.append(
-              CodeAction(
-                title: "Add test target for this target",
-                kind: .refactor,
-                edit: edits.asWorkspaceEdit(snapshot: scope.snapshot)
-              )
+            return [
+                CodeAction(
+                    title: "Add test target",
+                    kind: .refactor,
+                    edit: edits.asWorkspaceEdit(snapshot: scope.snapshot)
+                )
+            ]
+        } catch {
+            return []
+        }
+    }
+
+    /// A list of target kinds that allow the creation of tests.
+    static let targetsThatAllowTests: Set<String> = [
+        "executableTarget",
+        "macro",
+        "target",
+    ]
+
+    /// Produce code actions to add a product if we are currently on
+    /// a target for which we can create a product.
+    static func maybeAddProductActions(
+        call: FunctionCallExprSyntax,
+        in scope: SyntaxCodeActionScope
+    ) -> [CodeAction] {
+        guard let calledMember = call.findMemberAccessCallee(),
+              targetsThatAllowProducts.contains(calledMember),
+              let targetName = call.findStringArgument(label: "name")
+        else {
+            return []
+        }
+
+        do {
+            let type: ProductType = calledMember == "executableTarget"
+                ? .executable
+                : .library(.automatic)
+
+            // Describe the target we are going to create.
+            let product = try ProductDescription(
+                name: "\(targetName)",
+                type: type,
+                targets: [ targetName ]
             )
+
+            let edits = try AddProduct.addProduct(product, to: scope.file)
+            return [
+                CodeAction(
+                    title: "Add product to export this target",
+                    kind: .refactor,
+                    edit: edits.asWorkspaceEdit(snapshot: scope.snapshot)
+                )
+            ]
         } catch {
-            // nothing to do
+            return []
         }
     }
 
-    return actions
-  }
+    /// A list of target kinds that allow the creation of tests.
+    static let targetsThatAllowProducts: Set<String> = [
+        "executableTarget",
+        "target",
+    ]
 }
 
 fileprivate extension PackageEditResult {
@@ -163,4 +235,16 @@ fileprivate extension FunctionCallExprSyntax {
 
         return nil
     }
+
+    /// Find the callee when it is a member access expression referencing
+    /// a declaration when a specific name.
+    func findMemberAccessCallee() -> String? {
+        guard let memberAccess = self.calledExpression
+            .as(MemberAccessExprSyntax.self)
+        else {
+            return nil
+        }
+
+        return memberAccess.declName.baseName.text
+    }
 }

Tests/SourceKitLSPTests/CodeActionTests.swift

@@ -290,6 +290,13 @@ final class CodeActionTests: XCTestCase {
     }
 
     XCTAssertTrue(codeActions.contains(expectedCodeAction))
+
+    // Make sure we get one of the swift-syntax refactoring actions.
+    XCTAssertTrue(
+      codeActions.contains { action in
+        return action.title == "Convert string literal to minimal number of \'#\'s"
+      }
+    )
   }
 
   func testSemanticRefactorRangeCodeActionResult() async throws {
@@ -482,4 +489,47 @@ final class CodeActionTests: XCTestCase {
     ]
     XCTAssertEqual(expectedCodeActions, codeActions)
   }
+
+  func testPackageManifestEditingCodeActionResult() async throws {
+    let testClient = try await TestSourceKitLSPClient(capabilities: clientCapabilitiesWithCodeActionSupport())
+    let uri = DocumentURI.for(.swift)
+    let positions = testClient.openDocument(
+      """
+      // swift-tools-version: 5.5
+      let package = Package(
+          name: "packages",
+          targets: [
+              .tar1️⃣get(name: "MyLib"),
+          ]
+      )
+      """,
+      uri: uri
+    )
+
+    let testPosition = positions["1️⃣"]
+    let request = CodeActionRequest(
+      range: Range(testPosition),
+      context: .init(),
+      textDocument: TextDocumentIdentifier(uri)
+    )
+    let result = try await testClient.send(request)
+
+    guard case .codeActions(let codeActions) = result else {
+      XCTFail("Expected code actions")
+      return
+    }
+
+    // Make sure we get the expected package manifest editing actions.
+    XCTAssertTrue(
+      codeActions.contains { action in
+        return action.title == "Add test target"
+      }
+    )
+
+    XCTAssertTrue(
+      codeActions.contains { action in
+        return action.title == "Add product to export this target"
+      }
+    )
+  }
 }