[SwiftRefactor] PackageManifest: Remove handling of auxiliary files

This is now handled by the Swift Package Manager itself and refactoring
actions are only responsible for package manifest updates.

Author: xedin

Sources/SwiftRefactor/PackageManifest/AddPackageTarget.swift

@@ -86,44 +86,10 @@ public struct AddPackageTarget: ManifestEditRefactoringProvider {
       newElement: target.asSyntax()
     )
 
-    let outerDirectory: String?
-    switch target.type {
-    case .binary, .plugin, .system: outerDirectory = nil
-    case .executable, .library, .macro: outerDirectory = "Sources"
-    case .test: outerDirectory = "Tests"
-    }
-
-    guard let outerDirectory else {
-      return PackageEdit(
-        manifestEdits: [
-          .replace(packageCall, with: newPackageCall.description)
-        ]
-      )
-    }
-
-    let outerPath = outerDirectory
-
-    /// The set of auxiliary files this refactoring will create.
-    var auxiliaryFiles: AuxiliaryFiles = []
-
-    // Add the primary source file. Every target type has this.
-    addPrimarySourceFile(
-      outerPath: outerPath,
-      target: target,
-      in: context,
-      to: &auxiliaryFiles
-    )
-
     // Perform any other actions that are needed for this target type.
     var extraManifestEdits: [SourceEdit] = []
     switch target.type {
     case .macro:
-      addProvidedMacrosSourceFile(
-        outerPath: outerPath,
-        target: target,
-        to: &auxiliaryFiles
-      )
-
       if !manifest.containsStringLiteral("swift-syntax") {
         newPackageCall =
           try AddPackageDependency
@@ -156,157 +122,9 @@ public struct AddPackageTarget: ManifestEditRefactoringProvider {
     return PackageEdit(
       manifestEdits: [
         .replace(packageCall, with: newPackageCall.description)
-      ] + extraManifestEdits,
-      auxiliaryFiles: auxiliaryFiles
-    )
-  }
-
-  /// Add the primary source file for a target to the list of auxiliary
-  /// source files.
-  fileprivate static func addPrimarySourceFile(
-    outerPath: String,
-    target: PackageTarget,
-    in context: Context,
-    to auxiliaryFiles: inout AuxiliaryFiles
-  ) {
-    let sourceFilePath = "\(outerPath)/\(target.name)/\(target.name).swift"
-
-    // Introduce imports for each of the dependencies that were specified.
-    var importModuleNames = target.dependencies.map {
-      $0.name
-    }
-
-    // Add appropriate test module dependencies.
-    if target.type == .test {
-      switch context.testHarness {
-      case .none:
-        break
-
-      case .xctest:
-        importModuleNames.append("XCTest")
-
-      case .swiftTesting:
-        importModuleNames.append("Testing")
-      }
-    }
-
-    let importDecls = importModuleNames.lazy.sorted().map { name in
-      DeclSyntax("import \(raw: name)\n")
-    }
-
-    let imports = CodeBlockItemListSyntax {
-      for importDecl in importDecls {
-        importDecl
-      }
-    }
-
-    let sourceFileText: SourceFileSyntax
-    switch target.type {
-    case .binary, .plugin, .system:
-      fatalError("should have exited above")
-
-    case .macro:
-      sourceFileText = """
-        \(imports)
-        struct \(raw: target.sanitizedName): Macro {
-            /// TODO: Implement one or more of the protocols that inherit
-            /// from Macro. The appropriate macro protocol is determined
-            /// by the "macro" declaration that \(raw: target.sanitizedName) implements.
-            /// Examples include:
-            ///     @freestanding(expression) macro --> ExpressionMacro
-            ///     @attached(member) macro         --> MemberMacro
-        }
-        """
-
-    case .test:
-      switch context.testHarness {
-      case .none:
-        sourceFileText = """
-          \(imports)
-          // Test code here
-          """
-
-      case .xctest:
-        sourceFileText = """
-          \(imports)
-          class \(raw: target.sanitizedName)Tests: XCTestCase {
-              func test\(raw: target.sanitizedName)() {
-                  XCTAssertEqual(42, 17 + 25)
-              }
-          }
-          """
-
-      case .swiftTesting:
-        sourceFileText = """
-          \(imports)
-          @Suite
-          struct \(raw: target.sanitizedName)Tests {
-              @Test("\(raw: target.sanitizedName) tests")
-              func example() {
-                  #expect(42 == 17 + 25)
-              }
-          }
-          """
-      }
-
-    case .library:
-      sourceFileText = """
-        \(imports)
-        """
-
-    case .executable:
-      sourceFileText = """
-        \(imports)
-        @main
-        struct \(raw: target.sanitizedName)Main {
-            static func main() {
-                print("Hello, world")
-            }
-        }
-        """
-    }
-
-    auxiliaryFiles.addSourceFile(
-      path: sourceFilePath,
-      sourceCode: sourceFileText
+      ] + extraManifestEdits
     )
   }
-
-  /// Add a file that introduces the main entrypoint and provided macros
-  /// for a macro target.
-  fileprivate static func addProvidedMacrosSourceFile(
-    outerPath: String,
-    target: PackageTarget,
-    to auxiliaryFiles: inout AuxiliaryFiles
-  ) {
-    auxiliaryFiles.addSourceFile(
-      path: "\(outerPath)/\(target.name)/ProvidedMacros.swift",
-      sourceCode: """
-        import SwiftCompilerPlugin
-
-        @main
-        struct \(raw: target.sanitizedName)Macros: CompilerPlugin {
-            let providingMacros: [Macro.Type] = [
-                \(raw: target.sanitizedName).self,
-            ]
-        }
-        """
-    )
-  }
-}
-
-/// The array of auxiliary files that can be added by a package editing
-/// operation.
-private typealias AuxiliaryFiles = [(String, SourceFileSyntax)]
-
-fileprivate extension AuxiliaryFiles {
-  /// Add a source file to the list of auxiliary files.
-  mutating func addSourceFile(
-    path: String,
-    sourceCode: SourceFileSyntax
-  ) {
-    self.append((path, sourceCode))
-  }
 }
 
 /// The set of dependencies we need to introduce to a newly-created macro

