Update SwiftPM for FileSystemError changes in TSC

Author: MaxDesiatov

Sources/SPMTestSupport/InMemoryGitRepository.swift

@@ -211,7 +211,7 @@ extension InMemoryGitRepository: FileSystem {
     }
 
     public func changeCurrentWorkingDirectory(to path: AbsolutePath) throws {
-        throw FileSystemError.unsupported
+        throw FileSystemError(.unsupported, path)
     }
 
     public var homeDirectory: AbsolutePath {
@@ -231,7 +231,7 @@ extension InMemoryGitRepository: FileSystem {
     }
 
     public func createSymbolicLink(_ path: AbsolutePath, pointingAt destination: AbsolutePath, relative: Bool) throws {
-        throw FileSystemError.unsupported
+        throw FileSystemError(.unsupported, path)
     }
 
     public func readFileContents(_ path: AbsolutePath) throws -> ByteString {

Sources/SourceControl/GitRepository.swift

@@ -638,13 +638,15 @@ private class GitFileSystemView: FileSystem {
         // Walk the components resolving the tree (starting with a synthetic
         // root entry).
         var current: Tree.Entry = Tree.Entry(hash: root, type: .tree, name: "/")
+        var currentPath = AbsolutePath.root
         for component in path.components.dropFirst(1) {
             // Skip the root pseudo-component.
             if component == "/" { continue }
 
+            currentPath = currentPath.appending(component: component)
             // We have a component to resolve, so the current entry must be a tree.
             guard current.type == .tree else {
-                throw FileSystemError.notDirectory
+                throw FileSystemError(.notDirectory, currentPath)
             }
 
             // Fetch the tree.
@@ -733,21 +735,21 @@ private class GitFileSystemView: FileSystem {
 
     func getDirectoryContents(_ path: AbsolutePath) throws -> [String] {
         guard let entry = try getEntry(path) else {
-            throw FileSystemError.noEntry
+            throw FileSystemError(.noEntry, path)
         }
         guard entry.type == .tree else {
-            throw FileSystemError.notDirectory
+            throw FileSystemError(.notDirectory, path)
         }
 
         return try getTree(entry.hash).contents.map({ $0.name })
     }
 
     func readFileContents(_ path: AbsolutePath) throws -> ByteString {
         guard let entry = try getEntry(path) else {
-            throw FileSystemError.noEntry
+            throw FileSystemError(.noEntry, path)
         }
         guard entry.type != .tree else {
-            throw FileSystemError.isDirectory
+            throw FileSystemError(.isDirectory, path)
         }
         guard entry.type != .symlink else {
             fatalError("FIXME: not implemented")
@@ -766,27 +768,27 @@ private class GitFileSystemView: FileSystem {
     }
 
     func createDirectory(_ path: AbsolutePath) throws {
-        throw FileSystemError.unsupported
+        throw FileSystemError(.unsupported, path)
     }
 
     func createDirectory(_ path: AbsolutePath, recursive: Bool) throws {
-        throw FileSystemError.unsupported
+        throw FileSystemError(.unsupported, path)
     }
 
     func createSymbolicLink(_ path: AbsolutePath, pointingAt destination: AbsolutePath, relative: Bool) throws {
-        throw FileSystemError.unsupported
+        throw FileSystemError(.unsupported, path)
     }
 
     func writeFileContents(_ path: AbsolutePath, bytes: ByteString) throws {
-        throw FileSystemError.unsupported
+        throw FileSystemError(.unsupported, path)
     }
 
     func removeFileTree(_ path: AbsolutePath) throws {
-        throw FileSystemError.unsupported
+        throw FileSystemError(.unsupported, path)
     }
 
     func chmod(_ mode: FileMode, path: AbsolutePath, options: Set<FileMode.Option>) throws {
-        throw FileSystemError.unsupported
+        throw FileSystemError(.unsupported, path)
     }
 
     func copy(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws {

Sources/Workspace/Diagnostics.swift

@@ -158,23 +158,44 @@ extension Diagnostic.Message {
 extension FileSystemError: CustomStringConvertible {
 
     public var description: String {
-        switch self {
+        guard let path = path else {
+            switch self.kind {
+            case .invalidAccess:
+                return "invalid access"
+            case .ioError:
+                return "encountered I/O error"
+            case .isDirectory:
+                return "is a directory"
+            case .noEntry:
+                return "doesn't exist in file system"
+            case .notDirectory:
+                return "is not a directory"
+            case .unsupported:
+                return "unsupported operation"
+            case .unknownOSError:
+                return "unknown system error"
+            case .alreadyExistsAtDestination:
+                return "already exists in file system"
+            }
+        }
+
+        switch self.kind {
         case .invalidAccess:
-            return "invalid access"
+            return "invalid access to \(path)"
         case .ioError:
-            return "encountered I/O error"
+            return "encountered an I/O error while reading \(path)"
         case .isDirectory:
-            return "is a directory"
+            return "\(path) is a directory"
         case .noEntry:
-            return "doesn't exist in file system"
+            return "\(path) doesn't exist in file system"
         case .notDirectory:
-            return "is not a directory"
+            return "\(path) is not a directory"
         case .unsupported:
-            return "unsupported operation"
+            return "unsupported operation on \(path)"
         case .unknownOSError:
-            return "unknown system error"
+            return "unknown system error while operating on \(path)"
         case .alreadyExistsAtDestination:
-            return "already exists in file system"
+            return "\(path) already exists in file system"
         }
     }
 }

Tests/SourceControlTests/GitRepositoryTests.swift

@@ -208,31 +208,36 @@ class GitRepositoryTests: XCTestCase {
             XCTAssert(view.isExecutableFile(AbsolutePath("/test-file-3.sh")))
 
             // Check read of a directory.
+            let subdirPath = AbsolutePath("/subdir")
             XCTAssertEqual(try view.getDirectoryContents(AbsolutePath("/")).sorted(), ["file.swift", "subdir", "test-file-1.txt", "test-file-3.sh"])
-            XCTAssertEqual(try view.getDirectoryContents(AbsolutePath("/subdir")).sorted(), ["test-file-2.txt"])
-            XCTAssertThrows(FileSystemError.isDirectory) {
-                _ = try view.readFileContents(AbsolutePath("/subdir"))
+            XCTAssertEqual(try view.getDirectoryContents(subdirPath).sorted(), ["test-file-2.txt"])
+            XCTAssertThrows(FileSystemError(.isDirectory, subdirPath)) {
+                _ = try view.readFileContents(subdirPath)
             }
 
             // Check read versus root.
-            XCTAssertThrows(FileSystemError.isDirectory) {
-                _ = try view.readFileContents(AbsolutePath("/"))
+            XCTAssertThrows(FileSystemError(.isDirectory, .root)) {
+                _ = try view.readFileContents(.root)
             }
 
             // Check read through a non-directory.
-            XCTAssertThrows(FileSystemError.notDirectory) {
-                _ = try view.getDirectoryContents(AbsolutePath("/test-file-1.txt"))
+            let notDirectoryPath1 = AbsolutePath("/test-file-1.txt")
+            XCTAssertThrows(FileSystemError(.notDirectory, notDirectoryPath1)) {
+                _ = try view.getDirectoryContents(notDirectoryPath1)
             }
-            XCTAssertThrows(FileSystemError.notDirectory) {
-                _ = try view.readFileContents(AbsolutePath("/test-file-1.txt/thing"))
+            let notDirectoryPath2 = AbsolutePath("/test-file-1.txt/thing")
+            XCTAssertThrows(FileSystemError(.notDirectory, notDirectoryPath2)) {
+                _ = try view.readFileContents(notDirectoryPath2)
             }
 
             // Check read/write into a missing directory.
-            XCTAssertThrows(FileSystemError.noEntry) {
-                _ = try view.getDirectoryContents(AbsolutePath("/does-not-exist"))
+            let noEntryPath1 = AbsolutePath("/does-not-exist")
+            XCTAssertThrows(FileSystemError(.noEntry, noEntryPath1)) {
+                _ = try view.getDirectoryContents(noEntryPath1)
             }
-            XCTAssertThrows(FileSystemError.noEntry) {
-                _ = try view.readFileContents(AbsolutePath("/does/not/exist"))
+            let noEntryPath2 = AbsolutePath("/does/not/exist")
+            XCTAssertThrows(FileSystemError(.noEntry, noEntryPath2)) {
+                _ = try view.readFileContents(noEntryPath2)
             }
 
             // Check read of a file.

Tests/WorkspaceTests/WorkspaceTests.swift

@@ -3030,7 +3030,7 @@ final class WorkspaceTests: XCTestCase {
                 result.check(targets: "Foo")
             }
             DiagnosticsEngineTester(diagnostics) { result in
-                result.check(diagnostic: .contains("the package at '/tmp/ws/pkgs/Bar' cannot be accessed (doesn't exist in file system"), behavior: .error)
+                result.check(diagnostic: .contains("the package at '/tmp/ws/pkgs/Bar' cannot be accessed (/tmp/ws/pkgs/Bar doesn't exist in file system"), behavior: .error)
             }
         }
     }