Fix LocalFileSystem.move() to not follow symlinks when checking source existence

The move() method was using exists(sourcePath) which follows symlinks by default.
This caused failures when moving a symlink whose target had already been moved,
because it would try to follow the symlink to validate the target exists.

Now uses exists(sourcePath, followSymlink: false) to check if the symlink itself
exists, allowing symlinks to be moved even if their targets have been relocated.

This fixes an issue where extracting package archives with symlinks could fail
if files were moved in alphabetical order and a target file was moved before
its symlink.

Added test testMoveSymlinkWithMovedTarget() to verify this behavior.

Author: fortmarek

Sources/TSCBasic/FileSystem.swift

@@ -735,7 +735,9 @@ private struct LocalFileSystem: FileSystem {
     }
 
     func move(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws {
-        guard exists(sourcePath) else { throw FileSystemError(.noEntry, sourcePath) }
+        // Don't follow symlinks when checking if source exists - we want to check if the symlink itself exists,
+        // not whether its target exists. This allows moving symlinks even if their targets have been moved.
+        guard exists(sourcePath, followSymlink: false) else { throw FileSystemError(.noEntry, sourcePath) }
         guard !exists(destinationPath)
         else { throw FileSystemError(.alreadyExistsAtDestination, destinationPath) }
         do {

Tests/TSCBasicTests/FileSystemTests.swift

@@ -511,6 +511,49 @@ class FileSystemTests: XCTestCase {
         }
     }
 
+    func testMoveSymlinkWithMovedTarget() throws {
+        let fs = TSCBasic.localFileSystem
+
+        try testWithTemporaryDirectory { tmpdir in
+            let sourceDir = tmpdir.appending(component: "source")
+            let destDir = tmpdir.appending(component: "dest")
+
+            try fs.createDirectory(sourceDir)
+            try fs.createDirectory(destDir)
+
+            // Create a regular file that will be the symlink target
+            let targetFile = sourceDir.appending(component: "AFile.swift")
+            try fs.writeFileContents(targetFile, bytes: "// Target file content\n")
+
+            // Create a relative symlink pointing to the target file
+            let symlink = sourceDir.appending(component: "ZLinkToFile.swift")
+            try fs.createSymbolicLink(symlink, pointingAt: targetFile, relative: true)
+
+            XCTAssertTrue(fs.isSymlink(symlink))
+            XCTAssertTrue(fs.exists(symlink))
+
+            // Move the target file first (alphabetically it comes before the symlink)
+            let movedTarget = destDir.appending(component: "AFile.swift")
+            try fs.move(from: targetFile, to: movedTarget)
+
+            // Now try to move the symlink - this should succeed even though its target has moved
+            // The symlink's target will be broken after the move, but the symlink itself should be moveable
+            let movedSymlink = destDir.appending(component: "ZLinkToFile.swift")
+            XCTAssertNoThrow(try fs.move(from: symlink, to: movedSymlink))
+
+            // Verify the symlink was moved
+            XCTAssertFalse(fs.exists(symlink, followSymlink: false))
+            XCTAssertTrue(fs.exists(movedSymlink, followSymlink: false))
+            XCTAssertTrue(fs.isSymlink(movedSymlink))
+
+            // Verify the symlink now points correctly (both files are in the same directory again)
+            XCTAssertTrue(fs.exists(movedSymlink, followSymlink: true))
+            let symlinkContent = try fs.readFileContents(movedSymlink)
+            let targetContent = try fs.readFileContents(movedTarget)
+            XCTAssertEqual(symlinkContent, targetContent)
+        }
+    }
+
     // MARK: InMemoryFileSystem Tests
 
     func testInMemoryBasics() throws {