Sources/SwiftRefactor/PackageManifest/PackageEdit.swift

@@ -18,7 +18,4 @@ import SwiftSyntax
 public struct PackageEdit {
   /// Edits to perform to the package manifest.
   public var manifestEdits: [SourceEdit] = []
-
-  /// Auxiliary files to write.
-  public var auxiliaryFiles: [(relativePath: String, contents: SourceFileSyntax)] = []
 }

Tests/SwiftRefactorTest/ManifestEditTests.swift

@@ -442,11 +442,6 @@ final class ManifestEditTests: XCTestCase {
             ]
         )
         """,
-      expectedAuxiliarySources: [
-        "Sources/MyLib/MyLib.swift": """
-
-        """
-      ],
       provider: AddPackageTarget.self,
       context: .init(
         target: PackageTarget(name: "MyLib")
@@ -478,14 +473,6 @@ final class ManifestEditTests: XCTestCase {
             ]
         )
         """,
-      expectedAuxiliarySources: [
-        "Sources/MyLib/MyLib.swift": """
-        import OtherLib
-        import SwiftSyntax
-        import TargetLib
-
-        """
-      ],
       provider: AddPackageTarget.self,
       context: .init(
         target: PackageTarget(
@@ -530,20 +517,6 @@ final class ManifestEditTests: XCTestCase {
             ]
         )
         """,
-      expectedAuxiliarySources: [
-        "Sources/MyProgram target-name/MyProgram target-name.swift": """
-        import MyLib
-        import SwiftSyntax
-        import TargetLib
-
-        @main
-        struct MyProgram_target_nameMain {
-            static func main() {
-                print("Hello, world")
-            }
-        }
-        """
-      ],
       provider: AddPackageTarget.self,
       context: .init(
         target: PackageTarget(
@@ -590,31 +563,6 @@ final class ManifestEditTests: XCTestCase {
             ]
         )
         """,
-      expectedAuxiliarySources: [
-        "Sources/MyMacro target-name/MyMacro target-name.swift": """
-        import SwiftCompilerPlugin
-        import SwiftSyntaxMacros
-
-        struct MyMacro_target_name: Macro {
-            /// TODO: Implement one or more of the protocols that inherit
-            /// from Macro. The appropriate macro protocol is determined
-            /// by the "macro" declaration that MyMacro_target_name implements.
-            /// Examples include:
-            ///     @freestanding(expression) macro --> ExpressionMacro
-            ///     @attached(member) macro         --> MemberMacro
-        }
-        """,
-        "Sources/MyMacro target-name/ProvidedMacros.swift": """
-        import SwiftCompilerPlugin
-
-        @main
-        struct MyMacro_target_nameMacros: CompilerPlugin {
-            let providingMacros: [Macro.Type] = [
-                MyMacro_target_name.self,
-            ]
-        }
-        """,
-      ],
       provider: AddPackageTarget.self,
       context: .init(
         target: PackageTarget(
@@ -642,19 +590,6 @@ final class ManifestEditTests: XCTestCase {
             ]
         )
         """,
-      expectedAuxiliarySources: [
-        "Tests/MyTest target-name/MyTest target-name.swift": """
-        import Testing
-
-        @Suite
-        struct MyTest_target_nameTests {
-            @Test("MyTest_target_name tests")
-            func example() {
-                #expect(42 == 17 + 25)
-            }
-        }
-        """
-      ],
       provider: AddPackageTarget.self,
       context: .init(
         target: PackageTarget(
@@ -1033,12 +968,10 @@ final class ManifestEditTests: XCTestCase {
 }
 
 /// Assert that applying the given edit/refactor operation to the manifest
-/// produces the expected manifest source file and the expected auxiliary
-/// files.
+/// produces the expected manifest source file.
 func assertManifestRefactor<Provider: ManifestEditRefactoringProvider>(
   _ originalManifest: SourceFileSyntax,
   expectedManifest: SourceFileSyntax,
-  expectedAuxiliarySources: [String: SourceFileSyntax] = [:],
   provider: Provider.Type,
   context: Provider.Context,
   file: StaticString = #filePath,
@@ -1047,7 +980,6 @@ func assertManifestRefactor<Provider: ManifestEditRefactoringProvider>(
   return try assertManifestRefactor(
     originalManifest,
     expectedManifest: expectedManifest,
-    expectedAuxiliarySources: expectedAuxiliarySources,
     file: file,
     line: line
   ) { (manifest) in
@@ -1056,12 +988,10 @@ func assertManifestRefactor<Provider: ManifestEditRefactoringProvider>(
 }
 
 /// Assert that applying the given edit/refactor operation to the manifest
-/// produces the expected manifest source file and the expected auxiliary
-/// files.
+/// produces the expected manifest source file.
 func assertManifestRefactor(
   _ originalManifest: SourceFileSyntax,
   expectedManifest: SourceFileSyntax,
-  expectedAuxiliarySources: [String: SourceFileSyntax] = [:],
   file: StaticString = #filePath,
   line: UInt = #line,
   operation: (SourceFileSyntax) throws -> PackageEdit
@@ -1079,25 +1009,4 @@ func assertManifestRefactor(
     file: file,
     line: line
   )
-
-  // Check all of the auxiliary sources.
-  for (auxSourcePath, auxSourceSyntax) in edits.auxiliaryFiles {
-    guard let expectedSyntax = expectedAuxiliarySources[auxSourcePath] else {
-      XCTFail("unexpected auxiliary source file '\(auxSourcePath)' in \(expectedAuxiliarySources)")
-      return
-    }
-
-    assertStringsEqualWithDiff(
-      auxSourceSyntax.description,
-      expectedSyntax.description,
-      file: file,
-      line: line
-    )
-  }
-
-  XCTAssertEqual(
-    edits.auxiliaryFiles.count,
-    expectedAuxiliarySources.count,
-    "didn't get all of the auxiliary files we expected"
-  )
 }